Description
Over the last few years, I've found myself writing a lot of code which leans heavily on context managers, and parenthesized context managers make it quite conventient to do so - in all but one case. If you have mixed synchronous and async context managers, each switch from sync to async costs another level of indentation, making the code noticably harder to read.
I therefore propose that the async with statement should also accept mixed sync and async context managers, so long as there is at least one async context manager.
I've been using a helper function which gets most of the way towards this. I nonetheless think that the feature would be valuable, because:
- It guides people away from a "convert to async cm" pattern (e.g.
as_acm(sync_cm()) as v,), which changes code semantics by adding checkpoints where the async framework can switch tasks - and entering or exiting context managers is an unusally bad time to do that, since they are often responsible for timeouts or error handling. - Keeping the
asclauses local helps to avoid naming confusion: when adding or deleting code, it's easy to mismatchasync with multicontext(some(), contexts()) as (a, b):relative toasync with some() as b, contexts as a:. As seen here, it's also more concise.
from contextlib import AsyncExitStack, asynccontextmanager
@asynccontextmanager
async def multicontext(*cms):
assert any(hasattr(cm, "__aenter__") for cm in cms)
async with AsyncExitStack() as stack:
enter, aenter = stack.enter_context, stack.enter_async_context
yield tuple(
(enter(cm) if hasattr(cm, "__enter__") else await aenter(cm))
for cm in cms
)Has this already been discussed elsewhere?
This is a minor feature, which does not need previous discussion elsewhere.
Update: now on discuss.python.org to collect feedback.