You have learned about the context management protocol and how the `with` statement uses objects that implement `__enter__` and `__exit__` methods to manage resources. Now, put your understanding into practice by implementing a simple context manager class. Your class will simulate acquiring and releasing a resource by printing messages when entering and exiting the context block. This exercise reinforces the protocol and prepares you for more advanced custom context managers.


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_resource_manager_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        expected_acquire = normalize_text("Resource acquired.")
        expected_inside = normalize_text("Inside the context block.")
        expected_release = normalize_text("Resource released.")
        _dynamic_test(
            self,
            expected_acquire in output,
            'Output includes "Resource acquired." when entering the context',
            f'Expected message "Resource acquired." not found in output: {output}'
        )
        _dynamic_test(
            self,
            expected_inside in output,
            'Output includes "Inside the context block."',
            f'Expected message "Inside the context block." not found in output: {output}'
        )
        _dynamic_test(
            self,
            expected_release in output,
            'Output includes "Resource released." when exiting the context',
            f'Expected message "Resource released." not found in output: {output}'
        )
        # Check order: acquired -> inside -> released
        idx_acquire = output.find(expected_acquire)
        idx_inside = output.find(expected_inside)
        idx_release = output.find(expected_release)
        _dynamic_test(
            self,
            idx_acquire != -1 and idx_inside != -1 and idx_release != -1 and idx_acquire < idx_inside < idx_release,
            'Output messages are in the correct order',
            f'Expected order: acquire -> inside -> release, got: {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: Implement a Basic Context Manager

Solução