In this challenge, you will apply your understanding of generator-based context managers using the `contextlib.contextmanager` decorator. Your goal is to create a context manager that can temporarily change the value of a variable during the context and restore its original value afterward. This is a common pattern when you need to alter global or module-level state in a controlled and reversible way.


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_value_set_inside_context(self):
        import user_code
        importlib.reload(user_code)
        user_code.some_value = 10
        f = io.StringIO()
        with redirect_stdout(f):
            with user_code.temporary_value(42):
                print(user_code.some_value)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "42" in output,
            "some_value is set to new_value inside the context",
            f"Expected '42' inside context, got: '{output}'",
        )

    def test_value_restored_after_context(self):
        import user_code
        importlib.reload(user_code)
        user_code.some_value = 123
        with user_code.temporary_value(77):
            pass
        actual = user_code.some_value
        _dynamic_test(
            self,
            actual == 123,
            "some_value is restored after the context exits",
            f"Expected 123 after context, got: {actual}",
        )

    def test_value_restored_on_exception(self):
        import user_code
        importlib.reload(user_code)
        user_code.some_value = 55
        class CustomError(Exception):
            pass
        try:
            with user_code.temporary_value(888):
                raise CustomError("fail inside context")
        except CustomError:
            pass
        actual = user_code.some_value
        _dynamic_test(
            self,
            actual == 55,
            "some_value is restored after exception in context",
            f"Expected 55 after exception, got: {actual}",
        )

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: Generator-based Context Manager

Solution