Content creators often find themselves repeatedly writing similar video descriptions when uploading new content. This repetitive task can quickly become tedious, especially when managing multiple videos at once. Automating the generation of video descriptions not only saves time but also ensures consistency across uploads. By leveraging Python, you can streamline this process and focus more energy on the creative aspects of your work.


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

class TestTask(unittest.TestCase):
    def test_same_number_of_descriptions(self):
        import user_code
        importlib.reload(user_code)
        titles = [
            "How to Edit Photos Like a Pro",
            "Top 5 Video Editing Tricks",
            "Beginner's Guide to YouTube Thumbnails"
        ]
        result = user_code.generate_video_descriptions(titles)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == len(titles),
            "Returned list has same number of elements as input titles list.",
            f"Expected {len(titles)} descriptions, got {len(result) if isinstance(result, list) else type(result)}."
        )

    def test_descriptions_format(self):
        import user_code
        importlib.reload(user_code)
        titles = [
            "How to Edit Photos Like a Pro",
            "Top 5 Video Editing Tricks",
            "Beginner's Guide to YouTube Thumbnails"
        ]
        expected = [
            f"Watch our latest video: {title} for tips and tricks!" for title in titles
        ]
        result = user_code.generate_video_descriptions(titles)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Descriptions are formatted correctly for all titles.",
            f"Expected: {expected}, got: {result}"
        )

    def test_empty_list(self):
        import user_code
        importlib.reload(user_code)
        titles = []
        result = user_code.generate_video_descriptions(titles)
        _dynamic_test(
            self,
            isinstance(result, list) and result == [],
            "Function returns empty list for empty input.",
            f"Expected empty list, got: {result}"
        )

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 Video Descriptions from Titles

Solution