Identifying your top-performing content is crucial for refining your strategy and maximizing your impact as a content creator. By quickly surfacing posts that generate the most engagement, you gain actionable insights into what resonates with your audience. This allows you to focus your efforts on creating more of what works, experiment with new ideas, and allocate resources more effectively. In this challenge, you will use Python to analyze a hardcoded dataset of content performance and pinpoint the three posts with the highest combined engagement, empowering you to make smarter content decisions.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.sample_data = [
            {"title": "How to Edit Photos Like a Pro", "views": 1200, "likes": 300},
            {"title": "10 Tips for Better Videos", "views": 950, "likes": 210},
            {"title": "Behind the Scenes: My Studio Setup", "views": 1800, "likes": 400},
            {"title": "Beginner's Guide to Lighting", "views": 750, "likes": 120},
            {"title": "Instagram Growth Hacks", "views": 2100, "likes": 500},
            {"title": "Editing with Mobile Apps", "views": 600, "likes": 80},
            {"title": "Creative Storytelling Ideas", "views": 1700, "likes": 350}
        ]

    def test_returns_three_posts(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.get_top_performing_content([d.copy() for d in self.sample_data])
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 3,
            "Function returns exactly 3 posts",
            f"Expected 3 posts, got {len(result) if isinstance(result, list) else type(result)}"
        )

    def test_engagement_value_correct(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.get_top_performing_content([d.copy() for d in self.sample_data])
        for post in result:
            engagement = post.get('engagement', None)
            expected = post.get('views', 0) + post.get('likes', 0)
            _dynamic_test(
                self,
                engagement == expected,
                f"Engagement value correct for post '{post.get('title', '')}'",
                f"Expected engagement {expected} for post '{post.get('title', '')}', got {engagement}"
            )

    def test_sorted_descending(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.get_top_performing_content([d.copy() for d in self.sample_data])
        if isinstance(result, list) and len(result) == 3:
            engagements = [post.get('engagement', 0) for post in result]
            _dynamic_test(
                self,
                engagements == sorted(engagements, reverse=True),
                "Posts are sorted in descending order of engagement",
                f"Posts not sorted in descending order: {engagements}"
            )
        else:
            _dynamic_test(
                self,
                False,
                "",
                "Result is not a list of 3 posts, cannot test sorting."
            )

    def test_top_3_are_correct(self):
        import user_code
        importlib.reload(user_code)
        # Calculate correct top 3
        posts_with_engagement = [d.copy() for d in self.sample_data]
        for post in posts_with_engagement:
            post['engagement'] = post['views'] + post['likes']
        posts_with_engagement.sort(key=lambda x: x['engagement'], reverse=True)
        expected_titles = [p['title'] for p in posts_with_engagement[:3]]
        result = user_code.get_top_performing_content([d.copy() for d in self.sample_data])
        result_titles = [p.get('title', None) for p in result]
        _dynamic_test(
            self,
            result_titles == expected_titles,
            "Top 3 posts are correct",
            f"Expected titles {expected_titles}, got {result_titles}"
        )

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: Identify Top-Performing Content

Solution