You have now seen how decorators can enhance functions with additional behavior, such as **logging**, **timing**, or **formatting**. Sometimes, you may want to make your functions more robust by automatically retrying them when they fail due to exceptions. This is especially useful when dealing with unreliable operations, like network requests or file I/O, where a temporary glitch might cause a function to fail even though retrying would succeed. In this challenge, you will implement a decorator that retries a function up to three times if it raises an exception, and only gives up if all attempts fail.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import types

class TestTask(unittest.TestCase):
    def test_success_on_first_try(self):
        import user_code
        importlib.reload(user_code)
        def always_succeeds():
            return "ok"
        decorated = user_code.retry_decorator(always_succeeds)
        result = decorated()
        _dynamic_test(
            self,
            result == "ok",
            "Decorator returns result if function succeeds on first try.",
            f"Expected 'ok', got {result}",
        )

    def test_success_on_second_try(self):
        import user_code
        importlib.reload(user_code)
        state = {"failures": 1}
        def fails_once():
            if state["failures"] > 0:
                state["failures"] -= 1
                raise ValueError("fail once")
            return "ok"
        decorated = user_code.retry_decorator(fails_once)
        result = decorated()
        _dynamic_test(
            self,
            result == "ok",
            "Decorator retries and returns result if function succeeds on second try.",
            f"Expected 'ok', got {result}",
        )

    def test_success_on_third_try(self):
        import user_code
        importlib.reload(user_code)
        state = {"failures": 2}
        def fails_twice():
            if state["failures"] > 0:
                state["failures"] -= 1
                raise RuntimeError("fail twice")
            return "ok"
        decorated = user_code.retry_decorator(fails_twice)
        result = decorated()
        _dynamic_test(
            self,
            result == "ok",
            "Decorator retries and returns result if function succeeds on third try.",
            f"Expected 'ok', got {result}",
        )

    def test_raises_after_three_failures(self):
        import user_code
        importlib.reload(user_code)
        def always_fails():
            raise KeyError("fail always")
        decorated = user_code.retry_decorator(always_fails)
        try:
            decorated()
            outcome = False
        except KeyError as e:
            outcome = str(e) == "'fail always'" or str(e) == "fail always"
        except Exception as e:
            outcome = False
        _dynamic_test(
            self,
            outcome,
            "Decorator re-raises last exception after three failed attempts.",
            "Expected KeyError to be raised after three failures.",
        )

    def test_preserves_args_kwargs(self):
        import user_code
        importlib.reload(user_code)
        def echo(a, b=2):
            return a + b
        decorated = user_code.retry_decorator(echo)
        result = decorated(3, b=4)
        _dynamic_test(
            self,
            result == 7,
            "Decorator preserves *args and **kwargs when calling function.",
            f"Expected 7, got {result}",
        )

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 Python decorators, from foundational concepts to advanced applications. This course guides you through the mechanics, use cases, and best practices of decorators, empowering you to write more expressive and reusable Python code.

Explore the foundational concepts of Python decorators, including their syntax, how they work, and why they're useful.

Delve deeper into decorators by exploring arguments, chaining, and built-in decorators.

Explore Python's built-in decorators and practical use cases for custom decorators.

Apply your knowledge of decorators in a series of hands-on coding challenges.

Challenge: Retry Decorator

Oplossing

Challenge: Retry Decorator

Oplossing