darker VS fastapi

Thanks for your suggestions. I have gone through the GitHub issue that you have mentioned. From there I got to know about this plugin https://github.com/akaihola/darker

For Python, Darker does that by applying Black only to changed areas of the code. Maybe the same approach could be used for rustfmt by creating a separate tool?

Not an answer to your question but in the specific case of black you can instead use: https://github.com/akaihola/darker

For instance, we have a number of interesting features planned for the 1.5.0 release of Darker, a tool for running Black/isort/pylint/flake8 but limiting to only lines modified between two given Git commits.

I knew one library using "composite". - Darker: https://github.com/akaihola/darker/blob/master/action.yml - More details here: https://docs.github.com/en/actions/creating-actions/creating-a-composite-action

There's also Darker for only reformatting (using Black) the lines modified by commits.

Assuming the range you're interested in is a range with your changes, you should look at darker.

Yeah that's how we've used it. The results need manual checking, but together with darker https://github.com/akaihola/darker that's how we've been slowly ratcheting our Django monolith into a typed codebase.

FastAPI is a modern, high-performance web framework for building APIs with Python, based on standard Python type hints.

In this tutorial, I will demonstrate how to use Burr, an open source framework (disclosure: I helped create it), using simple OpenAI client calls to GPT4, and FastAPI to create a custom email assistant agent. We’ll describe the challenge one faces and then how you can solve for them. For the application frontend we provide a reference implementation but won’t dive into details for it.

That’s when I found FastAPI.

FastAPI & Uvicorn

Discussion at FastAPI GitHub: https://github.com/tiangolo/fastapi/issues/2696

An API application framework (such as FastAPI)

It’s been my experience that async Python frameworks tend to turn IO bound problems into CPU bound problems with a high enough request rate, because due to their nature they act as unbounded queues.

This ends up made worse if you’re using sync routes.

If you’re constrained on a resource such as a database connection pool, your framework will continue to pull http requests off the wire that a sane client will cancel and retry due to timeouts because it takes too long to get a connection out of the pool. Since there isn’t a straightforward way to cancel the execution of a route handler in every Python http framework I’ve seen exhibit this problem, the problem quickly snowballs.

This is an issue with fastapi, too- https://github.com/tiangolo/fastapi/issues/5759

Fast API.

We will create our API using FastAPI, a modern high-performance web framework for building fast APIs with Python. It is designed to be easy to use, efficient, and highly scalable. Some key features of FastAPI include: