comfy-ui-api-workflow 0.0.1__py3-none-any.whl

comfy_ui_api_workflow/_impl/nodes/advanced/guidance.py

@@ -0,0 +1,281 @@
+from ..base import BaseNode
+from ..validation import validate_bool, validate_range
+
+
+class SkipLayerGuidanceSD3(BaseNode):
+    __slots__ = ("model", "layers", "scale", "start_percent", "end_percent")
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {
+        "model": "MODEL",
+        "layers": "STRING",
+        "scale": "FLOAT",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        layers: str | tuple[str, int] = "7, 8, 9",
+        scale: float | tuple[str, int] = 3.0,
+        start_percent: float | tuple[str, int] = 0.01,
+        end_percent: float | tuple[str, int] = 0.15,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.layers = layers
+        self.scale = scale
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("scale", self.scale, 0.0, 10.0)
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+        validate_range("end_percent", self.end_percent, 0.0, 1.0)
+
+
+class SkipLayerGuidanceDiT(BaseNode):
+    __slots__ = (
+        "model",
+        "double_layers",
+        "single_layers",
+        "scale",
+        "start_percent",
+        "end_percent",
+        "rescaling_scale",
+    )
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {
+        "model": "MODEL",
+        "double_layers": "STRING",
+        "single_layers": "STRING",
+        "scale": "FLOAT",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+        "rescaling_scale": "FLOAT",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        double_layers: str | tuple[str, int] = "7, 8, 9",
+        single_layers: str | tuple[str, int] = "7, 8, 9",
+        scale: float | tuple[str, int] = 3.0,
+        start_percent: float | tuple[str, int] = 0.01,
+        end_percent: float | tuple[str, int] = 0.15,
+        rescaling_scale: float | tuple[str, int] = 0.0,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.double_layers = double_layers
+        self.single_layers = single_layers
+        self.scale = scale
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.rescaling_scale = rescaling_scale
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("scale", self.scale, 0.0, 10.0)
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+        validate_range("end_percent", self.end_percent, 0.0, 1.0)
+        validate_range("rescaling_scale", self.rescaling_scale, 0.0, 10.0)
+
+
+class SkipLayerGuidanceDiTSimple(BaseNode):
+    __slots__ = (
+        "model",
+        "double_layers",
+        "single_layers",
+        "start_percent",
+        "end_percent",
+    )
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {
+        "model": "MODEL",
+        "double_layers": "STRING",
+        "single_layers": "STRING",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        double_layers: str | tuple[str, int] = "7, 8, 9",
+        single_layers: str | tuple[str, int] = "7, 8, 9",
+        start_percent: float | tuple[str, int] = 0.0,
+        end_percent: float | tuple[str, int] = 1.0,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.double_layers = double_layers
+        self.single_layers = single_layers
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+        validate_range("end_percent", self.end_percent, 0.0, 1.0)
+
+
+class LTXVModalityGuidance(BaseNode):
+    __slots__ = ("model", "modality_scale", "start_percent", "end_percent")
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {
+        "model": "MODEL",
+        "modality_scale": "FLOAT",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        modality_scale: float | tuple[str, int] = 3.0,
+        start_percent: float | tuple[str, int] = 0.0,
+        end_percent: float | tuple[str, int] = 1.0,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.modality_scale = modality_scale
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("modality_scale", self.modality_scale, 1.0, 100.0)
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+        validate_range("end_percent", self.end_percent, 0.0, 1.0)
+
+
+class LTXVSpatioTemporalGuidance(BaseNode):
+    __slots__ = ("model", "scale", "blocks", "start_percent", "end_percent")
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {
+        "model": "MODEL",
+        "scale": "FLOAT",
+        "blocks": "STRING",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        scale: float | tuple[str, int] = 1.0,
+        blocks: str | tuple[str, int] = "29",
+        start_percent: float | tuple[str, int] = 0.0,
+        end_percent: float | tuple[str, int] = 1.0,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.scale = scale
+        self.blocks = blocks
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("scale", self.scale, 0.0, 100.0)
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+        validate_range("end_percent", self.end_percent, 0.0, 1.0)
+
+
+class CFGZeroStar(BaseNode):
+    __slots__ = ("model",)
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"patched_model": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {"model": "MODEL"}
+
+    def __init__(self, node_id: str, model: tuple[str, int]) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+
+
+class CFGNorm(BaseNode):
+    __slots__ = ("model", "strength", "pre_cfg")
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"patched_model": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {"model": "MODEL", "strength": "FLOAT", "pre_cfg": "BOOLEAN"}
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        strength: float | tuple[str, int] = 1.0,
+        pre_cfg: bool | tuple[str, int] = False,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.strength = strength
+        self.pre_cfg = pre_cfg
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("strength", self.strength, 0.0, 100.0)
+        validate_bool("pre_cfg", self.pre_cfg)
+
+
+class TCFG(BaseNode):
+    __slots__ = ("model",)
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"patched_model": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {"model": "MODEL"}
+
+    def __init__(self, node_id: str, model: tuple[str, int]) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+
+
+class NAGuidance(BaseNode):
+    __slots__ = ("model", "nag_scale", "nag_alpha", "nag_tau")
+    CATEGORY = "advanced/guidance"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {
+        "model": "MODEL",
+        "nag_scale": "FLOAT",
+        "nag_alpha": "FLOAT",
+        "nag_tau": "FLOAT",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        nag_scale: float | tuple[str, int] = 5.0,
+        nag_alpha: float | tuple[str, int] = 0.5,
+        nag_tau: float | tuple[str, int] = 1.5,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.nag_scale = nag_scale
+        self.nag_alpha = nag_alpha
+        self.nag_tau = nag_tau
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("nag_scale", self.nag_scale, 0.0, 50.0)
+        validate_range("nag_alpha", self.nag_alpha, 0.0, 1.0)
+        validate_range("nag_tau", self.nag_tau, 1.0, 10.0)

comfy_ui_api_workflow/_impl/nodes/advanced/hooks/__init__.py

@@ -0,0 +1,29 @@
+from ...base import BaseNode
+from ...validation import validate_range
+from ....lazy import submodules_of
+
+
+class ConditioningTimestepsRange(BaseNode):
+    __slots__ = ("start_percent", "end_percent")
+    CATEGORY = "advanced/hooks"
+    OUTPUTS = {"TIMESTEPS_RANGE": 0, "BEFORE_RANGE": 1, "AFTER_RANGE": 2}
+    RETURN_TYPES = ("TIMESTEPS_RANGE", "TIMESTEPS_RANGE", "TIMESTEPS_RANGE")
+    INPUT_SOCKET_TYPES = {"start_percent": "FLOAT", "end_percent": "FLOAT"}
+
+    def __init__(
+        self,
+        node_id: str,
+        start_percent: float | tuple[str, int] = 0.0,
+        end_percent: float | tuple[str, int] = 1.0,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+        validate_range("end_percent", self.end_percent, 0.0, 1.0)
+
+
+__getattr__ = submodules_of(__name__)

comfy_ui_api_workflow/_impl/nodes/advanced/hooks/clip.py

@@ -0,0 +1,35 @@
+from ...base import BaseNode
+from ...validation import validate_bool
+
+
+class SetClipHooks(BaseNode):
+    __slots__ = ("clip", "apply_to_conds", "schedule_clip", "hooks")
+    CATEGORY = "advanced/hooks/clip"
+    OUTPUTS = {"CLIP": 0}
+    RETURN_TYPES = ("CLIP",)
+    INPUT_SOCKET_TYPES = {
+        "clip": "CLIP",
+        "apply_to_conds": "BOOLEAN",
+        "schedule_clip": "BOOLEAN",
+        "hooks": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        clip: tuple[str, int],
+        apply_to_conds: bool | tuple[str, int] = True,
+        schedule_clip: bool | tuple[str, int] = False,
+        hooks: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.clip = clip
+        self.apply_to_conds = apply_to_conds
+        self.schedule_clip = schedule_clip
+        if hooks is not None:
+            self.hooks = hooks
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_bool("apply_to_conds", self.apply_to_conds)
+        validate_bool("schedule_clip", self.schedule_clip)

comfy_ui_api_workflow/_impl/nodes/advanced/hooks/combine.py

@@ -0,0 +1,108 @@
+from ...base import BaseNode
+
+
+class CombineHooks2(BaseNode):
+    __slots__ = ("hooks_A", "hooks_B")
+    CATEGORY = "advanced/hooks/combine"
+    OUTPUTS = {"HOOKS": 0}
+    RETURN_TYPES = ("HOOKS",)
+    INPUT_SOCKET_TYPES = {"hooks_A": "HOOKS", "hooks_B": "HOOKS"}
+
+    def __init__(
+        self,
+        node_id: str,
+        hooks_A: tuple[str, int] | None = None,
+        hooks_B: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        if hooks_A is not None:
+            self.hooks_A = hooks_A
+        if hooks_B is not None:
+            self.hooks_B = hooks_B
+
+
+class CombineHooks4(BaseNode):
+    __slots__ = ("hooks_A", "hooks_B", "hooks_C", "hooks_D")
+    CATEGORY = "advanced/hooks/combine"
+    OUTPUTS = {"HOOKS": 0}
+    RETURN_TYPES = ("HOOKS",)
+    INPUT_SOCKET_TYPES = {
+        "hooks_A": "HOOKS",
+        "hooks_B": "HOOKS",
+        "hooks_C": "HOOKS",
+        "hooks_D": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        hooks_A: tuple[str, int] | None = None,
+        hooks_B: tuple[str, int] | None = None,
+        hooks_C: tuple[str, int] | None = None,
+        hooks_D: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        if hooks_A is not None:
+            self.hooks_A = hooks_A
+        if hooks_B is not None:
+            self.hooks_B = hooks_B
+        if hooks_C is not None:
+            self.hooks_C = hooks_C
+        if hooks_D is not None:
+            self.hooks_D = hooks_D
+
+
+class CombineHooks8(BaseNode):
+    __slots__ = (
+        "hooks_A",
+        "hooks_B",
+        "hooks_C",
+        "hooks_D",
+        "hooks_E",
+        "hooks_F",
+        "hooks_G",
+        "hooks_H",
+    )
+    CATEGORY = "advanced/hooks/combine"
+    OUTPUTS = {"HOOKS": 0}
+    RETURN_TYPES = ("HOOKS",)
+    INPUT_SOCKET_TYPES = {
+        "hooks_A": "HOOKS",
+        "hooks_B": "HOOKS",
+        "hooks_C": "HOOKS",
+        "hooks_D": "HOOKS",
+        "hooks_E": "HOOKS",
+        "hooks_F": "HOOKS",
+        "hooks_G": "HOOKS",
+        "hooks_H": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        hooks_A: tuple[str, int] | None = None,
+        hooks_B: tuple[str, int] | None = None,
+        hooks_C: tuple[str, int] | None = None,
+        hooks_D: tuple[str, int] | None = None,
+        hooks_E: tuple[str, int] | None = None,
+        hooks_F: tuple[str, int] | None = None,
+        hooks_G: tuple[str, int] | None = None,
+        hooks_H: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        if hooks_A is not None:
+            self.hooks_A = hooks_A
+        if hooks_B is not None:
+            self.hooks_B = hooks_B
+        if hooks_C is not None:
+            self.hooks_C = hooks_C
+        if hooks_D is not None:
+            self.hooks_D = hooks_D
+        if hooks_E is not None:
+            self.hooks_E = hooks_E
+        if hooks_F is not None:
+            self.hooks_F = hooks_F
+        if hooks_G is not None:
+            self.hooks_G = hooks_G
+        if hooks_H is not None:
+            self.hooks_H = hooks_H

comfy_ui_api_workflow/_impl/nodes/advanced/hooks/cond_pair.py

@@ -0,0 +1,203 @@
+from typing import Literal, get_args
+
+from ...base import BaseNode
+from ...validation import validate_choice, validate_range
+
+PairConditioningSetProperties_Set_Cond_Areas = Literal["default", "mask bounds"]
+PAIRCONDITIONINGSETPROPERTIES_SET_COND_AREAS = frozenset(
+    get_args(PairConditioningSetProperties_Set_Cond_Areas)
+)
+
+
+class PairConditioningSetProperties(BaseNode):
+    __slots__ = (
+        "positive_NEW",
+        "negative_NEW",
+        "set_cond_area",
+        "strength",
+        "mask",
+        "hooks",
+        "timesteps",
+    )
+    CATEGORY = "advanced/hooks/cond pair"
+    OUTPUTS = {"positive": 0, "negative": 1}
+    RETURN_TYPES = ("CONDITIONING", "CONDITIONING")
+    INPUT_SOCKET_TYPES = {
+        "positive_NEW": "CONDITIONING",
+        "negative_NEW": "CONDITIONING",
+        "strength": "FLOAT",
+        "set_cond_area": "V1 COMBO",
+        "mask": "MASK",
+        "hooks": "HOOKS",
+        "timesteps": "TIMESTEPS_RANGE",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        positive_NEW: tuple[str, int],
+        negative_NEW: tuple[str, int],
+        set_cond_area: PairConditioningSetProperties_Set_Cond_Areas | tuple[str, int],
+        strength: float | tuple[str, int] = 1.0,
+        mask: tuple[str, int] | None = None,
+        hooks: tuple[str, int] | None = None,
+        timesteps: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.positive_NEW = positive_NEW
+        self.negative_NEW = negative_NEW
+        self.set_cond_area = set_cond_area
+        self.strength = strength
+        if mask is not None:
+            self.mask = mask
+        if hooks is not None:
+            self.hooks = hooks
+        if timesteps is not None:
+            self.timesteps = timesteps
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_choice(
+            "set_cond_area",
+            self.set_cond_area,
+            PAIRCONDITIONINGSETPROPERTIES_SET_COND_AREAS,
+        )
+        validate_range("strength", self.strength, 0.0, 10.0)
+
+
+PairConditioningSetPropertiesAndCombine_Set_Cond_Areas = Literal[
+    "default", "mask bounds"
+]
+PAIRCONDITIONINGSETPROPERTIESANDCOMBINE_SET_COND_AREAS = frozenset(
+    get_args(PairConditioningSetPropertiesAndCombine_Set_Cond_Areas)
+)
+
+
+class PairConditioningSetPropertiesAndCombine(BaseNode):
+    __slots__ = (
+        "positive",
+        "negative",
+        "positive_NEW",
+        "negative_NEW",
+        "set_cond_area",
+        "strength",
+        "mask",
+        "hooks",
+        "timesteps",
+    )
+    CATEGORY = "advanced/hooks/cond pair"
+    OUTPUTS = {"positive": 0, "negative": 1}
+    RETURN_TYPES = ("CONDITIONING", "CONDITIONING")
+    INPUT_SOCKET_TYPES = {
+        "positive": "CONDITIONING",
+        "negative": "CONDITIONING",
+        "positive_NEW": "CONDITIONING",
+        "negative_NEW": "CONDITIONING",
+        "strength": "FLOAT",
+        "set_cond_area": "V1 COMBO",
+        "mask": "MASK",
+        "hooks": "HOOKS",
+        "timesteps": "TIMESTEPS_RANGE",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        positive: tuple[str, int],
+        negative: tuple[str, int],
+        positive_NEW: tuple[str, int],
+        negative_NEW: tuple[str, int],
+        set_cond_area: (
+            PairConditioningSetPropertiesAndCombine_Set_Cond_Areas | tuple[str, int]
+        ),
+        strength: float | tuple[str, int] = 1.0,
+        mask: tuple[str, int] | None = None,
+        hooks: tuple[str, int] | None = None,
+        timesteps: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.positive = positive
+        self.negative = negative
+        self.positive_NEW = positive_NEW
+        self.negative_NEW = negative_NEW
+        self.set_cond_area = set_cond_area
+        self.strength = strength
+        if mask is not None:
+            self.mask = mask
+        if hooks is not None:
+            self.hooks = hooks
+        if timesteps is not None:
+            self.timesteps = timesteps
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_choice(
+            "set_cond_area",
+            self.set_cond_area,
+            PAIRCONDITIONINGSETPROPERTIESANDCOMBINE_SET_COND_AREAS,
+        )
+        validate_range("strength", self.strength, 0.0, 10.0)
+
+
+class PairConditioningSetDefaultCombine(BaseNode):
+    __slots__ = (
+        "positive",
+        "negative",
+        "positive_DEFAULT",
+        "negative_DEFAULT",
+        "hooks",
+    )
+    CATEGORY = "advanced/hooks/cond pair"
+    OUTPUTS = {"positive": 0, "negative": 1}
+    RETURN_TYPES = ("CONDITIONING", "CONDITIONING")
+    INPUT_SOCKET_TYPES = {
+        "positive": "CONDITIONING",
+        "negative": "CONDITIONING",
+        "positive_DEFAULT": "CONDITIONING",
+        "negative_DEFAULT": "CONDITIONING",
+        "hooks": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        positive: tuple[str, int],
+        negative: tuple[str, int],
+        positive_DEFAULT: tuple[str, int],
+        negative_DEFAULT: tuple[str, int],
+        hooks: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.positive = positive
+        self.negative = negative
+        self.positive_DEFAULT = positive_DEFAULT
+        self.negative_DEFAULT = negative_DEFAULT
+        if hooks is not None:
+            self.hooks = hooks
+
+
+class PairConditioningCombine(BaseNode):
+    __slots__ = ("positive_A", "negative_A", "positive_B", "negative_B")
+    CATEGORY = "advanced/hooks/cond pair"
+    OUTPUTS = {"positive": 0, "negative": 1}
+    RETURN_TYPES = ("CONDITIONING", "CONDITIONING")
+    INPUT_SOCKET_TYPES = {
+        "positive_A": "CONDITIONING",
+        "negative_A": "CONDITIONING",
+        "positive_B": "CONDITIONING",
+        "negative_B": "CONDITIONING",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        positive_A: tuple[str, int],
+        negative_A: tuple[str, int],
+        positive_B: tuple[str, int],
+        negative_B: tuple[str, int],
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.positive_A = positive_A
+        self.negative_A = negative_A
+        self.positive_B = positive_B
+        self.negative_B = negative_B