Project scheduling is a foundational aspect of civil engineering project management. By clearly defining **tasks**, **durations**, and **dependencies**, you can ensure that projects progress efficiently and avoid costly delays. Automated scheduling tools help transform complex task lists into actionable timelines, reducing manual errors and improving clarity for all stakeholders. Understanding how to compute **earliest start** and **finish times** for each task, given their dependencies, forms the backbone of effective project planning. This approach not only streamlines communication but also provides a solid basis for **resource allocation**, **risk management**, and **progress tracking**.


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 test_no_dependencies(self):
        import user_code
        importlib.reload(user_code)
        tasks = [
            {'name': 'A', 'duration': 2, 'dependencies': []},
            {'name': 'B', 'duration': 3, 'dependencies': []}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.calculate_schedule(tasks)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            'a' in output and 'b' in output,
            "Task names A and B are present in output",
            f"Expected task names in output, got: {output}"
        )
        _dynamic_test(
            self,
            '0' in output,
            "Start time 0 is present for tasks with no dependencies",
            f"Expected start time 0 in output, got: {output}"
        )
        _dynamic_test(
            self,
            '2' in output and '3' in output,
            "Finish times are correct for tasks with no dependencies",
            f"Expected finish times 2 and 3 in output, got: {output}"
        )

    def test_single_dependency(self):
        import user_code
        importlib.reload(user_code)
        tasks = [
            {'name': 'A', 'duration': 2, 'dependencies': []},
            {'name': 'B', 'duration': 3, 'dependencies': ['A']}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.calculate_schedule(tasks)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            'a' in output and 'b' in output,
            "Task names A and B are present in output",
            f"Expected task names in output, got: {output}"
        )
        _dynamic_test(
            self,
            '0' in output,
            "Start time 0 is present for task A",
            f"Expected start time 0 in output, got: {output}"
        )
        _dynamic_test(
            self,
            '2' in output,
            "Finish time 2 is present for task A",
            f"Expected finish time 2 in output, got: {output}"
        )
        _dynamic_test(
            self,
            '3' in output or '5' in output,
            "Finish time for task B is correct (should be 5)",
            f"Expected finish time 5 in output, got: {output}"
        )

    def test_multiple_dependencies(self):
        import user_code
        importlib.reload(user_code)
        tasks = [
            {'name': 'A', 'duration': 2, 'dependencies': []},
            {'name': 'B', 'duration': 3, 'dependencies': []},
            {'name': 'C', 'duration': 4, 'dependencies': ['A', 'B']}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.calculate_schedule(tasks)
        output = normalize_text(f.getvalue())
        # C starts at max(A.finish, B.finish) = max(2,3) = 3, finish at 7
        _dynamic_test(
            self,
            'c' in output,
            "Task C is present in output",
            f"Expected task C in output, got: {output}"
        )
        _dynamic_test(
            self,
            '3' in output,
            "Start time 3 is present for task C",
            f"Expected start time 3 in output, got: {output}"
        )
        _dynamic_test(
            self,
            '7' in output,
            "Finish time 7 is present for task C",
            f"Expected finish time 7 in output, got: {output}"
        )

    def test_schedule_table_format(self):
        import user_code
        importlib.reload(user_code)
        tasks = [
            {'name': 'Alpha', 'duration': 1, 'dependencies': []},
            {'name': 'Beta', 'duration': 2, 'dependencies': ['Alpha']}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.calculate_schedule(tasks)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            'task' in output and 'start' in output and 'finish' in output,
            "Schedule table headers are present in output",
            f"Expected headers in output, got: {output}"
        )
        _dynamic_test(
            self,
            'alpha' in output and 'beta' in output,
            "Task names Alpha and Beta are present in output",
            f"Expected task names in output, got: {output}"
        )

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 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: Task Scheduling Script

解答