In architectural projects, managing **material costs** is a crucial part of staying within budget. You often need to calculate not only the cost of each material but also the **total cost for the entire project**. Suppose you are given two dictionaries: one representing the quantities of materials required and another representing the unit cost for each material. Your task is to write a function that computes the total cost for each material and then sums these to provide the overall project cost, storing this under the key `"Total"` in the result.

To solve this, you will:

- Iterate through the materials;
- Multiply each material's quantity by its unit cost;
- Store the result in a new dictionary;
- After calculating all individual material costs, sum these values to get the total project cost and add it to the dictionary with the key `"Total"`.

This approach ensures that you have both a **detailed breakdown** and a **single summary value**, which is useful for architects during project planning.

material_quantities = {
    "Concrete": 100,
    "Steel": 50,
    "Glass": 30
}

unit_costs = {
    "Concrete": 120,
    "Steel": 300,
    "Glass": 200
}

def calculate_material_costs(quantities, costs):
    result = {}
    total = 0
    for material in quantities:
        if material in costs:
            cost = quantities[material] * costs[material]
            result[material] = cost
            total += cost
        else:
            result[material] = "No unit cost available"
    result["Total"] = total
    return result

cost_summary = calculate_material_costs(material_quantities, unit_costs)
print(cost_summary)
# Output: {'Concrete': 12000, 'Steel': 15000, 'Glass': 6000, 'Total': 33000}

This pattern of combining two dictionaries—one for **quantities** and one for **unit prices**—can be applied to various architectural calculations. By automating this process, you reduce the risk of manual errors and save time, especially when dealing with large projects or frequent updates to material prices. You also make it easy to adjust quantities or prices and instantly see the impact on the overall budget.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_basic_case(self):
        import user_code
        importlib.reload(user_code)
        quantities = {"Brick": 500, "Wood": 250, "Glass": 100}
        unit_costs = {"Brick": 2, "Wood": 5, "Glass": 10}
        result = user_code.material_cost_calculator(quantities, unit_costs)
        expected = {'Brick': 1000, 'Wood': 1250, 'Glass': 1000, 'Total': 3250}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Function returns correct dictionary for standard case.",
            f"Expected {expected}, got {result}",
        )

    def test_missing_material_in_unit_costs(self):
        import user_code
        importlib.reload(user_code)
        quantities = {"Brick": 500, "Wood": 250, "Glass": 100, "Concrete": 50}
        unit_costs = {"Brick": 2, "Wood": 5, "Glass": 10}
        result = user_code.material_cost_calculator(quantities, unit_costs)
        expected = {'Brick': 1000, 'Wood': 1250, 'Glass': 1000, 'Concrete': 0, 'Total': 3250}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Handles missing material in unit_costs by setting cost to 0.",
            f"Expected {expected}, got {result}",
        )

    def test_empty_quantities(self):
        import user_code
        importlib.reload(user_code)
        quantities = {}
        unit_costs = {"Brick": 2, "Wood": 5, "Glass": 10}
        result = user_code.material_cost_calculator(quantities, unit_costs)
        expected = {'Total': 0}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Returns only 'Total': 0 for empty quantities.",
            f"Expected {expected}, got {result}",
        )

    def test_zero_quantity(self):
        import user_code
        importlib.reload(user_code)
        quantities = {"Brick": 0, "Wood": 0, "Glass": 0}
        unit_costs = {"Brick": 2, "Wood": 5, "Glass": 10}
        result = user_code.material_cost_calculator(quantities, unit_costs)
        expected = {'Brick': 0, 'Wood': 0, 'Glass': 0, 'Total': 0}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Handles zero quantities correctly.",
            f"Expected {expected}, got {result}",
        )

    def test_extra_unit_costs(self):
        import user_code
        importlib.reload(user_code)
        quantities = {"Brick": 100}
        unit_costs = {"Brick": 2, "Wood": 5, "Glass": 10, "Concrete": 100}
        result = user_code.material_cost_calculator(quantities, unit_costs)
        expected = {'Brick': 200, 'Total': 200}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Ignores extra unit_costs not present in quantities.",
            f"Expected {expected}, got {result}",
        )

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

A hands-on course designed for architects to leverage Python for solving real-world architectural problems, including data analysis, geometry, visualization, and automation. This course blends architectural thinking with Python programming, focusing on practical applications relevant to the field.

Learn to analyze, manipulate, and summarize architectural data using Python and pandas. This section focuses on extracting insights from building data, room schedules, and material lists.

Apply Python to solve geometric and spatial problems relevant to architectural design, such as calculating areas, perimeters, and analyzing spatial relationships.

Harness Python's visualization libraries and automation capabilities to streamline architectural analysis and presentation.

Challenge: Material Cost Calculator

Solution