After exploring cost estimation and budget tracking in civil engineering projects, you have seen how crucial it is to keep expenses under control. Automated budget monitoring not only saves time but also helps prevent costly overruns by providing immediate feedback on project spending. By leveraging Python, you can quickly compare estimated and actual costs, making sure your project stays on track for financial success.


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 setUp(self):
        self.project_items = [
            {"name": "Concrete", "estimated_cost": 5000, "actual_cost": 5200},
            {"name": "Steel", "estimated_cost": 7000, "actual_cost": 6800},
            {"name": "Labor", "estimated_cost": 8000, "actual_cost": 8500},
            {"name": "Equipment", "estimated_cost": 3000, "actual_cost": 3000}
        ]

    def test_overrun_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Patch print to capture output
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.track_budget(self.project_items)
        output = f.getvalue()
        # Check summary table rows
        expected_summary = [
            {'Item': 'Concrete', 'Estimated Cost': 5000, 'Actual Cost': 5200, 'Overrun': 200},
            {'Item': 'Steel', 'Estimated Cost': 7000, 'Actual Cost': 6800, 'Overrun': -200},
            {'Item': 'Labor', 'Estimated Cost': 8000, 'Actual Cost': 8500, 'Overrun': 500},
            {'Item': 'Equipment', 'Estimated Cost': 3000, 'Actual Cost': 3000, 'Overrun': 0}
        ]
        for expected_row in expected_summary:
            # Convert dict to normalized string for comparison
            expected_row_str = normalize_text(str(expected_row))
            _dynamic_test(
                self,
                expected_row_str in normalize_text(output),
                f"Summary row includes: {expected_row}",
                f"Expected summary row: {expected_row} not found in output: {output}",
            )

    def test_warning_messages(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.track_budget(self.project_items)
        output = normalize_text(f.getvalue())
        expected_warnings = [
            "Warning: Concrete is over budget by 200",
            "Warning: Labor is over budget by 500"
        ]
        for warning in expected_warnings:
            _dynamic_test(
                self,
                normalize_text(warning) in output,
                f"Warning message for {warning} present",
                f"Expected warning: '{warning}' not found in output: {output}",
            )
        # Ensure no warning for Steel or Equipment
        not_expected = [
            "Warning: Steel is over budget by -200",
            "Warning: Equipment is over budget by 0"
        ]
        for warning in not_expected:
            _dynamic_test(
                self,
                normalize_text(warning) not in output,
                f"No warning for non-overrun item: {warning}",
                f"Unexpected warning found for non-overrun item: {warning}",
            )

    def test_summary_table_header(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.track_budget(self.project_items)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "summary table:" in output,
            "Summary table header is printed",
            "Expected 'Summary Table:' header not found in 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: Budget Tracking Script

Ratkaisu