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()