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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")
        self.data = [
            {'sales': 100, 'timestamp': '2024-05-01'},
            {'sales': 200, 'timestamp': '2024-05-02'},
            {'sales': 150, 'timestamp': '2024-05-08'},
            {'sales': 300, 'timestamp': '2024-05-10'},
            {'sales': 120, 'timestamp': '2024-05-15'},
            {'sales': 180, 'timestamp': '2024-05-16'},
            {'sales': 220, 'timestamp': '2024-05-22'},
            {'sales': 140, 'timestamp': '2024-05-23'},
        ]

    def test_timestamps_converted(self):
        # Check that timestamps are converted to datetime
        result = self.user_code.weekly_sales_summary(self.data)
        df = pd.DataFrame(self.data)
        df['timestamp'] = pd.to_datetime(df['timestamp'])
        _dynamic_test(
            self,
            pd.api.types.is_datetime64_any_dtype(df['timestamp']),
            "Timestamps are converted to pandas datetime objects.",
            "Timestamps are not converted to pandas datetime objects."
        )

    def test_week_column_created(self):
        # Check that week column is created and is present in the result
        result = self.user_code.weekly_sales_summary(self.data)
        _dynamic_test(
            self,
            isinstance(result, pd.DataFrame) and 'week' in result.columns,
            "Week column is present in the summary DataFrame.",
            "Week column is missing from the summary DataFrame."
        )

    def test_grouped_and_summed_by_week(self):
        # Check that sales are summed per week correctly
        result = self.user_code.weekly_sales_summary(self.data)
        # Manually compute expected sums
        # May 1-2: 100+200 = 300 (week starting 2024-04-29)
        # May 8,10: 150+300 = 450 (week starting 2024-05-06)
        # May 15,16: 120+180 = 300 (week starting 2024-05-13)
        # May 22,23: 220+140 = 360 (week starting 2024-05-20)
        expected = pd.DataFrame({
            'week': [pd.Timestamp('2024-04-29'), pd.Timestamp('2024-05-06'), pd.Timestamp('2024-05-13'), pd.Timestamp('2024-05-20')],
            'sales': [300, 450, 300, 360]
        })
        # Merge to compare
        merged = pd.merge(result, expected, on='week', how='outer', suffixes=('', '_expected'))
        correct = all(merged['sales'] == merged['sales_expected'])
        _dynamic_test(
            self,
            correct,
            "Sales values are correctly summed for each week.",
            f"Sales values are incorrect. Got: {result}, Expected: {expected}"
        )

    def test_returns_dataframe(self):
        # Check that the function returns a DataFrame
        result = self.user_code.weekly_sales_summary(self.data)
        _dynamic_test(
            self,
            isinstance(result, pd.DataFrame),
            "The function returns a pandas DataFrame.",
            f"The function does not return a pandas DataFrame. Got: {type(result)}"
        )

    def test_multiple_records_same_week(self):
        # All records in same week
        test_data = [
            {'sales': 10, 'timestamp': '2024-05-01'},
            {'sales': 20, 'timestamp': '2024-05-02'},
            {'sales': 30, 'timestamp': '2024-05-03'},
        ]
        result = self.user_code.weekly_sales_summary(test_data)
        expected_sum = 60
        _dynamic_test(
            self,
            len(result) == 1 and result.iloc[0]['sales'] == expected_sum,
            "Multiple records in the same week are summed correctly.",
            f"Expected sales sum {expected_sum}, got {result.iloc[0]['sales']}"
        )

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

Advance your Python automation skills by learning to generate analytical summaries, business reports, and visual dashboards automatically. This course guides you through practical workflows for automating data analysis, reporting, and visualization tasks using Python, pandas, matplotlib, and seaborn.

Learn to automate the generation of analytical summaries, business reports, and visual dashboards using Python. Alternate between concept introduction and hands-on automation tasks for real-world reporting scenarios.

Challenge: Generate Weekly Summary Table

Ratkaisu