#!/usr/bin/env python3 import json import os import math from pathlib import Path import subprocess import tempfile DESKTOP = Path(os.environ.get("ENGIWORLD_DESKTOP", "/home/user/Desktop")) SPEC = {'required_outputs': {'result.osm': 500}, 'object_counts': {'OS:BuildingStory': 1, 'OS:Space': 1, 'OS:ThermalZone': 1, 'OS:Surface': 6, 'OS:SubSurface': 0}, 'space_names': ['EquipmentRoom'], 'surface_counts': {'Floor': 1, 'RoofCeiling': 1, 'Wall': 4}, 'outside_boundary_counts': {'Ground': 1, 'Outdoors': 5, 'Surface': 0}, 'window_count': 0, 'fixed_window_count': 0, 'bbox_spans_m': [7.0, 5.0, 3.2], 'floor_area_m2': 35.0, 'exterior_wall_area_m2': 76.8, 'window_area_m2': 0, 'hvac': {'ideal_loads': 0, 'equipment_lists': 1, 'thermostats': 0}, 'loads': {'min_schedules': 1, 'people': 0, 'lights': 0, 'electric_equipment': 1, 'space_types': 0}} GUI_BYPASS_FORBIDDEN_EXTENSIONS = { ".py", ".pyw", ".ipynb", ".sh", ".bash", ".zsh", ".bat", ".cmd", ".ps1", ".psm1", ".psd1", ".vbs", ".js", ".mjs", ".ts", ".rb", ".lua", ".tcl", ".ahk", ".scr" } GUI_BYPASS_ALLOWED_FILENAMES = {"eval.py"} GUI_BYPASS_OUTPUT_TOKENS = ( "result.ifc", "result.pdf", "result.osm", "workflow.osw", "summary.txt", "report.csv", "result.csv", "kpis.json" ) GUI_BYPASS_COMMAND_TOKENS = ( "python", "python3", "py ", "powershell", "pwsh", "cmd.exe", "cmd /c", "bash", " sh ", "zsh", "node", "ruby", "perl", "ifcopenshell", "openstudio", "energyplus", "blender --background", "revitbatchprocessor" ) WINDOW_TYPES = {"FixedWindow", "OperableWindow", "GlassDoor", "Skylight"} def finish(ok): print("True" if ok else "False") raise SystemExit(0) def approx(actual, expected, abs_tol, rel_tol=0.0): return abs(float(actual) - float(expected)) <= max(float(abs_tol), abs(float(expected)) * float(rel_tol)) def _read_text_safe(path): try: return path.read_text(encoding="utf-8", errors="ignore") except Exception: return "" def _desktop_script_artifacts(root): if not root.exists() or not root.is_dir(): return True try: candidates = list(root.iterdir()) for directory in list(candidates): if directory.is_dir() and directory.name not in {"__pycache__", "_runtime"}: try: candidates.extend(directory.iterdir()) except Exception: pass for path in candidates: if not path.is_file() or path.name in GUI_BYPASS_ALLOWED_FILENAMES: continue if path.suffix.lower() in GUI_BYPASS_FORBIDDEN_EXTENSIONS: return True except Exception: return True return False def _history_contains_bypass(root): home = Path.home() paths = [ home / ".bash_history", home / ".zsh_history", home / ".python_history", home / ".local/share/fish/fish_history", root / ".bash_history", root / ".zsh_history", ] for path in paths: if not path.is_file(): continue text = _read_text_safe(path).lower() for raw_line in text.splitlines(): line = raw_line.strip() if not line or "eval.py" in line: continue touches_output = any(token in line for token in GUI_BYPASS_OUTPUT_TOKENS) runs_command = any(token in line for token in GUI_BYPASS_COMMAND_TOKENS) writes_file = any(token in line for token in (">", "tee ", "cat ", "set-content", "out-file", "new-item")) if touches_output and (runs_command or writes_file): return True if ("/desktop/" in line or "\\desktop\\" in line) and any(ext in line for ext in GUI_BYPASS_FORBIDDEN_EXTENSIONS) and runs_command: return True return False def check_no_gui_bypass(root): root = Path(root) return not _desktop_script_artifacts(root) and not _history_contains_bypass(root) OPENSTUDIO_DUMP_RUBY = r""" require 'openstudio' require 'json' path = ARGV[0] loaded = OpenStudio::IdfFile.load(path) if loaded.empty? STDERR.puts("OpenStudio could not load #{path}") exit 2 end idf = loaded.get objects = [] version = idf.versionObject objects << version.get unless version.empty? objects.concat(idf.objects) objects = objects.map do |object| fields = [] (0...object.numFields).each do |index| fields << object.getField(index).to_s end {"type" => object.iddObject.name.to_s, "fields" => fields} end STDOUT.write(JSON.generate(objects)) """ def parse_osm(path): with tempfile.NamedTemporaryFile("w", suffix=".rb", delete=False, encoding="utf-8") as script: script.write(OPENSTUDIO_DUMP_RUBY) script_path = Path(script.name) try: proc = subprocess.run( ["openstudio", "execute_ruby_script", str(script_path), str(path)], text=True, capture_output=True, timeout=30, ) finally: script_path.unlink(missing_ok=True) if proc.returncode != 0: raise ValueError(proc.stderr.strip() or proc.stdout.strip() or "OpenStudio failed to parse OSM") payload = proc.stdout.strip() start = payload.find("[") if start > 0: payload = payload[start:] return json.loads(payload) def by_type(objects, object_type): return [obj for obj in objects if obj["type"] == object_type] def handle(obj): return obj["fields"][0] if obj["fields"] else "" def name(obj): return obj["fields"][1] if len(obj["fields"]) > 1 else "" def parse_float(value): text = str(value).strip() if not text or text.lower() == "autosize": raise ValueError(text) return float(text) def parse_vertices(fields, start_index): values = [parse_float(v) for v in fields[start_index:]] if len(values) % 3 != 0 or not values: raise ValueError("invalid vertices") return [(values[i], values[i + 1], values[i + 2]) for i in range(0, len(values), 3)] def polygon_area_3d(points): sx = sy = sz = 0.0 for i, p1 in enumerate(points): p2 = points[(i + 1) % len(points)] sx += (p1[1] - p2[1]) * (p1[2] + p2[2]) sy += (p1[2] - p2[2]) * (p1[0] + p2[0]) sz += (p1[0] - p2[0]) * (p1[1] + p2[1]) return 0.5 * math.sqrt(sx * sx + sy * sy + sz * sz) def bbox(points): xs = [p[0] for p in points] ys = [p[1] for p in points] zs = [p[2] for p in points] return min(xs), min(ys), min(zs), max(xs), max(ys), max(zs) def surface_data(objects): result = [] for obj in by_type(objects, "OS:Surface"): fields = obj["fields"] if len(fields) < 14: raise ValueError("surface has too few fields") points = parse_vertices(fields, 11) result.append({ "handle": handle(obj), "type": fields[2], "space": fields[4], "obc": fields[5], "vertices": points, "area": polygon_area_3d(points), }) return result def subsurface_data(objects): result = [] for obj in by_type(objects, "OS:SubSurface"): fields = obj["fields"] if len(fields) < 13: raise ValueError("subsurface has too few fields") points = parse_vertices(fields, 10) result.append({ "handle": handle(obj), "type": fields[2], "surface": fields[4], "vertices": points, "area": polygon_area_3d(points), }) return result def shading_surface_data(objects): result = [] for obj in by_type(objects, "OS:ShadingSurface"): fields = obj["fields"] if len(fields) < 8: raise ValueError("shading surface has too few fields") points = parse_vertices(fields, 6) result.append({"handle": handle(obj), "vertices": points, "area": polygon_area_3d(points)}) return result def metrics(objects): surfaces = surface_data(objects) subsurfaces = subsurface_data(objects) shading = shading_surface_data(objects) all_points = [point for surface in surfaces for point in surface["vertices"]] bounds = bbox(all_points) spans = (bounds[3] - bounds[0], bounds[4] - bounds[1], bounds[5] - bounds[2]) floors = [s for s in surfaces if s["type"] == "Floor"] exterior_walls = [s for s in surfaces if s["type"] == "Wall" and s["obc"] == "Outdoors"] windows = [s for s in subsurfaces if s["type"] in WINDOW_TYPES] floor_area_by_space = {} for floor in floors: floor_area_by_space[floor["space"]] = floor_area_by_space.get(floor["space"], 0.0) + floor["area"] return { "surfaces": surfaces, "subsurfaces": subsurfaces, "shading": shading, "spans": spans, "windows": windows, "floor_area": sum(s["area"] for s in floors), "exterior_wall_area": sum(s["area"] for s in exterior_walls), "window_area": sum(s["area"] for s in windows), "shading_area": sum(s["area"] for s in shading), "floor_area_by_space": floor_area_by_space, } def check_required_outputs(root): for rel, min_bytes in SPEC["required_outputs"].items(): path = root / rel if not path.is_file() or path.stat().st_size < min_bytes: return False return True def check_counts(objects, data): for object_type, expected in SPEC.get("object_counts", {}).items(): if len(by_type(objects, object_type)) != int(expected): return False if SPEC.get("space_names") is not None: if sorted(name(obj) for obj in by_type(objects, "OS:Space")) != sorted(SPEC["space_names"]): return False for surface_type, expected in SPEC.get("surface_counts", {}).items(): if sum(1 for s in data["surfaces"] if s["type"] == surface_type) != int(expected): return False for obc, expected in SPEC.get("outside_boundary_counts", {}).items(): if sum(1 for s in data["surfaces"] if s["obc"] == obc) != int(expected): return False if SPEC.get("window_count") is not None and len(data["windows"]) != int(SPEC["window_count"]): return False if SPEC.get("fixed_window_count") is not None and sum(1 for w in data["windows"] if w["type"] == "FixedWindow") != int(SPEC["fixed_window_count"]): return False if SPEC.get("shading_surface_count") is not None and len(data["shading"]) != int(SPEC["shading_surface_count"]): return False return True def check_model_integrity(objects, data): # Every interzone Surface boundary must point to one peer and that peer # must point back. Names may vary unless SPEC explicitly names the pair. surfaces_by_handle = {surface["handle"]: surface for surface in data["surfaces"]} for surface in data["surfaces"]: if surface["obc"] != "Surface": continue peer = surfaces_by_handle.get(surface["obc_object"]) if not peer or peer["obc"] != "Surface" or peer["obc_object"] != surface["handle"]: return False surface_handles = set(surfaces_by_handle) if any(subsurface["surface"] not in surface_handles for subsurface in data["subsurfaces"]): return False zones = {handle(obj) for obj in by_type(objects, "OS:ThermalZone")} equipment_lists = by_type(objects, "OS:ZoneHVAC:EquipmentList") equipment_targets = [obj["fields"][2] for obj in equipment_lists if len(obj["fields"]) > 2] if any(target not in zones for target in equipment_targets): return False if len(equipment_lists) == len(zones) and set(equipment_targets) != zones: return False thermostats = {handle(obj) for obj in by_type(objects, "OS:ThermostatSetpoint:DualSetpoint")} zone_thermostats = {obj["fields"][19] for obj in by_type(objects, "OS:ThermalZone") if len(obj["fields"]) > 19 and obj["fields"][19]} if thermostats != zone_thermostats: return False schedule_handles = {handle(obj) for obj in by_type(objects, "OS:Schedule:Ruleset")} for thermostat in by_type(objects, "OS:ThermostatSetpoint:DualSetpoint"): fields = thermostat["fields"] if len(fields) < 4 or fields[2] not in schedule_handles or fields[3] not in schedule_handles: return False spaces = {handle(obj) for obj in by_type(objects, "OS:Space")} space_types = {handle(obj) for obj in by_type(objects, "OS:SpaceType")} valid_targets = spaces | space_types load_rules = SPEC.get("loads", {}) load_types = [ ("OS:People", "OS:People:Definition", "people_definitions"), ("OS:Lights", "OS:Lights:Definition", "lights_definitions"), ("OS:ElectricEquipment", "OS:ElectricEquipment:Definition", "electric_equipment_definitions"), ] for object_type, definition_type, definition_key in load_types: definitions = {handle(obj) for obj in by_type(objects, definition_type)} if definition_key in load_rules and len(definitions) != int(load_rules[definition_key]): return False load_objects = by_type(objects, object_type) targets = [] for load in load_objects: fields = load["fields"] if len(fields) < 5 or fields[2] not in definitions or fields[3] not in valid_targets or fields[4] not in schedule_handles: return False targets.append(fields[3]) # When there is one instance per space and no SpaceType, the task's # direct-space loads must cover every space, not duplicate one space. if not space_types and load_objects and len(load_objects) == len(spaces) and set(targets) != spaces: return False if "space_type_name" in load_rules: matching = [obj for obj in by_type(objects, "OS:SpaceType") if name(obj) == load_rules["space_type_name"]] if len(matching) != 1: return False space_type_handle = handle(matching[0]) if any(len(space["fields"]) < 3 or space["fields"][2] != space_type_handle for space in by_type(objects, "OS:Space")): return False for object_type in ("OS:People", "OS:Lights"): if any(len(obj["fields"]) < 4 or obj["fields"][3] != space_type_handle for obj in by_type(objects, object_type)): return False people_schedules = {obj["fields"][4] for obj in by_type(objects, "OS:People")} lights_schedules = {obj["fields"][4] for obj in by_type(objects, "OS:Lights")} if people_schedules & lights_schedules: return False return True def check_space_links(objects, data): stories = {handle(obj) for obj in by_type(objects, "OS:BuildingStory")} zones = {handle(obj) for obj in by_type(objects, "OS:ThermalZone")} for space in by_type(objects, "OS:Space"): fields = space["fields"] if len(fields) < 11 or fields[9] not in stories or fields[10] not in zones: return False if data["floor_area_by_space"].get(handle(space), 0.0) <= 0.05: return False return True def check_geometry(data): for actual, expected in zip(data["spans"], SPEC["bbox_spans_m"]): if not approx(actual, expected, SPEC.get("dimension_tolerance_m", 0.1)): return False for key, data_key in [ ("floor_area_m2", "floor_area"), ("exterior_wall_area_m2", "exterior_wall_area"), ("window_area_m2", "window_area"), ("shading_area_m2", "shading_area"), ]: if key in SPEC and not approx(data[data_key], SPEC[key], SPEC.get("area_tolerance_m2", 0.75)): return False return True def check_hvac(objects): hvac = SPEC.get("hvac", {}) mapping = { "ideal_loads": "OS:ZoneHVAC:IdealLoadsAirSystem", "equipment_lists": "OS:ZoneHVAC:EquipmentList", "thermostats": "OS:ThermostatSetpoint:DualSetpoint", } return all(len(by_type(objects, object_type)) == expected for key, object_type in mapping.items() for expected in [hvac.get(key, 0)]) def check_loads(objects): loads = SPEC.get("loads", {}) mapping = { "people": "OS:People", "lights": "OS:Lights", "electric_equipment": "OS:ElectricEquipment", "space_types": "OS:SpaceType", } if len(by_type(objects, "OS:Schedule:Ruleset")) < loads.get("min_schedules", 0): return False return all(len(by_type(objects, object_type)) == expected for key, object_type in mapping.items() for expected in [loads.get(key, 0)]) def evaluate(): root = DESKTOP if not check_no_gui_bypass(root): return False if not root.is_dir() or not check_required_outputs(root): return False objects = parse_osm(root / "result.osm") data = metrics(objects) return ( check_counts(objects, data) and check_model_integrity(objects, data) and check_space_links(objects, data) and check_geometry(data) and check_hvac(objects) and check_loads(objects) ) def main(): try: finish(evaluate()) except SystemExit: raise except Exception: finish(False) if __name__ == "__main__": main()