Shielding some tasks from being cancelled

Sometimes, however, you need to have an opposite behavior: a child must execute no matter what exceptions are raised in other tasks. Imagine a payment transaction running in one task, and an sms sending in another. You certainly don’t want an sms sending error to cancel a payment transaction.

For that, you can asyncio.shield your tasks before starting them in the nursery:

async def perform_payment():
    ...

async def send_sms():
    ...

async def parent():
    async with Nursery() as nursery:
        nursery.start_soon(asyncio.shield(perform_payment()))
        nursery.start_soon(send_sms())

Getting results from children

If your background tasks are not quite long-lived and return some useful values that you want to process, you can gather all tasks into a list and use asyncio.wait (or similar functions) as usual:

async def parent():
    async with Nursery() as nursery:
        task_foo = nursery.start_soon(foo())
        task_bar = nursery.start_soon(bar())
        results = await asyncio.wait([task_foo, task_bar])

If your background tasks are long-lived, you should use asyncio.Queue to pass objects between children and parent tasks:

async def child(queue):
    while True:
        data = await from_external_system()
        await queue.put(data)

async def parent():
    queue = asyncio.Queue()
    async with Nursery() as nursery:
        nursery.start_soon(child(queue))
        while some_condition():
            data = await queue.get()
            await do_stuff_with(data)

Integration with async_timeout

You can wrap a nursery in a async_timeout.timeout context manager. When timeout happens, the whole nursery cancels:

from async_timeout import timeout

async def child():
    await asyncio.sleep(1000 * 1000)

async def parent():
    async with timeout(10):
        async with Nursery() as nursery:
            nursery.start_soon(child())
            await asyncio.sleep(1000 * 1000)