[Python-Dev] PEP 492: async/await in Python; version 5 (original) (raw)

Tue May 5 18:29:44 CEST 2015

 async def read_data(db):
     pass
 async def read_data(db):
     data = await db.fetch('SELECT ...')
     ...
 power ::=  await ["**" u_expr]
 await ::=  ["await"] primary
 primary ::=  atom | attributeref | subscription | slicing | call
 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:
     VAR = await aenter
     BLOCK
 except:
     if not await aexit(mgr, *sys.exc_info()):
         raise
 else:
     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 letter in AsyncIteratorWrapper("abc"):
     print(letter)
 @asyncio.coroutine
 def useful():
     asyncio.sleep(1) # this will do noting without 'yield from'
 class Spam:
     async = 42

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

 # The coroutine can be executed and will print '42'
 decorated: decorators (classdef | funcdef | async_funcdef)
 async_funcdef: ASYNC funcdef

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

 async_stmt: ASYNC (funcdef | with_stmt | for_stmt)

 power: atom_expr ['**' factor]
 atom_expr: [AWAIT] atom trailer*
 # 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)
 await fut
 await function_returning_future()
 await asyncio.gather(coro1(arg1, arg2), coro2(arg1, arg2))
 cocall fut()  # or cocall costart(fut)
 cocall (function_returning_future())()
 cocall asyncio.gather(costart(coro1, arg1, arg2),
                       costart(coro2, arg1, arg2))
 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] PEP 492: async/await in Python; version 5 (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"

Coroutine objects

Debugging Features

New Standard Library Functions

Glossary

List of functions and methods

Transition Plan

Backwards Compatibility

Grammar Updates

Transition Period Shortcomings

Deprecation Plans

Design Considerations

PEP 3152

Coroutine-generators

Why "async" and "await" keywords

Why "aiter" returns awaitable

Importance of "async" keyword

Why "async def"

Why not "await for" and "await with"

Why "async def" and not "def async"

Why not a future import

Why magic methods start with "a"

Why not reuse existing magic names

Why not reuse existing "for" and "with" statements

Comprehensions

Async lambda functions

Performance

Overall Impact

Tokenizer modifications

async/await

Reference Implementation

List of high-level changes and new protocols

Working example

References

Acknowledgments

Copyright