532 lines
18 KiB
Python
532 lines
18 KiB
Python
# SimpleSyrup - workflow-focused ComfyUI extensions for image generation
|
|
# Copyright (C) 2026 Artificial Sweetener and contributors
|
|
# SPDX-License-Identifier: AGPL-3.0-or-later
|
|
|
|
"""Tests for SimpleSyrup ComfyUI node registration."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import importlib
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
from types import ModuleType
|
|
|
|
import pytest
|
|
|
|
|
|
def test_package_exports_node_mappings() -> None:
|
|
"""Root package import exposes ComfyUI mapping dictionaries."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
|
|
assert hasattr(package, "NODE_CLASS_MAPPINGS")
|
|
assert hasattr(package, "NODE_DISPLAY_NAME_MAPPINGS")
|
|
assert hasattr(package, "comfy_entrypoint")
|
|
assert package.WEB_DIRECTORY == "./web/dist"
|
|
|
|
|
|
def test_package_imports_from_custom_nodes_parent_path() -> None:
|
|
"""ComfyUI-style import works without the repository root on sys.path."""
|
|
|
|
project_root = Path(__file__).resolve().parents[1]
|
|
custom_nodes_root = project_root.parent
|
|
script = (
|
|
"import importlib, pathlib, sys; "
|
|
f"project = pathlib.Path({str(project_root)!r}).resolve(); "
|
|
"sys.path = [p for p in sys.path "
|
|
"if pathlib.Path(p or '.').resolve() != project]; "
|
|
f"sys.path.insert(0, {str(custom_nodes_root)!r}); "
|
|
"package = importlib.import_module('SimpleSyrup'); "
|
|
"assert 'SimpleSyrup.PromptSEGSWithSAM' in package.NODE_CLASS_MAPPINGS; "
|
|
"assert 'server' not in sys.modules"
|
|
)
|
|
|
|
result = subprocess.run(
|
|
[sys.executable, "-c", script],
|
|
cwd=custom_nodes_root,
|
|
check=False,
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
|
|
assert result.returncode == 0, result.stderr
|
|
|
|
|
|
def test_comfy_import_exposes_stable_internal_package_alias() -> None:
|
|
"""ComfyUI-style import exposes `simple_syrup` for vendored runtime imports."""
|
|
|
|
project_root = Path(__file__).resolve().parents[1]
|
|
custom_nodes_root = project_root.parent
|
|
script = (
|
|
"import importlib, pathlib, sys; "
|
|
f"project = pathlib.Path({str(project_root)!r}).resolve(); "
|
|
"sys.path = [p for p in sys.path "
|
|
"if pathlib.Path(p or '.').resolve() != project]; "
|
|
f"sys.path.insert(0, {str(custom_nodes_root)!r}); "
|
|
"importlib.import_module('SimpleSyrup'); "
|
|
"runtime = importlib.import_module("
|
|
"'simple_syrup.third_party.groundingdino_runtime.models'"
|
|
"); "
|
|
"assert runtime.__name__.endswith('groundingdino_runtime.models')"
|
|
)
|
|
|
|
result = subprocess.run(
|
|
[sys.executable, "-c", script],
|
|
cwd=custom_nodes_root,
|
|
check=False,
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
|
|
assert result.returncode == 0, result.stderr
|
|
|
|
|
|
def test_resize_node_is_registered() -> None:
|
|
"""Resize node id maps to the expected node class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.ResizeImageToTarget"]
|
|
|
|
assert registered.__name__ == "ResizeImageToTarget"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.ResizeImageToTarget"]
|
|
== "Resize Image to Target"
|
|
)
|
|
|
|
|
|
def test_ksampler_extras_node_is_registered() -> None:
|
|
"""KSampler Extras node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.KSamplerExtras"]
|
|
|
|
assert registered.__name__ == "KSamplerExtras"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.KSamplerExtras"]
|
|
== "KSampler (Extras)"
|
|
)
|
|
|
|
|
|
def test_ksampler_tiled_diffusion_node_is_registered() -> None:
|
|
"""KSampler tiled diffusion node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.KSamplerTiledDiffusion"]
|
|
|
|
assert registered.__name__ == "KSamplerTiledDiffusion"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.KSamplerTiledDiffusion"]
|
|
== "KSampler (Tiled Diffusion)"
|
|
)
|
|
assert (
|
|
"KSamplerTiledDiffusion"
|
|
in importlib.import_module("SimpleSyrup.simple_syrup.nodes").__all__
|
|
)
|
|
assert "SimpleSyrup.KSamplerMixtureOfDiffusers" not in package.NODE_CLASS_MAPPINGS
|
|
assert "SimpleSyrup.KSamplerMultiDiffusion" not in package.NODE_CLASS_MAPPINGS
|
|
assert (
|
|
"SimpleSyrup.KSamplerMixtureOfDiffusers"
|
|
not in package.NODE_DISPLAY_NAME_MAPPINGS
|
|
)
|
|
assert (
|
|
"SimpleSyrup.KSamplerMultiDiffusion" not in package.NODE_DISPLAY_NAME_MAPPINGS
|
|
)
|
|
|
|
|
|
def test_latent_diagnostics_node_is_registered() -> None:
|
|
"""Latent Diagnostics node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.LatentDiagnostics"]
|
|
|
|
assert registered.__name__ == "LatentDiagnostics"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.LatentDiagnostics"]
|
|
== "Latent Diagnostics"
|
|
)
|
|
|
|
|
|
def test_prompt_encode_style_node_is_registered() -> None:
|
|
"""Prompt Encode Style node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.PromptEncodeStyle"]
|
|
|
|
assert registered.__name__ == "PromptEncodeStyle"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.PromptEncodeStyle"]
|
|
== "Prompt Encode Style"
|
|
)
|
|
|
|
|
|
def test_prompt_encode_style_and_normalization_node_is_registered() -> None:
|
|
"""Prompt Encode Style & Normalization node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS[
|
|
"SimpleSyrup.PromptEncodeStyleAndNormalization"
|
|
]
|
|
|
|
assert registered.__name__ == "PromptEncodeStyleAndNormalization"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS[
|
|
"SimpleSyrup.PromptEncodeStyleAndNormalization"
|
|
]
|
|
== "Prompt Encode Style & Normalization"
|
|
)
|
|
|
|
|
|
def test_prompt_control_encode_style_clean_break_id_is_removed() -> None:
|
|
"""Old Prompt Control Encode Style node id is not registered."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
|
|
assert "SimpleSyrup.PromptControlEncodeStyle" not in package.NODE_CLASS_MAPPINGS
|
|
assert (
|
|
"SimpleSyrup.PromptControlEncodeStyle" not in package.NODE_DISPLAY_NAME_MAPPINGS
|
|
)
|
|
|
|
|
|
def test_prompt_segs_with_sam_node_is_registered() -> None:
|
|
"""Prompt SEGS w/ SAM node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.PromptSEGSWithSAM"]
|
|
|
|
assert registered.__name__ == "PromptSEGSWithSAM"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.PromptSEGSWithSAM"]
|
|
== "Prompt SEGS w/ SAM"
|
|
)
|
|
assert "SimpleSyrup.PromptSAMMask" not in package.NODE_CLASS_MAPPINGS
|
|
assert "SimpleSyrup.PromptSAMMask" not in package.NODE_DISPLAY_NAME_MAPPINGS
|
|
|
|
|
|
def test_sam_model_loader_node_is_registered() -> None:
|
|
"""SAM loader node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.SAMModelLoader"]
|
|
|
|
assert registered.__name__ == "SAMModelLoader"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.SAMModelLoader"]
|
|
== "SAM Model Loader"
|
|
)
|
|
|
|
|
|
def test_scale_factor_node_is_registered() -> None:
|
|
"""Scale Factor node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.ScaleFactor"]
|
|
|
|
assert registered.__name__ == "ScaleFactor"
|
|
assert package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.ScaleFactor"] == (
|
|
"Scale Factor"
|
|
)
|
|
assert (
|
|
"ScaleFactor"
|
|
in importlib.import_module("SimpleSyrup.simple_syrup.nodes").__all__
|
|
)
|
|
|
|
|
|
def test_seed_node_is_registered() -> None:
|
|
"""Seed node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.Seed"]
|
|
|
|
assert registered.__name__ == "Seed"
|
|
assert package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.Seed"] == "Seed"
|
|
|
|
|
|
def test_grounding_dino_model_loader_node_is_registered() -> None:
|
|
"""GroundingDINO loader node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.GroundingDINOModelLoader"]
|
|
|
|
assert registered.__name__ == "GroundingDINOModelLoader"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.GroundingDINOModelLoader"]
|
|
== "GroundingDINO Model Loader"
|
|
)
|
|
|
|
|
|
def test_vitmatte_model_loader_node_is_registered() -> None:
|
|
"""ViTMatte loader node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.ViTMatteModelLoader"]
|
|
|
|
assert registered.__name__ == "ViTMatteModelLoader"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.ViTMatteModelLoader"]
|
|
== "ViTMatte Model Loader"
|
|
)
|
|
|
|
|
|
def test_wd14_tagger_loader_node_is_registered() -> None:
|
|
"""WD14 tagger loader node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.WD14TaggerLoader"]
|
|
|
|
assert registered.__name__ == "WD14TaggerLoader"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.WD14TaggerLoader"]
|
|
== "Load WD14 Tagger"
|
|
)
|
|
|
|
|
|
def test_load_ultralytics_model_node_is_registered() -> None:
|
|
"""Load Ultralytics Model node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.LoadUltralyticsModel"]
|
|
|
|
assert registered.__name__ == "LoadUltralyticsModel"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.LoadUltralyticsModel"]
|
|
== "Load Ultralytics Model"
|
|
)
|
|
|
|
|
|
def test_detect_segs_with_ultralytics_node_is_registered() -> None:
|
|
"""Detect SEGS w/ Ultralytics node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.DetectSEGSWithUltralytics"]
|
|
|
|
assert registered.__name__ == "DetectSEGSWithUltralytics"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.DetectSEGSWithUltralytics"]
|
|
== "Detect SEGS w/ Ultralytics"
|
|
)
|
|
|
|
|
|
def test_detail_segs_by_scale_factor_node_is_registered() -> None:
|
|
"""Detail SEGS by Scale Factor node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.DetailSEGSByScaleFactor"]
|
|
|
|
assert registered.__name__ == "DetailSEGSByScaleFactor"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.DetailSEGSByScaleFactor"]
|
|
== "Detail SEGS by Scale Factor"
|
|
)
|
|
|
|
|
|
def test_tiled_detail_segs_by_scale_factor_node_is_registered() -> None:
|
|
"""Tiled Detail SEGS by Scale Factor node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS[
|
|
"SimpleSyrup.DetailSEGSByScaleFactorTiledDiffusion"
|
|
]
|
|
|
|
assert registered.__name__ == "DetailSEGSByScaleFactorTiledDiffusion"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS[
|
|
"SimpleSyrup.DetailSEGSByScaleFactorTiledDiffusion"
|
|
]
|
|
== "Detail SEGS by Scale Factor w/ Tiled Diffusion"
|
|
)
|
|
assert (
|
|
"DetailSEGSByScaleFactorTiledDiffusion"
|
|
in importlib.import_module("SimpleSyrup.simple_syrup.nodes").__all__
|
|
)
|
|
|
|
|
|
def test_detail_segs_as_regions_node_is_registered() -> None:
|
|
"""Detail SEGS as Regions node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.DetailSEGSAsRegions"]
|
|
|
|
assert registered.__name__ == "DetailSEGSAsRegions"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.DetailSEGSAsRegions"]
|
|
== "Detail SEGS as Regions"
|
|
)
|
|
|
|
|
|
def test_tile_and_tag_segs_node_is_registered() -> None:
|
|
"""Tile & Tag SEGS node maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.TileAndTagSEGS"]
|
|
|
|
assert registered.__name__ == "TileAndTagSEGS"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.TileAndTagSEGS"]
|
|
== "Tile & Tag SEGS"
|
|
)
|
|
|
|
|
|
def test_conditioning_batch_nodes_are_registered() -> None:
|
|
"""Conditioning batch nodes map to their classes and display names."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
|
|
assert (
|
|
package.NODE_CLASS_MAPPINGS["SimpleSyrup.ConditioningBatchStart"].__name__
|
|
== "ConditioningBatchStart"
|
|
)
|
|
assert (
|
|
package.NODE_CLASS_MAPPINGS["SimpleSyrup.ConditioningBatchAppend"].__name__
|
|
== "ConditioningBatchAppend"
|
|
)
|
|
assert (
|
|
package.NODE_CLASS_MAPPINGS["SimpleSyrup.EncodePromptBatch"].__name__
|
|
== "EncodePromptBatch"
|
|
)
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.ConditioningBatchStart"]
|
|
== "Conditioning Batch Start"
|
|
)
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.ConditioningBatchAppend"]
|
|
== "Conditioning Batch Append"
|
|
)
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.EncodePromptBatch"]
|
|
== "Encode Prompt Batch"
|
|
)
|
|
|
|
|
|
def test_layerstyle_adapter_node_is_registered() -> None:
|
|
"""LayerStyle adapter node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.LayerStyleSAMModelsAdapter"]
|
|
|
|
assert registered.__name__ == "LayerStyleSAMModelsAdapter"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.LayerStyleSAMModelsAdapter"]
|
|
== "LayerStyle SAM Models Adapter"
|
|
)
|
|
|
|
|
|
def test_grounded_sam_model_info_node_is_registered() -> None:
|
|
"""Grounded SAM model info node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.GroundedSAMModelInfo"]
|
|
|
|
assert registered.__name__ == "GroundedSAMModelInfo"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.GroundedSAMModelInfo"]
|
|
== "Grounded SAM Model Info"
|
|
)
|
|
|
|
|
|
def test_simple_load_anima_node_is_registered() -> None:
|
|
"""Simple Load Anima node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.SimpleLoadAnima"]
|
|
|
|
assert registered.__name__ == "SimpleLoadAnima"
|
|
assert registered.RETURN_TYPES == ("MODEL", "CLIP", "VAE")
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.SimpleLoadAnima"]
|
|
== "Simple Load Anima"
|
|
)
|
|
|
|
|
|
def test_simple_load_checkpoint_node_is_registered() -> None:
|
|
"""Simple Load Checkpoint node id maps to its class and display name."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
registered = package.NODE_CLASS_MAPPINGS["SimpleSyrup.SimpleLoadCheckpoint"]
|
|
|
|
assert registered.__name__ == "SimpleLoadCheckpoint"
|
|
assert registered.RETURN_TYPES == ("MODEL", "CLIP", "VAE")
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.SimpleLoadCheckpoint"]
|
|
== "Simple Load Checkpoint"
|
|
)
|
|
|
|
|
|
def test_provenance_latent_nodes_are_registered() -> None:
|
|
"""Provenance-aware latent nodes map to their classes and display names."""
|
|
|
|
package = importlib.import_module("SimpleSyrup")
|
|
nodes_package = importlib.import_module("SimpleSyrup.simple_syrup.nodes")
|
|
|
|
simple_vae = package.NODE_CLASS_MAPPINGS["SimpleSyrup.SimpleVAEEncode"]
|
|
upscale = package.NODE_CLASS_MAPPINGS["SimpleSyrup.UpscaleLatentFromImage"]
|
|
|
|
assert simple_vae.__name__ == "SimpleVAEEncode"
|
|
assert upscale.__name__ == "UpscaleLatentFromImage"
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.SimpleVAEEncode"]
|
|
== "Simple VAE Encode"
|
|
)
|
|
assert (
|
|
package.NODE_DISPLAY_NAME_MAPPINGS["SimpleSyrup.UpscaleLatentFromImage"]
|
|
== "Upscale Latent From Image"
|
|
)
|
|
assert "SimpleVAEEncode" in nodes_package.__all__
|
|
assert "UpscaleLatentFromImage" in nodes_package.__all__
|
|
|
|
|
|
def test_registration_import_does_not_require_torchlanc() -> None:
|
|
"""Importing registration does not eagerly import TorchLanc."""
|
|
|
|
sys.modules.pop("torchlanc", None)
|
|
importlib.import_module("SimpleSyrup")
|
|
|
|
imported_module: ModuleType | None = sys.modules.get("torchlanc")
|
|
assert imported_module is None
|
|
|
|
|
|
def test_v3_entrypoint_registers_tile_and_prompt_control_batch_nodes(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""Comfy v3 entrypoint exposes native v3 nodes without Prompt Control imports."""
|
|
|
|
sys.modules.pop("prompt_control.nodes_lazy", None)
|
|
package = importlib.import_module("SimpleSyrup")
|
|
nodes_v3 = importlib.import_module("SimpleSyrup.simple_syrup.nodes_v3")
|
|
monkeypatch.setattr(nodes_v3, "prompt_control_is_available", lambda: True)
|
|
|
|
extension = asyncio.run(package.comfy_entrypoint())
|
|
nodes = asyncio.run(extension.get_node_list())
|
|
|
|
assert [node.__name__ for node in nodes] == [
|
|
"WD14TaggerLoaderV3",
|
|
"TileAndTagSEGSV3",
|
|
"SimpleLoadCheckpointV3",
|
|
"ScaleFactorV3",
|
|
"EncodePromptBatchWithPromptControl",
|
|
]
|
|
assert "prompt_control.nodes_lazy" not in sys.modules
|
|
|
|
|
|
def test_v3_entrypoint_keeps_tile_node_when_prompt_control_unavailable(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""Comfy v3 entrypoint omits only Prompt Control nodes when unavailable."""
|
|
|
|
sys.modules.pop("prompt_control.nodes_lazy", None)
|
|
package = importlib.import_module("SimpleSyrup")
|
|
nodes_v3 = importlib.import_module("SimpleSyrup.simple_syrup.nodes_v3")
|
|
monkeypatch.setattr(nodes_v3, "prompt_control_is_available", lambda: False)
|
|
|
|
extension = asyncio.run(package.comfy_entrypoint())
|
|
nodes = asyncio.run(extension.get_node_list())
|
|
|
|
assert [node.__name__ for node in nodes] == [
|
|
"WD14TaggerLoaderV3",
|
|
"TileAndTagSEGSV3",
|
|
"SimpleLoadCheckpointV3",
|
|
"ScaleFactorV3",
|
|
]
|
|
assert "prompt_control.nodes_lazy" not in sys.modules
|