BackgroundTasks concurrent parameter

[mbforbes]

Hi all,

First, many thanks for this wonderful library!

I'm using BackgroundTasks, and was surprised (as #549) that they are not executed concurrently, and there's no option to do so.

starlette/starlette/background.py

Lines 42 to 43 in 93494a4

	for task in self.tasks:
	await task()

I'm empathetic to #549 (comment) ("users should deal with the concurrency themselves if that's not what they want."), and I see users could write their own wrappers as in #549 (comment).

But, as a user, I may humbly suggest: I would be delighted if I could pass a concurrent = True flag to BackgroundTasks and have them executed concurrently. As a user—but not author—of async libraries, I'm intimidated by writing async-managing code correctly, and potentially needling to learn about the different async backends. It would also require learning about the APIs, and how to hook in my own background task manager (I'm using FastAPI's wrapper). However, writing a simple but realtime app, I have a real use case for concurrent background tasks: I need to send multiple HTTP requests out as quickly as possible after my own HTTP response.

(also related: #1589)

Many thanks for your consideration,
Max

[adriangb]

If it helps here's a full-fledged implementation of BackgroundTasks that you could use with FastAPI: https://github.com/adriangb/asgi-background

[mbforbes]

Thank you for the reply, @adriangb !

My own implementation is much more barebones, just swapping in the __call__ implementation from @patrys in #549 (comment)

class ConcurrentBackgroundTasks(BackgroundTasks):
    async def __call__(self) -> None:
        await asyncio.gather(*[task() for task in self.tasks])

This has worked in my preliminary testing.

Admittedly, the reason I'd love for this implementation to be an option with a concurrent flag has to do with code calling and wrappers. To use this with FastAPI, we must return a starlette Response, which breaks out of FastAPI's framework and requires more manual hookup.

# Doesn't work; still constructed as BackgroundTasks
@app.post("/foo")
def foo(background_tasks: ConcurrentBackgroundTasks):
    pass

# Works, but we must now manually add schema and validation features
@app.post("/foo", response_model=Model)
def foo():
    bgt = ConcurrentBackgroundTasks()
    bgt.add_task(...)
    return JSONResponse(
        content=jsonable_encoder(
            Model(...)
        ),
        background=bgt,
    )

If a native concurrent option was supported in starlette, there'd be hope for FastAPI's wrapper to expose it.

I'll open an issue on FastAPI too. It would be a great start if starlette exposed this API.

[adriangb]

My point more so was that you can write something that works with FastAPI. My implementation doesn’t require interaction with the Response object and works with FastAPI out of the box.

[mbforbes]

Ah, thanks very much for the reply @adriangb, and I'm sorry that I missed your point. I am still enough of a novice in this area that I couldn't tell that your implementation works with FastAPI out of the box, doesn’t require interaction with the Response object, and that tasks execute concurrently. (I think because the readme shows starlette, a Response object, and doesn't mention concurrency.)