Consistent and automated reporting is essential for marketing teams to track progress, identify trends, and make informed decisions quickly. Manual reporting can be time-consuming and prone to errors, especially when dealing with large datasets and multiple channels. Automating the process not only saves time but also ensures accuracy and repeatability, allowing marketers to focus on strategy rather than data wrangling. By leveraging Python, you can streamline the generation of weekly marketing reports, providing clear and actionable insights for your team.


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.data = {
            'channel': ['Email', 'Email', 'Social', 'Social', 'Search', 'Search'],
            'impressions': [1000, 1200, 2500, 2600, 4000, 4200],
            'clicks': [50, 60, 200, 210, 300, 320],
            'conversions': [5, 6, 20, 21, 30, 32],
            'spend': [100.0, 110.0, 250.0, 260.0, 400.0, 420.0]
        }
        self.df = pd.DataFrame(self.data)
        self.expected_channels = set(['Email', 'Social', 'Search'])
        self.expected_totals = {
            'Email': {'impressions': 2200, 'clicks': 110, 'conversions': 11, 'spend': 210.0},
            'Social': {'impressions': 5100, 'clicks': 410, 'conversions': 41, 'spend': 510.0},
            'Search': {'impressions': 8200, 'clicks': 620, 'conversions': 62, 'spend': 820.0},
        }
        self.expected_averages = {
            'Email': {'impressions': 1100.0, 'clicks': 55.0, 'conversions': 5.5, 'spend': 105.0},
            'Social': {'impressions': 2550.0, 'clicks': 205.0, 'conversions': 20.5, 'spend': 255.0},
            'Search': {'impressions': 4100.0, 'clicks': 310.0, 'conversions': 31.0, 'spend': 410.0},
        }

    def test_report_contains_all_channels(self):
        import user_code
        importlib.reload(user_code)
        report = user_code.generate_weekly_marketing_report(self.df)
        found_channels = set()
        for channel in self.expected_channels:
            if f"Channel: {channel}" in report:
                found_channels.add(channel)
        _dynamic_test(
            self,
            found_channels == self.expected_channels,
            "Report includes all channels",
            f"Missing channels in report: {self.expected_channels - found_channels}"
        )

    def test_totals_for_each_channel(self):
        import user_code
        importlib.reload(user_code)
        report = user_code.generate_weekly_marketing_report(self.df)
        for channel, totals in self.expected_totals.items():
            for metric, value in totals.items():
                if metric == 'spend':
                    expected_str = f"Total Spend: ${value:.2f}"
                else:
                    expected_str = f"Total {metric.capitalize()}: {int(value)}"
                _dynamic_test(
                    self,
                    expected_str in report,
                    f"Correct total {metric} for {channel}",
                    f"Report missing or incorrect total {metric} for {channel}: expected '{expected_str}'"
                )

    def test_averages_for_each_channel(self):
        import user_code
        importlib.reload(user_code)
        report = user_code.generate_weekly_marketing_report(self.df)
        for channel, avgs in self.expected_averages.items():
            for metric, value in avgs.items():
                if metric == 'spend':
                    expected_str = f"Avg Spend: ${value:.2f}"
                elif metric == 'conversions':
                    expected_str = f"Avg Conversions: {value:.2f}"
                else:
                    expected_str = f"Avg {metric.capitalize()}: {value:.1f}"
                _dynamic_test(
                    self,
                    expected_str in report,
                    f"Correct average {metric} for {channel}",
                    f"Report missing or incorrect average {metric} for {channel}: expected '{expected_str}'"
                )

    def test_report_format(self):
        import user_code
        importlib.reload(user_code)
        report = user_code.generate_weekly_marketing_report(self.df)
        # Check that each channel's section starts with 'Channel: ...' and has all metrics
        for channel in self.expected_channels:
            header = f"Channel: {channel}" in report
            total_impr = f"Total Impressions: {self.expected_totals[channel]['impressions']}" in report
            avg_impr = f"Avg Impressions: {self.expected_averages[channel]['impressions']:.1f}" in report
            _dynamic_test(
                self,
                header and total_impr and avg_impr,
                f"Report section for {channel} formatted correctly",
                f"Missing or incorrectly formatted section for {channel}"
            )

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

Unlock the power of Python to solve real-world marketing problems. This course guides marketers through practical Python applications, from analyzing campaign data to visualizing trends and automating repetitive tasks. Each section blends engaging theory with hands-on challenges tailored to marketing scenarios.

Learn to harness Python for analyzing marketing data, uncovering trends, and making data-driven decisions.

Explore how Python can automate repetitive marketing tasks, saving time and reducing errors.

Delve into advanced analytics techniques to uncover deeper insights and optimize marketing strategies.

Challenge: Automate Weekly Marketing Report Generation

Oplossing