Flask Asynchronous Programming Using async.io

Flask is inherently synchronous, meaning each request is processed one at a time. However, modern web applications often require handling multiple tasks simultaneously, such as:

• Making external API calls
• Processing large datasets
• Managing real-time communication

Asynchronous programming allows us to execute multiple tasks concurrently, improving performance and responsiveness.

With Python's built-in asyncio, we can introduce asynchronous behavior in Flask applications, allowing tasks like database queries and API requests to run without blocking the main application thread.

Features of asynchronous programming

• Improves Performance – Handles multiple tasks without waiting for each to complete.
• Non-Blocking I/O – Ideal for tasks like fetching external data or database operations.
• Better User Experience – Reduces delays for users when making API requests.

Syntax of async.io Programs

Before using async.io in Flask, let’s understand how asynchronous functions work in Python.

Declaring an Asynchronous Function

In Python, asynchronous functions are defined using the async def keyword:

Explanation:

• async def: Declares a function as asynchronous, meaning it can perform non-blocking operations.
• await: Suspends execution of the function until the awaited task completes, preventing blocking.

Running Multiple Async Tasks

To run multiple async functions concurrently, use asyncio.gather():

Explanation:

• async def functions must be awaited inside another async function.
• awaitasyncio.sleep(n) simulates non-blocking behavior.
• asyncio.gather() executes multiple async functions in parallel.

Now that we have the fundamental understanding of how asynchronus programming works, let's understand how we can implement it in Flask applications with some basic flask app examples:

Asynchronous Database Queries in Flask

Flask's traditional database extensions like Flask-SQLAlchemy are synchronous. To perform asynchronous database operations, we can use Tortoise-ORM, an async ORM for Python.

Let's create a basic Flask app that creates a user table, stores user data and fetches it.

Installation:

Flask does not support async routes by default in a WSGI environment, so to keep using async def routes, we need to install Flask with the "async" extra using this command:

pip install "flask[async]"

Install the Tortoise-orm using this command in terminal:

pip install tortoise-orm aiosqlite

Creating the Application:

This app wil have features to insert, fetch, and list users asynchronously using Tortoise-ORM.

Code Breakdown:

• User Model: Defines an async User model with fields for id, name, and unique email.
• Database Initialization: init_tortoise() function asynchronously connects to an SQLite database and generates schemas.
• Before Request Hook: initialize() function uses an event loop to run init_tortoise() before handling requests.
• /add-user Route: Accepts JSON input and creates a new user asynchronously, then returns the user details.
• /user/int:user_id Route: Asynchronously fetches a user by ID; returns user data if found or a 404 error otherwise.
• /users Route: Retrieves all users asynchronously and returns them as a JSON list.

Running and Testing the Application

Adding a user:

1. Run the application using command - python app.py and open Postman Api application to test it.

2. First we need to add a user in the databse, follow these steps to do it:

3. Select POST as the request type.

4. Enter the API URL- http://127.0.0.1:5000/add-user

5. Go to the "Body" Tab, select raw, choose JSON from the dropdown and paste the following in the Body section:

{
"username": "Geek,
"email": "geeks@gfg.org"
}

6. Click send and the user is added in the database.

Fetching user data:

To fetch the user data, make a get request to the URL - http://127.0.0.1:5000/users

Running Background Tasks in Flask

Flask doesn't natively support background tasks, but we can use asyncio.create_task() for lightweight tasks that run without blocking the main application.

Explanation:

1. background_task() – An asynchronous function that waits for 5 seconds before printing a message.

2. start_task() Route

• Creates a new event loop.
• Uses executor.submit() to run background_task() without blocking Flask.
• Returns a response immediately while the task runs in the background.

Run the application and open Postman application to make a GET Request on URL- http://127.0.0.1:5000/start-task.

After making the GET request, we will receive a background task completed message in the terminal after 5 seconds of delay.