Architects often need to quickly assess the proportions of different rooms to ensure they meet design standards and functional requirements. One way to do this is by classifying rooms based on their **aspect ratios**, which compare the `width` and `length` of a room. An aspect ratio close to `1:1` usually indicates a **square** room, while larger or smaller ratios suggest the room is either **wide** or **narrow**. In this challenge, you will write a function that analyzes a list of rooms, each with a specified `width` and `length`, and classifies their proportions as either `'Square'`, `'Wide'`, or `'Narrow'`.


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

class TestTask(unittest.TestCase):
    # def test_sample_data_classification(self):
    #     import user_code
    #     importlib.reload(user_code)
    #     func = getattr(user_code, 'classify_room_proportions', None)
    #     _dynamic_test(
    #         self,
    #         callable(func),
    #         "Function classify_room_proportions is defined and callable",
    #         "Function classify_room_proportions is not defined or not callable"
    #     )
    #     rooms = [
    #         {"name": "Gallery", "width": 6.0, "length": 6.5},
    #         {"name": "Studio", "width": 3.5, "length": 3.4},
    #         {"name": "Library", "width": 4.0, "length": 5.0},
    #         {"name": "Lounge", "width": 5.5, "length": 4.5},
    #         {"name": "Hall", "width": 7.0, "length": 7.0}
    #     ]
    #     expected = {
    #         'Gallery': 'Narrow',
    #         'Studio': 'Square',
    #         'Library': 'Narrow',
    #         'Lounge': 'Wide',
    #         'Hall': 'Square'
    #     }
    #     result = func(rooms) if func else None
    #     _dynamic_test(
    #         self,
    #         isinstance(result, dict),
    #         "Function returns a dictionary",
    #         f"Expected a dictionary, got {type(result)}"
    #     )
    #     _dynamic_test(
    #         self,
    #         result == expected,
    #         "Function returns correct classification for sample data",
    #         f"Expected {expected}, got {result}"
    #     )

    def test_square_threshold(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'classify_room_proportions', None)
        rooms = [
            {"name": "Room1", "width": 10.0, "length": 9.1}, # just inside square
            {"name": "Room2", "width": 10.0, "length": 11.1}, # just inside square
            {"name": "Room3", "width": 10.0, "length": 8.9}, # just outside square (wide)
            {"name": "Room4", "width": 10.0, "length": 11.2} # just outside square (narrow)
        ]
        expected = {
            "Room1": "Square",
            "Room2": "Square",
            "Room3": "Wide",
            "Room4": "Narrow"
        }
        result = func(rooms) if func else None
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary for threshold test",
            f"Expected a dictionary, got {type(result)}"
        )
        _dynamic_test(
            self,
            result == expected,
            "Function correctly applies 10% threshold for 'Square' rooms",
            f"Expected {expected}, got {result}"
        )

    def test_empty_list(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'classify_room_proportions', None)
        result = func([]) if func else None
        _dynamic_test(
            self,
            isinstance(result, dict) and len(result) == 0,
            "Function returns empty dictionary for empty input list",
            f"Expected empty dict for empty input, 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: Room Proportion Analyzer

Løsning