Python 3, an Illustrated Tour Transcripts
Chapter: Asynchronous Programming
Lecture: Walk-through: Asyncio Context Managers
Login or
purchase this course
to watch this video and the rest of the course contents.
0:00
In this video, we're going to look at async context test.py Let's look at the first test, it says write an asynchronous context manager staller,
0:09
it should accept a time in seconds when the context is entered, it should pause for that many seconds, call asyncio sleep.
0:16
Okay, so let's make a staller. We have to define a class called staller and we need to define a constructor __init__
0:26
and it needs to take some time in seconds and because this is an import there rather than saying time,
0:35
maybe I'll just say amount and I'll say self.amount is equal to amount. Now we need to define the implementation for the asynchronous protocol
0:43
of the context manager and that is defining __aenter__ and __aexit__ and because this is asynchronous,
0:52
we're going to put an async right in front of that def there. Okay, it says when we enter we want to call asyncio.sleep
1:02
and we want to sleep for self.amt and we're getting squiggles here in PyCharm because we need to import asyncio there
1:11
and because we're calling an asynchronous function, remember, whenever we call asynchronous functions, we need to await them.
1:17
So this is a function that can call asynchronous functions because it is defined with async in front of it.
1:25
Great, we just also need to define the async def __aexit__ and this doesn't need to do anything, so we'll just pass here.
1:35
Let's run this and make sure that it works, so I'll just right-click and say run this. And it looks like I'm on the second part here,
1:43
so this is my staller context manager, it takes an amount that we want to stall
1:49
and when we enter the context it will sleep for that amount before starting the context.
1:54
We can look down at the test here just to make sure that that's what's going on. We have a time, we keep track of the time before we go into it,
2:01
we're going to say we're going to stall for one second and then we're going to enter it, we're going to look at our time
2:06
and we're going to assert that our time difference is greater than or equal to 1 second, which it appears to be now.
2:12
The next one says write an asynchronous context manager closer. It should accept an object and call the .close method on it when the context exits.
2:20
Okay class closer, we need the constructor, and it needs some object here, I'm just going to say obj and let's say self.obj is equal to obj,
2:34
and we need a __aenter__, __aexit__ async def __aenter__ and this doesn't need to do anything here and we need a async def __aexit__
2:51
and when we exit we need to make sure that we call closer here so you can say self.obj.close. Let's run this and make sure it works.
3:05
Okay, it looks like it worked and we can look at the test down here. The test just makes a class called CloseMe and if you call close on it,
3:16
it sets an attribute called closed is equal to true and inside of here, we just create an instance of CloseMe
3:22
and we put it in our async context manager here and we don't do anything, we just assert that after we're done closed is called.
3:31
Note that nowhere inside of this code have we called closed but we passed the c object into closer and it called that when it exited out of it.
3:42
Hopefully you have a little bit more understanding how to use these asynchronous context managers
3:47
the key point being that if you want to do some asynchronous calling you can do that inside of the __enter__ or __exit__ if you want to.
3:58
Note that closer doesn't do any asynchronous calling. It just closes an object so you can make the context managers like that as well if you want to.