houdini-node-library 0.1.0__py3-none-any.whl

hnl/_houdini/python/hnl_bridge/extras.py

@@ -0,0 +1,439 @@
+"""cmd に入らない情報（付箋・ネットワークボックス・ドット・シーン設定）の保存と復元。"""
+from __future__ import annotations
+
+import math
+import os
+import re
+
+import hou
+
+from . import scan
+
+VERSION = 1
+# set -g に最初から入っている変数（ユーザー定義ではない）
+BUILTIN_VARS = frozenset("""F FF T FPS NFRAMES TEND TLENGTH TSTART FSTART FEND RFSTART RFEND UNITLENGTH
+UNITMASS CHOPMOTIONSAMPLES oldFF ACTIVETAKE E EYE HIP HIPFILE HIPNAME JOB PI POSE status HFS HH HOME""".split())
+
+
+def sub_children(n):
+    try:
+        return n.allSubChildren(recurse_in_locked_nodes=False)
+    except TypeError:
+        return n.allSubChildren()
+
+
+def rel_path(node, base) -> str:
+    return node.path()[len(base.path()):].lstrip("/")
+
+
+def _rgb(c) -> list:
+    return [round(float(x), 6) for x in c.rgb()]
+
+
+def _locked(n) -> bool:
+    return bool(getattr(n, "isLockedHDA", lambda: False)())
+
+
+def _dot_source(d):
+    it = d.inputItem()
+    for _ in range(1000):
+        if not isinstance(it, hou.NetworkDot):
+            break
+        it = it.inputItem()
+    return it
+
+
+def _overlaps(s, rects) -> bool:
+    x, y = s.position()
+    w, h = s.size()
+    return any(x < r[2] and x + w > r[0] and y < r[3] and y + h > r[1] for r in rects)
+
+
+def collect(parent, top_nodes, whole: bool, scope=None) -> dict:
+    """parent 配下の付箋・ボックス・ドットを集める。whole=False なら parent 直下は選択に関係するものだけ。"""
+    sel = set(top_nodes)
+    ex = {"version": VERSION, "source_parent": parent.path(), "stickies": [], "boxes": [], "dots": []}
+    nets = [parent] + [m for n in top_nodes for m in (n,) + tuple(sub_children(n))
+                       if m.isNetwork() and not _locked(m)]
+    rects = [(n.position()[0], n.position()[1], n.position()[0] + n.size()[0],
+              n.position()[1] + n.size()[1]) for n in top_nodes]
+    for net in nets:
+        top = net == parent
+        sh = None                                  # ロックされた HDA の中のネットワーク: 出荷時から持つ項目は除く
+        if scope is not None and not top:
+            sh = scope.shipped_items(net)
+            if sh is False:
+                continue
+        rel = "" if top else rel_path(net, parent)
+        flt = top and not whole
+        for b in net.networkBoxes():
+            if sh and b.name() in sh["boxes"]:
+                continue
+            names = [n.name() for n in b.nodes() if not flt or n in sel]
+            if flt and not names and not b.isSelected():
+                continue
+            ex["boxes"].append({
+                "parent": rel, "name": b.name(), "pos": list(b.position()), "size": list(b.restoredSize()),
+                "color": _rgb(b.color()), "comment": b.comment(), "minimized": b.isMinimized(),
+                "members": names})
+        for s in net.stickyNotes():
+            if sh and s.name() in sh["stickies"]:
+                continue
+            if flt and not (s.isSelected() or _overlaps(s, rects)):
+                continue
+            ex["stickies"].append({
+                "parent": rel, "name": s.name(), "text": s.text(), "pos": list(s.position()),
+                "size": list(s.restoredSize()), "color": _rgb(s.color()), "text_color": _rgb(s.textColor()),
+                "text_size": s.textSize(), "draw_background": s.drawBackground(), "minimized": s.isMinimized()})
+        for d in net.networkDots():
+            if sh and d.name() in sh["dots"]:
+                continue
+            if flt:
+                src = _dot_source(d)
+                if src not in sel or not any(c.outputItem() in sel for c in d.outputConnections()):
+                    continue
+            it = d.inputItem()
+            inp = None
+            if isinstance(it, hou.NetworkDot):
+                inp = {"kind": "dot", "name": it.name()}
+            elif it is not None:
+                inp = {"kind": "node", "name": it.name(), "out": d.inputItemOutputIndex()}
+            outs = [{"node": c.outputItem().name(), "idx": c.inputIndex()} for c in d.outputConnections()
+                    if isinstance(c.outputItem(), hou.Node) and (not flt or c.outputItem() in sel)]
+            ex["dots"].append({"parent": rel, "name": d.name(), "pos": list(d.position()),
+                               "color": _rgb(d.color()), "pinned": d.isPinned(), "input": inp, "outputs": outs})
+    return ex
+
+
+def top_rects(ex: dict) -> list:
+    """parent 直下の付箋・ボックス・ドットの矩形 (x0, y0, x1, y1)。"""
+    out = []
+    for k in ("boxes", "stickies"):
+        for e in ex.get(k, []):
+            if not e["parent"]:
+                out.append((e["pos"][0], e["pos"][1], e["pos"][0] + e["size"][0], e["pos"][1] + e["size"][1]))
+    out += [(d["pos"][0], d["pos"][1], d["pos"][0], d["pos"][1]) for d in ex.get("dots", []) if not d["parent"]]
+    return out
+
+# ---------------------------------------------------------------- 検証（extras.json は他人から届く入力）
+
+def _is_num(x, lo=-1e7, hi=1e7) -> bool:
+    return isinstance(x, (int, float)) and not isinstance(x, bool) and math.isfinite(x) and lo <= x <= hi
+
+
+def _vec(v, n=2, lo=-1e6, hi=1e6) -> bool:
+    return isinstance(v, (list, tuple)) and len(v) == n and all(_is_num(x, lo, hi) for x in v)
+
+
+def _color(v) -> bool:
+    return _vec(v, 3, 0.0, 1.0)
+
+
+def _node_name(s) -> bool:
+    """親を含まない単一のノード名（/ や .. を含まない）。"""
+    return (isinstance(s, str) and 0 < len(s) <= 256 and "/" not in s and "\\" not in s
+            and s not in (".", "..") and s.isprintable())
+
+
+def _rel(s) -> bool:
+    """取り込み先からの相対パス。空は取り込み先そのもの。絶対パスや .. は不可。"""
+    return s == "" or (isinstance(s, str) and len(s) <= 1024 and all(_node_name(p) for p in s.split("/")))
+
+
+def _text(s) -> bool:
+    return isinstance(s, str) and len(s) <= 200000
+
+
+def _int(x, hi=10000) -> bool:
+    return isinstance(x, int) and not isinstance(x, bool) and 0 <= x <= hi
+
+
+def _valid_box(e) -> bool:
+    return (isinstance(e, dict) and _rel(e.get("parent")) and _node_name(e.get("name")) and _vec(e.get("pos"))
+            and _vec(e.get("size"), 2, 0, 1e5) and _color(e.get("color")) and _text(e.get("comment", ""))
+            and isinstance(e.get("minimized", False), bool)
+            and isinstance(e.get("members"), list) and len(e["members"]) <= 100000
+            and all(_node_name(m) for m in e["members"]))
+
+
+def _valid_sticky(e) -> bool:
+    return (isinstance(e, dict) and _rel(e.get("parent")) and _node_name(e.get("name")) and _text(e.get("text", ""))
+            and _vec(e.get("pos")) and _vec(e.get("size"), 2, 0, 1e5) and _color(e.get("color"))
+            and _color(e.get("text_color")) and _is_num(e.get("text_size"), 0, 1000)
+            and isinstance(e.get("draw_background"), bool) and isinstance(e.get("minimized", False), bool))
+
+
+def _valid_dot(e) -> bool:
+    if not (isinstance(e, dict) and _rel(e.get("parent")) and _node_name(e.get("name")) and _vec(e.get("pos"))
+            and _color(e.get("color")) and isinstance(e.get("pinned"), bool)):
+        return False
+    inp = e.get("input")
+    if inp is not None:
+        if not (isinstance(inp, dict) and inp.get("kind") in ("dot", "node") and _node_name(inp.get("name"))):
+            return False
+        if inp["kind"] == "node" and not _int(inp.get("out")):
+            return False
+    outs = e.get("outputs")
+    return (isinstance(outs, list) and len(outs) <= 10000
+            and all(isinstance(o, dict) and _node_name(o.get("node")) and _int(o.get("idx")) for o in outs))
+
+
+def sanitize(ex) -> tuple[dict, list[str]]:
+    """extras の項目を検証し、不正な項目を除いた dict と警告を返す。"""
+    warns: list[str] = []
+    if not isinstance(ex, dict):
+        return {}, ["extras.json の形式が不正なため適用しませんでした"]
+    out: dict = {}
+    sp = ex.get("source_parent")
+    if isinstance(sp, str) and sp.startswith("/") and len(sp) <= 1024:
+        out["source_parent"] = sp
+    for key, ok, label in (("boxes", _valid_box, "ネットワークボックス"), ("stickies", _valid_sticky, "付箋"),
+                           ("dots", _valid_dot, "ドット")):
+        raw = ex.get(key, [])
+        if not isinstance(raw, list):
+            warns.append("%s の一覧が不正なため適用しませんでした" % label)
+            continue
+        good = [e for e in raw if ok(e)]
+        if len(good) != len(raw):
+            warns.append("不正な %s %d 件を適用しませんでした" % (label, len(raw) - len(good)))
+        out[key] = good
+    rm = ex.get("removed_nodes", [])
+    if isinstance(rm, list):
+        out["removed_nodes"] = [r for r in rm if isinstance(r, str) and 0 < len(r) <= 1024 and not r.startswith("/")
+                                and all(seg and seg != ".." and seg != "." for seg in r.split("/")) and _plain(r)][:2000]
+    elif rm:
+        warns.append("削除するノードの一覧が不正なため適用しませんでした")
+    wi = ex.get("editable_wires", [])
+    if isinstance(wi, list):
+        out["editable_wires"] = [e for e in wi[:20000] if isinstance(e, dict) and isinstance(e.get("node"), str)
+                                 and e["node"] and _rel(e["node"]) and _int(e.get("idx"), 100000)
+                                 and (e.get("src") is None or _node_name(e.get("src"))) and _int(e.get("out", 0), 100000)]
+    elif wi:
+        warns.append("接続の一覧が不正なため適用しませんでした")
+    if ex.get("scene") is not None:
+        sc, w = sanitize_scene(ex["scene"])
+        out["scene"] = sc
+        warns += w
+    return out, warns
+
+
+def sanitize_scene(s) -> tuple[dict, list[str]]:
+    """シーン設定を検証する。不正な項目は除き、警告を返す。"""
+    warns: list[str] = []
+    if not isinstance(s, dict):
+        return {}, ["シーン設定の形式が不正なため適用しませんでした"]
+    out: dict = {}
+    if _is_num(s.get("fps"), 0.001, 1000):
+        out["fps"] = float(s["fps"])
+    elif "fps" in s:
+        warns.append("シーン設定の fps が不正なため適用しませんでした")
+    for k in ("frame_range", "playback_range"):
+        v = s.get(k)
+        if _vec(v, 2, -1e7, 1e7) and v[0] <= v[1]:
+            out[k] = [float(v[0]), float(v[1])]
+        elif k in s:
+            warns.append("シーン設定の %s が不正なため適用しませんでした" % k)
+    if _is_num(s.get("frame")):
+        out["frame"] = float(s["frame"])
+    elif "frame" in s:
+        warns.append("シーン設定の frame が不正なため適用しませんでした")
+    g = s.get("globals", {})
+    if not isinstance(g, dict):
+        warns.append("グローバル変数の一覧が不正なため適用しませんでした")
+        g = {}
+    good = {}
+    for k, v in g.items():
+        why = scan.env_name_problem(k)
+        if why:
+            warns.append("グローバル変数 %s は設定しませんでした（%s）" % (str(k)[:40], why))
+        elif not isinstance(v, str) or len(v) > 4096 or not _plain(v):
+            warns.append("グローバル変数 %s の値が不正なため設定しませんでした" % k)
+        else:
+            good[k] = v
+    out["globals"] = good
+    return out, warns
+
+
+def _plain(v: str) -> bool:
+    """値に制御文字（改行など）を含まない。"""
+    return all(c >= " " and c != chr(127) for c in v)
+
+
+def apply(base, ex: dict, shift=(0.0, 0.0), name_map=None) -> tuple[list, list]:
+    """extras を base 配下に復元する。(作成した項目, 警告) を返す。"""
+    nm = name_map or {}
+    items: list = []
+    ex, warns = sanitize(ex)
+    sv = hou.Vector2(shift[0], shift[1])
+
+    def container(rel):
+        if not rel:
+            return base
+        parts = rel.split("/")
+        parts[0] = nm.get(parts[0], parts[0])
+        return base.node("/".join(parts))
+
+    def mapped(rel, name):
+        return nm.get(name, name) if not rel else name
+
+    def pos(rel, p):
+        v = hou.Vector2(p[0], p[1])
+        return v if rel else v + sv
+
+    for e in ex.get("boxes", []):
+        c = container(e["parent"])
+        if c is None:
+            warns.append("ネットワークボックス %s の親が見つからないため復元しませんでした" % e["name"])
+            continue
+        try:
+            b = c.createNetworkBox(e["name"])
+        except hou.Error:
+            b = c.createNetworkBox()
+        items.append(b)
+        members = [n for n in (c.node(mapped(e["parent"], m)) for m in e["members"]) if n is not None]
+        saved = [n.position() for n in members]
+        for n in members:
+            b.addNode(n)
+        b.setPosition(pos(e["parent"], e["pos"]))
+        for n, pp in zip(members, saved):          # ボックス移動でメンバーが動くので戻す
+            n.setPosition(pp)
+        b.setSize(hou.Vector2(*e["size"]))
+        b.setColor(hou.Color(e["color"]))
+        b.setComment(e["comment"])
+        if e["minimized"]:
+            b.setMinimized(True)
+    for e in ex.get("stickies", []):
+        c = container(e["parent"])
+        if c is None:
+            warns.append("付箋 %s の親が見つからないため復元しませんでした" % e["name"])
+            continue
+        try:
+            s = c.createStickyNote(e["name"])
+        except hou.Error:
+            s = c.createStickyNote()
+        items.append(s)
+        s.setText(e["text"])
+        s.setPosition(pos(e["parent"], e["pos"]))
+        s.setSize(hou.Vector2(*e["size"]))
+        s.setColor(hou.Color(e["color"]))
+        s.setTextColor(hou.Color(e["text_color"]))
+        s.setTextSize(e["text_size"])
+        s.setDrawBackground(e["draw_background"])
+        if e["minimized"]:
+            s.setMinimized(True)
+    dots: dict = {}
+    for e in ex.get("dots", []):
+        c = container(e["parent"])
+        if c is None:
+            continue
+        d = c.createNetworkDot()
+        d.setPosition(pos(e["parent"], e["pos"]))
+        d.setColor(hou.Color(e["color"]))
+        d.setPinned(e["pinned"])
+        dots[(e["parent"], e["name"])] = (c, d)
+        items.append(d)
+    for e in ex.get("dots", []):
+        if (e["parent"], e["name"]) not in dots:
+            continue
+        c, d = dots[(e["parent"], e["name"])]
+        inp = e["input"]
+        try:
+            if inp and inp["kind"] == "node":
+                src = c.node(mapped(e["parent"], inp["name"]))
+                if src is not None:
+                    d.setInput(0, src, inp["out"])
+            elif inp and (e["parent"], inp["name"]) in dots:
+                d.setInput(0, dots[(e["parent"], inp["name"])][1])
+            for o in e["outputs"]:
+                dst = c.node(mapped(e["parent"], o["node"]))
+                if dst is not None:
+                    dst.setInput(o["idx"], d)
+        except hou.Error as exc:
+            warns.append("ドット %s の接続を復元できませんでした: %s" % (e["name"], exc))
+        d.setPosition(pos(e["parent"], e["pos"]))      # 接続時に動くことがあるので再設定
+    return items, warns
+
+
+def all_vars() -> dict:
+    out = {}
+    for ln in hou.hscript("set -g")[0].splitlines():
+        m = re.match(r"^(\S+)\s*=\s?(.*)$", ln)
+        if m:
+            out[m.group(1)] = m.group(2)
+    return out
+
+
+def user_globals() -> dict:
+    out = {}
+    for k, v in all_vars().items():
+        if k in BUILTIN_VARS:
+            continue
+        try:                       # 一覧表示はバックスラッシュを二重に表示するので、実際の値を取り直す
+            v = hou.text.expandString("$" + k)
+        except hou.Error:
+            pass
+        out[k] = v
+    return out
+
+
+def set_var(name: str, value: str) -> None:
+    """環境変数とグローバル hscript 変数を設定する。名前・値が不正なら ValueError。
+    値は hscript の文字列として解釈させない: 変数を空で作り（名前は検証済み）、値は hou.putenv で渡す。"""
+    why = scan.env_name_problem(name)
+    if why:
+        raise ValueError("変数名 %s は使えません: %s" % (str(name)[:40], why))
+    if not isinstance(value, str) or not _plain(value):
+        raise ValueError("変数 %s の値が不正です（文字列で、制御文字や改行を含まないこと）" % name)
+    hou.hscript("set -g %s = ''" % name)       # 一覧（set -g）に載る hscript 変数を作る
+    hou.putenv(name, value)                    # hscript 変数の値
+    os.environ[name] = value                   # プロセスの環境変数（hscript は \ を解釈して値を変えるため揃える）
+
+
+class VarJournal:
+    """設定した変数の元の値を覚えておき、失敗時に戻す。"""
+
+    def __init__(self) -> None:
+        self.prev: dict = {}
+
+    def set(self, name: str, value: str) -> None:
+        if name not in self.prev:
+            self.prev[name] = (name in all_vars(), hou.getenv(name, None))
+        set_var(name, value)
+
+    def rollback(self) -> None:
+        for name, (listed, env) in self.prev.items():
+            try:
+                if listed and env is not None:
+                    set_var(name, env)
+                else:
+                    hou.hscript("set -u %s" % name)
+                    hou.unsetenv(name)
+                    os.environ.pop(name, None)
+            except Exception:
+                pass
+        self.prev = {}
+
+
+def collect_scene() -> dict:
+    return {"fps": hou.fps(), "frame_range": list(hou.playbar.frameRange()),
+            "playback_range": list(hou.playbar.playbackRange()), "frame": hou.frame(),
+            "globals": user_globals()}
+
+
+def apply_scene(s: dict, journal: "VarJournal | None" = None) -> list[str]:
+    """検証済みの項目だけを適用する。警告を返す。"""
+    s, warns = sanitize_scene(s)
+    if "fps" in s:
+        hou.setFps(s["fps"])
+    if "frame_range" in s:
+        hou.playbar.setFrameRange(*s["frame_range"])
+    if "playback_range" in s:
+        hou.playbar.setPlaybackRange(*s["playback_range"])
+    for k, v in s.get("globals", {}).items():
+        if journal is not None:
+            journal.set(k, v)
+        else:
+            set_var(k, v)
+    if "frame" in s:
+        hou.setFrame(s["frame"])
+    return warns

