Automating the production of a daily news digest is a practical way to increase newsroom efficiency and ensure consistent delivery of essential information to your audience. By using Python to handle repetitive editorial tasks, you can save valuable time and reduce manual errors, allowing journalists to focus on more in-depth reporting and analysis.

# Example: Reading and writing files in Python with predefined news data

# Predefined list of articles for today
articles = [
    {"headline": "City Council Approves New Park", "summary": "A new park will be built downtown following a unanimous vote."},
    {"headline": "Tech Conference Opens", "summary": "Leaders in technology gather to discuss the future of AI."},
]

# Compile the digest string
digest_lines = []
for article in articles:
    digest_lines.append(f"Headline: {article['headline']}")
    digest_lines.append(f"Summary: {article['summary']}\n")

digest_text = "\n".join(digest_lines)

# Save the digest to a file named with today's date
from datetime import date

filename = f"news_digest_{date.today()}.txt"
with open(filename, "w", encoding="utf-8") as file:
    file.write(digest_text)


Automating daily editorial tasks such as compiling news digests not only saves time but also helps maintain consistency and accuracy in newsroom outputs. By leveraging simple Python scripts, you can transform a routine, manual process into a streamlined workflow, freeing up journalists to focus on more complex assignments and creative storytelling.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import os
from datetime import date

class TestTask(unittest.TestCase):
    def setUp(self):
        self.articles = [
            {"headline": "Test Headline 1", "summary": "Test summary 1."},
            {"headline": "Test Headline 2", "summary": "Test summary 2."}
        ]
        self.expected_filename = f"news_digest_{date.today()}.txt"
        # Remove file if exists before test
        if os.path.exists(self.expected_filename):
            os.remove(self.expected_filename)

    def tearDown(self):
        if os.path.exists(self.expected_filename):
            os.remove(self.expected_filename)

    def test_extracts_headline_and_summary(self):
        import user_code
        importlib.reload(user_code)
        filename = user_code.create_news_digest(self.articles)
        _dynamic_test(
            self,
            filename is not None,
            "Function returns a filename.",
            "Function did not return a filename."
        )
        _dynamic_test(
            self,
            os.path.exists(filename),
            "Digest file was created.",
            f"File {filename} was not created."
        )
        with open(filename, "r", encoding="utf-8") as f:
            content = f.read()
        for article in self.articles:
            _dynamic_test(
                self,
                f"Headline: {article['headline']}" in content,
                f"Digest contains headline: {article['headline']}",
                f"Digest missing headline: {article['headline']}"
            )
            _dynamic_test(
                self,
                f"Summary: {article['summary']}" in content,
                f"Digest contains summary: {article['summary']}",
                f"Digest missing summary: {article['summary']}"
            )

    def test_digest_format_and_separation(self):
        import user_code
        importlib.reload(user_code)
        filename = user_code.create_news_digest(self.articles)
        with open(filename, "r", encoding="utf-8") as f:
            content = f.read()
        sections = content.strip().split("\\n\\n")
        _dynamic_test(
            self,
            len(sections) == len(self.articles),
            "Each article entry is separated by a blank line.",
            f"Expected {len(self.articles)} sections, got {len(sections)}."
        )
        for idx, article in enumerate(self.articles):
            section = sections[idx]
            _dynamic_test(
                self,
                f"Headline: {article['headline']}" in section and f"Summary: {article['summary']}" in section,
                "Section includes both headline and summary for the article.",
                f"Section missing headline or summary for article {idx+1}."
            )

    def test_filename_format_and_return(self):
        import user_code
        importlib.reload(user_code)
        filename = user_code.create_news_digest(self.articles)
        expected = f"news_digest_{date.today()}.txt"
        _dynamic_test(
            self,
            filename == expected,
            "Returned filename matches required format.",
            f"Returned filename '{filename}' does not match expected '{expected}'."
        )
        _dynamic_test(
            self,
            os.path.exists(filename),
            "File exists with the returned filename.",
            f"File '{filename}' does not exist."
        )

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

A practical course designed for journalists and media professionals to harness the power of Python for data-driven storytelling, news automation, and media analysis. Learn to collect, analyze, and visualize data, automate repetitive newsroom tasks, and uncover insights from large datasets using Python.

Learn how to gather, clean, and prepare data for journalistic investigations and media reporting using Python.

Master the skills to analyze, interpret, and visualize media data for compelling storytelling and reporting.

Discover how Python can automate repetitive newsroom tasks and analyze media content for deeper insights.

Challenge: Automate Daily News Digest

Løsning