Summarizing keyword categories is a crucial step in **SEO data analysis**, as it enables you to quickly identify which content areas are performing well and which may represent opportunities for growth. By aggregating **search volumes** by `category`, you can spot gaps in your content strategy and make informed decisions about where to focus your efforts.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.module = importlib.import_module('user_code')

    def test_all_unique_categories_present(self):
        data = {
            'keyword': ['a', 'b', 'c', 'd', 'e'],
            'category': ['Alpha', 'Beta', 'Alpha', 'Gamma', 'Beta'],
            'search_volume': [10, 20, 30, 40, 50]
        }
        df = pd.DataFrame(data)
        result = self.module.summarize_categories(df)
        categories = set(result['category']) if result is not None else set()
        expected = set(['Alpha', 'Beta', 'Gamma'])
        _dynamic_test(
            self,
            categories == expected,
            "All unique categories are present in the output DataFrame",
            f"Expected categories {expected}, got {categories}"
        )

    def test_sum_of_search_volumes(self):
        data = {
            'keyword': ['kw1', 'kw2', 'kw3', 'kw4'],
            'category': ['Cat1', 'Cat1', 'Cat2', 'Cat2'],
            'search_volume': [100, 200, 300, 400]
        }
        df = pd.DataFrame(data)
        result = self.module.summarize_categories(df)
        expected = {'Cat1': 300, 'Cat2': 700}
        if result is not None:
            for _, row in result.iterrows():
                cat = row['category']
                vol = row['search_volume']
                _dynamic_test(
                    self,
                    cat in expected and vol == expected[cat],
                    f"Correct total for {cat}",
                    f"Expected {expected[cat]} for {cat}, got {vol}"
                )
        else:
            _dynamic_test(self, False, "Result is not None", "Function returned None")

    def test_output_columns(self):
        data = {
            'keyword': ['x'],
            'category': ['Y'],
            'search_volume': [123]
        }
        df = pd.DataFrame(data)
        result = self.module.summarize_categories(df)
        columns = list(result.columns) if result is not None else []
        _dynamic_test(
            self,
            columns == ['category', 'search_volume'],
            "Output DataFrame has correct columns",
            f"Expected columns ['category', 'search_volume'], got {columns}"
        )

    def test_multiple_keywords_per_category(self):
        data = {
            'keyword': ['a', 'b', 'c', 'd'],
            'category': ['SEO', 'SEO', 'Content', 'Content'],
            'search_volume': [10, 20, 30, 40]
        }
        df = pd.DataFrame(data)
        result = self.module.summarize_categories(df)
        expected = {'SEO': 30, 'Content': 70}
        if result is not None:
            for _, row in result.iterrows():
                cat = row['category']
                vol = row['search_volume']
                _dynamic_test(
                    self,
                    cat in expected and vol == expected[cat],
                    f"Correct sum for {cat}",
                    f"Expected {expected[cat]} for {cat}, got {vol}"
                )
        else:
            _dynamic_test(self, False, "Result is not None", "Function returned None")

    def test_category_appears_only_once(self):
        data = {
            'keyword': ['unique'],
            'category': ['OnlyOne'],
            'search_volume': [99]
        }
        df = pd.DataFrame(data)
        result = self.module.summarize_categories(df)
        if result is not None and len(result) == 1:
            row = result.iloc[0]
            _dynamic_test(
                self,
                row['category'] == 'OnlyOne' and row['search_volume'] == 99,
                "Handles category that appears only once",
                f"Expected ('OnlyOne', 99), got ({row['category']}, {row['search_volume']})"
            )
        else:
            _dynamic_test(self, False, "Handles category that appears only once", f"Expected single row for 'OnlyOne', 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: Summarize Keyword Categories

Oplossing