Update examples to promote the use of a main coroutine

Author: Vincent Michel

examples/asyncio_deferred.py

@@ -13,7 +13,5 @@ async def steps(x):
 
 
 loop = asyncio.get_event_loop()
-coro = steps(5)
-loop.run_until_complete(coro)
+loop.run_until_complete(steps(5))
 loop.close()
-

examples/create_task.py

@@ -1,14 +1,17 @@
 import asyncio
 
+
 async def say(what, when):
     await asyncio.sleep(when)
     print(what)
 
 
-loop = asyncio.get_event_loop()
+async def schedule():
+    asyncio.ensure_future(say('first hello', 2))
+    asyncio.ensure_future(say('second hello', 1))
 
-loop.create_task(say('first hello', 2))
-loop.create_task(say('second hello', 1))
 
+loop = asyncio.get_event_loop()
+loop.run_until_complete(schedule())
 loop.run_forever()
 loop.close()

examples/hello_clock.py

@@ -2,7 +2,6 @@
 
 
 async def print_every_second():
-    "Print seconds"
     while True:
         for i in range(60):
             print(i, 's')
@@ -15,9 +14,12 @@ async def print_every_minute():
         print(i, 'minute')
 
 
+async def main():
+    coro_second = print_every_second()
+    coro_minute = print_every_minute()
+    await asyncio.gather(coro_second, coro_minute)
+
+
 loop = asyncio.get_event_loop()
-loop.run_until_complete(
-    asyncio.gather(print_every_second(),
-                   print_every_minute())
-)
+loop.run_until_complete(main())
 loop.close()

examples/hello_world.py

@@ -1,9 +1,11 @@
 import asyncio
 
+
 async def say(what, when):
     await asyncio.sleep(when)
     print(what)
 
+
 loop = asyncio.get_event_loop()
 loop.run_until_complete(say('hello world', 1))
 loop.close()

examples/http_client.py

@@ -1,15 +1,20 @@
 import asyncio
 import aiohttp
 
+
 async def fetch_page(session, url):
     with aiohttp.Timeout(10):
         async with session.get(url) as response:
             assert response.status == 200
             return await response.read()
 
+
+async def main():
+    with aiohttp.ClientSession() as session:
+        content = await fetch_page(session, 'http://python.org')
+        print(content.decode())
+
+
 loop = asyncio.get_event_loop()
-with aiohttp.ClientSession() as session:
-    content = loop.run_until_complete(
-        fetch_page(session, 'http://python.org'))
-    print(content)
+loop.run_until_complete(main())
 loop.close()

examples/loop_stop.py

@@ -1,20 +1,24 @@
 import asyncio
 
+
 async def say(what, when):
     await asyncio.sleep(when)
     print(what)
 
-async def stop_after(loop, when):
+
+async def stop_after(when):
     await asyncio.sleep(when)
-    loop.stop()
+    asyncio.get_event_loop().stop()
 
 
-loop = asyncio.get_event_loop()
+async def schedule():
+    asyncio.ensure_future(say('first hello', 2))
+    asyncio.ensure_future(say('second hello', 1))
+    asyncio.ensure_future(say('third hello', 4))
+    asyncio.ensure_future(stop_after(3))
 
-loop.create_task(say('first hello', 2))
-loop.create_task(say('second hello', 1))
-loop.create_task(say('third hello', 4))
-loop.create_task(stop_after(loop, 3))
 
+loop = asyncio.get_event_loop()
+loop.run_until_complete(schedule())
 loop.run_forever()
 loop.close()

examples/producer_consumer.py

@@ -3,12 +3,13 @@
 
 
 async def produce(queue, n):
-    for x in range(1, n + 1):
-        # produce an item
+    # produce n items
+    for x in range(1, n+1):
+
+        # produce an item (simulate i/o operation using sleep)
         print('producing {}/{}'.format(x, n))
-        # simulate i/o operation using sleep
-        await asyncio.sleep(random.random())
-        item = str(x)
+        item = await asyncio.sleep(random.random(), result=x)
+
         # put the item in the queue
         await queue.put(item)
 
@@ -20,19 +21,23 @@ async def consume(queue):
     while True:
         # wait for an item from the producer
         item = await queue.get()
+
+        # the producer emits None to indicate that it is done
         if item is None:
-            # the producer emits None to indicate that it is done
             break
 
-        # process the item
+        # process the item (simulate i/o operation using sleep)
         print('consuming item {}...'.format(item))
-        # simulate i/o operation using sleep
         await asyncio.sleep(random.random())
 
 
+async def main():
+    queue = asyncio.Queue()
+    producer_coro = produce(queue, 10)
+    consumer_coro = consume(queue)
+    await asyncio.gather(producer_coro, consumer_coro)
+
+
 loop = asyncio.get_event_loop()
