Converting Synchronous Functions to Asynchronous (and Vice Versa) in Python

In Python, asynchronous programming allows tasks to be executed concurrently, leading to improved performance and responsiveness.

However, there may be scenarios where you have existing synchronous functions that you would like to use in an asynchronous context, or vice versa.

This tutorial will guide you through the process of converting synchronous functions to asynchronous functions, and vice versa, using Python’s asyncio module.

We will demonstrate how to turn sync functions into async functions and async functions into sync functions.

Step 1: Understanding the Concept

Before diving into the code, let’s understand the concept of converting sync functions to async functions and vice versa.

Synchronous functions are executed sequentially, blocking the execution until each task is completed.

Asynchronous functions, on the other hand, allow tasks to be executed concurrently without waiting for each task to finish.

Converting sync functions to async functions can provide performance benefits, especially for I/O-bound operations.

Converting async functions to sync functions can simplify the code execution flow or integrate async functionality into a sync codebase.

Step 2: Converting Sync Functions to Async Functions

The code snippet provided here includes a force_async decorator that allows you to convert sync functions to async functions. Here’s how you can do it:

import functools
from concurrent.futures import ThreadPoolExecutor
import asyncio

def force_async(fn):
    '''
    Turns a sync function into an async function using threads
    '''
    pool = ThreadPoolExecutor()

    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        future = pool.submit(fn, *args, **kwargs)
        return asyncio.wrap_future(future)  # make it awaitable

    return wrapper

In this code, the force_async decorator takes a sync function as input and returns an async function.

It uses ThreadPoolExecutor from the concurrent.futures module to execute the sync function in a separate thread.

The asyncio.wrap_future function is then used to make the result of the sync function awaitable.

To convert a sync function to an async function, apply the force_async decorator to the sync function:

@force_async
def sync_function():
    # Synchronous function code here
    ...

Now, the sync_function can be used as an async function and can be awaited within other async functions.

Step 3: Converting Async Functions to Sync Functions

You can also use a force_sync decorator that allows you to convert async functions to sync functions. Here’s how you can do it:

import asyncio

def force_sync(fn):
    '''
    Turns an async function into a sync function
    '''

    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        res = fn(*args, **kwargs)
        if asyncio.iscoroutine(res):
            return asyncio.get_event_loop().run_until_complete(res)
        return res

    return wrapper

In this code, the force_sync decorator takes an async function as input and returns a sync function.

It checks if the result of the async function is a coroutine using asyncio.iscoroutine. If it is, it uses asyncio.get_event_loop().run_until_complete to await and retrieve the result.

To convert an async function to a sync function, apply the force_sync decorator to the async function:

@force_sync
async def async_function():
    # Asynchronous function code here
    ...

Now, the async_function can be used as a sync function and can be called directly without using await.

Conclusion

Converting synchronous functions to asynchronous functions, and vice versa, can be a valuable technique when working with Python.

It allows you to leverage the benefits of asynchronous programming without rewriting your entire codebase or integrating asynchronous functionality into synchronous code.

In this tutorial, we reviewed some code snippets, which include the force_async and force_sync decorators for converting sync functions to async functions and async functions to sync functions, respectively.

By applying these decorators to the appropriate functions, you can seamlessly switch between synchronous and asynchronous paradigms as needed.

Remember to consider the implications of converting functions between synchronous and asynchronous paradigms.

Asynchronous programming can improve performance for I/O-bound operations but requires careful management of concurrency.

Synchronous programming simplifies control flow but may result in slower execution times for long-running tasks.

By understanding the concepts and techniques covered in this tutorial, you now have the knowledge to convert sync functions to async functions and async functions to sync functions in your Python projects.

This flexibility allows you to optimize your code for performance and responsiveness while maintaining code simplicity and reusability.