DEV Community: Mahendra Patel

How FastAPI handle requests

Mahendra Patel — Sun, 23 Nov 2025 17:24:04 +0000

Introduction

Undoubtedly, 🙃 FastAPI is one of the popular python framework. In this article we will explore 🗺️, how FastAPI handle request and some Gotchas. So, what happen when we execute uvicorn main:app, this launches a single Uvicorn worker with a default thread pool of 40 threads. It is tempting to assume this automatically guarantees the ability to handle 40 concurrent requests.

Now, can we say one worker will be able to handle max 40 requests concurrently? 👏 And the answer is, it depends on the application code.

The Mechanism ⚙️

To understand performance bottlenecks, you must understand where your code executes:

Async APIs (async def): Run directly on the Event Loop.
Sync APIs (def): Run in the Thread Pool.

The "Gotcha" 😬

Here is the critical architectural dependency: The Event Loop is responsible for scheduling Sync requests onto the Thread Pool.

If your Event Loop is blocked (busy executing a long-running task), it cannot schedule new work. Even if your thread pool is completely empty, your Sync requests will sit in a queue, waiting for the Event Loop to free up and assign them a thread.

The Evidence ✍️

Let's look at a common anti-pattern: running blocking I/O (like requests) inside an async function.

from fastapi import FastAPI
import requests
import time

app = FastAPI()

# Blocking I/O function
def make_request(delay: int):
    url = f"[https://httpbin.org/delay/](https://httpbin.org/delay/){delay}"
    with requests.session() as session:
        resp = session.get(url)
    return resp.json()

# BAD: Running blocking code in the Event Loop
@app.get("/async/{delay}")
async def async_call(delay: int):
    print(f"Async call started at {time.time()}")
    return make_request(delay)

# GOOD: Running blocking code in the Thread Pool
@app.get("/sync/{delay}")
def sync_call(delay: int):
    print(f"Sync call started at {time.time()}")
    return make_request(delay)

The Result 🔖: If you trigger the async endpoint followed immediately by the sync endpoint, you will see that the sync request does not even start until the async request finishes.

Key Takeaways

async def runs on the main Event Loop.
def runs on the Thread Pool, but relies on the Event Loop for scheduling.
Never run blocking code in async def. It prevents the Event Loop, from accepting new requests.

I hope, 🙂, this article will help you to write better code using FastAPI, and, Happy Coding.

GIL and Race Condition in Python

Mahendra Patel — Sun, 02 Nov 2025 05:42:06 +0000

## What is a GIL (Global Interpreter Lock)

As the name suggests, the Global Interpreter Lock (GIL) is an interpreter-level mutually exclusive lock. What does that mean 😬? It means that in a Python process, only one thread can execute Python bytecode at any given time. In other words, two threads cannot execute Python code simultaneously within the same process.

So, if the GIL is an interpreter-level lock, can we say that we’ll never face race conditions in a multithreading environment 🤔? As GIL is taking care of and not letting more than one thread run at the same time. The answer is no. Refer to the following code for an explanation.

import threading
counter = 0

def increment_counter():
    global counter
    for _ in range(1_00_000):
        counter += 1


thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print(f"Counter value: {counter}")

In the above code, even though the GIL exists, the program may still experience race conditions. If you run the script multiple times, you may get the correct value mostly, but not always. The reason is that the statement counter += 1 is not an atomic operation at the interpreter level 🪢.

Internally, this single line translates into three operations:

Retrieve the current value of the counter variable.
Increment that value by 1.
Store the updated value back into the counter variable.

If the Python interpreter decides to perform a context switch between these operations, both threads might read the same counter value before either one writes it back. As a result, both threads "increment" the same original value, effectively losing one increment — a classic race condition 😟.

So how can we make this code thread-safe and avoid the race condition? The solution is to use an explicit lock provided by the threading library. Refer to the updated code below.

import threading
counter = 0

lock = threading.Lock()

def increment_counter():
    global counter
    for _ in range(1_00_000):
        with lock:
            counter += 1


thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print(f"Counter value: {counter}")

In the updated code, we use a Lock and acquire it before modifying the shared counter variable. The with lock: statement ensures that only one thread updates the counter at a time. This eliminates the race condition, although it introduces some overhead due to acquiring and releasing the lock for each iteration. The code becomes slightly slower, but much safer 😌.

Feel free to ask any related queries, and Happy Coding 🐍

Understanding Psycopg2: Bridging Python and PostgreSQL

Mahendra Patel — Sun, 23 Jun 2024 16:22:41 +0000

What is Psycopg2:

Psycopg2 is a PostgreSQL database adapter for the Python programming language. It allows developers to interact with PostgreSQL database using Python. It provides functionalities to connect to the PostgreSQL database, execute SQL commands, fetch results from executed SQL commands, manage database transactions, and more.

Querying the Database with Psycopg2:

