Batch processing is a powerful technique for content creators who need to handle large volumes of material efficiently. By automating repetitive tasks—such as summarizing multiple articles or posts—you can save significant time and ensure consistency across your content. Summaries are especially useful for newsletters, previews, or social media, where concise messaging is key. In this challenge, you will use Python to process a collection of articles, generate brief summaries for each, and simulate saving them with filenames that match the original content. This approach streamlines the workflow for preparing content digests or quick overviews.


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 setUp(self):
        self.articles = {
            "post1.txt": "Python is a versatile language. It is popular among content creators. You can use it for automation. It saves time.",
            "article2.txt": "Batch processing allows you to handle multiple files at once. This is useful for summarizing articles. It can also be used for renaming files. Efficiency is improved.",
            "blog3.txt": "Social media posts benefit from concise summaries. Python scripts can automate this process. Consistency is important for branding.",
        }
        self.expected_summaries = {
            "post1.txt": "Python is a versatile language. It is popular among content creators.",
            "article2.txt": "Batch processing allows you to handle multiple files at once. This is useful for summarizing articles.",
            "blog3.txt": "Social media posts benefit from concise summaries. Python scripts can automate this process.",
        }

    def test_extracts_first_two_sentences(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.summarize_articles(self.articles)
        for filename, expected_summary in self.expected_summaries.items():
            actual = result.get(filename, None)
            _dynamic_test(
                self,
                actual is not None and actual.startswith(expected_summary.split(". ")[0]) and actual.startswith(expected_summary[:20]),
                f"Correctly extracts summary for {filename}",
                f"Summary for {filename} not extracted as expected: {actual}",
            )

    def test_summary_stored_in_dict(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.summarize_articles(self.articles)
        for filename in self.articles:
            actual = result.get(filename, None)
            _dynamic_test(
                self,
                actual is not None,
                f"Summary for {filename} stored in dictionary",
                f"Summary for {filename} missing from dictionary",
            )

    def test_summary_ends_with_period(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.summarize_articles(self.articles)
        for filename in self.articles:
            actual = result.get(filename, None)
            _dynamic_test(
                self,
                actual is not None and actual.endswith('.'),
                f"Summary for {filename} ends with a period",
                f"Summary for {filename} does not end with period: {actual}",
            )

    def test_all_articles_processed(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.summarize_articles(self.articles)
        _dynamic_test(
            self,
            isinstance(result, dict) and len(result) == len(self.articles),
            "All articles processed and summarized",
            f"Expected {len(self.articles)} summaries, got {len(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: Create Batch Content Summaries

Oplossing