Call async function from sync function, while the synchronous function continues : Python

Just use asyncio.run() inside a synchronous function.

def syncfunc():
    async def asyncfunc():
        await some_async_work()
    asyncio.run(asyncfunc())

syncfunc()

Note that asyncio.run() cannot be called when another asyncio event loop is running in the same thread.

The following should work in all relevant scenarios

import asyncio
import threading
from concurrent.futures import ThreadPoolExecutor
from typing import Any, Coroutine, TypeVar

__all__ = [
    "run_coroutine_sync",
]

T = TypeVar("T")


def run_coroutine_sync(coroutine: Coroutine[Any, Any, T], timeout: float = 30) -> T:
    def run_in_new_loop():
        new_loop = asyncio.new_event_loop()
        asyncio.set_event_loop(new_loop)
        try:
            return new_loop.run_until_complete(coroutine)
        finally:
            new_loop.close()

    try:
        loop = asyncio.get_running_loop()
    except RuntimeError:
        return asyncio.run(coroutine)

    if threading.current_thread() is threading.main_thread():
        if not loop.is_running():
            return loop.run_until_complete(coroutine)
        else:
            with ThreadPoolExecutor() as pool:
                future = pool.submit(run_in_new_loop)
                return future.result(timeout=timeout)
    else:
        return asyncio.run_coroutine_threadsafe(coroutine, loop).result()

Here's a helper function to synchronize an async operation:

import asyncio

async def sleep_return(s):
    await asyncio.sleep(s)
    return 420

def async_to_sync(awaitable):
    loop = asyncio.get_event_loop()
    return loop.run_until_complete(awaitable)

async_result = async_to_sync(sleep_return(.69))
print(f"Result from async call: { async_result }")

# Output:
# Result from async call: 420

You can inline most of the calls to the asyncio api to simplify it even more, but this is a little bit cleaner, imho

asyncio can't run arbitrary code "in background" without using threads. As user4815162342 noted, in asyncio you run event loop that blocks main thread and manages execution of coroutines.

If you want to use asyncio and take advantage of using it, you should rewrite all your functions that uses coroutines to be coroutines either up to main function - entry point of your program. This main coroutine is usually passed to run_until_complete. This little post reveals this topic in more detail.

Since you're interested in Flask, take a look Quart: it's a web framework that tries to implement Flask API (as much as it's possible) in terms of asyncio. Reason this project exists is because pure Flask isn't compatible with asyncio. Quart is written to be compatible.

If you want to stay with pure Flask, but have asynchronous stuff, take a look at gevent. Through monkey-patching it can make your code asynchronous. Although this solution has its own problems (which why asyncio was created).

Maybe it's a bit late, but I'm running into a similar situation and I solved it in Flask by using run_in_executor:

def work(p):
    # intensive work being done in the background


def endpoint():
    p = ""
    loop = asyncio.get_event_loop()
    loop.run_in_executor(None, work, p)

I'm not sure however how safe this is since the loop is not being closed.

You want: Run a function asynchronously (without using a thread) and also ensure the function calling this async function continues its execution.

As user Mikhail Gerasimov has posted, this is impossible. You must have an event loop running in a different thread and the async function scheduled to run in that event loop. Function run_async is how I would do it:

import asyncio
import threading

_event_loop = None
_event_lock = threading.Lock()

def run_async(coro):
    """await a coroutine from a synchronous function/method."""

    global _event_loop

    if not _event_loop:
        with _event_lock:
            if not _event_loop:
                _event_loop = asyncio.new_event_loop()
                threading.Thread(target=_event_loop.run_forever,
                                 name="Async Runner",
                                 daemon=True
                                 ).start()

    return asyncio.run_coroutine_threadsafe(coro, _event_loop)

import time

async def async_fn():
    # simulate work:
    await asyncio.sleep(1)
    return time.time()  # When we finished

def sync_fn():
    waitable = run_async(async_fn())
    # simulate work
    import time
    time.sleep(1)
    t = time.time()  # when we finished
    # Wait for coroutine to complete and get its return value:
    return_value = waitable.result()
    print(t, return_value)

if __name__ == '__main__':
    sync_fn()

Prints:

1747424812.4480834 1747424812.4579432

I'm not sure what you are trying to achieve. By design coroutines won't run if the current thread is occupied by running some sync code. create_task as the name says just create a task entity somewhere inside asyncio and will run when you await something either returned task or any other awaitable object. To run it in current thread you need to explicitly switch context to it by calling await.

import asyncio


async def foo():
    await asyncio.sleep(5)
    return 'Hi there'

def bar():
    return asyncio.create_task(foo())

async def baz():
    print(await bar())

async def main():
    await baz()


if __name__ == '__main__':
    asyncio.run(main())

A slight variation on another answer, to make sure timeout is always taken into account, to simplify the code and explain the reasons for decisions used:

import asyncio
import typing as t
from concurrent.futures import ThreadPoolExecutor

if t.TYPE_CHECKING:
    from collections.abc import Coroutine


def run_coroutine_sync[T](coroutine: "Coroutine[t.Any, t.Any, T]", timeout: float = 30) -> T:
    assert asyncio.iscoroutine(coroutine)

    try:
        loop = asyncio.get_running_loop()
    except RuntimeError:
        return asyncio.run(asyncio.wait_for(coroutine, timeout=timeout))

    if not loop.is_running():
        return loop.run_until_complete(asyncio.wait_for(coroutine, timeout=timeout))

    with ThreadPoolExecutor() as executor:
        fut = executor.submit(lambda: asyncio.run(coroutine))
        return fut.result(timeout=timeout)

• When not in an async context, we just use asyncio.run which will start a new event loop and run the task.

• If we are in an async context, and (in the very rare case) the loop is not yet running, start the loop and run our task inside it.

• In the case that we are in an async context, with an already running loop, then start a new thread, and run the task in there.

The biggest hurdle is that asyncio loops are thread-specific, so you cannot have more than one running per thread.