Forem: rajshirolkar

FastAPI - moving on from Flask

rajshirolkar — Sat, 31 Dec 2022 09:43:11 +0000

If you're a Python developer, you've probably heard of Flask, the micro web framework that has gained a lot of popularity in recent years. However, if you're looking to build a high-performance web application, you may want to consider FastAPI as an alternative.

One of the major drawbacks of Flask is that it is not built for concurrency. In Python, implementing multithreading can be very complicated, as the language itself has some limitations. This means that if you want to build a web application that can handle a high volume of requests, Flask may not be the best choice.

Async support

One of the major limitations of Flask is its lack of async support. In Python, multithreading is very complicated, and the global interpreter lock (GIL) makes it difficult to achieve true parallelism. This is where async programming comes in. Async allows you to write code that can perform IO-bound and high-level structured network code in an async manner.

FastAPI, on the other hand, fully supports async. It's built on top of Starlette, which is an async-compatible web framework, and uses the new async/await syntax introduced in Python 3.5. This means you can write async code in FastAPI just like you would in any other async framework, such as aiohttp or Sanic.

Here's an example of a simple async endpoint in FastAPI:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

Compare this to the equivalent in Flask:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, World!"

Performance

FastAPI is also faster than Flask. It uses the uvicorn server, which is built on top of the asyncio library and the uvloop() event loop. uvloop() is a fast implementation of the asyncio event loop, written in Cython and based on libuv, the same library that powers Node.js. This means that FastAPI can handle a lot more requests per second compared to Flask.

In fact, a benchmark by the FastAPI team showed that FastAPI is up to 3x faster than Flask in some cases. Here's a comparison of the two frameworks using the wrk tool:

For Flask -

Flask (Python 3.7, uWSGI 2.0.18.1):
Running 30s test @ http://127.0.0.1:5000/
  12 threads and 400 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    28.41ms   20.74ms 635.86ms   80.54%
    Req/Sec     2.00k   439.36     3.44k    80.91%
  240973 requests in 30.09s, 41.97MB read
  Socket errors: connect 0, read 240973, write 0, timeout 0
  Non-2xx or 3xx responses: 240973
Requests/sec:   7975.34

For FastAPI -

FastAPI (Python 3.7, uvicorn 0.11.2):
Running 30s test @ http://127.0.0.1:8000/
  12 threads and 400 connections
  Thread Stats Avg Stdev Max +/- Stdev
    Latency 5.12ms 3.29ms 37.45ms 85.08%
    Req/Sec 6.70k 1.37k 10.22k 65.39%
  802934 requests in 30.10s, 134.69MB read
  Socket errors: connect 0, read 802934, write 0, timeout 0
  Non-2xx or 3xx responses: 802934
Requests/sec: 26702.16

As you can see, FastAPI is able to handle almost 3x the number of requests per second compared to Flask. This makes it a great choice for building high-performance APIs.

Flask

FastAPI

Data validation and parsing

FastAPI also has built-in support for data validation and parsing using Pydantic. Pydantic is a library that allows you to define your API's request and response bodies using Python's built-in type hints. FastAPI will then automatically validate the request data and parse it into the correct types.

Here's an example of a request body defined using Pydantic in FastAPI:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

FastAPI will automatically validate the request data and return any validation errors if the data is invalid. This saves you a lot of time and effort compared to manually validating the request data in Flask.

Conclusion

In conclusion, if you're a Python developer looking to build APIs, you should consider using FastAPI instead of Flask. It's a modern, fast, and easy-to-use web framework that fully supports async programming and comes with built-in support for data validation and parsing. Give it a try and see how it can improve your API development workflow.

How to use Async/Await in Unity

rajshirolkar — Sat, 31 Dec 2022 09:28:23 +0000

Async/Await is one of the most useful features in any programming language. In single threaded applications or applications like Unity where the UI runs on a single thread it is extremely useful for smooth functioning of the app to make Async calls which won’t block the main UI thread . We’ll get the whole code first so people who are frantically trying to solve the issues in their project can have a quick peek.

using UnityEngine;  
using System.Threading.Tasks;public class TaskExample : MonoBehaviour  
{  
    float \_elapsed = 0;  
    void Start()  
    {  
        Debug.Log("Start begins"); //Initialize a task completion source.  
        //This will be our source for creating a task and also holding the result on it's completion.  

var tcs = new TaskCompletionSource<Vector3>();  
        Task.Run(async () =>  
        {  
            Debug.Log("Task started");  
            tcs.SetResult(await LongRunningTask());  
            Debug.Log("Task stopped");  
        });// ConfigureAwait must be true to get unity main thread context  
        tcs.Task.ConfigureAwait(true).GetAwaiter().OnCompleted(() =>  
        {  
            Debug.Log("Task completed");  
            transform.Rotate(tcs.Task.Result);  
        });Debug.Log("Start method ends");  
    }void Update()  
    {  
        if (\_elapsed > 1)  
        {  
            Debug.Log($"Update loop running for : " + Time.realtimeSinceStartup + " seconds");  
            \_elapsed = 0;  
        }  
        \_elapsed += Time.deltaTime;  
    }async Task<Vector3> LongRunningTask()  
    {  
        var rand = new System.Random();  
        var v = Vector3.zero;  
        // Do somethings that takes a long time  
        for (var i = 0; i < 30000000; i++)  
        {  
            v = new Vector3(rand.Next(0, 360), rand.Next(0, 360), rand.Next(0, 360));  
        }  
        return v;  
    }  
}

