codefix-env 0.2.1__py3-none-any.whl

codefix_env/tasks/easy.py

@@ -0,0 +1,244 @@
+"""
+Easy Tasks — Syntax errors, simple fixes, missing colons, wrong indentation.
+Each task has 3+ test cases and a clear hint.
+"""
+
+from __future__ import annotations
+
+from codefix_env.models import BugCategory, Difficulty, Task, TestCase
+
+EASY_TASKS: list[Task] = [
+    # ── Task E1: Missing return ──────────────────────────────────────────
+    Task(
+        id="easy-001-missing-return",
+        title="Missing Return Statement",
+        description="The function adds two numbers but never returns the result.",
+        difficulty=Difficulty.EASY,
+        bug_category=BugCategory.RETURN_BUG,
+        tags=["return", "arithmetic"],
+        max_steps=10,
+        buggy_code="""\
+def add_numbers(a, b):
+    result = a + b
+""",
+        solution_code="""\
+def add_numbers(a, b):
+    result = a + b
+    return result
+""",
+        hints=[
+            "The function computes a result but never sends it back to the caller.",
+            "You need a `return` statement at the end of the function.",
+        ],
+        test_cases=[
+            TestCase(name="test_positive", code="assert add_numbers(2, 3) == 5"),
+            TestCase(name="test_negative", code="assert add_numbers(-1, -4) == -5"),
+            TestCase(name="test_zero", code="assert add_numbers(0, 0) == 0"),
+            TestCase(name="test_float", code="assert add_numbers(1.5, 2.5) == 4.0"),
+        ],
+    ),
+    # ── Task E2: Wrong comparison operator ──────────────────────────────
+    Task(
+        id="easy-002-wrong-operator",
+        title="Wrong Comparison Operator",
+        description="The is_even function uses assignment `=` instead of equality `==`.",
+        difficulty=Difficulty.EASY,
+        bug_category=BugCategory.WRONG_OPERATOR,
+        tags=["operators", "boolean"],
+        max_steps=8,
+        buggy_code="""\
+def is_even(n):
+    return n % 2 = 0
+""",
+        solution_code="""\
+def is_even(n):
+    return n % 2 == 0
+""",
+        hints=[
+            "Python uses `==` for comparison, `=` is only for assignment.",
+            "Look at the return expression carefully — one character is wrong.",
+        ],
+        test_cases=[
+            TestCase(name="test_even_2", code="assert is_even(2) == True"),
+            TestCase(name="test_odd_3", code="assert is_even(3) == False"),
+            TestCase(name="test_zero", code="assert is_even(0) == True"),
+            TestCase(name="test_neg", code="assert is_even(-4) == True"),
+        ],
+    ),
+    # ── Task E3: Off-by-one in range ─────────────────────────────────────
+    Task(
+        id="easy-003-off-by-one-range",
+        title="Off-by-One in Range",
+        description="sum_to_n should sum numbers 1 through n inclusive, but misses the last number.",
+        difficulty=Difficulty.EASY,
+        bug_category=BugCategory.OFF_BY_ONE,
+        tags=["range", "loop", "off-by-one"],
+        max_steps=10,
+        buggy_code="""\
+def sum_to_n(n):
+    total = 0
+    for i in range(1, n):
+        total += i
+    return total
+""",
+        solution_code="""\
+def sum_to_n(n):
+    total = 0
+    for i in range(1, n + 1):
+        total += i
+    return total
+""",
+        hints=[
+            "Python's range(a, b) excludes b. Think about whether n should be included.",
+            "Change `range(1, n)` to include n itself.",
+        ],
+        test_cases=[
+            TestCase(name="test_sum_5", code="assert sum_to_n(5) == 15"),
+            TestCase(name="test_sum_10", code="assert sum_to_n(10) == 55"),
+            TestCase(name="test_sum_1", code="assert sum_to_n(1) == 1"),
+            TestCase(name="test_sum_0", code="assert sum_to_n(0) == 0"),
+        ],
+    ),
+    # ── Task E4: Wrong indentation ───────────────────────────────────────
+    Task(
+        id="easy-004-wrong-indent",
+        title="Wrong Indentation in Loop",
+        description="The return statement is inside the loop — it exits too early.",
+        difficulty=Difficulty.EASY,
+        bug_category=BugCategory.LOGIC,
+        tags=["indentation", "loop"],
+        max_steps=10,
+        buggy_code="""\
+def find_max(numbers):
+    max_val = numbers[0]
+    for num in numbers:
+        if num > max_val:
+            max_val = num
+        return max_val
+""",
+        solution_code="""\
+def find_max(numbers):
+    max_val = numbers[0]
+    for num in numbers:
+        if num > max_val:
+            max_val = num
+    return max_val
+""",
+        hints=[
+            "The return statement is indented inside the for loop — it exits after checking the first element.",
+            "De-indent `return max_val` by one level so it runs after the loop finishes.",
+        ],
+        test_cases=[
+            TestCase(name="test_basic", code="assert find_max([3, 1, 4, 1, 5, 9]) == 9"),
+            TestCase(name="test_sorted", code="assert find_max([1, 2, 3, 4, 5]) == 5"),
+            TestCase(name="test_single", code="assert find_max([42]) == 42"),
+            TestCase(name="test_negative", code="assert find_max([-5, -1, -3]) == -1"),
+        ],
+    ),
+    # ── Task E5: Missing colon ───────────────────────────────────────────
+    Task(
+        id="easy-005-missing-colon",
+        title="Missing Colon in Function Definition",
+        description="A function definition is missing its colon, causing a SyntaxError.",
+        difficulty=Difficulty.EASY,
+        bug_category=BugCategory.SYNTAX,
+        tags=["syntax", "colon"],
+        max_steps=8,
+        buggy_code="""\
+def greet(name)
+    return f"Hello, {name}!"
+""",
+        solution_code="""\
+def greet(name):
+    return f"Hello, {name}!"
+""",
+        hints=[
+            "Every `def` statement must end with a colon `:`.",
+        ],
+        test_cases=[
+            TestCase(name="test_hello", code='assert greet("Alice") == "Hello, Alice!"'),
+            TestCase(name="test_empty", code='assert greet("") == "Hello, !"'),
+        ],
+    ),
+    # ── Task E6: String not converted to int ────────────────────────────
+    Task(
+        id="easy-006-type-mismatch",
+        title="Type Mismatch — String + Integer",
+        description="The function tries to add a string to an integer without converting.",
+        difficulty=Difficulty.EASY,
+        bug_category=BugCategory.TYPE_ERROR,
+        tags=["type", "casting"],
+        max_steps=10,
+        buggy_code="""\
+def add_age(base_age, years_str):
+    return base_age + years_str
+""",
+        solution_code="""\
+def add_age(base_age, years_str):
+    return base_age + int(years_str)
+""",
+        hints=[
+            "years_str is a string. You need to convert it to int before adding.",
+            "Use `int(years_str)` to convert.",
+        ],
+        test_cases=[
+            TestCase(name="test_basic", code='assert add_age(25, "5") == 30'),
+            TestCase(name="test_zero", code='assert add_age(30, "0") == 30'),
+            TestCase(name="test_large", code='assert add_age(0, "100") == 100'),
+        ],
+    ),
+    # ── Task E7: Wrong list index ────────────────────────────────────────
+    Task(
+        id="easy-007-wrong-index",
+        title="Wrong List Index",
+        description="get_last should return the last element but uses index 0.",
+        difficulty=Difficulty.EASY,
+        bug_category=BugCategory.INDEX_ERROR,
+        tags=["list", "index"],
+        max_steps=8,
+        buggy_code="""\
+def get_last(items):
+    return items[0]
+""",
+        solution_code="""\
+def get_last(items):
+    return items[-1]
+""",
+        hints=[
+            "Python index -1 refers to the last element of a list.",
+        ],
+        test_cases=[
+            TestCase(name="test_basic", code="assert get_last([1, 2, 3]) == 3"),
+            TestCase(name="test_single", code="assert get_last(['x']) == 'x'"),
+            TestCase(name="test_strings", code="assert get_last(['a', 'b', 'c']) == 'c'"),
+        ],
+    ),
+    # ── Task E8: Boolean logic inverted ─────────────────────────────────
+    Task(
+        id="easy-008-inverted-bool",
+        title="Inverted Boolean Condition",
+        description="is_adult returns True for ages under 18 and False for adults.",
+        difficulty=Difficulty.EASY,
+        bug_category=BugCategory.LOGIC,
+        tags=["boolean", "condition"],
+        max_steps=8,
+        buggy_code="""\
+def is_adult(age):
+    return age < 18
+""",
+        solution_code="""\
+def is_adult(age):
+    return age >= 18
+""",
+        hints=[
+            "The condition is backwards — an adult is someone 18 or older.",
+            "Change `<` to `>=`.",
+        ],
+        test_cases=[
+            TestCase(name="test_adult", code="assert is_adult(18) == True"),
+            TestCase(name="test_child", code="assert is_adult(10) == False"),
+            TestCase(name="test_exactly", code="assert is_adult(17) == False"),
+            TestCase(name="test_old", code="assert is_adult(65) == True"),
+        ],
+    ),
+]

codefix_env/tasks/hard.py

@@ -0,0 +1,430 @@
+"""
+Hard Tasks — Multi-function bugs, complex algorithms, subtle logic errors.
+These tasks require understanding interactions between multiple functions.
+"""
+
+from __future__ import annotations
+
+from codefix_env.models import BugCategory, Difficulty, Task, TestCase
+
+HARD_TASKS: list[Task] = [
+    # ── Task H1: LRU Cache — wrong eviction ─────────────────────────────
+    Task(
+        id="hard-001-lru-cache",
+        title="LRU Cache — Wrong Eviction Policy",
+        description=(
+            "A manual LRU cache implementation evicts the most recently used item "
+            "instead of the least recently used. The `get` method also fails to update "
+            "recency on a cache hit."
+        ),
+        difficulty=Difficulty.HARD,
+        bug_category=BugCategory.MULTI_FUNCTION,
+        tags=["lru", "cache", "data-structures", "ordered-dict"],
+        max_steps=25,
+        buggy_code="""\
+from collections import OrderedDict
+
+class LRUCache:
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.cache = OrderedDict()
+
+    def get(self, key: int) -> int:
+        if key not in self.cache:
+            return -1
+        # BUG: does not move to end (not updating recency)
+        return self.cache[key]
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            self.cache.move_to_end(key)
+        self.cache[key] = value
+        if len(self.cache) > self.capacity:
+            self.cache.popitem(last=True)  # BUG: evicts MRU not LRU
+""",
+        solution_code="""\
+from collections import OrderedDict
+
+class LRUCache:
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.cache = OrderedDict()
+
+    def get(self, key: int) -> int:
+        if key not in self.cache:
+            return -1
+        self.cache.move_to_end(key)  # FIX: mark as recently used
+        return self.cache[key]
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            self.cache.move_to_end(key)
+        self.cache[key] = value
+        if len(self.cache) > self.capacity:
+            self.cache.popitem(last=False)  # FIX: evict LRU (first item)
+""",
+        hints=[
+            "When `get` is called, the accessed item should become the most recently used.",
+            "To evict the *least* recently used, use `popitem(last=False)` — removes the first (oldest) item.",
+            "Both `get` and `put` have bugs. Fix them independently.",
+        ],
+        test_cases=[
+            TestCase(
+                name="test_basic_put_get",
+                code="""\
+cache = LRUCache(2)
+cache.put(1, 1)
+cache.put(2, 2)
+assert cache.get(1) == 1
+""",
+            ),
+            TestCase(
+                name="test_eviction",
+                code="""\
+cache = LRUCache(2)
+cache.put(1, 1)
+cache.put(2, 2)
+cache.get(1)       # 1 is now MRU
+cache.put(3, 3)    # evicts 2 (LRU)
+assert cache.get(2) == -1
+assert cache.get(3) == 3
+""",
+            ),
+            TestCase(
+                name="test_update_existing",
+                code="""\
+cache = LRUCache(2)
+cache.put(1, 1)
+cache.put(2, 2)
+cache.put(1, 10)   # update key 1
+assert cache.get(1) == 10
+""",
+            ),
+            TestCase(
+                name="test_miss",
+                code="""\
+cache = LRUCache(1)
+assert cache.get(99) == -1
+""",
+            ),
+        ],
+    ),
+    # ── Task H2: Graph BFS — wrong visited tracking ─────────────────────
+    Task(
+        id="hard-002-graph-bfs",
+        title="Graph BFS — Infinite Loop from Wrong Visited Tracking",
+        description=(
+            "BFS adds nodes to `visited` after dequeuing instead of before enqueuing, "
+            "causing nodes to be visited multiple times and potentially looping."
+        ),
+        difficulty=Difficulty.HARD,
+        bug_category=BugCategory.ALGORITHM_BUG,
+        tags=["graph", "bfs", "visited"],
+        max_steps=25,
+        buggy_code="""\
+from collections import deque
+
+def bfs(graph, start):
+    visited = set()
+    queue = deque([start])
+    order = []
+    while queue:
+        node = queue.popleft()
+        if node not in visited:
+            visited.add(node)
+            order.append(node)
+            for neighbour in graph.get(node, []):
+                queue.append(neighbour)  # BUG: should check visited before enqueuing
+    return order
+""",
+        solution_code="""\
+from collections import deque
+
+def bfs(graph, start):
+    visited = set([start])
+    queue = deque([start])
+    order = []
+    while queue:
+        node = queue.popleft()
+        order.append(node)
+        for neighbour in graph.get(node, []):
+            if neighbour not in visited:
+                visited.add(neighbour)
+                queue.append(neighbour)
+    return order
+""",
+        hints=[
+            "Nodes should be added to `visited` when they are *enqueued*, not when dequeued.",
+            "Initialise `visited` with the start node.",
+        ],
+        test_cases=[
+            TestCase(
+                name="test_linear",
+                code="""\
+g = {0: [1], 1: [2], 2: [3], 3: []}
+assert bfs(g, 0) == [0, 1, 2, 3]
+""",
+            ),
+            TestCase(
+                name="test_branching",
+                code="""\
+g = {0: [1, 2], 1: [3], 2: [3], 3: []}
+result = bfs(g, 0)
+assert result[0] == 0
+assert set(result) == {0, 1, 2, 3}
+assert len(result) == 4   # no duplicates
+""",
+            ),
+            TestCase(
+                name="test_single_node",
+                code="""\
+g = {0: []}
+assert bfs(g, 0) == [0]
+""",
+            ),
+        ],
+    ),
+    # ── Task H3: Decorator — wrong wraps usage ──────────────────────────
+    Task(
+        id="hard-003-decorator-bug",
+        title="Decorator — Lost Function Metadata",
+        description=(
+            "A timing decorator is missing `@functools.wraps(func)`, which causes the "
+            "wrapped function to lose its `__name__` and `__doc__`, breaking introspection."
+        ),
+        difficulty=Difficulty.HARD,
+        bug_category=BugCategory.MULTI_FUNCTION,
+        tags=["decorator", "functools", "wraps", "metadata"],
+        max_steps=15,
+        buggy_code="""\
+import functools
+import time
+
+def timer(func):
+    def wrapper(*args, **kwargs):   # BUG: missing @functools.wraps(func)
+        start = time.perf_counter()
+        result = func(*args, **kwargs)
+        elapsed = time.perf_counter() - start
+        return result
+    return wrapper
+
+@timer
+def compute(n):
+    \"\"\"Compute n^2.\"\"\"
+    return n * n
+""",
+        solution_code="""\
+import functools
+import time
+
+def timer(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.perf_counter()
+        result = func(*args, **kwargs)
+        elapsed = time.perf_counter() - start
+        return result
+    return wrapper
+
+@timer
+def compute(n):
+    \"\"\"Compute n^2.\"\"\"
+    return n * n
+""",
+        hints=[
+            "Without `@functools.wraps(func)`, the wrapper function replaces the original's metadata.",
+            "Add `@functools.wraps(func)` directly above `def wrapper`.",
+        ],
+        test_cases=[
+            TestCase(name="test_result", code="assert compute(5) == 25"),
+            TestCase(name="test_name", code='assert compute.__name__ == "compute"'),
+            TestCase(name="test_doc", code='assert compute.__doc__ == "Compute n^2."'),
+        ],
+    ),
+    # ── Task H4: Stack with linked list — pop bug ───────────────────────
+    Task(
+        id="hard-004-linked-stack",
+        title="Linked List Stack — Pop Returns Wrong Value",
+        description=(
+            "A stack implemented with a linked list has a `pop` method that updates the head "
+            "pointer but returns the new head's value instead of the removed node's value."
+        ),
+        difficulty=Difficulty.HARD,
+        bug_category=BugCategory.MULTI_FUNCTION,
+        tags=["linked-list", "stack", "data-structures"],
+        max_steps=25,
+        buggy_code="""\
+class Node:
+    def __init__(self, val):
+        self.val = val
+        self.next = None
+
+class Stack:
+    def __init__(self):
+        self.head = None
+        self.size = 0
+
+    def push(self, val):
+        node = Node(val)
+        node.next = self.head
+        self.head = node
+        self.size += 1
+
+    def pop(self):
+        if self.head is None:
+            raise IndexError("pop from empty stack")
+        self.head = self.head.next   # BUG: loses the removed node before capturing value
+        self.size -= 1
+        return self.head.val if self.head else None
+
+    def peek(self):
+        if self.head is None:
+            raise IndexError("peek from empty stack")
+        return self.head.val
+
+    def is_empty(self):
+        return self.head is None
+""",
+        solution_code="""\
+class Node:
+    def __init__(self, val):
+        self.val = val
+        self.next = None
+
+class Stack:
+    def __init__(self):
+        self.head = None
+        self.size = 0
+
+    def push(self, val):
+        node = Node(val)
+        node.next = self.head
+        self.head = node
+        self.size += 1
+
+    def pop(self):
+        if self.head is None:
+            raise IndexError("pop from empty stack")
+        removed_val = self.head.val   # FIX: capture value before moving head
+        self.head = self.head.next
+        self.size -= 1
+        return removed_val
+
+    def peek(self):
+        if self.head is None:
+            raise IndexError("peek from empty stack")
+        return self.head.val
+
+    def is_empty(self):
+        return self.head is None
+""",
+        hints=[
+            "You need to save the current head's value before moving `self.head` to the next node.",
+            "Store `removed_val = self.head.val` before updating `self.head`.",
+        ],
+        test_cases=[
+            TestCase(
+                name="test_push_pop",
+                code="""\
+s = Stack()
+s.push(1); s.push(2); s.push(3)
+assert s.pop() == 3
+assert s.pop() == 2
+assert s.pop() == 1
+""",
+            ),
+            TestCase(
+                name="test_peek",
+                code="""\
+s = Stack()
+s.push(42)
+assert s.peek() == 42
+assert s.size == 1
+""",
+            ),
+            TestCase(
+                name="test_empty_pop",
+                code="""\
+s = Stack()
+try:
+    s.pop()
+    assert False, "Should have raised"
+except IndexError:
+    pass
+""",
+            ),
+            TestCase(
+                name="test_size_tracking",
+                code="""\
+s = Stack()
+s.push(1); s.push(2)
+s.pop()
+assert s.size == 1
+""",
+            ),
+        ],
+    ),
+    # ── Task H5: Tokenizer — wrong string parsing ────────────────────────
+    Task(
+        id="hard-005-tokenizer",
+        title="Mini Tokenizer — String Literal Handling Bug",
+        description=(
+            "A simple expression tokenizer fails on string literals because it doesn't "
+            "handle quoted strings — it splits on spaces inside quotes."
+        ),
+        difficulty=Difficulty.HARD,
+        bug_category=BugCategory.MULTI_FUNCTION,
+        tags=["parsing", "tokenizer", "string-literals"],
+        max_steps=25,
+        buggy_code="""\
+def tokenize(expr):
+    \"\"\"Tokenize a simple expression into a list of tokens.\"\"\"
+    tokens = []
+    current = ''
+    for ch in expr:
+        if ch == ' ':
+            if current:
+                tokens.append(current)
+                current = ''
+        else:
+            current += ch
+    if current:
+        tokens.append(current)
+    return tokens
+""",
+        solution_code="""\
+def tokenize(expr):
+    \"\"\"Tokenize a simple expression into a list of tokens.\"\"\"
+    tokens = []
+    current = ''
+    in_string = False
+    for ch in expr:
+        if ch == '\"' :
+            in_string = not in_string
+            current += ch
+        elif ch == ' ' and not in_string:
+            if current:
+                tokens.append(current)
+                current = ''
+        else:
+            current += ch
+    if current:
+        tokens.append(current)
+    return tokens
+""",
+        hints=[
+            "The tokenizer doesn't track whether it's inside a quoted string.",
+            'Add an `in_string` flag that toggles when a `"` is encountered.',
+            "Only split on spaces when `in_string` is False.",
+        ],
+        test_cases=[
+            TestCase(name="test_simple", code='assert tokenize("a + b") == ["a", "+", "b"]'),
+            TestCase(
+                name="test_string_literal",
+                code="assert tokenize('print \"hello world\"') == ['print', '\"hello world\"']",
+            ),
+            TestCase(name="test_no_spaces", code='assert tokenize("abc") == ["abc"]'),
+            TestCase(name="test_empty", code='assert tokenize("") == []'),
+        ],
+    ),
+]