Using the async with Statement

Leodanis Pozo RamosJune 2, 2021About 3 min

Using the async with Statement 관련

Context Managers and Python's with Statement

In this step-by-step tutorial, you'll learn what the Python with statement is and how to use it with existing context managers. You'll also learn how to create your own context managers.

Context Managers and Python's with Statement

In this step-by-step tutorial, you'll learn what the Python with statement is and how to use it with existing context managers. You'll also learn how to create your own context managers.

The with statement also has an asynchronous version, async with. You can use it to write context managers that depend on asynchronous code. It’s quite common to see async with in that kind of code, as many IO operations involve setup and teardown phases.

For example, say you need to code an asynchronous function to check if a given site is online. To do that, you can use aiohttp, asyncio, and async with like this:

import aiohttp
import asyncio

async def check(url):
    async with aiohttp.ClientSession() as session: 
        async with session.get(url) as response: 
            print(f"{url}: status -> {response.status}")
            html = await response.text()
            print(f"{url}: type -> {html[:17].strip()}")

async def main():
    await asyncio.gather(
        check("https://realpython.com"),
        check("https://pycoders.com"),
    )

asyncio.run(main())

Here’s what this script does:

Line 3 imports aiohttp, which provides an asynchronous HTTP client and server for asyncio and Python. Note that aiohttp is a third-party package that you can install by running python -m pip install aiohttp on your command line.
Line 4 imports asyncio, which allows you to write concurrent code using the async and await syntax.
Line 6 defines check() as an asynchronous function using the async keyword.

Inside check(), you define two nested async with statements:

Line 7 defines an outer async with that instantiates aiohttp.ClientSession() to get a context manager. It stores the returned object in session.
Line 8 defines an inner async with statement that calls .get() on session using url as an argument. This creates a second context manager and returns a response.
Line 9 prints the response status code for the url at hand.
Line 10 runs an awaitable call to .text() on response and stores the result in html.
Line 11 prints the site url and its document type, doctype.
Line 13 defines the script’s main() function, which is also a coroutine.
Line 14 calls gather() from asyncio. This function runs awaitable objects in a sequence concurrently. In this example, gather() runs two instances of check() with a different URL for each.
Line 19 runs main() using asyncio.run(). This function creates a new asyncio event loop and closes it at the end of the operation.

If you run this script from your command line, then you get an output similar to the following:

python site_checker_v0.py
# 
# https://realpython.com: status -> 200
# https://pycoders.com: status -> 200
# https://pycoders.com: type -> <!doctype html>
# https://realpython.com: type -> <!doctype html>

Cool! Your script works and you confirm that both sites are currently available. You also retrieve the information regarding document type from each site’s home page.

Note

Your output can look slightly different due to the nondeterministic nature of concurrent task scheduling and network latency. In particular, the individual lines can come out in a different order.

The async with statement works similar to the regular with statement, but it requires an asynchronous context manager. In other words, it needs a context manager that is able to suspend execution in its enter and exit methods. Asynchronous context managers implement the special methods .__aenter__() and .__aexit__(), which correspond to .__enter__() and .__exit__() in a regular context manager.

The async with ctx_mgr construct implicitly uses await ctx_mgr.__aenter__() when entering the context and await ctx_mgr.__aexit__() when exiting it. This achieves async context manager behavior seamlessly.