mirror of
https://github.com/willmiao/ComfyUI-Lora-Manager.git
synced 2026-10-06 01:45:31 -03:00
Will Miao
8cd53c20f8
The Prompt and Lora Stack Combiner nodes expose unbounded dynamic input
slots (trigger_wordsN / lora_stackN). They resolved them by having
INPUT_TYPES() return a custom lookup object, but only when the caller was
ComfyUI's get_input_info() -- detected with inspect.stack(). That frame
inspection is what the registry security scan reports as
python_anti_debugging under the obfuscated-code admin tag.
Make the lookup a dict subclass instead, so INPUT_TYPES() can always
return it:
* /object_info (server.py) json.dumps INPUT_TYPES() directly, and a
dict subclass serializes its stored entries -- byte-identical to the
plain dict that was returned before.
* input_order (list(value.keys())), validate_inputs'
set(class_inputs["optional"]) and every other iteration still see only
the static slots.
* get_input_info() (graph.py) keeps resolving dynamic names through the
overridden __contains__/__getitem__, which no longer depends on who
the caller is.
The one behaviour change is in execution.py:get_input_data -- a dynamic
input passed as a constant rather than a link now reaches the node
instead of being silently dropped. These inputs are declared forceInput,
so the frontend only offers links; where it can happen the new behaviour
is the intended one.
Verified against ComfyUI's own consumer code: json.dumps output, keys(),
set(optional) and get_input_info() lookups all match the old behaviour,
and the two nodes no longer cross-resolve each other's slots.
3657 passed, 7 skipped.
183 lines
5.3 KiB
Python
183 lines
5.3 KiB
Python
import json
|
|
|
|
import pytest
|
|
|
|
from py.nodes.lora_stack_combiner import (
|
|
LoraStackCombinerLM,
|
|
_LoraStackOptionalInputs,
|
|
)
|
|
|
|
|
|
def test_combine_stacks_preserves_order():
|
|
node = LoraStackCombinerLM()
|
|
stack_a = [
|
|
("folder/a.safetensors", 0.7, 0.6),
|
|
("folder/b.safetensors", 0.8, 0.8),
|
|
]
|
|
stack_b = [
|
|
("folder/c.safetensors", 1.0, 0.9),
|
|
]
|
|
|
|
(combined_stack,) = node.combine_stacks(stack_a, stack_b)
|
|
|
|
assert combined_stack == stack_a + stack_b
|
|
|
|
|
|
def test_combine_stacks_returns_second_when_first_empty():
|
|
node = LoraStackCombinerLM()
|
|
stack_b = [("folder/c.safetensors", 1.0, 0.9)]
|
|
|
|
(combined_stack,) = node.combine_stacks([], stack_b)
|
|
|
|
assert combined_stack == stack_b
|
|
|
|
|
|
def test_combine_stacks_returns_first_when_second_empty():
|
|
node = LoraStackCombinerLM()
|
|
stack_a = [("folder/a.safetensors", 0.7, 0.6)]
|
|
|
|
(combined_stack,) = node.combine_stacks(stack_a, [])
|
|
|
|
assert combined_stack == stack_a
|
|
|
|
|
|
def test_combine_stacks_returns_empty_when_both_empty():
|
|
node = LoraStackCombinerLM()
|
|
|
|
(combined_stack,) = node.combine_stacks([], [])
|
|
|
|
assert combined_stack == []
|
|
|
|
|
|
def test_combine_stacks_allows_duplicate_entries():
|
|
node = LoraStackCombinerLM()
|
|
duplicate_entry = ("folder/shared.safetensors", 0.9, 0.5)
|
|
|
|
(combined_stack,) = node.combine_stacks([duplicate_entry], [duplicate_entry])
|
|
|
|
assert combined_stack == [duplicate_entry, duplicate_entry]
|
|
|
|
|
|
def test_combine_stacks_returns_empty_when_both_unconnected():
|
|
node = LoraStackCombinerLM()
|
|
|
|
(combined_stack,) = node.combine_stacks()
|
|
|
|
assert combined_stack == []
|
|
|
|
|
|
def test_combine_stacks_returns_other_when_one_unconnected():
|
|
node = LoraStackCombinerLM()
|
|
stack_a = [("folder/a.safetensors", 0.7, 0.6)]
|
|
|
|
(combined_stack_a,) = node.combine_stacks(lora_stack1=stack_a)
|
|
(combined_stack_b,) = node.combine_stacks(lora_stack2=stack_a)
|
|
|
|
assert combined_stack_a == stack_a
|
|
assert combined_stack_b == stack_a
|
|
|
|
|
|
def test_combine_stacks_with_dynamic_third_slot():
|
|
node = LoraStackCombinerLM()
|
|
stack_a = [("folder/a.safetensors", 0.7, 0.6)]
|
|
stack_b = [("folder/b.safetensors", 0.8, 0.8)]
|
|
stack_c = [("folder/c.safetensors", 1.0, 0.9)]
|
|
|
|
(combined_stack,) = node.combine_stacks(
|
|
lora_stack1=stack_a, lora_stack2=stack_b, lora_stack3=stack_c
|
|
)
|
|
|
|
assert combined_stack == stack_a + stack_b + stack_c
|
|
|
|
|
|
def test_combine_stacks_orders_by_slot_number_not_call_order():
|
|
node = LoraStackCombinerLM()
|
|
stack_a = [("folder/a.safetensors", 0.7, 0.6)]
|
|
stack_b = [("folder/b.safetensors", 0.8, 0.8)]
|
|
stack_c = [("folder/c.safetensors", 1.0, 0.9)]
|
|
|
|
(combined_stack,) = node.combine_stacks(
|
|
lora_stack3=stack_c, lora_stack2=stack_b, lora_stack1=stack_a
|
|
)
|
|
|
|
assert combined_stack == stack_a + stack_b + stack_c
|
|
|
|
|
|
def test_combine_stacks_accepts_only_dynamic_slot():
|
|
node = LoraStackCombinerLM()
|
|
stack_c = [("folder/c.safetensors", 1.0, 0.9)]
|
|
|
|
(combined_stack,) = node.combine_stacks(lora_stack3=stack_c)
|
|
|
|
assert combined_stack == stack_c
|
|
|
|
|
|
def test_combine_stacks_handles_legacy_input_names():
|
|
node = LoraStackCombinerLM()
|
|
stack_a = [("folder/a.safetensors", 0.7, 0.6)]
|
|
stack_b = [("folder/b.safetensors", 0.8, 0.8)]
|
|
|
|
(combined_stack,) = node.combine_stacks(lora_stack_a=stack_a, lora_stack_b=stack_b)
|
|
|
|
assert combined_stack == stack_a + stack_b
|
|
|
|
|
|
def test_input_types_exposes_two_default_slots():
|
|
input_types = LoraStackCombinerLM.INPUT_TYPES()
|
|
|
|
assert set(input_types["optional"]) == {"lora_stack1", "lora_stack2"}
|
|
assert input_types["optional"]["lora_stack1"][0] == "LORA_STACK"
|
|
assert input_types["optional"]["lora_stack2"][0] == "LORA_STACK"
|
|
|
|
|
|
def test_input_types_resolves_dynamic_slots():
|
|
input_types = LoraStackCombinerLM.INPUT_TYPES()
|
|
optional = input_types["optional"]
|
|
|
|
assert "lora_stack3" in optional
|
|
assert optional["lora_stack3"][0] == "LORA_STACK"
|
|
assert "lora_stack25" in optional
|
|
assert optional["lora_stack25"][0] == "LORA_STACK"
|
|
|
|
|
|
def test_input_types_serializes_only_static_slots():
|
|
"""ComfyUI's /object_info route json.dumps INPUT_TYPES() directly."""
|
|
input_types = LoraStackCombinerLM.INPUT_TYPES()
|
|
|
|
payload = json.loads(json.dumps(input_types))
|
|
|
|
assert set(payload["optional"]) == {"lora_stack1", "lora_stack2"}
|
|
assert payload["optional"]["lora_stack1"][0] == "LORA_STACK"
|
|
|
|
|
|
def test_input_types_supports_get_input_info_lookup_order():
|
|
"""Mirror comfy_execution.graph.get_input_info()'s containment then lookup."""
|
|
valid_inputs = LoraStackCombinerLM.INPUT_TYPES()
|
|
input_name = "lora_stack7"
|
|
|
|
assert "optional" in valid_inputs
|
|
assert input_name in valid_inputs["optional"]
|
|
input_type, extra_info = valid_inputs["optional"][input_name]
|
|
|
|
assert input_type == "LORA_STACK"
|
|
assert "tooltip" in extra_info
|
|
|
|
|
|
def test_lora_stack_optional_inputs_proxy():
|
|
proxy = _LoraStackOptionalInputs({"lora_stack1": ("LORA_STACK", {})})
|
|
|
|
assert "lora_stack1" in proxy
|
|
assert "lora_stack2" in proxy
|
|
assert "lora_stack10" in proxy
|
|
assert "lora_stack_a" in proxy
|
|
assert "lora_stack" not in proxy
|
|
assert "lora_stacka" not in proxy
|
|
assert "lora_stack_1" not in proxy
|
|
assert "text" not in proxy
|
|
|
|
assert proxy["lora_stack1"][0] == "LORA_STACK"
|
|
assert proxy["lora_stack5"][0] == "LORA_STACK"
|
|
|
|
with pytest.raises(KeyError):
|
|
proxy["not_a_stack"]
|