You have explored how loops and color lists can be combined to create dynamic, generative art patterns. By using nested loops, you can systematically control the placement of elements—such as squares in a grid—while color lists allow you to vary the appearance in visually engaging ways. This approach gives you the flexibility to generate intricate designs with just a few lines of code, and by changing variables, you can easily experiment with new patterns and color combinations. In this challenge, you will use these techniques to build a customizable grid of colored squares, reinforcing your understanding of loops, lists, and creative coding with `matplotlib`.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import sys

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code

    def test_grid_size(self):
        # Patch plt.show to prevent window
        original_show = plt.show
        plt.show = lambda *a, **k: None
        # Clear previous figures
        plt.close('all')
        rows, cols = 5, 7
        colors = ['red', 'green']
        self.user_code.draw_color_grid(rows, cols, colors)
        fig = plt.gcf()
        ax = plt.gca()
        patches = [p for p in ax.patches if isinstance(p, matplotlib.patches.Rectangle)]
        _dynamic_test(
            self,
            len(patches) == rows * cols,
            f"Draws correct number of squares: {rows*cols}",
            f"Expected {rows*cols} squares, found {len(patches)}",
        )
        plt.show = original_show
        plt.close('all')

    def test_color_sequence(self):
        original_show = plt.show
        plt.show = lambda *a, **k: None
        plt.close('all')
        rows, cols = 3, 4
        colors = ['cyan', 'magenta', 'yellow']
        self.user_code.draw_color_grid(rows, cols, colors)
        ax = plt.gca()
        patches = [p for p in ax.patches if isinstance(p, matplotlib.patches.Rectangle)]
        color_cycle = [colors[(r * cols + c) % len(colors)] for r in range(rows) for c in range(cols)]
        patch_facecolors = [p.get_facecolor() for p in patches]
        # Convert color names to RGBA for comparison
        expected_rgba = [matplotlib.colors.to_rgba(c) for c in color_cycle]
        # Only compare up to number of patches
        match = all(patch_facecolors[i] == expected_rgba[i] for i in range(len(patches)))
        _dynamic_test(
            self,
            match,
            "Squares use correct color sequence from color list",
            "Squares do not match expected color sequence",
        )
        plt.show = original_show
        plt.close('all')

    def test_change_grid_size(self):
        original_show = plt.show
        plt.show = lambda *a, **k: None
        plt.close('all')
        rows, cols = 2, 2
        colors = ['red']
        self.user_code.draw_color_grid(rows, cols, colors)
        ax = plt.gca()
        patches = [p for p in ax.patches if isinstance(p, matplotlib.patches.Rectangle)]
        _dynamic_test(
            self,
            len(patches) == 4,
            "Changing grid size produces correct number of squares",
            f"Expected 4 squares for 2x2 grid, got {len(patches)}",
        )
        plt.show = original_show
        plt.close('all')

    def test_change_color_list(self):
        original_show = plt.show
        plt.show = lambda *a, **k: None
        plt.close('all')
        rows, cols = 2, 3
        colors = ['black', 'white']
        self.user_code.draw_color_grid(rows, cols, colors)
        ax = plt.gca()
        patches = [p for p in ax.patches if isinstance(p, matplotlib.patches.Rectangle)]
        facecolors = [p.get_facecolor() for p in patches]
        expected = [matplotlib.colors.to_rgba(c) for c in ['black', 'white', 'black', 'white', 'black', 'white']]
        _dynamic_test(
            self,
            facecolors == expected,
            "Changing color list updates grid colors correctly",
            f"Color list did not update colors as expected. Got {facecolors}",
        )
        plt.show = original_show
        plt.close('all')

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: Generative Pattern Designer

Ratkaisu