When managing resources in Python, you sometimes need to coordinate multiple context managers at once. This is common when you want to ensure that several resources—such as files, timers, or configuration changes—are managed safely and efficiently, even if an error occurs. You can nest context managers using multiple `with` statements, or use a single `with` statement and separate them with commas. In this challenge, you will practice combining both **class-based** and **generator-based** context managers to manage two resources at the same time. This will help you understand how Python handles entering and exiting each context, and how exceptions are propagated and handled.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_context_managers_used_correctly(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.use_resources()
        output = normalize_text(f.getvalue())
        expected_lines = [
            "dummyresource acquired",
            "flag set",
            "inside nested context managers",
            "flag cleared",
            "dummyresource released"
        ]
        for line in expected_lines:
            _dynamic_test(
                self,
                line in output,
                f"Output includes line: {line}",
                f"Expected output line '{line}' not found in: '{output}'",
            )
        # Check order of context manager entry/exit
        order = [
            output.find("dummyresource acquired"),
            output.find("flag set"),
            output.find("inside nested context managers"),
            output.find("flag cleared"),
            output.find("dummyresource released")
        ]
        _dynamic_test(
            self,
            all(o != -1 for o in order) and order == sorted(order),
            "Context manager entry/exit order is correct",
            f"Context manager output order is incorrect: {order}"
        )

    def test_cleanup_on_exception(self):
        import user_code
        importlib.reload(user_code)
        # Patch use_resources to raise an exception inside nested block
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        # Replace use_resources with one that raises
        code = code.replace(
            "print(\\"Inside nested context managers\\")",
            "raise RuntimeError('forced error')"
        )
        ns = {}
        f = io.StringIO()
        try:
            with redirect_stdout(f):
                exec(code, ns)
                ns['use_resources']()
        except RuntimeError:
            pass
        output = normalize_text(f.getvalue())
        # Even with exception, cleanups should occur
        _dynamic_test(
            self,
            "flag cleared" in output and "dummyresource released" in output,
            "Both context managers cleanup after exception",
            f"Cleanup messages missing after exception: {output}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Master the art of resource management in Python by learning how to use and create context managers. This course covers the underlying protocol, practical applications, and advanced techniques for robust and efficient code.

Explore the fundamentals of context managers, their protocol, and how they simplify resource management in Python.

Delve into creating your own context managers using both classes and generator functions.

Solidify your understanding by tackling practical tasks that require context managers in various scenarios.

Challenge: Nested Context Managers

Oplossing

Awesome!

Challenge: Nested Context Managers

Oplossing