Flask Vs FastAPI which one should you choose?

If you’re stepping into machine learning, its important to have a good understanding of Flask vs FastAPI. As a developer, there are a few essential elements that you need in your arsenal before jumping into the world of machine learning or deep learning. Some of them include:

• Machine learning concepts
• Python or R languages — considered to be one of the most important languages in ML.
• Tensorflow or Pytorch — end to end opensource platform for ML and DL.
• Flask — To productionize an ML model we usually wrap a model in a REST API and serve it as a micro service.
• Docker — Platform that uses OS-level virtualization to deliver software in packages called containers.

In this article, we are going to zero in one Flask and take a look at how it compares to an alternative framework like FastAPI. In order to properly understand the difference between the two, it is important to get a deeper insight into what they are. 

What is Flask?

Flask is a micro web framework written in Python. Micro web frameworks are normally frameworks with little to no dependencies to external libraries. These kinds of frameworks have both advantages and disadvantages. Pros would be that the framework is light, there is little dependency to update and watch for security bugs, while the major disadvantage is that some times, you will have to do more work by yourself or increase the list of dependencies by adding plugins.

Flask is currently the primary choice of writing APIs for machine learning frameworks in Python. It is a framework based on the current/old standard for Python web frameworks: WSGI. Like most widely used Python libraries, the Flask package is installable from the Python Package Index (PPI).

One of the primary benefits that you will encounter while using Flask is its superior design, which is lightweight and modular. Users will also experience quality community support as well. Flask is absolutely compliant with WSGI, which makes it convenient for deployment during production. It is ORM-agnostic and developers can plug in the ORM that they prefer the most without any issues. Additionally, Flask can manage HTTP requests easily and it is much more flexible than its counterpart, Django.

Flask is also widely used as it is written in Python, the preferred language for most data scientists and machine learning developers. A few disadvantages that can be seen while using Flask is that it can be extremely time-consuming to use during big projects. Flask also relies on several dependencies. For instance, the admin site makes use of Flask-admin, and doesn’t have a default template engine. Instead, it comes with another dependency freeloaded with Flask, which is Jinja2.

What is FastAPI?

FastAPI was built with three primary concerns in mind:

• Speed
• Developer experience
• Open standards

FastAPI is a crucial element that brings Starlette, Pydantic, OpenAPI, and JSON Schema together.

Under the hood, FastAPI uses Pydantic for data validation and Starlette for tooling, making it blazing fast compared to Flask, giving comparable performance to high-speed web APIs in Node or Go. It is an innovative framework built on top of Starlette and Uvicorn. Starlette is a lightweight ASGI framework/toolkit, which is ideal for building high performance asyncio services. Uvicorn is a lightning-fast ASGI server, built on uvloop and httptools. 

How is Flask different from FastAPI?

• API-first

FastAPI is an API-first web server, which means that the error messages are in JSON format by default, and the return value expected by the handlers are dictionaries. On the other hand, the error messages displayed in Flask are HTML pages by default, and return JSON needs to be jsonify()’d

While developing APIs, it can be annoying to have HTML pages pop up as errors, since this will cause REST clients to issue a JSON decode error. This can also make the logs complex since there are a lot of superfluous formatting tags in the HTML page. Although Flask can be programmed to display error messages in JSON format, FastAPI comes out of the box ready to build APIs.

• Validation

Generally, APIs validate input against the API spec and reject data that doesn’t match. 

In Flask, this can be a challenging task. This is because there are only limited options available-  write a lot of if statements to check every possible part of the data coming in, and then manually make sure to go update your API documentation somewhere, or use some kind of data validation library. FastAPI on the other hand, uses pydantic to provide schema validation, and generates sensible human-readable error messages, and no extra code or libraries are needed.

The pydantic model can also be used to construct payloads as well as validating them:

>>> entry = ChatEntry(message="Hello", recipient="Dave")

>>> entry.timestamp = time.time()

>>> entry

ChatEntry(version='3.1', message='Hello', recipient='Dave', author=None, timestamp=1599307407.9207017)

>>> dict(entry)

{'version': '3.1', 'message': 'Hello', 'recipient': 'Dave', 'author': None, 'timestamp': 1599307407.9207017}

• Asyncio

One major issue with Flask is the lack of Asyncio support. Asyncio is a crucial element for HTTP endpoints, which tend to do a lot of waiting around for IO and network chatter, making it a good candidate for concurrency using async. Conversely, FastAPI supports asyncio by default, which means that you can use a single framework for all your endpoints.

FastAPI Vs Flask

• FastAPI is well known to be the fastest python web framework. It performs 100 times better than Flask in any given situation.
• FastAPI can also be considered a better option due to its auto scaling feature. As Flask is developed for WSGI services like Gunicorn, it doesn’t offer native async support. For auto scaling, you will have to asynchronously count queued and in-flight requests.
• FastAPI provides us with a powerful dependency injection system, which means infinite plug-ins. When you are using FastAPI your API will be compatible with OpenAPI, JSON Schema and OAuth2.0 which will be handled by FastAPI.
• Decreased latency and high throughput is another advantage provided by FastAPI over Flask. This will help in neglecting more hardware dependencies and can reduce costs too

Switching from Flask to FastAPI is quick and easy with very little hassle involved. Given all the advantages that the FastAPI framework has over Flask, it would definitely be worth your time to check it out and see if it would be able to suit your needs better.