Regular, clear communication with clients is crucial for digital agencies. Keeping clients informed about their campaigns builds trust and demonstrates ongoing value. However, preparing weekly updates manually can take up significant time, especially as the number of clients and campaigns grows. Automating the creation of weekly email digests allows you to deliver consistent, professional summaries of campaign activity with minimal effort, freeing up your team for higher-value work.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_heading_present(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_weekly_digest([
                {"title": "A", "summary": "S", "date": "2024-01-01"}
            ])
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "weekly campaign digest" in output,
            "Output contains heading 'Weekly Campaign Digest'",
            f"Heading 'Weekly Campaign Digest' not found in: {output}"
        )

    def test_all_campaigns_included(self):
        import user_code
        importlib.reload(user_code)
        sample_campaigns = [
            {"title": "C1", "summary": "Sum1", "date": "2024-01-01"},
            {"title": "C2", "summary": "Sum2", "date": "2024-01-02"}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_weekly_digest(sample_campaigns)
        output = normalize_text(f.getvalue())
        for camp in sample_campaigns:
            _dynamic_test(
                self,
                camp["title"].lower() in output and camp["summary"].lower() in output and camp["date"] in output,
                f"Campaign '{camp['title']}' is included in digest",
                f"Campaign '{camp['title']}' missing or incomplete in output: {output}"
            )

    def test_labels_and_formatting(self):
        import user_code
        importlib.reload(user_code)
        campaign = {"title": "XTitle", "summary": "XSummary", "date": "2024-01-05"}
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_weekly_digest([campaign])
        output = f.getvalue()
        _dynamic_test(
            self,
            "Title:" in output and "Summary:" in output and "Date:" in output,
            "Labels 'Title:', 'Summary:', and 'Date:' are present in output",
            f"Missing one or more labels in output: {output}"
        )

    def test_multiple_campaign_separation(self):
        import user_code
        importlib.reload(user_code)
        sample_campaigns = [
            {"title": "A", "summary": "S1", "date": "2024-01-01"},
            {"title": "B", "summary": "S2", "date": "2024-01-02"}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_weekly_digest(sample_campaigns)
        output = f.getvalue()
        # Check that both campaigns are separated by at least one blank line or line break
        first = output.find("A")
        second = output.find("B")
        _dynamic_test(
            self,
            first != -1 and second != -1 and second > first,
            "Campaigns appear in order and are separated in output",
            f"Campaigns not clearly separated or missing: {output}"
        )

    def test_all_information_present(self):
        import user_code
        importlib.reload(user_code)
        campaign = {"title": "Big Sale", "summary": "Lots of sales", "date": "2024-05-01"}
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_weekly_digest([campaign])
        output = f.getvalue()
        _dynamic_test(
            self,
            all(str(val) in output for val in campaign.values()),
            "All information from campaign dictionary is present in output",
            f"Not all campaign information found in output: {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: Automated Email Digest

Ratkaisu