Automating the generation of meta descriptions for multiple web pages can save you significant time and ensure consistency across your site. Instead of manually crafting meta description tags for each page, you can use Python to dynamically create them based on the content you already have. In this challenge, you will implement a function that takes a list of dictionaries—each representing a page with its title and description—and returns a list of properly formatted meta description tag strings. This approach leverages Python's string formatting capabilities to insert the relevant information into the standard meta tag template, making it easy to scale your SEO efforts as your site grows.


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

class TestTask(unittest.TestCase):
    def test_basic_functionality(self):
        import user_code
        importlib.reload(user_code)
        pages = [
            {"title": "Home", "description": "Welcome to our homepage."},
            {"title": "About", "description": "Learn more about our company."}
        ]
        expected = [
            '<meta name="description" content="Home: Welcome to our homepage.">',
            '<meta name="description" content="About: Learn more about our company.">'
        ]
        result = user_code.generate_meta_descriptions(pages)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correct meta description tags generated for provided pages.",
            f"Expected {expected}, got {result}"
        )

    def test_empty_input(self):
        import user_code
        importlib.reload(user_code)
        pages = []
        expected = []
        result = user_code.generate_meta_descriptions(pages)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns empty list for empty input.",
            f"Expected empty list, got {result}"
        )

    def test_empty_title_or_description(self):
        import user_code
        importlib.reload(user_code)
        pages = [
            {"title": "", "description": "No title here."},
            {"title": "No Description", "description": ""},
            {"title": "", "description": ""}
        ]
        expected = [
            '<meta name="description" content=": No title here.">',
            '<meta name="description" content="No Description: ">',
            '<meta name="description" content=": ">' 
        ]
        result = user_code.generate_meta_descriptions(pages)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Handles empty title or description strings correctly.",
            f"Expected {expected}, got {result}"
        )

    def test_multiple_pages(self):
        import user_code
        importlib.reload(user_code)
        pages = [
            {"title": "Page1", "description": "Desc1"},
            {"title": "Page2", "description": "Desc2"},
            {"title": "Page3", "description": "Desc3"}
        ]
        expected = [
            '<meta name="description" content="Page1: Desc1">',
            '<meta name="description" content="Page2: Desc2">',
            '<meta name="description" content="Page3: Desc3">'
        ]
        result = user_code.generate_meta_descriptions(pages)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly generates meta tags for multiple pages.",
            f"Expected {expected}, 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

Master the use of Python to automate, analyze, and optimize SEO workflows. This course guides SEO professionals through practical Python applications for keyword research, on-page analysis, and technical SEO, using real-world scenarios and hands-on coding tasks.

Learn how Python can automate repetitive SEO tasks, from scraping search results to generating meta tags, making your SEO workflow more efficient.

Explore how Python can be used to analyze keyword data, identify opportunities, and visualize keyword trends for SEO campaigns.

Apply Python to analyze on-page SEO elements and perform technical audits, including content checks, tag analysis, and site structure evaluation.

Challenge: Generate Meta Descriptions

Oplossing