The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
convert nodes_kling.py to V3 schema (#10236)
Alexander Piskun8c1991042795
diff --git a/comfy_api_nodes/nodes_kling.py b/comfy_api_nodes/nodes_kling.pyindex 44fccc0c7..457b43451 100644--- a/comfy_api_nodes/nodes_kling.py+++ b/comfy_api_nodes/nodes_kling.py@@ -10,6 +10,8 @@ from collections.abc import Callableimport mathimport logging+from typing_extensions import override+import torchfrom comfy_api_nodes.apis import (@@ -63,8 +65,8 @@ from comfy_api_nodes.apinode_utils import (upload_video_to_comfyapi,upload_audio_to_comfyapi,download_url_to_image_tensor,+ validate_string,)-from comfy_api_nodes.mapper_utils import model_field_to_node_inputfrom comfy_api_nodes.util.validation_utils import (validate_image_dimensions,validate_image_aspect_ratio,@@ -73,8 +75,7 @@ from comfy_api_nodes.util.validation_utils import ()from comfy_api.input.basic_types import AudioInputfrom comfy_api.input.video_types import VideoInput-from comfy_api.input_impl import VideoFromFile-from comfy.comfy_types.node_typing import IO, InputTypeOptions, ComfyNodeABC+from comfy_api.latest import ComfyExtension, io as comfy_ioKLING_API_VERSION = "v1"PATH_TEXT_TO_VIDEO = f"/proxy/kling/{KLING_API_VERSION}/videos/text2video"@@ -103,10 +104,113 @@ AVERAGE_DURATION_VIDEO_EXTEND = 320R = TypeVar("R")-class KlingApiError(Exception):- """Base exception for Kling API errors."""+MODE_TEXT2VIDEO = {+ "standard mode / 5s duration / kling-v1": ("std", "5", "kling-v1"),+ "standard mode / 10s duration / kling-v1": ("std", "10", "kling-v1"),+ "pro mode / 5s duration / kling-v1": ("pro", "5", "kling-v1"),+ "pro mode / 10s duration / kling-v1": ("pro", "10", "kling-v1"),+ "standard mode / 5s duration / kling-v1-6": ("std", "5", "kling-v1-6"),+ "standard mode / 10s duration / kling-v1-6": ("std", "10", "kling-v1-6"),+ "pro mode / 5s duration / kling-v2-master": ("pro", "5", "kling-v2-master"),+ "pro mode / 10s duration / kling-v2-master": ("pro", "10", "kling-v2-master"),+ "standard mode / 5s duration / kling-v2-master": ("std", "5", "kling-v2-master"),+ "standard mode / 10s duration / kling-v2-master": ("std", "10", "kling-v2-master"),+ "pro mode / 5s duration / kling-v2-1-master": ("pro", "5", "kling-v2-1-master"),+ "pro mode / 10s duration / kling-v2-1-master": ("pro", "10", "kling-v2-1-master"),+ "pro mode / 5s duration / kling-v2-5-turbo": ("pro", "5", "kling-v2-5-turbo"),+ "pro mode / 10s duration / kling-v2-5-turbo": ("pro", "10", "kling-v2-5-turbo"),+}+"""+Mapping of mode strings to their corresponding (mode, duration, model_name) tuples.+Only includes config combos that support the `image_tail` request field.++See: [Kling API Docs Capability Map](https://app.klingai.com/global/dev/document-api/apiReference/model/skillsMap)+"""+++MODE_START_END_FRAME = {+ "standard mode / 5s duration / kling-v1": ("std", "5", "kling-v1"),+ "pro mode / 5s duration / kling-v1": ("pro", "5", "kling-v1"),+ "pro mode / 5s duration / kling-v1-5": ("pro", "5", "kling-v1-5"),+ "pro mode / 10s duration / kling-v1-5": ("pro", "10", "kling-v1-5"),+ "pro mode / 5s duration / kling-v1-6": ("pro", "5", "kling-v1-6"),+ "pro mode / 10s duration / kling-v1-6": ("pro", "10", "kling-v1-6"),+ "pro mode / 5s duration / kling-v2-1": ("pro", "5", "kling-v2-1"),+ "pro mode / 10s duration / kling-v2-1": ("pro", "10", "kling-v2-1"),+}+"""+Returns a mapping of mode strings to their corresponding (mode, duration, model_name) tuples.+Only includes config combos that support the `image_tail` request field.++See: [Kling API Docs Capability Map](https://app.klingai.com/global/dev/document-api/apiReference/model/skillsMap)+"""+- pass+VOICES_CONFIG = {+ # English voices+ "Melody": ("girlfriend_4_speech02", "en"),+ "Sunny": ("genshin_vindi2", "en"),+ "Sage": ("zhinen_xuesheng", "en"),+ "Ace": ("AOT", "en"),+ "Blossom": ("ai_shatang", "en"),+ "Peppy": ("genshin_klee2", "en"),+ "Dove": ("genshin_kirara", "en"),+ "Shine": ("ai_kaiya", "en"),+ "Anchor": ("oversea_male1", "en"),+ "Lyric": ("ai_chenjiahao_712", "en"),+ "Tender": ("chat1_female_new-3", "en"),+ "Siren": ("chat_0407_5-1", "en"),+ "Zippy": ("cartoon-boy-07", "en"),+ "Bud": ("uk_boy1", "en"),+ "Sprite": ("cartoon-girl-01", "en"),+ "Candy": ("PeppaPig_platform", "en"),+ "Beacon": ("ai_huangzhong_712", "en"),+ "Rock": ("ai_huangyaoshi_712", "en"),+ "Titan": ("ai_laoguowang_712", "en"),+ "Grace": ("chengshu_jiejie", "en"),+ "Helen": ("you_pingjing", "en"),+ "Lore": ("calm_story1", "en"),+ "Crag": ("uk_man2", "en"),+ "Prattle": ("laopopo_speech02", "en"),+ "Hearth": ("heainainai_speech02", "en"),+ "The Reader": ("reader_en_m-v1", "en"),+ "Commercial Lady": ("commercial_lady_en_f-v1", "en"),+ # Chinese voices+ "阳光少年": ("genshin_vindi2", "zh"),+ "懂事小弟": ("zhinen_xuesheng", "zh"),+ "运动少年": ("tiyuxi_xuedi", "zh"),+ "青春少女": ("ai_shatang", "zh"),+ "温柔小妹": ("genshin_klee2", "zh"),+ "元气少女": ("genshin_kirara", "zh"),+ "阳光男生": ("ai_kaiya", "zh"),+ "幽默小哥": ("tiexin_nanyou", "zh"),+ "文艺小哥": ("ai_chenjiahao_712", "zh"),+ "甜美邻家": ("girlfriend_1_speech02", "zh"),+ "温柔姐姐": ("chat1_female_new-3", "zh"),+ "职场女青": ("girlfriend_2_speech02", "zh"),+ "活泼男童": ("cartoon-boy-07", "zh"),+ "俏皮女童": ("cartoon-girl-01", "zh"),+ "稳重老爸": ("ai_huangyaoshi_712", "zh"),+ "温柔妈妈": ("you_pingjing", "zh"),+ "严肃上司": ("ai_laoguowang_712", "zh"),+ "优雅贵妇": ("chengshu_jiejie", "zh"),+ "慈祥爷爷": ("zhuxi_speech02", "zh"),+ "唠叨爷爷": ("uk_oldman3", "zh"),+ "唠叨奶奶": ("laopopo_speech02", "zh"),+ "和蔼奶奶": ("heainainai_speech02", "zh"),+ "东北老铁": ("dongbeilaotie_speech02", "zh"),+ "重庆小伙": ("chongqingxiaohuo_speech02", "zh"),+ "四川妹子": ("chuanmeizi_speech02", "zh"),+ "潮汕大叔": ("chaoshandashu_speech02", "zh"),+ "台湾男生": ("ai_taiwan_man2_speech02", "zh"),+ "西安掌柜": ("xianzhanggui_speech02", "zh"),+ "天津姐姐": ("tianjinjiejie_speech02", "zh"),+ "新闻播报男": ("diyinnansang_DB_CN_M_04-v2", "zh"),+ "译制片男": ("yizhipiannan-v1", "zh"),+ "撒娇女友": ("tianmeixuemei-v1", "zh"),+ "刀片烟嗓": ("daopianyansang-v1", "zh"),+ "乖巧正太": ("mengwa-v1", "zh"),+}async def poll_until_finished(@@ -142,11 +246,6 @@ def is_valid_camera_control_configs(configs: list[float]) -> bool:return any(not math.isclose(value, 0.0) for value in configs)-def is_valid_prompt(prompt: str) -> bool:- """Verifies that the prompt is not empty."""- return bool(prompt)--def is_valid_task_creation_response(response: KlingText2VideoResponse) -> bool:"""Verifies that the initial response contains a task ID."""return bool(response.data.task_id)@@ -190,7 +289,7 @@ def validate_task_creation_response(response) -> None:if not is_valid_task_creation_response(response):error_msg = f"Kling initial request failed. Code: {response.code}, Message: {response.message}, Data: {response.data}"logging.error(error_msg)- raise KlingApiError(error_msg)+ raise Exception(error_msg)def validate_video_result_response(response) -> None:@@ -198,7 +297,7 @@ def validate_video_result_response(response) -> None:if not is_valid_video_response(response):error_msg = f"Kling task {response.data.task_id} succeeded but no video data found in response."logging.error(f"Error: {error_msg}.\nResponse: {response}")- raise KlingApiError(error_msg)+ raise Exception(error_msg)def validate_image_result_response(response) -> None:@@ -206,7 +305,7 @@ def validate_image_result_response(response) -> None:if not is_valid_image_response(response):error_msg = f"Kling task {response.data.task_id} succeeded but no image data found in response."logging.error(f"Error: {error_msg}.\nResponse: {response}")- raise KlingApiError(error_msg)+ raise Exception(error_msg)def validate_input_image(image: torch.Tensor) -> None:@@ -221,21 +320,6 @@ def validate_input_image(image: torch.Tensor) -> None:validate_image_aspect_ratio(image, min_aspect_ratio=1 / 2.5, max_aspect_ratio=2.5)-def get_camera_control_input_config(- tooltip: str, default: float = 0.0-) -> tuple[IO, InputTypeOptions]:- """Returns common InputTypeOptions for Kling camera control configurations."""- input_config = {- "default": default,- "min": -10.0,- "max": 10.0,- "step": 0.25,- "display": "slider",- "tooltip": tooltip,- }- return IO.FLOAT, input_config--def get_video_from_response(response) -> KlingVideoResult:"""Returns the first video object from the Kling video generation task result.Will raise an error if the response is not valid.@@ -278,17 +362,6 @@ def get_images_urls_from_response(response) -> Optional[str]:return None-async def video_result_to_node_output(- video: KlingVideoResult,-) -> tuple[VideoFromFile, str, str]:- """Converts a KlingVideoResult to a tuple of (VideoFromFile, str, str) to be used as a ComfyUI node output."""- return (- await download_url_to_video_output(str(video.url)),- str(video.id),- str(video.duration),- )--async def image_result_to_node_output(images: list[KlingImageResult],) -> torch.Tensor:@@ -302,57 +375,339 @@ async def image_result_to_node_output(return torch.cat([await download_url_to_image_tensor(str(image.url)) for image in images])-class KlingNodeBase(ComfyNodeABC):- """Base class for Kling nodes."""+async def execute_text2video(+ auth_kwargs: dict[str, str],+ node_id: str,+ prompt: str,+ negative_prompt: str,+ cfg_scale: float,+ model_name: str,+ model_mode: str,+ duration: str,+ aspect_ratio: str,+ camera_control: Optional[KlingCameraControl] = None,+) -> comfy_io.NodeOutput:+ validate_prompts(prompt, negative_prompt, MAX_PROMPT_LENGTH_T2V)+ initial_operation = SynchronousOperation(+ endpoint=ApiEndpoint(+ path=PATH_TEXT_TO_VIDEO,+ method=HttpMethod.POST,+ request_model=KlingText2VideoRequest,+ response_model=KlingText2VideoResponse,+ ),+ request=KlingText2VideoRequest(+ prompt=prompt if prompt else None,+ negative_prompt=negative_prompt if negative_prompt else None,+ duration=KlingVideoGenDuration(duration),+ mode=KlingVideoGenMode(model_mode),+ model_name=KlingVideoGenModelName(model_name),+ cfg_scale=cfg_scale,+ aspect_ratio=KlingVideoGenAspectRatio(aspect_ratio),+ camera_control=camera_control,+ ),+ auth_kwargs=auth_kwargs,+ )++ task_creation_response = await initial_operation.execute()+ validate_task_creation_response(task_creation_response)++ task_id = task_creation_response.data.task_id+ final_response = await poll_until_finished(+ auth_kwargs,+ ApiEndpoint(+ path=f"{PATH_TEXT_TO_VIDEO}/{task_id}",+ method=HttpMethod.GET,+ request_model=EmptyRequest,+ response_model=KlingText2VideoResponse,+ ),+ result_url_extractor=get_video_url_from_response,+ estimated_duration=AVERAGE_DURATION_T2V,+ node_id=node_id,+ )+ validate_video_result_response(final_response)++ video = get_video_from_response(final_response)+ return comfy_io.NodeOutput(await download_url_to_video_output(str(video.url)), str(video.id), str(video.duration))+- FUNCTION = "api_call"- CATEGORY = "api node/video/Kling"- API_NODE = True+async def execute_image2video(+ auth_kwargs: dict[str, str],+ node_id: str,+ start_frame: torch.Tensor,+ prompt: str,+ negative_prompt: str,+ model_name: str,+ cfg_scale: float,+ model_mode: str,+ aspect_ratio: str,+ duration: str,+ camera_control: Optional[KlingCameraControl] = None,+ end_frame: Optional[torch.Tensor] = None,+) -> comfy_io.NodeOutput:+ validate_prompts(prompt, negative_prompt, MAX_PROMPT_LENGTH_I2V)+ validate_input_image(start_frame)++ if camera_control is not None:+ # Camera control type for image 2 video is always `simple`+ camera_control.type = KlingCameraControlType.simple++ if model_mode == "std" and model_name == KlingVideoGenModelName.kling_v2_5_turbo.value:+ model_mode = "pro" # October 5: currently "std" mode is not supported for this model++ initial_operation = SynchronousOperation(+ endpoint=ApiEndpoint(+ path=PATH_IMAGE_TO_VIDEO,+ method=HttpMethod.POST,+ request_model=KlingImage2VideoRequest,+ response_model=KlingImage2VideoResponse,+ ),+ request=KlingImage2VideoRequest(+ model_name=KlingVideoGenModelName(model_name),+ image=tensor_to_base64_string(start_frame),+ image_tail=(+ tensor_to_base64_string(end_frame)+ if end_frame is not None+ else None+ ),+ prompt=prompt,+ negative_prompt=negative_prompt if negative_prompt else None,+ cfg_scale=cfg_scale,+ mode=KlingVideoGenMode(model_mode),+ duration=KlingVideoGenDuration(duration),+ camera_control=camera_control,+ ),+ auth_kwargs=auth_kwargs,+ )+ task_creation_response = await initial_operation.execute()+ validate_task_creation_response(task_creation_response)+ task_id = task_creation_response.data.task_id-class KlingCameraControls(KlingNodeBase):+ final_response = await poll_until_finished(+ auth_kwargs,+ ApiEndpoint(+ path=f"{PATH_IMAGE_TO_VIDEO}/{task_id}",+ method=HttpMethod.GET,+ request_model=KlingImage2VideoRequest,+ response_model=KlingImage2VideoResponse,+ ),+ result_url_extractor=get_video_url_from_response,+ estimated_duration=AVERAGE_DURATION_I2V,+ node_id=node_id,+ )+ validate_video_result_response(final_response)++ video = get_video_from_response(final_response)+ return comfy_io.NodeOutput(await download_url_to_video_output(str(video.url)), str(video.id), str(video.duration))+++async def execute_video_effect(+ auth_kwargs: dict[str, str],+ node_id: str,+ dual_character: bool,+ effect_scene: KlingDualCharacterEffectsScene | KlingSingleImageEffectsScene,+ model_name: str,+ duration: KlingVideoGenDuration,+ image_1: torch.Tensor,+ image_2: Optional[torch.Tensor] = None,+ model_mode: Optional[KlingVideoGenMode] = None,+) -> comfy_io.NodeOutput:+ if dual_character:+ request_input_field = KlingDualCharacterEffectInput(+ model_name=model_name,+ mode=model_mode,+ images=[+ tensor_to_base64_string(image_1),+ tensor_to_base64_string(image_2),+ ],+ duration=duration,+ )+ else:+ request_input_field = KlingSingleImageEffectInput(+ model_name=model_name,+ image=tensor_to_base64_string(image_1),+ duration=duration,+ )++ initial_operation = SynchronousOperation(+ endpoint=ApiEndpoint(+ path=PATH_VIDEO_EFFECTS,+ method=HttpMethod.POST,+ request_model=KlingVideoEffectsRequest,+ response_model=KlingVideoEffectsResponse,+ ),+ request=KlingVideoEffectsRequest(+ effect_scene=effect_scene,+ input=request_input_field,+ ),+ auth_kwargs=auth_kwargs,+ )++ task_creation_response = await initial_operation.execute()+ validate_task_creation_response(task_creation_response)+ task_id = task_creation_response.data.task_id++ final_response = await poll_until_finished(+ auth_kwargs,+ ApiEndpoint(+ path=f"{PATH_VIDEO_EFFECTS}/{task_id}",+ method=HttpMethod.GET,+ request_model=EmptyRequest,+ response_model=KlingVideoEffectsResponse,+ ),+ result_url_extractor=get_video_url_from_response,+ estimated_duration=AVERAGE_DURATION_VIDEO_EFFECTS,+ node_id=node_id,+ )+ validate_video_result_response(final_response)++ video = get_video_from_response(final_response)+ return comfy_io.NodeOutput(await download_url_to_video_output(str(video.url)), str(video.id), str(video.duration))+++async def execute_lipsync(+ auth_kwargs: dict[str, str],+ node_id: str,+ video: VideoInput,+ audio: Optional[AudioInput] = None,+ voice_language: Optional[str] = None,+ model_mode: Optional[str] = None,+ text: Optional[str] = None,+ voice_speed: Optional[float] = None,+ voice_id: Optional[str] = None,+) -> comfy_io.NodeOutput:+ if text:+ validate_string(text, field_name="Text", max_length=MAX_PROMPT_LENGTH_LIP_SYNC)+ validate_video_dimensions(video, 720, 1920)+ validate_video_duration(video, 2, 10)++ # Upload video to Comfy API and get download URL+ video_url = await upload_video_to_comfyapi(video, auth_kwargs=auth_kwargs)+ logging.info("Uploaded video to Comfy API. URL: %s", video_url)++ # Upload the audio file to Comfy API and get download URL+ if audio:+ audio_url = await upload_audio_to_comfyapi(audio, auth_kwargs=auth_kwargs)+ logging.info("Uploaded audio to Comfy API. URL: %s", audio_url)+ else:+ audio_url = None++ initial_operation = SynchronousOperation(+ endpoint=ApiEndpoint(+ path=PATH_LIP_SYNC,+ method=HttpMethod.POST,+ request_model=KlingLipSyncRequest,+ response_model=KlingLipSyncResponse,+ ),+ request=KlingLipSyncRequest(+ input=KlingLipSyncInputObject(+ video_url=video_url,+ mode=model_mode,+ text=text,+ voice_language=voice_language,+ voice_speed=voice_speed,+ audio_type="url",+ audio_url=audio_url,+ voice_id=voice_id,+ ),+ ),+ auth_kwargs=auth_kwargs,+ )++ task_creation_response = await initial_operation.execute()+ validate_task_creation_response(task_creation_response)+ task_id = task_creation_response.data.task_id++ final_response = await poll_until_finished(+ auth_kwargs,+ ApiEndpoint(+ path=f"{PATH_LIP_SYNC}/{task_id}",+ method=HttpMethod.GET,+ request_model=EmptyRequest,+ response_model=KlingLipSyncResponse,+ ),+ result_url_extractor=get_video_url_from_response,+ estimated_duration=AVERAGE_DURATION_LIP_SYNC,+ node_id=node_id,+ )+ validate_video_result_response(final_response)++ video = get_video_from_response(final_response)+ return comfy_io.NodeOutput(await download_url_to_video_output(str(video.url)), str(video.id), str(video.duration))+++class KlingCameraControls(comfy_io.ComfyNode):"""Kling Camera Controls Node"""@classmethod- def INPUT_TYPES(cls):- return {- "required": {- "camera_control_type": model_field_to_node_input(- IO.COMBO,- KlingCameraControl,- "type",- enum_type=KlingCameraControlType,- ),- "horizontal_movement": get_camera_control_input_config(- "Controls camera's movement along horizontal axis (x-axis). Negative indicates left, positive indicates right"- ),- "vertical_movement": get_camera_control_input_config(- "Controls camera's movement along vertical axis (y-axis). Negative indicates downward, positive indicates upward."- ),- "pan": get_camera_control_input_config(- "Controls camera's rotation in vertical plane (x-axis). Negative indicates downward rotation, positive indicates upward rotation.",+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingCameraControls",+ display_name="Kling Camera Controls",+ category="api node/video/Kling",+ description="Allows specifying configuration options for Kling Camera Controls and motion control effects.",+ inputs=[+ comfy_io.Combo.Input("camera_control_type", options=[i.value for i in KlingCameraControlType]),+ comfy_io.Float.Input(+ "horizontal_movement",+ default=0.0,+ min=-10.0,+ max=10.0,+ step=0.25,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Controls camera's movement along horizontal axis (x-axis). Negative indicates left, positive indicates right",+ ),+ comfy_io.Float.Input(+ "vertical_movement",+ default=0.0,+ min=-10.0,+ max=10.0,+ step=0.25,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Controls camera's movement along vertical axis (y-axis). Negative indicates downward, positive indicates upward.",+ ),+ comfy_io.Float.Input(+ "pan",default=0.5,- ),- "tilt": get_camera_control_input_config(- "Controls camera's rotation in horizontal plane (y-axis). Negative indicates left rotation, positive indicates right rotation.",- ),- "roll": get_camera_control_input_config(- "Controls camera's rolling amount (z-axis). Negative indicates counterclockwise, positive indicates clockwise.",- ),- "zoom": get_camera_control_input_config(- "Controls change in camera's focal length. Negative indicates narrower field of view, positive indicates wider field of view.",- ),- }- }-- DESCRIPTION = "Allows specifying configuration options for Kling Camera Controls and motion control effects."- RETURN_TYPES = ("CAMERA_CONTROL",)- RETURN_NAMES = ("camera_control",)- FUNCTION = "main"- API_NODE = False # This is just a helper node, it doesn't make an API call+ min=-10.0,+ max=10.0,+ step=0.25,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Controls camera's rotation in vertical plane (x-axis). Negative indicates downward rotation, positive indicates upward rotation.",+ ),+ comfy_io.Float.Input(+ "tilt",+ default=0.0,+ min=-10.0,+ max=10.0,+ step=0.25,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Controls camera's rotation in horizontal plane (y-axis). Negative indicates left rotation, positive indicates right rotation.",+ ),+ comfy_io.Float.Input(+ "roll",+ default=0.0,+ min=-10.0,+ max=10.0,+ step=0.25,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Controls camera's rolling amount (z-axis). Negative indicates counterclockwise, positive indicates clockwise.",+ ),+ comfy_io.Float.Input(+ "zoom",+ default=0.0,+ min=-10.0,+ max=10.0,+ step=0.25,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Controls change in camera's focal length. Negative indicates narrower field of view, positive indicates wider field of view.",+ ),+ ],+ outputs=[comfy_io.Custom("CAMERA_CONTROL").Output(display_name="camera_control")],+ )@classmethod- def VALIDATE_INPUTS(+ def validate_inputs(cls,horizontal_movement: float,vertical_movement: float,@@ -374,8 +729,9 @@ class KlingCameraControls(KlingNodeBase):return "Invalid camera control configs: at least one of the values must be non-zero"return True- def main(- self,+ @classmethod+ def execute(+ cls,camera_control_type: str,horizontal_movement: float,vertical_movement: float,@@ -383,8 +739,8 @@ class KlingCameraControls(KlingNodeBase):tilt: float,roll: float,zoom: float,- ) -> tuple[KlingCameraControl]:- return (+ ) -> comfy_io.NodeOutput:+ return comfy_io.NodeOutput(KlingCameraControl(type=KlingCameraControlType(camera_control_type),config=KlingCameraConfig(@@ -395,303 +751,186 @@ class KlingCameraControls(KlingNodeBase):tilt=tilt,zoom=zoom,),- ),+ ))-class KlingTextToVideoNode(KlingNodeBase):+class KlingTextToVideoNode(comfy_io.ComfyNode):"""Kling Text to Video Node"""- @staticmethod- def get_mode_string_mapping() -> dict[str, tuple[str, str, str]]:- """- Returns a mapping of mode strings to their corresponding (mode, duration, model_name) tuples.- Only includes config combos that support the `image_tail` request field.-- See: [Kling API Docs Capability Map](https://app.klingai.com/global/dev/document-api/apiReference/model/skillsMap)- """- return {- "standard mode / 5s duration / kling-v1": ("std", "5", "kling-v1"),- "standard mode / 10s duration / kling-v1": ("std", "10", "kling-v1"),- "pro mode / 5s duration / kling-v1": ("pro", "5", "kling-v1"),- "pro mode / 10s duration / kling-v1": ("pro", "10", "kling-v1"),- "standard mode / 5s duration / kling-v1-6": ("std", "5", "kling-v1-6"),- "standard mode / 10s duration / kling-v1-6": ("std", "10", "kling-v1-6"),- "pro mode / 5s duration / kling-v2-master": ("pro", "5", "kling-v2-master"),- "pro mode / 10s duration / kling-v2-master": ("pro", "10", "kling-v2-master"),- "standard mode / 5s duration / kling-v2-master": ("std", "5", "kling-v2-master"),- "standard mode / 10s duration / kling-v2-master": ("std", "10", "kling-v2-master"),- "pro mode / 5s duration / kling-v2-1-master": ("pro", "5", "kling-v2-1-master"),- "pro mode / 10s duration / kling-v2-1-master": ("pro", "10", "kling-v2-1-master"),- "pro mode / 5s duration / kling-v2-5-turbo": ("pro", "5", "kling-v2-5-turbo"),- "pro mode / 10s duration / kling-v2-5-turbo": ("pro", "10", "kling-v2-5-turbo"),- }-@classmethod- def INPUT_TYPES(s):- modes = list(KlingTextToVideoNode.get_mode_string_mapping().keys())- return {- "required": {- "prompt": model_field_to_node_input(- IO.STRING, KlingText2VideoRequest, "prompt", multiline=True- ),- "negative_prompt": model_field_to_node_input(- IO.STRING, KlingText2VideoRequest, "negative_prompt", multiline=True- ),- "cfg_scale": model_field_to_node_input(- IO.FLOAT,- KlingText2VideoRequest,- "cfg_scale",- default=1.0,- min=0.0,- max=1.0,- ),- "aspect_ratio": model_field_to_node_input(- IO.COMBO,- KlingText2VideoRequest,+ def define_schema(cls) -> comfy_io.Schema:+ modes = list(MODE_TEXT2VIDEO.keys())+ return comfy_io.Schema(+ node_id="KlingTextToVideoNode",+ display_name="Kling Text to Video",+ category="api node/video/Kling",+ description="Kling Text to Video Node",+ inputs=[+ comfy_io.String.Input("prompt", multiline=True, tooltip="Positive text prompt"),+ comfy_io.String.Input("negative_prompt", multiline=True, tooltip="Negative text prompt"),+ comfy_io.Float.Input("cfg_scale", default=1.0, min=0.0, max=1.0),+ comfy_io.Combo.Input("aspect_ratio",- enum_type=KlingVideoGenAspectRatio,+ options=[i.value for i in KlingVideoGenAspectRatio],+ default="16:9",),- "mode": (- modes,- {- "default": modes[4],- "tooltip": "The configuration to use for the video generation following the format: mode / duration / model_name.",- },- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- RETURN_TYPES = ("VIDEO", "STRING", "STRING")- RETURN_NAMES = ("VIDEO", "video_id", "duration")- DESCRIPTION = "Kling Text to Video Node"-- async def get_response(- self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None- ) -> KlingText2VideoResponse:- return await poll_until_finished(- auth_kwargs,- ApiEndpoint(- path=f"{PATH_TEXT_TO_VIDEO}/{task_id}",- method=HttpMethod.GET,- request_model=EmptyRequest,- response_model=KlingText2VideoResponse,- ),- result_url_extractor=get_video_url_from_response,- estimated_duration=AVERAGE_DURATION_T2V,- node_id=node_id,+ comfy_io.Combo.Input(+ "mode",+ options=modes,+ default=modes[4],+ tooltip="The configuration to use for the video generation following the format: mode / duration / model_name.",+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,)- async def api_call(- self,+ @classmethod+ async def execute(+ cls,prompt: str,negative_prompt: str,cfg_scale: float,mode: str,aspect_ratio: str,- camera_control: Optional[KlingCameraControl] = None,- model_name: Optional[str] = None,- duration: Optional[str] = None,- unique_id: Optional[str] = None,- **kwargs,- ) -> tuple[VideoFromFile, str, str]:- validate_prompts(prompt, negative_prompt, MAX_PROMPT_LENGTH_T2V)- if model_name is None:- mode, duration, model_name = self.get_mode_string_mapping()[mode]- initial_operation = SynchronousOperation(- endpoint=ApiEndpoint(- path=PATH_TEXT_TO_VIDEO,- method=HttpMethod.POST,- request_model=KlingText2VideoRequest,- response_model=KlingText2VideoResponse,- ),- request=KlingText2VideoRequest(- prompt=prompt if prompt else None,- negative_prompt=negative_prompt if negative_prompt else None,- duration=KlingVideoGenDuration(duration),- mode=KlingVideoGenMode(mode),- model_name=KlingVideoGenModelName(model_name),- cfg_scale=cfg_scale,- aspect_ratio=KlingVideoGenAspectRatio(aspect_ratio),- camera_control=camera_control,- ),- auth_kwargs=kwargs,- )-- task_creation_response = await initial_operation.execute()- validate_task_creation_response(task_creation_response)-- task_id = task_creation_response.data.task_id- final_response = await self.get_response(- task_id, auth_kwargs=kwargs, node_id=unique_id+ ) -> comfy_io.NodeOutput:+ model_mode, duration, model_name = MODE_TEXT2VIDEO[mode]+ return await execute_text2video(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,+ prompt=prompt,+ negative_prompt=negative_prompt,+ cfg_scale=cfg_scale,+ model_mode=model_mode,+ aspect_ratio=aspect_ratio,+ model_name=model_name,+ duration=duration,)- validate_video_result_response(final_response)-- video = get_video_from_response(final_response)- return await video_result_to_node_output(video)-class KlingCameraControlT2VNode(KlingTextToVideoNode):+class KlingCameraControlT2VNode(comfy_io.ComfyNode):"""Kling Text to Video Camera Control Node. This node is a text to video node, but it supports controlling the camera.Duration, mode, and model_name request fields are hard-coded because camera control is only supported in pro mode with the kling-v1-5 model at 5s duration as of 2025-05-02."""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "prompt": model_field_to_node_input(- IO.STRING, KlingText2VideoRequest, "prompt", multiline=True- ),- "negative_prompt": model_field_to_node_input(- IO.STRING,- KlingText2VideoRequest,- "negative_prompt",- multiline=True,- ),- "cfg_scale": model_field_to_node_input(- IO.FLOAT,- KlingText2VideoRequest,- "cfg_scale",- default=0.75,- min=0.0,- max=1.0,- ),- "aspect_ratio": model_field_to_node_input(- IO.COMBO,- KlingText2VideoRequest,+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingCameraControlT2VNode",+ display_name="Kling Text to Video (Camera Control)",+ category="api node/video/Kling",+ description="Transform text into cinematic videos with professional camera movements that simulate real-world cinematography. Control virtual camera actions including zoom, rotation, pan, tilt, and first-person view, while maintaining focus on your original text.",+ inputs=[+ comfy_io.String.Input("prompt", multiline=True, tooltip="Positive text prompt"),+ comfy_io.String.Input("negative_prompt", multiline=True, tooltip="Negative text prompt"),+ comfy_io.Float.Input("cfg_scale", default=0.75, min=0.0, max=1.0),+ comfy_io.Combo.Input("aspect_ratio",- enum_type=KlingVideoGenAspectRatio,- ),- "camera_control": (- "CAMERA_CONTROL",- {- "tooltip": "Can be created using the Kling Camera Controls node. Controls the camera movement and motion during the video generation.",- },- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Transform text into cinematic videos with professional camera movements that simulate real-world cinematography. Control virtual camera actions including zoom, rotation, pan, tilt, and first-person view, while maintaining focus on your original text."+ options=[i.value for i in KlingVideoGenAspectRatio],+ default="16:9",+ ),+ comfy_io.Custom("CAMERA_CONTROL").Input(+ "camera_control",+ tooltip="Can be created using the Kling Camera Controls node. Controls the camera movement and motion during the video generation.",+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,prompt: str,negative_prompt: str,cfg_scale: float,aspect_ratio: str,camera_control: Optional[KlingCameraControl] = None,- unique_id: Optional[str] = None,- **kwargs,- ):- return await super().api_call(+ ) -> comfy_io.NodeOutput:+ return await execute_text2video(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,model_name=KlingVideoGenModelName.kling_v1,cfg_scale=cfg_scale,- mode=KlingVideoGenMode.std,+ model_mode=KlingVideoGenMode.std,aspect_ratio=KlingVideoGenAspectRatio(aspect_ratio),duration=KlingVideoGenDuration.field_5,prompt=prompt,negative_prompt=negative_prompt,camera_control=camera_control,- **kwargs,)-class KlingImage2VideoNode(KlingNodeBase):+class KlingImage2VideoNode(comfy_io.ComfyNode):"""Kling Image to Video Node"""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "start_frame": model_field_to_node_input(- IO.IMAGE,- KlingImage2VideoRequest,- "image",- tooltip="The reference image used to generate the video.",- ),- "prompt": model_field_to_node_input(- IO.STRING, KlingImage2VideoRequest, "prompt", multiline=True- ),- "negative_prompt": model_field_to_node_input(- IO.STRING,- KlingImage2VideoRequest,- "negative_prompt",- multiline=True,- ),- "model_name": model_field_to_node_input(- IO.COMBO,- KlingImage2VideoRequest,+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingImage2VideoNode",+ display_name="Kling Image to Video",+ category="api node/video/Kling",+ description="Kling Image to Video Node",+ inputs=[+ comfy_io.Image.Input("start_frame", tooltip="The reference image used to generate the video."),+ comfy_io.String.Input("prompt", multiline=True, tooltip="Positive text prompt"),+ comfy_io.String.Input("negative_prompt", multiline=True, tooltip="Negative text prompt"),+ comfy_io.Combo.Input("model_name",- enum_type=KlingVideoGenModelName,+ options=[i.value for i in KlingVideoGenModelName],+ default="kling-v2-master",),- "cfg_scale": model_field_to_node_input(- IO.FLOAT,- KlingImage2VideoRequest,- "cfg_scale",- default=0.8,- min=0.0,- max=1.0,- ),- "mode": model_field_to_node_input(- IO.COMBO,- KlingImage2VideoRequest,- "mode",- enum_type=KlingVideoGenMode,- ),- "aspect_ratio": model_field_to_node_input(- IO.COMBO,- KlingImage2VideoRequest,+ comfy_io.Float.Input("cfg_scale", default=0.8, min=0.0, max=1.0),+ comfy_io.Combo.Input("mode", options=[i.value for i in KlingVideoGenMode], default="std"),+ comfy_io.Combo.Input("aspect_ratio",- enum_type=KlingVideoGenAspectRatio,- ),- "duration": model_field_to_node_input(- IO.COMBO,- KlingImage2VideoRequest,- "duration",- enum_type=KlingVideoGenDuration,- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- RETURN_TYPES = ("VIDEO", "STRING", "STRING")- RETURN_NAMES = ("VIDEO", "video_id", "duration")- DESCRIPTION = "Kling Image to Video Node"-- async def get_response(- self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None- ) -> KlingImage2VideoResponse:- return await poll_until_finished(- auth_kwargs,- ApiEndpoint(- path=f"{PATH_IMAGE_TO_VIDEO}/{task_id}",- method=HttpMethod.GET,- request_model=KlingImage2VideoRequest,- response_model=KlingImage2VideoResponse,- ),- result_url_extractor=get_video_url_from_response,- estimated_duration=AVERAGE_DURATION_I2V,- node_id=node_id,+ options=[i.value for i in KlingVideoGenAspectRatio],+ default="16:9",+ ),+ comfy_io.Combo.Input("duration", options=[i.value for i in KlingVideoGenDuration], default="5"),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,)- async def api_call(- self,+ @classmethod+ async def execute(+ cls,start_frame: torch.Tensor,prompt: str,negative_prompt: str,@@ -702,212 +941,151 @@ class KlingImage2VideoNode(KlingNodeBase):duration: str,camera_control: Optional[KlingCameraControl] = None,end_frame: Optional[torch.Tensor] = None,- unique_id: Optional[str] = None,- **kwargs,- ) -> tuple[VideoFromFile]:- validate_prompts(prompt, negative_prompt, MAX_PROMPT_LENGTH_I2V)- validate_input_image(start_frame)-- if camera_control is not None:- # Camera control type for image 2 video is always `simple`- camera_control.type = KlingCameraControlType.simple-- if mode == "std" and model_name == KlingVideoGenModelName.kling_v2_5_turbo.value:- mode = "pro" # October 5: currently "std" mode is not supported for this model-- initial_operation = SynchronousOperation(- endpoint=ApiEndpoint(- path=PATH_IMAGE_TO_VIDEO,- method=HttpMethod.POST,- request_model=KlingImage2VideoRequest,- response_model=KlingImage2VideoResponse,- ),- request=KlingImage2VideoRequest(- model_name=KlingVideoGenModelName(model_name),- image=tensor_to_base64_string(start_frame),- image_tail=(- tensor_to_base64_string(end_frame)- if end_frame is not None- else None- ),- prompt=prompt,- negative_prompt=negative_prompt if negative_prompt else None,- cfg_scale=cfg_scale,- mode=KlingVideoGenMode(mode),- duration=KlingVideoGenDuration(duration),- camera_control=camera_control,- ),- auth_kwargs=kwargs,- )-- task_creation_response = await initial_operation.execute()- validate_task_creation_response(task_creation_response)- task_id = task_creation_response.data.task_id-- final_response = await self.get_response(- task_id, auth_kwargs=kwargs, node_id=unique_id+ ) -> comfy_io.NodeOutput:+ return await execute_image2video(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,+ start_frame=start_frame,+ prompt=prompt,+ negative_prompt=negative_prompt,+ cfg_scale=cfg_scale,+ model_name=model_name,+ aspect_ratio=aspect_ratio,+ model_mode=mode,+ duration=duration,+ camera_control=camera_control,+ end_frame=end_frame,)- validate_video_result_response(final_response)-- video = get_video_from_response(final_response)- return await video_result_to_node_output(video)-class KlingCameraControlI2VNode(KlingImage2VideoNode):+class KlingCameraControlI2VNode(comfy_io.ComfyNode):"""Kling Image to Video Camera Control Node. This node is a image to video node, but it supports controlling the camera.Duration, mode, and model_name request fields are hard-coded because camera control is only supported in pro mode with the kling-v1-5 model at 5s duration as of 2025-05-02."""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "start_frame": model_field_to_node_input(- IO.IMAGE, KlingImage2VideoRequest, "image"- ),- "prompt": model_field_to_node_input(- IO.STRING, KlingImage2VideoRequest, "prompt", multiline=True- ),- "negative_prompt": model_field_to_node_input(- IO.STRING,- KlingImage2VideoRequest,- "negative_prompt",- multiline=True,- ),- "cfg_scale": model_field_to_node_input(- IO.FLOAT,- KlingImage2VideoRequest,- "cfg_scale",- default=0.75,- min=0.0,- max=1.0,- ),- "aspect_ratio": model_field_to_node_input(- IO.COMBO,- KlingImage2VideoRequest,+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingCameraControlI2VNode",+ display_name="Kling Image to Video (Camera Control)",+ category="api node/video/Kling",+ description="Transform still images into cinematic videos with professional camera movements that simulate real-world cinematography. Control virtual camera actions including zoom, rotation, pan, tilt, and first-person view, while maintaining focus on your original image.",+ inputs=[+ comfy_io.Image.Input(+ "start_frame",+ tooltip="Reference Image - URL or Base64 encoded string, cannot exceed 10MB, resolution not less than 300*300px, aspect ratio between 1:2.5 ~ 2.5:1. Base64 should not include data:image prefix.",+ ),+ comfy_io.String.Input("prompt", multiline=True, tooltip="Positive text prompt"),+ comfy_io.String.Input("negative_prompt", multiline=True, tooltip="Negative text prompt"),+ comfy_io.Float.Input("cfg_scale", default=0.75, min=0.0, max=1.0),+ comfy_io.Combo.Input("aspect_ratio",- enum_type=KlingVideoGenAspectRatio,- ),- "camera_control": (- "CAMERA_CONTROL",- {- "tooltip": "Can be created using the Kling Camera Controls node. Controls the camera movement and motion during the video generation.",- },- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Transform still images into cinematic videos with professional camera movements that simulate real-world cinematography. Control virtual camera actions including zoom, rotation, pan, tilt, and first-person view, while maintaining focus on your original image."+ options=[i.value for i in KlingVideoGenAspectRatio],+ default="16:9",+ ),+ comfy_io.Custom("CAMERA_CONTROL").Input(+ "camera_control",+ tooltip="Can be created using the Kling Camera Controls node. Controls the camera movement and motion during the video generation.",+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,start_frame: torch.Tensor,prompt: str,negative_prompt: str,cfg_scale: float,aspect_ratio: str,camera_control: KlingCameraControl,- unique_id: Optional[str] = None,- **kwargs,- ):- return await super().api_call(+ ) -> comfy_io.NodeOutput:+ return await execute_image2video(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,model_name=KlingVideoGenModelName.kling_v1_5,start_frame=start_frame,cfg_scale=cfg_scale,- mode=KlingVideoGenMode.pro,+ model_mode=KlingVideoGenMode.pro,aspect_ratio=KlingVideoGenAspectRatio(aspect_ratio),duration=KlingVideoGenDuration.field_5,prompt=prompt,negative_prompt=negative_prompt,camera_control=camera_control,- unique_id=unique_id,- **kwargs,)-class KlingStartEndFrameNode(KlingImage2VideoNode):+class KlingStartEndFrameNode(comfy_io.ComfyNode):"""Kling First Last Frame Node. This node allows creation of a video from a first and last frame. It calls the normal image to video endpoint, but only allows the subset of input options that support the `image_tail` request field."""- @staticmethod- def get_mode_string_mapping() -> dict[str, tuple[str, str, str]]:- """- Returns a mapping of mode strings to their corresponding (mode, duration, model_name) tuples.- Only includes config combos that support the `image_tail` request field.-- See: [Kling API Docs Capability Map](https://app.klingai.com/global/dev/document-api/apiReference/model/skillsMap)- """- return {- "standard mode / 5s duration / kling-v1": ("std", "5", "kling-v1"),- "pro mode / 5s duration / kling-v1": ("pro", "5", "kling-v1"),- "pro mode / 5s duration / kling-v1-5": ("pro", "5", "kling-v1-5"),- "pro mode / 10s duration / kling-v1-5": ("pro", "10", "kling-v1-5"),- "pro mode / 5s duration / kling-v1-6": ("pro", "5", "kling-v1-6"),- "pro mode / 10s duration / kling-v1-6": ("pro", "10", "kling-v1-6"),- "pro mode / 5s duration / kling-v2-1": ("pro", "5", "kling-v2-1"),- "pro mode / 10s duration / kling-v2-1": ("pro", "10", "kling-v2-1"),- }-@classmethod- def INPUT_TYPES(s):- modes = list(KlingStartEndFrameNode.get_mode_string_mapping().keys())- return {- "required": {- "start_frame": model_field_to_node_input(- IO.IMAGE, KlingImage2VideoRequest, "image"- ),- "end_frame": model_field_to_node_input(- IO.IMAGE, KlingImage2VideoRequest, "image_tail"- ),- "prompt": model_field_to_node_input(- IO.STRING, KlingImage2VideoRequest, "prompt", multiline=True- ),- "negative_prompt": model_field_to_node_input(- IO.STRING,- KlingImage2VideoRequest,- "negative_prompt",- multiline=True,- ),- "cfg_scale": model_field_to_node_input(- IO.FLOAT,- KlingImage2VideoRequest,- "cfg_scale",- default=0.5,- min=0.0,- max=1.0,- ),- "aspect_ratio": model_field_to_node_input(- IO.COMBO,- KlingImage2VideoRequest,+ def define_schema(cls) -> comfy_io.Schema:+ modes = list(MODE_START_END_FRAME.keys())+ return comfy_io.Schema(+ node_id="KlingStartEndFrameNode",+ display_name="Kling Start-End Frame to Video",+ category="api node/video/Kling",+ description="Generate a video sequence that transitions between your provided start and end images. The node creates all frames in between, producing a smooth transformation from the first frame to the last.",+ inputs=[+ comfy_io.Image.Input(+ "start_frame",+ tooltip="Reference Image - URL or Base64 encoded string, cannot exceed 10MB, resolution not less than 300*300px, aspect ratio between 1:2.5 ~ 2.5:1. Base64 should not include data:image prefix.",+ ),+ comfy_io.Image.Input(+ "end_frame",+ tooltip="Reference Image - End frame control. URL or Base64 encoded string, cannot exceed 10MB, resolution not less than 300*300px. Base64 should not include data:image prefix.",+ ),+ comfy_io.String.Input("prompt", multiline=True, tooltip="Positive text prompt"),+ comfy_io.String.Input("negative_prompt", multiline=True, tooltip="Negative text prompt"),+ comfy_io.Float.Input("cfg_scale", default=0.5, min=0.0, max=1.0),+ comfy_io.Combo.Input("aspect_ratio",- enum_type=KlingVideoGenAspectRatio,+ options=[i.value for i in KlingVideoGenAspectRatio],+ default="16:9",),- "mode": (- modes,- {- "default": modes[2],- "tooltip": "The configuration to use for the video generation following the format: mode / duration / model_name.",- },- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Generate a video sequence that transitions between your provided start and end images. The node creates all frames in between, producing a smooth transformation from the first frame to the last."+ comfy_io.Combo.Input(+ "mode",+ options=modes,+ default=modes[2],+ tooltip="The configuration to use for the video generation following the format: mode / duration / model_name.",+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,start_frame: torch.Tensor,end_frame: torch.Tensor,prompt: str,@@ -915,90 +1093,78 @@ class KlingStartEndFrameNode(KlingImage2VideoNode):cfg_scale: float,aspect_ratio: str,mode: str,- unique_id: Optional[str] = None,- **kwargs,- ):- mode, duration, model_name = KlingStartEndFrameNode.get_mode_string_mapping()[- mode- ]- return await super().api_call(+ ) -> comfy_io.NodeOutput:+ mode, duration, model_name = MODE_START_END_FRAME[mode]+ return await execute_image2video(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,prompt=prompt,negative_prompt=negative_prompt,model_name=model_name,start_frame=start_frame,cfg_scale=cfg_scale,- mode=mode,+ model_mode=mode,aspect_ratio=aspect_ratio,duration=duration,end_frame=end_frame,- unique_id=unique_id,- **kwargs,)-class KlingVideoExtendNode(KlingNodeBase):+class KlingVideoExtendNode(comfy_io.ComfyNode):@classmethod- def INPUT_TYPES(s):- return {- "required": {- "prompt": model_field_to_node_input(- IO.STRING, KlingVideoExtendRequest, "prompt", multiline=True+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingVideoExtendNode",+ display_name="Kling Video Extend",+ category="api node/video/Kling",+ description="Kling Video Extend Node. Extend videos made by other Kling nodes. The video_id is created by using other Kling Nodes.",+ inputs=[+ comfy_io.String.Input(+ "prompt",+ multiline=True,+ tooltip="Positive text prompt for guiding the video extension",),- "negative_prompt": model_field_to_node_input(- IO.STRING,- KlingVideoExtendRequest,+ comfy_io.String.Input("negative_prompt",multiline=True,- ),- "cfg_scale": model_field_to_node_input(- IO.FLOAT,- KlingVideoExtendRequest,- "cfg_scale",- default=0.5,- min=0.0,- max=1.0,- ),- "video_id": model_field_to_node_input(- IO.STRING, KlingVideoExtendRequest, "video_id", forceInput=True- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- RETURN_TYPES = ("VIDEO", "STRING", "STRING")- RETURN_NAMES = ("VIDEO", "video_id", "duration")- DESCRIPTION = "Kling Video Extend Node. Extend videos made by other Kling nodes. The video_id is created by using other Kling Nodes."-- async def get_response(- self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None- ) -> KlingVideoExtendResponse:- return await poll_until_finished(- auth_kwargs,- ApiEndpoint(- path=f"{PATH_VIDEO_EXTEND}/{task_id}",- method=HttpMethod.GET,- request_model=EmptyRequest,- response_model=KlingVideoExtendResponse,- ),- result_url_extractor=get_video_url_from_response,- estimated_duration=AVERAGE_DURATION_VIDEO_EXTEND,- node_id=node_id,+ tooltip="Negative text prompt for elements to avoid in the extended video",+ ),+ comfy_io.Float.Input("cfg_scale", default=0.5, min=0.0, max=1.0),+ comfy_io.String.Input(+ "video_id",+ force_input=True,+ tooltip="The ID of the video to be extended. Supports videos generated by text-to-video, image-to-video, and previous video extension operations. Cannot exceed 3 minutes total duration after extension.",+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,)- async def api_call(- self,+ @classmethod+ async def execute(+ cls,prompt: str,negative_prompt: str,cfg_scale: float,video_id: str,- unique_id: Optional[str] = None,- **kwargs,- ) -> tuple[VideoFromFile, str, str]:+ ) -> comfy_io.NodeOutput:validate_prompts(prompt, negative_prompt, MAX_PROMPT_LENGTH_T2V)+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }initial_operation = SynchronousOperation(endpoint=ApiEndpoint(path=PATH_VIDEO_EXTEND,@@ -1012,560 +1178,323 @@ class KlingVideoExtendNode(KlingNodeBase):cfg_scale=cfg_scale,video_id=video_id,),- auth_kwargs=kwargs,+ auth_kwargs=auth,)task_creation_response = await initial_operation.execute()validate_task_creation_response(task_creation_response)task_id = task_creation_response.data.task_id- final_response = await self.get_response(- task_id, auth_kwargs=kwargs, node_id=unique_id- )- validate_video_result_response(final_response)-- video = get_video_from_response(final_response)- return await video_result_to_node_output(video)---class KlingVideoEffectsBase(KlingNodeBase):- """Kling Video Effects Base"""-- RETURN_TYPES = ("VIDEO", "STRING", "STRING")- RETURN_NAMES = ("VIDEO", "video_id", "duration")-- async def get_response(- self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None- ) -> KlingVideoEffectsResponse:- return await poll_until_finished(- auth_kwargs,+ final_response = await poll_until_finished(+ auth,ApiEndpoint(- path=f"{PATH_VIDEO_EFFECTS}/{task_id}",+ path=f"{PATH_VIDEO_EXTEND}/{task_id}",method=HttpMethod.GET,request_model=EmptyRequest,- response_model=KlingVideoEffectsResponse,+ response_model=KlingVideoExtendResponse,),result_url_extractor=get_video_url_from_response,- estimated_duration=AVERAGE_DURATION_VIDEO_EFFECTS,- node_id=node_id,- )-- async def api_call(- self,- dual_character: bool,- effect_scene: KlingDualCharacterEffectsScene | KlingSingleImageEffectsScene,- model_name: str,- duration: KlingVideoGenDuration,- image_1: torch.Tensor,- image_2: Optional[torch.Tensor] = None,- mode: Optional[KlingVideoGenMode] = None,- unique_id: Optional[str] = None,- **kwargs,- ):- if dual_character:- request_input_field = KlingDualCharacterEffectInput(- model_name=model_name,- mode=mode,- images=[- tensor_to_base64_string(image_1),- tensor_to_base64_string(image_2),- ],- duration=duration,- )- else:- request_input_field = KlingSingleImageEffectInput(- model_name=model_name,- image=tensor_to_base64_string(image_1),- duration=duration,- )-- initial_operation = SynchronousOperation(- endpoint=ApiEndpoint(- path=PATH_VIDEO_EFFECTS,- method=HttpMethod.POST,- request_model=KlingVideoEffectsRequest,- response_model=KlingVideoEffectsResponse,- ),- request=KlingVideoEffectsRequest(- effect_scene=effect_scene,- input=request_input_field,- ),- auth_kwargs=kwargs,- )-- task_creation_response = await initial_operation.execute()- validate_task_creation_response(task_creation_response)- task_id = task_creation_response.data.task_id-- final_response = await self.get_response(- task_id, auth_kwargs=kwargs, node_id=unique_id+ estimated_duration=AVERAGE_DURATION_VIDEO_EXTEND,+ node_id=cls.hidden.unique_id,)validate_video_result_response(final_response)video = get_video_from_response(final_response)- return await video_result_to_node_output(video)+ return comfy_io.NodeOutput(await download_url_to_video_output(str(video.url)), str(video.id), str(video.duration))-class KlingDualCharacterVideoEffectNode(KlingVideoEffectsBase):+class KlingDualCharacterVideoEffectNode(comfy_io.ComfyNode):"""Kling Dual Character Video Effect Node"""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "image_left": (IO.IMAGE, {"tooltip": "Left side image"}),- "image_right": (IO.IMAGE, {"tooltip": "Right side image"}),- "effect_scene": model_field_to_node_input(- IO.COMBO,- KlingVideoEffectsRequest,+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingDualCharacterVideoEffectNode",+ display_name="Kling Dual Character Video Effects",+ category="api node/video/Kling",+ description="Achieve different special effects when generating a video based on the effect_scene. First image will be positioned on left side, second on right side of the composite.",+ inputs=[+ comfy_io.Image.Input("image_left", tooltip="Left side image"),+ comfy_io.Image.Input("image_right", tooltip="Right side image"),+ comfy_io.Combo.Input("effect_scene",- enum_type=KlingDualCharacterEffectsScene,+ options=[i.value for i in KlingDualCharacterEffectsScene],),- "model_name": model_field_to_node_input(- IO.COMBO,- KlingDualCharacterEffectInput,+ comfy_io.Combo.Input("model_name",- enum_type=KlingCharacterEffectModelName,+ options=[i.value for i in KlingCharacterEffectModelName],+ default="kling-v1",),- "mode": model_field_to_node_input(- IO.COMBO,- KlingDualCharacterEffectInput,+ comfy_io.Combo.Input("mode",- enum_type=KlingVideoGenMode,+ options=[i.value for i in KlingVideoGenMode],+ default="std",),- "duration": model_field_to_node_input(- IO.COMBO,- KlingDualCharacterEffectInput,+ comfy_io.Combo.Input("duration",- enum_type=KlingVideoGenDuration,- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Achieve different special effects when generating a video based on the effect_scene. First image will be positioned on left side, second on right side of the composite."- RETURN_TYPES = ("VIDEO", "STRING")- RETURN_NAMES = ("VIDEO", "duration")+ options=[i.value for i in KlingVideoGenDuration],+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,image_left: torch.Tensor,image_right: torch.Tensor,effect_scene: KlingDualCharacterEffectsScene,model_name: KlingCharacterEffectModelName,mode: KlingVideoGenMode,duration: KlingVideoGenDuration,- unique_id: Optional[str] = None,- **kwargs,- ):- video, _, duration = await super().api_call(+ ) -> comfy_io.NodeOutput:+ video, _, duration = await execute_video_effect(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,dual_character=True,effect_scene=effect_scene,model_name=model_name,- mode=mode,+ model_mode=mode,duration=duration,image_1=image_left,image_2=image_right,- unique_id=unique_id,- **kwargs,)return video, duration-class KlingSingleImageVideoEffectNode(KlingVideoEffectsBase):+class KlingSingleImageVideoEffectNode(comfy_io.ComfyNode):"""Kling Single Image Video Effect Node"""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "image": (- IO.IMAGE,- {- "tooltip": " Reference Image. URL or Base64 encoded string (without data:image prefix). File size cannot exceed 10MB, resolution not less than 300*300px, aspect ratio between 1:2.5 ~ 2.5:1"- },- ),- "effect_scene": model_field_to_node_input(- IO.COMBO,- KlingVideoEffectsRequest,+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingSingleImageVideoEffectNode",+ display_name="Kling Video Effects",+ category="api node/video/Kling",+ description="Achieve different special effects when generating a video based on the effect_scene.",+ inputs=[+ comfy_io.Image.Input("image", tooltip=" Reference Image. URL or Base64 encoded string (without data:image prefix). File size cannot exceed 10MB, resolution not less than 300*300px, aspect ratio between 1:2.5 ~ 2.5:1"),+ comfy_io.Combo.Input("effect_scene",- enum_type=KlingSingleImageEffectsScene,+ options=[i.value for i in KlingSingleImageEffectsScene],),- "model_name": model_field_to_node_input(- IO.COMBO,- KlingSingleImageEffectInput,+ comfy_io.Combo.Input("model_name",- enum_type=KlingSingleImageEffectModelName,+ options=[i.value for i in KlingSingleImageEffectModelName],),- "duration": model_field_to_node_input(- IO.COMBO,- KlingSingleImageEffectInput,+ comfy_io.Combo.Input("duration",- enum_type=KlingVideoGenDuration,- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Achieve different special effects when generating a video based on the effect_scene."+ options=[i.value for i in KlingVideoGenDuration],+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,image: torch.Tensor,effect_scene: KlingSingleImageEffectsScene,model_name: KlingSingleImageEffectModelName,duration: KlingVideoGenDuration,- unique_id: Optional[str] = None,- **kwargs,- ):- return await super().api_call(+ ) -> comfy_io.NodeOutput:+ return await execute_video_effect(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,dual_character=False,effect_scene=effect_scene,model_name=model_name,duration=duration,image_1=image,- unique_id=unique_id,- **kwargs,)-class KlingLipSyncBase(KlingNodeBase):- """Kling Lip Sync Base"""-- RETURN_TYPES = ("VIDEO", "STRING", "STRING")- RETURN_NAMES = ("VIDEO", "video_id", "duration")-- def validate_lip_sync_video(self, video: VideoInput):- """- Validates the input video adheres to the expectations of the Kling Lip Sync API:- - Video length does not exceed 10s and is not shorter than 2s- - Length and width dimensions should both be between 720px and 1920px-- See: https://app.klingai.com/global/dev/document-api/apiReference/model/videoTolip- """- validate_video_dimensions(video, 720, 1920)- validate_video_duration(video, 2, 10)-- def validate_text(self, text: str):- if not text:- raise ValueError("Text is required")- if len(text) > MAX_PROMPT_LENGTH_LIP_SYNC:- raise ValueError(- f"Text is too long. Maximum length is {MAX_PROMPT_LENGTH_LIP_SYNC} characters."- )-- async def get_response(- self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None- ) -> KlingLipSyncResponse:- """Polls the Kling API endpoint until the task reaches a terminal state."""- return await poll_until_finished(- auth_kwargs,- ApiEndpoint(- path=f"{PATH_LIP_SYNC}/{task_id}",- method=HttpMethod.GET,- request_model=EmptyRequest,- response_model=KlingLipSyncResponse,- ),- result_url_extractor=get_video_url_from_response,- estimated_duration=AVERAGE_DURATION_LIP_SYNC,- node_id=node_id,- )-- async def api_call(- self,- video: VideoInput,- audio: Optional[AudioInput] = None,- voice_language: Optional[str] = None,- mode: Optional[str] = None,- text: Optional[str] = None,- voice_speed: Optional[float] = None,- voice_id: Optional[str] = None,- unique_id: Optional[str] = None,- **kwargs,- ) -> tuple[VideoFromFile, str, str]:- if text:- self.validate_text(text)- self.validate_lip_sync_video(video)-- # Upload video to Comfy API and get download URL- video_url = await upload_video_to_comfyapi(video, auth_kwargs=kwargs)- logging.info("Uploaded video to Comfy API. URL: %s", video_url)-- # Upload the audio file to Comfy API and get download URL- if audio:- audio_url = await upload_audio_to_comfyapi(audio, auth_kwargs=kwargs)- logging.info("Uploaded audio to Comfy API. URL: %s", audio_url)- else:- audio_url = None-- initial_operation = SynchronousOperation(- endpoint=ApiEndpoint(- path=PATH_LIP_SYNC,- method=HttpMethod.POST,- request_model=KlingLipSyncRequest,- response_model=KlingLipSyncResponse,- ),- request=KlingLipSyncRequest(- input=KlingLipSyncInputObject(- video_url=video_url,- mode=mode,- text=text,- voice_language=voice_language,- voice_speed=voice_speed,- audio_type="url",- audio_url=audio_url,- voice_id=voice_id,- ),- ),- auth_kwargs=kwargs,- )-- task_creation_response = await initial_operation.execute()- validate_task_creation_response(task_creation_response)- task_id = task_creation_response.data.task_id-- final_response = await self.get_response(- task_id, auth_kwargs=kwargs, node_id=unique_id- )- validate_video_result_response(final_response)-- video = get_video_from_response(final_response)- return await video_result_to_node_output(video)---class KlingLipSyncAudioToVideoNode(KlingLipSyncBase):+class KlingLipSyncAudioToVideoNode(comfy_io.ComfyNode):"""Kling Lip Sync Audio to Video Node. Syncs mouth movements in a video file to the audio content of an audio file."""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "video": (IO.VIDEO, {}),- "audio": (IO.AUDIO, {}),- "voice_language": model_field_to_node_input(- IO.COMBO,- KlingLipSyncInputObject,+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingLipSyncAudioToVideoNode",+ display_name="Kling Lip Sync Video with Audio",+ category="api node/video/Kling",+ description="Kling Lip Sync Audio to Video Node. Syncs mouth movements in a video file to the audio content of an audio file. When using, ensure that the audio contains clearly distinguishable vocals and that the video contains a distinct face. The audio file should not be larger than 5MB. The video file should not be larger than 100MB, should have height/width between 720px and 1920px, and should be between 2s and 10s in length.",+ inputs=[+ comfy_io.Video.Input("video"),+ comfy_io.Audio.Input("audio"),+ comfy_io.Combo.Input("voice_language",- enum_type=KlingLipSyncVoiceLanguage,- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Kling Lip Sync Audio to Video Node. Syncs mouth movements in a video file to the audio content of an audio file. When using, ensure that the audio contains clearly distinguishable vocals and that the video contains a distinct face. The audio file should not be larger than 5MB. The video file should not be larger than 100MB, should have height/width between 720px and 1920px, and should be between 2s and 10s in length."+ options=[i.value for i in KlingLipSyncVoiceLanguage],+ default="en",+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,video: VideoInput,audio: AudioInput,voice_language: str,- unique_id: Optional[str] = None,- **kwargs,- ):- return await super().api_call(+ ) -> comfy_io.NodeOutput:+ return await execute_lipsync(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,video=video,audio=audio,voice_language=voice_language,- mode="audio2video",- unique_id=unique_id,- **kwargs,+ model_mode="audio2video",)-class KlingLipSyncTextToVideoNode(KlingLipSyncBase):+class KlingLipSyncTextToVideoNode(comfy_io.ComfyNode):"""Kling Lip Sync Text to Video Node. Syncs mouth movements in a video file to a text prompt."""- @staticmethod- def get_voice_config() -> dict[str, tuple[str, str]]:- return {- # English voices- "Melody": ("girlfriend_4_speech02", "en"),- "Sunny": ("genshin_vindi2", "en"),- "Sage": ("zhinen_xuesheng", "en"),- "Ace": ("AOT", "en"),- "Blossom": ("ai_shatang", "en"),- "Peppy": ("genshin_klee2", "en"),- "Dove": ("genshin_kirara", "en"),- "Shine": ("ai_kaiya", "en"),- "Anchor": ("oversea_male1", "en"),- "Lyric": ("ai_chenjiahao_712", "en"),- "Tender": ("chat1_female_new-3", "en"),- "Siren": ("chat_0407_5-1", "en"),- "Zippy": ("cartoon-boy-07", "en"),- "Bud": ("uk_boy1", "en"),- "Sprite": ("cartoon-girl-01", "en"),- "Candy": ("PeppaPig_platform", "en"),- "Beacon": ("ai_huangzhong_712", "en"),- "Rock": ("ai_huangyaoshi_712", "en"),- "Titan": ("ai_laoguowang_712", "en"),- "Grace": ("chengshu_jiejie", "en"),- "Helen": ("you_pingjing", "en"),- "Lore": ("calm_story1", "en"),- "Crag": ("uk_man2", "en"),- "Prattle": ("laopopo_speech02", "en"),- "Hearth": ("heainainai_speech02", "en"),- "The Reader": ("reader_en_m-v1", "en"),- "Commercial Lady": ("commercial_lady_en_f-v1", "en"),- # Chinese voices- "阳光少年": ("genshin_vindi2", "zh"),- "懂事小弟": ("zhinen_xuesheng", "zh"),- "运动少年": ("tiyuxi_xuedi", "zh"),- "青春少女": ("ai_shatang", "zh"),- "温柔小妹": ("genshin_klee2", "zh"),- "元气少女": ("genshin_kirara", "zh"),- "阳光男生": ("ai_kaiya", "zh"),- "幽默小哥": ("tiexin_nanyou", "zh"),- "文艺小哥": ("ai_chenjiahao_712", "zh"),- "甜美邻家": ("girlfriend_1_speech02", "zh"),- "温柔姐姐": ("chat1_female_new-3", "zh"),- "职场女青": ("girlfriend_2_speech02", "zh"),- "活泼男童": ("cartoon-boy-07", "zh"),- "俏皮女童": ("cartoon-girl-01", "zh"),- "稳重老爸": ("ai_huangyaoshi_712", "zh"),- "温柔妈妈": ("you_pingjing", "zh"),- "严肃上司": ("ai_laoguowang_712", "zh"),- "优雅贵妇": ("chengshu_jiejie", "zh"),- "慈祥爷爷": ("zhuxi_speech02", "zh"),- "唠叨爷爷": ("uk_oldman3", "zh"),- "唠叨奶奶": ("laopopo_speech02", "zh"),- "和蔼奶奶": ("heainainai_speech02", "zh"),- "东北老铁": ("dongbeilaotie_speech02", "zh"),- "重庆小伙": ("chongqingxiaohuo_speech02", "zh"),- "四川妹子": ("chuanmeizi_speech02", "zh"),- "潮汕大叔": ("chaoshandashu_speech02", "zh"),- "台湾男生": ("ai_taiwan_man2_speech02", "zh"),- "西安掌柜": ("xianzhanggui_speech02", "zh"),- "天津姐姐": ("tianjinjiejie_speech02", "zh"),- "新闻播报男": ("diyinnansang_DB_CN_M_04-v2", "zh"),- "译制片男": ("yizhipiannan-v1", "zh"),- "撒娇女友": ("tianmeixuemei-v1", "zh"),- "刀片烟嗓": ("daopianyansang-v1", "zh"),- "乖巧正太": ("mengwa-v1", "zh"),- }-@classmethod- def INPUT_TYPES(s):- voice_options = list(s.get_voice_config().keys())- return {- "required": {- "video": (IO.VIDEO, {}),- "text": model_field_to_node_input(- IO.STRING, KlingLipSyncInputObject, "text", multiline=True- ),- "voice": (voice_options, {"default": voice_options[0]}),- "voice_speed": model_field_to_node_input(- IO.FLOAT, KlingLipSyncInputObject, "voice_speed", slider=True- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Kling Lip Sync Text to Video Node. Syncs mouth movements in a video file to a text prompt. The video file should not be larger than 100MB, should have height/width between 720px and 1920px, and should be between 2s and 10s in length."+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingLipSyncTextToVideoNode",+ display_name="Kling Lip Sync Video with Text",+ category="api node/video/Kling",+ description="Kling Lip Sync Text to Video Node. Syncs mouth movements in a video file to a text prompt. The video file should not be larger than 100MB, should have height/width between 720px and 1920px, and should be between 2s and 10s in length.",+ inputs=[+ comfy_io.Video.Input("video"),+ comfy_io.String.Input(+ "text",+ multiline=True,+ tooltip="Text Content for Lip-Sync Video Generation. Required when mode is text2video. Maximum length is 120 characters.",+ ),+ comfy_io.Combo.Input(+ "voice",+ options=list(VOICES_CONFIG.keys()),+ default="Melody",+ ),+ comfy_io.Float.Input(+ "voice_speed",+ default=1,+ min=0.8,+ max=2.0,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Speech Rate. Valid range: 0.8~2.0, accurate to one decimal place.",+ ),+ ],+ outputs=[+ comfy_io.Video.Output(),+ comfy_io.String.Output(display_name="video_id"),+ comfy_io.String.Output(display_name="duration"),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,video: VideoInput,text: str,voice: str,voice_speed: float,- unique_id: Optional[str] = None,- **kwargs,- ):- voice_id, voice_language = KlingLipSyncTextToVideoNode.get_voice_config()[voice]- return await super().api_call(+ ) -> comfy_io.NodeOutput:+ voice_id, voice_language = VOICES_CONFIG[voice]+ return await execute_lipsync(+ auth_kwargs={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,video=video,text=text,voice_language=voice_language,voice_id=voice_id,voice_speed=voice_speed,- mode="text2video",- unique_id=unique_id,- **kwargs,+ model_mode="text2video",)-class KlingImageGenerationBase(KlingNodeBase):- """Kling Image Generation Base Node."""-- RETURN_TYPES = ("IMAGE",)- CATEGORY = "api node/image/Kling"-- def validate_prompt(self, prompt: str, negative_prompt: Optional[str] = None):- if not prompt or len(prompt) > MAX_PROMPT_LENGTH_IMAGE_GEN:- raise ValueError(- f"Prompt must be less than {MAX_PROMPT_LENGTH_IMAGE_GEN} characters"- )- if negative_prompt and len(negative_prompt) > MAX_PROMPT_LENGTH_IMAGE_GEN:- raise ValueError(- f"Negative prompt must be less than {MAX_PROMPT_LENGTH_IMAGE_GEN} characters"- )---class KlingVirtualTryOnNode(KlingImageGenerationBase):+class KlingVirtualTryOnNode(comfy_io.ComfyNode):"""Kling Virtual Try On Node."""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "human_image": (IO.IMAGE, {}),- "cloth_image": (IO.IMAGE, {}),- "model_name": model_field_to_node_input(- IO.COMBO,- KlingVirtualTryOnRequest,+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingVirtualTryOnNode",+ display_name="Kling Virtual Try On",+ category="api node/image/Kling",+ description="Kling Virtual Try On Node. Input a human image and a cloth image to try on the cloth on the human. You can merge multiple clothing item pictures into one image with a white background.",+ inputs=[+ comfy_io.Image.Input("human_image"),+ comfy_io.Image.Input("cloth_image"),+ comfy_io.Combo.Input("model_name",- enum_type=KlingVirtualTryOnModelName,- ),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Kling Virtual Try On Node. Input a human image and a cloth image to try on the cloth on the human. You can merge multiple clothing item pictures into one image with a white background."-- async def get_response(- self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None- ) -> KlingVirtualTryOnResponse:- return await poll_until_finished(- auth_kwargs,- ApiEndpoint(- path=f"{PATH_VIRTUAL_TRY_ON}/{task_id}",- method=HttpMethod.GET,- request_model=EmptyRequest,- response_model=KlingVirtualTryOnResponse,- ),- result_url_extractor=get_images_urls_from_response,- estimated_duration=AVERAGE_DURATION_VIRTUAL_TRY_ON,- node_id=node_id,+ options=[i.value for i in KlingVirtualTryOnModelName],+ default="kolors-virtual-try-on-v1",+ ),+ ],+ outputs=[+ comfy_io.Image.Output(),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,)- async def api_call(- self,+ @classmethod+ async def execute(+ cls,human_image: torch.Tensor,cloth_image: torch.Tensor,model_name: KlingVirtualTryOnModelName,- unique_id: Optional[str] = None,- **kwargs,- ):+ ) -> comfy_io.NodeOutput:+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }initial_operation = SynchronousOperation(endpoint=ApiEndpoint(path=PATH_VIRTUAL_TRY_ON,@@ -1578,113 +1507,99 @@ class KlingVirtualTryOnNode(KlingImageGenerationBase):cloth_image=tensor_to_base64_string(cloth_image),model_name=model_name,),- auth_kwargs=kwargs,+ auth_kwargs=auth,)task_creation_response = await initial_operation.execute()validate_task_creation_response(task_creation_response)task_id = task_creation_response.data.task_id- final_response = await self.get_response(- task_id, auth_kwargs=kwargs, node_id=unique_id+ final_response = await poll_until_finished(+ auth,+ ApiEndpoint(+ path=f"{PATH_VIRTUAL_TRY_ON}/{task_id}",+ method=HttpMethod.GET,+ request_model=EmptyRequest,+ response_model=KlingVirtualTryOnResponse,+ ),+ result_url_extractor=get_images_urls_from_response,+ estimated_duration=AVERAGE_DURATION_VIRTUAL_TRY_ON,+ node_id=cls.hidden.unique_id,)validate_image_result_response(final_response)images = get_images_from_response(final_response)- return (await image_result_to_node_output(images),)+ return comfy_io.NodeOutput(await image_result_to_node_output(images))-class KlingImageGenerationNode(KlingImageGenerationBase):+class KlingImageGenerationNode(comfy_io.ComfyNode):"""Kling Image Generation Node. Generate an image from a text prompt with an optional reference image."""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "prompt": model_field_to_node_input(- IO.STRING,- KlingImageGenerationsRequest,- "prompt",- multiline=True,- max_length=MAX_PROMPT_LENGTH_IMAGE_GEN,- ),- "negative_prompt": model_field_to_node_input(- IO.STRING,- KlingImageGenerationsRequest,- "negative_prompt",- multiline=True,- ),- "image_type": model_field_to_node_input(- IO.COMBO,- KlingImageGenerationsRequest,- "image_reference",- enum_type=KlingImageGenImageReferenceType,- ),- "image_fidelity": model_field_to_node_input(- IO.FLOAT,- KlingImageGenerationsRequest,+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="KlingImageGenerationNode",+ display_name="Kling Image Generation",+ category="api node/image/Kling",+ description="Kling Image Generation Node. Generate an image from a text prompt with an optional reference image.",+ inputs=[+ comfy_io.String.Input("prompt", multiline=True, tooltip="Positive text prompt"),+ comfy_io.String.Input("negative_prompt", multiline=True, tooltip="Negative text prompt"),+ comfy_io.Combo.Input(+ "image_type",+ options=[i.value for i in KlingImageGenImageReferenceType],+ ),+ comfy_io.Float.Input("image_fidelity",- slider=True,+ default=0.5,+ min=0.0,+ max=1.0,step=0.01,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Reference intensity for user-uploaded images",),- "human_fidelity": model_field_to_node_input(- IO.FLOAT,- KlingImageGenerationsRequest,+ comfy_io.Float.Input("human_fidelity",- slider=True,+ default=0.45,+ min=0.0,+ max=1.0,step=0.01,+ display_mode=comfy_io.NumberDisplay.slider,+ tooltip="Subject reference similarity",),- "model_name": model_field_to_node_input(- IO.COMBO,- KlingImageGenerationsRequest,+ comfy_io.Combo.Input("model_name",- enum_type=KlingImageGenModelName,+ options=[i.value for i in KlingImageGenModelName],+ default="kling-v1",),- "aspect_ratio": model_field_to_node_input(- IO.COMBO,- KlingImageGenerationsRequest,+ comfy_io.Combo.Input("aspect_ratio",- enum_type=KlingImageGenAspectRatio,+ options=[i.value for i in KlingImageGenAspectRatio],+ default="16:9",),- "n": model_field_to_node_input(- IO.INT,- KlingImageGenerationsRequest,+ comfy_io.Int.Input("n",- ),- },- "optional": {- "image": (IO.IMAGE, {}),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- DESCRIPTION = "Kling Image Generation Node. Generate an image from a text prompt with an optional reference image."-- async def get_response(- self,- task_id: str,- auth_kwargs: Optional[dict[str, str]],- node_id: Optional[str] = None,- ) -> KlingImageGenerationsResponse:- return await poll_until_finished(- auth_kwargs,- ApiEndpoint(- path=f"{PATH_IMAGE_GENERATIONS}/{task_id}",- method=HttpMethod.GET,- request_model=EmptyRequest,- response_model=KlingImageGenerationsResponse,- ),- result_url_extractor=get_images_urls_from_response,- estimated_duration=AVERAGE_DURATION_IMAGE_GEN,- node_id=node_id,+ default=1,+ min=1,+ max=9,+ tooltip="Number of generated images",+ ),+ comfy_io.Image.Input("image", optional=True),+ ],+ outputs=[+ comfy_io.Image.Output(),+ ],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,)- async def api_call(- self,+ @classmethod+ async def execute(+ cls,model_name: KlingImageGenModelName,prompt: str,negative_prompt: str,@@ -1694,10 +1609,9 @@ class KlingImageGenerationNode(KlingImageGenerationBase):n: int,aspect_ratio: KlingImageGenAspectRatio,image: Optional[torch.Tensor] = None,- unique_id: Optional[str] = None,- **kwargs,- ):- self.validate_prompt(prompt, negative_prompt)+ ) -> comfy_io.NodeOutput:+ validate_string(prompt, field_name="prompt", min_length=1, max_length=MAX_PROMPT_LENGTH_IMAGE_GEN)+ validate_string(negative_prompt, field_name="negative_prompt", max_length=MAX_PROMPT_LENGTH_IMAGE_GEN)if image is None:image_type = None@@ -1706,6 +1620,10 @@ class KlingImageGenerationNode(KlingImageGenerationBase):else:image = tensor_to_base64_string(image)+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }initial_operation = SynchronousOperation(endpoint=ApiEndpoint(path=PATH_IMAGE_GENERATIONS,@@ -1724,50 +1642,50 @@ class KlingImageGenerationNode(KlingImageGenerationBase):n=n,aspect_ratio=aspect_ratio,),- auth_kwargs=kwargs,+ auth_kwargs=auth,)task_creation_response = await initial_operation.execute()validate_task_creation_response(task_creation_response)task_id = task_creation_response.data.task_id- final_response = await self.get_response(- task_id, auth_kwargs=kwargs, node_id=unique_id+ final_response = await poll_until_finished(+ auth,+ ApiEndpoint(+ path=f"{PATH_IMAGE_GENERATIONS}/{task_id}",+ method=HttpMethod.GET,+ request_model=EmptyRequest,+ response_model=KlingImageGenerationsResponse,+ ),+ result_url_extractor=get_images_urls_from_response,+ estimated_duration=AVERAGE_DURATION_IMAGE_GEN,+ node_id=cls.hidden.unique_id,)validate_image_result_response(final_response)images = get_images_from_response(final_response)- return (await image_result_to_node_output(images),)---NODE_CLASS_MAPPINGS = {- "KlingCameraControls": KlingCameraControls,- "KlingTextToVideoNode": KlingTextToVideoNode,- "KlingImage2VideoNode": KlingImage2VideoNode,- "KlingCameraControlI2VNode": KlingCameraControlI2VNode,- "KlingCameraControlT2VNode": KlingCameraControlT2VNode,- "KlingStartEndFrameNode": KlingStartEndFrameNode,- "KlingVideoExtendNode": KlingVideoExtendNode,- "KlingLipSyncAudioToVideoNode": KlingLipSyncAudioToVideoNode,- "KlingLipSyncTextToVideoNode": KlingLipSyncTextToVideoNode,- "KlingVirtualTryOnNode": KlingVirtualTryOnNode,- "KlingImageGenerationNode": KlingImageGenerationNode,- "KlingSingleImageVideoEffectNode": KlingSingleImageVideoEffectNode,- "KlingDualCharacterVideoEffectNode": KlingDualCharacterVideoEffectNode,-}+ return comfy_io.NodeOutput(await image_result_to_node_output(images))+++class KlingExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[comfy_io.ComfyNode]]:+ return [+ KlingCameraControls,+ KlingTextToVideoNode,+ KlingImage2VideoNode,+ KlingCameraControlI2VNode,+ KlingCameraControlT2VNode,+ KlingStartEndFrameNode,+ KlingVideoExtendNode,+ KlingLipSyncAudioToVideoNode,+ KlingLipSyncTextToVideoNode,+ KlingVirtualTryOnNode,+ KlingImageGenerationNode,+ KlingSingleImageVideoEffectNode,+ KlingDualCharacterVideoEffectNode,+ ]-NODE_DISPLAY_NAME_MAPPINGS = {- "KlingCameraControls": "Kling Camera Controls",- "KlingTextToVideoNode": "Kling Text to Video",- "KlingImage2VideoNode": "Kling Image to Video",- "KlingCameraControlI2VNode": "Kling Image to Video (Camera Control)",- "KlingCameraControlT2VNode": "Kling Text to Video (Camera Control)",- "KlingStartEndFrameNode": "Kling Start-End Frame to Video",- "KlingVideoExtendNode": "Kling Video Extend",- "KlingLipSyncAudioToVideoNode": "Kling Lip Sync Video with Audio",- "KlingLipSyncTextToVideoNode": "Kling Lip Sync Video with Text",- "KlingVirtualTryOnNode": "Kling Virtual Try On",- "KlingImageGenerationNode": "Kling Image Generation",- "KlingSingleImageVideoEffectNode": "Kling Video Effects",- "KlingDualCharacterVideoEffectNode": "Kling Dual Character Video Effects",-}++async def comfy_entrypoint() -> KlingExtension:+ return KlingExtension()