Organizing files by their type is a frequent and essential task in **DevOps automation**, especially when you need to manage large numbers of **log files**, **configuration files**, or documentation. By categorizing files based on their **extensions**, you can streamline maintenance, automate clean-up processes, and quickly locate the files you need. In this challenge, you will practice this foundational automation skill by writing a Python script that groups a hardcoded list of filenames into categories according to their file extensions.


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

class TestTask(unittest.TestCase):
    def test_grouping_by_extension(self):
        import user_code
        importlib.reload(user_code)
        files = [
            "server.log",
            "config.conf",
            "readme.txt",
            "data.csv",
            "archive.tar.gz",
            "notes.txt",
            "debug.log",
            "settings.conf",
            "script",
            "output.log"
        ]
        result = user_code.organize_files_by_extension(files)
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Returned value is a dictionary.",
            f"Expected a dictionary, got {type(result)}."
        )
        expected = {
            ".log": ["server.log", "debug.log", "output.log"],
            ".conf": ["config.conf", "settings.conf"],
            ".txt": ["readme.txt", "notes.txt"],
            ".csv": ["data.csv"],
            ".gz": ["archive.tar.gz"],
            "": ["script"]
        }
        # Test each extension key
        for ext, expected_files in expected.items():
            actual_files = result.get(ext, None)
            _dynamic_test(
                self,
                isinstance(actual_files, list) and sorted(actual_files) == sorted(expected_files),
                f"Files with extension '{ext}' are grouped correctly.",
                f"Expected files {expected_files} for extension '{ext}', got {actual_files}."
            )

    def test_no_missing_files(self):
        import user_code
        importlib.reload(user_code)
        files = [
            "server.log",
            "config.conf",
            "readme.txt",
            "data.csv",
            "archive.tar.gz",
            "notes.txt",
            "debug.log",
            "settings.conf",
            "script",
            "output.log"
        ]
        result = user_code.organize_files_by_extension(files)
        all_grouped = []
        for v in result.values():
            all_grouped.extend(v)
        _dynamic_test(
            self,
            sorted(all_grouped) == sorted(files),
            "All input files are present in output dictionary.",
            f"Some files are missing or extra in output: {set(files) ^ set(all_grouped)}"
        )

    def test_compound_extension(self):
        import user_code
        importlib.reload(user_code)
        files = ["backup.tar.gz", "archive.tar.gz", "file.txt", "readme"]
        result = user_code.organize_files_by_extension(files)
        _dynamic_test(
            self,
            ".gz" in result and sorted(result[".gz"]) == ["archive.tar.gz", "backup.tar.gz"],
            "Compound extensions are grouped by the last period.",
            f"Expected .gz to include both archive.tar.gz and backup.tar.gz, got {result.get('.gz', None)}"
        )

    def test_empty_string_key(self):
        import user_code
        importlib.reload(user_code)
        files = ["file1", "file2", "file3.log"]
        result = user_code.organize_files_by_extension(files)
        _dynamic_test(
            self,
            "" in result and sorted(result[""]) == ["file1", "file2"],
            "Filenames without extension are under the empty string key.",
            f"Expected ['file1', 'file2'] under '', got {result.get('', None)}"
        )

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

Learn how Python empowers DevOps workflows, automates repetitive tasks, and streamlines infrastructure management. This course introduces practical Python techniques and libraries for DevOps beginners, focusing on automation, monitoring, and data-driven decision-making.

Explore how Python can automate repetitive DevOps tasks, from simple scripting to basic process management.

Learn how Python can be used to monitor system health and analyze logs, providing valuable insights for DevOps teams.

Apply Python's data analysis and visualization capabilities to make informed decisions in DevOps environments.

Challenge: Batch File Organizer

Lösung