Querying database can be simplified into following steps

Establish the connection to the database
Create a cursor object (which will be used to query the Database)
Execute SQL query with the help of cursor.
Retrieve database result, using fetchone(), fetchmany() or fetchall(), depend upon the use case.
Finally, close the connection, to free the allocated resources.

import psycopg2

# 1. Make a connection to the database
conn = psycopg2.connect(
    database="database name",
    user="username",
    password="password",
    host="localhost",
    port="5432" # default port of postgresql service
)

# 2. Create a cursor
with conn.cursor() as cur:

    # 3. Execute your SQL command
    cur.execute("SELECT * FROM table_name")

    # 4. Retrieve the result and print it
    rows = cur.fetchall()

    for row in rows:
        print(row)

# 5. Close the connection
conn.close()

Pro tip: We used context manager to create the cursor object
with conn.cursor() as cur: which will automatically close the cursor, once code goes out of the with block.

A little deep dive with retrieving database result:

Once we execute a SQL command with cur.execute() we can retrieve the results with fetchone(), fetchmany(), or fetchall().

fetchone(): This method retrieves the next row of a query result set and returns a single sequence, or None if no more rows are available.

# Execute your SQL command
cur.execute("SELECT * FROM table_name")

# Fetch the next row
row = cur.fetchone()

# Print the row
print(row)

fetchmany([size=cursor.arraysize]): This method retrieves the next set of rows of a query result and returns a list. An empty list is returned when no more rows are available. The number of rows to fetch per call is specified by the size parameter. If it is not given, the cursor’s arraysize determines the number of rows to be fetched.

# Execute your SQL command
cur.execute("SELECT * FROM table_name")

# Fetch the next set of rows
rows = cur.fetchmany(5)

# Print the rows
for row in rows:
    print(row)

fetchall(): This method retrieves all (remaining) rows of a query result and returns them as a list of tuples. An empty list is returned if no more rows are available.

# Execute your SQL command
cur.execute("SELECT * FROM table_name")

# Fetch all results
rows = cur.fetchall()

# Print the results
for row in rows:
    print(row)

These methods provide different ways to retrieve query results depending on the specific needs.

Working with transactions in Psycopg2:

In order to perform any changes to the database such as insert, update, or delete records, we need to use a database transaction.
Theoretically, Transaction is the set of operations, which are atomic in nature, so, either all the operations of the set will be executed successfully or all will be failed.

Executing Transaction involves following steps:

Create a database connection
Create a database cursor
Execute the insert, update or delete command 4.1. Commit the changes 4.2. If something went wrong in the above steps, do a rollback

# 1. Create database connection
conn = psycopg2.connect(...)
try:
    # 2. Create a cursor
    with conn.cursor() as cur:

        # 3. Execute SQL commands (e.g., INSERT INTO table_name)
        cur.execute("INSERT INTO table_name VALUES (%s, %s)", (value1, value2))

    # 4.1. Commit the transaction
    conn.commit()

except Exception as e:
    # 4.2. Roll back in case of error
    conn.rollback()

    print("An error occurred:", e)

And that’s it! Psycopg2 is your trusty bridge between Python and PostgreSQL. So go forth, create magic, and may your code dance elegantly through the data! 🌟✨

Simplifying function with keyword only arguments

Mahendra Patel — Fri, 17 May 2024 18:33:51 +0000

Picture this: you’re working with some legacy code; it has juggling multiple positional arguments passed to a function. Now you are mapping arguments to its value 🗺️ It’s like trying to catch falling knives blindfolded! 🤹‍♂️

The Original Function

def validate_document(name, size, path, doc_type, owner, category, date, issue_by):
    print(f'name: {name}, size: {size}, path: {path}, doc_type: {doc_type}, owner: {owner}, category: {category}, date: {date}, issue_by: {issue_by}')

# Function call with positional argument
validate_document('test.pdf', 1024, 'home/user/', 'pdf', 'Bob', 'medical', '2023-01-02', 'Martin')

It's difficult to work with 🥲, right?

Worry not 😉, you can refactor it to make it better, using keyword only arguments.

Using "*" in function declaration, make sure that all the following arguments will be passed as keyword argument only.

Now your Improved code look like this

def validate_document(name, *, size, path, doc_type, owner, category, date, issue_by):
    print(f'name: {name}, size: {size}, path: {path}, doc_type: {doc_type}, owner: {owner}, category: {category}, date: {date}, issue_by: {issue_by}')

# function called with keyword only arguments
validate_document(name='test.pdf', size=1024, path='home/user/', doc_type='pdf', owner='Bob', category='medical', date='2023-01-02', issue_by='Martin')

Now, only the “name” can venture forth as a positional argument, because it is before "*". The rest arguments must be called by their true names: size, path, doc_type, and so on. 🗝️

