FastAPI vs Flask | Is FastAPI the correct replacement for flasks?

from flask import Flask, jsonify
app = Flask(__name__)
@app.route("/<name>", methods=['GET'])
def home(name):
    return jsonify({"message": f"Hello! {name}"})
if __name__ == "__main__":
    app.run(debug=True)

By pressing the url localhost / AnyNameHere, a JSON result similar to this will be displayed: (I use the chrome extension called JSON viewer. You may be prompted for plain text instead of this formatted output)

Problems with the flask

The problem with this approach is that there are no data validation, which means we can pass any type of data, be it chains, tuples, numbers or any character. This can break the program often and you can imagine that if an ML model gets wrong data types, the program will crash. You can create a data checker before passing the values ​​over, but I would add additional work.

Error pages in Flask as plain HTML pages that can generate decoder errors when the API is called in other applications. There are other problems with Flask, like slow nature, no asyncand web socket support that can speed up processes and, Finally, no automated document generation system. You need to manually design the UI for API usage and examples. All these problems are solved in the new framework.

FastAPI

It is a modern framework that allows you to create APIs smoothly and without much effort. Has the ability to separate server code from business logic increasing code maintainability. As the name itself is fast, it is much faster compared to the flask because it is built on ASGI (Asynchronous server gateway interface) instead of WSGI (Web server gateway interface). It has a data validation system that can detect any invalid data type at runtime and returns the reason for incorrect entries to the user only in JSON format, which frees developers from explicitly handling this exception.

That generates the documentation on the fly when you are developing the API, which is the most requested by all developers. Documentation is a great way for other developers to collaborate on a project, as it presents everything that can be done with the necessary instructions. It also generates a good GUI that solves everything that was missing in the flask.

It does all of these things with the OpenAI and Swagger specifications to implement these specifications. As a developer, it is only focusing on the logical construction part and the rest of the stuff is managed by FastAPI. Let's see the same example that was created using Flask now implemented in FastAPI:

import uvicorn
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def home(name: str):
    return {"message": f"Hello! {name}"}
if __name__ == "__main__":
    uvicorn.run(app, host="127.0.0.1", port=8000, debug=True)

By pressing the url localhost /? Name = AnyNameHere, you will be prompted for a result like:

You can see that the code is very similar to flask, but here we are using uvicorn server, what is an ASGI implementation. What's more, here we are without routing any end points and create them directly using decorators, what makes the most sense. The function here simply takes the required arguments further than eliminates the need for the request object be called.

There is another documentation generator that is included with FastAPI, namely, ReDoc which also generated a beautiful documentation with all the endpoints listed. It can be accessed by pressing the end point / redoc:

To configure data validation, we can simply create the data type class inherited from the Pydantic base model. It is a library that offers data validation through Python type annotations. We can add the description of the entities and provide the custom example to display in the docs.

ML FastAPI example

I would like to share an example where an ML DecisionTree classifier model was implemented using FastAPI. The problem statement for this is a musical genre classifier where based on technical aspects of music such as tempo, the valencia, the music is rock or hip-hop. I did a music class to validate the data that will be passed to the model that looks like this:

from pydantic import BaseModel
class Music(BaseModel):
    acousticness: float 
    danceability: float 
    energy: float 
    instrumentalness: float 
    liveness: float 
    speechiness: float 
    tempo: float 
    valence: float

If you want to see the complete code, go to this GitHub repository.

Conclution: Which to choose?

After all this discussion, the question remains unanswered, who wins? Based on all factors, I would I suggest adopting FastAPI over Flask. Is very easy to configure, migrating an old flask project to this one will not take long, async, web sockets y automatic document generation function it's the cherry on top.

One can choose the flask frame to configure the whole web interface (Front-end y back-end) but in regards to ML where the main objective is to check if the model is working in production environment or not, creating an API makes more sense because the rest of the stuff can be managed by other teams of developers and to clearly explain to them the use of the program you developed, FastAPI auto docs is a good solution.

Connect with the author

You can connect with me at Linkedin to discuss anything related to Python development and data science, GitHub to see my projects or you can read my articles in the middle.

Kaustubh – Half