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

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

@@ -0,0 +1,143 @@
+from typing import Literal, get_args
+
+from ...base import BaseNode
+from ...validation import validate_choice, validate_range
+
+ConditioningSetProperties_Set_Cond_Areas = Literal["default", "mask bounds"]
+CONDITIONINGSETPROPERTIES_SET_COND_AREAS = frozenset(
+    get_args(ConditioningSetProperties_Set_Cond_Areas)
+)
+
+
+class ConditioningSetProperties(BaseNode):
+    __slots__ = ("cond_NEW", "set_cond_area", "strength", "mask", "hooks", "timesteps")
+    CATEGORY = "advanced/hooks/cond single"
+    OUTPUTS = {"CONDITIONING": 0}
+    RETURN_TYPES = ("CONDITIONING",)
+    INPUT_SOCKET_TYPES = {
+        "cond_NEW": "CONDITIONING",
+        "strength": "FLOAT",
+        "set_cond_area": "V1 COMBO",
+        "mask": "MASK",
+        "hooks": "HOOKS",
+        "timesteps": "TIMESTEPS_RANGE",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        cond_NEW: tuple[str, int],
+        set_cond_area: ConditioningSetProperties_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.cond_NEW = cond_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,
+            CONDITIONINGSETPROPERTIES_SET_COND_AREAS,
+        )
+        validate_range("strength", self.strength, 0.0, 10.0)
+
+
+ConditioningSetPropertiesAndCombine_Set_Cond_Areas = Literal["default", "mask bounds"]
+CONDITIONINGSETPROPERTIESANDCOMBINE_SET_COND_AREAS = frozenset(
+    get_args(ConditioningSetPropertiesAndCombine_Set_Cond_Areas)
+)
+
+
+class ConditioningSetPropertiesAndCombine(BaseNode):
+    __slots__ = (
+        "cond",
+        "cond_NEW",
+        "set_cond_area",
+        "strength",
+        "mask",
+        "hooks",
+        "timesteps",
+    )
+    CATEGORY = "advanced/hooks/cond single"
+    OUTPUTS = {"CONDITIONING": 0}
+    RETURN_TYPES = ("CONDITIONING",)
+    INPUT_SOCKET_TYPES = {
+        "cond": "CONDITIONING",
+        "cond_NEW": "CONDITIONING",
+        "strength": "FLOAT",
+        "set_cond_area": "V1 COMBO",
+        "mask": "MASK",
+        "hooks": "HOOKS",
+        "timesteps": "TIMESTEPS_RANGE",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        cond: tuple[str, int],
+        cond_NEW: tuple[str, int],
+        set_cond_area: (
+            ConditioningSetPropertiesAndCombine_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.cond = cond
+        self.cond_NEW = cond_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,
+            CONDITIONINGSETPROPERTIESANDCOMBINE_SET_COND_AREAS,
+        )
+        validate_range("strength", self.strength, 0.0, 10.0)
+
+
+class ConditioningSetDefaultCombine(BaseNode):
+    __slots__ = ("cond", "cond_DEFAULT", "hooks")
+    CATEGORY = "advanced/hooks/cond single"
+    OUTPUTS = {"CONDITIONING": 0}
+    RETURN_TYPES = ("CONDITIONING",)
+    INPUT_SOCKET_TYPES = {
+        "cond": "CONDITIONING",
+        "cond_DEFAULT": "CONDITIONING",
+        "hooks": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        cond: tuple[str, int],
+        cond_DEFAULT: tuple[str, int],
+        hooks: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.cond = cond
+        self.cond_DEFAULT = cond_DEFAULT
+        if hooks is not None:
+            self.hooks = hooks

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

@@ -0,0 +1,130 @@
+from ...base import BaseNode
+from ...validation import validate_not_empty, validate_range
+
+
+class CreateHookLora(BaseNode):
+    __slots__ = ("lora_name", "strength_model", "strength_clip", "prev_hooks")
+    CATEGORY = "advanced/hooks/create"
+    OUTPUTS = {"HOOKS": 0}
+    RETURN_TYPES = ("HOOKS",)
+    INPUT_SOCKET_TYPES = {
+        "lora_name": "V1 COMBO",
+        "strength_model": "FLOAT",
+        "strength_clip": "FLOAT",
+        "prev_hooks": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        lora_name: str | tuple[str, int],
+        strength_model: float | tuple[str, int] = 1.0,
+        strength_clip: float | tuple[str, int] = 1.0,
+        prev_hooks: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.lora_name = lora_name
+        self.strength_model = strength_model
+        self.strength_clip = strength_clip
+        if prev_hooks is not None:
+            self.prev_hooks = prev_hooks
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_not_empty("lora_name", self.lora_name)
+        validate_range("strength_model", self.strength_model, -20.0, 20.0)
+        validate_range("strength_clip", self.strength_clip, -20.0, 20.0)
+
+
+class CreateHookLoraModelOnly(BaseNode):
+    __slots__ = ("lora_name", "strength_model", "prev_hooks")
+    CATEGORY = "advanced/hooks/create"
+    OUTPUTS = {"HOOKS": 0}
+    RETURN_TYPES = ("HOOKS",)
+    INPUT_SOCKET_TYPES = {
+        "lora_name": "V1 COMBO",
+        "strength_model": "FLOAT",
+        "prev_hooks": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        lora_name: str | tuple[str, int],
+        strength_model: float | tuple[str, int] = 1.0,
+        prev_hooks: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.lora_name = lora_name
+        self.strength_model = strength_model
+        if prev_hooks is not None:
+            self.prev_hooks = prev_hooks
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_not_empty("lora_name", self.lora_name)
+        validate_range("strength_model", self.strength_model, -20.0, 20.0)
+
+
+class CreateHookModelAsLora(BaseNode):
+    __slots__ = ("ckpt_name", "strength_model", "strength_clip", "prev_hooks")
+    CATEGORY = "advanced/hooks/create"
+    OUTPUTS = {"HOOKS": 0}
+    RETURN_TYPES = ("HOOKS",)
+    INPUT_SOCKET_TYPES = {
+        "ckpt_name": "V1 COMBO",
+        "strength_model": "FLOAT",
+        "strength_clip": "FLOAT",
+        "prev_hooks": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        ckpt_name: str | tuple[str, int],
+        strength_model: float | tuple[str, int] = 1.0,
+        strength_clip: float | tuple[str, int] = 1.0,
+        prev_hooks: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.ckpt_name = ckpt_name
+        self.strength_model = strength_model
+        self.strength_clip = strength_clip
+        if prev_hooks is not None:
+            self.prev_hooks = prev_hooks
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_not_empty("ckpt_name", self.ckpt_name)
+        validate_range("strength_model", self.strength_model, -20.0, 20.0)
+        validate_range("strength_clip", self.strength_clip, -20.0, 20.0)
+
+
+class CreateHookModelAsLoraModelOnly(BaseNode):
+    __slots__ = ("ckpt_name", "strength_model", "prev_hooks")
+    CATEGORY = "advanced/hooks/create"
+    OUTPUTS = {"HOOKS": 0}
+    RETURN_TYPES = ("HOOKS",)
+    INPUT_SOCKET_TYPES = {
+        "ckpt_name": "V1 COMBO",
+        "strength_model": "FLOAT",
+        "prev_hooks": "HOOKS",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        ckpt_name: str | tuple[str, int],
+        strength_model: float | tuple[str, int] = 1.0,
+        prev_hooks: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.ckpt_name = ckpt_name
+        self.strength_model = strength_model
+        if prev_hooks is not None:
+            self.prev_hooks = prev_hooks
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_not_empty("ckpt_name", self.ckpt_name)
+        validate_range("strength_model", self.strength_model, -20.0, 20.0)

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

@@ -0,0 +1,167 @@
+from typing import Literal, get_args
+
+from ...base import BaseNode
+from ...validation import validate_bool, validate_choice, validate_range
+
+
+class SetHookKeyframes(BaseNode):
+    __slots__ = ("hooks", "hook_kf")
+    CATEGORY = "advanced/hooks/scheduling"
+    OUTPUTS = {"HOOKS": 0}
+    RETURN_TYPES = ("HOOKS",)
+    INPUT_SOCKET_TYPES = {"hooks": "HOOKS", "hook_kf": "HOOK_KEYFRAMES"}
+
+    def __init__(
+        self,
+        node_id: str,
+        hooks: tuple[str, int],
+        hook_kf: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.hooks = hooks
+        if hook_kf is not None:
+            self.hook_kf = hook_kf
+
+
+class CreateHookKeyframe(BaseNode):
+    __slots__ = ("strength_mult", "start_percent", "prev_hook_kf")
+    CATEGORY = "advanced/hooks/scheduling"
+    OUTPUTS = {"HOOK_KF": 0}
+    RETURN_TYPES = ("HOOK_KEYFRAMES",)
+    INPUT_SOCKET_TYPES = {
+        "strength_mult": "FLOAT",
+        "start_percent": "FLOAT",
+        "prev_hook_kf": "HOOK_KEYFRAMES",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        strength_mult: float | tuple[str, int] = 1.0,
+        start_percent: float | tuple[str, int] = 0.0,
+        prev_hook_kf: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.strength_mult = strength_mult
+        self.start_percent = start_percent
+        if prev_hook_kf is not None:
+            self.prev_hook_kf = prev_hook_kf
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("strength_mult", self.strength_mult, -20.0, 20.0)
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+
+
+CreateHookKeyframesInterpolated_Interpolations = Literal[
+    "linear", "ease_in", "ease_out", "ease_in_out"
+]
+CREATEHOOKKEYFRAMESINTERPOLATED_INTERPOLATIONS = frozenset(
+    get_args(CreateHookKeyframesInterpolated_Interpolations)
+)
+
+
+class CreateHookKeyframesInterpolated(BaseNode):
+    __slots__ = (
+        "interpolation",
+        "strength_start",
+        "strength_end",
+        "start_percent",
+        "end_percent",
+        "keyframes_count",
+        "print_keyframes",
+        "prev_hook_kf",
+    )
+    CATEGORY = "advanced/hooks/scheduling"
+    OUTPUTS = {"HOOK_KF": 0}
+    RETURN_TYPES = ("HOOK_KEYFRAMES",)
+    INPUT_SOCKET_TYPES = {
+        "strength_start": "FLOAT",
+        "strength_end": "FLOAT",
+        "interpolation": "V1 COMBO",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+        "keyframes_count": "INT",
+        "print_keyframes": "BOOLEAN",
+        "prev_hook_kf": "HOOK_KEYFRAMES",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        interpolation: CreateHookKeyframesInterpolated_Interpolations | tuple[str, int],
+        strength_start: float | tuple[str, int] = 1.0,
+        strength_end: float | tuple[str, int] = 1.0,
+        start_percent: float | tuple[str, int] = 0.0,
+        end_percent: float | tuple[str, int] = 1.0,
+        keyframes_count: int | tuple[str, int] = 5,
+        print_keyframes: bool | tuple[str, int] = False,
+        prev_hook_kf: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.interpolation = interpolation
+        self.strength_start = strength_start
+        self.strength_end = strength_end
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.keyframes_count = keyframes_count
+        self.print_keyframes = print_keyframes
+        if prev_hook_kf is not None:
+            self.prev_hook_kf = prev_hook_kf
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_choice(
+            "interpolation",
+            self.interpolation,
+            CREATEHOOKKEYFRAMESINTERPOLATED_INTERPOLATIONS,
+        )
+        validate_range("strength_start", self.strength_start, 0.0, 10.0)
+        validate_range("strength_end", self.strength_end, 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("keyframes_count", self.keyframes_count, 2, 100)
+        validate_bool("print_keyframes", self.print_keyframes)
+
+
+class CreateHookKeyframesFromFloats(BaseNode):
+    __slots__ = (
+        "floats_strength",
+        "start_percent",
+        "end_percent",
+        "print_keyframes",
+        "prev_hook_kf",
+    )
+    CATEGORY = "advanced/hooks/scheduling"
+    OUTPUTS = {"HOOK_KF": 0}
+    RETURN_TYPES = ("HOOK_KEYFRAMES",)
+    INPUT_SOCKET_TYPES = {
+        "floats_strength": "FLOATS",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+        "print_keyframes": "BOOLEAN",
+        "prev_hook_kf": "HOOK_KEYFRAMES",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        floats_strength: tuple[str, int],
+        start_percent: float | tuple[str, int] = 0.0,
+        end_percent: float | tuple[str, int] = 1.0,
+        print_keyframes: bool | tuple[str, int] = False,
+        prev_hook_kf: tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.floats_strength = floats_strength
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.print_keyframes = print_keyframes
+        if prev_hook_kf is not None:
+            self.prev_hook_kf = prev_hook_kf
+        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)
+        validate_bool("print_keyframes", self.print_keyframes)

comfy_ui_api_workflow/_impl/nodes/advanced/multigpu.py

@@ -0,0 +1,78 @@
+from ..base import BaseNode
+from ..validation import validate_not_empty, validate_range
+
+
+class MultiGPU_WorkUnits(BaseNode):
+    __slots__ = ("model", "max_gpus")
+    CATEGORY = "advanced/multigpu"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {"model": "MODEL", "max_gpus": "INT"}
+
+    def __init__(
+        self, node_id: str, model: tuple[str, int], max_gpus: int | tuple[str, int] = 2
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.max_gpus = max_gpus
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("max_gpus", self.max_gpus, 1)
+
+
+class SelectModelDevice(BaseNode):
+    __slots__ = ("model", "device")
+    CATEGORY = "advanced/multigpu"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {"model": "MODEL", "device": "COMBO"}
+
+    def __init__(
+        self, node_id: str, model: tuple[str, int], device: str | tuple[str, int]
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.device = device
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_not_empty("device", self.device)
+
+
+class SelectCLIPDevice(BaseNode):
+    __slots__ = ("clip", "device")
+    CATEGORY = "advanced/multigpu"
+    OUTPUTS = {"CLIP": 0}
+    RETURN_TYPES = ("CLIP",)
+    INPUT_SOCKET_TYPES = {"clip": "CLIP", "device": "COMBO"}
+
+    def __init__(
+        self, node_id: str, clip: tuple[str, int], device: str | tuple[str, int]
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.clip = clip
+        self.device = device
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_not_empty("device", self.device)
+
+
+class SelectVAEDevice(BaseNode):
+    __slots__ = ("vae", "device")
+    CATEGORY = "advanced/multigpu"
+    OUTPUTS = {"VAE": 0}
+    RETURN_TYPES = ("VAE",)
+    INPUT_SOCKET_TYPES = {"vae": "VAE", "device": "COMBO"}
+
+    def __init__(
+        self, node_id: str, vae: tuple[str, int], device: str | tuple[str, int]
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.vae = vae
+        self.device = device
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_not_empty("device", self.device)