-queue = asyncio.Queue()
-producer_coro = produce(queue, 10)
-consumer_coro = consume(queue)
-loop.run_until_complete(asyncio.gather(producer_coro, consumer_coro))
+loop.run_until_complete(main())
 loop.close()

examples/producer_consumer_join.py

@@ -17,28 +17,26 @@ async def consume(queue):
     while True:
         # wait for an item from the producer
         item = await queue.get()
-
         # process the item
         print('consuming {}...'.format(item))
         # simulate i/o operation using sleep
         await asyncio.sleep(random.random())
-
         # Notify the queue that the item has been processed
         queue.task_done()
 
 
-async def run(n):
+async def main():
     queue = asyncio.Queue()
     # schedule the consumer
     consumer = asyncio.ensure_future(consume(queue))
     # run the producer and wait for completion
-    await produce(queue, n)
+    await produce(queue, 10)
     # wait until the consumer has processed all items
     await queue.join()
     # the consumer is still awaiting for an item, cancel it
     consumer.cancel()
 
 
 loop = asyncio.get_event_loop()
-loop.run_until_complete(run(10))
+loop.run_until_complete(main())
 loop.close()

examples/run_in_thread.py

@@ -1,7 +1,8 @@
 import asyncio
 
+
 def compute_pi(digits):
-    # implementation
+    # CPU-intensive computation
     return 3.14
 
 

examples/subprocess_command.py

@@ -5,19 +5,27 @@ async def run_command(*args):
     # Create subprocess
     process = await asyncio.create_subprocess_exec(
         *args,
-        # stdout must a pipe to be accessible as process.stdout
+        # stdout must be piped to be accessible as process.stdout
         stdout=asyncio.subprocess.PIPE)
+
     # Wait for the subprocess to finish
     stdout, stderr = await process.communicate()
+
     # Return stdout
     return stdout.decode().strip()
 
 
+async def main():
+    # Gather uname and date commands
+    commands = asyncio.gather(run_command('uname'), run_command('date'))
+
+    # Wait for the results
+    uname, date = await commands
+
+    # Print a report
+    print('uname: {}, date: {}'.format(uname, date))
+
+
 loop = asyncio.get_event_loop()
-# Gather uname and date commands
-commands = asyncio.gather(run_command('uname'), run_command('date'))
-# Run the commands
-uname, date = loop.run_until_complete(commands)
-# Print a report
-print('uname: {}, date: {}'.format(uname, date))
+loop.run_until_complete(main())
 loop.close()

examples/subprocess_echo.py

@@ -9,13 +9,16 @@ async def echo(msg):
         stdin=asyncio.subprocess.PIPE,
         # stdout must a pipe to be accessible as process.stdout
         stdout=asyncio.subprocess.PIPE)
+
     # Write message
     print('Writing {!r} ...'.format(msg))
     process.stdin.write(msg.encode() + b'\n')
+
     # Read reply
     data = await process.stdout.readline()
     reply = data.decode().strip()
     print('Received {!r}'.format(reply))
+
     # Stop the subprocess
     process.terminate()
     code = await process.wait()

examples/tcp_echo_client.py

@@ -1,7 +1,7 @@
 import asyncio
 
 
-async def tcp_echo_client(message, loop):
+async def tcp_echo_client(message):
     reader, writer = await asyncio.open_connection('127.0.0.1', 8888)
 
     print('Send: %r' % message)
@@ -14,7 +14,11 @@ async def tcp_echo_client(message, loop):
     writer.close()
 
 
-message = 'Hello World!'
+async def main():
+    message = 'Hello World!'
+    await tcp_echo_client(message)
+
+
 loop = asyncio.get_event_loop()
-loop.run_until_complete(tcp_echo_client(message, loop))
+loop.run_until_complete(main())
 loop.close()

examples/tcp_echo_server.py

@@ -1,5 +1,6 @@
 import asyncio
 
+
 async def handle_echo(reader, writer):
     data = await reader.read(100)
     message = data.decode()
@@ -13,18 +14,28 @@ async def handle_echo(reader, writer):
     print("Close the client socket")
     writer.close()
 
+
+async def start_serving():
+    server = await asyncio.start_server(handle_echo, '127.0.0.1', 8888)
+    print('Serving on {}'.format(server.sockets[0].getsockname()))
+    return stop_serving(server)
+
+
+async def stop_serving(server):
+    server.close()
+    await server.wait_closed()
+
+
+# Start the server
 loop = asyncio.get_event_loop()
-coro = asyncio.start_server(handle_echo, '127.0.0.1', 8888)
-server = loop.run_until_complete(coro)
+stop_coro = loop.run_until_complete(start_serving())
 
 # Serve requests until Ctrl+C is pressed
-print('Serving on {}'.format(server.sockets[0].getsockname()))
 try:
     loop.run_forever()
 except KeyboardInterrupt:
     pass
 
 # Close the server
-server.close()
-loop.run_until_complete(server.wait_closed())
+loop.run_until_complete(stop_coro)
 loop.close()