| |
| 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): |
| |
| |
| 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]) |
| |
| |
| 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() |
|
|
