Visualizing project timelines is a powerful technique for makers to track their progress and gain insights into how time is allocated across different phases. By representing each phase of a project visually, you can quickly identify which stages require the most effort and where potential improvements can be made in future projects. This approach not only helps in managing your current work but also serves as a valuable reference when planning new endeavors.


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

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

    def test_bar_chart_data(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        phases = ['Planning', 'Building', 'Testing', 'Finishing']
        days = [3, 7, 2, 1]
        user_code.plot_project_timeline(phases, days)
        found_bar = False
        for ax in plt.gcf().axes:
            for bar in ax.patches:
                found_bar = True
        _dynamic_test(
            self,
            found_bar,
            "Bar chart is created with bars present.",
            "No bars found in the chart. Did you use plt.bar()?",
        )

    def test_x_axis_labels(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        phases = ['Planning', 'Building', 'Testing', 'Finishing']
        days = [3, 7, 2, 1]
        user_code.plot_project_timeline(phases, days)
        ax = plt.gca()
        labels = [tick.get_text() for tick in ax.get_xticklabels()]
        expected_labels = phases
        # Matplotlib may have empty labels if not drawn, so check tick positions instead
        tick_positions = [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()]
        _dynamic_test(
            self,
            len(tick_positions) == len(phases),
            "X-axis has correct number of phase labels.",
            f"Expected {len(phases)} x-axis labels, got {len(tick_positions)}."
        )

    def test_axis_labels(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        phases = ['Planning', 'Building', 'Testing', 'Finishing']
        days = [3, 7, 2, 1]
        user_code.plot_project_timeline(phases, days)
        ax = plt.gca()
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        _dynamic_test(
            self,
            xlabel == "Project Phase",
            "X-axis label is set to 'Project Phase'",
            f"Expected x-axis label 'Project Phase', got '{xlabel}'",
        )
        _dynamic_test(
            self,
            ylabel == "Days Spent",
            "Y-axis label is set to 'Days Spent'",
            f"Expected y-axis label 'Days Spent', got '{ylabel}'",
        )

    def test_title(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        phases = ['Planning', 'Building', 'Testing', 'Finishing']
        days = [3, 7, 2, 1]
        user_code.plot_project_timeline(phases, days)
        ax = plt.gca()
        title = ax.get_title()
        _dynamic_test(
            self,
            title == "Maker Project Timeline",
            "Chart title is set to 'Maker Project Timeline'",
            f"Expected chart title 'Maker Project Timeline', got '{title}'",
        )

    def test_function_runs(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        try:
            user_code.plot_project_timeline(['A', 'B'], [1, 2])
            ran = True
        except Exception as e:
            ran = False
        _dynamic_test(
            self,
            ran,
            "Function runs and displays a chart without error.",
            "Function failed to run with valid input.",
        )

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: Visualize Your Project Timeline

Solution