What is the suggested way to use AsyncClient to do multiple requests?

[SysuJayce]

Hello,
I am not familar with async code program, but I want to do multiple requests asynchronously. What is the suggestion?

I have 2 implements, the first one works well but I wonder if it is good to create a new client each time.

async def download_async(url, filename):
    async with httpx.AsyncClient() as client:
        try:
            res = await client.get(url)
            res.raise_for_status()
            with open(filename, "wb") as f:
                f.write(res.content)
        except httpx.HTTPError as exc:
            print(f"Error while requesting {exc.request.url!r} - {exc!r}")

However, although the latter one use a shared client, it'll get Pool Timeout or some other Errors if we do multiple requests together.

async def download_async(client, url, filename):
    try:
        res = await client.get(url)
        res.raise_for_status()
        with open(filename, "wb") as f:
            f.write(res.content)
    except httpx.HTTPError as exc:
        print(f"Error while requesting {exc.request.url!r} - {exc!r}")
        
       
async with httpx.AsyncClient() as client:
    await download_async(client, url, filename)

[SysuJayce]

Or should I call await httpx.get(url) instead?

[dubslow]

You need to use an async library, such as trio or asyncio, to enable running several tasks in parallel:

async def main(args):
    async with MyAsyncClient() as client, trio.open_nursery() as nursery:
        for arg in args:
            print(f'spawning for {arg}')
            nursery.start_soon(process_query_all, client, arg)

if __name__ == '__main__':
    from sys import argv
    args = argv[1:]
    if not args:
        raise ValueError('pass some args')
    trio.run(main, args)

For trio, it's called a nursery, for asyncio, it's called a TaskGroup or something like that. You need to use one or the other and call start_soon on as many tasks as you like.

[SysuJayce]

Thanks, but I have already used asyncio. My question is should I create standalone a client for each coroutine or use a shared one?

Below is an example of how I use asyncio

async with httpx.AsyncClient() as client:
    tasks = [asyncio.create_task(download_async(url)) for url in urls]
    await asyncio.gather(*tasks)

[lovelydinosaur]

You should use a single shared client instance.

You can use the asyncio_create_task() / asyncio.gather() primitives, but structured concurrency provides a more throughly designed approach to running multiple tasks.

I'd either recommend working with Python 3.11 asyncio.TaskGroup https://docs.python.org/3/library/asyncio-task.html#asyncio.TaskGroup or using anyio (Which you can use over the top of asyncio if needed).

At some point we ought to update our docs to help guide more folks towards structured concurrency, rather than working directly with asyncio. (In short... "If you can use trio, do that, it's ace. Otherwise use anyio.")

[SysuJayce]

Thanks @tomchristie , after testing, I found out that using a shared async client without connection limits is good for me.

httpx.AsyncClient(limits=httpx.Limits(max_connections=None, max_keepalive_connections=20))

As for trio, I'll give it a shot :)

[4dahalibut]

how come you don't recommend just using task groups over trio now that it's published?

[lovelydinosaur]

how come you don't recommend just using task groups over trio now that it's published?

We're not recommending either in our docs at the moment - we don't mention it at all.

However encode/httpcore#783 (reply in thread) has some good context to my actual thoughts here.

• Even once you're on 3.11 and have TaskGroup available, asyncio still exposes you to a bunch of primitives you'd rather not have available.
• The API for task group isn't quite as neat as trio's nurseries, and you're also missing trio's neat approach to timeout APIs.
• Harder to quantify, but my experience is that asyncio is less resilient than trio. We had a bunch of bugs with httpx in asyncio that eventually prompted us to use anyio for the implementation there, and I suspect there's various gnarly bits under the surface that're always going to be awkward to resolve there.

No criticism of asyncio intended here, just critique. Their team have had to work within a far more complex context than trio.

Brief. Trio nails the design space here. It just does. The only serious consideration is the issue of split ecosystems. (Eg. "okay trio has the more thorough design, but asyncio is part of Python's stdlib and has the larger existing ecosystem of support so let's promote that" would be a valid take.)