If you still try to call function with positional argument you will encounter TypeErorr like following.

TypeError: validate_document() takes 1 positional argument but x were given

Now you have better code to work with which 😇

And Happy Coding!

Simplifying function with keyword only arguments

Mahendra Patel — Fri, 17 May 2024 18:33:51 +0000

The Original Function

def validate_document(name, size, path, doc_type, owner, category, date, issue_by):
    print(f'name: {name}, size: {size}, path: {path}, doc_type: {doc_type}, owner: {owner}, category: {category}, date: {date}, issue_by: {issue_by}')

# Function call with positional argument
validate_document('test.pdf', 1024, 'home/user/', 'pdf', 'Bob', 'medical', '2023-01-02', 'Martin')

It's difficult to work with 🥲, right?

Worry not 😉, you can refactor it to make it better, using keyword only arguments.

Using "*" in function declaration, make sure that all the following arguments will be passed as keyword argument only.

Now your Improved code look like this

def validate_document(name, *, size, path, doc_type, owner, category, date, issue_by):
    print(f'name: {name}, size: {size}, path: {path}, doc_type: {doc_type}, owner: {owner}, category: {category}, date: {date}, issue_by: {issue_by}')

# function called with keyword only arguments
validate_document(name='test.pdf', size=1024, path='home/user/', doc_type='pdf', owner='Bob', category='medical', date='2023-01-02', issue_by='Martin')

If you still try to call function with positional argument you will encounter TypeErorr like following.

TypeError: validate_document() takes 1 positional argument but x were given

Now you have better code to work with which 😇

And Happy Coding!

File reading in python

Mahendra Patel — Sun, 23 Jul 2023 13:20:55 +0000

Generally, file.read() method is used to read entire content of the file. But what if file is too big?
In such cases file.readline() and file.readlines() came to rescue.

with open('abc.txt', 'r', encoding='utf-8') as file:
    pass

In the above code open() method return a stream/ file object, which didn't load anything in the memory. To read content of the file, we have 3 choices

1. read()

Read entire file and load all the content in the memory, optionally it can also take number of characters to load as first argument, but in most of the case we don't know the number of characters before hand.

2. readline()

Since file object return a stream, IOStream are actually iterable, so we can use next() method or for loop to get all the lines one by one, and do want-ever we want to do

3. readlines()

If no argument passed, it will also return entire file, but as a list, where one line represented by one element of the list, but you can also specify the number of lines you want to read at a time

To summerize

Python file object is a stream, and you have multiple option to read the file content, without loading entire file into the memory, so you can easily work with files without worrying about file size.

Top 2 Free Android apps of the week

Mahendra Patel — Thu, 04 Nov 2021 11:09:58 +0000

Dictionary app
Name : wordonary
Features: Clean UI, easy to use, No annoying ads
Cons: Required internet connection, too less features
Whiteboard app
Name: Whiteboard
Features: Easy to use, features rich, no annoying ads
Cons: Some text of app not in English, only available in white theme

Try these apps and let me know if you like them.

$PATH Environment Variable in Linux

Mahendra Patel — Sat, 22 May 2021 18:32:22 +0000

If you have downloaded some custom binary (external program) and want to access it from terminal irrespective of your current working directory, probably you are looking for PATH variable in Linux.
PATH is an environment variable which contains a list of directories separated by :.
When I typed echo $PATH it shows me

/home/my_user/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

Oh, wait! But what are these folders, and what is their use?
These are the folders which contains binaries of programs installed on my machine.
Output for echo $PATH may be different for you based on your Linux distros and program you have installed.

So whenever I typed any command in the terminal, OS will start finding that program one-by-one into these directories, whenever it found first match, it will open it. If it can't find the given command it will display an error command not found.
Okay now that make sense!
But you have not answered my original question till now? I have installed a new program and I want to access it using terminal from any working directory. How can I do that?
A simple solution for this is to add the path of your new program to the environment variable $PATH.
Let's do it with an example.
I have recently downloaded flutter package and unzip it. But when I typed flutter I can't access it. To get this working I have to update the $PATH variable, something like this

export PATH="$PATH:/home/my_user/flutter/bin"

and bingo. Now if you type flutter in terminal you can access it from anywhere.
Are these changes are permanent, what if I close the terminal or shut down my machine, will they persist?
And the answer is NO.
Okay! So what is the permanent solution?
Permanent solution is update path variables via updating terminal profile/settings, I am using bash shell so to update bash setting I will update .bashrc file, If you are using zsh or any other terminal please update its respective profile/settings file.
Use the same command

export PATH="$PATH:/home/my_user/flutter/bin"

and add it to the end of the .bashrc file and save the file.
Now these changes are permanent even if you shut down or restart your machine.

So what we have learnt in this Post

What is $PATH variable?
Update terminal settings file, for bash it is .bashrc
How to access any program from any working directly in the terminal.