Building on your understanding from the previous chapter about visualizing project timelines, you will now focus on a key tool used in civil engineering project management: the Gantt chart. Clear visualization of project schedules is essential for effective communication among stakeholders, allowing everyone to grasp task sequences, durations, and dependencies at a glance. Gantt charts not only help in planning but also serve as powerful visual aids during progress meetings, ensuring that timelines, overlaps, and critical tasks are always visible. By learning to create a Gantt chart in Python, you will gain a practical skill for presenting project schedules in a way that is both professional and immediately informative.

import unittest
import ast
import re
import importlib
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle

import user_code


class TestTask(unittest.TestCase):
    def setUp(self):
        self.tasks = [
            {"label": "Site Preparation", "start": 0, "finish": 5, "category": "Preparation"},
            {"label": "Foundation", "start": 5, "finish": 15, "category": "Structural"},
            {"label": "Framing", "start": 15, "finish": 30, "category": "Structural"},
            {"label": "Roofing", "start": 28, "finish": 35, "category": "Structural"},
            {"label": "Electrical", "start": 20, "finish": 32, "category": "MEP"},
            {"label": "Plumbing", "start": 22, "finish": 34, "category": "MEP"},
            {"label": "Finishing", "start": 35, "finish": 45, "category": "Finishing"},
        ]
        importlib.reload(user_code)

    def _render(self):
        plt.close("all")
        fig, ax = plt.subplots()
        orig_subplots = plt.subplots
        plt.subplots = lambda *args, **kwargs: (fig, ax)
        try:
            user_code.plot_gantt_chart(self.tasks)
        finally:
            plt.subplots = orig_subplots
        return fig, ax

    def _get_bar_patches(self, ax):
        # Collect only the actual bars drawn on the axes.
        # Exclude legend rectangles by requiring y to be close to task rows and height ~ 0.5
        bars = []
        for p in ax.patches:
            if isinstance(p, Rectangle):
                h = p.get_height()
                # barh height is 0.5 in user code
                if abs(h - 0.5) < 1e-6:
                    bars.append(p)
        return bars

    def test_bars_span_correct_start_finish(self):
        fig, ax = self._render()
        bar_patches = self._get_bar_patches(ax)

        # Must have exactly one bar per task
        _dynamic_test(
            self,
            len(bar_patches) == len(self.tasks),
            "Number of bars matches number of tasks.",
            f"Expected {len(self.tasks)} bars, got {len(bar_patches)}"
        )

        # Match each task index i to a bar by its center y position
        correct = True
        for i, task in enumerate(self.tasks):
            matched = [b for b in bar_patches if abs((b.get_y() + b.get_height() / 2) - i) < 1e-3]
            if len(matched) != 1:
                correct = False
                continue
            bar = matched[0]
            left = bar.get_x()
            right = bar.get_x() + bar.get_width()
            if not (abs(left - task["start"]) < 1e-2 and abs(right - task["finish"]) < 1e-2):
                correct = False

        _dynamic_test(
            self,
            correct,
            "Each task bar spans from start to finish as specified in the tasks list.",
            "Not all bars span the correct start and finish positions.",
        )

    def test_task_labels_present(self):
        fig, ax = self._render()
        labels = set([t.get_text() for t in ax.texts])
        correct = all(task["label"] in labels for task in self.tasks)
        _dynamic_test(
            self,
            correct,
            "Each task label is present inside the corresponding bar.",
            f"Not all task labels found in the chart: {labels}",
        )

    def test_category_colors_and_legend(self):
        fig, ax = self._render()
        legend = ax.get_legend()
        legend_labels = set([t.get_text() for t in legend.get_texts()]) if legend else set()
        categories = set(task["category"] for task in self.tasks)
        correct = categories.issubset(legend_labels)
        _dynamic_test(
            self,
            correct,
            "Legend shows all task categories.",
            f"Legend is missing some categories: {categories - legend_labels}",
        )

    def test_chart_title_and_xlabel(self):
        fig, ax = self._render()
        title = ax.get_title()
        xlabel = ax.get_xlabel()
        correct = "gantt" in normalize_text(title) and "day" in normalize_text(xlabel)
        _dynamic_test(
            self,
            correct,
            "Chart displays a title and x-axis label.",
            f"Chart missing required title or x-axis label: title='{title}', xlabel='{xlabel}'",
        )


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
    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 not assign_nodes:
        return code
    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 civil engineers to solve real-world engineering problems, automate calculations, and analyze data. This course blends practical coding with civil engineering scenarios, focusing on structural analysis, materials, and project management.

Learn how Python can be used to automate and solve common structural analysis problems in civil engineering, including beam calculations, load analysis, and visualization of structural responses.

Apply Python to analyze and visualize data related to construction materials, quality control, and site measurements, supporting better engineering decisions.

Use Python to automate project management tasks, optimize resource allocation, and support decision-making in civil engineering projects.

Challenge: Gantt Chart Visualization

Ratkaisu