Скачать или смотреть Convert Synchronous Python Functions to Asynchronous Functions with FastAPI

Learn how to run synchronous API calls in parallel using FastAPI and Python's threading capabilities. Explore an efficient workaround for optimizing performance without redesigning your entire codebase!
---
This video is based on the question https://stackoverflow.com/q/75322509/ asked by the user 'Abhishek Sachan' ( https://stackoverflow.com/u/3394021/ ) and on the answer https://stackoverflow.com/a/75322622/ provided by the user 'Kamuffel' ( https://stackoverflow.com/u/4686900/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Convert Blocking python function to async function

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Converting Synchronous Python Functions to Asynchronous Ones

In the world of web development, speed is crucial, especially when you're dealing with multiple API requests. If you're using FastAPI, a popular micro framework for building APIs, you might find yourself in a situation where you need to optimize the performance of your application. This guide addresses a common issue: converting synchronous API calls into asynchronous ones to reduce wait times through parallel execution.

The Problem: Synchronous API Calls

Imagine you're working on an application that makes four API requests using a third-party synchronous library. Each request must wait for the previous one to complete before running, resulting in an inefficient use of time. Simply put, if total execution time for four requests takes t seconds, and each request takes t'/4 seconds, invoking them synchronously leads to unnecessarily long wait times.

Example Scenario

Consider the following example code setup for your application:

[[See Video to Reveal this Text or Code Snippet]]

The Dilemma

Using await with some_third_party_lib() is not possible because it is not defined as an asynchronous function. Therefore, you need to find a way to run these synchronous calls in parallel while using FastAPI.

The Solution: Using Threading for Parallel Execution

Unfortunately, there's no direct way to convert a synchronous function into an async function without rewriting it completely. However, you can run your synchronous calls in separate threads using Python's concurrent.futures library, allowing them to execute in parallel without blocking one another.

Step-by-Step Implementation

Import Required Libraries:
You'll need to import concurrent.futures alongside your existing FastAPI imports.

[[See Video to Reveal this Text or Code Snippet]]

Define Synchronous Functions:
Instead of defining asynchronous versions of your API calls, simply set them up as regular synchronous functions:

[[See Video to Reveal this Text or Code Snippet]]

Create the API Endpoint:
Use the ThreadPoolExecutor to run your synchronous functions concurrently:

[[See Video to Reveal this Text or Code Snippet]]

How It Works

ThreadPoolExecutor: This creates a pool of worker threads that can execute your functions concurrently.

Executor.submit: Each API call is submitted as a task to be executed in a separate thread.

as_completed: This will return a generator that produces futures as they complete.

Important Consideration

Be aware that the order of results the user receives may not align with the order of functions in the list due to how threads are managed.

Conclusion

By following this approach, you can significantly optimize your FastAPI application by running synchronous API requests concurrently. While the implementation requires some adjustments, it effectively solves the problem of blocking calls without drastically changing your codebase.

Now you're ready to experiment with this threading solution and enhance the performance of your API endpoints!