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

class TestTask(unittest.TestCase):
    def test_start_time_recorded(self):
        import user_code
        importlib.reload(user_code)
        timer = user_code.Timer()
        timer.__enter__()
        _dynamic_test(
            self,
            hasattr(timer, 'start_time') and isinstance(timer.start_time, float),
            "Start time is recorded as a float on __enter__",
            f"Expected 'start_time' attribute as float, got: {getattr(timer, 'start_time', None)}",
        )

    def test_end_time_recorded(self):
        import user_code
        importlib.reload(user_code)
        timer = user_code.Timer()
        timer.__enter__()
        time.sleep(0.01)
        timer.__exit__(None, None, None)
        _dynamic_test(
            self,
            hasattr(timer, 'end_time') and isinstance(timer.end_time, float),
            "End time is recorded as a float on __exit__",
            f"Expected 'end_time' attribute as float, got: {getattr(timer, 'end_time', None)}",
        )

    def test_elapsed_time_calculated(self):
        import user_code
        importlib.reload(user_code)
        timer = user_code.Timer()
        timer.__enter__()
        time.sleep(0.01)
        timer.__exit__(None, None, None)
        elapsed = getattr(timer, 'elapsed', None)
        _dynamic_test(
            self,
            isinstance(elapsed, float) and elapsed >= 0.01,
            "Elapsed time is calculated and is at least the sleep duration",
            f"Expected elapsed >= 0.01, got: {elapsed}",
        )

    def test_print_elapsed_time(self):
        import user_code
        importlib.reload(user_code)
        timer = user_code.Timer()
        timer.__enter__()
        time.sleep(0.01)
        f = io.StringIO()
        with redirect_stdout(f):
            timer.__exit__(None, None, None)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "elapsed time:" in output and "seconds" in output,
            "Prints elapsed time in seconds on exit",
            f"Expected output containing 'Elapsed time:' and 'seconds', 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: Timer Context Manager

Solución