As a content creator, your digital assets—photos, videos, scripts, and project files—are often the backbone of your creative work. Losing these files due to accidental deletion, hardware failure, or other unforeseen events can be devastating. That is why regular backups are essential: they safeguard your work, provide peace of mind, and ensure you can recover quickly from setbacks. **Automating the backup process** reduces the risk of human error and saves valuable time, allowing you to focus more on creating and less on worrying about data loss.


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.test_structure = {
            "folderA": {
                "file1.txt": None,
                "file2.txt": None,
                "subA": {
                    "file3.txt": None
                }
            },
            "folderB": {
                "file4.txt": None
            }
        }

    def test_directory_messages(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.simulate_backup(self.test_structure, "/src", "/dest")
        output = normalize_text(f.getvalue())
        # Directories: /dest/folderA, /dest/folderA/subA, /dest/folderB
        expected_dirs = [
            "would create directory: /dest/foldera",
            "would create directory: /dest/foldera/suba",
            "would create directory: /dest/folderb"
        ]
        for dir_msg in expected_dirs:
            _dynamic_test(
                self,
                dir_msg in output,
                f"Printed directory creation message: {dir_msg}",
                f"Missing directory creation message: {dir_msg}"
            )

    def test_file_messages(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.simulate_backup(self.test_structure, "/src", "/dest")
        output = normalize_text(f.getvalue())
        # Files and their copy messages
        expected_files = [
            ("/src/folderA/file1.txt", "/dest/folderA/file1.txt"),
            ("/src/folderA/file2.txt", "/dest/folderA/file2.txt"),
            ("/src/folderA/subA/file3.txt", "/dest/folderA/subA/file3.txt"),
            ("/src/folderB/file4.txt", "/dest/folderB/file4.txt")
        ]
        for src, dest in expected_files:
            msg = f"would copy file: {src} to {dest}"
            _dynamic_test(
                self,
                normalize_text(msg) in output,
                f"Printed file copy message: {msg}",
                f"Missing file copy message: {msg}"
            )

    def test_recursion_and_paths(self):
        import user_code
        importlib.reload(user_code)
        # Use a deeper structure
        test_structure = {
            "outer": {
                "mid": {
                    "inner": {
                        "deepfile.txt": None
                    }
                }
            }
        }
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.simulate_backup(test_structure, "/a", "/b")
        output = normalize_text(f.getvalue())
        expected_dirs = [
            "would create directory: /b/outer",
            "would create directory: /b/outer/mid",
            "would create directory: /b/outer/mid/inner"
        ]
        expected_file = "would copy file: /a/outer/mid/inner/deepfile.txt to /b/outer/mid/inner/deepfile.txt"
        for dir_msg in expected_dirs:
            _dynamic_test(
                self,
                dir_msg in output,
                f"Recursively prints directory: {dir_msg}",
                f"Missing recursive directory: {dir_msg}"
            )
        _dynamic_test(
            self,
            expected_file in output,
            f"Recursively prints file: {expected_file}",
            f"Missing recursive file copy message: {expected_file}"
        )

    def test_original_sample_structure(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.simulate_backup(getattr(user_code, 'content_folder', {}), "/content", "/backup")
        output = normalize_text(f.getvalue())
        expected = [
            "would create directory: /backup/images",
            "would create directory: /backup/images/subfolder",
            "would copy file: /content/images/photo1.jpg to /backup/images/photo1.jpg",
            "would copy file: /content/images/photo2.png to /backup/images/photo2.png",
            "would copy file: /content/images/subfolder/photo3.gif to /backup/images/subfolder/photo3.gif",
            "would create directory: /backup/videos",
            "would copy file: /content/videos/video1.mp4 to /backup/videos/video1.mp4",
            "would create directory: /backup/docs",
            "would copy file: /content/docs/script.txt to /backup/docs/script.txt"
        ]
        for msg in expected:
            _dynamic_test(
                self,
                normalize_text(msg) in output,
                f"Sample structure prints: {msg}",
                f"Missing expected print: {msg}"
            )

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: Automate Content Backup

Ratkaisu