hnl/_houdini/python/hnl_bridge/hdas.py

@@ -0,0 +1,137 @@
+"""HDA の同梱（書き出し側）とインストール（読み込み側）。"""
+from __future__ import annotations
+
+import glob
+import os
+import re
+import shutil
+
+import hou
+
+
+def _hfs() -> str:
+    return os.path.realpath(hou.text.expandString("$HFS")).lower()
+
+
+def _safe(name: str) -> str:
+    return re.sub(r"[^\w.\-]+", "_", name)
+
+
+# スクリプトを含む HDA セクション（読み込み・作成時に自動実行され得るもの）
+_SCRIPT_SECTIONS = frozenset(n.lower() for n in (
+    "OnCreated OnLoaded OnUpdated OnInputChanged OnNameChanged OnDeleted PreFirstCreate PostLastDelete "
+    "OnUnloaded OnInstall PythonModule ViewerStateModule ViewerHandleModule").split())
+_SCRIPT_SUFFIXES = (".py", ".cmd", ".hscript", ".pypanel")
+
+
+class HdaRefused(Exception):
+    """インストールしてはいけない HDA が含まれている。"""
+
+
+def _template_callbacks(entries) -> bool:
+    for t in entries:
+        try:
+            if t.type() == hou.parmTemplateType.Folder or hasattr(t, "parmTemplates"):
+                if _template_callbacks(t.parmTemplates()):
+                    return True
+            if t.scriptCallback():
+                return True
+        except Exception:
+            continue
+    return False
+
+
+def script_info(d) -> tuple[list[str], bool]:
+    """定義が持つスクリプト入りのセクション名と、パラメータのコールバックの有無。"""
+    names: list[str] = []
+    try:
+        for n in d.sections():
+            low = n.lower()
+            if low in _SCRIPT_SECTIONS or low.endswith(_SCRIPT_SUFFIXES):
+                names.append(n)
+    except Exception:
+        pass
+    try:
+        cb = _template_callbacks(d.parmTemplateGroup().entries())
+    except Exception:
+        cb = False
+    return sorted(names), cb
+
+
+def collect_hdas(nodes, staging_dir: str) -> list[dict]:
+    """nodes が使う非標準 HDA を staging_dir/hda へ書き出し、依存一覧を返す。"""
+    hfs = _hfs()
+    deps: list[dict] = []
+    seen: set = set()
+    copied: dict = {}
+    for n in nodes:
+        t = n.type()
+        d = t.definition()
+        key = t.nameWithCategory()
+        if d is None or key in seen:
+            continue
+        lib = d.libraryFilePath()
+        embedded = lib == "Embedded"
+        if not embedded and os.path.realpath(lib).lower().startswith(hfs):
+            continue
+        seen.add(key)
+        hda_dir = os.path.join(staging_dir, "hda")
+        os.makedirs(hda_dir, exist_ok=True)
+        if embedded:
+            fname = _safe(key) + ".hda"
+            d.copyToHDAFile(os.path.join(hda_dir, fname))
+        else:
+            if lib not in copied:
+                fname = os.path.basename(lib)
+                while os.path.exists(os.path.join(hda_dir, fname)):
+                    fname = "_" + fname
+                shutil.copy2(lib, os.path.join(hda_dir, fname))
+                copied[lib] = fname
+            fname = copied[lib]
+        secs, cb = script_info(d)
+        deps.append({"type_name": key, "library": lib, "embedded": embedded, "bundled": "hda/" + fname,
+                     "sections": secs, "callbacks": cb})
+    return deps
+
+
+def install_dir(hda_dir: str) -> list[str]:
+    """hda_dir の HDA をインストールする。同じ定義が入っていれば何もしない。警告を返す。
+    Houdini 組み込みの（HDA ではない）ノード型と同名の定義があれば、何もインストールせず HdaRefused を投げる。"""
+    warns: list[str] = []
+    files = []
+    for pat in ("*.hda", "*.otl", "*.hdalc", "*.otllc"):
+        files += glob.glob(os.path.join(hda_dir, pat))
+    loaded: list[tuple[str, list]] = []
+    for f in sorted(files):
+        try:
+            defs = list(hou.hda.definitionsInFile(f))
+        except hou.Error as e:
+            warns.append("HDA %s を読めませんでした: %s" % (os.path.basename(f), e))
+            continue
+        for d in defs:
+            cur = hou.nodeType(d.nodeTypeCategory(), d.nodeTypeName())
+            if cur is not None and cur.definition() is None:
+                raise HdaRefused("HDA %s の %s は Houdini 組み込みのノード型と同名のためインストールできません"
+                                 % (os.path.basename(f), d.nodeTypeName()))
+        loaded.append((f, defs))
+    for f, defs in loaded:
+        need = False
+        for d in defs:
+            secs, cb = script_info(d)
+            if secs or cb:
+                warns.append("HDA %s はスクリプトを含みます: %s" % (
+                    d.nodeTypeName(), ", ".join(secs + (["パラメータのコールバック"] if cb else []))))
+            cur = hou.nodeType(d.nodeTypeCategory(), d.nodeTypeName())
+            cd = cur.definition() if cur is not None else None
+            if cd is None:
+                need = True
+            elif cd.version() == d.version() and cd.modificationTime() == d.modificationTime():
+                continue                      # 同じ定義がインストール済み
+            else:
+                warns.append("HDA %s は同名の別定義が既にあるため、既存の定義を使います" % d.nodeTypeName())
+        if need:
+            try:
+                hou.hda.installFile(f, change_oplibraries_file=False)
+            except hou.Error as e:
+                warns.append("HDA %s をインストールできませんでした: %s" % (os.path.basename(f), e))
+    return warns