httpx | 🦋 | Reactive Programming library

Something like this

The code is making requests sequentially for every element in parsed['data'].

Consider running your code asynchronously with some HTTP client that supports asyncio, for example httpx, and use asyncio.gather to run your requests concurrently.

Consider the following example which makes 50 GET requests to google.com using requests and using httpx. Note that the async solution is significantly faster.

Q :
_{" ... What's the problem? "}

A :
The FastAPI documentation is explicit to say the framework uses in-process tasks ( as inherited from Starlette ).

That, by itself, means, that all such task compete to receive ( from time to time ) the Python Interpreter GIL-lock - being efficiently a MUTEX-terrorising Global Interpreter Lock, which in effect re-[SERIAL]-ises any and all amounts of Python Interpreter in-process threads
to work as one-and-only-one-WORKS-while-all-others-stay-waiting...

On fine-grain scale, you see the result -- if spawning another handler for the second ( manually initiated from a second FireFox-tab ) arriving http-request actually takes longer than a sleep has taken, the result of GIL-lock interleaved ~ 100 [ms] time-quanta round-robin ( all-wait-one-can-work ~ 100 [ms] before each next round of GIL-lock release-acquire-roulette takes place ) Python Interpreter internal work does not show more details, you may use more details ( depending on O/S type or version ) from here to see more in-thread LoD, like this inside the async-decorated code being performed :

You're double encoding your content as JSON - you're both asking for it to be returned as a JSON string, and then telling your request method to encode it as JSON a second time. json= as an argument to the method on the client converts the given data to JSON - it does not expect already serialized JSON.

You can see this in your request string because it starts with " and not with { as you'd expect:

I once created similar pattern when I was mixing trio and kivy, which was demonstration of running multiple coroutines asynchronously.

It use a trio.MemoryChannel which is roughly equivalent to asyncio.Queue, I'll just refer it as queue here.

Main idea is:

1. Wrap each task with class, which has run function.
2. Make class object's own async method to put object itself into queue when execution is done.
3. Create a global task-spawning loop to wait for the object in queue and schedule execution/create task for the object.

It is possible to extract undecoded data from httpx response only in case of streaming mode stream=True or httpx.stream. In the example below, I collect the entire response using aiter_raw and return it from the path operation. Keep in mind that the entire response is loaded into memory, if you want to avoid this use fastapi StreamingResponse

OK I figured it out and now I feel dumb.

The issue was indeed related to the venv, basically, uvicorn is installed on the base image but not in my pyproject.toml. So poetry didn't install it in the venv. When I started the app in the Dockerfile using CMD it couldn't find uvicorn in the venv so went to the base install and ran from there. When I added uvicorn to the venv it all worked fine.

Is there any advantage in doing it like this or is there a better way?

No, there is no advantage using httpx.Client in the way you've shown. In fact the httpx. API, e.g. httpx.get, does exactly the same thing!

The "pool" is a feature of the transport manager held by Client, which is HTTPTransport by default. The transport is created at Client initialisation time and stored as the instance property self._transport.

Creating a new Client instance means a new HTTPTransport instance, and transport instances have their own TCP connection pool. By creating a new Client instance each time and using it only once, you get no benefit over using e.g. httpx.get directly.

And that might be OK! Connection pooling is an optimisation over creating a new TCP connection for each request. Your application may not need that optimisation, it may be performant enough already for your needs.

If you are making many requests to the same endpoint in a tight loop, iterating within the context of the loop may net you some throughput gains, e.g.

This seems to be very confusing according to the official docs, but this github issue has a solution.

For some reason the docs specify both strings and HTTPTransports but this has been clarified in the issue above.

Basically: