
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'milk':   [1, 0, 0, 1, 1],
            'bread':  [1, 1, 0, 1, 0],
            'eggs':   [0, 1, 1, 1, 0],
            'butter': [0, 0, 1, 1, 1],
        }
        self.df = pd.DataFrame(self.data)
        self.user_code = importlib.import_module('user_code')

    def test_returns_dataframe(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=2)
        _dynamic_test(
            self,
            isinstance(result, pd.DataFrame),
            "Function returns a DataFrame.",
            f"Expected a DataFrame, got {type(result)}."
        )

    def test_confidence_filtering(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.8, top_n=5)
        if result is not None and not result.empty:
            all_conf = result['confidence'] >= 0.8
            _dynamic_test(
                self,
                all(all_conf),
                "All rules have confidence >= min_confidence.",
                f"Some rules have confidence below min_confidence: {result['confidence'].tolist()}"
            )
        else:
            _dynamic_test(
                self,
                True,
                "No rules found with high confidence, as expected.",
                "No rules found with high confidence, as expected."
            )

    def test_sorted_by_lift_descending(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=4)
        if result is not None and not result.empty:
            lifts = result['lift'].tolist()
            sorted_lifts = sorted(lifts, reverse=True)
            _dynamic_test(
                self,
                lifts == sorted_lifts,
                "Rules are sorted by lift in descending order.",
                f"Rules are not sorted by lift descending: {lifts}"
            )
        else:
            _dynamic_test(
                self,
                True,
                "No rules found to sort, as expected.",
                "No rules found to sort, as expected."
            )

    def test_top_n_rules(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=2)
        n_rows = result.shape[0] if result is not None else 0
        _dynamic_test(
            self,
            n_rows <= 2,
            "Returned at most top_n rules.",
            f"Returned more than top_n rules: {n_rows}"
        )

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()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        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] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Master the skills needed to design, implement, and scale modern recommendation engines and transactional association models. Go from analyzing raw retail checkouts using classic algorithmic principles like Apriori and FP-Growth to building advanced personalization systems via collaborative filtering and matrix factorization. Learn how to engineer data pipelines that power modern digital storefront discovery layers and drive user engagement metrics.

Discover how to find hidden relationships within massive transactional data structures. Learn the core mathematical frameworks retail giants use to optimize shelf placement, inventory structures, and product bundling strategies.

What does the support metric represent in association rule mining?

Which metric best measures the strength of a rule beyond random chance?

In a market basket matrix, what does each row typically represent?

What is the main purpose of the Apriori algorithm?

How does pruning improve the efficiency of Apriori?

Which metric would you use to identify rules that are both frequent and strong?

Take your algorithmic knowledge to the next level by handling heavy corporate transaction data without memory crashes. Master high-performance compressed trees and discover how to eliminate commercial noise from rule patterns.

Get hands-on experience building the recommendation engines that power modern digital platforms. Learn how to look past product groupings to map historical user behaviors, ratings, and shared consumer habits.

Dive into the mathematical fundamentals of advanced machine learning models for sparse datasets. Learn how to uncover latent features hidden inside multi-dimensional user feedback data to accurately predict missing interactions.

Challenge: Extracting Basic Checkout Associations Using mlxtend

Solution