@genex-ai/cli-demo 1.30.0-dev.644 → 1.31.0

package/templates/blender-service/ops.py

@@ -1,225 +0,0 @@
-"""Scene operations. Every mutating call runs on the HTTP server's own thread,
-which is Blender's main thread -- bpy is not thread-safe and the server is
-deliberately non-threading so this holds without a queue."""
-
-import contextlib
-import io
-import os
-import tempfile
-import traceback
-import urllib.parse
-import urllib.request
-
-import bpy
-
-from views import scene_bounds
-
-# The exec namespace PERSISTS across calls, so an agent can define a helper in
-# one step and use it in the next. That is the difference between a REPL and a
-# series of unrelated scripts.
-NAMESPACE = {}
-
-
-def reset_namespace():
-    import math
-    import random
-
-    import bmesh
-    import mathutils
-
-    NAMESPACE.clear()
-    NAMESPACE.update(
-        {"bpy": bpy, "bmesh": bmesh, "mathutils": mathutils, "math": math, "random": random}
-    )
-
-
-def run_script(source):
-    """Execute arbitrary Python against the live scene.
-
-    Arbitrary by design: a fixed tool vocabulary cannot express 'build a castle'.
-    The containment story is the container -- disposable, egress-locked in the
-    hosted path -- never a sanitizer on this string, which does not work.
-    """
-    out, err = io.StringIO(), io.StringIO()
-    error = None
-    with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
-        try:
-            exec(compile(source, "<genex-exec>", "exec"), NAMESPACE)
-        except Exception:
-            error = traceback.format_exc(limit=8)
-    return {"stdout": out.getvalue(), "stderr": err.getvalue(), "error": error}
-
-
-def _tri_count(obj):
-    if obj.type != "MESH" or obj.data is None:
-        return 0
-    return sum(max(len(p.vertices) - 2, 0) for p in obj.data.polygons)
-
-
-def scene_info():
-    """The numeric truths. These are the GATE -- the picture is for steering.
-
-    A screenshot judge is measurably bad at pass/fail (WorldCoder-Bench: a
-    screenshot+VLM gate passes 2.7% of outputs), so an agent should assert on
-    these counts and use the render to decide what to change.
-    """
-    objects, total_tris = [], 0
-    for obj in bpy.context.scene.objects:
-        tris = _tri_count(obj)
-        total_tris += tris
-        objects.append(
-            {
-                "name": obj.name,
-                "type": obj.type,
-                "tris": tris,
-                "location": [round(v, 4) for v in obj.location],
-                "dimensions": [round(v, 4) for v in obj.dimensions],
-                "materials": [m.name for m in obj.data.materials if m]
-                if getattr(obj.data, "materials", None)
-                else [],
-                "visible": obj.visible_get(),
-            }
-        )
-    center, radius = scene_bounds()
-    return {
-        "objectCount": len(objects),
-        "meshCount": sum(1 for o in objects if o["type"] == "MESH"),
-        "totalTris": total_tris,
-        "materialCount": len(bpy.data.materials),
-        "bounds": {
-            "center": [round(v, 4) for v in center],
-            "radius": round(radius, 4),
-        },
-        "objects": objects,
-    }
-
-
-def reset_scene():
-    bpy.ops.wm.read_factory_settings(use_empty=True)
-    reset_namespace()
-    return scene_info()
-
-
-# A picture the agent LOOKS AT goes inline; an artifact the GAME SHIPS goes to
-# object storage. Base64 inflates 4/3 plus JSON escaping, so ~7 MB of raw GLB
-# already blows RunPod's 10 MB /run ceiling -- and it fails only on long,
-# successful sessions that generated a lot of texture, which is the worst time.
-INLINE_GLB_MAX_BYTES = 6 * 1024 * 1024
-
-
-def export_glb(path):
-    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
-    bpy.ops.export_scene.gltf(filepath=path, export_format="GLB", use_selection=False)
-    return {"path": path, "bytes": os.path.getsize(path)}
-
-
-def upload_file(path, url, headers=None):
-    """PUT the bytes to a presigned URL. The service never holds an account key
-    -- the caller mints a single-object, short-TTL URL, so code running inside
-    /exec has nothing durable to steal."""
-    import urllib.request
-
-    with open(path, "rb") as f:
-        body = f.read()
-    req = urllib.request.Request(url, data=body, method="PUT")
-    for k, v in (headers or {}).items():
-        req.add_header(k, v)
-    with urllib.request.urlopen(req, timeout=300) as r:  # noqa: S310 - caller-minted
-        return {"status": r.status, "bytes": len(body)}
-
-
-def save_checkpoint(path):
-    """Whole-scene snapshot. Measured elsewhere at tens to hundreds of ms, and
-    it hides inside the agent's think time. What makes a pod disposable."""
-    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
-    bpy.ops.wm.save_as_mainfile(filepath=path, copy=True, compress=True)
-    return os.path.getsize(path)
-
-
-def load_checkpoint(path):
-    """Restore a snapshot. NOTE: this invalidates every live bpy reference, so
-    the exec namespace is reset alongside it -- a held Python handle raises
-    `StructRNA has been removed` long after the restore, somewhere unrelated."""
-    bpy.ops.wm.open_mainfile(filepath=path)
-    reset_namespace()
-
-
-def _host_allowed(url):
-    """Empty allowlist = permissive, which is correct for the admin-only spike
-    and wrong for the hosted lane. GENEX_BLENDER_IMPORT_HOSTS narrows it without
-    a code change when this reaches a session."""
-    allow = [h.strip() for h in os.environ.get("GENEX_BLENDER_IMPORT_HOSTS", "").split(",") if h.strip()]
-    if not allow:
-        return True
-    host = (urllib.parse.urlparse(url).hostname or "").lower()
-    return any(host == a.lower() or host.endswith("." + a.lower().lstrip(".")) for a in allow)
-
-
-def import_glb(url):
-    if not _host_allowed(url):
-        raise ValueError(f"import host not allowed: {urllib.parse.urlparse(url).hostname}")
-    before = {o.name for o in bpy.context.scene.objects}
-    fd, tmp = tempfile.mkstemp(suffix=".glb", prefix="genex-import-")
-    os.close(fd)
-    try:
-        with urllib.request.urlopen(url, timeout=60) as r:  # noqa: S310 - allowlisted above
-            with open(tmp, "wb") as f:
-                f.write(r.read())
-        bpy.ops.import_scene.gltf(filepath=tmp)
-    finally:
-        os.unlink(tmp)
-    added = [o.name for o in bpy.context.scene.objects if o.name not in before]
-    return {"imported": added, "count": len(added)}
-
-
-def scene_digest():
-    """A fingerprint of everything a render depends on, for the sheet-repeat guard.
-
-    Built from the data blocks directly, not from scene_info(): that summary
-    carries location, dimensions and material NAMES, and nothing else — so a
-    rotation, a scale, a modifier, a moved vertex, a dimmed light or a recoloured
-    material all hashed identically and the model was told the picture was
-    unchanged (review finding). Vertex coordinates go through numpy, so a 600k
-    triangle mesh costs one foreach_get and one hash rather than a Python loop.
-    """
-    import hashlib
-    h = hashlib.sha256()
-    scene = bpy.context.scene
-    for obj in scene.objects:
-        # The RNA transform, NOT matrix_world: a script that sets rotation_euler
-        # leaves matrix_world stale until the depsgraph evaluates, which in
-        # background mode is not before this runs. Measured live: a rotation
-        # hashed identical through matrix_world and the guard said "unchanged".
-        parent = obj.parent.name if obj.parent else ""
-        h.update(("%s|%s|%s|%s|%s|%s|%d|%s\n" % (
-            obj.name, obj.type, parent, tuple(obj.location),
-            tuple(obj.rotation_euler), tuple(obj.scale),
-            obj.hide_render, [m.type for m in getattr(obj, "modifiers", [])],
-        )).encode("utf-8"))
-        data = obj.data
-        if obj.type == "MESH" and data is not None:
-            n = len(data.vertices)
-            if n:
-                try:
-                    import numpy as np
-                    buf = np.empty(n * 3, dtype=np.float32)
-                    data.vertices.foreach_get("co", buf)
-                    h.update(buf.tobytes())
-                except Exception:
-                    h.update(str(n).encode())
-            for m in data.materials:
-                if m is None:
-                    continue
-                h.update(("mat:%s:%s\n" % (m.name, tuple(m.diffuse_color))).encode())
-                if m.use_nodes and m.node_tree:
-                    for node in m.node_tree.nodes:
-                        if node.type == "BSDF_PRINCIPLED":
-                            h.update(("bsdf:%s\n" % (tuple(node.inputs["Base Color"].default_value),)).encode())
-        elif obj.type == "LIGHT" and data is not None:
-            h.update(("light:%s:%s:%s\n" % (data.type, data.energy, tuple(data.color))).encode())
-        elif obj.type == "CAMERA" and data is not None:
-            h.update(("cam:%s:%s\n" % (data.lens, data.type)).encode())
-    w = scene.world
-    if w is not None:
-        h.update(("world:%s\n" % (tuple(getattr(w, "color", (0, 0, 0))),)).encode())
-    return h.hexdigest()