[Python-Dev] async/await in Python; v2 (original) (raw)

Tue Apr 21 19:26:48 CEST 2015

 async def read_data(db):
     pass
 async def read_data(db):
     data = await db.fetch('SELECT ...')
     ...
 class AsyncContextManager:
     async def __aenter__(self):
         await log('entering context')

     async def __aexit__(self, exc_type, exc, tb):
         await log('exiting context')
 async with EXPR as VAR:
     BLOCK
 mgr = (EXPR)
 aexit = type(mgr).__aexit__
 aenter = type(mgr).__aenter__(mgr)
 exc = True

 try:
     try:
         VAR = await aenter
         BLOCK
     except:
         exc = False
         exit_res = await aexit(mgr, *sys.exc_info())
         if not exit_res:
             raise

 finally:
     if exc:
         await aexit(mgr, None, None, None)
 async def commit(session, data):
     ...

     async with session.transaction():
         ...
         await session.update(data)
         ...
 async with lock:
     ...
 with (yield from lock):
     ...
 class AsyncIterable:
     async def __aiter__(self):
         return self

     async def __anext__(self):
         data = await self.fetch_data()
         if data:
             return data
         else:
             raise StopAsyncIteration

     async def fetch_data(self):
         ...
 async for TARGET in ITER:
     BLOCK
 else:
     BLOCK2
 iter = (ITER)
 iter = await type(iter).__aiter__(iter)
 running = True
 while running:
     try:
         TARGET = await type(iter).__anext__(iter)
     except StopAsyncIteration:
         running = False
     else:
         BLOCK
 else:
     BLOCK2
 async for data in cursor:
     ...
 class Cursor:
     def __init__(self):
         self.buffer = collections.deque()

     def _prefetch(self):
         ...

     async def __aiter__(self):
         return self

     async def __anext__(self):
         if not self.buffer:
             self.buffer = await self._prefetch()
             if not self.buffer:
                 raise StopAsyncIteration
         return self.buffer.popleft()
 async for row in Cursor():
     print(row)
 i = await Cursor().__aiter__()
 while True:
     try:
         row = await i.__anext__()
     except StopAsyncIteration:
         break
     else:
         print(row)
     async def __aiter__(self):
         return self

     async def __anext__(self):
         try:
             value = next(self._it)
         except StopIteration:
             raise StopAsyncIteration
         return value

 async for item in AsyncIteratorWrapper("abc"):
     print(item)
 @asyncio.coroutine
 def useful():
     asyncio.sleep(1) # this will do noting without 'yield from'
 async def debug_me():
     await asyncio.sleep(1)

 def async_debug_wrap(generator):
     return asyncio.AsyncDebugWrapper(generator)

 sys.set_coroutine_wrapper(async_debug_wrap)

 debug_me()  # <- this line will likely GC the coroutine object and
             # trigger AsyncDebugWrapper's code.

 assert isinstance(debug_me(), AsyncDebugWrapper)

 sys.set_coroutine_wrapper(None) # <- this unsets any
                                 #    previously set wrapper
 assert not isinstance(debug_me(), AsyncDebugWrapper)
 class Spam:
     async = 42

 async def ham():
     print(getattr(Spam, 'async'))

 # The coroutine can be executed and will print '42'
 await_expr: AWAIT test
 await_stmt: await_expr

 decorated: decorators (classdef | funcdef | async_funcdef)
 async_funcdef: ASYNC funcdef

 async_stmt: ASYNC (funcdef | with_stmt | for_stmt)

 compound_stmt: (if_stmt | while_stmt | for_stmt | try_stmt |
                 with_stmt | funcdef | classdef | decorated |
                 async_stmt)

 atom: ('(' [yield_expr|await_expr|testlist_comp] ')' |
       '[' [testlist_comp] ']' |
       '{' [dictorsetmaker] '}' |
       NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False’)

 expr_stmt: testlist_star_expr
                 (augassign (yield_expr|await_expr|testlist) |
                 ('=' (yield_expr|await_expr|testlist_star_expr))*)
 # async and await will always be parsed as variables

 async def outer():                             # 1
     def nested(a=(await fut)):
         pass

 async def foo(): return (await fut)            # 2
 async def outer():                             # 1
     a_default = await fut
     def nested(a=a_default):
         pass

 async def foo():                               # 2
     return (await fut)
 def useful():
     ...
     await log(...)
     ...

 def important():
     await useful()
 class CM:
     async def __enter__(self): # instead of __aenter__
         ...
 [skipped]

 Report on Darwin ysmac 14.3.0 Darwin Kernel Version 14.3.0:
 Mon Mar 23 11:59:05 PDT 2015; root:xnu-2782.20.48~5/RELEASE_X86_64
 x86_64 i386

 Total CPU cores: 8

 ### etree_iterparse ###
 Min: 0.365359 -> 0.349168: 1.05x faster
 Avg: 0.396924 -> 0.379735: 1.05x faster
 Significant (t=9.71)
 Stddev: 0.01225 -> 0.01277: 1.0423x larger

 The following not significant results are hidden, use -v to show them:
 django_v2, 2to3, etree_generate, etree_parse, etree_process, 
 import sys
 import time

 def binary(n):
     if n <= 0:
         return 1
     l = yield from binary(n - 1)
     r = yield from binary(n - 1)
     return l + 1 + r

 async def abinary(n):
     if n <= 0:
         return 1
     l = await abinary(n - 1)
     r = await abinary(n - 1)
     return l + 1 + r

 def timeit(gen, depth, repeat):
     t0 = time.time()
     for _ in range(repeat):
         list(gen(depth))
     t1 = time.time()
     print('{}({}) * {}: total {:.3f}s'.format(
         gen.__name__, depth, repeat, t1-t0))
 async def echo_server():
     print('Serving on localhost:8000')
     await asyncio.start_server(handle_connection,
                                'localhost', 8000)

 async def handle_connection(reader, writer):
     print('New connection...')

     while True:
         data = await reader.read(8192)

         if not data:
             break

         print('Sending {:.10}... back'.format(repr(data)))
         writer.write(data)

 loop = asyncio.get_event_loop()
 loop.run_until_complete(echo_server())
 try:
     loop.run_forever()
 finally:
     loop.close()

[Python-Dev] async/await in Python; v2 (original) (raw)

Abstract

Rationale and Goals

Specification

New Coroutine Declaration Syntax

types.coroutine()

Await Expression

Asynchronous Context Managers and "async with"

Asynchronous Iterators and "async for"

Debugging Features

Glossary

List of functions and methods

Transition Plan

Backwards Compatibility

Grammar Updates

Transition Period Shortcomings

Deprecation Plans

asyncio

Design Considerations

PEP 3152

Coroutine-generators

No implicit wrapping in Futures

Why "async" and "await" keywords

Why "aiter" is a coroutine

Importance of "async" keyword

Why "async def"

Why not a future import

Why magic methods start with "a"

Why not reuse existing magic names

Comprehensions

Async lambdas

Performance

Overall Impact

Tokenizer modifications

async/await

Reference Implementation

List of high-level changes and new protocols

Working example

References

Acknowledgments

Copyright