How Context Managers Work, Step by Step

What happens when nesting with statements for the same object? Let’s say I have an instance foo of class Bar, which has a context manager defined

class Bar:

    def __init__(self):
        my_resource = None

    def __enter__(self):
        my_resource = allocate_resource()

    def __exit__(self, ...):
        free_resource(my_resource)

what happens if I nest WITH statements like this:

foo = Bar()

with foo:
    with foo:
        with foo:
            do_something

Does Python handle that for me? I.e. will it only call enter upon the first WITH statement and exit when exiting from the same level?

If not, how should I handle this myself? If I have enter check whetehr the resource is already allocated and only allocate it, if not, it will be released upon exiting the innermost level, so that’s not an option, I believe. Alternatively, I could use a nesting counter:

def __init__(self):
    self.my_resource = None
    self.counter = 0

def __enter__(self):
    if self.counter == 0:
        self.my_resource = allocate_resource()
    self.counter += 1

def __exit__(self, ...):
    if self.counter == 1: 
        free_resource(self.my_resource)
    self.counter -= 1

How will that work if an exception occurs? Will exit be called the necessary number of times, so that the resource is eventually freed up?

Does Python handle that for me? I.e. will it only call enter upon the first WITH statement and exit when exiting from the same level?

Yep, nested context managers work as expected and Python takes care of calling __enter__ and __exit__ at the appropriate time.

Here’s an example from my Python Tricks book:

class Indenter:
    def __init__(self):
        self.level = 0

    def __enter__(self):
        self.level += 1
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.level -= 1

    def print(self, text):
        print(' ' * self.level + text)

with Indenter() as indent:
    indent.print('hi!')
    with indent:
        indent.print('hello')
        with indent:
            indent.print('bonjour')
    indent.print('hey')

Output:

hi!
    hello
        bonjour
hey

Quick note since I just got an email about this being confusing – at the end of the video I’m showing the following code example:

mf = ManagedFile("hello.txt")
with mf as the_file:
    the_file.write("hello.txt")

This will create a file named hello.txt and then write the text hello.txt to it.

The example would be clearer if I had used Hello, World! as the sample file contents, like in the previous examples:

mf = ManagedFile("hello.txt")
with mf as the_file:
    the_file.write("Hello, World!")

I hope that clears up what determines the filename and the file contents (what gets written to the file) in the example :)

Yes it does. Thank you.

Got the idea behind context managers and how they mostly work but I’ve a specific concern about scoping in “with block”. You could access all the variables declared inside with block later. How does that really happen ?