Automating repetitive naming tasks is a common challenge in creative work, especially when managing design assets or organizing files for maker projects. By leveraging Python, you can rapidly generate consistent, systematic names for a series of elements—saving time and reducing the potential for manual errors. This approach streamlines your workflow and lets you focus more energy on the creative aspects of your project.


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

class TestTask(unittest.TestCase):
    def test_returns_correct_length(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.generate_patterned_names('tile', 5)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 5,
            "Returned list has correct length 5 for n=5",
            f"Returned list length is not 5: {result}"
        )

    def test_elements_are_patterned_strings(self):
        import user_code
        importlib.reload(user_code)
        base = 'tile'
        n = 4
        result = user_code.generate_patterned_names(base, n)
        expected = [f"{base}_{i}" for i in range(1, n+1)]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "List elements have correct patterned format",
            f"Expected {expected}, got {result}"
        )

    def test_different_base_strings(self):
        import user_code
        importlib.reload(user_code)
        base = 'layer'
        n = 3
        result = user_code.generate_patterned_names(base, n)
        expected = [f"{base}_{i}" for i in range(1, n+1)]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function works with different base string",
            f"Expected {expected}, got {result}"
        )

    def test_zero_n_returns_empty_list(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.generate_patterned_names('tile', 0)
        _dynamic_test(
            self,
            isinstance(result, list) and result == [],
            "Returns empty list when n is 0",
            f"Expected empty list, 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

Explore how Python empowers creators and makers to automate, analyze, and visualize their projects. This course blends hands-on coding with creative problem-solving, focusing on real-world applications relevant to artists, designers, hobbyists, and inventors.

Learn how Python can automate and streamline creative workflows, from batch image processing to generating design variations.

Harness the power of Python's visualization libraries to turn data into insights and creative visuals for maker projects.

Unleash your creativity by using Python to generate art, patterns, and interactive visuals, blending code with artistic expression.

Challenge: Automated Pattern Generator

Solution

Challenge: Automated Pattern Generator

Solution