Executive summaries are essential tools for digital agencies, providing clients with quick, high-level insights that inform strategic decisions. By distilling complex campaign data into a few actionable points, you help stakeholders focus on what matters most—performance highlights, key metrics, and recommended next steps. This approach not only saves time but also builds trust, as clients can clearly see the value and direction in your reporting.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io

class TestTask(unittest.TestCase):
    def setUp(self):
        self.module_name = "user_code"
        if self.module_name in sys.modules:
            del sys.modules[self.module_name]

    def test_top_performing_campaign(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        sys.stdout = f
        user_code.generate_executive_summary()
        sys.stdout = sys.__stdout__
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "top-performing campaign: holiday promo (120 conversions)" in output,
            "Identifies and reports the campaign with the highest conversions.",
            f"Top-performing campaign not correctly reported in output: {output}",
        )

    def test_overall_conversion_rate(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        sys.stdout = f
        user_code.generate_executive_summary()
        sys.stdout = sys.__stdout__
        output = normalize_text(f.getvalue())
        # Calculation: total conversions = 50+120+20+45=235, total clicks = 400+700+180+300=1580, rate=235/1580=0.1487
        _dynamic_test(
            self,
            "overall conversion rate: 14.87%" in output,
            "Calculates and reports correct overall conversion rate.",
            f"Overall conversion rate not correctly reported in output: {output}",
        )

    def test_recommendation_logic(self):
        import user_code
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        # Test for > 0.15
        code_high = code.replace("[50, 120, 20, 45]", "[100, 200, 80, 150]") # boosts conversions
        # Capture print output
        f_high = io.StringIO()
        sys.stdout = f_high
        exec(code_high, {})
        sys.stdout = sys.__stdout__
        output_high = normalize_text(f_high.getvalue())
        _dynamic_test(
            self,
            "maintain momentum and consider increasing budget" in output_high,
            "Includes correct recommendation for high conversion rate.",
            "Recommendation for high conversion rate not found in output.",
        )
        # Test for <=0.05
        code_low = code.replace("[50, 120, 20, 45]", "[1, 2, 1, 1]") # low conversions
        f_low = io.StringIO()
        sys.stdout = f_low
        exec(code_low, {})
        sys.stdout = sys.__stdout__
        output_low = normalize_text(f_low.getvalue())
        _dynamic_test(
            self,
            "reevaluate campaign creatives and audience segments" in output_low,
            "Includes correct recommendation for low conversion rate.",
            "Recommendation for low conversion rate not found in output.",
        )

    def test_summary_contains_all_elements(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        sys.stdout = f
        user_code.generate_executive_summary()
        sys.stdout = sys.__stdout__
        output = normalize_text(f.getvalue())
        has_campaign = "top-performing campaign: holiday promo (120 conversions)" in output
        has_rate = "overall conversion rate: 14.87%" in output
        has_recommend = "optimize underperforming campaigns and review targeting strategies." in output
        _dynamic_test(
            self,
            has_campaign and has_rate and has_recommend,
            "Summary output contains all required elements.",
            f"Summary missing elements: {output}",
        )

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

Learn how to leverage Python to solve real-world problems faced by digital agencies. This course covers automation, data analysis, and reporting techniques tailored for marketing, content, and analytics teams. Through engaging theory and hands-on challenges, you'll gain practical skills to streamline workflows, analyze campaign data, and generate actionable insights.

Discover how Python can automate repetitive tasks in digital agencies, from campaign scheduling to content management and client communication.

Learn how to use Python for analyzing campaign data, extracting insights, and making data-driven decisions in digital agencies.

Master the art of generating clear, insightful reports and visualizations for clients using Python.

Challenge: Executive Summary Generator

Рішення