Automated reporting is a powerful tool for content creators, allowing you to quickly turn raw audience engagement data into clear, actionable summaries. By using **Python** to generate these reports, you save time, minimize manual errors, and ensure consistency in your analytics. This approach lets you focus on strategy and creativity rather than spending hours compiling statistics. Automated reports can be easily shared with team members or stakeholders, making collaboration and decision-making more efficient.


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_total_views(self):
        import user_code
        importlib.reload(user_code)
        engagement_data = [
            {"day": "Monday", "views": 120, "likes": 25, "comments": 8},
            {"day": "Tuesday", "views": 150, "likes": 30, "comments": 10},
            {"day": "Wednesday", "views": 200, "likes": 50, "comments": 20},
            {"day": "Thursday", "views": 90, "likes": 15, "comments": 5},
            {"day": "Friday", "views": 175, "likes": 40, "comments": 15},
            {"day": "Saturday", "views": 220, "likes": 60, "comments": 25},
            {"day": "Sunday", "views": 180, "likes": 35, "comments": 12}
        ]
        expected_total_views = sum(item["views"] for item in engagement_data)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            str(expected_total_views) in output,
            f"Report includes correct total views: {expected_total_views}",
            f"Expected total views '{expected_total_views}' not found in output: {output}",
        )

    def test_average_likes(self):
        import user_code
        importlib.reload(user_code)
        engagement_data = [
            {"day": "Monday", "views": 120, "likes": 25, "comments": 8},
            {"day": "Tuesday", "views": 150, "likes": 30, "comments": 10},
            {"day": "Wednesday", "views": 200, "likes": 50, "comments": 20},
            {"day": "Thursday", "views": 90, "likes": 15, "comments": 5},
            {"day": "Friday", "views": 175, "likes": 40, "comments": 15},
            {"day": "Saturday", "views": 220, "likes": 60, "comments": 25},
            {"day": "Sunday", "views": 180, "likes": 35, "comments": 12}
        ]
        total_likes = sum(item["likes"] for item in engagement_data)
        expected_avg = total_likes / len(engagement_data)
        expected_avg_str = f"{expected_avg:.2f}"
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            expected_avg_str in output,
            f"Report includes correct average likes per day: {expected_avg_str}",
            f"Expected average likes '{expected_avg_str}' not found in output: {output}",
        )

    def test_highest_engagement_day(self):
        import user_code
        importlib.reload(user_code)
        engagement_data = [
            {"day": "Monday", "views": 120, "likes": 25, "comments": 8},
            {"day": "Tuesday", "views": 150, "likes": 30, "comments": 10},
            {"day": "Wednesday", "views": 200, "likes": 50, "comments": 20},
            {"day": "Thursday", "views": 90, "likes": 15, "comments": 5},
            {"day": "Friday", "views": 175, "likes": 40, "comments": 15},
            {"day": "Saturday", "views": 220, "likes": 60, "comments": 25},
            {"day": "Sunday", "views": 180, "likes": 35, "comments": 12}
        ]
        highest_engagement = max(
            engagement_data,
            key=lambda x: x["likes"] + x["comments"]
        )
        highest_day = highest_engagement["day"]
        highest_total = highest_engagement["likes"] + highest_engagement["comments"]
        expected_line = f"{highest_day} ({highest_total} total interactions)"
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            normalize_text(expected_line) in output,
            f"Report includes correct highest engagement day: {expected_line}",
            f"Expected highest engagement day '{expected_line}' not found in output: {output}",
        )

    def test_report_format(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue()
        expected_headers = [
            "=== Weekly Engagement Summary Report ===",
            "Total Views:",
            "Average Likes per Day:",
            "Highest Engagement Day:"
        ]
        for header in expected_headers:
            _dynamic_test(
                self,
                header in output,
                f"Report includes line: {header}",
                f"Expected report line '{header}' not 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

Unlock the power of Python to automate, analyze, and enhance your content creation workflow. This course is designed for content creators who want to leverage Python for tasks such as automating repetitive processes, analyzing audience data, and generating creative content. With hands-on challenges and engaging theory, you'll learn to solve real-world problems and boost your productivity.

Learn how to use Python to automate repetitive tasks in content creation, such as renaming files, organizing assets, and generating batch content.

Use Python to analyze and visualize audience engagement data, helping content creators make data-driven decisions.

Explore how Python can assist in generating creative content, such as captions, summaries, and batch content for various platforms.

Challenge: Generate Engagement Summary Report

Soluzione