Summary  
This chapter covers how to implement a custom iterator that lazily generates the Fibonacci sequence by adhering to the iterator protocol.  

General domain of usage  
Algorithmic sequence generation


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

class TestTask(unittest.TestCase):
    def test_fibonacci_sequence_up_to_max(self):
        import user_code
        importlib.reload(user_code)
        fib_iter = user_code.FibonacciIterator(10)
        result = list(fib_iter)
        expected = [0, 1, 1, 2, 3, 5, 8]
        _dynamic_test(
            self,
            result == expected,
            f"Fibonacci numbers up to 10: {expected}",
            f"Expected Fibonacci up to 10: {expected}, got: {result}"
        )

    def test_stops_at_max(self):
        import user_code
        importlib.reload(user_code)
        fib_iter = user_code.FibonacciIterator(5)
        result = list(fib_iter)
        expected = [0, 1, 1, 2, 3, 5]
        _dynamic_test(
            self,
            result == expected,
            "Iterator stops at or before exceeding max_value",
            f"Expected: {expected}, got: {result}"
        )

    def test_stop_iteration_after_exhaustion(self):
        import user_code
        importlib.reload(user_code)
        fib_iter = user_code.FibonacciIterator(3)
        next(fib_iter)
        next(fib_iter)
        next(fib_iter)
        next(fib_iter)
        next(fib_iter)
        with self.assertRaises(StopIteration):
            next(fib_iter)
        _dynamic_test(
            self,
            True,
            "StopIteration is raised after sequence is exhausted",
            "StopIteration not raised after sequence exhausted"
        )

    def test_multiple_iterations_do_not_restart(self):
        import user_code
        importlib.reload(user_code)
        fib_iter = user_code.FibonacciIterator(8)
        vals1 = [next(fib_iter) for _ in range(3)]  # 0, 1, 1
        vals2 = list(fib_iter)  # should continue from 2
        expected1 = [0, 1, 1]
        expected2 = [2, 3, 5, 8]
        _dynamic_test(
            self,
            vals1 == expected1 and vals2 == expected2,
            "Iterator does not restart on multiple iterations",
            f"Expected {expected1} then {expected2}, got {vals1} then {vals2}"
        )

    def test_max_value_less_than_zero(self):
        import user_code
        importlib.reload(user_code)
        fib_iter = user_code.FibonacciIterator(-1)
        with self.assertRaises(StopIteration):
            next(fib_iter)
        _dynamic_test(
            self,
            True,
            "StopIteration is raised immediately for max_value < 0",
            "Iterator did not immediately raise StopIteration for max_value < 0"
        )

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 efficient iteration in Python by learning about iterators and generators. This course covers the creation, use, and advanced techniques of generators and iterators, with hands-on tasks and conceptual quizzes to reinforce your understanding.

Explore the fundamentals of Python's iteration protocol and learn how to create and use custom iterators.

Learn how to use generator functions and expressions for efficient, lazy iteration.

Master advanced generator features such as delegation, state management, and practical applications.

Challenge: Fibonacci Iterator

Lösning