When you implement a countdown timer, you usually want to display each number at regular intervals, such as every second. In a synchronous program, using a loop with `time.sleep` would block the entire program, preventing any other tasks from running until the countdown finishes. However, with asynchronous execution using `asyncio`, you can create a timer that waits between numbers without blocking the rest of your program. This means your application can remain responsive, handle user input, or perform other background tasks while the countdown proceeds. **Async countdown timers** are especially useful in interactive applications, games, or any scenario where you want to manage time-based events smoothly without freezing the whole program.


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

class TestTask(unittest.TestCase):
    def test_countdown_prints_correct_numbers(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        # Run the countdown with 3 for faster test
        async def runner():
            with redirect_stdout(f):
                await user_code.async_countdown(3)
        asyncio.run(runner())
        output = f.getvalue().strip().split('\\n')
        expected = ['3', '2', '1', '0']
        _dynamic_test(
            self,
            output == expected,
            f"Countdown prints numbers from 3 to 0 in order.",
            f"Expected output {expected}, got {output}.",
        )

    def test_countdown_includes_zero_and_start(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        # Use 1 as starting number
        async def runner():
            with redirect_stdout(f):
                await user_code.async_countdown(1)
        asyncio.run(runner())
        output = f.getvalue().strip().split('\\n')
        expected = ['1', '0']
        _dynamic_test(
            self,
            output == expected,
            "Countdown includes both starting number and zero.",
            f"Expected output {expected}, got {output}.",
        )

    def test_countdown_handles_zero(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        async def runner():
            with redirect_stdout(f):
                await user_code.async_countdown(0)
        asyncio.run(runner())
        output = f.getvalue().strip().split('\\n')
        expected = ['0']
        _dynamic_test(
            self,
            output == expected,
            "Countdown handles zero as input.",
            f"Expected output {expected}, got {output}.",
        )

    def test_sleep_called_between_prints(self):
        import user_code
        importlib.reload(user_code)
        import types
        sleep_calls = []
        # Patch asyncio.sleep to record calls
        async def fake_sleep(secs):
            sleep_calls.append(secs)
        orig_sleep = asyncio.sleep
        setattr(asyncio, 'sleep', fake_sleep)
        try:
            async def runner():
                await user_code.async_countdown(2)
            asyncio.run(runner())
        finally:
            setattr(asyncio, 'sleep', orig_sleep)
        expected = [1, 1, 1]
        _dynamic_test(
            self,
            sleep_calls == expected,
            "asyncio.sleep(1) called between each print.",
            f"Expected sleep calls {expected}, got {sleep_calls}.",
        )

    def test_countdown_works_for_large_number(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        async def runner():
            with redirect_stdout(f):
                await user_code.async_countdown(5)
        asyncio.run(runner())
        output = f.getvalue().strip().split('\\n')
        expected = ['5', '4', '3', '2', '1', '0']
        _dynamic_test(
            self,
            output == expected,
            "Countdown works for a larger starting number.",
            f"Expected output {expected}, 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

A beginner-friendly course introducing Python's asyncio library, focusing on asynchronous programming concepts, practical usage, and hands-on challenges with real-world scenarios.

Introduction to asynchronous programming and the basics of Python's asyncio library.

Delve into creating, running, and managing multiple asyncio tasks concurrently.

Explore more advanced asyncio patterns such as task cancellation and error handling.

Challenge: Async Countdown Timer

Oplossing

Challenge: Async Countdown Timer

Oplossing