nodes/ComfyAssets-ComfyUI_PromptManager
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix(inspector): pass text through unknown nodes instead of refusing them (#381)

Browse Source 
The inspector refused any node class missing from the semantics table, so a
PromptManagerPair behind an rgthree Any Switch showed "Prompt uses a node the
inspector does not support". The inspection resolver (Python and browser) now
reads through unknown nodes: a text input is the text, positive/negative route
by output slot, a conditioning input is followed alone, otherwise every linked
input except core type inputs (pass_through.skip_inputs). PromptManager nodes
are authoritative; several different texts become one candidate each
("Several prompts reach the sampler"). A seeded text node with no conditioning
input is generated at run time, and a recorded PromptManager execution is not
checked against text that passed through an unknown node.

INSPECTION_RESOLVER_VERSION goes to 2; ingestion keeps the default profile.
A legacy parity gate records every committed graph whose inspection positive
matches the legacy parser's; no graph may leave it.
This commit is contained in:
Vito Sansevero
2026-10-27 06:28:42 -07:00
parent d868745194
commit a842a3c256
16 changed files with 1208 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TESTING.md
+23 -2
View File
@@ -745,11 +745,32 @@ with a literal true `strip_newlines` is `replace("\n", "").strip()`;
(`N` = `inputcount`) after the literal delimiter unless missing or exactly `""`, and
ignores later inputs. A linked setting is `unsupported-node`; a list output
(`return_list` true or linked) and `PromptSearchList` are `runtime-value` ("Text is
decided at run time"), never one list item. Unverified text nodes (LoRAfromText,
RegexReplace, XYZPrompt, ImpactWildcardProcessor) stay `unsupported-node`. Every
decided at run time"), never one list item. Every
intermediate text is length-checked and charged to the scanned-character budget. If
the table cannot be loaded, graph inspection is `unresolved` ("Inspection node
semantics are unavailable") and ingestion is unaffected, because it never imports the table.
Unknown nodes pass through (#381, maintainer-approved 2026-10-27; no per-node
inventory): an output whose class the table, its `facts`, `lineage` and the code's
adapters never name is read through, not refused. A `text` input is its text (the
legacy encoder rule, so RegexReplace or LoRAfromText show their input text). Else
output slot 0 with a linked `positive` (slot 1, `negative`) follows only that input,
else a linked `conditioning` alone, else every linked input except the table's
`pass_through.skip_inputs` (core type inputs: model, clip, vae, image, latent, ...),
each traced with kind `any`. A followed input with no text adds nothing; limits and
selector choices propagate; another failure (`runtime-value`, `composite`,
`malformed`) blocks, unless a PromptManager node was reached: this repository's own
nodes are authoritative, and then only their texts count. One distinct text
resolves; several make the sampler `ambiguous` "Several prompts reach the sampler"
with one candidate per text, in input order (at most 32, else `work-limit`). No text
at all is `unsupported-node` naming the outermost unknown node. An unlisted output
of a listed class (a sampler, a loader, a lineage node) stays `unsupported-node`, so
the walk never reads another stage's prompt. `INSPECTION_RESOLVER_VERSION` is 2 for
this rule; ingestion keeps the default profile (`RESOLVER_VERSION` 1). The legacy
parity gate (`tests/test_legacy_parity_gate.py`) records, per corpus (the
generation-params vectors, the inspection parity fixtures, the local resolver golden
and selection cases, the unknown-node shapes in `tests/unknown_node_graphs.py`),
every graph whose inspection positive equals the legacy parser's; a graph may join
that list (`python3 -m tests.test_legacy_parity_gate --write`), never leave it.
`tools/inspection_corpus.py --root DIR --out JSONL [--workers N] [--baseline JSONL]
[--summary TXT] [--code TREE]` measures a media folder read-only against the #240
tests/fixtures/local-inspect/legacy-agreement.json
Vendored
+102
View File
@@ -0,0 +1,102 @@
{
"generation_params": [
"case:basic",
"case:shared-prompt-pipeline",
"tests/fixtures/inspection_parity/f02.png",
"tests/fixtures/inspection_parity/f03.png",
"tests/fixtures/inspection_parity/f06c.png",
"tests/fixtures/inspection_parity/f06e.png",
"tests/fixtures/inspection_parity/f07a.png",
"tests/fixtures/inspection_parity/f07b.png",
"tests/fixtures/inspection_parity/f08.png",
"tests/fixtures/inspection_parity/f09.png",
"tests/fixtures/inspection_parity/f10.png",
"tests/fixtures/inspection_parity/f11.png",
"tests/fixtures/inspection_parity/f15.png",
"tests/fixtures/inspection_parity/f16.png",
"tests/fixtures/inspection_parity/f23.png"
],
"inspection_parity": [
"f02",
"f03",
"f06c",
"f06e",
"f07a",
"f07b",
"f08",
"f09",
"f10",
"f11",
"f14",
"f15",
"f16",
"f23"
],
"local_resolver": [
"built-chars",
"class-type-missing",
"class-type-number",
"combine-equal",
"controlnet-slot1",
"custom-cfg",
"duplicate-key",
"encode",
"int-id",
"latent-encode",
"overwritten-bad-workflow",
"pair-execution",
"pair-execution-bad-json",
"pair-execution-mismatch",
"pair-execution-negative-changed",
"pair-execution-other-node",
"pair-execution-truncated",
"pair-execution-two-records",
"pair-execution-version-float",
"pair-execution-version-true",
"pair-graph",
"pass-through-unknown-role-inputs",
"passthrough",
"prompt-and-parameters",
"prompt-manager",
"select-detailer-chain-same",
"select-detailer-no-sampler-upstream",
"select-detailer-output-walk-exhausted",
"select-detailer-same-prompt",
"select-edge-hires-fix-lineage-cycle",
"select-edge-hires-fix-two-refiners",
"select-flux-concat",
"select-flux-reroute-input",
"select-flux-three-stage",
"select-hires-fix",
"select-hires-fix-both-saved",
"select-hires-fix-reroute",
"select-multistage-latent",
"select-preview-dropped",
"select-preview-through-bad-node",
"select-runtime-flux-other-full-prompt",
"select-runtime-flux-trigger",
"select-runtime-search-list-append",
"select-runtime-through-chained",
"select-runtime-through-concat",
"select-runtime-through-text-encode",
"select-runtime-traced-prepend",
"select-runtime-trigger-append-single",
"select-runtime-trigger-pair",
"select-runtime-trigger-prepend",
"select-three-identical-one-advanced",
"select-two-identical",
"select-unconsumed-stage-kept",
"several-samplers",
"smz-false",
"text-at-limit",
"unknown-encoder",
"workflow-type-dict",
"workflow-type-in-subgraph",
"workflow-type-list",
"workflow-type-without-id",
"zeroed"
],
"unknown_nodes": [
"unknown-role-inputs"
]
}
tests/fixtures/local-inspect/resolver-vectors.json
Vendored
+1 -1
View File
File diff suppressed because one or more lines are too long
tests/local_resolver_cases.py
+11 -1
View File
@@ -906,6 +906,15 @@ def golden_cases():
},
),
)
# #381: unknown nodes between the prompt and the sampler pass through.
try:
from tests import unknown_node_graphs
except ImportError: # pragma: no cover - discover -s tests puts tests/ first
import unknown_node_graphs
for name, graph in unknown_node_graphs.shapes().items():
add(f"pass-through-{name}", graph)
for name, records in unknown_node_graphs.recorded_shapes().items():
cases[f"pass-through-{name}"] = records
cases["parameters-only"] = {
"parameters": "a fox\nNegative prompt: blur\nSteps: 20, Sampler: euler"
}
@@ -1059,7 +1068,8 @@ def boundary_cases():
["7", 0],
{
"\U0001f600"
* 70: {"class_type": long_name, "inputs": {"text": "x"}},
# No text and no links: still named, not passed through (#381).
* 70: {"class_type": long_name, "inputs": {"seed": 1}},
"7": _encode("b"),
},
)
tests/test_api_prompt_inspector.py
+3 -2
View File
@@ -190,7 +190,8 @@ class TestPromptInspector(ImageAPITestCase):
"inputs": {"positive": ["5", 0], "negative": ["2", 0]},
}
else:
source["1"]["class_type"] = "UnknownEncoder"
# No text and no links: nothing passes through it (#381).
source["1"] = {"class_type": "UnknownEncoder", "inputs": {"seed": 1}}
png(
path,
prompt=source,
@@ -215,7 +216,7 @@ class TestPromptInspector(ImageAPITestCase):
result["prompts"]["negative"], self.side("", "embedded-parameters")
)
source = graph()
source["2"]["class_type"] = "UnknownEncoder"
source["2"] = {"class_type": "UnknownEncoder", "inputs": {"seed": 1}}
png(path, prompt=source)
_, result = await self.inspect()
self.assertEqual(result["prompts"]["positive"], self.side("portrait"))
tests/test_inspection_semantics.py
+13
View File
@@ -59,6 +59,7 @@ def _minimal():
{"class": "VAEEncode", "slot": 0, "strategy": "continue", "input": "pixels"}
],
"stage_inputs": {"shaped": ["positive"], "with_model": ["samples"]},
"pass_through": {"skip_inputs": ["clip"]},
"facts": {
"configuration_outputs": {},
"model_outputs": {},
@@ -690,6 +691,18 @@ class ValidationTest(_TableCase):
(lambda d: d["stage_inputs"].update(shaped="pipe"), "input name"),
(lambda d: d["stage_inputs"].update(with_model=["positive"]), "both"),
(lambda d: d["stage_inputs"].update(shaped=["model"]), "model"),
(lambda d: d.pop("pass_through"), "category"),
(lambda d: d["pass_through"].update(extra=["x"]), "pass_through"),
(lambda d: d["pass_through"].update(skip_inputs="clip"), "input name"),
(lambda d: d["pass_through"].update(skip_inputs=[]), "input name"),
(
lambda d: d["pass_through"].update(skip_inputs=["clip", "clip"]),
"repeated",
),
(
lambda d: d["pass_through"].update(skip_inputs=["conditioning"]),
"carries text",
),
(
lambda d: d["facts"]["configuration_outputs"].update(
X={"kind": "sigmas", "fields": ["steps"], "type_fields": []}
tests/test_legacy_parity_gate.py
+142
View File
@@ -0,0 +1,142 @@
"""Legacy parity gate for the inspection resolver (#381, the PR #170 floor).
The legacy parser (``utils.generation_params``, the port of the browser's
``extractGenerationParams``) is the floor: a graph whose positive prompt it
found, and that the inspection resolver resolved to the same text, must keep
resolving to that text. ``legacy-agreement.json`` records those graphs per
corpus: the generation-params vectors, the inspection parity fixtures, the
local resolver golden and selection cases, and the unknown-node shapes of
#381. A graph may join the list, never leave it; regenerate with::
python3 -m tests.test_legacy_parity_gate --write
"""
import argparse
import json
import unittest
from pathlib import Path
from utils import prompt_pair_resolver as resolver
from utils.generation_params import (
GenerationParamsError,
extract_generation_params,
parse_js_json,
)
try:
from tests import inspection_parity as parity
from tests import local_resolver_cases as cases
from tests import local_resolver_selection_cases as selection
from tests import unknown_node_graphs as unknown
except ImportError: # discovered with ``-s tests``
import inspection_parity as parity
import local_resolver_cases as cases
import local_resolver_selection_cases as selection
import unknown_node_graphs as unknown
HERE = Path(__file__).resolve().parent
AGREEMENT_PATH = HERE / "fixtures" / "local-inspect" / "legacy-agreement.json"
VECTORS_PATH = HERE / "fixtures" / "generation_params" / "vectors.json"
NOT_FOUND = "No prompt found"
def _parsed(value):
return parse_js_json(value) if isinstance(value, str) else value
def corpora() -> dict:
"""Corpus name to ``{case name: (prompt graph, workflow or None)}``."""
vectors = json.loads(VECTORS_PATH.read_text(encoding="utf-8"))
named = {**cases.golden_cases(), **selection.selection_cases()}
return {
"generation_params": {
item["name"]: (_parsed(item["prompt"]), _parsed(item.get("workflow")))
for item in vectors
},
"inspection_parity": {
name: (parity.build(name)["prompt"], parity.build(name)["workflow"])
for name in parity.COMMITTED
},
"local_resolver": {
name: (_parsed(records["prompt"]), _parsed(records.get("workflow")))
for name, records in named.items()
if "prompt" in records
},
"unknown_nodes": {
name: (graph, None) for name, graph in unknown.shapes().items()
},
}
def legacy_positive(graph, workflow):
"""The positive prompt the legacy parser found, or ``None``."""
try:
found = extract_generation_params({"prompt": graph, "workflow": workflow})
except GenerationParamsError:
return None
text = found["positivePrompt"]
return None if text == NOT_FOUND else text
def agreeing(graphs: dict) -> list:
"""Names whose inspection positive equals the legacy parser's, sorted."""
names = []
for name, (graph, workflow) in graphs.items():
if not isinstance(graph, dict):
continue
expected = legacy_positive(graph, workflow)
if expected is None:
continue
metadata = {"prompt": graph}
if workflow is not None:
metadata["workflow"] = workflow
result = resolver.resolve_prompt_pair(
metadata, profile=resolver.INSPECTION_PROFILE
)
positive = result["positive"]
if (
result["state"] == "resolved"
and isinstance(positive, dict)
and positive["text"] == expected
):
names.append(name)
return sorted(names)
class LegacyParityGateTest(unittest.TestCase):
def test_no_graph_leaves_the_legacy_agreement(self):
recorded = json.loads(AGREEMENT_PATH.read_text(encoding="utf-8"))
current = {name: agreeing(graphs) for name, graphs in corpora().items()}
self.assertEqual(set(recorded), set(current))
for corpus, names in recorded.items():
with self.subTest(corpus=corpus):
lost = sorted(set(names) - set(current[corpus]))
self.assertEqual(lost, [], "these graphs no longer match legacy")
def test_every_unknown_node_shape_legacy_reads_still_agrees(self):
graphs = corpora()["unknown_nodes"]
legacy = {name for name, pair in graphs.items() if legacy_positive(*pair)}
self.assertLessEqual(legacy, set(agreeing(graphs)))
def test_the_reported_graph_reads_better_than_legacy(self):
# Legacy found no positive here (cf0cef3 showed the positive text as
# the negative); the floor is met, and the inspector now reads it.
graph = unknown.any_switch_graph()
self.assertIsNone(legacy_positive(graph, None))
result = resolver.resolve_prompt_pair(
{"prompt": graph}, profile=resolver.INSPECTION_PROFILE
)
self.assertEqual(result["positive"]["text"], unknown.POSITIVE)
def main():
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("--write", action="store_true", help="record the agreement")
if parser.parse_args().write:
current = {name: agreeing(graphs) for name, graphs in corpora().items()}
text = json.dumps(current, indent=1, sort_keys=True, ensure_ascii=False)
AGREEMENT_PATH.write_text(text + "\n", encoding="utf-8", newline="\n")
if __name__ == "__main__":
main()
tests/test_prompt_pair_resolver.py
+16 -13
View File
@@ -1019,7 +1019,8 @@ class TestResolverProfiles(unittest.TestCase):
def test_unsupported_node_names_the_blocking_node(self):
source = graph()
source["1"]["class_type"] = "UnknownEncoder"
# No text and no links: nothing passes through it (#381).
source["1"] = {"class_type": "UnknownEncoder", "inputs": {"seed": 1}}
result = resolve_prompt_pair(source, profile=resolver.INSPECTION_PROFILE)
self.assertEqual(result["reason_code"], "unsupported-node")
self.assertEqual(result["node"], {"id": "1", "class_type": "UnknownEncoder"})
@@ -1161,14 +1162,9 @@ class TestGuiderSamplers(unittest.TestCase):
def test_unsupported_node_names_first_blocking_node(self):
source = _guided()
source["30"] = {
"class_type": "FutureConditioner",
"inputs": {"conditioning": ["6", 0]},
}
source["31"] = {
"class_type": "OtherConditioner",
"inputs": {"conditioning": ["7", 0]},
}
# No links: nothing passes through them (#381).
source["30"] = {"class_type": "FutureConditioner", "inputs": {"seed": 1}}
source["31"] = {"class_type": "OtherConditioner", "inputs": {"seed": 2}}
source["21"]["inputs"]["positive"] = ["30", 0]
source["21"]["inputs"]["negative"] = ["31", 0]
result = _inspect(source)
@@ -1548,7 +1544,8 @@ class TestConditioningSemantics(unittest.TestCase):
def test_diverging_branch_that_cannot_be_traced_is_never_guessed(self):
extra = {
"10": _encoded(parity.POS),
"11": {"class_type": "FutureEncoder", "inputs": {"text": WOLF}},
# No text and no links: nothing passes through it (#381).
"11": {"class_type": "FutureEncoder", "inputs": {"strength": 1.0}},
"12": _image_exists(),
}
source = _with_positive(_if_else(["12", 1], ["10", 0], ["11", 0]), extra)
@@ -2048,12 +2045,17 @@ class TestEncoderAndStringSemantics(unittest.TestCase):
result = _inspect(_with_positive(node))
self.assertEqual(result["reason_code"], "malformed")
def test_unverified_text_nodes_stay_unsupported_and_named(self):
# TextBoxMira was verified in its source in Task 2.7b and is listed.
def test_unknown_text_nodes_pass_their_text_through(self):
# #381: an unlisted node's ``text`` input is its text (the legacy rule);
# without one, and with nothing linked, it is still named.
for name in ("LoRAfromText", "RegexReplace", "XYZPrompt"):
with self.subTest(node=name):
node = {"class_type": name, "inputs": {"text": parity.POS}}
result = _inspect(_string_positive(node))
self.assertEqual(result["state"], "resolved")
self.assertEqual(result["positive"]["text"], parity.POS)
node = {"class_type": name, "inputs": {"pattern": parity.POS}}
result = _inspect(_string_positive(node))
self.assertEqual(result["reason_code"], "unsupported-node")
self.assertEqual(result["node"], {"id": "10", "class_type": name})
@@ -2313,7 +2315,8 @@ class TestDetailerStages(unittest.TestCase):
def test_unresolved_stage_blocks_the_chain(self):
source = _detailed(same_prompt=True)
source["30"] = {"class_type": "FutureConditioner", "inputs": {"c": ["6", 0]}}
# No links: nothing passes through it (#381).
source["30"] = {"class_type": "FutureConditioner", "inputs": {"c": 1.0}}
source["3"]["inputs"]["positive"] = ["30", 0]
source["50"]["inputs"]["positive"] = ["10", 0]
result = _inspect(source)
tests/test_resolver_generic_pass_through.py
+303
View File
@@ -0,0 +1,303 @@
"""Unknown nodes between the prompt and the sampler pass through (#381).
The inspection resolver no longer needs a node class on an allow-list to read
through it. An output the semantics table does not describe passes through: a
``text`` input is the text, a ``positive``/``negative`` input routes by output
slot, a ``conditioning`` input is followed alone, otherwise every linked input
except core type inputs (``pass_through.skip_inputs``) is followed. One text,
or several equal texts, resolve; PromptManager nodes are authoritative; several
different texts are one candidate each. Ingestion (the default profile) is
unchanged. Every graph here is synthetic, with neutral texts.
"""
import json
import unittest
from utils import prompt_pair_resolver as resolver
from utils.prompt_inspector import inspect_prompt_evidence
from utils.prompt_pair_resolver import resolve_prompt_pair
try:
from tests import unknown_node_graphs as graphs
except ImportError: # discovered with ``-s tests``
import unknown_node_graphs as graphs
POSITIVE, OTHER, NEGATIVE = graphs.POSITIVE, graphs.OTHER, graphs.NEGATIVE
any_switch_graph = graphs.any_switch_graph
_encode, _pair, _with = graphs.encode, graphs.pair, graphs.with_nodes
def _inspect(graph, **options):
return resolve_prompt_pair(
{"prompt": graph}, profile=resolver.INSPECTION_PROFILE, **options
)
def _texts(result):
return tuple(
result[role]["text"] if isinstance(result[role], dict) else None
for role in ("positive", "negative")
)
class TestTheReportedGraph(unittest.TestCase):
def test_prompt_manager_pair_through_any_switch_resolves(self):
result = _inspect(any_switch_graph())
self.assertEqual(result["state"], "resolved", result["reason"])
self.assertEqual(_texts(result), (POSITIVE, ""))
self.assertEqual(result["sampler_id"], "17")
self.assertIsNone(result["reason_code"])
path = [step["node_id"] for step in result["positive"]["provenance"]["path"]]
self.assertEqual(path, ["15", "10"])
def test_the_inspector_shows_the_prompt(self):
evidence = inspect_prompt_evidence({"prompt": json.dumps(any_switch_graph())})
self.assertEqual(evidence["resolution"]["state"], "resolved")
self.assertEqual(evidence["prompts"]["positive"]["status"], "resolved")
self.assertEqual(evidence["prompts"]["positive"]["text"], POSITIVE)
def test_ingestion_is_unchanged(self):
result = resolve_prompt_pair({"prompt": any_switch_graph()})
self.assertEqual(result["state"], "unresolved")
# Its first failure is the custom latent node, as before this change.
self.assertEqual(result["reason"], "Unsupported latent ancestry")
def test_the_inspection_version_moves(self):
self.assertEqual(resolver.INSPECTION_RESOLVER_VERSION, 2)
self.assertEqual(resolver.RESOLVER_VERSION, 1)
class TestSourcesThroughUnknownNodes(unittest.TestCase):
def test_several_inputs_with_one_text_resolve(self):
graph = any_switch_graph(any_01=["10", 0], any_02=["10", 0])
self.assertEqual(_texts(_inspect(graph)), (POSITIVE, ""))
def test_equal_texts_from_different_nodes_resolve(self):
graph = _with(
any_switch_graph(any_01=["20", 0], any_02=["21", 0]),
**{"20": _encode(OTHER), "21": _encode(OTHER)},
)
result = _inspect(graph)
self.assertEqual(result["state"], "resolved")
self.assertEqual(_texts(result)[0], OTHER)
def test_different_texts_are_candidates_not_a_refusal(self):
graph = _with(
any_switch_graph(any_01=["20", 0], any_02=["21", 0]),
**{"20": _encode(POSITIVE), "21": _encode(OTHER)},
)
result = _inspect(graph)
self.assertEqual(result["state"], "ambiguous")
self.assertEqual(result["reason"], resolver.SEVERAL_SOURCES_REASON)
self.assertEqual(
[_texts(item) for item in result["candidates"]],
[(POSITIVE, ""), (OTHER, "")],
)
for item in result["candidates"]:
self.assertEqual(item["state"], "resolved")
self.assertEqual(item["sampler_id"], "17")
def test_prompt_manager_is_authoritative(self):
graph = _with(
any_switch_graph(any_01=["20", 0], any_02=["10", 0]),
**{"20": _encode(OTHER)},
)
result = _inspect(graph)
self.assertEqual(result["state"], "resolved")
self.assertEqual(_texts(result), (POSITIVE, ""))
def test_prompt_manager_wins_over_an_unreadable_branch(self):
graph = _with(
any_switch_graph(any_01=["20", 0], any_02=["10", 0]),
**{
"20": {
"class_type": "CLIPTextEncode",
"inputs": {"text": ["21", 0], "clip": ["7", 0]},
},
"21": {"class_type": "PromptSearchList", "inputs": {"search": "x"}},
},
)
self.assertEqual(_texts(_inspect(graph)), (POSITIVE, ""))
def test_an_unreadable_branch_blocks_without_prompt_manager(self):
graph = _with(
any_switch_graph(any_01=["20", 0], any_02=["22", 0]),
**{
"20": {
"class_type": "CLIPTextEncode",
"inputs": {"text": ["21", 0], "clip": ["7", 0]},
},
"21": {"class_type": "PromptSearchList", "inputs": {"search": "x"}},
"22": _encode(OTHER),
},
)
result = _inspect(graph)
self.assertEqual(result["state"], "unresolved")
self.assertEqual(result["reason_code"], "runtime-value")
def test_chained_unknown_nodes(self):
graph = _with(
any_switch_graph(any_01=["20", 0]),
**{
"20": {
"class_type": "Router Node (vendor)",
"inputs": {"in": ["10", 0]},
}
},
)
self.assertEqual(_texts(_inspect(graph)), (POSITIVE, ""))
def test_no_text_names_the_unknown_node(self):
graph = any_switch_graph(any_01=["7", 0])
result = _inspect(graph)
self.assertEqual(result["state"], "unresolved")
self.assertEqual(result["reason_code"], "unsupported-node")
self.assertEqual(
result["node"], {"id": "15", "class_type": "Any Switch (rgthree)"}
)
def test_another_sampler_is_never_entered(self):
graph = any_switch_graph(any_01=["17", 0], any_02=["10", 0])
graph["30"] = {
"class_type": "KSampler",
"inputs": {**graph["17"]["inputs"], "positive": ["31", 0]},
}
graph["31"] = _encode(OTHER)
graph["15"]["inputs"]["any_01"] = ["30", 0]
result = _inspect(graph)
found = {item["sampler_id"]: _texts(item) for item in result["candidates"]}
self.assertEqual(found["17"], (POSITIVE, ""))
class TestLegacyShapedRules(unittest.TestCase):
def test_a_text_input_is_the_text(self):
graph = _with(
any_switch_graph(any_01=["20", 0]),
**{
"20": {
"class_type": "VendorTextEncode",
"inputs": {"text": OTHER, "clip": ["9", 1]},
}
},
)
self.assertEqual(_texts(_inspect(graph))[0], OTHER)
def test_role_inputs_route_by_output_slot(self):
graph = any_switch_graph()
graph["20"] = {
"class_type": "VendorControlApply",
"inputs": {
"positive": ["21", 0],
"negative": ["22", 0],
"control_net": ["8", 0],
"image": ["8", 0],
},
}
graph["21"] = _encode(POSITIVE)
graph["22"] = _encode(NEGATIVE)
graph["17"]["inputs"]["positive"] = ["20", 0]
graph["17"]["inputs"]["negative"] = ["20", 1]
self.assertEqual(_texts(_inspect(graph)), (POSITIVE, NEGATIVE))
def test_a_conditioning_input_is_followed_alone(self):
graph = _with(
any_switch_graph(any_01=["20", 0]),
**{
"20": {
"class_type": "VendorStyleApply",
"inputs": {"conditioning": ["10", 0], "style": ["21", 0]},
},
"21": _encode(OTHER),
},
)
self.assertEqual(_texts(_inspect(graph)), (POSITIVE, ""))
def test_core_type_inputs_are_skipped(self):
# The vendor encoder's ``clip`` reaches a loader with its own ``text``:
# that text is a lora tag, never the prompt.
graph = _with(
any_switch_graph(any_01=["20", 0]),
**{
"20": {
"class_type": "VendorPromptEncode",
"inputs": {"prompt": ["21", 0], "clip": ["22", 1]},
},
"21": {"class_type": "PrimitiveString", "inputs": {"value": OTHER}},
"22": {
"class_type": "VendorLoraLoader",
"inputs": {"text": "<lora:x:1>", "clip": ["7", 0]},
},
},
)
result = _inspect(graph)
self.assertEqual(result["state"], "resolved")
self.assertEqual(_texts(result)[0], OTHER)
class TestBounds(unittest.TestCase):
def test_a_long_unknown_chain_reaches_the_depth_limit(self):
graph = any_switch_graph(any_01=["100", 0])
for index in range(100, 100 + resolver.INSPECTION_PROFILE.max_depth + 2):
graph[str(index)] = {
"class_type": "Router Node (vendor)",
"inputs": {"in": [str(index + 1), 0]},
}
graph[str(index + 1)] = _pair()
result = _inspect(graph)
self.assertEqual(result["state"], "unresolved")
self.assertEqual(result["reason_code"], "depth-limit")
def test_many_different_sources_hit_the_candidate_cap(self):
inputs = {}
graph = any_switch_graph()
for index in range(resolver._MAX_BRANCH_CANDIDATES + 1):
graph[str(200 + index)] = _encode(f"{OTHER} {index}")
inputs[f"any_{index:02}"] = [str(200 + index), 0]
graph["15"]["inputs"] = inputs
result = _inspect(graph)
self.assertEqual(result["state"], "unresolved")
self.assertEqual(result["reason_code"], "work-limit")
if __name__ == "__main__":
unittest.main()
class TestGeneratedAndTransformedText(unittest.TestCase):
def test_a_seeded_text_node_is_generated_at_run_time(self):
result = _inspect(graphs.generated_text_graph())
self.assertEqual(result["state"], "unresolved")
self.assertEqual(result["reason_code"], "runtime-value")
self.assertEqual(
result["node"], {"id": "30", "class_type": "VendorTextGenerate"}
)
def test_the_recorded_text_is_authoritative(self):
# The record is what ran: a generated or transformed text is never
# checked against the generator's or transform's inputs.
for name, records in graphs.recorded_shapes().items():
with self.subTest(shape=name):
metadata = {
"prompt": json.loads(records["prompt"]),
"comfyassets_prompt_pairs": records["comfyassets_prompt_pairs"],
}
result = resolve_prompt_pair(
metadata, profile=resolver.INSPECTION_PROFILE
)
self.assertEqual(result["state"], "resolved", result["reason"])
self.assertEqual(_texts(result), (graphs.GENERATED, ""))
self.assertEqual(
result["positive"]["provenance"]["text_source"], "execution"
)
def test_a_seeded_conditioning_node_still_passes_through(self):
graph = _with(
any_switch_graph(any_01=["20", 0]),
**{
"20": {
"class_type": "VendorConditioningNoise",
"inputs": {"conditioning": ["10", 0], "seed": 3},
}
},
)
self.assertEqual(_texts(_inspect(graph)), (POSITIVE, ""))
tests/test_review_inspection.py
+5 -1
View File
@@ -864,7 +864,11 @@ class TestInspectionResolverVersion(InspectionTestCase):
}
with (
patch.object(review_capture, "INSPECTION_RESOLVER_VERSION", 2),
patch.object(
review_capture,
"INSPECTION_RESOLVER_VERSION",
review_capture.INSPECTION_RESOLVER_VERSION + 1,
),
patch.object(review_capture, "resolve_inspection", side_effect=newer),
):
self.assertNotEqual(_version(), version)
tests/unknown_node_graphs.py
+259
View File
@@ -0,0 +1,259 @@
"""Synthetic graphs with unknown nodes between the prompt and the sampler (#381).
``any_switch_graph`` reproduces the shape of the maintainer's krea2 run
(PromptManagerPair -> Any Switch (rgthree) -> KSampler, a LoraManager loader
with its own lora ``text``, custom latent, filename and saver nodes) with
neutral texts. ``shapes()`` names one graph per pass-through rule; the resolver
tests and the browser-port parity vectors share them. No user file is involved.
"""
import json
POSITIVE = "a lighthouse on a cliff, golden hour"
OTHER = "a red bicycle in the rain"
NEGATIVE = "blurry, lowres"
def encode(text):
return {"class_type": "CLIPTextEncode", "inputs": {"text": text, "clip": ["7", 0]}}
def pair(text=POSITIVE, negative=""):
return {
"class_type": "PromptManagerPair",
"inputs": {
"text": text,
"negative_text": negative,
"category": "",
"tags": "",
"search_text": "",
"prepend_text": "",
"append_text": "",
"clip": ["9", 1],
},
}
def any_switch_graph(**switch_inputs):
"""The shape of #381: PromptManagerPair -> Any Switch (rgthree) -> KSampler.
Classes and links reproduce the maintainer's krea2 run (a LoraManager
loader with its own lora ``text``, a project-path filename node, a custom
latent and saver); the texts are neutral.
"""
inputs = switch_inputs or {"any_02": ["10", 0]}
return {
"3": {"class_type": "SeedHistory", "inputs": {"seed": 1538595059}},
"5": {
"class_type": "KikoProjectFilePath",
"inputs": {"project_name": "demo", "filename": "final"},
},
"6": {"class_type": "UNETLoader", "inputs": {"unet_name": "model.safetensors"}},
"7": {"class_type": "CLIPLoader", "inputs": {"clip_name": "clip.safetensors"}},
"8": {"class_type": "VAELoader", "inputs": {"vae_name": "vae.safetensors"}},
"9": {
"class_type": "Lora Loader (LoraManager)",
"inputs": {
"text": "<lora:style-demo:1>",
"loras": [{"name": "style-demo", "strength": 1, "active": True}],
"model": ["6", 0],
"clip": ["7", 0],
},
},
"10": pair(),
"15": {"class_type": "Any Switch (rgthree)", "inputs": inputs},
"16": {
"class_type": "EmptyLatentBatch",
"inputs": {"width": 1024, "height": 1536, "batch_size": 1},
},
"17": {
"class_type": "KSampler",
"inputs": {
"seed": ["3", 0],
"steps": 8,
"cfg": 1.0,
"sampler_name": "er_sde",
"scheduler": "beta",
"denoise": 1.0,
"model": ["9", 0],
"positive": ["15", 0],
"negative": ["10", 1],
"latent_image": ["16", 0],
},
},
"18": {
"class_type": "VAEDecode",
"inputs": {"samples": ["17", 0], "vae": ["8", 0]},
},
"19": {
"class_type": "KikoSaveImage",
"inputs": {"filename_prefix": ["5", 0], "images": ["18", 0]},
},
}
def with_nodes(graph, **nodes):
return {**graph, **nodes}
GENERATED = "a generated caption of a lighthouse"
def generated_text_graph():
"""PromptManagerPair whose ``text`` is a language model's output.
The generator (``sampling_mode.seed``, ``prompt``, ``system_prompt``)
writes new text at run time: its inputs are not the prompt.
"""
graph = any_switch_graph()
graph["10"]["inputs"]["text"] = ["30", 0]
graph["30"] = {
"class_type": "VendorTextGenerate",
"inputs": {
"prompt": ["31", 0],
"system_prompt": ["32", 0],
"sampling_mode.seed": 0,
"clip": ["7", 0],
},
}
graph["31"] = {"class_type": "PrimitiveStringMultiline", "inputs": {"value": OTHER}}
graph["32"] = {"class_type": "PrimitiveStringMultiline", "inputs": {"value": "You"}}
return graph
def transformed_text_graph():
"""PromptManagerPair whose ``text`` passes an unknown string transform."""
graph = any_switch_graph()
graph["10"]["inputs"]["text"] = ["30", 0]
graph["30"] = {
"class_type": "VendorRegexReplace",
"inputs": {"text": OTHER, "pattern": "rain", "replace": "snow"},
}
return graph
def execution(node_id, text):
"""A ``comfyassets_prompt_pairs`` record of what the pair node ran."""
record = {
"text": text,
"negative_text": "",
"positive_text": text,
"negative_effective_text": "",
"prepend_text": "",
"append_text": "",
}
return json.dumps({"version": 1, "nodes": {node_id: {"records": [record]}}})
def recorded_shapes():
"""Record sets whose PromptManager node recorded the text it ran."""
return {
"generated-recorded": {
"prompt": json.dumps(generated_text_graph()),
"comfyassets_prompt_pairs": execution("10", GENERATED),
},
"transformed-recorded": {
"prompt": json.dumps(transformed_text_graph()),
"comfyassets_prompt_pairs": execution("10", GENERATED),
},
}
def _sampler_inputs(graph, positive, negative):
graph["17"]["inputs"]["positive"] = positive
graph["17"]["inputs"]["negative"] = negative
return graph
def shapes():
"""One named graph per rule (resolved, candidates, PromptManager, refusals)."""
vendor_encode = {
"class_type": "VendorPromptEncode",
"inputs": {"prompt": ["21", 0], "clip": ["22", 1]},
}
control = {
"class_type": "VendorControlApply",
"inputs": {
"positive": ["21", 0],
"negative": ["22", 0],
"control_net": ["8", 0],
"image": ["8", 0],
},
}
return {
"any-switch-pair": any_switch_graph(),
"any-switch-same-pair": any_switch_graph(any_01=["10", 0], any_02=["10", 0]),
"any-switch-equal-texts": with_nodes(
any_switch_graph(any_01=["20", 0], any_02=["21", 0]),
**{"20": encode(OTHER), "21": encode(OTHER)},
),
"any-switch-candidates": with_nodes(
any_switch_graph(any_01=["20", 0], any_02=["21", 0]),
**{"20": encode(POSITIVE), "21": encode(OTHER)},
),
"any-switch-prompt-manager-wins": with_nodes(
any_switch_graph(any_01=["20", 0], any_02=["10", 0]),
**{"20": encode(OTHER)},
),
"any-switch-runtime-blocks": with_nodes(
any_switch_graph(any_01=["20", 0], any_02=["22", 0]),
**{
"20": {
"class_type": "CLIPTextEncode",
"inputs": {"text": ["21", 0], "clip": ["7", 0]},
},
"21": {"class_type": "PromptSearchList", "inputs": {"search": "x"}},
"22": encode(OTHER),
},
),
"any-switch-no-text": any_switch_graph(any_01=["7", 0]),
"unknown-chain": with_nodes(
any_switch_graph(any_01=["20", 0]),
**{
"20": {
"class_type": "Router Node (vendor)",
"inputs": {"in": ["10", 0]},
}
},
),
"unknown-text-input": with_nodes(
any_switch_graph(any_01=["20", 0]),
**{
"20": {
"class_type": "VendorTextEncode",
"inputs": {"text": OTHER, "clip": ["9", 1]},
}
},
),
"unknown-role-inputs": _sampler_inputs(
with_nodes(
any_switch_graph(),
**{"20": control, "21": encode(POSITIVE), "22": encode(NEGATIVE)},
),
["20", 0],
["20", 1],
),
"unknown-conditioning-input": with_nodes(
any_switch_graph(any_01=["20", 0]),
**{
"20": {
"class_type": "VendorStyleApply",
"inputs": {"conditioning": ["10", 0], "style": ["21", 0]},
},
"21": encode(OTHER),
},
),
"generated-text-runtime": generated_text_graph(),
"transformed-text": transformed_text_graph(),
"unknown-skips-clip": with_nodes(
any_switch_graph(any_01=["20", 0]),
**{
"20": vendor_encode,
"21": {"class_type": "PrimitiveString", "inputs": {"value": OTHER}},
"22": {
"class_type": "VendorLoraLoader",
"inputs": {"text": "<lora:x:1>", "clip": ["7", 0]},
},
},
),
}
utils/inspection_semantics.py
+29 -6
View File
@@ -13,7 +13,7 @@ profile never imports it, so a missing or bad table can never break ingestion.
An invalid table raises ``SemanticsError`` so a bad edit fails loudly instead of
silently changing what the inspector resolves. The file is bounded in size and
nesting before it is validated. Every class appears in exactly one prompt
category; classes that are not listed stay ``unsupported-node``. ``lineage``
category; an unlisted output of a listed class stays ``unsupported-node``. ``lineage``
(image and latent pass-through outputs for multi-stage chains) describes no
prompt, so its classes are not claimed by a category.
@@ -23,9 +23,13 @@ keys, no whitespace): any change of content, never of layout, moves it.
folds into the version of the items it records from the inspection profile
(``utils.review_capture``): the SHA-256 of ``class_projection``, the table
restricted to what it says about ``classes`` (the node classes of one graph)
plus the class-independent ``schema`` and ``stage_inputs``. The resolver looks
the table up only by the class of a graph node, so an edit about other
classes cannot change how that graph resolves and leaves the version alone.
plus the class-independent ``schema``, ``stage_inputs`` and ``pass_through``.
The resolver looks the table up only by the class of a graph node, so an edit
about other classes cannot change how that graph resolves and leaves the
version alone. A class the table does not list at all passes text through
(#381); that rule lives in code, so ``INSPECTION_RESOLVER_VERSION`` moves for it.
``pass_through.skip_inputs`` names the core type inputs (model, clip, image,
...) such a node's text is never read through.
"""
import hashlib
@@ -86,7 +90,7 @@ _CATEGORIES = frozenset(
+ _CLASS_CATEGORIES
+ _SLOT_CATEGORIES
+ _SET_CATEGORIES
+ ("lineage", "stage_inputs", "facts")
+ ("lineage", "stage_inputs", "pass_through", "facts")
)
# Input names that make an unlisted node a possible sampler stage in an ancestry
# walk (``shaped``: pipes, video embeds and custom-sampler parts carry a prompt
@@ -95,6 +99,10 @@ _CATEGORIES = frozenset(
# ``model`` alone (ModelSampling*) or with ``clip`` (LoraLoader) is a model patch.
# The resolver and comfy-metadata.js both read these lists.
_STAGE_INPUT_LISTS = ("shaped", "with_model")
# Inputs of core ComfyUI types (model, clip, image, ...) that an unknown node's
# output is never read through when the resolver passes text through it (#381):
# a loader's lora tag reached through ``clip`` is not the prompt.
_PASS_THROUGH_KEYS = ("skip_inputs",)
_STRING_PARAMS = MappingProxyType(
{
"literal": frozenset(),
@@ -127,6 +135,7 @@ class Semantics:
non_file_outputs: FrozenSet[str]
lineage: Mapping[Tuple[str, int], Mapping[str, Any]]
stage_inputs: Mapping[str, Tuple[str, ...]]
pass_through: Mapping[str, Tuple[str, ...]]
facts: Mapping[str, Any]
all_classes: FrozenSet[str]
# SHA-256 of the canonical table JSON (set by ``load_semantics``).
@@ -447,6 +456,19 @@ def _stage_inputs(doc: dict) -> Mapping[str, Tuple[str, ...]]:
return _freeze(table)
def _pass_through(doc: dict) -> Mapping[str, Tuple[str, ...]]:
table = doc["pass_through"]
if not isinstance(table, dict) or set(table) != set(_PASS_THROUGH_KEYS):
raise SemanticsError(
f"pass_through must have exactly {list(_PASS_THROUGH_KEYS)}"
)
_names(table["skip_inputs"], "pass_through.skip_inputs")
for name in ("text", "positive", "negative", "conditioning"):
if name in table["skip_inputs"]:
raise SemanticsError(f"pass_through.skip_inputs: {name} carries text")
return _freeze(table)
def _facts(doc: dict) -> Mapping[str, Any]:
facts = doc["facts"]
if not isinstance(facts, dict) or set(facts) != set(_FACTS_TABLES):
@@ -506,6 +528,7 @@ def _validate(doc: Any) -> Semantics:
return Semantics(
lineage=_lineage(doc),
stage_inputs=_stage_inputs(doc),
pass_through=_pass_through(doc),
facts=_facts(doc),
all_classes=owners.classes(),
**tables,
@@ -542,7 +565,7 @@ def load_semantics(path: Optional[Union[str, Path]] = None) -> Semantics:
# Table parts that hold no class names: they apply to every graph.
_CLASS_INDEPENDENT = frozenset({"schema", "stage_inputs"})
_CLASS_INDEPENDENT = frozenset({"schema", "stage_inputs", "pass_through"})
def _canonical_json(doc: Any) -> str:
utils/prompt_pair_resolver.py
+166 -17
View File
@@ -6,7 +6,9 @@ contains effective ``text``, deduplicated-recipe ``storage_text`` and
``provenance``; ComfyUI provenance records the exact output
slot and complete followed link path. States distinguish a resolved pair (an
explicit empty negative is valid), absent data, unsupported/unresolved data and
ambiguous sampler selection. Unknown conditioning semantics are never flattened.
ambiguous sampler selection. Listed composites are never flattened; in the
inspection profile, nodes the semantics table does not name pass their text
through (#381, ``_GraphResolver.passed``).
Future nodes can register declarative ``OutputAdapter`` entries by
``(class_type, output_slot)``. This does not prescribe a future paired-node schema.
@@ -48,7 +50,9 @@ RESOLVER_VERSION = 1
# review items recorded from that profile (with the profile's budgets and
# the semantics table). Bump it when a change would make the inspection
# profile resolve the same metadata otherwise, even if ingestion is unchanged.
INSPECTION_RESOLVER_VERSION = 1
# 2: unknown nodes pass through generically (#381); unknown classes are not in
# the table's class projection, so only this number can move those items.
INSPECTION_RESOLVER_VERSION = 2
@dataclass(frozen=True)
@@ -113,6 +117,15 @@ _HISTORICAL_ADAPTERS = {
for _name in ("PromptManagerPositive", "PromptManagerDetailer"):
_HISTORICAL_ADAPTERS[(_name, 0)] = _COMMA
_HISTORICAL_ADAPTERS[(_name, 1)] = replace(_COMMA, kind="string")
# This repository's own node classes, current and historical: their text is the
# prompt whatever unknown nodes sit between them and the sampler (#381).
_OWN_CLASSES = frozenset(
name
for name, _ in list(_DEFAULT_ADAPTERS) + list(_HISTORICAL_ADAPTERS)
if name.startswith("PromptManager")
)
# Nodes with these exact names are traced by code, not by the table.
_CODED_CLASSES = frozenset({"Reroute", "StringConcatenate", "Text Concatenate"})
@dataclass(frozen=True)
@@ -197,6 +210,16 @@ _ZEROED_SOURCE = "zeroed-conditioning"
_MAX_BRANCH_CANDIDATES = 32
# Statically undecidable text (a search, a list output): never pick an item.
_RUNTIME_REASON = "Text is decided at run time"
# Different texts reach one sampler through unknown nodes (#381): one candidate
# per text, never a refusal.
SEVERAL_SOURCES_REASON = "Several prompts reach the sampler"
SELECTOR_BRANCHES_REASON = "Selector branches have different prompts"
# Failures that bound the work: never skipped by a pass-through walk.
_LIMIT_CODES = frozenset({"work-limit", "depth-limit", "text-limit"})
# Inputs that make an unknown node a conditioning transform, not a generator.
_CONDITIONING_INPUTS = ("conditioning", "positive", "negative")
# The first item of a pass-through divergence's 3-tuple choice key.
_PASS_THROUGH = "pass-through"
# Uncoded outcomes the inspector explains by their exact reason.
EMPTY_POSITIVE_REASON = "Positive prompt is empty"
# Several sampler branches, every one resolved to the same pair (#249).
@@ -241,17 +264,23 @@ class _Unresolved(Exception):
class _Diverging(Exception):
"""A runtime selector whose branches trace to different texts.
"""A runtime choice whose options trace to different texts.
Raised from inside tracing; ``_GraphResolver.branches`` resolves the sampler
again once per choice, so each candidate is internally consistent.
again once per choice, so each candidate is internally consistent. A
selector's choices are ``(True, False)``; an unknown node passing several
texts through (#381) has one choice per distinct text, ``0..n-1``.
"""
def __init__(self, key: Tuple[str, int]) -> None:
def __init__(self, key: tuple, choices: tuple, sources: bool = False) -> None:
super().__init__(key)
# The condition output (node ID, slot): one runtime value, so every
# selector it drives is forced together.
# A selector's condition output (node ID, slot): one runtime value, so
# every selector it drives is forced together. A pass-through key is
# ``(_PASS_THROUGH, node ID, slot)``.
self.key = key
self.choices = choices
# Raised by an unknown node passing several texts (the outcome's reason).
self.sources = sources
def _node_ref(node_id: str, class_type: Any) -> dict:
@@ -457,6 +486,19 @@ class _GraphResolver:
)
# Any listed sampler upstream in latent ancestry is an earlier stage.
self.stage_classes = frozenset(semantics.samplers)
# Classes the resolver knows something about: an unlisted output of
# one stays ``unsupported-node``; any other class passes through.
facts = semantics.facts
self.described = (
semantics.all_classes
| {name for name, _ in semantics.lineage}
| {name for name, _ in self.adapters}
| _CODED_CLASSES
| frozenset(facts["configuration_outputs"])
| frozenset(facts["model_outputs"])
| frozenset(facts["model_passthroughs"])
| frozenset(facts["scalar_outputs"])
)
def node(self, node_id: str) -> Tuple[str, dict]:
if self.legacy:
@@ -557,7 +599,9 @@ class _GraphResolver:
self.inherit_source(node_id, slot, [path])
elif (name, slot) in self.adapters:
adapter = self.adapters[(name, slot)]
if not isinstance(adapter, OutputAdapter) or adapter.kind != kind:
if not isinstance(adapter, OutputAdapter) or (
kind != "any" and adapter.kind != kind
):
raise _Unresolved(_INCOMPATIBLE_SLOT, "malformed")
evidence = (
self.execution_record(node_id, inputs)
@@ -613,7 +657,7 @@ class _GraphResolver:
elif (
name in ("StringConcatenate", "Text Concatenate")
and slot == 0
and kind == "string"
and kind in ("string", "any")
):
if name == "StringConcatenate":
keys = ["string_a", "string_b"]
@@ -652,6 +696,10 @@ class _GraphResolver:
text, path, storage_text = self.semantic(
node_id, name, slot, kind, inputs, depth
)
elif self.semantics is not None and name not in self.described:
text, path, storage_text = self.passed(
node_id, slot, kind, inputs, depth
)
else:
raise self.unsupported(
"Unsupported node semantics or output slot", node_id
@@ -747,7 +795,7 @@ class _GraphResolver:
return True
if slot == 0 and name in semantics.selectors:
return True
return kind == "conditioning" and (
return kind in ("conditioning", "any") and (
(name, slot) in semantics.conditioning
or (slot == 0 and name in semantics.composites)
)
@@ -769,11 +817,13 @@ class _GraphResolver:
):
listed = table.get((name, slot))
if listed is not None:
if kind != expected:
if kind not in (expected, "any"):
raise _Unresolved(_INCOMPATIBLE_SLOT, "malformed")
return build(node_id, listed, inputs, depth)
entry = (
semantics.conditioning.get((name, slot)) if kind == "conditioning" else None
semantics.conditioning.get((name, slot))
if kind in ("conditioning", "any")
else None
)
if entry is not None and entry["strategy"] == "zeroed":
# The upstream text is discarded, so it is not traced.
@@ -825,9 +875,98 @@ class _GraphResolver:
for label in ("true", "false")
]
if parts[0][0] != parts[1][0]:
raise _Diverging((str(condition[0]), condition[1]))
raise _Diverging((str(condition[0]), condition[1]), (True, False))
return self.merged(node_id, 0, parts)
def passed(
self, node_id: str, slot: int, kind: str, inputs: dict, depth: int
) -> Tuple[str, list, str]:
"""An output no rule describes passes its text through (#381).
A text output (kind ``string`` or ``any``) of a node with a seed input
(``seed``, ``noise_seed``, ``sampling_mode.seed``) and no linked
conditioning input is generated at run time (a language model, a
wildcard or random line): ``runtime-value``, never its inputs. With a
linked conditioning input it is a conditioning transform (noise). A
``text`` input is the text (the legacy encoder rule). Otherwise the
followed inputs (``pass_inputs``) are traced with kind ``any``: an
unknown node may turn a string into conditioning. A followed input that
finds no text (``unsupported-node``) adds nothing; limits and runtime
choices propagate; any other failure blocks, unless a PromptManager
node was reached: this repository's own nodes are authoritative, so
only their texts count then. One distinct text is the result; several
are a runtime choice with one candidate per text, in input order.
"""
if (
kind != "conditioning"
and any(name.endswith("seed") for name in inputs)
and not any(_link(inputs.get(name)) for name in _CONDITIONING_INPUTS)
):
raise self.named(_RUNTIME_REASON, "runtime-value", node_id)
if "text" in inputs:
traced = self.text(inputs["text"], "string", depth + 1)
self.inherit_source(node_id, slot, [traced[1]])
return traced
found: list = []
blocking: Optional[_Unresolved] = None
for value in self.pass_inputs(slot, inputs):
try:
found.append(self.text(value, "any", depth + 1))
except _Unresolved as error:
if error.code in _LIMIT_CODES:
raise
if error.code != "unsupported-node" and blocking is None:
blocking = error
owned = [traced for traced in found if self.owned(traced[1])]
if owned:
found = owned
elif blocking is not None:
raise blocking
if not found:
raise self.unsupported("Unsupported node semantics or output slot", node_id)
texts = list(dict.fromkeys(traced[0] for traced in found))
if len(texts) == 1:
return self.merged(node_id, slot, found)
if len(texts) > _MAX_BRANCH_CANDIDATES:
raise _Unresolved("Too many selector branches", "work-limit")
key = (_PASS_THROUGH, node_id, slot)
if key not in self.choices:
raise _Diverging(key, tuple(range(len(texts))), sources=True)
self.tainted = True
chosen = texts[self.choices[key]]
return self.merged(node_id, slot, [t for t in found if t[0] == chosen])
def pass_inputs(self, slot: int, inputs: dict) -> list:
"""The linked inputs an unknown node's output is read through.
Output slot 0 with a linked ``positive`` (slot 1, ``negative``) reads
only that input: the paired-conditioning convention, which the legacy
parser followed by role. A linked ``conditioning`` is read alone (the
legacy order). Otherwise every linked input but the core type inputs
(``pass_through.skip_inputs``: model, clip, image, ...) is read.
"""
for wanted, name in ((0, "positive"), (1, "negative")):
if slot == wanted and _link(inputs.get(name)):
return [inputs[name]]
if _link(inputs.get("conditioning")):
return [inputs["conditioning"]]
skipped = self.semantics.pass_through["skip_inputs"]
return [
value
for name, value in inputs.items()
if _link(value) and name not in skipped
]
def through_unknown(self, path: list) -> bool:
"""Whether a followed path passes through a node no rule describes."""
self.scan(len(path))
return any(self.node(step["node_id"])[0] not in self.described for step in path)
def owned(self, path: list) -> bool:
"""Whether a followed path passes through one of this repository's nodes."""
self.scan(len(path))
return any(self.node(step["node_id"])[0] in _OWN_CLASSES for step in path)
def merged(self, node_id: str, slot: int, parts: list) -> Tuple[str, list, str]:
"""One text reached through several followed paths (deduplicated)."""
text, merged, storage_text = self.joined_paths(parts, parts)
@@ -1022,7 +1161,11 @@ class _GraphResolver:
return None
for name in ("text", "negative_text", "prepend_text", "append_text"):
try:
expected = self.text(inputs.get(name, ""), "string")[0]
expected, followed, _ = self.text(inputs.get(name, ""), "string")
except _Diverging:
# Several texts passed through an unknown node (#381): the
# record is what ran, so it is not checked against them.
continue
except _Unresolved as error:
if self.unverifiable(error):
value = inputs.get(name)
@@ -1043,6 +1186,9 @@ class _GraphResolver:
raise
continue
raise
if self.semantics is not None and self.through_unknown(followed):
# A text passed through an unknown node may be transformed there.
continue
if name in ("prepend_text", "append_text"):
expected = expected.strip()
if expected != record[name]:
@@ -1563,17 +1709,20 @@ class _GraphResolver:
"""
pending: list = [{}]
results: list = []
several = False
try:
while pending:
self.choices = pending.pop(0)
try:
results.append(self.stage(sampler_id, frozenset()))
except _Diverging as diverging:
if len(results) + len(pending) + 2 > _MAX_BRANCH_CANDIDATES:
count = len(diverging.choices)
if len(results) + len(pending) + count > _MAX_BRANCH_CANDIDATES:
raise _Unresolved("Too many selector branches", "work-limit")
several = several or diverging.sources
pending.extend(
{**self.choices, diverging.key: choice}
for choice in (True, False)
for choice in diverging.choices
)
except _Unresolved as error:
return _result(
@@ -1592,7 +1741,7 @@ class _GraphResolver:
return _result(
"ambiguous",
sampler_id=sampler_id,
reason="Selector branches have different prompts",
reason=SEVERAL_SOURCES_REASON if several else SELECTOR_BRANCHES_REASON,
candidates=results,
)
web/js/inspection-semantics.json
+23
View File
@@ -246,6 +246,29 @@
],
"with_model": ["conditioning", "neg_conditioning", "samples", "latent"]
},
"pass_through": {
"skip_inputs": [
"model",
"clip",
"vae",
"clip_vision",
"clip_vision_output",
"control_net",
"style_model",
"upscale_model",
"image",
"images",
"pixels",
"mask",
"latent",
"latent_image",
"samples",
"noise",
"sampler",
"sigmas",
"guider"
]
},
"facts": {
"configuration_outputs": {
"RandomNoise": { "kind": "noise", "fields": ["noise_seed"] },
web/js/workspace/local-resolver-support.mjs
+28 -1
View File
@@ -29,6 +29,14 @@ export const ZEROED_SOURCE = 'zeroed-conditioning';
export const MAX_BRANCH_CANDIDATES = 32;
export const RUNTIME_REASON = 'Text is decided at run time';
export const EMPTY_POSITIVE_REASON = 'Positive prompt is empty';
// #381: different texts reach one sampler through unknown nodes (one candidate each).
export const SEVERAL_SOURCES_REASON = 'Several prompts reach the sampler';
export const SELECTOR_BRANCHES_REASON = 'Selector branches have different prompts';
// Failures that bound the work: never skipped by a pass-through walk (`_LIMIT_CODES`).
export const PASS_LIMIT_CODES = new Set(['work-limit', 'depth-limit', 'text-limit']);
export const PASS_THROUGH = 'pass-through';
// Classes traced by code, not by the table (`_CODED_CLASSES`).
export const CODED_CLASSES = ['Reroute', 'StringConcatenate', 'Text Concatenate'];
export const IDENTICAL_BRANCHES_REASON = 'Every sampler branch uses the same prompt pair';
export const MULTISTAGE_UNATTRIBUTED_REASON = 'Multistage sampler ancestry is ambiguous';
export const ADDED_CONDITIONING_REASON = 'A later stage adds conditioning to the base prompt';
@@ -96,6 +104,8 @@ const historical = [
];
for (const name of ['PromptManagerPositive', 'PromptManagerDetailer']) historical.push([name, 0, 'text', 'conditioning', COMMA], [name, 1, 'text', 'string', COMMA]);
for (const [name, slot, input, kind, options] of historical) ADAPTERS.set(slotKey(name, slot), adapter(input, kind, options));
// This repository's own classes (`_OWN_CLASSES`): authoritative through unknown nodes (#381).
export const OWN_CLASSES = new Set([...ADAPTERS.keys()].map(key => key.split('\u0000')[0]).filter(name => name.startsWith('PromptManager')));
// `known_slots` in execution_record: every adapter slot per class.
export const ADAPTER_SLOTS = new Map();
for (const key of ADAPTERS.keys()) {
@@ -112,9 +122,13 @@ export class Unresolved extends Error {
}
}
export class Diverging extends Error {
constructor(key) {
/** A selector's choices are [true, false]; an unknown node's are 0..n-1, one per distinct text (#381). */
constructor(key, choices, sources = false) {
super('diverging');
this.key = key;
this.choices = choices;
// Raised by an unknown node passing several texts (the outcome's reason).
this.sources = sources;
}
}
@@ -247,9 +261,22 @@ export function compileSemantics(doc) {
}
const stageInputs = doc.stage_inputs;
if (!plain(stageInputs) || !Array.isArray(stageInputs.shaped) || !Array.isArray(stageInputs.with_model)) fail('stage_inputs');
// #381: core type inputs an unknown node's text is never read through.
const passThrough = doc.pass_through;
if (!plain(passThrough) || Object.keys(passThrough).length !== 1 || !Array.isArray(passThrough.skip_inputs) ||
!passThrough.skip_inputs.length || passThrough.skip_inputs.some(name => typeof name !== 'string' || !name) ||
new Set(passThrough.skip_inputs).size !== passThrough.skip_inputs.length ||
['text', 'positive', 'negative', 'conditioning'].some(name => passThrough.skip_inputs.includes(name))) fail('pass_through');
// Classes the facts tables describe (loaders, model patches, configuration and scalar outputs).
const facts = doc.facts;
if (!plain(facts) || !plain(facts.configuration_outputs) || !plain(facts.model_outputs) || !Array.isArray(facts.model_passthroughs) ||
!plain(facts.scalar_outputs)) fail('facts');
const factClasses = new Set([...Object.keys(facts.configuration_outputs), ...Object.keys(facts.model_outputs), ...facts.model_passthroughs,
...Object.keys(facts.scalar_outputs)]);
return Object.freeze({
samplers, guiders, selectors, composites, savers, conditioning, encoders, strings, runtime, nonFileOutputs, lineage,
stageInputs: { shaped: [...stageInputs.shaped], withModel: [...stageInputs.with_model] }, allClasses: new Set(owners.keys()),
skipInputs: new Set(passThrough.skip_inputs), factClasses,
});
}
web/js/workspace/local-resolver.mjs
+84 -11
View File
@@ -23,7 +23,13 @@ import {
MAX_JOIN_INPUTS,
MAX_SUBGRAPH_DEPTH,
MAX_WORKFLOW_NODES,
CODED_CLASSES,
NO_SAMPLER_NAMES,
OWN_CLASSES,
PASS_LIMIT_CODES,
PASS_THROUGH,
SELECTOR_BRANCHES_REASON,
SEVERAL_SOURCES_REASON,
OVERWRITTEN_PROMPT_REASON,
PROFILE,
ROLE_METADATA_KEYS,
@@ -78,6 +84,9 @@ class GraphResolver {
this.semantics = semantics;
this.samplerClasses = new Set([...semantics.samplers].filter(([, entry]) => CANDIDATE_STRATEGIES.has(entry.strategy)).map(([name]) => name));
this.stageClasses = new Set(semantics.samplers.keys());
// `described`: an unlisted output of one of these stays `unsupported-node`; any other class passes through (#381).
this.described = new Set([...semantics.allClasses, ...[...semantics.lineage.keys()].map(key => key.split('\u0000')[0]),
...[...ADAPTERS.keys()].map(key => key.split('\u0000')[0]), ...CODED_CLASSES, ...semantics.factClasses]);
}
node(nodeId) {
@@ -156,7 +165,7 @@ class GraphResolver {
[text, path, storageText] = this.text(inputs.get(keys[0]), kind, depth + 1);
this.inheritSource(nodeId, slot, [path]);
} else if (adapted) {
if (adapted.kind !== kind) throw new Unresolved(INCOMPATIBLE_SLOT, 'malformed');
if (kind !== 'any' && adapted.kind !== kind) throw new Unresolved(INCOMPATIBLE_SLOT, 'malformed');
const evidence = name === 'PromptManagerPair' ? this.executionRecord(nodeId, inputs) : null;
if (evidence !== null) {
text = evidence[adapted.inputName === 'text' ? 'positive_text' : 'negative_effective_text'];
@@ -178,11 +187,13 @@ class GraphResolver {
if (omitted.length) this.omitting.add(slotKey(nodeId, slot));
}
}
} else if ((name === 'StringConcatenate' || name === 'Text Concatenate') && slot === 0 && kind === 'string') {
} else if ((name === 'StringConcatenate' || name === 'Text Concatenate') && slot === 0 && (kind === 'string' || kind === 'any')) {
[text, path] = this.concatenate(name, inputs, depth);
storageText = text;
} else if (this.follows(name, slot, kind)) {
[text, path, storageText] = this.semantic(nodeId, name, slot, kind, inputs, depth);
} else if (!this.described.has(name)) {
[text, path, storageText] = this.passed(nodeId, slot, kind, inputs, depth);
} else {
throw this.unsupported('Unsupported node semantics or output slot', nodeId);
}
@@ -258,7 +269,7 @@ class GraphResolver {
if (semantics.runtime.has(name)) return true;
if (semantics.encoders.has(key) || semantics.strings.has(key)) return true;
if (slot === 0 && semantics.selectors.has(name)) return true;
return kind === 'conditioning' && (semantics.conditioning.has(key) || (slot === 0 && semantics.composites.has(name)));
return (kind === 'conditioning' || kind === 'any') && (semantics.conditioning.has(key) || (slot === 0 && semantics.composites.has(name)));
}
semantic(nodeId, name, slot, kind, inputs, depth) {
@@ -267,11 +278,11 @@ class GraphResolver {
for (const [table, expected, build] of [[semantics.encoders, 'conditioning', 'encoded'], [semantics.strings, 'string', 'stringed']]) {
const listed = table.get(key);
if (listed !== undefined) {
if (kind !== expected) throw new Unresolved(INCOMPATIBLE_SLOT, 'malformed');
if (kind !== expected && kind !== 'any') throw new Unresolved(INCOMPATIBLE_SLOT, 'malformed');
return this[build](nodeId, listed, inputs, depth);
}
}
const entry = kind === 'conditioning' ? semantics.conditioning.get(key) : undefined;
const entry = kind === 'conditioning' || kind === 'any' ? semantics.conditioning.get(key) : undefined;
if (entry !== undefined && entry.strategy === 'zeroed') {
this.textSources.set(slotKey(nodeId, slot), ZEROED_SOURCE);
return ['', [], ''];
@@ -302,10 +313,66 @@ class GraphResolver {
return traced;
}
const parts = ['true', 'false'].map(label => this.text(pyGet(inputs, branches[label]), kind, depth + 1));
if (parts[0][0] !== parts[1][0]) throw new Diverging(slotKey(String(condition[0]), condition[1]));
if (parts[0][0] !== parts[1][0]) throw new Diverging(slotKey(String(condition[0]), condition[1]), [true, false]);
return this.merged(nodeId, 0, parts);
}
/** `passed` (#381): an output no rule describes passes its text through; PromptManager nodes are authoritative. */
passed(nodeId, slot, kind, inputs, depth) {
// A text output of a node with a seed input is generated at run time (a language model, a wildcard).
// With a linked conditioning input it is a conditioning transform (noise) instead.
if (kind !== 'conditioning' && [...inputs.keys()].some(name => name.endsWith('seed')) &&
!['conditioning', 'positive', 'negative'].some(name => isLink(pyGet(inputs, name)))) throw this.named(RUNTIME_REASON, 'runtime-value', nodeId);
if (inputs.has('text')) {
const traced = this.text(inputs.get('text'), 'string', depth + 1);
this.inheritSource(nodeId, slot, [traced[1]]);
return traced;
}
let found = [], blocking = null;
for (const value of this.passInputs(slot, inputs)) {
try {
found.push(this.text(value, 'any', depth + 1));
} catch (error) {
if (!(error instanceof Unresolved) || PASS_LIMIT_CODES.has(error.code)) throw error;
if (error.code !== 'unsupported-node' && blocking === null) blocking = error;
}
}
const owned = found.filter(traced => this.owned(traced[1]));
if (owned.length) found = owned;
else if (blocking !== null) throw blocking;
if (!found.length) throw this.unsupported('Unsupported node semantics or output slot', nodeId);
const texts = [...new Set(found.map(traced => traced[0]))];
if (texts.length === 1) return this.merged(nodeId, slot, found);
if (texts.length > MAX_BRANCH_CANDIDATES) throw new Unresolved('Too many selector branches', 'work-limit');
// JSON escapes U+0000, so this never equals a selector's raw `slotKey` (Python: a 3-tuple vs a 2-tuple).
const key = JSON.stringify([PASS_THROUGH, nodeId, slot]);
if (!this.choices.has(key)) throw new Diverging(key, texts.map((_, index) => index), true);
this.tainted = true;
const chosen = texts[this.choices.get(key)];
return this.merged(nodeId, slot, found.filter(traced => traced[0] === chosen));
}
/** `pass_inputs`: the role input by output slot, else `conditioning`, else every linked non-type input. */
passInputs(slot, inputs) {
for (const [wanted, name] of [[0, 'positive'], [1, 'negative']]) {
if (slot === wanted && isLink(pyGet(inputs, name))) return [inputs.get(name)];
}
if (isLink(pyGet(inputs, 'conditioning'))) return [inputs.get('conditioning')];
return [...inputs].filter(([name, value]) => isLink(value) && !this.semantics.skipInputs.has(name)).map(([, value]) => value);
}
/** `through_unknown`: whether a followed path passes through a node no rule describes. */
throughUnknown(path) {
this.scan(path.length);
return path.some(step => !this.described.has(this.node(step.node_id)[0]));
}
/** `owned`: whether a followed path passes through one of this repository's nodes. */
owned(path) {
this.scan(path.length);
return path.some(step => OWN_CLASSES.has(this.node(step.node_id)[0]));
}
merged(nodeId, slot, parts) {
const traced = this.joinedPaths(parts, parts);
this.inheritSource(nodeId, slot, parts.map(part => part[1]));
@@ -421,10 +488,12 @@ class GraphResolver {
const record = readPairExecution(this.metadata, nodeId);
if (record === null) return null;
for (const name of ['text', 'negative_text', 'prepend_text', 'append_text']) {
let expected;
let expected, followed;
try {
expected = this.text(pyGet(inputs, name, ''), 'string')[0];
[expected, followed] = this.text(pyGet(inputs, name, ''), 'string');
} catch (error) {
// Several texts passed through an unknown node (#381): the record is what ran.
if (error instanceof Diverging) continue;
if (error instanceof Unresolved && this.unverifiable(error)) {
const value = pyGet(inputs, name);
if (isLink(value)) {
@@ -437,6 +506,8 @@ class GraphResolver {
}
throw error;
}
// A text passed through an unknown node may be transformed there.
if (this.throughUnknown(followed)) continue;
if (name === 'prepend_text' || name === 'append_text') expected = pyStrip(expected);
if (expected !== record[name]) throw new Unresolved('Execution evidence does not match recorded node inputs', 'malformed');
}
@@ -492,6 +563,7 @@ class GraphResolver {
branches(samplerId) {
const pending = [new Map()], results = [];
let several = false;
try {
while (pending.length) {
this.choices = pending.shift();
@@ -499,8 +571,9 @@ class GraphResolver {
results.push(stage(this, samplerId, new Set()));
} catch (error) {
if (!(error instanceof Diverging)) throw error;
if (results.length + pending.length + 2 > MAX_BRANCH_CANDIDATES) throw new Unresolved('Too many selector branches', 'work-limit');
for (const choice of [true, false]) pending.push(new Map([...this.choices, [error.key, choice]]));
if (results.length + pending.length + error.choices.length > MAX_BRANCH_CANDIDATES) throw new Unresolved('Too many selector branches', 'work-limit');
several = several || error.sources;
for (const choice of error.choices) pending.push(new Map([...this.choices, [error.key, choice]]));
}
}
} catch (error) {
@@ -511,7 +584,7 @@ class GraphResolver {
}
if (results.every(item => item.state === 'unresolved')) return results[0];
if (new Set(results.map(outcomeKey)).size === 1) return results[0];
return result('ambiguous', { samplerId, reason: 'Selector branches have different prompts', candidates: results });
return result('ambiguous', { samplerId, reason: several ? SEVERAL_SOURCES_REASON : SELECTOR_BRANCHES_REASON, candidates: results });
}
sides(samplerId) {