| |
| from __future__ import annotations |
|
|
| import argparse |
| import ast |
| import hashlib |
| import json |
| import re |
| import subprocess |
| import sys |
| import xml.etree.ElementTree as ET |
| from pathlib import Path |
|
|
|
|
| FLOAT_RE = re.compile(r"(?<![A-Za-z0-9_])[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?(?![A-Za-z0-9_])") |
|
|
|
|
| def is_result_artifact(path: Path) -> bool: |
| name = path.name.lower() |
| return ( |
| any(k in name for k in ("summary", "result", "report", "diagnosis")) |
| or path.suffix.lower() in {".txt", ".csv", ".xy", ".result"} |
| ) |
|
|
|
|
| def is_nonempty_file(path: Path) -> bool: |
| return path.exists() and path.is_file() and path.stat().st_size > 0 |
|
|
|
|
| def read_text(path: Path) -> str: |
| return path.read_text(encoding="utf-8", errors="ignore") |
|
|
|
|
| def parse_floats(text: str) -> list[float]: |
| out: list[float] = [] |
| for token in FLOAT_RE.findall(text): |
| try: |
| out.append(float(token)) |
| except (TypeError, ValueError): |
| continue |
| return out |
|
|
|
|
| def write_result(path: Path, value: int) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps({"result": int(1 if value else 0)}, ensure_ascii=False) + "\n", encoding="utf-8") |
|
|
|
|
| def sha256(path: Path) -> str: |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def valid_xdmf(path: Path, expected_h5: str) -> bool: |
| try: |
| root = ET.parse(path).getroot() |
| except (ET.ParseError, OSError): |
| return False |
| hdf_items = [ |
| (node.text or "").strip() |
| for node in root.iter() |
| if node.tag.endswith("DataItem") and node.attrib.get("Format", "").upper() == "HDF" |
| ] |
| return bool(hdf_items) and all(item.startswith(expected_h5 + ":/") for item in hdf_items) |
|
|
|
|
| def parse_report(path: Path) -> dict[str, object]: |
| data: dict[str, object] = {} |
| for raw_line in read_text(path).splitlines(): |
| line = raw_line.strip() |
| if (not line) or line.startswith("#"): |
| continue |
| parts = [p.strip() for p in line.split(",")] |
| if len(parts) >= 3 and parts[0] in ("job_a", "job_b"): |
| vals_1 = parse_floats(parts[1]) |
| vals_2 = parse_floats(parts[2]) |
| if vals_1 and vals_2: |
| data[parts[0]] = (vals_1[0], vals_2[0]) |
| continue |
| if len(parts) >= 2 and parts[0] in ("Ratio_Mises", "Ratio_Displacement"): |
| vals = parse_floats(parts[1]) |
| if vals: |
| data[parts[0]] = vals[0] |
| return data |
|
|
|
|
| def check_task(root: Path) -> bool: |
| required = [ |
| "job_a.py", |
| "job_b.py", |
| "run_pipeline.py", |
| "compare.py", |
| ] |
| for rel in required: |
| if not is_nonempty_file(root / rel): |
| return False |
|
|
| expected_job_hashes = { |
| "job_a.py": "f09fb0fb7c90b5fe53135cc540c246f7398699455d98eecae12ef2120a5d205d", |
| "job_b.py": "5ec8262a3a1fcdbce13175651d6b4cf8b53e2b0694e4eef084ba6c2fcbe712af", |
| } |
| if any(sha256(root / name) != digest for name, digest in expected_job_hashes.items()): |
| return False |
|
|
| pipeline_source = read_text(root / "run_pipeline.py") |
| compare_source = read_text(root / "compare.py") |
| try: |
| ast.parse(pipeline_source, filename=str(root / "run_pipeline.py")) |
| ast.parse(compare_source, filename=str(root / "compare.py")) |
| except SyntaxError: |
| return False |
| generated = [ |
| "job_a.xdmf", "job_a.h5", "job_a_metrics.json", |
| "job_b.xdmf", "job_b.h5", "job_b_metrics.json", |
| "comparison_report.txt", |
| ] |
| for rel in generated: |
| (root / rel).unlink(missing_ok=True) |
| try: |
| pipeline = subprocess.run( |
| [sys.executable, str(root / "run_pipeline.py")], cwd=root, |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, |
| timeout=300, check=False, |
| ) |
| if pipeline.returncode != 0: |
| return False |
| comparison = subprocess.run( |
| [sys.executable, str(root / "compare.py")], cwd=root, |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, |
| timeout=60, check=False, |
| ) |
| except (OSError, subprocess.SubprocessError): |
| return False |
| if comparison.returncode != 0 or any(not is_nonempty_file(root / rel) for rel in generated): |
| return False |
| if not valid_xdmf(root / "job_a.xdmf", "job_a.h5") or not valid_xdmf(root / "job_b.xdmf", "job_b.h5"): |
| return False |
|
|
| data = parse_report(root / "comparison_report.txt") |
| if "job_a" not in data or "job_b" not in data: |
| return False |
| report_lines = [line.strip() for line in read_text(root / "comparison_report.txt").splitlines() if line.strip()] |
| if len(report_lines) != 4: |
| return False |
| expected_prefixes = ("job_a,", "job_b,", "Ratio_Mises,", "Ratio_Displacement,") |
| if any(not line.startswith(prefix) for line, prefix in zip(report_lines, expected_prefixes)): |
| return False |
|
|
| mises_a, uy_a = data["job_a"] |
| mises_b, uy_b = data["job_b"] |
|
|
| metrics_a = json.loads(read_text(root / "job_a_metrics.json")) |
| metrics_b = json.loads(read_text(root / "job_b_metrics.json")) |
| if abs(mises_a - float(metrics_a["max_mises_mpa"])) > 1e-6 * max(1.0, abs(mises_a)): |
| return False |
| if abs(uy_a - float(metrics_a["tip_uy_mm"])) > 1e-6 * max(1.0, abs(uy_a)): |
| return False |
| if abs(mises_b - float(metrics_b["max_mises_mpa"])) > 1e-6 * max(1.0, abs(mises_b)): |
| return False |
| if abs(uy_b - float(metrics_b["tip_uy_mm"])) > 1e-6 * max(1.0, abs(uy_b)): |
| return False |
|
|
| if not (mises_a > 0.0 and mises_b > mises_a and uy_a < 0.0 and uy_b < uy_a): |
| return False |
|
|
| if "Ratio_Mises" not in data or abs(float(data["Ratio_Mises"]) - 2.0) > 0.02: |
| return False |
| if "Ratio_Displacement" not in data or abs(float(data["Ratio_Displacement"]) - 2.0) > 0.02: |
| return False |
| return True |
|
|
| def evaluate() -> int: |
| root = Path("/home/user/Desktop") |
| try: |
| ok = check_task(root) |
| except Exception: |
| ok = False |
| return 1 if ok else 0 |
|
|
|
|
| def main() -> int: |
| result = evaluate() |
| print("True" if result == 1 else "False") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
