Merge commit '70d0672ee306019c7dba8f799a273ec486bec95b' as 'vendor/dumas_minimax_h3_refmod'
This commit is contained in:
@@ -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
|
||||
]
|
||||
}
|
||||
@@ -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');
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user