Spaces:
Running on Zero
Running on Zero
| """Static checks for a generated bpy script, used both as an agent tool and as the acceptance gate. | |
| Without a Blender backend this is the only verification, so it is deliberately conservative: | |
| errors reject the sample, warnings are recorded but do not. | |
| """ | |
| import argparse | |
| import ast | |
| import json | |
| import sys | |
| from pathlib import Path | |
| MAX_BYTES = 200_000 | |
| FORBIDDEN_MODULES = { | |
| "subprocess", "socket", "requests", "urllib", "http", "ftplib", "smtplib", | |
| "multiprocessing", "ctypes", "shutil", "webbrowser", "asyncio", | |
| } | |
| FORBIDDEN_CALLS = { | |
| "os.system", "os.popen", "os.remove", "os.unlink", "os.rmdir", "os.removedirs", | |
| "os.rename", "os.replace", "os.kill", "os.fork", "os.execv", "os.execvp", | |
| "exec", "eval", "compile", "__import__", | |
| } | |
| # The script renders the video itself (bpy.ops.render.render); saving and process lifetime belong to the harness. | |
| REQUIRED_RENDER_CALL = "bpy.ops.render.render" | |
| FORBIDDEN_BPY_OPS = { | |
| "bpy.ops.render.opengl", | |
| "bpy.ops.wm.save_as_mainfile", "bpy.ops.wm.save_mainfile", "bpy.ops.wm.quit_blender", | |
| "bpy.ops.wm.open_mainfile", "bpy.ops.wm.read_homefile", | |
| } | |
| ANIMATION_MARKERS = { | |
| "keyframe_insert", "driver_add", "fcurves", "keyframe_points", | |
| "rigidbody", "rigid_body", "frame_change_pre", "frame_change_post", "constraints", | |
| } | |
| def _dotted(node: ast.AST) -> str: | |
| parts = [] | |
| while isinstance(node, ast.Attribute): | |
| parts.append(node.attr) | |
| node = node.value | |
| if isinstance(node, ast.Name): | |
| parts.append(node.id) | |
| return ".".join(reversed(parts)) | |
| return "" | |
| def check_source(source: str) -> dict: | |
| errors: list[str] = [] | |
| warnings: list[str] = [] | |
| if len(source.encode()) > MAX_BYTES: | |
| errors.append(f"script is larger than {MAX_BYTES} bytes") | |
| try: | |
| tree = ast.parse(source) | |
| except SyntaxError as e: | |
| return {"ok": False, "errors": [f"SyntaxError: {e.msg} (line {e.lineno})"], "warnings": [], "stats": {}} | |
| imports: set[str] = set() | |
| calls: set[str] = set() | |
| attrs: set[str] = set() | |
| assigned_attrs: set[str] = set() | |
| for node in ast.walk(tree): | |
| if isinstance(node, ast.Import): | |
| imports.update(a.name.split(".")[0] for a in node.names) | |
| elif isinstance(node, ast.ImportFrom) and node.module: | |
| imports.add(node.module.split(".")[0]) | |
| elif isinstance(node, ast.Call): | |
| calls.add(_dotted(node.func)) | |
| elif isinstance(node, ast.Attribute): | |
| attrs.add(node.attr) | |
| elif isinstance(node, ast.Constant) and isinstance(node.value, str): | |
| attrs.add(node.value) # e.g. keyframe_insert(data_path=...) or getattr(obj, "constraints") | |
| if isinstance(node, (ast.Assign, ast.AugAssign, ast.AnnAssign)): | |
| targets = node.targets if isinstance(node, ast.Assign) else [node.target] | |
| assigned_attrs.update(t.attr for t in targets if isinstance(t, ast.Attribute)) | |
| if "bpy" not in imports: | |
| errors.append("script does not import bpy") | |
| for mod in sorted(imports & FORBIDDEN_MODULES): | |
| errors.append(f"forbidden import: {mod}") | |
| for call in sorted(calls & (FORBIDDEN_CALLS | FORBIDDEN_BPY_OPS)): | |
| errors.append(f"forbidden call: {call} (only the video render may write output)") | |
| if REQUIRED_RENDER_CALL not in calls: | |
| errors.append("no render: the script must end with bpy.ops.render.render(animation=True)") | |
| has_camera = "camera" in assigned_attrs or "bpy.ops.object.camera_add" in calls | |
| if not has_camera: | |
| errors.append("no camera: create a camera and assign it to scene.camera") | |
| if not (attrs & ANIMATION_MARKERS): | |
| warnings.append("no animation detected (keyframes, drivers, constraints or physics)") | |
| if "open" in calls: | |
| warnings.append("script calls open(); external files are not available") | |
| stats = {"lines": source.count("\n") + 1, "bytes": len(source.encode()), "n_bpy_ops_calls": sum(c.startswith("bpy.ops.") for c in calls)} | |
| return {"ok": not errors, "errors": errors, "warnings": warnings, "stats": stats} | |
| def check_file(path: Path) -> dict: | |
| if not path.is_file(): | |
| return {"ok": False, "errors": [f"{path} not found"], "warnings": [], "stats": {}} | |
| return check_source(path.read_text(encoding="utf-8", errors="replace")) | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description="Static checks for a Blender bpy script.") | |
| parser.add_argument("script", nargs="?", default="main.py") | |
| parser.add_argument("--json", action="store_true") | |
| args = parser.parse_args() | |
| result = check_file(Path(args.script)) | |
| if args.json: | |
| print(json.dumps(result, indent=2)) | |
| else: | |
| print("STATIC CHECK " + ("PASSED" if result["ok"] else "FAILED")) | |
| for e in result["errors"]: | |
| print(f"error: {e}") | |
| for w in result["warnings"]: | |
| print(f"warning: {w}") | |
| if result["stats"]: | |
| print(f"stats: {json.dumps(result['stats'])}") | |
| sys.exit(0 if result["ok"] else 1) | |
| if __name__ == "__main__": | |
| main() | |