You are tasked with creating a function that calculates key envelope properties for a rectangular building. These properties are important in architectural design for understanding the building's exterior boundaries and surfaces. The function you need to write will take three measurements: the length, width, and height of the building. Using these, you will compute three values: the perimeter of the building's base, the total wall surface area (excluding the roof and floor), and the area of the roof.

First, consider the **perimeter**. For a rectangle, the perimeter is the sum of all four sides. In this case, the formula is `2 * (length + width)`. Next, the **wall surface area** includes the four vertical sides of the building, but not the roof or floor. Each pair of opposite walls has the same area: two walls are `length x height` and the other two are `width x height`. Add these together to get the total wall area: `2 * (length * height) + 2 * (width * height)`. Finally, the **area of the roof** is simply the area of the rectangle at the top of the building: `length * width`.

You will return these values in a dictionary with the keys `'perimeter'`, `'wall_area'`, and `'roof_area'`. Each value should be a float or integer, depending on the input. This function will be useful for quickly assessing building envelope properties in various architectural calculations.


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

class TestTask(unittest.TestCase):
    def test_basic_example(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'envelope_calculator', None)
        _dynamic_test(
            self,
            callable(func),
            "Function envelope_calculator is defined",
            "Function envelope_calculator is not defined",
        )
        result = func(30, 20, 10) if func else None
        expected = {'perimeter': 100, 'wall_area': 1000, 'roof_area': 600}
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary",
            f"Expected a dictionary, got {type(result)}",
        )
        for key in expected:
            _dynamic_test(
                self,
                key in result and result[key] == expected[key],
                f"Key '{key}' is present and correct for (30, 20, 10)",
                f"Expected {key}: {expected[key]}, got: {result.get(key, None)}",
            )

    def test_float_inputs(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'envelope_calculator', None)
        result = func(12.5, 8.0, 3.2) if func else None
        expected = {
            'perimeter': 2 * (12.5 + 8.0),
            'wall_area': 2 * (12.5 * 3.2) + 2 * (8.0 * 3.2),
            'roof_area': 12.5 * 8.0
        }
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary for float inputs",
            f"Expected a dictionary, got {type(result)}",
        )
        for key in expected:
            _dynamic_test(
                self,
                key in result and abs(result[key] - expected[key]) < 1e-8,
                f"Key '{key}' is present and correct for float inputs",
                f"Expected {key}: {expected[key]}, got: {result.get(key, None)}",
            )

    def test_zero_height(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'envelope_calculator', None)
        result = func(15, 10, 0) if func else None
        expected = {
            'perimeter': 50,
            'wall_area': 0,
            'roof_area': 150
        }
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary for zero height",
            f"Expected a dictionary, got {type(result)}",
        )
        for key in expected:
            _dynamic_test(
                self,
                key in result and result[key] == expected[key],
                f"Key '{key}' is present and correct for zero height",
                f"Expected {key}: {expected[key]}, got: {result.get(key, None)}",
            )

    def test_zero_length_or_width(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'envelope_calculator', None)
        # Zero length
        result = func(0, 10, 5) if func else None
        expected = {
            'perimeter': 20,
            'wall_area': 2 * (0 * 5) + 2 * (10 * 5),
            'roof_area': 0
        }
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary for zero length",
            f"Expected a dictionary, got {type(result)}",
        )
        for key in expected:
            _dynamic_test(
                self,
                key in result and result[key] == expected[key],
                f"Key '{key}' is present and correct for zero length",
                f"Expected {key}: {expected[key]}, got: {result.get(key, None)}",
            )
        # Zero width
        result = func(12, 0, 7) if func else None
        expected = {
            'perimeter': 24,
            'wall_area': 2 * (12 * 7) + 2 * (0 * 7),
            'roof_area': 0
        }
        for key in expected:
            _dynamic_test(
                self,
                key in result and result[key] == expected[key],
                f"Key '{key}' is present and correct for zero width",
                f"Expected {key}: {expected[key]}, got: {result.get(key, None)}",
            )

    def test_negative_values(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'envelope_calculator', None)
        result = func(-10, 5, 2) if func else None
        expected = {
            'perimeter': 2 * (-10 + 5),
            'wall_area': 2 * (-10 * 2) + 2 * (5 * 2),
            'roof_area': -10 * 5
        }
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary for negative values",
            f"Expected a dictionary, got {type(result)}",
        )
        for key in expected:
            _dynamic_test(
                self,
                key in result and result[key] == expected[key],
                f"Key '{key}' is present and correct for negative values",
                f"Expected {key}: {expected[key]}, got: {result.get(key, None)}",
            )

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: Envelope Calculator

Solução