def _detect_running_asynclib() -> str:
    if 'trio' in sys.modules:
        from trio.hazmat import current_trio_token
        try:
            current_trio_token()
        except RuntimeError:
            pass
        else:
            return 'trio'

    if 'curio' in sys.modules:
        from curio.meta import curio_running
        if curio_running():
            return 'curio'

    if 'asyncio' in sys.modules:
        from .backends.asyncio import get_running_loop
        if get_running_loop() is not None:
            return 'asyncio'

    raise LookupError('Cannot find any running async event loop')

Hi all,

A number of people are working on packages that support multiple async

backends (e.g., asyncio + trio, or trio + curio, or trio + twisted,

...). So then the question arises... how can I figure out which async

library my user is actually using?

Answer: install sniffio, and then call

sniffio.current_async_library(), and it tells you.

Well, right now it only works for trio and asyncio, but if you

maintain an async library and you want to make it easier for packages

to detect you, then it's easy to add support – see the manual. We

considered various clever things, but ultimately decided that the best

approach was to use a ContextVar and make it the coroutine runner's

responsibility to advertise which async flavor it uses. In particular,

this approach works even for hybrid programs that are using multiple

coroutine runners in the same loop, like a Twisted program with

asyncio-flavored and twisted-flavored coroutines in the same thread,

or a Trio program using trio-asyncio to run both asyncio-flavored and

trio-flavored coroutines in the same thread.

Github: https://github.com/python-trio/sniffio

Manual: https://sniffio.readthedocs.io/

PyPI: https://pypi.org/p/sniffio

-n