Log :

The logs depict the flow of the code as it excutes the async tasks.

Async/await in C# is similar to promises in javascript to some extent. The underlying concept is the same.

You create a task and send it to say fetch some data from the server. Next you set a means for our code to store the result of the task whenever it comes back with a response from the server.

In the above example we create a TaskCompletionSource which will provide us with a source to create the task and also a source to hold the result on the completion of the task.

var tcs = new TaskCompletionSource<Vector3>();

Create the Task :

Task.Run(async () =>  
        {  
            Debug.Log("Task started");  
            tcs.SetResult(await LongRunningTask());  
            Debug.Log("Task stopped");  
        });

Using the result of the task on completion

// ConfigureAwait must be true to get unity main thread context  
        tcs.Task.ConfigureAwait(true).GetAwaiter().OnCompleted(() =>  
        {  
            Debug.Log("Task completed");  
            transform.Rotate(tcs.Task.Result);  
        });

Here the LongRunningTask( ) method returns a Vector3 which dictates the rotation for our gameobject to which this script is attached. The result of the LongRunningTask( ) method can be accessed by the Task.Result property which we set in

tcs.SetResult(await LongRunningTask());

Now we need to create a function called LongRunningTask() which will be async and will return a Vector3 which dictates the rotation for our gameobject to which this script is attached.

async Task<Vector3> LongRunningTask()  
    {  
        var rand = new System.Random();  
        var v = Vector3.zero;  
        // Do somethings that takes a long time  
        for (var i = 0; i < 30000000; i++)  
        {  
            v = new Vector3(rand.Next(0, 360), rand.Next(0, 360), rand.Next(0, 360));  
        }  
        return v;  
    }

Note : the return type is enclosed in Task<>. I made this mistake and spent a good 5 minutes wondering why I was getting an error.

Now in Unity Editor lets create a new scene and add a 3D Object of a capsule.

Create a capsule so we can see it rotate.

Now attach our script to this capsule and run! We can see the flow of the code in the logs and we can also see the capsule rotating in the scene.

FastAPI over HTTPS for development on Windows

rajshirolkar — Sat, 03 Apr 2021 14:23:01 +0000

Today we'll implement FastAPI over HTTPS using mkcert and setup our own Certificate Authority(CA) on our localhost.

Note: since this is a self-signed certificate you might get a warning before accessing your API depending on which browser you're using.

We'll get started with the code right away so if your boss has told you "Cool get this running over https by EOD" you are in the right place.

Open cmd and make a directory for our app. ```

-> mkdir fastapi-https
-> cd fastapi-https


+ Create and activate a virtual environment for your project and install fastapi and uvicorn in our virtual environment.

-> python -m venv ./venv
-> .\venv\Scripts\activate
(venv) -> pip install fastapi uvicorn

It's always a good practice to create [virtual environments](https://realpython.com/python-virtual-environments-a-primer/) 

+ Open the _fastapi-https_ folder in VSCode and create a directory _app_ which will contain our FastAPI application in *app/main.py*. Also create a file *server.py* to run our [Uvicorn](https://www.uvicorn.org/) server and use it to serve our FastAPI app.
So your directory structure should look like this:
    ![Alt Directory Structure](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qgnuj7wrrgsvs9u3ewck.PNG)

+ Paste the following code in *app/main.py* which will create a FastAPI route for us.
```python


    from fastapi import FastAPI

    app = FastAPI()

    @app.get('/')
    def read_main():
        return { "message" : "Hello World of FastAPI HTTPS"}

Since FastAPI doesn't come with a built-in web server like Flask and Django, we will be using Uvicorn which is an ASGI server. In the file server.py paste the following code - ```python

import uvicorn

if name == 'main':
uvicorn.run("app.main:app",
host="0.0.0.0",
port=8432,
reload=True,
)


In this code in the main function we essentially tell the uvicorn server "Dude! Go to app.main and run whatever this 'app' is" and then we mention the host and port and yeah we do want to reload and all those things.

+ Now its run the server.py file with `python server.py` and go to this link http://localhost:8432/
    ![Alt It worked!](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/w74pzvouv5fjau3y3m8q.PNG)

+ It works! But over "http" 🙄 this won't do in production. We need HTTPS in production. If you want to learn more about how HTTPS works, I will be writing another article here.
To get HTTPS we need to install [mkcert](https://github.com/FiloSottile/mkcert). Mkcert is a free way to get a self signed certificate for your app so it can run over HTTPS.
Install mkcert using [Chocolatey](https://chocolatey.org/install)

-> choco install mkcert


+ You need to generate the certificate and add to your CA with the mkcert utility

-> mkcert -install
-> mkcert localhost 127.0.0.1 ::1


+ The certificate is at "localhost+2.pem" and the key at "localhost+2-key.pem" in our project folder. I like to rename the files as "cert.pem" and "key.pem" so its a bit easier on the eyes.

+ Now we just need to tell Uvicorn the location of these files and Uvicorn will do all the HTTPS heavy-lifting for us. In *server.py* add the ssl arguemnts
```python


import uvicorn

if __name__ == '__main__':
    uvicorn.run("app.main:app",
                host="0.0.0.0",
                port=8432,
                reload=True,
                ssl_keyfile="./key.pem", 
                ssl_certfile="./cert.pem"
                )

Voila! Go to https://localhost:8432/docs and we now have the sweet green text