Squashed 'vendor/dumas_minimax_h3_refmod/' content from commit 517e8c4

git-subtree-dir: vendor/dumas_minimax_h3_refmod
git-subtree-split: 517e8c419a8584fbf69fceb487bc39d83e6a6ec8
This commit is contained in:
2026-10-20 13:43:44 +00:00
commit 70d0672ee3
49 changed files with 7097 additions and 0 deletions
+23
View File
@@ -0,0 +1,23 @@
{
"properties": {"refmod_visible_slots": [1, 8]},
"widgets_values": [
false,
"characters/alice", 0.73, 2,
"(none)", 1, 1,
"(none)", 1, 1,
"(none)", 1, 1,
"(none)", 1, 1,
"(none)", 1, 1,
"(none)", 1, 1,
"motion/walk", 0.6, 1,
8192,
"Visual", 0.85, 0.25,
"All", 1, 1,
"All", 1, 1,
"All", 1, 1,
"All", 1, 1,
"All", 1, 1,
"All", 1, 1,
"All", 1, 0.4
]
}
+157
View File
@@ -0,0 +1,157 @@
import assert from 'node:assert/strict';
import {readFileSync} from 'node:fs';
const source = readFileSync(new URL('../web/refmod_slots.js', import.meta.url), 'utf8')
.replace('import { app } from "../../scripts/app.js";', 'const app = {registerExtension() {}};');
const {installRefModSlots} = await import('data:text/javascript;base64,' + Buffer.from(source).toString('base64'));
function fixture(axis = false, stableView = false) {
class Node {
constructor() {
if (stableView) {
// Frontend v1.53.6 widgetsView.ts mutates a stable array on assignment.
const view = [];
Object.defineProperty(this, 'widgets', {
get: () => view,
set: widgets => view.splice(0, view.length, ...widgets),
});
}
this.widgets = []; this.properties = {}; this.inputs = []; this.size = [360, 1400];
this.addWidget('toggle', 'show_info', false);
for (let i=1;i<=8;i++) {
if (axis) {
this.addWidget('combo',`mod_a_${i}`,'(none)');
this.addWidget('combo',`mod_b_${i}`,'(none)');
this.addWidget('number',`value_${i}`,0);
} else {
this.addWidget('combo',`mod_${i}`,'(none)');
this.addWidget('number',`strength_${i}`,1);
this.addWidget('number',`copies_${i}`,1);
}
}
this.addWidget('number','max_total_tokens',0);
for (let i=1;i<=8;i++) {
this.addWidget('combo',`components_${i}`,'All');
this.addWidget('number',`visual_strength_${i}`,1);
this.addWidget('number',`audio_strength_${i}`,1);
}
this.onNodeCreated();
}
addWidget(type,name,value,callback,options={}) {
const widget={type,name,value,callback,options}; this.widgets.push(widget); return widget;
}
computeSize() { return [360, 60 + this.widgets.reduce((h,w)=>h+(w.computeSize?.()[1] ?? 20)+4,0)]; }
setSize(size) { this.size=size; }
setDirtyCanvas() {}
serialize() { return {properties:structuredClone(this.properties),widgets_values:this.widgets.map(w=>w.options.serialize===false?null:w.value)}; }
// PR #20: modern frontend saves directly, without calling serialize().
serializeFromStoreState() {
return {properties:structuredClone(this.properties),widgets_values:this.widgets.map(w=>w.options.serialize===false?null:w.value)};
}
configure(info) {
this.properties = structuredClone(info.properties ?? {});
// LiteGraph invokes these even for unconnected input sockets,
// before restoring widgets_values (frontend 1.39.2 and 1.52.7).
this.inputs=info.inputs ?? [{name:'show_info',link:null}];
for (const [i,input] of this.inputs.entries()) {
this.onConnectionsChange?.(1,i,true,null,input);
}
info.widgets_values.forEach((value,i)=>{if(this.widgets[i])this.widgets[i].value=value;});
}
}
installRefModSlots(Node);
return Node;
}
const get=(node,name)=>node.widgets.find(w=>w.name===name);
const click=(node,name)=>get(node,name).callback();
for (const stableView of [false,true]) for (const axis of [false,true]) {
const Node=fixture(axis, stableView), node=new Node();
const mod=axis?'mod_a_':'mod_';
const initial=node.size[1];
assert.deepEqual(node.properties.refmod_visible_slots,[1]);
assert.equal(get(node,mod+'8').type,'combo');
assert.equal(get(node,mod+'8').options.hidden,true);
// Nodes 2.0 renders converted-widget socket rows even when hidden. Real
// widget types plus options.hidden eliminate those blank rows entirely.
const rendered = () => node.widgets.filter(w => w.type === 'converted-widget' || !w.options.hidden).map(w => w.name);
assert.ok(!rendered().includes(mod+'8'));
assert.deepEqual(rendered().slice(0,6), axis
? ['mod_a_1','mod_b_1','value_1','components_1','visual_strength_1','audio_strength_1']
: ['mod_1','strength_1','copies_1','components_1','visual_strength_1','audio_strength_1']);
click(node,'+ Add RefMod');
assert.deepEqual(node.properties.refmod_visible_slots,[1,2]);
assert.ok(node.size[1]>initial);
get(node,mod+'2').value='folder/hero';
get(node,'audio_strength_2').value=.25;
const saved=node.serialize();
assert.equal(saved.widgets_values[4],'folder/hero');
const displayOrder = [...node.widgets];
node.serialize = () => { throw new Error('store serializer must be independent'); };
assert.deepEqual(node.serializeFromStoreState(), saved);
assert.deepEqual(node.widgets, displayOrder);
assert.equal(node._refmodSlots.schemaOrderDepth, 0);
// Vue/store snapshots may restore visible rows as an indexed object.
const fromStore = new Node();
fromStore.configure({...saved, properties:{refmod_visible_slots:{0:1,1:2,2:4}}});
assert.deepEqual(fromStore.properties.refmod_visible_slots,[1,2,4]);
assert.equal(get(fromStore,mod+'2').value,'folder/hero');
assert.equal(get(fromStore,'audio_strength_2').value,.25);
assert.deepEqual(fromStore.serializeFromStoreState().widgets_values,saved.widgets_values);
const restored=new Node(); restored.configure(saved);
assert.equal(get(restored,mod+'2').value,'folder/hero');
assert.equal(get(restored,'audio_strength_2').value,.25);
assert.deepEqual(restored.serialize().widgets_values,saved.widgets_values);
assert.equal(restored.widgets.indexOf(get(restored,'audio_strength_1')),5);
// Repeated tab changes must keep all schema values and visible rows stable.
let current = restored;
for (let i=0;i<5;i++) {
const snapshot = current.serialize();
current = new Node();
current.configure(snapshot);
assert.deepEqual(current.serialize(), snapshot);
}
// A saved connected input also fires callbacks before value restoration.
const connected = new Node();
connected.configure({...saved,inputs:[{name:mod+'8',link:99}]});
assert.equal(get(connected,mod+'2').value,'folder/hero');
assert.equal(get(connected,'audio_strength_2').value,.25);
assert.ok(connected.properties.refmod_visible_slots.includes(8));
// Connected rows cannot be removed, even when their widget has no filename.
restored.inputs=[{name:mod+'8',link:99}]; restored.onConnectionsChange();
click(restored,'Remove RefMod 8');
assert.ok(restored.properties.refmod_visible_slots.includes(8));
assert.equal(restored.inputs[0].link,99);
click(restored,'Remove RefMod 2');
assert.equal(get(restored,mod+'2').value,'(none)');
assert.equal(get(restored,'audio_strength_2').value,1);
assert.ok(!restored.properties.refmod_visible_slots.includes(2));
// Legacy positional workflow, including a high selected slot and no UI properties.
const legacy=new Node().serialize(); delete legacy.properties;
legacy.widgets_values=legacy.widgets_values.slice(0,26);
legacy.widgets_values[22]='legacy/eighth';
const migrated=new Node(); migrated.configure(legacy);
assert.equal(get(migrated,mod+'8').value,'legacy/eighth');
assert.ok(migrated.properties.refmod_visible_slots.includes(8));
assert.equal(get(migrated,'audio_strength_8').value,1);
// Library selection in a hidden slot reveals it via its existing callback.
get(migrated,mod+'5').value='library/pick'; get(migrated,mod+'5').callback();
assert.ok(migrated.properties.refmod_visible_slots.includes(5));
while(migrated.properties.refmod_visible_slots.length<8) click(migrated,'+ Add RefMod');
assert.equal(get(migrated,'+ Add RefMod').options.hidden,true);
}
// Frozen pre-library schema values: restoration must not depend on a snapshot
// produced by the current implementation under test.
const legacyFixture = JSON.parse(readFileSync(new URL('./fixtures/loader_widgets.json',import.meta.url),'utf8'));
const FixtureNode = fixture();
const fixtureNode = new FixtureNode();
fixtureNode.configure(legacyFixture);
assert.equal(get(fixtureNode,'mod_1').value,'characters/alice');
assert.equal(get(fixtureNode,'strength_1').value,.73);
assert.equal(get(fixtureNode,'copies_1').value,2);
assert.equal(get(fixtureNode,'mod_8').value,'motion/walk');
assert.equal(get(fixtureNode,'components_1').value,'Visual');
assert.equal(get(fixtureNode,'visual_strength_1').value,.85);
assert.equal(get(fixtureNode,'audio_strength_8').value,.4);
assert.equal(get(fixtureNode,'max_total_tokens').value,8192);
assert.deepEqual(fixtureNode.properties.refmod_visible_slots,[1,8]);
assert.deepEqual(fixtureNode.serializeFromStoreState().widgets_values.slice(0,50),legacyFixture.widgets_values);
console.log('PASS: Loader + Axis, legacy/store serialization, indexed visible slots, frozen fixture, linked slots and library selection');
+84
View File
@@ -0,0 +1,84 @@
"""Audio backend regressions without loading codec weights."""
import builtins
import contextlib
import importlib
import math
import sys
import types
import unittest
from unittest.mock import Mock, patch
import test_loaders as loaders
torch = loaders.torch
AUDIO = importlib.import_module(loaders.N.__package__ + ".audio")
class AudioResampleTests(unittest.TestCase):
def setUp(self):
self.pieces = []
pieces = self.pieces
class Codec:
def encode(self, waveform):
pieces.append(waveform.clone())
return torch.zeros(1, 32, 2, math.ceil(waveform.shape[-1] / 800))
self.vae = types.SimpleNamespace(first_stage_model=Codec(), patcher=object(),
device="cpu", vae_dtype=torch.float32)
for mocked in (patch.object(AUDIO, "MiniMaxH3AudioVAE", Codec),
patch.object(AUDIO.model_management, "load_models_gpu"),
patch.object(AUDIO.model_management, "cuda_device_context",
side_effect=lambda device: contextlib.nullcontext())):
mocked.start()
self.addCleanup(mocked.stop)
def backend(self):
def resample(waveform, orig_freq, new_freq):
length = math.ceil(waveform.shape[-1] * new_freq / orig_freq)
return torch.ones(*waveform.shape[:-1], length)
return types.SimpleNamespace(resample=Mock(side_effect=resample))
def test_native_backend_without_torchaudio_clips_before_resampling(self):
for rate, channels in ((44100, 1), (48000, 2)):
with self.subTest(rate=rate, channels=channels):
native = self.backend()
self.pieces.clear()
with patch.dict(sys.modules, {"comfy.audio": native, "torchaudio": None,
"torchaudio.functional": None}):
z = AUDIO.encode_audio(self.vae, {
"waveform": torch.zeros(1,channels,rate*2), "sample_rate": rate},
max_seconds=1.25, chunk_seconds=1)
wave, orig, new = native.resample.call_args.args
self.assertEqual(tuple(wave.shape), (1,2,round(rate*1.25)))
self.assertEqual((orig,new), (rate,32000))
self.assertEqual([p.shape[-1] for p in self.pieces], [32000,8000])
self.assertEqual(tuple(z.shape), (1,32,2,50))
def test_older_comfyui_uses_torchaudio(self):
legacy = self.backend()
with patch.dict(sys.modules, {"comfy.audio": None, "torchaudio.functional": legacy}):
AUDIO.encode_audio(self.vae, {"waveform": torch.zeros(1,2,4800), "sample_rate": 48000})
legacy.resample.assert_called_once()
self.assertEqual(self.pieces[0].shape[-1], 3200)
def test_32000_needs_neither_resampler(self):
with patch.dict(sys.modules, {"comfy.audio": None, "torchaudio": None,
"torchaudio.functional": None}):
AUDIO.encode_audio(self.vae, {"waveform": torch.ones(1,1,3200), "sample_rate": 32000})
torch.testing.assert_close(self.pieces[0], torch.ones(1,2,3200))
def test_native_dependency_error_is_not_hidden_by_fallback(self):
original_import = builtins.__import__
def failing_import(name, *args, **kwargs):
if name == "comfy.audio":
raise ModuleNotFoundError("Missing native dependency", name="scipy")
return original_import(name, *args, **kwargs)
with patch.object(builtins, "__import__", side_effect=failing_import):
with self.assertRaises(ModuleNotFoundError) as error:
AUDIO.encode_audio(self.vae, {"waveform": torch.zeros(1,2,4800), "sample_rate": 48000})
self.assertEqual(error.exception.name, "scipy")
if __name__ == "__main__":
unittest.main()
+229
View File
@@ -0,0 +1,229 @@
"""Loader regressions using real safetensors and ComfyUI's queue validator.
Run with ComfyUI's Python: python tests/test_loaders.py
No models or server are started; all mod files live in temporary folders.
"""
import asyncio
import contextlib
import importlib
import io
import json
import os
from pathlib import Path
import sys
import tempfile
import unittest
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT.parents[1]))
from comfy.cli_args import args
args.cpu = True
import folder_paths
import torch
from safetensors.torch import save_file
with tempfile.TemporaryDirectory() as import_dir:
with patch.object(folder_paths, "models_dir", import_dir):
N = importlib.import_module(f"custom_nodes.{ROOT.name}.nodes")
import execution
import nodes as comfy_nodes
class UpstreamString:
RETURN_TYPES = ("STRING",)
FUNCTION = "run"
@classmethod
def INPUT_TYPES(cls):
return {"required": {"text": ("STRING",)}}
def run(self, text):
raise AssertionError("Queue validation must not execute upstream nodes")
class LoaderTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name) / "refmods"
self.legacy = Path(self.temp.name) / "mods"
self.root.mkdir()
self.legacy.mkdir()
search = patch.object(N, "_mod_search_dirs", return_value=[str(self.root), str(self.legacy)])
search.start()
self.addCleanup(search.stop)
N._MOD_CACHE.clear()
N._MOD_LIST_CACHE_KEY = N._MOD_LIST_CACHE_VAL = None
output = contextlib.redirect_stdout(io.StringIO())
output.__enter__()
self.addCleanup(output.__exit__, None, None, None)
def save_mod(self, name, kind="image", root=None, value=1.0, metadata=None):
path = (root or self.root) / name
path.parent.mkdir(parents=True, exist_ok=True)
mod = N.H3RefMod(name=path.name, kind=kind,
latent=torch.full((1, 24, 1, 4, 4), value),
latent_h=4, latent_w=4)
if metadata is None:
mod.save(str(path))
else:
save_file({"latent": mod.latent}, str(path) + ".safetensors",
metadata={"refmod_meta": json.dumps(metadata)})
return path
def test_empty_names_validate_and_execute_in_every_slot(self):
for cls in (N.MiniMaxH3RefModsLoader, N.MiniMaxH3RefModsAxis):
for field in cls.INPUT_TYPES()["required"]:
if not field.startswith("mod_"):
continue
for empty in (None, "", "None", "(none)"):
with self.subTest(node=cls.__name__, field=field, empty=empty):
inputs = {field: empty}
if "_a_" in field or "_b_" in field:
inputs["value_" + field.rsplit("_", 1)[1]] = -1 if "_a_" in field else 1
self.assertIs(cls.VALIDATE_INPUTS(**inputs), True)
self.assertEqual(cls().load(**inputs), ([], ""))
def test_recursive_listing_filters_metadata_and_presets(self):
self.save_mod("root")
self.save_mod("celebs/person", kind="video")
self.save_mod("oc/deep/person", root=self.legacy)
self.save_mod("celebs/audio", metadata={"kind": "other"})
self.save_mod("celebs/bad_json_type", metadata=["image"])
self.save_mod("graph_presets/hidden")
self.save_mod("oc/graph_presets/hidden")
(self.root / "curve.png").touch()
(self.root / "junk.safetensors").write_bytes(b"invalid")
expected = ["celebs/person", "oc/deep/person", "root"]
self.assertEqual(N._list_mod_names(), expected)
for cls in (N.MiniMaxH3RefModsLoader, N.MiniMaxH3RefModsAxis):
for field, schema in cls.INPUT_TYPES()["required"].items():
if field.startswith("mod_"):
self.assertEqual(schema[0], ["(none)"] + expected)
def test_listing_cache_reuses_metadata_reads(self):
self.save_mod("deep/a")
with patch.object(N, "read_refmod_meta", wraps=N.read_refmod_meta) as read:
self.assertEqual(N._list_mod_names(), ["deep/a"])
self.assertEqual(N._list_mod_names(), ["deep/a"])
self.assertEqual(read.call_count, 1)
def test_nested_add_rename_delete_refresh_listing(self):
self.assertEqual(N._list_mod_names(), [])
path = self.save_mod("new/deep/a")
self.assertEqual(N._list_mod_names(), ["new/deep/a"])
file = Path(str(path) + ".safetensors")
renamed = file.with_name("b.safetensors")
file.rename(renamed)
self.assertEqual(N._list_mod_names(), ["new/deep/b"])
renamed.unlink()
self.assertEqual(N._list_mod_names(), [])
def test_subsecond_metadata_change_refreshes_listing(self):
path = self.save_mod("deep/a", metadata={"kind": "image"})
file = Path(str(path) + ".safetensors")
stamp = 1_700_000_000_100_000_000
os.utime(file, ns=(stamp, stamp))
self.assertEqual(N._list_mod_names(), ["deep/a"])
self.save_mod("deep/a", metadata={"kind": "other"})
os.utime(file, ns=(stamp + 1_000_000, stamp + 1_000_000))
self.assertEqual(N._list_mod_names(), [])
def test_legacy_sidecar_add_change_delete_refresh_listing(self):
path = self.root / "deep" / "legacy"
path.parent.mkdir()
save_file({"latent": torch.zeros(1, 24, 1, 4, 4)}, str(path) + ".safetensors")
self.assertEqual(N._list_mod_names(), [])
sidecar = Path(str(path) + ".json")
sidecar.write_text('{"kind": "image"}')
self.assertEqual(N._list_mod_names(), ["deep/legacy"])
self.assertEqual(N._load_mod("deep/legacy").kind, "image")
sidecar.write_text('{"kind": "unsupported"}')
self.assertEqual(N._list_mod_names(), [])
sidecar.unlink()
self.assertEqual(N._list_mod_names(), [])
def test_search_root_identity_and_precedence(self):
self.save_mod("a", value=1)
self.save_mod("a", root=self.legacy, value=2)
self.assertEqual(N._list_mod_names(), ["a"])
self.assertEqual(N._load_mod("a").latent.flatten()[0].item(), 1)
with patch.object(N, "_mod_search_dirs", return_value=[str(self.legacy)]):
self.assertEqual(N._load_mod("a").latent.flatten()[0].item(), 2)
self.save_mod("a", metadata={"kind": "other"})
self.assertEqual(N._list_mod_names(), [])
def test_nested_runtime_both_loaders_and_windows_separators(self):
self.save_mod("celebs/person", value=3)
self.assertIs(N.MiniMaxH3RefModsLoader.VALIDATE_INPUTS(mod_1="celebs\\person"), True)
bundle, _ = N.MiniMaxH3RefModsLoader().load(mod_1="celebs\\person", strength_1=0.6, copies_1=2)
self.assertEqual(len(bundle), 2)
self.assertEqual(bundle[0][1], 0.6)
self.assertEqual(bundle[0][0].latent.flatten()[0].item(), 3)
for side, value in (("a", -0.4), ("b", 0.4)):
bundle, _ = N.MiniMaxH3RefModsAxis().load(**{f"mod_{side}_1": "celebs/person", "value_1": value})
self.assertEqual(bundle[0][1], 0.4)
self.assertIs(bundle[0][0], N._load_mod("celebs\\person"))
def test_same_metadata_name_config_does_not_poison_root_cache(self):
self.save_mod("person", value=1)
nested_path = self.save_mod("celebs/person", value=2)
root_mod = N._load_mod("person")
nested_mod = N._load_mod("celebs/person")
N.MiniMaxH3RefModConfig().fix([(nested_mod, 1.0)], retention=0.4)
self.assertIs(N._load_mod("person"), root_mod)
self.assertEqual(root_mod.config, {})
self.assertEqual(N.H3RefMod.load(str(nested_path)).config["retention"], 0.4)
def test_fixed_missing_names_rejected_and_linked_missing_fail_at_load(self):
for cls, field in ((N.MiniMaxH3RefModsLoader, "mod_1"),
(N.MiniMaxH3RefModsAxis, "mod_a_1"),
(N.MiniMaxH3RefModsAxis, "mod_b_1")):
self.assertIn("not found", cls.VALIDATE_INPUTS(**{field: "missing"}))
self.assertIs(cls.VALIDATE_INPUTS(input_types={field: "STRING"}, **{field: None}), True)
with self.assertRaisesRegex(FileNotFoundError, "missing"):
N.MiniMaxH3RefModsLoader().load(mod_1="missing")
def test_path_boundary_is_checked_at_execution(self):
for name in ("../outside", "a/../../outside", "/absolute", "C:/absolute", "C:relative",
"\\\\server\\share\\mod", "graph_presets/a"):
with self.subTest(name=name), self.assertRaises(ValueError):
N._load_mod(name)
def test_actual_comfy_queue_with_unexecuted_upstream(self):
for cls, field in ((N.MiniMaxH3RefModsLoader, "mod_1"),
(N.MiniMaxH3RefModsAxis, "mod_a_1"),
(N.MiniMaxH3RefModsAxis, "mod_b_1")):
inputs = {}
for name, (kind, options) in cls.INPUT_TYPES()["required"].items():
inputs[name] = kind[0] if isinstance(kind, list) else options["default"]
inputs[field] = ["source", 0]
prompt = {"source": {"class_type": "TestRefModString", "inputs": {"text": "future/person"}},
"loader": {"class_type": "TestRefModLoader", "inputs": inputs}}
with patch.dict(comfy_nodes.NODE_CLASS_MAPPINGS, TestRefModString=UpstreamString, TestRefModLoader=cls):
for output_type in ("STRING", "COMBO", ["future/person"]):
with self.subTest(node=cls.__name__, field=field, output_type=output_type):
with patch.object(UpstreamString, "RETURN_TYPES", (output_type,)):
result = asyncio.run(execution.validate_inputs("test-refmods", prompt, "loader", {}))
self.assertTrue(result[0], result)
with patch.object(UpstreamString, "RETURN_TYPES", ("IMAGE",)):
result = asyncio.run(execution.validate_inputs("test-refmods", prompt, "loader", {}))
self.assertFalse(result[0], result)
def test_connected_non_mod_inputs_keep_type_checks(self):
for cls, field in ((N.MiniMaxH3RefModsLoader, "strength_1"),
(N.MiniMaxH3RefModsLoader, "copies_1"),
(N.MiniMaxH3RefModsLoader, "show_info"),
(N.MiniMaxH3RefModsAxis, "value_1")):
with self.subTest(field=field):
self.assertIn("expected", cls.VALIDATE_INPUTS(input_types={field: "IMAGE"}))
if __name__ == "__main__":
unittest.main(verbosity=2)