Keeping your content assets organized is crucial for managing a growing library of images, videos, and documents. As a content creator, you often deal with dozens or even hundreds of files, and manually sorting them can be tedious and error-prone. Automating this organizational process with Python not only saves you time but also ensures your files are always in the right place, making them easier to find and use in future projects. By simulating the creation of subfolders and moving files into them based on their type, you can develop a workflow that mirrors best practices for digital asset management—without the risk of accidentally moving files during testing.


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.files = [
            "summer_vacation.jpg",
            "project_proposal.pdf",
            "family_video.mp4",
            "notes.txt",
            "logo.png",
            "meeting_recording.mov",
            "budget.xlsx",
            "unknown_file.xyz"
        ]
        self.expected_creations = [
            "Simulating: Creating folder 'images'",
            "Simulating: Creating folder 'documents'",
            "Simulating: Creating folder 'videos'",
            "Simulating: Creating folder 'others'"
        ]
        self.expected_moves = [
            ("summer_vacation.jpg", "images/"),
            ("project_proposal.pdf", "documents/"),
            ("family_video.mp4", "videos/"),
            ("notes.txt", "documents/"),
            ("logo.png", "images/"),
            ("meeting_recording.mov", "videos/"),
            ("budget.xlsx", "documents/"),
            ("unknown_file.xyz", "others/")
        ]

    def test_folder_creation_once(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.organize_files_by_type(self.files)
        output = f.getvalue()
        # Each folder creation message appears only once
        for folder_msg in self.expected_creations:
            count = output.count(folder_msg)
            _dynamic_test(
                self,
                count == 1,
                f"Folder creation message '{folder_msg}' appears once",
                f"Folder creation message '{folder_msg}' appears {count} times"
            )

    def test_simulated_move_for_each_file(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.organize_files_by_type(self.files)
        output = f.getvalue()
        # Each file move message is present and correct
        for file_name, folder in self.expected_moves:
            move_msg = f"Simulating: Moving '{file_name}' to '{folder}'"
            _dynamic_test(
                self,
                move_msg in output,
                f"Move message for '{file_name}' to '{folder}' found",
                f"Expected move message: '{move_msg}' not found in output"
            )

    def test_unknown_file_goes_to_others(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.organize_files_by_type(self.files)
        output = f.getvalue()
        move_msg = "Simulating: Moving 'unknown_file.xyz' to 'others/'"
        _dynamic_test(
            self,
            move_msg in output,
            "Unknown file correctly moved to 'others/'",
            f"Expected unknown file to be moved to 'others/', got output: {output}"
        )

    def test_no_duplicate_folder_creation(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.organize_files_by_type(self.files)
        output = f.getvalue()
        # Check that 'Simulating: Creating folder' never appears more than once per folder
        for folder_msg in self.expected_creations:
            count = output.count(folder_msg)
            _dynamic_test(
                self,
                count == 1,
                f"Folder creation message '{folder_msg}' appears only once",
                f"Duplicate folder creation: '{folder_msg}' appears {count} times"
            )

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: Organize Content Assets by Type

Solution