Delete comfy_api_nodes

comfy_api_nodes/README.md

@@ -1,65 +0,0 @@
-# ComfyUI API Nodes
-
-## Introduction 
-
-Below are a collection of nodes that work by calling external APIs. More information available in our [docs](https://docs.comfy.org/tutorials/api-nodes/overview#api-nodes).
-
-## Development
-
-While developing, you should be testing against the Staging environment. To test against staging:
-
-**Install ComfyUI_frontend**
-
-Follow the instructions [here](https://github.com/Comfy-Org/ComfyUI_frontend) to start the frontend server. By default, it will connect to Staging authentication. 
-
-> **Hint:** If you use --front-end-version argument for ComfyUI, it will use production authentication.
-
-```bash
-python run main.py --comfy-api-base https://stagingapi.comfy.org
-```
-
-To authenticate to staging, please login and then ask one of Comfy Org team to whitelist you for access to staging.
-
-API stubs are generated through automatic codegen tools from OpenAPI definitions. Since the Comfy Org OpenAPI definition contains many things from the Comfy Registry as well, we use redocly/cli to filter out only the paths relevant for API nodes.
-
-### Redocly Instructions 
-
-**Tip**
-When developing locally, use the `redocly-dev.yaml` file to generate pydantic models. This lets you use stubs for APIs that are not marked `Released` yet.
-
-Before your API node PR merges, make sure to add the `Released` tag to the `openapi.yaml` file and test in staging.
-
-```bash
-# Download the OpenAPI file from staging server.
-curl -o openapi.yaml https://stagingapi.comfy.org/openapi
-
-# Filter out unneeded API definitions.
-npm install -g @redocly/cli
-redocly bundle openapi.yaml --output filtered-openapi.yaml --config comfy_api_nodes/redocly-dev.yaml --remove-unused-components
-
-# Generate the pydantic datamodels for validation.
-datamodel-codegen --use-subclass-enum --field-constraints --strict-types bytes --input filtered-openapi.yaml --output comfy_api_nodes/apis/__init__.py --output-model-type pydantic_v2.BaseModel
-
-```
-
-
-# Merging to Master
-
-Before merging to comfyanonymous/ComfyUI master, follow these steps:
-
-1. Add the "Released" tag to the ComfyUI OpenAPI yaml file for each endpoint you are using in the nodes. 
-1. Make sure the ComfyUI API is deployed to prod with your changes.
-1. Run the code generation again with `redocly.yaml` and the production OpenAPI yaml file.
-
-```bash
-# Download the OpenAPI file from prod server.
-curl -o openapi.yaml https://api.comfy.org/openapi
-
-# Filter out unneeded API definitions.
-npm install -g @redocly/cli
-redocly bundle openapi.yaml --output filtered-openapi.yaml --config comfy_api_nodes/redocly.yaml --remove-unused-components
-
-# Generate the pydantic datamodels for validation.
-datamodel-codegen --use-subclass-enum --field-constraints --strict-types bytes --input filtered-openapi.yaml --output comfy_api_nodes/apis/__init__.py --output-model-type pydantic_v2.BaseModel
-
-```

comfy_api_nodes/apinode_utils.py

@@ -1,678 +0,0 @@
-from __future__ import annotations
-import io
-import logging
-import mimetypes
-from typing import Optional, Union
-from comfy.utils import common_upscale
-from comfy_api.input_impl import VideoFromFile
-from comfy_api.util import VideoContainer, VideoCodec
-from comfy_api.input.video_types import VideoInput
-from comfy_api.input.basic_types import AudioInput
-from comfy_api_nodes.apis.client import (
-    ApiClient,
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    UploadRequest,
-    UploadResponse,
-)
-from server import PromptServer
-
-
-import numpy as np
-from PIL import Image
-import requests
-import torch
-import math
-import base64
-import uuid
-from io import BytesIO
-import av
-
-
-def download_url_to_video_output(video_url: str, timeout: int = None) -> VideoFromFile:
-    """Downloads a video from a URL and returns a `VIDEO` output.
-
-    Args:
-        video_url: The URL of the video to download.
-
-    Returns:
-        A Comfy node `VIDEO` output.
-    """
-    video_io = download_url_to_bytesio(video_url, timeout)
-    if video_io is None:
-        error_msg = f"Failed to download video from {video_url}"
-        logging.error(error_msg)
-        raise ValueError(error_msg)
-    return VideoFromFile(video_io)
-
-
-def downscale_image_tensor(image, total_pixels=1536 * 1024) -> torch.Tensor:
-    """Downscale input image tensor to roughly the specified total pixels."""
-    samples = image.movedim(-1, 1)
-    total = int(total_pixels)
-    scale_by = math.sqrt(total / (samples.shape[3] * samples.shape[2]))
-    if scale_by >= 1:
-        return image
-    width = round(samples.shape[3] * scale_by)
-    height = round(samples.shape[2] * scale_by)
-
-    s = common_upscale(samples, width, height, "lanczos", "disabled")
-    s = s.movedim(1, -1)
-    return s
-
-
-def validate_and_cast_response(
-    response, timeout: int = None, node_id: Union[str, None] = None
-) -> torch.Tensor:
-    """Validates and casts a response to a torch.Tensor.
-
-    Args:
-        response: The response to validate and cast.
-        timeout: Request timeout in seconds. Defaults to None (no timeout).
-
-    Returns:
-        A torch.Tensor representing the image (1, H, W, C).
-
-    Raises:
-        ValueError: If the response is not valid.
-    """
-    # validate raw JSON response
-    data = response.data
-    if not data or len(data) == 0:
-        raise ValueError("No images returned from API endpoint")
-
-    # Initialize list to store image tensors
-    image_tensors: list[torch.Tensor] = []
-
-    # Process each image in the data array
-    for image_data in data:
-        image_url = image_data.url
-        b64_data = image_data.b64_json
-
-        if not image_url and not b64_data:
-            raise ValueError("No image was generated in the response")
-
-        if b64_data:
-            img_data = base64.b64decode(b64_data)
-            img = Image.open(io.BytesIO(img_data))
-
-        elif image_url:
-            if node_id:
-                PromptServer.instance.send_progress_text(
-                    f"Result URL: {image_url}", node_id
-                )
-            img_response = requests.get(image_url, timeout=timeout)
-            if img_response.status_code != 200:
-                raise ValueError("Failed to download the image")
-            img = Image.open(io.BytesIO(img_response.content))
-
-        img = img.convert("RGBA")
-
-        # Convert to numpy array, normalize to float32 between 0 and 1
-        img_array = np.array(img).astype(np.float32) / 255.0
-        img_tensor = torch.from_numpy(img_array)
-
-        # Add to list of tensors
-        image_tensors.append(img_tensor)
-
-    return torch.stack(image_tensors, dim=0)
-
-
-def validate_aspect_ratio(
-    aspect_ratio: str,
-    minimum_ratio: float,
-    maximum_ratio: float,
-    minimum_ratio_str: str,
-    maximum_ratio_str: str,
-) -> float:
-    """Validates and casts an aspect ratio string to a float.
-
-    Args:
-        aspect_ratio: The aspect ratio string to validate.
-        minimum_ratio: The minimum aspect ratio.
-        maximum_ratio: The maximum aspect ratio.
-        minimum_ratio_str: The minimum aspect ratio string.
-        maximum_ratio_str: The maximum aspect ratio string.
-
-    Returns:
-        The validated and cast aspect ratio.
-
-    Raises:
-        Exception: If the aspect ratio is not valid.
-    """
-    # get ratio values
-    numbers = aspect_ratio.split(":")
-    if len(numbers) != 2:
-        raise TypeError(
-            f"Aspect ratio must be in the format X:Y, such as 16:9, but was {aspect_ratio}."
-        )
-    try:
-        numerator = int(numbers[0])
-        denominator = int(numbers[1])
-    except ValueError as exc:
-        raise TypeError(
-            f"Aspect ratio must contain numbers separated by ':', such as 16:9, but was {aspect_ratio}."
-        ) from exc
-    calculated_ratio = numerator / denominator
-    # if not close to minimum and maximum, check bounds
-    if not math.isclose(calculated_ratio, minimum_ratio) or not math.isclose(
-        calculated_ratio, maximum_ratio
-    ):
-        if calculated_ratio < minimum_ratio:
-            raise TypeError(
-                f"Aspect ratio cannot reduce to any less than {minimum_ratio_str} ({minimum_ratio}), but was {aspect_ratio} ({calculated_ratio})."
-            )
-        elif calculated_ratio > maximum_ratio:
-            raise TypeError(
-                f"Aspect ratio cannot reduce to any greater than {maximum_ratio_str} ({maximum_ratio}), but was {aspect_ratio} ({calculated_ratio})."
-            )
-    return aspect_ratio
-
-
-def mimetype_to_extension(mime_type: str) -> str:
-    """Converts a MIME type to a file extension."""
-    return mime_type.split("/")[-1].lower()
-
-
-def download_url_to_bytesio(url: str, timeout: int = None) -> BytesIO:
-    """Downloads content from a URL using requests and returns it as BytesIO.
-
-    Args:
-        url: The URL to download.
-        timeout: Request timeout in seconds. Defaults to None (no timeout).
-
-    Returns:
-        BytesIO object containing the downloaded content.
-    """
-    response = requests.get(url, stream=True, timeout=timeout)
-    response.raise_for_status()  # Raises HTTPError for bad responses (4XX or 5XX)
-    return BytesIO(response.content)
-
-
-def bytesio_to_image_tensor(image_bytesio: BytesIO, mode: str = "RGBA") -> torch.Tensor:
-    """Converts image data from BytesIO to a torch.Tensor.
-
-    Args:
-        image_bytesio: BytesIO object containing the image data.
-        mode: The PIL mode to convert the image to (e.g., "RGB", "RGBA").
-
-    Returns:
-        A torch.Tensor representing the image (1, H, W, C).
-
-    Raises:
-        PIL.UnidentifiedImageError: If the image data cannot be identified.
-        ValueError: If the specified mode is invalid.
-    """
-    image = Image.open(image_bytesio)
-    image = image.convert(mode)
-    image_array = np.array(image).astype(np.float32) / 255.0
-    return torch.from_numpy(image_array).unsqueeze(0)
-
-
-def download_url_to_image_tensor(url: str, timeout: int = None) -> torch.Tensor:
-    """Downloads an image from a URL and returns a [B, H, W, C] tensor."""
-    image_bytesio = download_url_to_bytesio(url, timeout)
-    return bytesio_to_image_tensor(image_bytesio)
-
-
-def process_image_response(response: requests.Response) -> torch.Tensor:
-    """Uses content from a Response object and converts it to a torch.Tensor"""
-    return bytesio_to_image_tensor(BytesIO(response.content))
-
-
-def _tensor_to_pil(image: torch.Tensor, total_pixels: int = 2048 * 2048) -> Image.Image:
-    """Converts a single torch.Tensor image [H, W, C] to a PIL Image, optionally downscaling."""
-    if len(image.shape) > 3:
-        image = image[0]
-    # TODO: remove alpha if not allowed and present
-    input_tensor = image.cpu()
-    input_tensor = downscale_image_tensor(
-        input_tensor.unsqueeze(0), total_pixels=total_pixels
-    ).squeeze()
-    image_np = (input_tensor.numpy() * 255).astype(np.uint8)
-    img = Image.fromarray(image_np)
-    return img
-
-
-def _pil_to_bytesio(img: Image.Image, mime_type: str = "image/png") -> BytesIO:
-    """Converts a PIL Image to a BytesIO object."""
-    if not mime_type:
-        mime_type = "image/png"
-
-    img_byte_arr = io.BytesIO()
-    # Derive PIL format from MIME type (e.g., 'image/png' -> 'PNG')
-    pil_format = mime_type.split("/")[-1].upper()
-    if pil_format == "JPG":
-        pil_format = "JPEG"
-    img.save(img_byte_arr, format=pil_format)
-    img_byte_arr.seek(0)
-    return img_byte_arr
-
-
-def tensor_to_bytesio(
-    image: torch.Tensor,
-    name: Optional[str] = None,
-    total_pixels: int = 2048 * 2048,
-    mime_type: str = "image/png",
-) -> BytesIO:
-    """Converts a torch.Tensor image to a named BytesIO object.
-
-    Args:
-        image: Input torch.Tensor image.
-        name: Optional filename for the BytesIO object.
-        total_pixels: Maximum total pixels for potential downscaling.
-        mime_type: Target image MIME type (e.g., 'image/png', 'image/jpeg', 'image/webp', 'video/mp4').
-
-    Returns:
-        Named BytesIO object containing the image data.
-    """
-    if not mime_type:
-        mime_type = "image/png"
-
-    pil_image = _tensor_to_pil(image, total_pixels=total_pixels)
-    img_binary = _pil_to_bytesio(pil_image, mime_type=mime_type)
-    img_binary.name = (
-        f"{name if name else uuid.uuid4()}.{mimetype_to_extension(mime_type)}"
-    )
-    return img_binary
-
-
-def tensor_to_base64_string(
-    image_tensor: torch.Tensor,
-    total_pixels: int = 2048 * 2048,
-    mime_type: str = "image/png",
-) -> str:
-    """Convert [B, H, W, C] or [H, W, C] tensor to a base64 string.
-
-    Args:
-        image_tensor: Input torch.Tensor image.
-        total_pixels: Maximum total pixels for potential downscaling.
-        mime_type: Target image MIME type (e.g., 'image/png', 'image/jpeg', 'image/webp', 'video/mp4').
-
-    Returns:
-        Base64 encoded string of the image.
-    """
-    pil_image = _tensor_to_pil(image_tensor, total_pixels=total_pixels)
-    img_byte_arr = _pil_to_bytesio(pil_image, mime_type=mime_type)
-    img_bytes = img_byte_arr.getvalue()
-    # Encode bytes to base64 string
-    base64_encoded_string = base64.b64encode(img_bytes).decode("utf-8")
-    return base64_encoded_string
-
-
-def tensor_to_data_uri(
-    image_tensor: torch.Tensor,
-    total_pixels: int = 2048 * 2048,
-    mime_type: str = "image/png",
-) -> str:
-    """Converts a tensor image to a Data URI string.
-
-    Args:
-        image_tensor: Input torch.Tensor image.
-        total_pixels: Maximum total pixels for potential downscaling.
-        mime_type: Target image MIME type (e.g., 'image/png', 'image/jpeg', 'image/webp').
-
-    Returns:
-        Data URI string (e.g., 'data:image/png;base64,...').
-    """
-    base64_string = tensor_to_base64_string(image_tensor, total_pixels, mime_type)
-    return f"data:{mime_type};base64,{base64_string}"
-
-
-def text_filepath_to_base64_string(filepath: str) -> str:
-    """Converts a text file to a base64 string."""
-    with open(filepath, "rb") as f:
-        file_content = f.read()
-    return base64.b64encode(file_content).decode("utf-8")
-
-
-def text_filepath_to_data_uri(filepath: str) -> str:
-    """Converts a text file to a data URI."""
-    base64_string = text_filepath_to_base64_string(filepath)
-    mime_type, _ = mimetypes.guess_type(filepath)
-    if mime_type is None:
-        mime_type = "application/octet-stream"
-    return f"data:{mime_type};base64,{base64_string}"
-
-
-def upload_file_to_comfyapi(
-    file_bytes_io: BytesIO,
-    filename: str,
-    upload_mime_type: str,
-    auth_kwargs: Optional[dict[str, str]] = None,
-) -> str:
-    """
-    Uploads a single file to ComfyUI API and returns its download URL.
-
-    Args:
-        file_bytes_io: BytesIO object containing the file data.
-        filename: The filename of the file.
-        upload_mime_type: MIME type of the file.
-        auth_kwargs: Optional authentication token(s).
-
-    Returns:
-        The download URL for the uploaded file.
-    """
-    request_object = UploadRequest(file_name=filename, content_type=upload_mime_type)
-    operation = SynchronousOperation(
-        endpoint=ApiEndpoint(
-            path="/customers/storage",
-            method=HttpMethod.POST,
-            request_model=UploadRequest,
-            response_model=UploadResponse,
-        ),
-        request=request_object,
-        auth_kwargs=auth_kwargs,
-    )
-
-    response: UploadResponse = operation.execute()
-    upload_response = ApiClient.upload_file(
-        response.upload_url, file_bytes_io, content_type=upload_mime_type
-    )
-    upload_response.raise_for_status()
-
-    return response.download_url
-
-
-def video_to_base64_string(
-    video: VideoInput,
-    container_format: VideoContainer = None,
-    codec: VideoCodec = None
-) -> str:
-    """
-    Converts a video input to a base64 string.
-
-    Args:
-        video: The video input to convert
-        container_format: Optional container format to use (defaults to video.container if available)
-        codec: Optional codec to use (defaults to video.codec if available)
-    """
-    video_bytes_io = io.BytesIO()
-
-    # Use provided format/codec if specified, otherwise use video's own if available
-    format_to_use = container_format if container_format is not None else getattr(video, 'container', VideoContainer.MP4)
-    codec_to_use = codec if codec is not None else getattr(video, 'codec', VideoCodec.H264)
-
-    video.save_to(video_bytes_io, format=format_to_use, codec=codec_to_use)
-    video_bytes_io.seek(0)
-    return base64.b64encode(video_bytes_io.getvalue()).decode("utf-8")
-
-
-def upload_video_to_comfyapi(
-    video: VideoInput,
-    auth_kwargs: Optional[dict[str, str]] = None,
-    container: VideoContainer = VideoContainer.MP4,
-    codec: VideoCodec = VideoCodec.H264,
-    max_duration: Optional[int] = None,
-) -> str:
-    """
-    Uploads a single video to ComfyUI API and returns its download URL.
-    Uses the specified container and codec for saving the video before upload.
-
-    Args:
-        video: VideoInput object (Comfy VIDEO type).
-        auth_kwargs: Optional authentication token(s).
-        container: The video container format to use (default: MP4).
-        codec: The video codec to use (default: H264).
-        max_duration: Optional maximum duration of the video in seconds. If the video is longer than this, an error will be raised.
-
-    Returns:
-        The download URL for the uploaded video file.
-    """
-    if max_duration is not None:
-        try:
-            actual_duration = video.duration_seconds
-            if actual_duration is not None and actual_duration > max_duration:
-                raise ValueError(
-                    f"Video duration ({actual_duration:.2f}s) exceeds the maximum allowed ({max_duration}s)."
-                )
-        except Exception as e:
-            logging.error(f"Error getting video duration: {e}")
-            raise ValueError(f"Could not verify video duration from source: {e}") from e
-
-    upload_mime_type = f"video/{container.value.lower()}"
-    filename = f"uploaded_video.{container.value.lower()}"
-
-    # Convert VideoInput to BytesIO using specified container/codec
-    video_bytes_io = io.BytesIO()
-    video.save_to(video_bytes_io, format=container, codec=codec)
-    video_bytes_io.seek(0)
-
-    return upload_file_to_comfyapi(
-        video_bytes_io, filename, upload_mime_type, auth_kwargs
-    )
-
-
-def audio_tensor_to_contiguous_ndarray(waveform: torch.Tensor) -> np.ndarray:
-    """
-    Prepares audio waveform for av library by converting to a contiguous numpy array.
-
-    Args:
-        waveform: a tensor of shape (1, channels, samples) derived from a Comfy `AUDIO` type.
-
-    Returns:
-        Contiguous numpy array of the audio waveform. If the audio was batched,
-            the first item is taken.
-    """
-    if waveform.ndim != 3 or waveform.shape[0] != 1:
-        raise ValueError("Expected waveform tensor shape (1, channels, samples)")
-
-    # If batch is > 1, take first item
-    if waveform.shape[0] > 1:
-        waveform = waveform[0]
-
-    # Prepare for av: remove batch dim, move to CPU, make contiguous, convert to numpy array
-    audio_data_np = waveform.squeeze(0).cpu().contiguous().numpy()
-    if audio_data_np.dtype != np.float32:
-        audio_data_np = audio_data_np.astype(np.float32)
-
-    return audio_data_np
-
-
-def audio_ndarray_to_bytesio(
-    audio_data_np: np.ndarray,
-    sample_rate: int,
-    container_format: str = "mp4",
-    codec_name: str = "aac",
-) -> BytesIO:
-    """
-    Encodes a numpy array of audio data into a BytesIO object.
-    """
-    audio_bytes_io = io.BytesIO()
-    with av.open(audio_bytes_io, mode="w", format=container_format) as output_container:
-        audio_stream = output_container.add_stream(codec_name, rate=sample_rate)
-        frame = av.AudioFrame.from_ndarray(
-            audio_data_np,
-            format="fltp",
-            layout="stereo" if audio_data_np.shape[0] > 1 else "mono",
-        )
-        frame.sample_rate = sample_rate
-        frame.pts = 0
-
-        for packet in audio_stream.encode(frame):
-            output_container.mux(packet)
-
-        # Flush stream
-        for packet in audio_stream.encode(None):
-            output_container.mux(packet)
-
-    audio_bytes_io.seek(0)
-    return audio_bytes_io
-
-
-def upload_audio_to_comfyapi(
-    audio: AudioInput,
-    auth_kwargs: Optional[dict[str, str]] = None,
-    container_format: str = "mp4",
-    codec_name: str = "aac",
-    mime_type: str = "audio/mp4",
-    filename: str = "uploaded_audio.mp4",
-) -> str:
-    """
-    Uploads a single audio input to ComfyUI API and returns its download URL.
-    Encodes the raw waveform into the specified format before uploading.
-
-    Args:
-        audio: a Comfy `AUDIO` type (contains waveform tensor and sample_rate)
-        auth_kwargs: Optional authentication token(s).
-
-    Returns:
-        The download URL for the uploaded audio file.
-    """
-    sample_rate: int = audio["sample_rate"]
-    waveform: torch.Tensor = audio["waveform"]
-    audio_data_np = audio_tensor_to_contiguous_ndarray(waveform)
-    audio_bytes_io = audio_ndarray_to_bytesio(
-        audio_data_np, sample_rate, container_format, codec_name
-    )
-
-    return upload_file_to_comfyapi(audio_bytes_io, filename, mime_type, auth_kwargs)
-
-
-def audio_to_base64_string(
-    audio: AudioInput, container_format: str = "mp4", codec_name: str = "aac"
-) -> str:
-    """Converts an audio input to a base64 string."""
-    sample_rate: int = audio["sample_rate"]
-    waveform: torch.Tensor = audio["waveform"]
-    audio_data_np = audio_tensor_to_contiguous_ndarray(waveform)
-    audio_bytes_io = audio_ndarray_to_bytesio(
-        audio_data_np, sample_rate, container_format, codec_name
-    )
-    audio_bytes = audio_bytes_io.getvalue()
-    return base64.b64encode(audio_bytes).decode("utf-8")
-
-
-def upload_images_to_comfyapi(
-    image: torch.Tensor,
-    max_images=8,
-    auth_kwargs: Optional[dict[str, str]] = None,
-    mime_type: Optional[str] = None,
-) -> list[str]:
-    """
-    Uploads images to ComfyUI API and returns download URLs.
-    To upload multiple images, stack them in the batch dimension first.
-
-    Args:
-        image: Input torch.Tensor image.
-        max_images: Maximum number of images to upload.
-        auth_kwargs: Optional authentication token(s).
-        mime_type: Optional MIME type for the image.
-    """
-    # if batch, try to upload each file if max_images is greater than 0
-    idx_image = 0
-    download_urls: list[str] = []
-    is_batch = len(image.shape) > 3
-    batch_length = 1
-    if is_batch:
-        batch_length = image.shape[0]
-    while True:
-        curr_image = image
-        if len(image.shape) > 3:
-            curr_image = image[idx_image]
-        # get BytesIO version of image
-        img_binary = tensor_to_bytesio(curr_image, mime_type=mime_type)
-        # first, request upload/download urls from comfy API
-        if not mime_type:
-            request_object = UploadRequest(file_name=img_binary.name)
-        else:
-            request_object = UploadRequest(
-                file_name=img_binary.name, content_type=mime_type
-            )
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/customers/storage",
-                method=HttpMethod.POST,
-                request_model=UploadRequest,
-                response_model=UploadResponse,
-            ),
-            request=request_object,
-            auth_kwargs=auth_kwargs,
-        )
-        response = operation.execute()
-
-        upload_response = ApiClient.upload_file(
-            response.upload_url, img_binary, content_type=mime_type
-        )
-        # verify success
-        try:
-            upload_response.raise_for_status()
-        except requests.exceptions.HTTPError as e:
-            raise ValueError(f"Could not upload one or more images: {e}") from e
-        # add download_url to list
-        download_urls.append(response.download_url)
-
-        idx_image += 1
-        # stop uploading additional files if done
-        if is_batch and max_images > 0:
-            if idx_image >= max_images:
-                break
-            if idx_image >= batch_length:
-                break
-    return download_urls
-
-
-def resize_mask_to_image(
-    mask: torch.Tensor,
-    image: torch.Tensor,
-    upscale_method="nearest-exact",
-    crop="disabled",
-    allow_gradient=True,
-    add_channel_dim=False,
-):
-    """
-    Resize mask to be the same dimensions as an image, while maintaining proper format for API calls.
-    """
-    _, H, W, _ = image.shape
-    mask = mask.unsqueeze(-1)
-    mask = mask.movedim(-1, 1)
-    mask = common_upscale(
-        mask, width=W, height=H, upscale_method=upscale_method, crop=crop
-    )
-    mask = mask.movedim(1, -1)
-    if not add_channel_dim:
-        mask = mask.squeeze(-1)
-    if not allow_gradient:
-        mask = (mask > 0.5).float()
-    return mask
-
-
-def validate_string(
-    string: str,
-    strip_whitespace=True,
-    field_name="prompt",
-    min_length=None,
-    max_length=None,
-):
-    if string is None:
-        raise Exception(f"Field '{field_name}' cannot be empty.")
-    if strip_whitespace:
-        string = string.strip()
-    if min_length and len(string) < min_length:
-        raise Exception(
-            f"Field '{field_name}' cannot be shorter than {min_length} characters; was {len(string)} characters long."
-        )
-    if max_length and len(string) > max_length:
-        raise Exception(
-            f" Field '{field_name} cannot be longer than {max_length} characters; was {len(string)} characters long."
-        )
-
-
-def image_tensor_pair_to_batch(
-    image1: torch.Tensor, image2: torch.Tensor
-) -> torch.Tensor:
-    """
-    Converts a pair of image tensors to a batch tensor.
-    If the images are not the same size, the smaller image is resized to
-    match the larger image.
-    """
-    if image1.shape[1:] != image2.shape[1:]:
-        image2 = common_upscale(
-            image2.movedim(-1, 1),
-            image1.shape[2],
-            image1.shape[1],
-            "bilinear",
-            "center",
-        ).movedim(1, -1)
-    return torch.cat((image1, image2), dim=0)

comfy_api_nodes/apis/PixverseController.py

@@ -1,17 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  filtered-openapi.yaml
-#   timestamp: 2025-04-29T23:44:54+00:00
-
-from __future__ import annotations
-
-from typing import Optional
-
-from pydantic import BaseModel
-
-from . import PixverseDto
-
-
-class ResponseData(BaseModel):
-    ErrCode: Optional[int] = None
-    ErrMsg: Optional[str] = None
-    Resp: Optional[PixverseDto.V2OpenAPII2VResp] = None

comfy_api_nodes/apis/PixverseDto.py

@@ -1,57 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  filtered-openapi.yaml
-#   timestamp: 2025-04-29T23:44:54+00:00
-
-from __future__ import annotations
-
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class V2OpenAPII2VResp(BaseModel):
-    video_id: Optional[int] = Field(None, description='Video_id')
-
-
-class V2OpenAPIT2VReq(BaseModel):
-    aspect_ratio: str = Field(
-        ..., description='Aspect ratio (16:9, 4:3, 1:1, 3:4, 9:16)', examples=['16:9']
-    )
-    duration: int = Field(
-        ...,
-        description='Video duration (5, 8 seconds, --model=v3.5 only allows 5,8; --quality=1080p does not support 8s)',
-        examples=[5],
-    )
-    model: str = Field(
-        ..., description='Model version (only supports v3.5)', examples=['v3.5']
-    )
-    motion_mode: Optional[str] = Field(
-        'normal',
-        description='Motion mode (normal, fast, --fast only available when duration=5; --quality=1080p does not support fast)',
-        examples=['normal'],
-    )
-    negative_prompt: Optional[str] = Field(
-        None, description='Negative prompt\n', max_length=2048
-    )
-    prompt: str = Field(..., description='Prompt', max_length=2048)
-    quality: str = Field(
-        ...,
-        description='Video quality ("360p"(Turbo model), "540p", "720p", "1080p")',
-        examples=['540p'],
-    )
-    seed: Optional[int] = Field(None, description='Random seed, range: 0 - 2147483647')
-    style: Optional[str] = Field(
-        None,
-        description='Style (effective when model=v3.5, "anime", "3d_animation", "clay", "comic", "cyberpunk") Do not include style parameter unless needed',
-        examples=['anime'],
-    )
-    template_id: Optional[int] = Field(
-        None,
-        description='Template ID (template_id must be activated before use)',
-        examples=[302325299692608],
-    )
-    water_mark: Optional[bool] = Field(
-        False,
-        description='Watermark (true: add watermark, false: no watermark)',
-        examples=[False],
-    )

comfy_api_nodes/apis/bfl_api.py

@@ -1,174 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel, Field, confloat, conint
-
-
-class BFLOutputFormat(str, Enum):
-    png = 'png'
-    jpeg = 'jpeg'
-
-
-class BFLFluxExpandImageRequest(BaseModel):
-    prompt: str = Field(..., description='The description of the changes you want to make. This text guides the expansion process, allowing you to specify features, styles, or modifications for the expanded areas.')
-    prompt_upsampling: Optional[bool] = Field(
-        None, description='Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation.'
-    )
-    seed: Optional[int] = Field(None, description='The seed value for reproducibility.')
-    top: conint(ge=0, le=2048) = Field(..., description='Number of pixels to expand at the top of the image')
-    bottom: conint(ge=0, le=2048) = Field(..., description='Number of pixels to expand at the bottom of the image')
-    left: conint(ge=0, le=2048) = Field(..., description='Number of pixels to expand at the left side of the image')
-    right: conint(ge=0, le=2048) = Field(..., description='Number of pixels to expand at the right side of the image')
-    steps: conint(ge=15, le=50) = Field(..., description='Number of steps for the image generation process')
-    guidance: confloat(ge=1.5, le=100) = Field(..., description='Guidance strength for the image generation process')
-    safety_tolerance: Optional[conint(ge=0, le=6)] = Field(
-        6, description='Tolerance level for input and output moderation. Between 0 and 6, 0 being most strict, 6 being least strict. Defaults to 2.'
-    )
-    output_format: Optional[BFLOutputFormat] = Field(
-        BFLOutputFormat.png, description="Output format for the generated image. Can be 'jpeg' or 'png'.", examples=['png']
-    )
-    image: str = Field(None, description='A Base64-encoded string representing the image you wish to expand')
-
-
-class BFLFluxFillImageRequest(BaseModel):
-    prompt: str = Field(..., description='The description of the changes you want to make. This text guides the expansion process, allowing you to specify features, styles, or modifications for the expanded areas.')
-    prompt_upsampling: Optional[bool] = Field(
-        None, description='Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation.'
-    )
-    seed: Optional[int] = Field(None, description='The seed value for reproducibility.')
-    steps: conint(ge=15, le=50) = Field(..., description='Number of steps for the image generation process')
-    guidance: confloat(ge=1.5, le=100) = Field(..., description='Guidance strength for the image generation process')
-    safety_tolerance: Optional[conint(ge=0, le=6)] = Field(
-        6, description='Tolerance level for input and output moderation. Between 0 and 6, 0 being most strict, 6 being least strict. Defaults to 2.'
-    )
-    output_format: Optional[BFLOutputFormat] = Field(
-        BFLOutputFormat.png, description="Output format for the generated image. Can be 'jpeg' or 'png'.", examples=['png']
-    )
-    image: str = Field(None, description='A Base64-encoded string representing the image you wish to modify. Can contain alpha mask if desired.')
-    mask: str = Field(None, description='A Base64-encoded string representing the mask of the areas you with to modify.')
-
-
-class BFLFluxCannyImageRequest(BaseModel):
-    prompt: str = Field(..., description='Text prompt for image generation')
-    prompt_upsampling: Optional[bool] = Field(
-        None, description='Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation.'
-    )
-    canny_low_threshold: Optional[int] = Field(None, description='Low threshold for Canny edge detection')
-    canny_high_threshold: Optional[int] = Field(None, description='High threshold for Canny edge detection')
-    seed: Optional[int] = Field(None, description='The seed value for reproducibility.')
-    steps: conint(ge=15, le=50) = Field(..., description='Number of steps for the image generation process')
-    guidance: confloat(ge=1, le=100) = Field(..., description='Guidance strength for the image generation process')
-    safety_tolerance: Optional[conint(ge=0, le=6)] = Field(
-        6, description='Tolerance level for input and output moderation. Between 0 and 6, 0 being most strict, 6 being least strict. Defaults to 2.'
-    )
-    output_format: Optional[BFLOutputFormat] = Field(
-        BFLOutputFormat.png, description="Output format for the generated image. Can be 'jpeg' or 'png'.", examples=['png']
-    )
-    control_image: Optional[str] = Field(None, description='Base64 encoded image to use as control input if no preprocessed image is provided')
-    preprocessed_image: Optional[str] = Field(None, description='Optional pre-processed image that will bypass the control preprocessing step')
-
-
-class BFLFluxDepthImageRequest(BaseModel):
-    prompt: str = Field(..., description='Text prompt for image generation')
-    prompt_upsampling: Optional[bool] = Field(
-        None, description='Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation.'
-    )
-    seed: Optional[int] = Field(None, description='The seed value for reproducibility.')
-    steps: conint(ge=15, le=50) = Field(..., description='Number of steps for the image generation process')
-    guidance: confloat(ge=1, le=100) = Field(..., description='Guidance strength for the image generation process')
-    safety_tolerance: Optional[conint(ge=0, le=6)] = Field(
-        6, description='Tolerance level for input and output moderation. Between 0 and 6, 0 being most strict, 6 being least strict. Defaults to 2.'
-    )
-    output_format: Optional[BFLOutputFormat] = Field(
-        BFLOutputFormat.png, description="Output format for the generated image. Can be 'jpeg' or 'png'.", examples=['png']
-    )
-    control_image: Optional[str] = Field(None, description='Base64 encoded image to use as control input if no preprocessed image is provided')
-    preprocessed_image: Optional[str] = Field(None, description='Optional pre-processed image that will bypass the control preprocessing step')
-
-
-class BFLFluxProGenerateRequest(BaseModel):
-    prompt: str = Field(..., description='The text prompt for image generation.')
-    prompt_upsampling: Optional[bool] = Field(
-        None, description='Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation.'
-    )
-    seed: Optional[int] = Field(None, description='The seed value for reproducibility.')
-    width: conint(ge=256, le=1440) = Field(1024, description='Width of the generated image in pixels. Must be a multiple of 32.')
-    height: conint(ge=256, le=1440) = Field(768, description='Height of the generated image in pixels. Must be a multiple of 32.')
-    safety_tolerance: Optional[conint(ge=0, le=6)] = Field(
-        6, description='Tolerance level for input and output moderation. Between 0 and 6, 0 being most strict, 6 being least strict. Defaults to 2.'
-    )
-    output_format: Optional[BFLOutputFormat] = Field(
-        BFLOutputFormat.png, description="Output format for the generated image. Can be 'jpeg' or 'png'.", examples=['png']
-    )
-    image_prompt: Optional[str] = Field(None, description='Optional image to remix in base64 format')
-    # image_prompt_strength: Optional[confloat(ge=0.0, le=1.0)] = Field(
-    #     None, description='Blend between the prompt and the image prompt.'
-    # )
-
-
-class BFLFluxKontextProGenerateRequest(BaseModel):
-    prompt: str = Field(..., description='The text prompt for what you wannt to edit.')
-    input_image: Optional[str] = Field(None, description='Image to edit in base64 format')
-    seed: Optional[int] = Field(None, description='The seed value for reproducibility.')
-    guidance: confloat(ge=0.1, le=99.0) = Field(..., description='Guidance strength for the image generation process')
-    steps: conint(ge=1, le=150) = Field(..., description='Number of steps for the image generation process')
-    safety_tolerance: Optional[conint(ge=0, le=2)] = Field(
-        2, description='Tolerance level for input and output moderation. Between 0 and 2, 0 being most strict, 6 being least strict. Defaults to 2.'
-    )
-    output_format: Optional[BFLOutputFormat] = Field(
-        BFLOutputFormat.png, description="Output format for the generated image. Can be 'jpeg' or 'png'.", examples=['png']
-    )
-    aspect_ratio: Optional[str] = Field(None, description='Aspect ratio of the image between 21:9 and 9:21.')
-    prompt_upsampling: Optional[bool] = Field(
-        None, description='Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation.'
-    )
-
-
-class BFLFluxProUltraGenerateRequest(BaseModel):
-    prompt: str = Field(..., description='The text prompt for image generation.')
-    prompt_upsampling: Optional[bool] = Field(
-        None, description='Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation.'
-    )
-    seed: Optional[int] = Field(None, description='The seed value for reproducibility.')
-    aspect_ratio: Optional[str] = Field(None, description='Aspect ratio of the image between 21:9 and 9:21.')
-    safety_tolerance: Optional[conint(ge=0, le=6)] = Field(
-        6, description='Tolerance level for input and output moderation. Between 0 and 6, 0 being most strict, 6 being least strict. Defaults to 2.'
-    )
-    output_format: Optional[BFLOutputFormat] = Field(
-        BFLOutputFormat.png, description="Output format for the generated image. Can be 'jpeg' or 'png'.", examples=['png']
-    )
-    raw: Optional[bool] = Field(None, description='Generate less processed, more natural-looking images.')
-    image_prompt: Optional[str] = Field(None, description='Optional image to remix in base64 format')
-    image_prompt_strength: Optional[confloat(ge=0.0, le=1.0)] = Field(
-        None, description='Blend between the prompt and the image prompt.'
-    )
-
-
-class BFLFluxProGenerateResponse(BaseModel):
-    id: str = Field(..., description='The unique identifier for the generation task.')
-    polling_url: str = Field(..., description='URL to poll for the generation result.')
-
-
-class BFLStatus(str, Enum):
-    task_not_found = "Task not found"
-    pending = "Pending"
-    request_moderated = "Request Moderated"
-    content_moderated = "Content Moderated"
-    ready = "Ready"
-    error = "Error"
-
-
-class BFLFluxProStatusResponse(BaseModel):
-    id: str = Field(..., description="The unique identifier for the generation task.")
-    status: BFLStatus = Field(..., description="The status of the task.")
-    result: Optional[Dict[str, Any]] = Field(
-        None, description="The result of the task (null if not completed)."
-    )
-    progress: confloat(ge=0.0, le=1.0) = Field(
-        ..., description="The progress of the task (0.0 to 1.0)."
-    )
-    details: Optional[Dict[str, Any]] = Field(
-        None, description="Additional details about the task (null if not available)."
-    )

comfy_api_nodes/apis/client.py

@@ -1,1126 +0,0 @@
-"""
-API Client Framework for api.comfy.org.
-
-This module provides a flexible framework for making API requests from ComfyUI nodes.
-It supports both synchronous and asynchronous API operations with proper type validation.
-
-Key Components:
---------------
-1. ApiClient - Handles HTTP requests with authentication and error handling
-2. ApiEndpoint - Defines a single HTTP endpoint with its request/response models
-3. ApiOperation - Executes a single synchronous API operation
-
-Usage Examples:
---------------
-
-# Example 1: Synchronous API Operation
-# ------------------------------------
-# For a simple API call that returns the result immediately:
-
-# 1. Create the API client
-api_client = ApiClient(
-    base_url="https://api.example.com",
-    auth_token="your_auth_token_here",
-    comfy_api_key="your_comfy_api_key_here",
-    timeout=30.0,
-    verify_ssl=True
-)
-
-# 2. Define the endpoint
-user_info_endpoint = ApiEndpoint(
-    path="/v1/users/me",
-    method=HttpMethod.GET,
-    request_model=EmptyRequest,  # No request body needed
-    response_model=UserProfile,   # Pydantic model for the response
-    query_params=None
-)
-
-# 3. Create the request object
-request = EmptyRequest()
-
-# 4. Create and execute the operation
-operation = ApiOperation(
-    endpoint=user_info_endpoint,
-    request=request
-)
-user_profile = operation.execute(client=api_client)  # Returns immediately with the result
-
-
-# Example 2: Asynchronous API Operation with Polling
-# -------------------------------------------------
-# For an API that starts a task and requires polling for completion:
-
-# 1. Define the endpoints (initial request and polling)
-generate_image_endpoint = ApiEndpoint(
-    path="/v1/images/generate",
-    method=HttpMethod.POST,
-    request_model=ImageGenerationRequest,
-    response_model=TaskCreatedResponse,
-    query_params=None
-)
-
-check_task_endpoint = ApiEndpoint(
-    path="/v1/tasks/{task_id}",
-    method=HttpMethod.GET,
-    request_model=EmptyRequest,
-    response_model=ImageGenerationResult,
-    query_params=None
-)
-
-# 2. Create the request object
-request = ImageGenerationRequest(
-    prompt="a beautiful sunset over mountains",
-    width=1024,
-    height=1024,
-    num_images=1
-)
-
-# 3. Create and execute the polling operation
-operation = PollingOperation(
-    initial_endpoint=generate_image_endpoint,
-    initial_request=request,
-    poll_endpoint=check_task_endpoint,
-    task_id_field="task_id",
-    status_field="status",
-    completed_statuses=["completed"],
-    failed_statuses=["failed", "error"]
-)
-
-# This will make the initial request and then poll until completion
-result = operation.execute(client=api_client)  # Returns the final ImageGenerationResult when done
-"""
-
-from __future__ import annotations
-import logging
-import time
-import io
-import socket
-from typing import Dict, Type, Optional, Any, TypeVar, Generic, Callable, Tuple
-from enum import Enum
-import json
-import requests
-from urllib.parse import urljoin, urlparse
-from pydantic import BaseModel, Field
-import uuid # For generating unique operation IDs
-
-from server import PromptServer
-from comfy.cli_args import args
-from comfy import utils
-from . import request_logger
-
-T = TypeVar("T", bound=BaseModel)
-R = TypeVar("R", bound=BaseModel)
-P = TypeVar("P", bound=BaseModel)  # For poll response
-
-PROGRESS_BAR_MAX = 100
-
-
-class NetworkError(Exception):
-    """Base exception for network-related errors with diagnostic information."""
-    pass
-
-
-class LocalNetworkError(NetworkError):
-    """Exception raised when local network connectivity issues are detected."""
-    pass
-
-
-class ApiServerError(NetworkError):
-    """Exception raised when the API server is unreachable but internet is working."""
-    pass
-
-
-class EmptyRequest(BaseModel):
-    """Base class for empty request bodies.
-    For GET requests, fields will be sent as query parameters."""
-
-    pass
-
-
-class UploadRequest(BaseModel):
-    file_name: str = Field(..., description="Filename to upload")
-    content_type: Optional[str] = Field(
-        None,
-        description="Mime type of the file. For example: image/png, image/jpeg, video/mp4, etc.",
-    )
-
-
-class UploadResponse(BaseModel):
-    download_url: str = Field(..., description="URL to GET uploaded file")
-    upload_url: str = Field(..., description="URL to PUT file to upload")
-
-
-class HttpMethod(str, Enum):
-    GET = "GET"
-    POST = "POST"
-    PUT = "PUT"
-    DELETE = "DELETE"
-    PATCH = "PATCH"
-
-
-class ApiClient:
-    """
-    Client for making HTTP requests to an API with authentication, error handling, and retry logic.
-    """
-
-    def __init__(
-        self,
-        base_url: str,
-        auth_token: Optional[str] = None,
-        comfy_api_key: Optional[str] = None,
-        timeout: float = 3600.0,
-        verify_ssl: bool = True,
-        max_retries: int = 3,
-        retry_delay: float = 1.0,
-        retry_backoff_factor: float = 2.0,
-        retry_status_codes: Optional[Tuple[int, ...]] = None,
-    ):
-        self.base_url = base_url
-        self.auth_token = auth_token
-        self.comfy_api_key = comfy_api_key
-        self.timeout = timeout
-        self.verify_ssl = verify_ssl
-        self.max_retries = max_retries
-        self.retry_delay = retry_delay
-        self.retry_backoff_factor = retry_backoff_factor
-        # Default retry status codes: 408 (Request Timeout), 429 (Too Many Requests),
-        # 500, 502, 503, 504 (Server Errors)
-        self.retry_status_codes = retry_status_codes or (408, 429, 500, 502, 503, 504)
-
-    def _generate_operation_id(self, path: str) -> str:
-        """Generates a unique operation ID for logging."""
-        return f"{path.strip('/').replace('/', '_')}_{uuid.uuid4().hex[:8]}"
-
-    def _create_json_payload_args(
-        self,
-        data: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> Dict[str, Any]:
-        return {
-            "json": data,
-            "headers": headers,
-        }
-
-    def _create_form_data_args(
-        self,
-        data: Dict[str, Any],
-        files: Dict[str, Any],
-        headers: Optional[Dict[str, str]] = None,
-        multipart_parser = None,
-    ) -> Dict[str, Any]:
-        if headers and "Content-Type" in headers:
-            del headers["Content-Type"]
-
-        if multipart_parser:
-            data = multipart_parser(data)
-
-        return {
-            "data": data,
-            "files": files,
-            "headers": headers,
-        }
-
-    def _create_urlencoded_form_data_args(
-        self,
-        data: Dict[str, Any],
-        headers: Optional[Dict[str, str]] = None,
-    ) -> Dict[str, Any]:
-        headers = headers or {}
-        headers["Content-Type"] = "application/x-www-form-urlencoded"
-
-        return {
-            "data": data,
-            "headers": headers,
-        }
-
-    def get_headers(self) -> Dict[str, str]:
-        """Get headers for API requests, including authentication if available"""
-        headers = {"Content-Type": "application/json", "Accept": "application/json"}
-
-        if self.auth_token:
-            headers["Authorization"] = f"Bearer {self.auth_token}"
-        elif self.comfy_api_key:
-            headers["X-API-KEY"] = self.comfy_api_key
-
-        return headers
-
-    def _check_connectivity(self, target_url: str) -> Dict[str, bool]:
-        """
-        Check connectivity to determine if network issues are local or server-related.
-
-        Args:
-            target_url: URL to check connectivity to
-
-        Returns:
-            Dictionary with connectivity status details
-        """
-        results = {
-            "internet_accessible": False,
-            "api_accessible": False,
-            "is_local_issue": False,
-            "is_api_issue": False
-        }
-
-        # First check basic internet connectivity using a reliable external site
-        try:
-            # Use a reliable external domain for checking basic connectivity
-            check_response = requests.get("https://www.google.com",
-                                         timeout=5.0,
-                                         verify=self.verify_ssl)
-            if check_response.status_code < 500:
-                results["internet_accessible"] = True
-        except (requests.RequestException, socket.error):
-            results["internet_accessible"] = False
-            results["is_local_issue"] = True
-            return results
-
-        # Now check API server connectivity
-        try:
-            # Extract domain from the target URL to do a simpler health check
-            parsed_url = urlparse(target_url)
-            api_base = f"{parsed_url.scheme}://{parsed_url.netloc}"
-
-            # Try to reach the API domain
-            api_response = requests.get(f"{api_base}/health", timeout=5.0, verify=self.verify_ssl)
-            if api_response.status_code < 500:
-                results["api_accessible"] = True
-            else:
-                results["api_accessible"] = False
-                results["is_api_issue"] = True
-        except requests.RequestException:
-            results["api_accessible"] = False
-            # If we can reach the internet but not the API, it's an API issue
-            results["is_api_issue"] = True
-
-        return results
-
-    def request(
-        self,
-        method: str,
-        path: str,
-        params: Optional[Dict[str, Any]] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        content_type: str = "application/json",
-        multipart_parser: Callable = None,
-        retry_count: int = 0,  # Used internally for tracking retries
-    ) -> Dict[str, Any]:
-        """
-        Make an HTTP request to the API with automatic retries for transient errors.
-
-        Args:
-            method: HTTP method (GET, POST, etc.)
-            path: API endpoint path (will be joined with base_url)
-            params: Query parameters
-            data: body data
-            files: Files to upload
-            headers: Additional headers
-            content_type: Content type of the request. Defaults to application/json.
-            retry_count: Internal parameter for tracking retries, do not set manually
-
-        Returns:
-            Parsed JSON response
-
-        Raises:
-            LocalNetworkError: If local network connectivity issues are detected
-            ApiServerError: If the API server is unreachable but internet is working
-            Exception: For other request failures
-        """
-        # Use urljoin but ensure path is relative to avoid absolute path behavior
-        relative_path = path.lstrip('/')
-        url = urljoin(self.base_url, relative_path)
-        self.check_auth(self.auth_token, self.comfy_api_key)
-        # Combine default headers with any provided headers
-        request_headers = self.get_headers()
-        if headers:
-            request_headers.update(headers)
-
-        # Let requests handle the content type when files are present.
-        if files:
-            del request_headers["Content-Type"]
-
-        logging.debug(f"[DEBUG] Request Headers: {request_headers}")
-        logging.debug(f"[DEBUG] Files: {files}")
-        logging.debug(f"[DEBUG] Params: {params}")
-        logging.debug(f"[DEBUG] Data: {data}")
-
-        if content_type == "application/x-www-form-urlencoded":
-            payload_args = self._create_urlencoded_form_data_args(data, request_headers)
-        elif content_type == "multipart/form-data":
-            payload_args = self._create_form_data_args(
-                data, files, request_headers, multipart_parser
-            )
-        else:
-            payload_args = self._create_json_payload_args(data, request_headers)
-
-        operation_id = self._generate_operation_id(path)
-        request_logger.log_request_response(
-            operation_id=operation_id,
-            request_method=method,
-            request_url=url,
-            request_headers=request_headers,
-            request_params=params,
-            request_data=data if content_type == "application/json" else "[form-data or other]"
-        )
-
-        try:
-            response = requests.request(
-                method=method,
-                url=url,
-                params=params,
-                timeout=self.timeout,
-                verify=self.verify_ssl,
-                **payload_args,
-            )
-
-            # Check if we should retry based on status code
-            if (response.status_code in self.retry_status_codes and
-                retry_count < self.max_retries):
-
-                # Calculate delay with exponential backoff
-                delay = self.retry_delay * (self.retry_backoff_factor ** retry_count)
-
-                logging.warning(
-                    f"Request failed with status {response.status_code}. "
-                    f"Retrying in {delay:.2f}s ({retry_count + 1}/{self.max_retries})"
-                )
-
-                time.sleep(delay)
-                return self.request(
-                    method=method,
-                    path=path,
-                    params=params,
-                    data=data,
-                    files=files,
-                    headers=headers,
-                    content_type=content_type,
-                    multipart_parser=multipart_parser,
-                    retry_count=retry_count + 1,
-                )
-
-            # Raise exception for error status codes
-            response.raise_for_status()
-
-            # Log successful response
-            response_content_to_log = response.content
-            try:
-                # Attempt to parse JSON for prettier logging, fallback to raw content
-                response_content_to_log = response.json()
-            except json.JSONDecodeError:
-                pass # Keep as bytes/str if not JSON
-
-            request_logger.log_request_response(
-                operation_id=operation_id,
-                request_method=method, # Pass request details again for context in log
-                request_url=url,
-                response_status_code=response.status_code,
-                response_headers=dict(response.headers),
-                response_content=response_content_to_log
-            )
-
-        except requests.ConnectionError as e:
-            error_message = f"ConnectionError: {str(e)}"
-            request_logger.log_request_response(
-                operation_id=operation_id,
-                request_method=method,
-                request_url=url,
-                error_message=error_message
-            )
-            # Only perform connectivity check if we've exhausted all retries
-            if retry_count >= self.max_retries:
-                # Check connectivity to determine if it's a local or API issue
-                connectivity = self._check_connectivity(self.base_url)
-
-                if connectivity["is_local_issue"]:
-                    raise LocalNetworkError(
-                        "Unable to connect to the API server due to local network issues. "
-                        "Please check your internet connection and try again."
-                    ) from e
-                elif connectivity["is_api_issue"]:
-                    raise ApiServerError(
-                        f"The API server at {self.base_url} is currently unreachable. "
-                        f"The service may be experiencing issues. Please try again later."
-                    ) from e
-
-            # If we haven't exhausted retries yet, retry the request
-            if retry_count < self.max_retries:
-                delay = self.retry_delay * (self.retry_backoff_factor ** retry_count)
-                logging.warning(
-                    f"Connection error: {str(e)}. "
-                    f"Retrying in {delay:.2f}s ({retry_count + 1}/{self.max_retries})"
-                )
-                time.sleep(delay)
-                return self.request(
-                    method=method,
-                    path=path,
-                    params=params,
-                    data=data,
-                    files=files,
-                    headers=headers,
-                    content_type=content_type,
-                    multipart_parser=multipart_parser,
-                    retry_count=retry_count + 1,
-                )
-
-            # If we've exhausted retries and didn't identify the specific issue,
-            # raise a generic exception
-            final_error_message = (
-                f"Unable to connect to the API server after {self.max_retries} attempts. "
-                f"Please check your internet connection or try again later."
-            )
-            request_logger.log_request_response( # Log final failure
-                operation_id=operation_id,
-                request_method=method, request_url=url,
-                error_message=final_error_message
-            )
-            raise Exception(final_error_message) from e
-
-        except requests.Timeout as e:
-            error_message = f"Timeout: {str(e)}"
-            request_logger.log_request_response(
-                operation_id=operation_id,
-                request_method=method, request_url=url,
-                error_message=error_message
-            )
-            # Retry timeouts if we haven't exhausted retries
-            if retry_count < self.max_retries:
-                delay = self.retry_delay * (self.retry_backoff_factor ** retry_count)
-                logging.warning(
-                    f"Request timed out. "
-                    f"Retrying in {delay:.2f}s ({retry_count + 1}/{self.max_retries})"
-                )
-                time.sleep(delay)
-                return self.request(
-                    method=method,
-                    path=path,
-                    params=params,
-                    data=data,
-                    files=files,
-                    headers=headers,
-                    content_type=content_type,
-                    multipart_parser=multipart_parser,
-                    retry_count=retry_count + 1,
-                )
-            final_error_message = (
-                f"Request timed out after {self.timeout} seconds and {self.max_retries} retry attempts. "
-                f"The server might be experiencing high load or the operation is taking longer than expected."
-            )
-            request_logger.log_request_response( # Log final failure
-                operation_id=operation_id,
-                request_method=method, request_url=url,
-                error_message=final_error_message
-            )
-            raise Exception(final_error_message) from e
-
-        except requests.HTTPError as e:
-            status_code = e.response.status_code if hasattr(e, "response") else None
-            original_error_message = f"HTTP Error: {str(e)}"
-            error_content_for_log = None
-            if hasattr(e, "response") and e.response is not None:
-                error_content_for_log = e.response.content
-                try:
-                    error_content_for_log = e.response.json()
-                except json.JSONDecodeError:
-                    pass
-
-
-            # Try to extract detailed error message from JSON response for user display
-            # but log the full error content.
-            user_display_error_message = original_error_message
-
-            try:
-                if hasattr(e, "response") and e.response is not None and e.response.content:
-                    error_json = e.response.json()
-                    if "error" in error_json and "message" in error_json["error"]:
-                        user_display_error_message = f"API Error: {error_json['error']['message']}"
-                        if "type" in error_json["error"]:
-                            user_display_error_message += f" (Type: {error_json['error']['type']})"
-                    elif isinstance(error_json, dict): # Handle cases where error is just a JSON dict
-                        user_display_error_message = f"API Error: {json.dumps(error_json)}"
-                    else: # Non-dict JSON error
-                        user_display_error_message = f"API Error: {str(error_json)}"
-            except json.JSONDecodeError:
-                # If not JSON, use the raw content if it's not too long, or a summary
-                if hasattr(e, "response") and e.response is not None and e.response.content:
-                    raw_content = e.response.content.decode(errors='ignore')
-                    if len(raw_content) < 200: # Arbitrary limit for display
-                        user_display_error_message = f"API Error (raw): {raw_content}"
-                    else:
-                        user_display_error_message = f"API Error (raw, status {status_code})"
-
-            request_logger.log_request_response(
-                operation_id=operation_id,
-                request_method=method, request_url=url,
-                response_status_code=status_code,
-                response_headers=dict(e.response.headers) if hasattr(e, "response") and e.response is not None else None,
-                response_content=error_content_for_log,
-                error_message=original_error_message # Log the original exception string as error
-            )
-
-            logging.debug(f"[DEBUG] API Error: {user_display_error_message} (Status: {status_code})")
-            if hasattr(e, "response") and e.response is not None and e.response.content:
-                logging.debug(f"[DEBUG] Response content: {e.response.content}")
-
-            # Retry if the status code is in our retry list and we haven't exhausted retries
-            if (status_code in self.retry_status_codes and
-                retry_count < self.max_retries):
-
-                delay = self.retry_delay * (self.retry_backoff_factor ** retry_count)
-                logging.warning(
-                    f"HTTP error {status_code}. "
-                    f"Retrying in {delay:.2f}s ({retry_count + 1}/{self.max_retries})"
-                )
-                time.sleep(delay)
-                return self.request(
-                    method=method,
-                    path=path,
-                    params=params,
-                    data=data,
-                    files=files,
-                    headers=headers,
-                    content_type=content_type,
-                    multipart_parser=multipart_parser,
-                    retry_count=retry_count + 1,
-                )
-
-            # Specific error messages for common status codes for user display
-            if status_code == 401:
-                user_display_error_message = "Unauthorized: Please login first to use this node."
-            elif status_code == 402:
-                user_display_error_message = "Payment Required: Please add credits to your account to use this node."
-            elif status_code == 409:
-                user_display_error_message = "There is a problem with your account. Please contact support@comfy.org."
-            elif status_code == 429:
-                user_display_error_message = "Rate Limit Exceeded: Please try again later."
-            # else, user_display_error_message remains as parsed from response or original HTTPError string
-
-            raise Exception(user_display_error_message) # Raise with the user-friendly message
-
-        # Parse and return JSON response
-        if response.content:
-            return response.json()
-        return {}
-
-    def check_auth(self, auth_token, comfy_api_key):
-        """Verify that an auth token is present or comfy_api_key is present"""
-        if auth_token is None and comfy_api_key is None:
-            raise Exception("Unauthorized: Please login first to use this node.")
-        return auth_token or comfy_api_key
-
-    @staticmethod
-    def upload_file(
-        upload_url: str,
-        file: io.BytesIO | str,
-        content_type: str | None = None,
-        max_retries: int = 3,
-        retry_delay: float = 1.0,
-        retry_backoff_factor: float = 2.0,
-    ):
-        """Upload a file to the API with retry logic.
-
-        Args:
-            upload_url: The URL to upload to
-            file: Either a file path string, BytesIO object, or tuple of (file_path, filename)
-            content_type: Optional mime type to set for the upload
-            max_retries: Maximum number of retry attempts
-            retry_delay: Initial delay between retries in seconds
-            retry_backoff_factor: Multiplier for the delay after each retry
-        """
-        headers = {}
-        if content_type:
-            headers["Content-Type"] = content_type
-
-        # Prepare the file data
-        if isinstance(file, io.BytesIO):
-            file.seek(0)  # Ensure we're at the start of the file
-            data = file.read()
-        elif isinstance(file, str):
-            with open(file, "rb") as f:
-                data = f.read()
-        else:
-            raise ValueError("File must be either a BytesIO object or a file path string")
-
-        # Try the upload with retries
-        last_exception = None
-        operation_id = f"upload_{upload_url.split('/')[-1]}_{uuid.uuid4().hex[:8]}" # Simplified ID for uploads
-
-        # Log initial attempt (without full file data for brevity)
-        request_logger.log_request_response(
-            operation_id=operation_id,
-            request_method="PUT",
-            request_url=upload_url,
-            request_headers=headers,
-            request_data=f"[File data of type {content_type or 'unknown'}, size {len(data)} bytes]"
-        )
-
-        for retry_attempt in range(max_retries + 1):
-            try:
-                response = requests.put(upload_url, data=data, headers=headers)
-                response.raise_for_status()
-                request_logger.log_request_response(
-                    operation_id=operation_id,
-                    request_method="PUT", request_url=upload_url, # For context
-                    response_status_code=response.status_code,
-                    response_headers=dict(response.headers),
-                    response_content="File uploaded successfully." # Or response.text if available
-                )
-                return response
-
-            except (requests.ConnectionError, requests.Timeout, requests.HTTPError) as e:
-                last_exception = e
-                error_message_for_log = f"{type(e).__name__}: {str(e)}"
-                response_content_for_log = None
-                status_code_for_log = None
-                headers_for_log = None
-
-                if hasattr(e, 'response') and e.response is not None:
-                    status_code_for_log = e.response.status_code
-                    headers_for_log = dict(e.response.headers)
-                    try:
-                        response_content_for_log = e.response.json()
-                    except json.JSONDecodeError:
-                        response_content_for_log = e.response.content
-
-
-                request_logger.log_request_response(
-                    operation_id=operation_id,
-                    request_method="PUT", request_url=upload_url,
-                    response_status_code=status_code_for_log,
-                    response_headers=headers_for_log,
-                    response_content=response_content_for_log,
-                    error_message=error_message_for_log
-                )
-
-                if retry_attempt < max_retries:
-                    delay = retry_delay * (retry_backoff_factor ** retry_attempt)
-                    logging.warning(
-                        f"File upload failed: {str(e)}. "
-                        f"Retrying in {delay:.2f}s ({retry_attempt + 1}/{max_retries})"
-                    )
-                    time.sleep(delay)
-                else:
-                    break # Max retries reached
-
-        # If we've exhausted all retries, determine the final error type and raise
-        final_error_message = f"Failed to upload file after {max_retries + 1} attempts. Error: {str(last_exception)}"
-        try:
-            # Check basic internet connectivity
-            check_response = requests.get("https://www.google.com", timeout=5.0, verify=True) # Assuming verify=True is desired
-            if check_response.status_code >= 500: # Google itself has an issue (rare)
-                 final_error_message = (f"Failed to upload file. Internet connectivity check to Google failed "
-                                       f"(status {check_response.status_code}). Original error: {str(last_exception)}")
-                 # Not raising LocalNetworkError here as Google itself might be down.
-            # If Google is reachable, the issue is likely with the upload server or a more specific local problem
-            # not caught by a simple Google ping (e.g., DNS for the specific upload URL, firewall).
-            # The original last_exception is probably most relevant.
-
-        except (requests.RequestException, socket.error) as conn_check_exc:
-            # Could not reach Google, likely a local network issue
-            final_error_message = (f"Failed to upload file due to network connectivity issues "
-                                   f"(cannot reach Google: {str(conn_check_exc)}). "
-                                   f"Original upload error: {str(last_exception)}")
-            request_logger.log_request_response( # Log final failure reason
-                operation_id=operation_id,
-                request_method="PUT", request_url=upload_url,
-                error_message=final_error_message
-            )
-            raise LocalNetworkError(final_error_message) from last_exception
-
-        request_logger.log_request_response( # Log final failure reason if not LocalNetworkError
-            operation_id=operation_id,
-            request_method="PUT", request_url=upload_url,
-            error_message=final_error_message
-        )
-        raise Exception(final_error_message) from last_exception
-
-
-class ApiEndpoint(Generic[T, R]):
-    """Defines an API endpoint with its request and response types"""
-
-    def __init__(
-        self,
-        path: str,
-        method: HttpMethod,
-        request_model: Type[T],
-        response_model: Type[R],
-        query_params: Optional[Dict[str, Any]] = None,
-    ):
-        """Initialize an API endpoint definition.
-
-        Args:
-            path: The URL path for this endpoint, can include placeholders like {id}
-            method: The HTTP method to use (GET, POST, etc.)
-            request_model: Pydantic model class that defines the structure and validation rules for API requests to this endpoint
-            response_model: Pydantic model class that defines the structure and validation rules for API responses from this endpoint
-            query_params: Optional dictionary of query parameters to include in the request
-        """
-        self.path = path
-        self.method = method
-        self.request_model = request_model
-        self.response_model = response_model
-        self.query_params = query_params or {}
-
-
-class SynchronousOperation(Generic[T, R]):
-    """
-    Represents a single synchronous API operation.
-    """
-
-    def __init__(
-        self,
-        endpoint: ApiEndpoint[T, R],
-        request: T,
-        files: Optional[Dict[str, Any]] = None,
-        api_base: str | None = None,
-        auth_token: Optional[str] = None,
-        comfy_api_key: Optional[str] = None,
-        auth_kwargs: Optional[Dict[str,str]] = None,
-        timeout: float = 604800.0,
-        verify_ssl: bool = True,
-        content_type: str = "application/json",
-        multipart_parser: Callable = None,
-        max_retries: int = 3,
-        retry_delay: float = 1.0,
-        retry_backoff_factor: float = 2.0,
-    ):
-        self.endpoint = endpoint
-        self.request = request
-        self.response = None
-        self.error = None
-        self.api_base: str = api_base or args.comfy_api_base
-        self.auth_token = auth_token
-        self.comfy_api_key = comfy_api_key
-        if auth_kwargs is not None:
-            self.auth_token = auth_kwargs.get("auth_token", self.auth_token)
-            self.comfy_api_key = auth_kwargs.get("comfy_api_key", self.comfy_api_key)
-        self.timeout = timeout
-        self.verify_ssl = verify_ssl
-        self.files = files
-        self.content_type = content_type
-        self.multipart_parser = multipart_parser
-        self.max_retries = max_retries
-        self.retry_delay = retry_delay
-        self.retry_backoff_factor = retry_backoff_factor
-
-    def execute(self, client: Optional[ApiClient] = None) -> R:
-        """Execute the API operation using the provided client or create one with retry support"""
-        try:
-            # Create client if not provided
-            if client is None:
-                client = ApiClient(
-                    base_url=self.api_base,
-                    auth_token=self.auth_token,
-                    comfy_api_key=self.comfy_api_key,
-                    timeout=self.timeout,
-                    verify_ssl=self.verify_ssl,
-                    max_retries=self.max_retries,
-                    retry_delay=self.retry_delay,
-                    retry_backoff_factor=self.retry_backoff_factor,
-                )
-
-            # Convert request model to dict, but use None for EmptyRequest
-            request_dict = (
-                None
-                if isinstance(self.request, EmptyRequest)
-                else self.request.model_dump(exclude_none=True)
-            )
-            if request_dict:
-                for key, value in request_dict.items():
-                    if isinstance(value, Enum):
-                        request_dict[key] = value.value
-
-            # Debug log for request
-            logging.debug(
-                f"[DEBUG] API Request: {self.endpoint.method.value} {self.endpoint.path}"
-            )
-            logging.debug(f"[DEBUG] Request Data: {json.dumps(request_dict, indent=2)}")
-            logging.debug(f"[DEBUG] Query Params: {self.endpoint.query_params}")
-
-            # Make the request with built-in retry
-            resp = client.request(
-                method=self.endpoint.method.value,
-                path=self.endpoint.path,
-                data=request_dict,
-                params=self.endpoint.query_params,
-                files=self.files,
-                content_type=self.content_type,
-                multipart_parser=self.multipart_parser
-            )
-
-            # Debug log for response
-            logging.debug("=" * 50)
-            logging.debug("[DEBUG] RESPONSE DETAILS:")
-            logging.debug("[DEBUG] Status Code: 200 (Success)")
-            logging.debug(f"[DEBUG] Response Body: {json.dumps(resp, indent=2)}")
-            logging.debug("=" * 50)
-
-            # Parse and return the response
-            return self._parse_response(resp)
-
-        except LocalNetworkError as e:
-            # Propagate specific network error types
-            logging.error(f"[ERROR] Local network error: {str(e)}")
-            raise
-
-        except ApiServerError as e:
-            # Propagate API server errors
-            logging.error(f"[ERROR] API server error: {str(e)}")
-            raise
-
-        except Exception as e:
-            logging.error(f"[ERROR] API Exception: {str(e)}")
-            raise Exception(str(e))
-
-    def _parse_response(self, resp):
-        """Parse response data - can be overridden by subclasses"""
-        # The response is already the complete object, don't extract just the "data" field
-        # as that would lose the outer structure (created timestamp, etc.)
-
-        # Parse response using the provided model
-        self.response = self.endpoint.response_model.model_validate(resp)
-        logging.debug(f"[DEBUG] Parsed Response: {self.response}")
-        return self.response
-
-
-class TaskStatus(str, Enum):
-    """Enum for task status values"""
-
-    COMPLETED = "completed"
-    FAILED = "failed"
-    PENDING = "pending"
-
-
-class PollingOperation(Generic[T, R]):
-    """
-    Represents an asynchronous API operation that requires polling for completion.
-    """
-
-    def __init__(
-        self,
-        poll_endpoint: ApiEndpoint[EmptyRequest, R],
-        completed_statuses: list,
-        failed_statuses: list,
-        status_extractor: Callable[[R], str],
-        progress_extractor: Callable[[R], float] = None,
-        result_url_extractor: Callable[[R], str] = None,
-        request: Optional[T] = None,
-        api_base: str | None = None,
-        auth_token: Optional[str] = None,
-        comfy_api_key: Optional[str] = None,
-        auth_kwargs: Optional[Dict[str,str]] = None,
-        poll_interval: float = 5.0,
-        max_poll_attempts: int = 120,  # Default max polling attempts (10 minutes with 5s interval)
-        max_retries: int = 3,  # Max retries per individual API call
-        retry_delay: float = 1.0,
-        retry_backoff_factor: float = 2.0,
-        estimated_duration: Optional[float] = None,
-        node_id: Optional[str] = None,
-    ):
-        self.poll_endpoint = poll_endpoint
-        self.request = request
-        self.api_base: str = api_base or args.comfy_api_base
-        self.auth_token = auth_token
-        self.comfy_api_key = comfy_api_key
-        if auth_kwargs is not None:
-            self.auth_token = auth_kwargs.get("auth_token", self.auth_token)
-            self.comfy_api_key = auth_kwargs.get("comfy_api_key", self.comfy_api_key)
-        self.poll_interval = poll_interval
-        self.max_poll_attempts = max_poll_attempts
-        self.max_retries = max_retries
-        self.retry_delay = retry_delay
-        self.retry_backoff_factor = retry_backoff_factor
-        self.estimated_duration = estimated_duration
-
-        # Polling configuration
-        self.status_extractor = status_extractor or (
-            lambda x: getattr(x, "status", None)
-        )
-        self.progress_extractor = progress_extractor
-        self.result_url_extractor = result_url_extractor
-        self.node_id = node_id
-        self.completed_statuses = completed_statuses
-        self.failed_statuses = failed_statuses
-
-        # For storing response data
-        self.final_response = None
-        self.error = None
-
-    def execute(self, client: Optional[ApiClient] = None) -> R:
-        """Execute the polling operation using the provided client. If failed, raise an exception."""
-        try:
-            if client is None:
-                client = ApiClient(
-                    base_url=self.api_base,
-                    auth_token=self.auth_token,
-                    comfy_api_key=self.comfy_api_key,
-                    max_retries=self.max_retries,
-                    retry_delay=self.retry_delay,
-                    retry_backoff_factor=self.retry_backoff_factor,
-                )
-            return self._poll_until_complete(client)
-        except LocalNetworkError as e:
-            # Provide clear message for local network issues
-            raise Exception(
-                f"Polling failed due to local network issues. Please check your internet connection. "
-                f"Details: {str(e)}"
-            ) from e
-        except ApiServerError as e:
-            # Provide clear message for API server issues
-            raise Exception(
-                f"Polling failed due to API server issues. The service may be experiencing problems. "
-                f"Please try again later. Details: {str(e)}"
-            ) from e
-        except Exception as e:
-            raise Exception(f"Error during polling: {str(e)}")
-
-    def _display_text_on_node(self, text: str):
-        """Sends text to the client which will be displayed on the node in the UI"""
-        if not self.node_id:
-            return
-
-        PromptServer.instance.send_progress_text(text, self.node_id)
-
-    def _display_time_progress_on_node(self, time_completed: int):
-        if not self.node_id:
-            return
-
-        if self.estimated_duration is not None:
-            estimated_time_remaining = max(
-                0, int(self.estimated_duration) - int(time_completed)
-            )
-            message = f"Task in progress: {time_completed:.0f}s (~{estimated_time_remaining:.0f}s remaining)"
-        else:
-            message = f"Task in progress: {time_completed:.0f}s"
-        self._display_text_on_node(message)
-
-    def _check_task_status(self, response: R) -> TaskStatus:
-        """Check task status using the status extractor function"""
-        try:
-            status = self.status_extractor(response)
-            if status in self.completed_statuses:
-                return TaskStatus.COMPLETED
-            elif status in self.failed_statuses:
-                return TaskStatus.FAILED
-            return TaskStatus.PENDING
-        except Exception as e:
-            logging.error(f"Error extracting status: {e}")
-            return TaskStatus.PENDING
-
-    def _poll_until_complete(self, client: ApiClient) -> R:
-        """Poll until the task is complete"""
-        poll_count = 0
-        consecutive_errors = 0
-        max_consecutive_errors = min(5, self.max_retries * 2)  # Limit consecutive errors
-
-        if self.progress_extractor:
-            progress = utils.ProgressBar(PROGRESS_BAR_MAX)
-
-        while poll_count < self.max_poll_attempts:
-            try:
-                poll_count += 1
-                logging.debug(f"[DEBUG] Polling attempt #{poll_count}")
-
-                request_dict = (
-                    self.request.model_dump(exclude_none=True)
-                    if self.request is not None
-                    else None
-                )
-
-                if poll_count == 1:
-                    logging.debug(
-                        f"[DEBUG] Poll Request: {self.poll_endpoint.method.value} {self.poll_endpoint.path}"
-                    )
-                    logging.debug(
-                        f"[DEBUG] Poll Request Data: {json.dumps(request_dict, indent=2) if request_dict else 'None'}"
-                    )
-
-                # Query task status
-                resp = client.request(
-                    method=self.poll_endpoint.method.value,
-                    path=self.poll_endpoint.path,
-                    params=self.poll_endpoint.query_params,
-                    data=request_dict,
-                )
-
-                # Successfully got a response, reset consecutive error count
-                consecutive_errors = 0
-
-                # Parse response
-                response_obj = self.poll_endpoint.response_model.model_validate(resp)
-
-                # Check if task is complete
-                status = self._check_task_status(response_obj)
-                logging.debug(f"[DEBUG] Task Status: {status}")
-
-                # If progress extractor is provided, extract progress
-                if self.progress_extractor:
-                    new_progress = self.progress_extractor(response_obj)
-                    if new_progress is not None:
-                        progress.update_absolute(new_progress, total=PROGRESS_BAR_MAX)
-
-                if status == TaskStatus.COMPLETED:
-                    message = "Task completed successfully"
-                    if self.result_url_extractor:
-                        result_url = self.result_url_extractor(response_obj)
-                        if result_url:
-                            message = f"Result URL: {result_url}"
-                    else:
-                        message = "Task completed successfully!"
-                    logging.debug(f"[DEBUG] {message}")
-                    self._display_text_on_node(message)
-                    self.final_response = response_obj
-                    if self.progress_extractor:
-                        progress.update(100)
-                    return self.final_response
-                elif status == TaskStatus.FAILED:
-                    message = f"Task failed: {json.dumps(resp)}"
-                    logging.error(f"[DEBUG] {message}")
-                    raise Exception(message)
-                else:
-                    logging.debug("[DEBUG] Task still pending, continuing to poll...")
-
-                # Wait before polling again
-                logging.debug(
-                    f"[DEBUG] Waiting {self.poll_interval} seconds before next poll"
-                )
-                for i in range(int(self.poll_interval)):
-                    time_completed = (poll_count * self.poll_interval) + i
-                    self._display_time_progress_on_node(time_completed)
-                    time.sleep(1)
-
-            except (LocalNetworkError, ApiServerError) as e:
-                # For network-related errors, increment error count and potentially abort
-                consecutive_errors += 1
-                if consecutive_errors >= max_consecutive_errors:
-                    raise Exception(
-                        f"Polling aborted after {consecutive_errors} consecutive network errors: {str(e)}"
-                    ) from e
-
-                # Log the error but continue polling
-                logging.warning(
-                    f"Network error during polling (attempt {poll_count}/{self.max_poll_attempts}): {str(e)}. "
-                    f"Will retry in {self.poll_interval} seconds."
-                )
-                time.sleep(self.poll_interval)
-
-            except Exception as e:
-                # For other errors, increment count and potentially abort
-                consecutive_errors += 1
-                if consecutive_errors >= max_consecutive_errors or status == TaskStatus.FAILED:
-                    raise Exception(
-                        f"Polling aborted after {consecutive_errors} consecutive errors: {str(e)}"
-                    ) from e
-
-                logging.error(f"[DEBUG] Polling error: {str(e)}")
-                logging.warning(
-                    f"Error during polling (attempt {poll_count}/{self.max_poll_attempts}): {str(e)}. "
-                    f"Will retry in {self.poll_interval} seconds."
-                )
-                time.sleep(self.poll_interval)
-
-        # If we've exhausted all polling attempts
-        raise Exception(
-            f"Polling timed out after {poll_count} attempts ({poll_count * self.poll_interval} seconds). "
-            f"The operation may still be running on the server but is taking longer than expected."
-        )

comfy_api_nodes/apis/luma_api.py

@@ -1,253 +0,0 @@
-from __future__ import annotations
-
-
-import torch
-
-from enum import Enum
-from typing import Optional, Union
-
-from pydantic import BaseModel, Field, confloat
-
-
-
-class LumaIO:
-    LUMA_REF = "LUMA_REF"
-    LUMA_CONCEPTS = "LUMA_CONCEPTS"
-
-
-class LumaReference:
-    def __init__(self, image: torch.Tensor, weight: float):
-        self.image = image
-        self.weight = weight
-
-    def create_api_model(self, download_url: str):
-        return LumaImageRef(url=download_url, weight=self.weight)
-
-class LumaReferenceChain:
-    def __init__(self, first_ref: LumaReference=None):
-        self.refs: list[LumaReference] = []
-        if first_ref:
-            self.refs.append(first_ref)
-
-    def add(self, luma_ref: LumaReference=None):
-        self.refs.append(luma_ref)
-
-    def create_api_model(self, download_urls: list[str], max_refs=4):
-        if len(self.refs) == 0:
-            return None
-        api_refs: list[LumaImageRef] = []
-        for ref, url in zip(self.refs, download_urls):
-            api_ref = LumaImageRef(url=url, weight=ref.weight)
-            api_refs.append(api_ref)
-        return api_refs
-
-    def clone(self):
-        c = LumaReferenceChain()
-        for ref in self.refs:
-            c.add(ref)
-        return c
-
-
-class LumaConcept:
-    def __init__(self, key: str):
-        self.key = key
-
-
-class LumaConceptChain:
-    def __init__(self, str_list: list[str] = None):
-        self.concepts: list[LumaConcept] = []
-        if str_list is not None:
-            for c in str_list:
-                if c != "None":
-                    self.add(LumaConcept(key=c))
-
-    def add(self, concept: LumaConcept):
-        self.concepts.append(concept)
-
-    def create_api_model(self):
-        if len(self.concepts) == 0:
-            return None
-        api_concepts: list[LumaConceptObject] = []
-        for concept in self.concepts:
-            if concept.key == "None":
-                continue
-            api_concepts.append(LumaConceptObject(key=concept.key))
-        if len(api_concepts) == 0:
-            return None
-        return api_concepts
-
-    def clone(self):
-        c = LumaConceptChain()
-        for concept in self.concepts:
-            c.add(concept)
-        return c
-
-    def clone_and_merge(self, other: LumaConceptChain):
-        c = self.clone()
-        for concept in other.concepts:
-            c.add(concept)
-        return c
-
-
-def get_luma_concepts(include_none=False):
-    concepts = []
-    if include_none:
-        concepts.append("None")
-    return concepts + [
-        "truck_left",
-        "pan_right",
-        "pedestal_down",
-        "low_angle",
-        "pedestal_up",
-        "selfie",
-        "pan_left",
-        "roll_right",
-        "zoom_in",
-        "over_the_shoulder",
-        "orbit_right",
-        "orbit_left",
-        "static",
-        "tiny_planet",
-        "high_angle",
-        "bolt_cam",
-        "dolly_zoom",
-        "overhead",
-        "zoom_out",
-        "handheld",
-        "roll_left",
-        "pov",
-        "aerial_drone",
-        "push_in",
-        "crane_down",
-        "truck_right",
-        "tilt_down",
-        "elevator_doors",
-        "tilt_up",
-        "ground_level",
-        "pull_out",
-        "aerial",
-        "crane_up",
-        "eye_level"
-    ]
-
-
-class LumaImageModel(str, Enum):
-    photon_1 = "photon-1"
-    photon_flash_1 = "photon-flash-1"
-
-
-class LumaVideoModel(str, Enum):
-    ray_2 = "ray-2"
-    ray_flash_2 = "ray-flash-2"
-    ray_1_6 = "ray-1-6"
-
-
-class LumaAspectRatio(str, Enum):
-    ratio_1_1 = "1:1"
-    ratio_16_9 = "16:9"
-    ratio_9_16 = "9:16"
-    ratio_4_3 = "4:3"
-    ratio_3_4 = "3:4"
-    ratio_21_9 = "21:9"
-    ratio_9_21 = "9:21"
-
-
-class LumaVideoOutputResolution(str, Enum):
-    res_540p = "540p"
-    res_720p = "720p"
-    res_1080p = "1080p"
-    res_4k = "4k"
-
-
-class LumaVideoModelOutputDuration(str, Enum):
-    dur_5s = "5s"
-    dur_9s = "9s"
-
-
-class LumaGenerationType(str, Enum):
-    video = 'video'
-    image = 'image'
-
-
-class LumaState(str, Enum):
-    queued = "queued"
-    dreaming = "dreaming"
-    completed = "completed"
-    failed = "failed"
-
-
-class LumaAssets(BaseModel):
-    video: Optional[str] = Field(None, description='The URL of the video')
-    image: Optional[str] = Field(None, description='The URL of the image')
-    progress_video: Optional[str] = Field(None, description='The URL of the progress video')
-
-
-class LumaImageRef(BaseModel):
-    '''Used for image gen'''
-    url: str = Field(..., description='The URL of the image reference')
-    weight: confloat(ge=0.0, le=1.0) = Field(..., description='The weight of the image reference')
-
-
-class LumaImageReference(BaseModel):
-    '''Used for video gen'''
-    type: Optional[str] = Field('image', description='Input type, defaults to image')
-    url: str = Field(..., description='The URL of the image')
-
-
-class LumaModifyImageRef(BaseModel):
-    url: str = Field(..., description='The URL of the image reference')
-    weight: confloat(ge=0.0, le=1.0) = Field(..., description='The weight of the image reference')
-
-
-class LumaCharacterRef(BaseModel):
-    identity0: LumaImageIdentity = Field(..., description='The image identity object')
-
-
-class LumaImageIdentity(BaseModel):
-    images: list[str] = Field(..., description='The URLs of the image identity')
-
-
-class LumaGenerationReference(BaseModel):
-    type: str = Field('generation', description='Input type, defaults to generation')
-    id: str = Field(..., description='The ID of the generation')
-
-
-class LumaKeyframes(BaseModel):
-    frame0: Optional[Union[LumaImageReference, LumaGenerationReference]] = Field(None, description='')
-    frame1: Optional[Union[LumaImageReference, LumaGenerationReference]] = Field(None, description='')
-
-
-class LumaConceptObject(BaseModel):
-    key: str = Field(..., description='Camera Concept name')
-
-
-class LumaImageGenerationRequest(BaseModel):
-    prompt: str = Field(..., description='The prompt of the generation')
-    model: LumaImageModel = Field(LumaImageModel.photon_1, description='The image model used for the generation')
-    aspect_ratio: Optional[LumaAspectRatio] = Field(LumaAspectRatio.ratio_16_9, description='The aspect ratio of the generation')
-    image_ref: Optional[list[LumaImageRef]] = Field(None, description='List of image reference objects')
-    style_ref: Optional[list[LumaImageRef]] = Field(None, description='List of style reference objects')
-    character_ref: Optional[LumaCharacterRef] = Field(None, description='The image identity object')
-    modify_image_ref: Optional[LumaModifyImageRef] = Field(None, description='The modify image reference object')
-
-
-class LumaGenerationRequest(BaseModel):
-    prompt: str = Field(..., description='The prompt of the generation')
-    model: LumaVideoModel = Field(LumaVideoModel.ray_2, description='The video model used for the generation')
-    duration: Optional[LumaVideoModelOutputDuration] = Field(None, description='The duration of the generation')
-    aspect_ratio: Optional[LumaAspectRatio] = Field(None, description='The aspect ratio of the generation')
-    resolution: Optional[LumaVideoOutputResolution] = Field(None, description='The resolution of the generation')
-    loop: Optional[bool] = Field(None, description='Whether to loop the video')
-    keyframes: Optional[LumaKeyframes] = Field(None, description='The keyframes of the generation')
-    concepts: Optional[list[LumaConceptObject]] = Field(None, description='Camera Concepts to apply to generation')
-
-
-class LumaGeneration(BaseModel):
-    id: str = Field(..., description='The ID of the generation')
-    generation_type: LumaGenerationType = Field(..., description='Generation type, image or video')
-    state: LumaState = Field(..., description='The state of the generation')
-    failure_reason: Optional[str] = Field(None, description='The reason for the state of the generation')
-    created_at: str = Field(..., description='The date and time when the generation was created')
-    assets: Optional[LumaAssets] = Field(None, description='The assets of the generation')
-    model: str = Field(..., description='The model used for the generation')
-    request: Union[LumaGenerationRequest, LumaImageGenerationRequest] = Field(..., description="The request used for the generation")

comfy_api_nodes/apis/pixverse_api.py

@@ -1,146 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-pixverse_templates = {
-    "Microwave": 324641385496960,
-    "Suit Swagger": 328545151283968,
-    "Anything, Robot": 313358700761536,
-    "Subject 3 Fever": 327828816843648,
-    "kiss kiss": 315446315336768,
-}
-
-
-class PixverseIO:
-    TEMPLATE = "PIXVERSE_TEMPLATE"
-
-
-class PixverseStatus(int, Enum):
-    successful = 1
-    generating = 5
-    deleted = 6
-    contents_moderation = 7
-    failed = 8
-
-
-class PixverseAspectRatio(str, Enum):
-    ratio_16_9 = "16:9"
-    ratio_4_3 = "4:3"
-    ratio_1_1 = "1:1"
-    ratio_3_4 = "3:4"
-    ratio_9_16 = "9:16"
-
-
-class PixverseQuality(str, Enum):
-    res_360p = "360p"
-    res_540p = "540p"
-    res_720p = "720p"
-    res_1080p = "1080p"
-
-
-class PixverseDuration(int, Enum):
-    dur_5 = 5
-    dur_8 = 8
-
-
-class PixverseMotionMode(str, Enum):
-    normal = "normal"
-    fast = "fast"
-
-
-class PixverseStyle(str, Enum):
-    anime = "anime"
-    animation_3d = "3d_animation"
-    clay = "clay"
-    comic = "comic"
-    cyberpunk = "cyberpunk"
-
-
-# NOTE: forgoing descriptions for now in return for dev speed
-class PixverseTextVideoRequest(BaseModel):
-    aspect_ratio: PixverseAspectRatio = Field(...)
-    quality: PixverseQuality = Field(...)
-    duration: PixverseDuration = Field(...)
-    model: Optional[str] = Field("v3.5")
-    motion_mode: Optional[PixverseMotionMode] = Field(PixverseMotionMode.normal)
-    prompt: str = Field(...)
-    negative_prompt: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-    style: Optional[str] = Field(None)
-    template_id: Optional[int] = Field(None)
-    water_mark: Optional[bool] = Field(None)
-
-
-class PixverseImageVideoRequest(BaseModel):
-    quality: PixverseQuality = Field(...)
-    duration: PixverseDuration = Field(...)
-    img_id: int = Field(...)
-    model: Optional[str] = Field("v3.5")
-    motion_mode: Optional[PixverseMotionMode] = Field(PixverseMotionMode.normal)
-    prompt: str = Field(...)
-    negative_prompt: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-    style: Optional[str] = Field(None)
-    template_id: Optional[int] = Field(None)
-    water_mark: Optional[bool] = Field(None)
-
-
-class PixverseTransitionVideoRequest(BaseModel):
-    quality: PixverseQuality = Field(...)
-    duration: PixverseDuration = Field(...)
-    first_frame_img: int = Field(...)
-    last_frame_img: int = Field(...)
-    model: Optional[str] = Field("v3.5")
-    motion_mode: Optional[PixverseMotionMode] = Field(PixverseMotionMode.normal)
-    prompt: str = Field(...)
-    # negative_prompt: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-    # style: Optional[str] = Field(None)
-    # template_id: Optional[int] = Field(None)
-    # water_mark: Optional[bool] = Field(None)
-
-
-class PixverseImageUploadResponse(BaseModel):
-    ErrCode: Optional[int] = None
-    ErrMsg: Optional[str] = None
-    Resp: Optional[PixverseImgIdResponseObject] = Field(None, alias='Resp')
-
-
-class PixverseImgIdResponseObject(BaseModel):
-    img_id: Optional[int] = None
-
-
-class PixverseVideoResponse(BaseModel):
-    ErrCode: Optional[int] = Field(None)
-    ErrMsg: Optional[str] = Field(None)
-    Resp: Optional[PixverseVideoIdResponseObject] = Field(None)
-
-
-class PixverseVideoIdResponseObject(BaseModel):
-    video_id: int = Field(..., description='Video_id')
-
-
-class PixverseGenerationStatusResponse(BaseModel):
-    ErrCode: Optional[int] = Field(None)
-    ErrMsg: Optional[str] = Field(None)
-    Resp: Optional[PixverseGenerationStatusResponseObject] = Field(None)
-
-
-class PixverseGenerationStatusResponseObject(BaseModel):
-    create_time: Optional[str] = Field(None)
-    id: Optional[int] = Field(None)
-    modify_time: Optional[str] = Field(None)
-    negative_prompt: Optional[str] = Field(None)
-    outputHeight: Optional[int] = Field(None)
-    outputWidth: Optional[int] = Field(None)
-    prompt: Optional[str] = Field(None)
-    resolution_ratio: Optional[int] = Field(None)
-    seed: Optional[int] = Field(None)
-    size: Optional[int] = Field(None)
-    status: Optional[int] = Field(None)
-    style: Optional[str] = Field(None)
-    url: Optional[str] = Field(None)

comfy_api_nodes/apis/recraft_api.py

@@ -1,262 +0,0 @@
-from __future__ import annotations
-
-
-
-from enum import Enum
-from typing import Optional
-
-from pydantic import BaseModel, Field, conint, confloat
-
-
-class RecraftColor:
-    def __init__(self, r: int, g: int, b: int):
-        self.color = [r, g, b]
-
-    def create_api_model(self):
-        return RecraftColorObject(rgb=self.color)
-
-
-class RecraftColorChain:
-    def __init__(self):
-        self.colors: list[RecraftColor] = []
-
-    def get_first(self):
-        if len(self.colors) > 0:
-            return self.colors[0]
-        return None
-
-    def add(self, color: RecraftColor):
-        self.colors.append(color)
-
-    def create_api_model(self):
-        if not self.colors:
-            return None
-        colors_api = [x.create_api_model() for x in self.colors]
-        return colors_api
-
-    def clone(self):
-        c = RecraftColorChain()
-        for color in self.colors:
-            c.add(color)
-        return c
-
-    def clone_and_merge(self, other: RecraftColorChain):
-        c = self.clone()
-        for color in other.colors:
-            c.add(color)
-        return c
-
-
-class RecraftControls:
-    def __init__(self, colors: RecraftColorChain=None, background_color: RecraftColorChain=None,
-                 artistic_level: int=None, no_text: bool=None):
-        self.colors = colors
-        self.background_color = background_color
-        self.artistic_level = artistic_level
-        self.no_text = no_text
-
-    def create_api_model(self):
-        if self.colors is None and self.background_color is None and self.artistic_level is None and self.no_text is None:
-            return None
-        colors_api = None
-        background_color_api = None
-        if self.colors:
-            colors_api = self.colors.create_api_model()
-        if self.background_color:
-            first_background = self.background_color.get_first()
-            background_color_api = first_background.create_api_model() if first_background else None
-
-        return RecraftControlsObject(colors=colors_api, background_color=background_color_api,
-                                             artistic_level=self.artistic_level, no_text=self.no_text)
-
-
-class RecraftStyle:
-    def __init__(self, style: str=None, substyle: str=None, style_id: str=None):
-        self.style = style
-        if substyle == "None":
-            substyle = None
-        self.substyle = substyle
-        self.style_id = style_id
-
-
-class RecraftIO:
-    STYLEV3 = "RECRAFT_V3_STYLE"
-    COLOR = "RECRAFT_COLOR"
-    CONTROLS = "RECRAFT_CONTROLS"
-
-
-class RecraftStyleV3(str, Enum):
-    #any = 'any' NOTE: this does not work for some reason... why?
-    realistic_image = 'realistic_image'
-    digital_illustration = 'digital_illustration'
-    vector_illustration = 'vector_illustration'
-    logo_raster = 'logo_raster'
-
-
-def get_v3_substyles(style_v3: str, include_none=True) -> list[str]:
-    substyles: list[str] = []
-    if include_none:
-        substyles.append("None")
-    return substyles + dict_recraft_substyles_v3.get(style_v3, [])
-
-
-dict_recraft_substyles_v3 = {
-    RecraftStyleV3.realistic_image: [
-        "b_and_w",
-        "enterprise",
-        "evening_light",
-        "faded_nostalgia",
-        "forest_life",
-        "hard_flash",
-        "hdr",
-        "motion_blur",
-        "mystic_naturalism",
-        "natural_light",
-        "natural_tones",
-        "organic_calm",
-        "real_life_glow",
-        "retro_realism",
-        "retro_snapshot",
-        "studio_portrait",
-        "urban_drama",
-        "village_realism",
-        "warm_folk"
-    ],
-    RecraftStyleV3.digital_illustration: [
-        "2d_art_poster",
-        "2d_art_poster_2",
-        "antiquarian",
-        "bold_fantasy",
-        "child_book",
-        "child_books",
-        "cover",
-        "crosshatch",
-        "digital_engraving",
-        "engraving_color",
-        "expressionism",
-        "freehand_details",
-        "grain",
-        "grain_20",
-        "graphic_intensity",
-        "hand_drawn",
-        "hand_drawn_outline",
-        "handmade_3d",
-        "hard_comics",
-        "infantile_sketch",
-        "long_shadow",
-        "modern_folk",
-        "multicolor",
-        "neon_calm",
-        "noir",
-        "nostalgic_pastel",
-        "outline_details",
-        "pastel_gradient",
-        "pastel_sketch",
-        "pixel_art",
-        "plastic",
-        "pop_art",
-        "pop_renaissance",
-        "seamless",
-        "street_art",
-        "tablet_sketch",
-        "urban_glow",
-        "urban_sketching",
-        "vanilla_dreams",
-        "young_adult_book",
-        "young_adult_book_2"
-    ],
-    RecraftStyleV3.vector_illustration: [
-        "bold_stroke",
-        "chemistry",
-        "colored_stencil",
-        "contour_pop_art",
-        "cosmics",
-        "cutout",
-        "depressive",
-        "editorial",
-        "emotional_flat",
-        "engraving",
-        "infographical",
-        "line_art",
-        "line_circuit",
-        "linocut",
-        "marker_outline",
-        "mosaic",
-        "naivector",
-        "roundish_flat",
-        "seamless",
-        "segmented_colors",
-        "sharp_contrast",
-        "thin",
-        "vector_photo",
-        "vivid_shapes"
-    ],
-    RecraftStyleV3.logo_raster: [
-        "emblem_graffiti",
-        "emblem_pop_art",
-        "emblem_punk",
-        "emblem_stamp",
-        "emblem_vintage"
-    ],
-}
-
-
-class RecraftModel(str, Enum):
-    recraftv3 = 'recraftv3'
-    recraftv2 = 'recraftv2'
-
-
-class RecraftImageSize(str, Enum):
-    res_1024x1024 = '1024x1024'
-    res_1365x1024 = '1365x1024'
-    res_1024x1365 = '1024x1365'
-    res_1536x1024 = '1536x1024'
-    res_1024x1536 = '1024x1536'
-    res_1820x1024 = '1820x1024'
-    res_1024x1820 = '1024x1820'
-    res_1024x2048 = '1024x2048'
-    res_2048x1024 = '2048x1024'
-    res_1434x1024 = '1434x1024'
-    res_1024x1434 = '1024x1434'
-    res_1024x1280 = '1024x1280'
-    res_1280x1024 = '1280x1024'
-    res_1024x1707 = '1024x1707'
-    res_1707x1024 = '1707x1024'
-
-
-class RecraftColorObject(BaseModel):
-    rgb: list[int] = Field(..., description='An array of 3 integer values in range of 0...255 defining RGB Color Model')
-
-
-class RecraftControlsObject(BaseModel):
-    colors: Optional[list[RecraftColorObject]] = Field(None, description='An array of preferable colors')
-    background_color: Optional[RecraftColorObject] = Field(None, description='Use given color as a desired background color')
-    no_text: Optional[bool] = Field(None, description='Do not embed text layouts')
-    artistic_level: Optional[conint(ge=0, le=5)] = Field(None, description='Defines artistic tone of your image. At a simple level, the person looks straight at the camera in a static and clean style. Dynamic and eccentric levels introduce movement and creativity. The value should be in range [0..5].')
-
-
-class RecraftImageGenerationRequest(BaseModel):
-    prompt: str = Field(..., description='The text prompt describing the image to generate')
-    size: Optional[RecraftImageSize] = Field(None, description='The size of the generated image (e.g., "1024x1024")')
-    n: conint(ge=1, le=6) = Field(..., description='The number of images to generate')
-    negative_prompt: Optional[str] = Field(None, description='A text description of undesired elements on an image')
-    model: Optional[RecraftModel] = Field(RecraftModel.recraftv3, description='The model to use for generation (e.g., "recraftv3")')
-    style: Optional[str] = Field(None, description='The style to apply to the generated image (e.g., "digital_illustration")')
-    substyle: Optional[str] = Field(None, description='The substyle to apply to the generated image, depending on the style input')
-    controls: Optional[RecraftControlsObject] = Field(None, description='A set of custom parameters to tweak generation process')
-    style_id: Optional[str] = Field(None, description='Use a previously uploaded style as a reference; UUID')
-    strength: Optional[confloat(ge=0.0, le=1.0)] = Field(None, description='Defines the difference with the original image, should lie in [0, 1], where 0 means almost identical, and 1 means miserable similarity')
-    random_seed: Optional[int] = Field(None, description="Seed for video generation")
-    # text_layout
-
-
-class RecraftReturnedObject(BaseModel):
-    image_id: str = Field(..., description='Unique identifier for the generated image')
-    url: str = Field(..., description='URL to access the generated image')
-
-
-class RecraftImageGenerationResponse(BaseModel):
-    created: int = Field(..., description='Unix timestamp when the generation was created')
-    credits: int = Field(..., description='Number of credits used for the generation')
-    data: Optional[list[RecraftReturnedObject]] = Field(None, description='Array of generated image information')
-    image: Optional[RecraftReturnedObject] = Field(None, description='Single generated image')

comfy_api_nodes/apis/request_logger.py

@@ -1,125 +0,0 @@
-import os
-import datetime
-import json
-import logging
-import folder_paths
-
-# Get the logger instance
-logger = logging.getLogger(__name__)
-
-def get_log_directory():
-    """
-    Ensures the API log directory exists within ComfyUI's temp directory
-    and returns its path.
-    """
-    base_temp_dir = folder_paths.get_temp_directory()
-    log_dir = os.path.join(base_temp_dir, "api_logs")
-    try:
-        os.makedirs(log_dir, exist_ok=True)
-    except Exception as e:
-        logger.error(f"Error creating API log directory {log_dir}: {e}")
-        # Fallback to base temp directory if sub-directory creation fails
-        return base_temp_dir
-    return log_dir
-
-def _format_data_for_logging(data):
-    """Helper to format data (dict, str, bytes) for logging."""
-    if isinstance(data, bytes):
-        try:
-            return data.decode('utf-8')  # Try to decode as text
-        except UnicodeDecodeError:
-            return f"[Binary data of length {len(data)} bytes]"
-    elif isinstance(data, (dict, list)):
-        try:
-            return json.dumps(data, indent=2, ensure_ascii=False)
-        except TypeError:
-            return str(data) # Fallback for non-serializable objects
-    return str(data)
-
-def log_request_response(
-    operation_id: str,
-    request_method: str,
-    request_url: str,
-    request_headers: dict | None = None,
-    request_params: dict | None = None,
-    request_data: any = None,
-    response_status_code: int | None = None,
-    response_headers: dict | None = None,
-    response_content: any = None,
-    error_message: str | None = None
-):
-    """
-    Logs API request and response details to a file in the temp/api_logs directory.
-    """
-    log_dir = get_log_directory()
-    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")
-    filename = f"{timestamp}_{operation_id.replace('/', '_').replace(':', '_')}.log"
-    filepath = os.path.join(log_dir, filename)
-
-    log_content = []
-
-    log_content.append(f"Timestamp: {datetime.datetime.now().isoformat()}")
-    log_content.append(f"Operation ID: {operation_id}")
-    log_content.append("-" * 30 + " REQUEST " + "-" * 30)
-    log_content.append(f"Method: {request_method}")
-    log_content.append(f"URL: {request_url}")
-    if request_headers:
-        log_content.append(f"Headers:\n{_format_data_for_logging(request_headers)}")
-    if request_params:
-        log_content.append(f"Params:\n{_format_data_for_logging(request_params)}")
-    if request_data:
-        log_content.append(f"Data/Body:\n{_format_data_for_logging(request_data)}")
-
-    log_content.append("\n" + "-" * 30 + " RESPONSE " + "-" * 30)
-    if response_status_code is not None:
-        log_content.append(f"Status Code: {response_status_code}")
-    if response_headers:
-        log_content.append(f"Headers:\n{_format_data_for_logging(response_headers)}")
-    if response_content:
-        log_content.append(f"Content:\n{_format_data_for_logging(response_content)}")
-    if error_message:
-        log_content.append(f"Error:\n{error_message}")
-
-    try:
-        with open(filepath, "w", encoding="utf-8") as f:
-            f.write("\n".join(log_content))
-        logger.debug(f"API log saved to: {filepath}")
-    except Exception as e:
-        logger.error(f"Error writing API log to {filepath}: {e}")
-
-if __name__ == '__main__':
-    # Example usage (for testing the logger directly)
-    logger.setLevel(logging.DEBUG)
-    # Mock folder_paths for direct execution if not running within ComfyUI full context
-    if not hasattr(folder_paths, 'get_temp_directory'):
-        class MockFolderPaths:
-            def get_temp_directory(self):
-                # Create a local temp dir for testing if needed
-                p = os.path.join(os.path.dirname(__file__), 'temp_test_logs')
-                os.makedirs(p, exist_ok=True)
-                return p
-        folder_paths = MockFolderPaths()
-
-    log_request_response(
-        operation_id="test_operation_get",
-        request_method="GET",
-        request_url="https://api.example.com/test",
-        request_headers={"Authorization": "Bearer testtoken"},
-        request_params={"param1": "value1"},
-        response_status_code=200,
-        response_content={"message": "Success!"}
-    )
-    log_request_response(
-        operation_id="test_operation_post_error",
-        request_method="POST",
-        request_url="https://api.example.com/submit",
-        request_data={"key": "value", "nested": {"num": 123}},
-        error_message="Connection timed out"
-    )
-    log_request_response(
-        operation_id="test_binary_response",
-        request_method="GET",
-        request_url="https://api.example.com/image.png",
-        response_status_code=200,
-        response_content=b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR...' # Sample binary data
-    )

comfy_api_nodes/apis/rodin_api.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Optional, List
-from pydantic import BaseModel, Field
-
-
-class Rodin3DGenerateRequest(BaseModel):
-    seed: int = Field(..., description="seed_")
-    tier: str = Field(..., description="Tier of generation.")
-    material: str = Field(..., description="The material type.")
-    quality: str = Field(..., description="The generation quality of the mesh.")
-    mesh_mode: str = Field(..., description="It controls the type of faces of generated models.")
-
-class GenerateJobsData(BaseModel):
-    uuids: List[str] = Field(..., description="str LIST")
-    subscription_key: str = Field(..., description="subscription key")
-
-class Rodin3DGenerateResponse(BaseModel):
-    message: Optional[str] = Field(None, description="Return message.")
-    prompt: Optional[str] = Field(None, description="Generated Prompt from image.")
-    submit_time: Optional[str] = Field(None, description="Submit Time")
-    uuid: Optional[str] = Field(None, description="Task str")
-    jobs: Optional[GenerateJobsData] = Field(None, description="Details of jobs")
-
-class JobStatus(str, Enum):
-    """
-    Status for jobs
-    """
-    Done = "Done"
-    Failed = "Failed"
-    Generating = "Generating"
-    Waiting = "Waiting"
-
-class Rodin3DCheckStatusRequest(BaseModel):
-    subscription_key: str = Field(..., description="subscription from generate endpoint")
-
-class JobItem(BaseModel):
-    uuid: str = Field(..., description="uuid")
-    status: JobStatus = Field(...,description="Status Currently")
-
-class Rodin3DCheckStatusResponse(BaseModel):
-    jobs: List[JobItem] = Field(..., description="Job status List")
-
-class Rodin3DDownloadRequest(BaseModel):
-    task_uuid: str = Field(..., description="Task str")
-
-class RodinResourceItem(BaseModel):
-    url: str = Field(..., description="Download Url")
-    name: str = Field(..., description="File name with ext")
-
-class Rodin3DDownloadResponse(BaseModel):
-    list: List[RodinResourceItem] = Field(..., description="Source List")
-
-
-
-

comfy_api_nodes/apis/stability_api.py

@@ -1,127 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Optional
-
-from pydantic import BaseModel, Field, confloat
-
-
-class StabilityFormat(str, Enum):
-    png = 'png'
-    jpeg = 'jpeg'
-    webp = 'webp'
-
-
-class StabilityAspectRatio(str, Enum):
-    ratio_1_1 = "1:1"
-    ratio_16_9 = "16:9"
-    ratio_9_16 = "9:16"
-    ratio_3_2 = "3:2"
-    ratio_2_3 = "2:3"
-    ratio_5_4 = "5:4"
-    ratio_4_5 = "4:5"
-    ratio_21_9 = "21:9"
-    ratio_9_21 = "9:21"
-
-
-def get_stability_style_presets(include_none=True):
-    presets = []
-    if include_none:
-        presets.append("None")
-    return presets + [x.value for x in StabilityStylePreset]
-
-
-class StabilityStylePreset(str, Enum):
-    _3d_model = "3d-model"
-    analog_film = "analog-film"
-    anime = "anime"
-    cinematic = "cinematic"
-    comic_book = "comic-book"
-    digital_art = "digital-art"
-    enhance = "enhance"
-    fantasy_art = "fantasy-art"
-    isometric = "isometric"
-    line_art = "line-art"
-    low_poly = "low-poly"
-    modeling_compound = "modeling-compound"
-    neon_punk = "neon-punk"
-    origami = "origami"
-    photographic = "photographic"
-    pixel_art = "pixel-art"
-    tile_texture = "tile-texture"
-
-
-class Stability_SD3_5_Model(str, Enum):
-    sd3_5_large = "sd3.5-large"
-    # sd3_5_large_turbo = "sd3.5-large-turbo"
-    sd3_5_medium = "sd3.5-medium"
-
-
-class Stability_SD3_5_GenerationMode(str, Enum):
-    text_to_image = "text-to-image"
-    image_to_image = "image-to-image"
-
-
-class StabilityStable3_5Request(BaseModel):
-    model: str = Field(...)
-    mode: str = Field(...)
-    prompt: str = Field(...)
-    negative_prompt: Optional[str] = Field(None)
-    aspect_ratio: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-    output_format: Optional[str] = Field(StabilityFormat.png.value)
-    image: Optional[str] = Field(None)
-    style_preset: Optional[str] = Field(None)
-    cfg_scale: float = Field(...)
-    strength: Optional[confloat(ge=0.0, le=1.0)] = Field(None)
-
-
-class StabilityUpscaleConservativeRequest(BaseModel):
-    prompt: str = Field(...)
-    negative_prompt: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-    output_format: Optional[str] = Field(StabilityFormat.png.value)
-    image: Optional[str] = Field(None)
-    creativity: Optional[confloat(ge=0.2, le=0.5)] = Field(None)
-
-
-class StabilityUpscaleCreativeRequest(BaseModel):
-    prompt: str = Field(...)
-    negative_prompt: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-    output_format: Optional[str] = Field(StabilityFormat.png.value)
-    image: Optional[str] = Field(None)
-    creativity: Optional[confloat(ge=0.1, le=0.5)] = Field(None)
-    style_preset: Optional[str] = Field(None)
-
-
-class StabilityStableUltraRequest(BaseModel):
-    prompt: str = Field(...)
-    negative_prompt: Optional[str] = Field(None)
-    aspect_ratio: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-    output_format: Optional[str] = Field(StabilityFormat.png.value)
-    image: Optional[str] = Field(None)
-    style_preset: Optional[str] = Field(None)
-    strength: Optional[confloat(ge=0.0, le=1.0)] = Field(None)
-
-
-class StabilityStableUltraResponse(BaseModel):
-    image: Optional[str] = Field(None)
-    finish_reason: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-
-
-class StabilityResultsGetResponse(BaseModel):
-    image: Optional[str] = Field(None)
-    finish_reason: Optional[str] = Field(None)
-    seed: Optional[int] = Field(None)
-    id: Optional[str] = Field(None)
-    name: Optional[str] = Field(None)
-    errors: Optional[list[str]] = Field(None)
-    status: Optional[str] = Field(None)
-    result: Optional[str] = Field(None)
-
-
-class StabilityAsyncResponse(BaseModel):
-    id: Optional[str] = Field(None)

comfy_api_nodes/apis/tripo_api.py

@@ -1,275 +0,0 @@
-from __future__ import annotations
-from comfy_api_nodes.apis import (
-    TripoModelVersion,
-    TripoTextureQuality,
-)
-from enum import Enum
-from typing import Optional, List, Dict, Any, Union
-
-from pydantic import BaseModel, Field, RootModel
-
-class TripoStyle(str, Enum):
-    PERSON_TO_CARTOON = "person:person2cartoon"
-    ANIMAL_VENOM = "animal:venom"
-    OBJECT_CLAY = "object:clay"
-    OBJECT_STEAMPUNK = "object:steampunk"
-    OBJECT_CHRISTMAS = "object:christmas"
-    OBJECT_BARBIE = "object:barbie"
-    GOLD = "gold"
-    ANCIENT_BRONZE = "ancient_bronze"
-    NONE = "None"
-
-class TripoTaskType(str, Enum):
-    TEXT_TO_MODEL = "text_to_model"
-    IMAGE_TO_MODEL = "image_to_model"
-    MULTIVIEW_TO_MODEL = "multiview_to_model"
-    TEXTURE_MODEL = "texture_model"
-    REFINE_MODEL = "refine_model"
-    ANIMATE_PRERIGCHECK = "animate_prerigcheck"
-    ANIMATE_RIG = "animate_rig"
-    ANIMATE_RETARGET = "animate_retarget"
-    STYLIZE_MODEL = "stylize_model"
-    CONVERT_MODEL = "convert_model"
-
-class TripoTextureAlignment(str, Enum):
-    ORIGINAL_IMAGE = "original_image"
-    GEOMETRY = "geometry"
-
-class TripoOrientation(str, Enum):
-    ALIGN_IMAGE = "align_image"
-    DEFAULT = "default"
-
-class TripoOutFormat(str, Enum):
-    GLB = "glb"
-    FBX = "fbx"
-
-class TripoTopology(str, Enum):
-    BIP = "bip"
-    QUAD = "quad"
-
-class TripoSpec(str, Enum):
-    MIXAMO = "mixamo"
-    TRIPO = "tripo"
-
-class TripoAnimation(str, Enum):
-    IDLE = "preset:idle"
-    WALK = "preset:walk"
-    CLIMB = "preset:climb"
-    JUMP = "preset:jump"
-    RUN = "preset:run"
-    SLASH = "preset:slash"
-    SHOOT = "preset:shoot"
-    HURT = "preset:hurt"
-    FALL = "preset:fall"
-    TURN = "preset:turn"
-
-class TripoStylizeStyle(str, Enum):
-    LEGO = "lego"
-    VOXEL = "voxel"
-    VORONOI = "voronoi"
-    MINECRAFT = "minecraft"
-
-class TripoConvertFormat(str, Enum):
-    GLTF = "GLTF"
-    USDZ = "USDZ"
-    FBX = "FBX"
-    OBJ = "OBJ"
-    STL = "STL"
-    _3MF = "3MF"
-
-class TripoTextureFormat(str, Enum):
-    BMP = "BMP"
-    DPX = "DPX"
-    HDR = "HDR"
-    JPEG = "JPEG"
-    OPEN_EXR = "OPEN_EXR"
-    PNG = "PNG"
-    TARGA = "TARGA"
-    TIFF = "TIFF"
-    WEBP = "WEBP"
-
-class TripoTaskStatus(str, Enum):
-    QUEUED = "queued"
-    RUNNING = "running"
-    SUCCESS = "success"
-    FAILED = "failed"
-    CANCELLED = "cancelled"
-    UNKNOWN = "unknown"
-    BANNED = "banned"
-    EXPIRED = "expired"
-
-class TripoFileTokenReference(BaseModel):
-    type: Optional[str] = Field(None, description='The type of the reference')
-    file_token: str
-
-class TripoUrlReference(BaseModel):
-    type: Optional[str] = Field(None, description='The type of the reference')
-    url: str
-
-class TripoObjectStorage(BaseModel):
-    bucket: str
-    key: str
-
-class TripoObjectReference(BaseModel):
-    type: str
-    object: TripoObjectStorage
-
-class TripoFileEmptyReference(BaseModel):
-    pass
-
-class TripoFileReference(RootModel):
-    root: Union[TripoFileTokenReference, TripoUrlReference, TripoObjectReference, TripoFileEmptyReference]
-
-class TripoGetStsTokenRequest(BaseModel):
-    format: str = Field(..., description='The format of the image')
-
-class TripoTextToModelRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.TEXT_TO_MODEL, description='Type of task')
-    prompt: str = Field(..., description='The text prompt describing the model to generate', max_length=1024)
-    negative_prompt: Optional[str] = Field(None, description='The negative text prompt', max_length=1024)
-    model_version: Optional[TripoModelVersion] = TripoModelVersion.V2_5
-    face_limit: Optional[int] = Field(None, description='The number of faces to limit the generation to')
-    texture: Optional[bool] = Field(True, description='Whether to apply texture to the generated model')
-    pbr: Optional[bool] = Field(True, description='Whether to apply PBR to the generated model')
-    image_seed: Optional[int] = Field(None, description='The seed for the text')
-    model_seed: Optional[int] = Field(None, description='The seed for the model')
-    texture_seed: Optional[int] = Field(None, description='The seed for the texture')
-    texture_quality: Optional[TripoTextureQuality] = TripoTextureQuality.standard
-    style: Optional[TripoStyle] = None
-    auto_size: Optional[bool] = Field(False, description='Whether to auto-size the model')
-    quad: Optional[bool] = Field(False, description='Whether to apply quad to the generated model')
-
-class TripoImageToModelRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.IMAGE_TO_MODEL, description='Type of task')
-    file: TripoFileReference = Field(..., description='The file reference to convert to a model')
-    model_version: Optional[TripoModelVersion] = Field(None, description='The model version to use for generation')
-    face_limit: Optional[int] = Field(None, description='The number of faces to limit the generation to')
-    texture: Optional[bool] = Field(True, description='Whether to apply texture to the generated model')
-    pbr: Optional[bool] = Field(True, description='Whether to apply PBR to the generated model')
-    model_seed: Optional[int] = Field(None, description='The seed for the model')
-    texture_seed: Optional[int] = Field(None, description='The seed for the texture')
-    texture_quality: Optional[TripoTextureQuality] = TripoTextureQuality.standard
-    texture_alignment: Optional[TripoTextureAlignment] = Field(TripoTextureAlignment.ORIGINAL_IMAGE, description='The texture alignment method')
-    style: Optional[TripoStyle] = Field(None, description='The style to apply to the generated model')
-    auto_size: Optional[bool] = Field(False, description='Whether to auto-size the model')
-    orientation: Optional[TripoOrientation] = TripoOrientation.DEFAULT
-    quad: Optional[bool] = Field(False, description='Whether to apply quad to the generated model')
-
-class TripoMultiviewToModelRequest(BaseModel):
-    type: TripoTaskType = TripoTaskType.MULTIVIEW_TO_MODEL
-    files: List[TripoFileReference] = Field(..., description='The file references to convert to a model')
-    model_version: Optional[TripoModelVersion] = Field(None, description='The model version to use for generation')
-    orthographic_projection: Optional[bool] = Field(False, description='Whether to use orthographic projection')
-    face_limit: Optional[int] = Field(None, description='The number of faces to limit the generation to')
-    texture: Optional[bool] = Field(True, description='Whether to apply texture to the generated model')
-    pbr: Optional[bool] = Field(True, description='Whether to apply PBR to the generated model')
-    model_seed: Optional[int] = Field(None, description='The seed for the model')
-    texture_seed: Optional[int] = Field(None, description='The seed for the texture')
-    texture_quality: Optional[TripoTextureQuality] = TripoTextureQuality.standard
-    texture_alignment: Optional[TripoTextureAlignment] = TripoTextureAlignment.ORIGINAL_IMAGE
-    auto_size: Optional[bool] = Field(False, description='Whether to auto-size the model')
-    orientation: Optional[TripoOrientation] = Field(TripoOrientation.DEFAULT, description='The orientation for the model')
-    quad: Optional[bool] = Field(False, description='Whether to apply quad to the generated model')
-
-class TripoTextureModelRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.TEXTURE_MODEL, description='Type of task')
-    original_model_task_id: str = Field(..., description='The task ID of the original model')
-    texture: Optional[bool] = Field(True, description='Whether to apply texture to the model')
-    pbr: Optional[bool] = Field(True, description='Whether to apply PBR to the model')
-    model_seed: Optional[int] = Field(None, description='The seed for the model')
-    texture_seed: Optional[int] = Field(None, description='The seed for the texture')
-    texture_quality: Optional[TripoTextureQuality] = Field(None, description='The quality of the texture')
-    texture_alignment: Optional[TripoTextureAlignment] = Field(TripoTextureAlignment.ORIGINAL_IMAGE, description='The texture alignment method')
-
-class TripoRefineModelRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.REFINE_MODEL, description='Type of task')
-    draft_model_task_id: str = Field(..., description='The task ID of the draft model')
-
-class TripoAnimatePrerigcheckRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.ANIMATE_PRERIGCHECK, description='Type of task')
-    original_model_task_id: str = Field(..., description='The task ID of the original model')
-
-class TripoAnimateRigRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.ANIMATE_RIG, description='Type of task')
-    original_model_task_id: str = Field(..., description='The task ID of the original model')
-    out_format: Optional[TripoOutFormat] = Field(TripoOutFormat.GLB, description='The output format')
-    spec: Optional[TripoSpec] = Field(TripoSpec.TRIPO, description='The specification for rigging')
-
-class TripoAnimateRetargetRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.ANIMATE_RETARGET, description='Type of task')
-    original_model_task_id: str = Field(..., description='The task ID of the original model')
-    animation: TripoAnimation = Field(..., description='The animation to apply')
-    out_format: Optional[TripoOutFormat] = Field(TripoOutFormat.GLB, description='The output format')
-    bake_animation: Optional[bool] = Field(True, description='Whether to bake the animation')
-
-class TripoStylizeModelRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.STYLIZE_MODEL, description='Type of task')
-    style: TripoStylizeStyle = Field(..., description='The style to apply to the model')
-    original_model_task_id: str = Field(..., description='The task ID of the original model')
-    block_size: Optional[int] = Field(80, description='The block size for stylization')
-
-class TripoConvertModelRequest(BaseModel):
-    type: TripoTaskType = Field(TripoTaskType.CONVERT_MODEL, description='Type of task')
-    format: TripoConvertFormat = Field(..., description='The format to convert to')
-    original_model_task_id: str = Field(..., description='The task ID of the original model')
-    quad: Optional[bool] = Field(False, description='Whether to apply quad to the model')
-    force_symmetry: Optional[bool] = Field(False, description='Whether to force symmetry')
-    face_limit: Optional[int] = Field(10000, description='The number of faces to limit the conversion to')
-    flatten_bottom: Optional[bool] = Field(False, description='Whether to flatten the bottom of the model')
-    flatten_bottom_threshold: Optional[float] = Field(0.01, description='The threshold for flattening the bottom')
-    texture_size: Optional[int] = Field(4096, description='The size of the texture')
-    texture_format: Optional[TripoTextureFormat] = Field(TripoTextureFormat.JPEG, description='The format of the texture')
-    pivot_to_center_bottom: Optional[bool] = Field(False, description='Whether to pivot to the center bottom')
-
-class TripoTaskRequest(RootModel):
-    root: Union[
-        TripoTextToModelRequest,
-        TripoImageToModelRequest,
-        TripoMultiviewToModelRequest,
-        TripoTextureModelRequest,
-        TripoRefineModelRequest,
-        TripoAnimatePrerigcheckRequest,
-        TripoAnimateRigRequest,
-        TripoAnimateRetargetRequest,
-        TripoStylizeModelRequest,
-        TripoConvertModelRequest
-    ]
-
-class TripoTaskOutput(BaseModel):
-    model: Optional[str] = Field(None, description='URL to the model')
-    base_model: Optional[str] = Field(None, description='URL to the base model')
-    pbr_model: Optional[str] = Field(None, description='URL to the PBR model')
-    rendered_image: Optional[str] = Field(None, description='URL to the rendered image')
-    riggable: Optional[bool] = Field(None, description='Whether the model is riggable')
-
-class TripoTask(BaseModel):
-    task_id: str = Field(..., description='The task ID')
-    type: Optional[str] = Field(None, description='The type of task')
-    status: Optional[TripoTaskStatus] = Field(None, description='The status of the task')
-    input: Optional[Dict[str, Any]] = Field(None, description='The input parameters for the task')
-    output: Optional[TripoTaskOutput] = Field(None, description='The output of the task')
-    progress: Optional[int] = Field(None, description='The progress of the task', ge=0, le=100)
-    create_time: Optional[int] = Field(None, description='The creation time of the task')
-    running_left_time: Optional[int] = Field(None, description='The estimated time left for the task')
-    queue_position: Optional[int] = Field(None, description='The position in the queue')
-
-class TripoTaskResponse(BaseModel):
-    code: int = Field(0, description='The response code')
-    data: TripoTask = Field(..., description='The task data')
-
-class TripoGeneralResponse(BaseModel):
-    code: int = Field(0, description='The response code')
-    data: Dict[str, str] = Field(..., description='The task ID data')
-
-class TripoBalanceData(BaseModel):
-    balance: float = Field(..., description='The account balance')
-    frozen: float = Field(..., description='The frozen balance')
-
-class TripoBalanceResponse(BaseModel):
-    code: int = Field(0, description='The response code')
-    data: TripoBalanceData = Field(..., description='The balance data')
-
-class TripoErrorResponse(BaseModel):
-    code: int = Field(..., description='The error code')
-    message: str = Field(..., description='The error message')
-    suggestion: str = Field(..., description='The suggestion for fixing the error')

comfy_api_nodes/canary.py

@@ -1,10 +0,0 @@
-import av
-
-ver = av.__version__.split(".")
-if int(ver[0]) < 14:
-    raise Exception("INSTALL NEW VERSION OF PYAV TO USE API NODES.")
-
-if int(ver[0]) == 14 and int(ver[1]) < 2:
-    raise Exception("INSTALL NEW VERSION OF PYAV TO USE API NODES.")
-
-NODE_CLASS_MAPPINGS = {}

comfy_api_nodes/mapper_utils.py

@@ -1,116 +0,0 @@
-from enum import Enum
-
-from pydantic.fields import FieldInfo
-from pydantic import BaseModel
-from pydantic_core import PydanticUndefined
-
-from comfy.comfy_types.node_typing import IO, InputTypeOptions
-
-NodeInput = tuple[IO, InputTypeOptions]
-
-
-def _create_base_config(field_info: FieldInfo) -> InputTypeOptions:
-    config = {}
-    if hasattr(field_info, "default") and field_info.default is not PydanticUndefined:
-        config["default"] = field_info.default
-    if hasattr(field_info, "description") and field_info.description is not None:
-        config["tooltip"] = field_info.description
-    return config
-
-
-def _get_number_constraints_config(field_info: FieldInfo) -> dict:
-    config = {}
-    if hasattr(field_info, "metadata"):
-        metadata = field_info.metadata
-        for constraint in metadata:
-            if hasattr(constraint, "ge"):
-                config["min"] = constraint.ge
-            if hasattr(constraint, "le"):
-                config["max"] = constraint.le
-            if hasattr(constraint, "multiple_of"):
-                config["step"] = constraint.multiple_of
-    return config
-
-
-def _model_field_to_image_input(field_info: FieldInfo, **kwargs) -> NodeInput:
-    return IO.IMAGE, {
-        **_create_base_config(field_info),
-        **kwargs,
-    }
-
-
-def _model_field_to_string_input(field_info: FieldInfo, **kwargs) -> NodeInput:
-    return IO.STRING, {
-        **_create_base_config(field_info),
-        **kwargs,
-    }
-
-
-def _model_field_to_float_input(field_info: FieldInfo, **kwargs) -> NodeInput:
-    return IO.FLOAT, {
-        **_create_base_config(field_info),
-        **_get_number_constraints_config(field_info),
-        **kwargs,
-    }
-
-
-def _model_field_to_int_input(field_info: FieldInfo, **kwargs) -> NodeInput:
-    return IO.INT, {
-        **_create_base_config(field_info),
-        **_get_number_constraints_config(field_info),
-        **kwargs,
-    }
-
-
-def _model_field_to_combo_input(
-    field_info: FieldInfo, enum_type: type[Enum] = None, **kwargs
-) -> NodeInput:
-    combo_config = {}
-    if enum_type is not None:
-        combo_config["options"] = [option.value for option in enum_type]
-    combo_config = {
-        **combo_config,
-        **_create_base_config(field_info),
-        **kwargs,
-    }
-    return IO.COMBO, combo_config
-
-
-def model_field_to_node_input(
-    input_type: IO, base_model: type[BaseModel], field_name: str, **kwargs
-) -> NodeInput:
-    """
-    Maps a field from a Pydantic model to a Comfy node input.
-
-    Args:
-        input_type: The type of the input.
-        base_model: The Pydantic model to map the field from.
-        field_name: The name of the field to map.
-        **kwargs: Additional key/values to include in the input options.
-
-    Note:
-        For combo inputs, pass an `Enum` to the `enum_type` keyword argument to populate the options automatically.
-
-    Example:
-        >>> model_field_to_node_input(IO.STRING, MyModel, "my_field", multiline=True)
-        >>> model_field_to_node_input(IO.COMBO, MyModel, "my_field", enum_type=MyEnum)
-        >>> model_field_to_node_input(IO.FLOAT, MyModel, "my_field", slider=True)
-    """
-    field_info: FieldInfo = base_model.model_fields[field_name]
-    result: NodeInput
-
-    if input_type == IO.IMAGE:
-        result = _model_field_to_image_input(field_info, **kwargs)
-    elif input_type == IO.STRING:
-        result = _model_field_to_string_input(field_info, **kwargs)
-    elif input_type == IO.FLOAT:
-        result = _model_field_to_float_input(field_info, **kwargs)
-    elif input_type == IO.INT:
-        result = _model_field_to_int_input(field_info, **kwargs)
-    elif input_type == IO.COMBO:
-        result = _model_field_to_combo_input(field_info, **kwargs)
-    else:
-        message = f"Invalid input type: {input_type}"
-        raise ValueError(message)
-
-    return result

comfy_api_nodes/nodes_bfl.py

@@ -1,1075 +0,0 @@
-import io
-from inspect import cleandoc
-from typing import Union, Optional
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC
-from comfy_api_nodes.apis.bfl_api import (
-    BFLStatus,
-    BFLFluxExpandImageRequest,
-    BFLFluxFillImageRequest,
-    BFLFluxCannyImageRequest,
-    BFLFluxDepthImageRequest,
-    BFLFluxProGenerateRequest,
-    BFLFluxKontextProGenerateRequest,
-    BFLFluxProUltraGenerateRequest,
-    BFLFluxProGenerateResponse,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-)
-from comfy_api_nodes.apinode_utils import (
-    downscale_image_tensor,
-    validate_aspect_ratio,
-    process_image_response,
-    resize_mask_to_image,
-    validate_string,
-)
-
-import numpy as np
-from PIL import Image
-import requests
-import torch
-import base64
-import time
-from server import PromptServer
-
-
-def convert_mask_to_image(mask: torch.Tensor):
-    """
-    Make mask have the expected amount of dims (4) and channels (3) to be recognized as an image.
-    """
-    mask = mask.unsqueeze(-1)
-    mask = torch.cat([mask]*3, dim=-1)
-    return mask
-
-
-def handle_bfl_synchronous_operation(
-    operation: SynchronousOperation,
-    timeout_bfl_calls=360,
-    node_id: Union[str, None] = None,
-):
-    response_api: BFLFluxProGenerateResponse = operation.execute()
-    return _poll_until_generated(
-        response_api.polling_url, timeout=timeout_bfl_calls, node_id=node_id
-    )
-
-
-def _poll_until_generated(
-    polling_url: str, timeout=360, node_id: Union[str, None] = None
-):
-    # used bfl-comfy-nodes to verify code implementation:
-    # https://github.com/black-forest-labs/bfl-comfy-nodes/tree/main
-    start_time = time.time()
-    retries_404 = 0
-    max_retries_404 = 5
-    retry_404_seconds = 2
-    retry_202_seconds = 2
-    retry_pending_seconds = 1
-    request = requests.Request(method=HttpMethod.GET, url=polling_url)
-    # NOTE: should True loop be replaced with checking if workflow has been interrupted?
-    while True:
-        if node_id:
-            time_elapsed = time.time() - start_time
-            PromptServer.instance.send_progress_text(
-                f"Generating ({time_elapsed:.0f}s)", node_id
-            )
-
-        response = requests.Session().send(request.prepare())
-        if response.status_code == 200:
-            result = response.json()
-            if result["status"] == BFLStatus.ready:
-                img_url = result["result"]["sample"]
-                if node_id:
-                    PromptServer.instance.send_progress_text(
-                        f"Result URL: {img_url}", node_id
-                    )
-                img_response = requests.get(img_url)
-                return process_image_response(img_response)
-            elif result["status"] in [
-                BFLStatus.request_moderated,
-                BFLStatus.content_moderated,
-            ]:
-                status = result["status"]
-                raise Exception(
-                    f"BFL API did not return an image due to: {status}."
-                )
-            elif result["status"] == BFLStatus.error:
-                raise Exception(f"BFL API encountered an error: {result}.")
-            elif result["status"] == BFLStatus.pending:
-                time.sleep(retry_pending_seconds)
-                continue
-        elif response.status_code == 404:
-            if retries_404 < max_retries_404:
-                retries_404 += 1
-                time.sleep(retry_404_seconds)
-                continue
-            raise Exception(
-                f"BFL API could not find task after {max_retries_404} tries."
-            )
-        elif response.status_code == 202:
-            time.sleep(retry_202_seconds)
-        elif time.time() - start_time > timeout:
-            raise Exception(
-                f"BFL API experienced a timeout; could not return request under {timeout} seconds."
-            )
-        else:
-            raise Exception(f"BFL API encountered an error: {response.json()}")
-
-def convert_image_to_base64(image: torch.Tensor):
-    scaled_image = downscale_image_tensor(image, total_pixels=2048 * 2048)
-    # remove batch dimension if present
-    if len(scaled_image.shape) > 3:
-        scaled_image = scaled_image[0]
-    image_np = (scaled_image.numpy() * 255).astype(np.uint8)
-    img = Image.fromarray(image_np)
-    img_byte_arr = io.BytesIO()
-    img.save(img_byte_arr, format="PNG")
-    return base64.b64encode(img_byte_arr.getvalue()).decode()
-
-
-class FluxProUltraImageNode(ComfyNodeABC):
-    """
-    Generates images using Flux Pro 1.1 Ultra via api based on prompt and resolution.
-    """
-
-    MINIMUM_RATIO = 1 / 4
-    MAXIMUM_RATIO = 4 / 1
-    MINIMUM_RATIO_STR = "1:4"
-    MAXIMUM_RATIO_STR = "4:1"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "prompt_upsampling": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-                "aspect_ratio": (
-                    IO.STRING,
-                    {
-                        "default": "16:9",
-                        "tooltip": "Aspect ratio of image; must be between 1:4 and 4:1.",
-                    },
-                ),
-                "raw": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "When True, generate less processed, more natural-looking images.",
-                    },
-                ),
-            },
-            "optional": {
-                "image_prompt": (IO.IMAGE,),
-                "image_prompt_strength": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.1,
-                        "min": 0.0,
-                        "max": 1.0,
-                        "step": 0.01,
-                        "tooltip": "Blend between the prompt and the image prompt.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    @classmethod
-    def VALIDATE_INPUTS(cls, aspect_ratio: str):
-        try:
-            validate_aspect_ratio(
-                aspect_ratio,
-                minimum_ratio=cls.MINIMUM_RATIO,
-                maximum_ratio=cls.MAXIMUM_RATIO,
-                minimum_ratio_str=cls.MINIMUM_RATIO_STR,
-                maximum_ratio_str=cls.MAXIMUM_RATIO_STR,
-            )
-        except Exception as e:
-            return str(e)
-        return True
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/BFL"
-
-    def api_call(
-        self,
-        prompt: str,
-        aspect_ratio: str,
-        prompt_upsampling=False,
-        raw=False,
-        seed=0,
-        image_prompt=None,
-        image_prompt_strength=0.1,
-        unique_id: Union[str, None] = None,
-        **kwargs,
-    ):
-        if image_prompt is None:
-            validate_string(prompt, strip_whitespace=False)
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/bfl/flux-pro-1.1-ultra/generate",
-                method=HttpMethod.POST,
-                request_model=BFLFluxProUltraGenerateRequest,
-                response_model=BFLFluxProGenerateResponse,
-            ),
-            request=BFLFluxProUltraGenerateRequest(
-                prompt=prompt,
-                prompt_upsampling=prompt_upsampling,
-                seed=seed,
-                aspect_ratio=validate_aspect_ratio(
-                    aspect_ratio,
-                    minimum_ratio=self.MINIMUM_RATIO,
-                    maximum_ratio=self.MAXIMUM_RATIO,
-                    minimum_ratio_str=self.MINIMUM_RATIO_STR,
-                    maximum_ratio_str=self.MAXIMUM_RATIO_STR,
-                ),
-                raw=raw,
-                image_prompt=(
-                    image_prompt
-                    if image_prompt is None
-                    else convert_image_to_base64(image_prompt)
-                ),
-                image_prompt_strength=(
-                    None if image_prompt is None else round(image_prompt_strength, 2)
-                ),
-            ),
-            auth_kwargs=kwargs,
-        )
-        output_image = handle_bfl_synchronous_operation(operation, node_id=unique_id)
-        return (output_image,)
-
-
-class FluxKontextProImageNode(ComfyNodeABC):
-    """
-    Edits images using Flux.1 Kontext [pro] via api based on prompt and aspect ratio.
-    """
-
-    MINIMUM_RATIO = 1 / 4
-    MAXIMUM_RATIO = 4 / 1
-    MINIMUM_RATIO_STR = "1:4"
-    MAXIMUM_RATIO_STR = "4:1"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation - specify what and how to edit.",
-                    },
-                ),
-                "aspect_ratio": (
-                    IO.STRING,
-                    {
-                        "default": "16:9",
-                        "tooltip": "Aspect ratio of image; must be between 1:4 and 4:1.",
-                    },
-                ),
-                "guidance": (
-                    IO.FLOAT,
-                    {
-                        "default": 3.0,
-                        "min": 0.1,
-                        "max": 99.0,
-                        "step": 0.1,
-                        "tooltip": "Guidance strength for the image generation process"
-                    },
-                ),
-                "steps": (
-                    IO.INT,
-                    {
-                        "default": 50,
-                        "min": 1,
-                        "max": 150,
-                        "tooltip": "Number of steps for the image generation process"
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 1234,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-                "prompt_upsampling": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
-                    },
-                ),
-            },
-            "optional": {
-                "input_image": (IO.IMAGE,),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/BFL"
-
-    BFL_PATH = "/proxy/bfl/flux-kontext-pro/generate"
-
-    def api_call(
-        self,
-        prompt: str,
-        aspect_ratio: str,
-        guidance: float,
-        steps: int,
-        input_image: Optional[torch.Tensor]=None,
-        seed=0,
-        prompt_upsampling=False,
-        unique_id: Union[str, None] = None,
-        **kwargs,
-    ):
-        aspect_ratio = validate_aspect_ratio(
-            aspect_ratio,
-            minimum_ratio=self.MINIMUM_RATIO,
-            maximum_ratio=self.MAXIMUM_RATIO,
-            minimum_ratio_str=self.MINIMUM_RATIO_STR,
-            maximum_ratio_str=self.MAXIMUM_RATIO_STR,
-        )
-        if input_image is None:
-            validate_string(prompt, strip_whitespace=False)
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=self.BFL_PATH,
-                method=HttpMethod.POST,
-                request_model=BFLFluxKontextProGenerateRequest,
-                response_model=BFLFluxProGenerateResponse,
-            ),
-            request=BFLFluxKontextProGenerateRequest(
-                prompt=prompt,
-                prompt_upsampling=prompt_upsampling,
-                guidance=round(guidance, 1),
-                steps=steps,
-                seed=seed,
-                aspect_ratio=aspect_ratio,
-                input_image=(
-                    input_image
-                    if input_image is None
-                    else convert_image_to_base64(input_image)
-                )
-            ),
-            auth_kwargs=kwargs,
-        )
-        output_image = handle_bfl_synchronous_operation(operation, node_id=unique_id)
-        return (output_image,)
-
-
-class FluxKontextMaxImageNode(FluxKontextProImageNode):
-    """
-    Edits images using Flux.1 Kontext [max] via api based on prompt and aspect ratio.
-    """
-
-    DESCRIPTION = cleandoc(__doc__ or "")
-    BFL_PATH = "/proxy/bfl/flux-kontext-max/generate"
-
-
-class FluxProImageNode(ComfyNodeABC):
-    """
-    Generates images synchronously based on prompt and resolution.
-    """
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "prompt_upsampling": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
-                    },
-                ),
-                "width": (
-                    IO.INT,
-                    {
-                        "default": 1024,
-                        "min": 256,
-                        "max": 1440,
-                        "step": 32,
-                    },
-                ),
-                "height": (
-                    IO.INT,
-                    {
-                        "default": 768,
-                        "min": 256,
-                        "max": 1440,
-                        "step": 32,
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {
-                "image_prompt": (IO.IMAGE,),
-                # "image_prompt_strength": (
-                #     IO.FLOAT,
-                #     {
-                #         "default": 0.1,
-                #         "min": 0.0,
-                #         "max": 1.0,
-                #         "step": 0.01,
-                #         "tooltip": "Blend between the prompt and the image prompt.",
-                #     },
-                # ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/BFL"
-
-    def api_call(
-        self,
-        prompt: str,
-        prompt_upsampling,
-        width: int,
-        height: int,
-        seed=0,
-        image_prompt=None,
-        # image_prompt_strength=0.1,
-        unique_id: Union[str, None] = None,
-        **kwargs,
-    ):
-        image_prompt = (
-                    image_prompt
-                    if image_prompt is None
-                    else convert_image_to_base64(image_prompt)
-                )
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/bfl/flux-pro-1.1/generate",
-                method=HttpMethod.POST,
-                request_model=BFLFluxProGenerateRequest,
-                response_model=BFLFluxProGenerateResponse,
-            ),
-            request=BFLFluxProGenerateRequest(
-                prompt=prompt,
-                prompt_upsampling=prompt_upsampling,
-                width=width,
-                height=height,
-                seed=seed,
-                image_prompt=image_prompt,
-            ),
-            auth_kwargs=kwargs,
-        )
-        output_image = handle_bfl_synchronous_operation(operation, node_id=unique_id)
-        return (output_image,)
-
-
-class FluxProExpandNode(ComfyNodeABC):
-    """
-    Outpaints image based on prompt.
-    """
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "prompt_upsampling": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
-                    },
-                ),
-                "top": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2048,
-                        "tooltip": "Number of pixels to expand at the top of the image"
-                    },
-                ),
-                "bottom": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2048,
-                        "tooltip": "Number of pixels to expand at the bottom of the image"
-                    },
-                ),
-                "left": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2048,
-                        "tooltip": "Number of pixels to expand at the left side of the image"
-                    },
-                ),
-                "right": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2048,
-                        "tooltip": "Number of pixels to expand at the right side of the image"
-                    },
-                ),
-                "guidance": (
-                    IO.FLOAT,
-                    {
-                        "default": 60,
-                        "min": 1.5,
-                        "max": 100,
-                        "tooltip": "Guidance strength for the image generation process"
-                    },
-                ),
-                "steps": (
-                    IO.INT,
-                    {
-                        "default": 50,
-                        "min": 15,
-                        "max": 50,
-                        "tooltip": "Number of steps for the image generation process"
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {},
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/BFL"
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        prompt: str,
-        prompt_upsampling: bool,
-        top: int,
-        bottom: int,
-        left: int,
-        right: int,
-        steps: int,
-        guidance: float,
-        seed=0,
-        unique_id: Union[str, None] = None,
-        **kwargs,
-    ):
-        image = convert_image_to_base64(image)
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/bfl/flux-pro-1.0-expand/generate",
-                method=HttpMethod.POST,
-                request_model=BFLFluxExpandImageRequest,
-                response_model=BFLFluxProGenerateResponse,
-            ),
-            request=BFLFluxExpandImageRequest(
-                prompt=prompt,
-                prompt_upsampling=prompt_upsampling,
-                top=top,
-                bottom=bottom,
-                left=left,
-                right=right,
-                steps=steps,
-                guidance=guidance,
-                seed=seed,
-                image=image,
-            ),
-            auth_kwargs=kwargs,
-        )
-        output_image = handle_bfl_synchronous_operation(operation, node_id=unique_id)
-        return (output_image,)
-
-
-
-class FluxProFillNode(ComfyNodeABC):
-    """
-    Inpaints image based on mask and prompt.
-    """
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE,),
-                "mask": (IO.MASK,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "prompt_upsampling": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
-                    },
-                ),
-                "guidance": (
-                    IO.FLOAT,
-                    {
-                        "default": 60,
-                        "min": 1.5,
-                        "max": 100,
-                        "tooltip": "Guidance strength for the image generation process"
-                    },
-                ),
-                "steps": (
-                    IO.INT,
-                    {
-                        "default": 50,
-                        "min": 15,
-                        "max": 50,
-                        "tooltip": "Number of steps for the image generation process"
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {},
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/BFL"
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        mask: torch.Tensor,
-        prompt: str,
-        prompt_upsampling: bool,
-        steps: int,
-        guidance: float,
-        seed=0,
-        unique_id: Union[str, None] = None,
-        **kwargs,
-    ):
-        # prepare mask
-        mask = resize_mask_to_image(mask, image)
-        mask = convert_image_to_base64(convert_mask_to_image(mask))
-        # make sure image will have alpha channel removed
-        image = convert_image_to_base64(image[:, :, :, :3])
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/bfl/flux-pro-1.0-fill/generate",
-                method=HttpMethod.POST,
-                request_model=BFLFluxFillImageRequest,
-                response_model=BFLFluxProGenerateResponse,
-            ),
-            request=BFLFluxFillImageRequest(
-                prompt=prompt,
-                prompt_upsampling=prompt_upsampling,
-                steps=steps,
-                guidance=guidance,
-                seed=seed,
-                image=image,
-                mask=mask,
-            ),
-            auth_kwargs=kwargs,
-        )
-        output_image = handle_bfl_synchronous_operation(operation, node_id=unique_id)
-        return (output_image,)
-
-
-class FluxProCannyNode(ComfyNodeABC):
-    """
-    Generate image using a control image (canny).
-    """
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "control_image": (IO.IMAGE,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "prompt_upsampling": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
-                    },
-                ),
-                "canny_low_threshold": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.1,
-                        "min": 0.01,
-                        "max": 0.99,
-                        "step": 0.01,
-                        "tooltip": "Low threshold for Canny edge detection; ignored if skip_processing is True"
-                    },
-                ),
-                "canny_high_threshold": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.4,
-                        "min": 0.01,
-                        "max": 0.99,
-                        "step": 0.01,
-                        "tooltip": "High threshold for Canny edge detection; ignored if skip_processing is True"
-                    },
-                ),
-                "skip_preprocessing": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to skip preprocessing; set to True if control_image already is canny-fied, False if it is a raw image.",
-                    },
-                ),
-                "guidance": (
-                    IO.FLOAT,
-                    {
-                        "default": 30,
-                        "min": 1,
-                        "max": 100,
-                        "tooltip": "Guidance strength for the image generation process"
-                    },
-                ),
-                "steps": (
-                    IO.INT,
-                    {
-                        "default": 50,
-                        "min": 15,
-                        "max": 50,
-                        "tooltip": "Number of steps for the image generation process"
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {},
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/BFL"
-
-    def api_call(
-        self,
-        control_image: torch.Tensor,
-        prompt: str,
-        prompt_upsampling: bool,
-        canny_low_threshold: float,
-        canny_high_threshold: float,
-        skip_preprocessing: bool,
-        steps: int,
-        guidance: float,
-        seed=0,
-        unique_id: Union[str, None] = None,
-        **kwargs,
-    ):
-        control_image = convert_image_to_base64(control_image[:, :, :, :3])
-        preprocessed_image = None
-
-        # scale canny threshold between 0-500, to match BFL's API
-        def scale_value(value: float, min_val=0, max_val=500):
-            return min_val + value * (max_val - min_val)
-        canny_low_threshold = int(round(scale_value(canny_low_threshold)))
-        canny_high_threshold = int(round(scale_value(canny_high_threshold)))
-
-
-        if skip_preprocessing:
-            preprocessed_image = control_image
-            control_image = None
-            canny_low_threshold = None
-            canny_high_threshold = None
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/bfl/flux-pro-1.0-canny/generate",
-                method=HttpMethod.POST,
-                request_model=BFLFluxCannyImageRequest,
-                response_model=BFLFluxProGenerateResponse,
-            ),
-            request=BFLFluxCannyImageRequest(
-                prompt=prompt,
-                prompt_upsampling=prompt_upsampling,
-                steps=steps,
-                guidance=guidance,
-                seed=seed,
-                control_image=control_image,
-                canny_low_threshold=canny_low_threshold,
-                canny_high_threshold=canny_high_threshold,
-                preprocessed_image=preprocessed_image,
-            ),
-            auth_kwargs=kwargs,
-        )
-        output_image = handle_bfl_synchronous_operation(operation, node_id=unique_id)
-        return (output_image,)
-
-
-class FluxProDepthNode(ComfyNodeABC):
-    """
-    Generate image using a control image (depth).
-    """
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "control_image": (IO.IMAGE,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "prompt_upsampling": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
-                    },
-                ),
-                "skip_preprocessing": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to skip preprocessing; set to True if control_image already is depth-ified, False if it is a raw image.",
-                    },
-                ),
-                "guidance": (
-                    IO.FLOAT,
-                    {
-                        "default": 15,
-                        "min": 1,
-                        "max": 100,
-                        "tooltip": "Guidance strength for the image generation process"
-                    },
-                ),
-                "steps": (
-                    IO.INT,
-                    {
-                        "default": 50,
-                        "min": 15,
-                        "max": 50,
-                        "tooltip": "Number of steps for the image generation process"
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {},
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/BFL"
-
-    def api_call(
-        self,
-        control_image: torch.Tensor,
-        prompt: str,
-        prompt_upsampling: bool,
-        skip_preprocessing: bool,
-        steps: int,
-        guidance: float,
-        seed=0,
-        unique_id: Union[str, None] = None,
-        **kwargs,
-    ):
-        control_image = convert_image_to_base64(control_image[:,:,:,:3])
-        preprocessed_image = None
-
-        if skip_preprocessing:
-            preprocessed_image = control_image
-            control_image = None
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/bfl/flux-pro-1.0-depth/generate",
-                method=HttpMethod.POST,
-                request_model=BFLFluxDepthImageRequest,
-                response_model=BFLFluxProGenerateResponse,
-            ),
-            request=BFLFluxDepthImageRequest(
-                prompt=prompt,
-                prompt_upsampling=prompt_upsampling,
-                steps=steps,
-                guidance=guidance,
-                seed=seed,
-                control_image=control_image,
-                preprocessed_image=preprocessed_image,
-            ),
-            auth_kwargs=kwargs,
-        )
-        output_image = handle_bfl_synchronous_operation(operation, node_id=unique_id)
-        return (output_image,)
-
-
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
-    "FluxProUltraImageNode": FluxProUltraImageNode,
-    # "FluxProImageNode": FluxProImageNode,
-    "FluxKontextProImageNode": FluxKontextProImageNode,
-    "FluxKontextMaxImageNode": FluxKontextMaxImageNode,
-    "FluxProExpandNode": FluxProExpandNode,
-    "FluxProFillNode": FluxProFillNode,
-    "FluxProCannyNode": FluxProCannyNode,
-    "FluxProDepthNode": FluxProDepthNode,
-}
-
-# A dictionary that contains the friendly/humanly readable titles for the nodes
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "FluxProUltraImageNode": "Flux 1.1 [pro] Ultra Image",
-    # "FluxProImageNode": "Flux 1.1 [pro] Image",
-    "FluxKontextProImageNode": "Flux.1 Kontext [pro] Image",
-    "FluxKontextMaxImageNode": "Flux.1 Kontext [max] Image",
-    "FluxProExpandNode": "Flux.1 Expand Image",
-    "FluxProFillNode": "Flux.1 Fill Image",
-    "FluxProCannyNode": "Flux.1 Canny Control Image",
-    "FluxProDepthNode": "Flux.1 Depth Control Image",
-}

comfy_api_nodes/nodes_gemini.py

@@ -1,446 +0,0 @@
-"""
-API Nodes for Gemini Multimodal LLM Usage via Remote API
-See: https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/inference
-"""
-
-import os
-from enum import Enum
-from typing import Optional, Literal
-
-import torch
-
-import folder_paths
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC, InputTypeDict
-from server import PromptServer
-from comfy_api_nodes.apis import (
-    GeminiContent,
-    GeminiGenerateContentRequest,
-    GeminiGenerateContentResponse,
-    GeminiInlineData,
-    GeminiPart,
-    GeminiMimeType,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-)
-from comfy_api_nodes.apinode_utils import (
-    validate_string,
-    audio_to_base64_string,
-    video_to_base64_string,
-    tensor_to_base64_string,
-)
-
-
-GEMINI_BASE_ENDPOINT = "/proxy/vertexai/gemini"
-GEMINI_MAX_INPUT_FILE_SIZE = 20 * 1024 * 1024  # 20 MB
-
-
-class GeminiModel(str, Enum):
-    """
-    Gemini Model Names allowed by comfy-api
-    """
-
-    gemini_2_5_pro_preview_05_06 = "gemini-2.5-pro-preview-05-06"
-    gemini_2_5_flash_preview_04_17 = "gemini-2.5-flash-preview-04-17"
-
-
-def get_gemini_endpoint(
-    model: GeminiModel,
-) -> ApiEndpoint[GeminiGenerateContentRequest, GeminiGenerateContentResponse]:
-    """
-    Get the API endpoint for a given Gemini model.
-
-    Args:
-        model: The Gemini model to use, either as enum or string value.
-
-    Returns:
-        ApiEndpoint configured for the specific Gemini model.
-    """
-    if isinstance(model, str):
-        model = GeminiModel(model)
-    return ApiEndpoint(
-        path=f"{GEMINI_BASE_ENDPOINT}/{model.value}",
-        method=HttpMethod.POST,
-        request_model=GeminiGenerateContentRequest,
-        response_model=GeminiGenerateContentResponse,
-    )
-
-
-class GeminiNode(ComfyNodeABC):
-    """
-    Node to generate text responses from a Gemini model.
-
-    This node allows users to interact with Google's Gemini AI models, providing
-    multimodal inputs (text, images, audio, video, files) to generate coherent
-    text responses. The node works with the latest Gemini models, handling the
-    API communication and response parsing.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text inputs to the model, used to generate a response. You can include detailed instructions, questions, or context for the model.",
-                    },
-                ),
-                "model": (
-                    IO.COMBO,
-                    {
-                        "tooltip": "The Gemini model to use for generating responses.",
-                        "options": [model.value for model in GeminiModel],
-                        "default": GeminiModel.gemini_2_5_pro_preview_05_06.value,
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 42,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "When seed is fixed to a specific value, the model makes a best effort to provide the same response for repeated requests. Deterministic output isn't guaranteed. Also, changing the model or parameter settings, such as the temperature, can cause variations in the response even when you use the same seed value. By default, a random seed value is used.",
-                    },
-                ),
-            },
-            "optional": {
-                "images": (
-                    IO.IMAGE,
-                    {
-                        "default": None,
-                        "tooltip": "Optional image(s) to use as context for the model. To include multiple images, you can use the Batch Images node.",
-                    },
-                ),
-                "audio": (
-                    IO.AUDIO,
-                    {
-                        "tooltip": "Optional audio to use as context for the model.",
-                        "default": None,
-                    },
-                ),
-                "video": (
-                    IO.VIDEO,
-                    {
-                        "tooltip": "Optional video to use as context for the model.",
-                        "default": None,
-                    },
-                ),
-                "files": (
-                    "GEMINI_INPUT_FILES",
-                    {
-                        "default": None,
-                        "tooltip": "Optional file(s) to use as context for the model. Accepts inputs from the Gemini Generate Content Input Files node.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Generate text responses with Google's Gemini AI model. You can provide multiple types of inputs (text, images, audio, video) as context for generating more relevant and meaningful responses."
-    RETURN_TYPES = ("STRING",)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/text/Gemini"
-    API_NODE = True
-
-    def get_parts_from_response(
-        self, response: GeminiGenerateContentResponse
-    ) -> list[GeminiPart]:
-        """
-        Extract all parts from the Gemini API response.
-
-        Args:
-            response: The API response from Gemini.
-
-        Returns:
-            List of response parts from the first candidate.
-        """
-        return response.candidates[0].content.parts
-
-    def get_parts_by_type(
-        self, response: GeminiGenerateContentResponse, part_type: Literal["text"] | str
-    ) -> list[GeminiPart]:
-        """
-        Filter response parts by their type.
-
-        Args:
-            response: The API response from Gemini.
-            part_type: Type of parts to extract ("text" or a MIME type).
-
-        Returns:
-            List of response parts matching the requested type.
-        """
-        parts = []
-        for part in self.get_parts_from_response(response):
-            if part_type == "text" and hasattr(part, "text") and part.text:
-                parts.append(part)
-            elif (
-                hasattr(part, "inlineData")
-                and part.inlineData
-                and part.inlineData.mimeType == part_type
-            ):
-                parts.append(part)
-            # Skip parts that don't match the requested type
-        return parts
-
-    def get_text_from_response(self, response: GeminiGenerateContentResponse) -> str:
-        """
-        Extract and concatenate all text parts from the response.
-
-        Args:
-            response: The API response from Gemini.
-
-        Returns:
-            Combined text from all text parts in the response.
-        """
-        parts = self.get_parts_by_type(response, "text")
-        return "\n".join([part.text for part in parts])
-
-    def create_video_parts(self, video_input: IO.VIDEO, **kwargs) -> list[GeminiPart]:
-        """
-        Convert video input to Gemini API compatible parts.
-
-        Args:
-            video_input: Video tensor from ComfyUI.
-            **kwargs: Additional arguments to pass to the conversion function.
-
-        Returns:
-            List of GeminiPart objects containing the encoded video.
-        """
-        from comfy_api.util import VideoContainer, VideoCodec
-        base_64_string = video_to_base64_string(
-            video_input,
-            container_format=VideoContainer.MP4,
-            codec=VideoCodec.H264
-        )
-        return [
-            GeminiPart(
-                inlineData=GeminiInlineData(
-                    mimeType=GeminiMimeType.video_mp4,
-                    data=base_64_string,
-                )
-            )
-        ]
-
-    def create_audio_parts(self, audio_input: IO.AUDIO) -> list[GeminiPart]:
-        """
-        Convert audio input to Gemini API compatible parts.
-
-        Args:
-            audio_input: Audio input from ComfyUI, containing waveform tensor and sample rate.
-
-        Returns:
-            List of GeminiPart objects containing the encoded audio.
-        """
-        audio_parts: list[GeminiPart] = []
-        for batch_index in range(audio_input["waveform"].shape[0]):
-            # Recreate an IO.AUDIO object for the given batch dimension index
-            audio_at_index = {
-                "waveform": audio_input["waveform"][batch_index].unsqueeze(0),
-                "sample_rate": audio_input["sample_rate"],
-            }
-            # Convert to MP3 format for compatibility with Gemini API
-            audio_bytes = audio_to_base64_string(
-                audio_at_index,
-                container_format="mp3",
-                codec_name="libmp3lame",
-            )
-            audio_parts.append(
-                GeminiPart(
-                    inlineData=GeminiInlineData(
-                        mimeType=GeminiMimeType.audio_mp3,
-                        data=audio_bytes,
-                    )
-                )
-            )
-        return audio_parts
-
-    def create_image_parts(self, image_input: torch.Tensor) -> list[GeminiPart]:
-        """
-        Convert image tensor input to Gemini API compatible parts.
-
-        Args:
-            image_input: Batch of image tensors from ComfyUI.
-
-        Returns:
-            List of GeminiPart objects containing the encoded images.
-        """
-        image_parts: list[GeminiPart] = []
-        for image_index in range(image_input.shape[0]):
-            image_as_b64 = tensor_to_base64_string(
-                image_input[image_index].unsqueeze(0)
-            )
-            image_parts.append(
-                GeminiPart(
-                    inlineData=GeminiInlineData(
-                        mimeType=GeminiMimeType.image_png,
-                        data=image_as_b64,
-                    )
-                )
-            )
-        return image_parts
-
-    def create_text_part(self, text: str) -> GeminiPart:
-        """
-        Create a text part for the Gemini API request.
-
-        Args:
-            text: The text content to include in the request.
-
-        Returns:
-            A GeminiPart object with the text content.
-        """
-        return GeminiPart(text=text)
-
-    def api_call(
-        self,
-        prompt: str,
-        model: GeminiModel,
-        images: Optional[IO.IMAGE] = None,
-        audio: Optional[IO.AUDIO] = None,
-        video: Optional[IO.VIDEO] = None,
-        files: Optional[list[GeminiPart]] = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ) -> tuple[str]:
-        # Validate inputs
-        validate_string(prompt, strip_whitespace=False)
-
-        # Create parts list with text prompt as the first part
-        parts: list[GeminiPart] = [self.create_text_part(prompt)]
-
-        # Add other modal parts
-        if images is not None:
-            image_parts = self.create_image_parts(images)
-            parts.extend(image_parts)
-        if audio is not None:
-            parts.extend(self.create_audio_parts(audio))
-        if video is not None:
-            parts.extend(self.create_video_parts(video))
-        if files is not None:
-            parts.extend(files)
-
-        # Create response
-        response = SynchronousOperation(
-            endpoint=get_gemini_endpoint(model),
-            request=GeminiGenerateContentRequest(
-                contents=[
-                    GeminiContent(
-                        role="user",
-                        parts=parts,
-                    )
-                ]
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-
-        # Get result output
-        output_text = self.get_text_from_response(response)
-        if unique_id and output_text:
-            PromptServer.instance.send_progress_text(output_text, node_id=unique_id)
-
-        return (output_text or "Empty response from Gemini model...",)
-
-
-class GeminiInputFiles(ComfyNodeABC):
-    """
-    Loads and formats input files for use with the Gemini API.
-
-    This node allows users to include text (.txt) and PDF (.pdf) files as input
-    context for the Gemini model. Files are converted to the appropriate format
-    required by the API and can be chained together to include multiple files
-    in a single request.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        """
-        For details about the supported file input types, see:
-        https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/inference
-        """
-        input_dir = folder_paths.get_input_directory()
-        input_files = [
-            f
-            for f in os.scandir(input_dir)
-            if f.is_file()
-            and (f.name.endswith(".txt") or f.name.endswith(".pdf"))
-            and f.stat().st_size < GEMINI_MAX_INPUT_FILE_SIZE
-        ]
-        input_files = sorted(input_files, key=lambda x: x.name)
-        input_files = [f.name for f in input_files]
-        return {
-            "required": {
-                "file": (
-                    IO.COMBO,
-                    {
-                        "tooltip": "Input files to include as context for the model. Only accepts text (.txt) and PDF (.pdf) files for now.",
-                        "options": input_files,
-                        "default": input_files[0] if input_files else None,
-                    },
-                ),
-            },
-            "optional": {
-                "GEMINI_INPUT_FILES": (
-                    "GEMINI_INPUT_FILES",
-                    {
-                        "tooltip": "An optional additional file(s) to batch together with the file loaded from this node. Allows chaining of input files so that a single message can include multiple input files.",
-                        "default": None,
-                    },
-                ),
-            },
-        }
-
-    DESCRIPTION = "Loads and prepares input files to include as inputs for Gemini LLM nodes. The files will be read by the Gemini model when generating a response. The contents of the text file count toward the token limit. 🛈 TIP: Can be chained together with other Gemini Input File nodes."
-    RETURN_TYPES = ("GEMINI_INPUT_FILES",)
-    FUNCTION = "prepare_files"
-    CATEGORY = "api node/text/Gemini"
-
-    def create_file_part(self, file_path: str) -> GeminiPart:
-        mime_type = (
-            GeminiMimeType.application_pdf
-            if file_path.endswith(".pdf")
-            else GeminiMimeType.text_plain
-        )
-        # Use base64 string directly, not the data URI
-        with open(file_path, "rb") as f:
-            file_content = f.read()
-        import base64
-        base64_str = base64.b64encode(file_content).decode("utf-8")
-
-        return GeminiPart(
-            inlineData=GeminiInlineData(
-                mimeType=mime_type,
-                data=base64_str,
-            )
-        )
-
-    def prepare_files(
-        self, file: str, GEMINI_INPUT_FILES: list[GeminiPart] = []
-    ) -> tuple[list[GeminiPart]]:
-        """
-        Loads and formats input files for Gemini API.
-        """
-        file_path = folder_paths.get_annotated_filepath(file)
-        input_file_content = self.create_file_part(file_path)
-        files = [input_file_content] + GEMINI_INPUT_FILES
-        return (files,)
-
-
-NODE_CLASS_MAPPINGS = {
-    "GeminiNode": GeminiNode,
-    "GeminiInputFiles": GeminiInputFiles,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "GeminiNode": "Google Gemini",
-    "GeminiInputFiles": "Gemini Input Files",
-}

comfy_api_nodes/nodes_ideogram.py

@@ -1,801 +0,0 @@
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC, InputTypeDict
-from inspect import cleandoc
-from PIL import Image
-import numpy as np
-import io
-import torch
-from comfy_api_nodes.apis import (
-    IdeogramGenerateRequest,
-    IdeogramGenerateResponse,
-    ImageRequest,
-    IdeogramV3Request,
-    IdeogramV3EditRequest,
-)
-
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-)
-
-from comfy_api_nodes.apinode_utils import (
-    download_url_to_bytesio,
-    bytesio_to_image_tensor,
-    resize_mask_to_image,
-)
-from server import PromptServer
-
-V1_V1_RES_MAP = {
-  "Auto":"AUTO",
-  "512 x 1536":"RESOLUTION_512_1536",
-  "576 x 1408":"RESOLUTION_576_1408",
-  "576 x 1472":"RESOLUTION_576_1472",
-  "576 x 1536":"RESOLUTION_576_1536",
-  "640 x 1024":"RESOLUTION_640_1024",
-  "640 x 1344":"RESOLUTION_640_1344",
-  "640 x 1408":"RESOLUTION_640_1408",
-  "640 x 1472":"RESOLUTION_640_1472",
-  "640 x 1536":"RESOLUTION_640_1536",
-  "704 x 1152":"RESOLUTION_704_1152",
-  "704 x 1216":"RESOLUTION_704_1216",
-  "704 x 1280":"RESOLUTION_704_1280",
-  "704 x 1344":"RESOLUTION_704_1344",
-  "704 x 1408":"RESOLUTION_704_1408",
-  "704 x 1472":"RESOLUTION_704_1472",
-  "720 x 1280":"RESOLUTION_720_1280",
-  "736 x 1312":"RESOLUTION_736_1312",
-  "768 x 1024":"RESOLUTION_768_1024",
-  "768 x 1088":"RESOLUTION_768_1088",
-  "768 x 1152":"RESOLUTION_768_1152",
-  "768 x 1216":"RESOLUTION_768_1216",
-  "768 x 1232":"RESOLUTION_768_1232",
-  "768 x 1280":"RESOLUTION_768_1280",
-  "768 x 1344":"RESOLUTION_768_1344",
-  "832 x 960":"RESOLUTION_832_960",
-  "832 x 1024":"RESOLUTION_832_1024",
-  "832 x 1088":"RESOLUTION_832_1088",
-  "832 x 1152":"RESOLUTION_832_1152",
-  "832 x 1216":"RESOLUTION_832_1216",
-  "832 x 1248":"RESOLUTION_832_1248",
-  "864 x 1152":"RESOLUTION_864_1152",
-  "896 x 960":"RESOLUTION_896_960",
-  "896 x 1024":"RESOLUTION_896_1024",
-  "896 x 1088":"RESOLUTION_896_1088",
-  "896 x 1120":"RESOLUTION_896_1120",
-  "896 x 1152":"RESOLUTION_896_1152",
-  "960 x 832":"RESOLUTION_960_832",
-  "960 x 896":"RESOLUTION_960_896",
-  "960 x 1024":"RESOLUTION_960_1024",
-  "960 x 1088":"RESOLUTION_960_1088",
-  "1024 x 640":"RESOLUTION_1024_640",
-  "1024 x 768":"RESOLUTION_1024_768",
-  "1024 x 832":"RESOLUTION_1024_832",
-  "1024 x 896":"RESOLUTION_1024_896",
-  "1024 x 960":"RESOLUTION_1024_960",
-  "1024 x 1024":"RESOLUTION_1024_1024",
-  "1088 x 768":"RESOLUTION_1088_768",
-  "1088 x 832":"RESOLUTION_1088_832",
-  "1088 x 896":"RESOLUTION_1088_896",
-  "1088 x 960":"RESOLUTION_1088_960",
-  "1120 x 896":"RESOLUTION_1120_896",
-  "1152 x 704":"RESOLUTION_1152_704",
-  "1152 x 768":"RESOLUTION_1152_768",
-  "1152 x 832":"RESOLUTION_1152_832",
-  "1152 x 864":"RESOLUTION_1152_864",
-  "1152 x 896":"RESOLUTION_1152_896",
-  "1216 x 704":"RESOLUTION_1216_704",
-  "1216 x 768":"RESOLUTION_1216_768",
-  "1216 x 832":"RESOLUTION_1216_832",
-  "1232 x 768":"RESOLUTION_1232_768",
-  "1248 x 832":"RESOLUTION_1248_832",
-  "1280 x 704":"RESOLUTION_1280_704",
-  "1280 x 720":"RESOLUTION_1280_720",
-  "1280 x 768":"RESOLUTION_1280_768",
-  "1280 x 800":"RESOLUTION_1280_800",
-  "1312 x 736":"RESOLUTION_1312_736",
-  "1344 x 640":"RESOLUTION_1344_640",
-  "1344 x 704":"RESOLUTION_1344_704",
-  "1344 x 768":"RESOLUTION_1344_768",
-  "1408 x 576":"RESOLUTION_1408_576",
-  "1408 x 640":"RESOLUTION_1408_640",
-  "1408 x 704":"RESOLUTION_1408_704",
-  "1472 x 576":"RESOLUTION_1472_576",
-  "1472 x 640":"RESOLUTION_1472_640",
-  "1472 x 704":"RESOLUTION_1472_704",
-  "1536 x 512":"RESOLUTION_1536_512",
-  "1536 x 576":"RESOLUTION_1536_576",
-  "1536 x 640":"RESOLUTION_1536_640",
-}
-
-V1_V2_RATIO_MAP = {
-  "1:1":"ASPECT_1_1",
-  "4:3":"ASPECT_4_3",
-  "3:4":"ASPECT_3_4",
-  "16:9":"ASPECT_16_9",
-  "9:16":"ASPECT_9_16",
-  "2:1":"ASPECT_2_1",
-  "1:2":"ASPECT_1_2",
-  "3:2":"ASPECT_3_2",
-  "2:3":"ASPECT_2_3",
-  "4:5":"ASPECT_4_5",
-  "5:4":"ASPECT_5_4",
-}
-
-V3_RATIO_MAP = {
-    "1:3":"1x3",
-    "3:1":"3x1",
-    "1:2":"1x2",
-    "2:1":"2x1",
-    "9:16":"9x16",
-    "16:9":"16x9",
-    "10:16":"10x16",
-    "16:10":"16x10",
-    "2:3":"2x3",
-    "3:2":"3x2",
-    "3:4":"3x4",
-    "4:3":"4x3",
-    "4:5":"4x5",
-    "5:4":"5x4",
-    "1:1":"1x1",
-}
-
-V3_RESOLUTIONS= [
-    "Auto",
-    "512x1536",
-    "576x1408",
-    "576x1472",
-    "576x1536",
-    "640x1344",
-    "640x1408",
-    "640x1472",
-    "640x1536",
-    "704x1152",
-    "704x1216",
-    "704x1280",
-    "704x1344",
-    "704x1408",
-    "704x1472",
-    "736x1312",
-    "768x1088",
-    "768x1216",
-    "768x1280",
-    "768x1344",
-    "800x1280",
-    "832x960",
-    "832x1024",
-    "832x1088",
-    "832x1152",
-    "832x1216",
-    "832x1248",
-    "864x1152",
-    "896x960",
-    "896x1024",
-    "896x1088",
-    "896x1120",
-    "896x1152",
-    "960x832",
-    "960x896",
-    "960x1024",
-    "960x1088",
-    "1024x832",
-    "1024x896",
-    "1024x960",
-    "1024x1024",
-    "1088x768",
-    "1088x832",
-    "1088x896",
-    "1088x960",
-    "1120x896",
-    "1152x704",
-    "1152x832",
-    "1152x864",
-    "1152x896",
-    "1216x704",
-    "1216x768",
-    "1216x832",
-    "1248x832",
-    "1280x704",
-    "1280x768",
-    "1280x800",
-    "1312x736",
-    "1344x640",
-    "1344x704",
-    "1344x768",
-    "1408x576",
-    "1408x640",
-    "1408x704",
-    "1472x576",
-    "1472x640",
-    "1472x704",
-    "1536x512",
-    "1536x576",
-    "1536x640"
-]
-
-def download_and_process_images(image_urls):
-    """Helper function to download and process multiple images from URLs"""
-
-    # Initialize list to store image tensors
-    image_tensors = []
-
-    for image_url in image_urls:
-        # Using functions from apinode_utils.py to handle downloading and processing
-        image_bytesio = download_url_to_bytesio(image_url)  # Download image content to BytesIO
-        img_tensor = bytesio_to_image_tensor(image_bytesio, mode="RGB")  # Convert to torch.Tensor with RGB mode
-        image_tensors.append(img_tensor)
-
-    # Stack tensors to match (N, width, height, channels)
-    if image_tensors:
-        stacked_tensors = torch.cat(image_tensors, dim=0)
-    else:
-        raise Exception("No valid images were processed")
-
-    return stacked_tensors
-
-
-def display_image_urls_on_node(image_urls, node_id):
-    if node_id and image_urls:
-        if len(image_urls) == 1:
-            PromptServer.instance.send_progress_text(
-                f"Generated Image URL:\n{image_urls[0]}", node_id
-            )
-        else:
-            urls_text = "Generated Image URLs:\n" + "\n".join(
-                f"{i+1}. {url}" for i, url in enumerate(image_urls)
-            )
-            PromptServer.instance.send_progress_text(urls_text, node_id)
-
-
-class IdeogramV1(ComfyNodeABC):
-    """
-    Generates images using the Ideogram V1 model.
-    """
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "turbo": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to use turbo mode (faster generation, potentially lower quality)",
-                    }
-                ),
-            },
-            "optional": {
-                "aspect_ratio": (
-                    IO.COMBO,
-                    {
-                        "options": list(V1_V2_RATIO_MAP.keys()),
-                        "default": "1:1",
-                        "tooltip": "The aspect ratio for image generation.",
-                    },
-                ),
-                "magic_prompt_option": (
-                    IO.COMBO,
-                    {
-                        "options": ["AUTO", "ON", "OFF"],
-                        "default": "AUTO",
-                        "tooltip": "Determine if MagicPrompt should be used in generation",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2147483647,
-                        "step": 1,
-                        "control_after_generate": True,
-                        "display": "number",
-                    },
-                ),
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Description of what to exclude from the image",
-                    },
-                ),
-                "num_images": (
-                    IO.INT,
-                    {"default": 1, "min": 1, "max": 8, "step": 1, "display": "number"},
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/image/Ideogram"
-    DESCRIPTION = cleandoc(__doc__ or "")
-    API_NODE = True
-
-    def api_call(
-        self,
-        prompt,
-        turbo=False,
-        aspect_ratio="1:1",
-        magic_prompt_option="AUTO",
-        seed=0,
-        negative_prompt="",
-        num_images=1,
-        unique_id=None,
-        **kwargs,
-    ):
-        # Determine the model based on turbo setting
-        aspect_ratio = V1_V2_RATIO_MAP.get(aspect_ratio, None)
-        model = "V_1_TURBO" if turbo else "V_1"
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/ideogram/generate",
-                method=HttpMethod.POST,
-                request_model=IdeogramGenerateRequest,
-                response_model=IdeogramGenerateResponse,
-            ),
-            request=IdeogramGenerateRequest(
-                image_request=ImageRequest(
-                    prompt=prompt,
-                    model=model,
-                    num_images=num_images,
-                    seed=seed,
-                    aspect_ratio=aspect_ratio if aspect_ratio != "ASPECT_1_1" else None,
-                    magic_prompt_option=(
-                        magic_prompt_option if magic_prompt_option != "AUTO" else None
-                    ),
-                    negative_prompt=negative_prompt if negative_prompt else None,
-                )
-            ),
-            auth_kwargs=kwargs,
-        )
-
-        response = operation.execute()
-
-        if not response.data or len(response.data) == 0:
-            raise Exception("No images were generated in the response")
-
-        image_urls = [image_data.url for image_data in response.data if image_data.url]
-
-        if not image_urls:
-            raise Exception("No image URLs were generated in the response")
-
-        display_image_urls_on_node(image_urls, unique_id)
-        return (download_and_process_images(image_urls),)
-
-
-class IdeogramV2(ComfyNodeABC):
-    """
-    Generates images using the Ideogram V2 model.
-    """
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "turbo": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                        "tooltip": "Whether to use turbo mode (faster generation, potentially lower quality)",
-                    }
-                ),
-            },
-            "optional": {
-                "aspect_ratio": (
-                    IO.COMBO,
-                    {
-                        "options": list(V1_V2_RATIO_MAP.keys()),
-                        "default": "1:1",
-                        "tooltip": "The aspect ratio for image generation. Ignored if resolution is not set to AUTO.",
-                    },
-                ),
-                "resolution": (
-                    IO.COMBO,
-                    {
-                        "options": list(V1_V1_RES_MAP.keys()),
-                        "default": "Auto",
-                        "tooltip": "The resolution for image generation. If not set to AUTO, this overrides the aspect_ratio setting.",
-                    },
-                ),
-                "magic_prompt_option": (
-                    IO.COMBO,
-                    {
-                        "options": ["AUTO", "ON", "OFF"],
-                        "default": "AUTO",
-                        "tooltip": "Determine if MagicPrompt should be used in generation",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2147483647,
-                        "step": 1,
-                        "control_after_generate": True,
-                        "display": "number",
-                    },
-                ),
-                "style_type": (
-                    IO.COMBO,
-                    {
-                        "options": ["AUTO", "GENERAL", "REALISTIC", "DESIGN", "RENDER_3D", "ANIME"],
-                        "default": "NONE",
-                        "tooltip": "Style type for generation (V2 only)",
-                    },
-                ),
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Description of what to exclude from the image",
-                    },
-                ),
-                "num_images": (
-                    IO.INT,
-                    {"default": 1, "min": 1, "max": 8, "step": 1, "display": "number"},
-                ),
-                #"color_palette": (
-                #    IO.STRING,
-                #    {
-                #        "multiline": False,
-                #        "default": "",
-                #        "tooltip": "Color palette preset name or hex colors with weights",
-                #    },
-                #),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/image/Ideogram"
-    DESCRIPTION = cleandoc(__doc__ or "")
-    API_NODE = True
-
-    def api_call(
-        self,
-        prompt,
-        turbo=False,
-        aspect_ratio="1:1",
-        resolution="Auto",
-        magic_prompt_option="AUTO",
-        seed=0,
-        style_type="NONE",
-        negative_prompt="",
-        num_images=1,
-        color_palette="",
-        unique_id=None,
-        **kwargs,
-    ):
-        aspect_ratio = V1_V2_RATIO_MAP.get(aspect_ratio, None)
-        resolution = V1_V1_RES_MAP.get(resolution, None)
-        # Determine the model based on turbo setting
-        model = "V_2_TURBO" if turbo else "V_2"
-
-        # Handle resolution vs aspect_ratio logic
-        # If resolution is not AUTO, it overrides aspect_ratio
-        final_resolution = None
-        final_aspect_ratio = None
-
-        if resolution != "AUTO":
-            final_resolution = resolution
-        else:
-            final_aspect_ratio = aspect_ratio if aspect_ratio != "ASPECT_1_1" else None
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/ideogram/generate",
-                method=HttpMethod.POST,
-                request_model=IdeogramGenerateRequest,
-                response_model=IdeogramGenerateResponse,
-            ),
-            request=IdeogramGenerateRequest(
-                image_request=ImageRequest(
-                    prompt=prompt,
-                    model=model,
-                    num_images=num_images,
-                    seed=seed,
-                    aspect_ratio=final_aspect_ratio,
-                    resolution=final_resolution,
-                    magic_prompt_option=(
-                        magic_prompt_option if magic_prompt_option != "AUTO" else None
-                    ),
-                    style_type=style_type if style_type != "NONE" else None,
-                    negative_prompt=negative_prompt if negative_prompt else None,
-                    color_palette=color_palette if color_palette else None,
-                )
-            ),
-            auth_kwargs=kwargs,
-        )
-
-        response = operation.execute()
-
-        if not response.data or len(response.data) == 0:
-            raise Exception("No images were generated in the response")
-
-        image_urls = [image_data.url for image_data in response.data if image_data.url]
-
-        if not image_urls:
-            raise Exception("No image URLs were generated in the response")
-
-        display_image_urls_on_node(image_urls, unique_id)
-        return (download_and_process_images(image_urls),)
-
-class IdeogramV3(ComfyNodeABC):
-    """
-    Generates images using the Ideogram V3 model. Supports both regular image generation from text prompts and image editing with mask.
-    """
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation or editing",
-                    },
-                ),
-            },
-            "optional": {
-                "image": (
-                    IO.IMAGE,
-                    {
-                        "default": None,
-                        "tooltip": "Optional reference image for image editing.",
-                    },
-                ),
-                "mask": (
-                    IO.MASK,
-                    {
-                        "default": None,
-                        "tooltip": "Optional mask for inpainting (white areas will be replaced)",
-                    },
-                ),
-                "aspect_ratio": (
-                    IO.COMBO,
-                    {
-                        "options": list(V3_RATIO_MAP.keys()),
-                        "default": "1:1",
-                        "tooltip": "The aspect ratio for image generation. Ignored if resolution is not set to Auto.",
-                    },
-                ),
-                "resolution": (
-                    IO.COMBO,
-                    {
-                        "options": V3_RESOLUTIONS,
-                        "default": "Auto",
-                        "tooltip": "The resolution for image generation. If not set to Auto, this overrides the aspect_ratio setting.",
-                    },
-                ),
-                "magic_prompt_option": (
-                    IO.COMBO,
-                    {
-                        "options": ["AUTO", "ON", "OFF"],
-                        "default": "AUTO",
-                        "tooltip": "Determine if MagicPrompt should be used in generation",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2147483647,
-                        "step": 1,
-                        "control_after_generate": True,
-                        "display": "number",
-                    },
-                ),
-                "num_images": (
-                    IO.INT,
-                    {"default": 1, "min": 1, "max": 8, "step": 1, "display": "number"},
-                ),
-                "rendering_speed": (
-                    IO.COMBO,
-                    {
-                        "options": ["BALANCED", "TURBO", "QUALITY"],
-                        "default": "BALANCED",
-                        "tooltip": "Controls the trade-off between generation speed and quality",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/image/Ideogram"
-    DESCRIPTION = cleandoc(__doc__ or "")
-    API_NODE = True
-
-    def api_call(
-        self,
-        prompt,
-        image=None,
-        mask=None,
-        resolution="Auto",
-        aspect_ratio="1:1",
-        magic_prompt_option="AUTO",
-        seed=0,
-        num_images=1,
-        rendering_speed="BALANCED",
-        unique_id=None,
-        **kwargs,
-    ):
-        # Check if both image and mask are provided for editing mode
-        if image is not None and mask is not None:
-            # Edit mode
-            path = "/proxy/ideogram/ideogram-v3/edit"
-
-            # Process image and mask
-            input_tensor = image.squeeze().cpu()
-            # Resize mask to match image dimension
-            mask = resize_mask_to_image(mask, image, allow_gradient=False)
-            # Invert mask, as Ideogram API will edit black areas instead of white areas (opposite of convention).
-            mask = 1.0 - mask
-
-            # Validate mask dimensions match image
-            if mask.shape[1:] != image.shape[1:-1]:
-                raise Exception("Mask and Image must be the same size")
-
-            # Process image
-            img_np = (input_tensor.numpy() * 255).astype(np.uint8)
-            img = Image.fromarray(img_np)
-            img_byte_arr = io.BytesIO()
-            img.save(img_byte_arr, format="PNG")
-            img_byte_arr.seek(0)
-            img_binary = img_byte_arr
-            img_binary.name = "image.png"
-
-            # Process mask - white areas will be replaced
-            mask_np = (mask.squeeze().cpu().numpy() * 255).astype(np.uint8)
-            mask_img = Image.fromarray(mask_np)
-            mask_byte_arr = io.BytesIO()
-            mask_img.save(mask_byte_arr, format="PNG")
-            mask_byte_arr.seek(0)
-            mask_binary = mask_byte_arr
-            mask_binary.name = "mask.png"
-
-            # Create edit request
-            edit_request = IdeogramV3EditRequest(
-                prompt=prompt,
-                rendering_speed=rendering_speed,
-            )
-
-            # Add optional parameters
-            if magic_prompt_option != "AUTO":
-                edit_request.magic_prompt = magic_prompt_option
-            if seed != 0:
-                edit_request.seed = seed
-            if num_images > 1:
-                edit_request.num_images = num_images
-
-            # Execute the operation for edit mode
-            operation = SynchronousOperation(
-                endpoint=ApiEndpoint(
-                    path=path,
-                    method=HttpMethod.POST,
-                    request_model=IdeogramV3EditRequest,
-                    response_model=IdeogramGenerateResponse,
-                ),
-                request=edit_request,
-                files={
-                    "image": img_binary,
-                    "mask": mask_binary,
-                },
-                content_type="multipart/form-data",
-                auth_kwargs=kwargs,
-            )
-
-        elif image is not None or mask is not None:
-            # If only one of image or mask is provided, raise an error
-            raise Exception("Ideogram V3 image editing requires both an image AND a mask")
-        else:
-            # Generation mode
-            path = "/proxy/ideogram/ideogram-v3/generate"
-
-            # Create generation request
-            gen_request = IdeogramV3Request(
-                prompt=prompt,
-                rendering_speed=rendering_speed,
-            )
-
-            # Handle resolution vs aspect ratio
-            if resolution != "Auto":
-                gen_request.resolution = resolution
-            elif aspect_ratio != "1:1":
-                v3_aspect = V3_RATIO_MAP.get(aspect_ratio)
-                if v3_aspect:
-                    gen_request.aspect_ratio = v3_aspect
-
-            # Add optional parameters
-            if magic_prompt_option != "AUTO":
-                gen_request.magic_prompt = magic_prompt_option
-            if seed != 0:
-                gen_request.seed = seed
-            if num_images > 1:
-                gen_request.num_images = num_images
-
-            # Execute the operation for generation mode
-            operation = SynchronousOperation(
-                endpoint=ApiEndpoint(
-                    path=path,
-                    method=HttpMethod.POST,
-                    request_model=IdeogramV3Request,
-                    response_model=IdeogramGenerateResponse,
-                ),
-                request=gen_request,
-                auth_kwargs=kwargs,
-            )
-
-        # Execute the operation and process response
-        response = operation.execute()
-
-        if not response.data or len(response.data) == 0:
-            raise Exception("No images were generated in the response")
-
-        image_urls = [image_data.url for image_data in response.data if image_data.url]
-
-        if not image_urls:
-            raise Exception("No image URLs were generated in the response")
-
-        display_image_urls_on_node(image_urls, unique_id)
-        return (download_and_process_images(image_urls),)
-
-
-NODE_CLASS_MAPPINGS = {
-    "IdeogramV1": IdeogramV1,
-    "IdeogramV2": IdeogramV2,
-    "IdeogramV3": IdeogramV3,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "IdeogramV1": "Ideogram V1",
-    "IdeogramV2": "Ideogram V2",
-    "IdeogramV3": "Ideogram V3",
-}

comfy_api_nodes/nodes_kling.py

@@ -1,1760 +0,0 @@
-"""Kling API Nodes
-
-For source of truth on the allowed permutations of request fields, please reference:
-- [Compatibility Table](https://app.klingai.com/global/dev/document-api/apiReference/model/skillsMap)
-"""
-
-from __future__ import annotations
-from typing import Optional, TypeVar, Any
-from collections.abc import Callable
-import math
-import logging
-
-import torch
-
-from comfy_api_nodes.apis import (
-    KlingTaskStatus,
-    KlingCameraControl,
-    KlingCameraConfig,
-    KlingCameraControlType,
-    KlingVideoGenDuration,
-    KlingVideoGenMode,
-    KlingVideoGenAspectRatio,
-    KlingVideoGenModelName,
-    KlingText2VideoRequest,
-    KlingText2VideoResponse,
-    KlingImage2VideoRequest,
-    KlingImage2VideoResponse,
-    KlingVideoExtendRequest,
-    KlingVideoExtendResponse,
-    KlingLipSyncVoiceLanguage,
-    KlingLipSyncInputObject,
-    KlingLipSyncRequest,
-    KlingLipSyncResponse,
-    KlingVirtualTryOnModelName,
-    KlingVirtualTryOnRequest,
-    KlingVirtualTryOnResponse,
-    KlingVideoResult,
-    KlingImageResult,
-    KlingImageGenerationsRequest,
-    KlingImageGenerationsResponse,
-    KlingImageGenImageReferenceType,
-    KlingImageGenModelName,
-    KlingImageGenAspectRatio,
-    KlingVideoEffectsRequest,
-    KlingVideoEffectsResponse,
-    KlingDualCharacterEffectsScene,
-    KlingSingleImageEffectsScene,
-    KlingDualCharacterEffectInput,
-    KlingSingleImageEffectInput,
-    KlingCharacterEffectModelName,
-    KlingSingleImageEffectModelName,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    tensor_to_base64_string,
-    download_url_to_video_output,
-    upload_video_to_comfyapi,
-    upload_audio_to_comfyapi,
-    download_url_to_image_tensor,
-)
-from comfy_api_nodes.mapper_utils import model_field_to_node_input
-from comfy_api_nodes.util.validation_utils import (
-    validate_image_dimensions,
-    validate_image_aspect_ratio,
-    validate_video_dimensions,
-    validate_video_duration,
-)
-from comfy_api.input.basic_types import AudioInput
-from comfy_api.input.video_types import VideoInput
-from comfy_api.input_impl import VideoFromFile
-from comfy.comfy_types.node_typing import IO, InputTypeOptions, ComfyNodeABC
-
-KLING_API_VERSION = "v1"
-PATH_TEXT_TO_VIDEO = f"/proxy/kling/{KLING_API_VERSION}/videos/text2video"
-PATH_IMAGE_TO_VIDEO = f"/proxy/kling/{KLING_API_VERSION}/videos/image2video"
-PATH_VIDEO_EXTEND = f"/proxy/kling/{KLING_API_VERSION}/videos/video-extend"
-PATH_LIP_SYNC = f"/proxy/kling/{KLING_API_VERSION}/videos/lip-sync"
-PATH_VIDEO_EFFECTS = f"/proxy/kling/{KLING_API_VERSION}/videos/effects"
-PATH_CHARACTER_IMAGE = f"/proxy/kling/{KLING_API_VERSION}/images/generations"
-PATH_VIRTUAL_TRY_ON = f"/proxy/kling/{KLING_API_VERSION}/images/kolors-virtual-try-on"
-PATH_IMAGE_GENERATIONS = f"/proxy/kling/{KLING_API_VERSION}/images/generations"
-
-MAX_PROMPT_LENGTH_T2V = 2500
-MAX_PROMPT_LENGTH_I2V = 500
-MAX_PROMPT_LENGTH_IMAGE_GEN = 500
-MAX_NEGATIVE_PROMPT_LENGTH_IMAGE_GEN = 200
-MAX_PROMPT_LENGTH_LIP_SYNC = 120
-
-AVERAGE_DURATION_T2V = 319
-AVERAGE_DURATION_I2V = 164
-AVERAGE_DURATION_LIP_SYNC = 455
-AVERAGE_DURATION_VIRTUAL_TRY_ON = 19
-AVERAGE_DURATION_IMAGE_GEN = 32
-AVERAGE_DURATION_VIDEO_EFFECTS = 320
-AVERAGE_DURATION_VIDEO_EXTEND = 320
-
-R = TypeVar("R")
-
-
-class KlingApiError(Exception):
-    """Base exception for Kling API errors."""
-
-    pass
-
-
-def poll_until_finished(
-    auth_kwargs: dict[str, str],
-    api_endpoint: ApiEndpoint[Any, R],
-    result_url_extractor: Optional[Callable[[R], str]] = None,
-    estimated_duration: Optional[int] = None,
-    node_id: Optional[str] = None,
-) -> R:
-    """Polls the Kling API endpoint until the task reaches a terminal state, then returns the response."""
-    return PollingOperation(
-        poll_endpoint=api_endpoint,
-        completed_statuses=[
-            KlingTaskStatus.succeed.value,
-        ],
-        failed_statuses=[KlingTaskStatus.failed.value],
-        status_extractor=lambda response: (
-            response.data.task_status.value
-            if response.data and response.data.task_status
-            else None
-        ),
-        auth_kwargs=auth_kwargs,
-        result_url_extractor=result_url_extractor,
-        estimated_duration=estimated_duration,
-        node_id=node_id,
-        poll_interval=16.0,
-        max_poll_attempts=256,
-    ).execute()
-
-
-def is_valid_camera_control_configs(configs: list[float]) -> bool:
-    """Verifies that at least one camera control configuration is non-zero."""
-    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)
-
-
-def is_valid_video_response(response: KlingText2VideoResponse) -> bool:
-    """Verifies that the response contains a task result with at least one video."""
-    return (
-        response.data is not None
-        and response.data.task_result is not None
-        and response.data.task_result.videos is not None
-        and len(response.data.task_result.videos) > 0
-    )
-
-
-def is_valid_image_response(response: KlingVirtualTryOnResponse) -> bool:
-    """Verifies that the response contains a task result with at least one image."""
-    return (
-        response.data is not None
-        and response.data.task_result is not None
-        and response.data.task_result.images is not None
-        and len(response.data.task_result.images) > 0
-    )
-
-
-def validate_prompts(prompt: str, negative_prompt: str, max_length: int) -> bool:
-    """Verifies that the positive prompt is not empty and that neither promt is too long."""
-    if not prompt:
-        raise ValueError("Positive prompt is empty")
-    if len(prompt) > max_length:
-        raise ValueError(f"Positive prompt is too long: {len(prompt)} characters")
-    if negative_prompt and len(negative_prompt) > max_length:
-        raise ValueError(
-            f"Negative prompt is too long: {len(negative_prompt)} characters"
-        )
-    return True
-
-
-def validate_task_creation_response(response) -> None:
-    """Validates that the Kling task creation request was successful."""
-    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)
-
-
-def validate_video_result_response(response) -> None:
-    """Validates that the Kling task result contains a video."""
-    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)
-
-
-def validate_image_result_response(response) -> None:
-    """Validates that the Kling task result contains an image."""
-    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)
-
-
-def validate_input_image(image: torch.Tensor) -> None:
-    """
-    Validates the input image adheres to the expectations of the Kling API:
-    - The image resolution should not be less than 300*300px
-    - The aspect ratio of the image should be between 1:2.5 ~ 2.5:1
-
-    See: https://app.klingai.com/global/dev/document-api/apiReference/model/imageToVideo
-    """
-    validate_image_dimensions(image, min_width=300, min_height=300)
-    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.
-    """
-    video = response.data.task_result.videos[0]
-    logging.info(
-        "Kling task %s succeeded. Video URL: %s", response.data.task_id, video.url
-    )
-    return video
-
-
-def get_video_url_from_response(response) -> Optional[str]:
-    """Returns the first video url from the Kling video generation task result.
-    Will not raise an error if the response is not valid.
-    """
-    if response and is_valid_video_response(response):
-        return str(get_video_from_response(response).url)
-    else:
-        return None
-
-
-def get_images_from_response(response) -> list[KlingImageResult]:
-    """Returns the list of image objects from the Kling image generation task result.
-    Will raise an error if the response is not valid.
-    """
-    images = response.data.task_result.images
-    logging.info("Kling task %s succeeded. Images: %s", response.data.task_id, images)
-    return images
-
-
-def get_images_urls_from_response(response) -> Optional[str]:
-    """Returns the list of image urls from the Kling image generation task result.
-    Will not raise an error if the response is not valid. If there is only one image, returns the url as a string. If there are multiple images, returns a list of urls.
-    """
-    if response and is_valid_image_response(response):
-        images = get_images_from_response(response)
-        image_urls = [str(image.url) for image in images]
-        return "\n".join(image_urls)
-    else:
-        return None
-
-
-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 (
-        download_url_to_video_output(video.url),
-        str(video.id),
-        str(video.duration),
-    )
-
-
-def image_result_to_node_output(
-    images: list[KlingImageResult],
-) -> torch.Tensor:
-    """
-    Converts a KlingImageResult to a tuple containing a [B, H, W, C] tensor.
-    If multiple images are returned, they will be stacked along the batch dimension.
-    """
-    if len(images) == 1:
-        return download_url_to_image_tensor(images[0].url)
-    else:
-        return torch.cat([download_url_to_image_tensor(image.url) for image in images])
-
-
-class KlingNodeBase(ComfyNodeABC):
-    """Base class for Kling nodes."""
-
-    FUNCTION = "api_call"
-    CATEGORY = "api node/video/Kling"
-    API_NODE = True
-
-
-class KlingCameraControls(KlingNodeBase):
-    """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.",
-                    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
-
-    @classmethod
-    def VALIDATE_INPUTS(
-        cls,
-        horizontal_movement: float,
-        vertical_movement: float,
-        pan: float,
-        tilt: float,
-        roll: float,
-        zoom: float,
-    ) -> bool | str:
-        if not is_valid_camera_control_configs(
-            [
-                horizontal_movement,
-                vertical_movement,
-                pan,
-                tilt,
-                roll,
-                zoom,
-            ]
-        ):
-            return "Invalid camera control configs: at least one of the values must be non-zero"
-        return True
-
-    def main(
-        self,
-        camera_control_type: str,
-        horizontal_movement: float,
-        vertical_movement: float,
-        pan: float,
-        tilt: float,
-        roll: float,
-        zoom: float,
-    ) -> tuple[KlingCameraControl]:
-        return (
-            KlingCameraControl(
-                type=KlingCameraControlType(camera_control_type),
-                config=KlingCameraConfig(
-                    horizontal=horizontal_movement,
-                    vertical=vertical_movement,
-                    pan=pan,
-                    roll=roll,
-                    tilt=tilt,
-                    zoom=zoom,
-                ),
-            ),
-        )
-
-
-class KlingTextToVideoNode(KlingNodeBase):
-    """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"),
-        }
-
-    @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,
-                    "aspect_ratio",
-                    enum_type=KlingVideoGenAspectRatio,
-                ),
-                "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"
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> KlingText2VideoResponse:
-        return 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,
-        )
-
-    def api_call(
-        self,
-        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 = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-
-        task_id = task_creation_response.data.task_id
-        final_response = 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 video_result_to_node_output(video)
-
-
-class KlingCameraControlT2VNode(KlingTextToVideoNode):
-    """
-    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,
-                    "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."
-
-    def api_call(
-        self,
-        prompt: str,
-        negative_prompt: str,
-        cfg_scale: float,
-        aspect_ratio: str,
-        camera_control: Optional[KlingCameraControl] = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        return super().api_call(
-            model_name=KlingVideoGenModelName.kling_v1,
-            cfg_scale=cfg_scale,
-            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):
-    """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,
-                    "model_name",
-                    enum_type=KlingVideoGenModelName,
-                ),
-                "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,
-                    "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"
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> KlingImage2VideoResponse:
-        return 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,
-        )
-
-    def api_call(
-        self,
-        start_frame: torch.Tensor,
-        prompt: str,
-        negative_prompt: str,
-        model_name: str,
-        cfg_scale: float,
-        mode: str,
-        aspect_ratio: str,
-        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
-
-        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 = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.data.task_id
-
-        final_response = 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 video_result_to_node_output(video)
-
-
-class KlingCameraControlI2VNode(KlingImage2VideoNode):
-    """
-    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,
-                    "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."
-
-    def api_call(
-        self,
-        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 super().api_call(
-            model_name=KlingVideoGenModelName.kling_v1_5,
-            start_frame=start_frame,
-            cfg_scale=cfg_scale,
-            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):
-    """
-    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"),
-        }
-
-    @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,
-                    "aspect_ratio",
-                    enum_type=KlingVideoGenAspectRatio,
-                ),
-                "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."
-
-    def api_call(
-        self,
-        start_frame: torch.Tensor,
-        end_frame: torch.Tensor,
-        prompt: str,
-        negative_prompt: str,
-        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 super().api_call(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            model_name=model_name,
-            start_frame=start_frame,
-            cfg_scale=cfg_scale,
-            mode=mode,
-            aspect_ratio=aspect_ratio,
-            duration=duration,
-            end_frame=end_frame,
-            unique_id=unique_id,
-            **kwargs,
-        )
-
-
-class KlingVideoExtendNode(KlingNodeBase):
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": model_field_to_node_input(
-                    IO.STRING, KlingVideoExtendRequest, "prompt", multiline=True
-                ),
-                "negative_prompt": model_field_to_node_input(
-                    IO.STRING,
-                    KlingVideoExtendRequest,
-                    "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."
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> KlingVideoExtendResponse:
-        return 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,
-        )
-
-    def api_call(
-        self,
-        prompt: str,
-        negative_prompt: str,
-        cfg_scale: float,
-        video_id: str,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ) -> tuple[VideoFromFile, str, str]:
-        validate_prompts(prompt, negative_prompt, MAX_PROMPT_LENGTH_T2V)
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_VIDEO_EXTEND,
-                method=HttpMethod.POST,
-                request_model=KlingVideoExtendRequest,
-                response_model=KlingVideoExtendResponse,
-            ),
-            request=KlingVideoExtendRequest(
-                prompt=prompt if prompt else None,
-                negative_prompt=negative_prompt if negative_prompt else None,
-                cfg_scale=cfg_scale,
-                video_id=video_id,
-            ),
-            auth_kwargs=kwargs,
-        )
-
-        task_creation_response = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.data.task_id
-
-        final_response = 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 video_result_to_node_output(video)
-
-
-class KlingVideoEffectsBase(KlingNodeBase):
-    """Kling Video Effects Base"""
-
-    RETURN_TYPES = ("VIDEO", "STRING", "STRING")
-    RETURN_NAMES = ("VIDEO", "video_id", "duration")
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> KlingVideoEffectsResponse:
-        return 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,
-        )
-
-    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 = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.data.task_id
-
-        final_response = 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 video_result_to_node_output(video)
-
-
-class KlingDualCharacterVideoEffectNode(KlingVideoEffectsBase):
-    """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,
-                    "effect_scene",
-                    enum_type=KlingDualCharacterEffectsScene,
-                ),
-                "model_name": model_field_to_node_input(
-                    IO.COMBO,
-                    KlingDualCharacterEffectInput,
-                    "model_name",
-                    enum_type=KlingCharacterEffectModelName,
-                ),
-                "mode": model_field_to_node_input(
-                    IO.COMBO,
-                    KlingDualCharacterEffectInput,
-                    "mode",
-                    enum_type=KlingVideoGenMode,
-                ),
-                "duration": model_field_to_node_input(
-                    IO.COMBO,
-                    KlingDualCharacterEffectInput,
-                    "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")
-
-    def api_call(
-        self,
-        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 = super().api_call(
-            dual_character=True,
-            effect_scene=effect_scene,
-            model_name=model_name,
-            mode=mode,
-            duration=duration,
-            image_1=image_left,
-            image_2=image_right,
-            unique_id=unique_id,
-            **kwargs,
-        )
-        return video, duration
-
-
-class KlingSingleImageVideoEffectNode(KlingVideoEffectsBase):
-    """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,
-                    "effect_scene",
-                    enum_type=KlingSingleImageEffectsScene,
-                ),
-                "model_name": model_field_to_node_input(
-                    IO.COMBO,
-                    KlingSingleImageEffectInput,
-                    "model_name",
-                    enum_type=KlingSingleImageEffectModelName,
-                ),
-                "duration": model_field_to_node_input(
-                    IO.COMBO,
-                    KlingSingleImageEffectInput,
-                    "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."
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        effect_scene: KlingSingleImageEffectsScene,
-        model_name: KlingSingleImageEffectModelName,
-        duration: KlingVideoGenDuration,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        return super().api_call(
-            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."
-            )
-
-    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 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,
-        )
-
-    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 = 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 = 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 = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.data.task_id
-
-        final_response = 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 video_result_to_node_output(video)
-
-
-class KlingLipSyncAudioToVideoNode(KlingLipSyncBase):
-    """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,
-                    "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."
-
-    def api_call(
-        self,
-        video: VideoInput,
-        audio: AudioInput,
-        voice_language: str,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        return super().api_call(
-            video=video,
-            audio=audio,
-            voice_language=voice_language,
-            mode="audio2video",
-            unique_id=unique_id,
-            **kwargs,
-        )
-
-
-class KlingLipSyncTextToVideoNode(KlingLipSyncBase):
-    """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 api_call(
-        self,
-        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 super().api_call(
-            video=video,
-            text=text,
-            voice_language=voice_language,
-            voice_id=voice_id,
-            voice_speed=voice_speed,
-            mode="text2video",
-            unique_id=unique_id,
-            **kwargs,
-        )
-
-
-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):
-    """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,
-                    "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."
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> KlingVirtualTryOnResponse:
-        return 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,
-        )
-
-    def api_call(
-        self,
-        human_image: torch.Tensor,
-        cloth_image: torch.Tensor,
-        model_name: KlingVirtualTryOnModelName,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_VIRTUAL_TRY_ON,
-                method=HttpMethod.POST,
-                request_model=KlingVirtualTryOnRequest,
-                response_model=KlingVirtualTryOnResponse,
-            ),
-            request=KlingVirtualTryOnRequest(
-                human_image=tensor_to_base64_string(human_image),
-                cloth_image=tensor_to_base64_string(cloth_image),
-                model_name=model_name,
-            ),
-            auth_kwargs=kwargs,
-        )
-
-        task_creation_response = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.data.task_id
-
-        final_response = self.get_response(
-            task_id, auth_kwargs=kwargs, node_id=unique_id
-        )
-        validate_image_result_response(final_response)
-
-        images = get_images_from_response(final_response)
-        return (image_result_to_node_output(images),)
-
-
-class KlingImageGenerationNode(KlingImageGenerationBase):
-    """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,
-                    "image_fidelity",
-                    slider=True,
-                    step=0.01,
-                ),
-                "human_fidelity": model_field_to_node_input(
-                    IO.FLOAT,
-                    KlingImageGenerationsRequest,
-                    "human_fidelity",
-                    slider=True,
-                    step=0.01,
-                ),
-                "model_name": model_field_to_node_input(
-                    IO.COMBO,
-                    KlingImageGenerationsRequest,
-                    "model_name",
-                    enum_type=KlingImageGenModelName,
-                ),
-                "aspect_ratio": model_field_to_node_input(
-                    IO.COMBO,
-                    KlingImageGenerationsRequest,
-                    "aspect_ratio",
-                    enum_type=KlingImageGenAspectRatio,
-                ),
-                "n": model_field_to_node_input(
-                    IO.INT,
-                    KlingImageGenerationsRequest,
-                    "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."
-
-    def get_response(
-        self,
-        task_id: str,
-        auth_kwargs: Optional[dict[str, str]],
-        node_id: Optional[str] = None,
-    ) -> KlingImageGenerationsResponse:
-        return 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,
-        )
-
-    def api_call(
-        self,
-        model_name: KlingImageGenModelName,
-        prompt: str,
-        negative_prompt: str,
-        image_type: KlingImageGenImageReferenceType,
-        image_fidelity: float,
-        human_fidelity: float,
-        n: int,
-        aspect_ratio: KlingImageGenAspectRatio,
-        image: Optional[torch.Tensor] = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        self.validate_prompt(prompt, negative_prompt)
-
-        if image is not None:
-            image = tensor_to_base64_string(image)
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_IMAGE_GENERATIONS,
-                method=HttpMethod.POST,
-                request_model=KlingImageGenerationsRequest,
-                response_model=KlingImageGenerationsResponse,
-            ),
-            request=KlingImageGenerationsRequest(
-                model_name=model_name,
-                prompt=prompt,
-                negative_prompt=negative_prompt,
-                image=image,
-                image_reference=image_type,
-                image_fidelity=image_fidelity,
-                human_fidelity=human_fidelity,
-                n=n,
-                aspect_ratio=aspect_ratio,
-            ),
-            auth_kwargs=kwargs,
-        )
-
-        task_creation_response = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.data.task_id
-
-        final_response = self.get_response(
-            task_id, auth_kwargs=kwargs, node_id=unique_id
-        )
-        validate_image_result_response(final_response)
-
-        images = get_images_from_response(final_response)
-        return (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,
-}
-
-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",
-}

comfy_api_nodes/nodes_luma.py

@@ -1,737 +0,0 @@
-from __future__ import annotations
-from inspect import cleandoc
-from typing import Optional
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC
-from comfy_api.input_impl.video_types import VideoFromFile
-from comfy_api_nodes.apis.luma_api import (
-    LumaImageModel,
-    LumaVideoModel,
-    LumaVideoOutputResolution,
-    LumaVideoModelOutputDuration,
-    LumaAspectRatio,
-    LumaState,
-    LumaImageGenerationRequest,
-    LumaGenerationRequest,
-    LumaGeneration,
-    LumaCharacterRef,
-    LumaModifyImageRef,
-    LumaImageIdentity,
-    LumaReference,
-    LumaReferenceChain,
-    LumaImageReference,
-    LumaKeyframes,
-    LumaConceptChain,
-    LumaIO,
-    get_luma_concepts,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    upload_images_to_comfyapi,
-    process_image_response,
-    validate_string,
-)
-from server import PromptServer
-
-import requests
-import torch
-from io import BytesIO
-
-LUMA_T2V_AVERAGE_DURATION = 105
-LUMA_I2V_AVERAGE_DURATION = 100
-
-def image_result_url_extractor(response: LumaGeneration):
-    return response.assets.image if hasattr(response, "assets") and hasattr(response.assets, "image") else None
-
-def video_result_url_extractor(response: LumaGeneration):
-    return response.assets.video if hasattr(response, "assets") and hasattr(response.assets, "video") else None
-
-class LumaReferenceNode(ComfyNodeABC):
-    """
-    Holds an image and weight for use with Luma Generate Image node.
-    """
-
-    RETURN_TYPES = (LumaIO.LUMA_REF,)
-    RETURN_NAMES = ("luma_ref",)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "create_luma_reference"
-    CATEGORY = "api node/image/Luma"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (
-                    IO.IMAGE,
-                    {
-                        "tooltip": "Image to use as reference.",
-                    },
-                ),
-                "weight": (
-                    IO.FLOAT,
-                    {
-                        "default": 1.0,
-                        "min": 0.0,
-                        "max": 1.0,
-                        "step": 0.01,
-                        "tooltip": "Weight of image reference.",
-                    },
-                ),
-            },
-            "optional": {"luma_ref": (LumaIO.LUMA_REF,)},
-        }
-
-    def create_luma_reference(
-        self, image: torch.Tensor, weight: float, luma_ref: LumaReferenceChain = None
-    ):
-        if luma_ref is not None:
-            luma_ref = luma_ref.clone()
-        else:
-            luma_ref = LumaReferenceChain()
-        luma_ref.add(LumaReference(image=image, weight=round(weight, 2)))
-        return (luma_ref,)
-
-
-class LumaConceptsNode(ComfyNodeABC):
-    """
-    Holds one or more Camera Concepts for use with Luma Text to Video and Luma Image to Video nodes.
-    """
-
-    RETURN_TYPES = (LumaIO.LUMA_CONCEPTS,)
-    RETURN_NAMES = ("luma_concepts",)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "create_concepts"
-    CATEGORY = "api node/video/Luma"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "concept1": (get_luma_concepts(include_none=True),),
-                "concept2": (get_luma_concepts(include_none=True),),
-                "concept3": (get_luma_concepts(include_none=True),),
-                "concept4": (get_luma_concepts(include_none=True),),
-            },
-            "optional": {
-                "luma_concepts": (
-                    LumaIO.LUMA_CONCEPTS,
-                    {
-                        "tooltip": "Optional Camera Concepts to add to the ones chosen here."
-                    },
-                ),
-            },
-        }
-
-    def create_concepts(
-        self,
-        concept1: str,
-        concept2: str,
-        concept3: str,
-        concept4: str,
-        luma_concepts: LumaConceptChain = None,
-    ):
-        chain = LumaConceptChain(str_list=[concept1, concept2, concept3, concept4])
-        if luma_concepts is not None:
-            chain = luma_concepts.clone_and_merge(chain)
-        return (chain,)
-
-
-class LumaImageGenerationNode(ComfyNodeABC):
-    """
-    Generates images synchronously based on prompt and aspect ratio.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Luma"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "model": ([model.value for model in LumaImageModel],),
-                "aspect_ratio": (
-                    [ratio.value for ratio in LumaAspectRatio],
-                    {
-                        "default": LumaAspectRatio.ratio_16_9,
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-                "style_image_weight": (
-                    IO.FLOAT,
-                    {
-                        "default": 1.0,
-                        "min": 0.0,
-                        "max": 1.0,
-                        "step": 0.01,
-                        "tooltip": "Weight of style image. Ignored if no style_image provided.",
-                    },
-                ),
-            },
-            "optional": {
-                "image_luma_ref": (
-                    LumaIO.LUMA_REF,
-                    {
-                        "tooltip": "Luma Reference node connection to influence generation with input images; up to 4 images can be considered."
-                    },
-                ),
-                "style_image": (
-                    IO.IMAGE,
-                    {"tooltip": "Style reference image; only 1 image will be used."},
-                ),
-                "character_image": (
-                    IO.IMAGE,
-                    {
-                        "tooltip": "Character reference images; can be a batch of multiple, up to 4 images can be considered."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        model: str,
-        aspect_ratio: str,
-        seed,
-        style_image_weight: float,
-        image_luma_ref: LumaReferenceChain = None,
-        style_image: torch.Tensor = None,
-        character_image: torch.Tensor = None,
-        unique_id: str = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=True, min_length=3)
-        # handle image_luma_ref
-        api_image_ref = None
-        if image_luma_ref is not None:
-            api_image_ref = self._convert_luma_refs(
-                image_luma_ref, max_refs=4, auth_kwargs=kwargs,
-            )
-        # handle style_luma_ref
-        api_style_ref = None
-        if style_image is not None:
-            api_style_ref = self._convert_style_image(
-                style_image, weight=style_image_weight, auth_kwargs=kwargs,
-            )
-        # handle character_ref images
-        character_ref = None
-        if character_image is not None:
-            download_urls = upload_images_to_comfyapi(
-                character_image, max_images=4, auth_kwargs=kwargs,
-            )
-            character_ref = LumaCharacterRef(
-                identity0=LumaImageIdentity(images=download_urls)
-            )
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/luma/generations/image",
-                method=HttpMethod.POST,
-                request_model=LumaImageGenerationRequest,
-                response_model=LumaGeneration,
-            ),
-            request=LumaImageGenerationRequest(
-                prompt=prompt,
-                model=model,
-                aspect_ratio=aspect_ratio,
-                image_ref=api_image_ref,
-                style_ref=api_style_ref,
-                character_ref=character_ref,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response_api: LumaGeneration = operation.execute()
-
-        operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"/proxy/luma/generations/{response_api.id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=LumaGeneration,
-            ),
-            completed_statuses=[LumaState.completed],
-            failed_statuses=[LumaState.failed],
-            status_extractor=lambda x: x.state,
-            result_url_extractor=image_result_url_extractor,
-            node_id=unique_id,
-            auth_kwargs=kwargs,
-        )
-        response_poll = operation.execute()
-
-        img_response = requests.get(response_poll.assets.image)
-        img = process_image_response(img_response)
-        return (img,)
-
-    def _convert_luma_refs(
-        self, luma_ref: LumaReferenceChain, max_refs: int, auth_kwargs: Optional[dict[str,str]] = None
-    ):
-        luma_urls = []
-        ref_count = 0
-        for ref in luma_ref.refs:
-            download_urls = upload_images_to_comfyapi(
-                ref.image, max_images=1, auth_kwargs=auth_kwargs
-            )
-            luma_urls.append(download_urls[0])
-            ref_count += 1
-            if ref_count >= max_refs:
-                break
-        return luma_ref.create_api_model(download_urls=luma_urls, max_refs=max_refs)
-
-    def _convert_style_image(
-        self, style_image: torch.Tensor, weight: float, auth_kwargs: Optional[dict[str,str]] = None
-    ):
-        chain = LumaReferenceChain(
-            first_ref=LumaReference(image=style_image, weight=weight)
-        )
-        return self._convert_luma_refs(chain, max_refs=1, auth_kwargs=auth_kwargs)
-
-
-class LumaImageModifyNode(ComfyNodeABC):
-    """
-    Modifies images synchronously based on prompt and aspect ratio.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Luma"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation",
-                    },
-                ),
-                "image_weight": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.1,
-                        "min": 0.0,
-                        "max": 0.98,
-                        "step": 0.01,
-                        "tooltip": "Weight of the image; the closer to 1.0, the less the image will be modified.",
-                    },
-                ),
-                "model": ([model.value for model in LumaImageModel],),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-            },
-            "optional": {},
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        model: str,
-        image: torch.Tensor,
-        image_weight: float,
-        seed,
-        unique_id: str = None,
-        **kwargs,
-    ):
-        # first, upload image
-        download_urls = upload_images_to_comfyapi(
-            image, max_images=1, auth_kwargs=kwargs,
-        )
-        image_url = download_urls[0]
-        # next, make Luma call with download url provided
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/luma/generations/image",
-                method=HttpMethod.POST,
-                request_model=LumaImageGenerationRequest,
-                response_model=LumaGeneration,
-            ),
-            request=LumaImageGenerationRequest(
-                prompt=prompt,
-                model=model,
-                modify_image_ref=LumaModifyImageRef(
-                    url=image_url, weight=round(max(min(1.0-image_weight, 0.98), 0.0), 2)
-                ),
-            ),
-            auth_kwargs=kwargs,
-        )
-        response_api: LumaGeneration = operation.execute()
-
-        operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"/proxy/luma/generations/{response_api.id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=LumaGeneration,
-            ),
-            completed_statuses=[LumaState.completed],
-            failed_statuses=[LumaState.failed],
-            status_extractor=lambda x: x.state,
-            result_url_extractor=image_result_url_extractor,
-            node_id=unique_id,
-            auth_kwargs=kwargs,
-        )
-        response_poll = operation.execute()
-
-        img_response = requests.get(response_poll.assets.image)
-        img = process_image_response(img_response)
-        return (img,)
-
-
-class LumaTextToVideoGenerationNode(ComfyNodeABC):
-    """
-    Generates videos synchronously based on prompt and output_size.
-    """
-
-    RETURN_TYPES = (IO.VIDEO,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/video/Luma"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the video generation",
-                    },
-                ),
-                "model": ([model.value for model in LumaVideoModel],),
-                "aspect_ratio": (
-                    [ratio.value for ratio in LumaAspectRatio],
-                    {
-                        "default": LumaAspectRatio.ratio_16_9,
-                    },
-                ),
-                "resolution": (
-                    [resolution.value for resolution in LumaVideoOutputResolution],
-                    {
-                        "default": LumaVideoOutputResolution.res_540p,
-                    },
-                ),
-                "duration": ([dur.value for dur in LumaVideoModelOutputDuration],),
-                "loop": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-            },
-            "optional": {
-                "luma_concepts": (
-                    LumaIO.LUMA_CONCEPTS,
-                    {
-                        "tooltip": "Optional Camera Concepts to dictate camera motion via the Luma Concepts node."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        model: str,
-        aspect_ratio: str,
-        resolution: str,
-        duration: str,
-        loop: bool,
-        seed,
-        luma_concepts: LumaConceptChain = None,
-        unique_id: str = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False, min_length=3)
-        duration = duration if model != LumaVideoModel.ray_1_6 else None
-        resolution = resolution if model != LumaVideoModel.ray_1_6 else None
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/luma/generations",
-                method=HttpMethod.POST,
-                request_model=LumaGenerationRequest,
-                response_model=LumaGeneration,
-            ),
-            request=LumaGenerationRequest(
-                prompt=prompt,
-                model=model,
-                resolution=resolution,
-                aspect_ratio=aspect_ratio,
-                duration=duration,
-                loop=loop,
-                concepts=luma_concepts.create_api_model() if luma_concepts else None,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response_api: LumaGeneration = operation.execute()
-
-        if unique_id:
-            PromptServer.instance.send_progress_text(f"Luma video generation started: {response_api.id}", unique_id)
-
-        operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"/proxy/luma/generations/{response_api.id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=LumaGeneration,
-            ),
-            completed_statuses=[LumaState.completed],
-            failed_statuses=[LumaState.failed],
-            status_extractor=lambda x: x.state,
-            result_url_extractor=video_result_url_extractor,
-            node_id=unique_id,
-            estimated_duration=LUMA_T2V_AVERAGE_DURATION,
-            auth_kwargs=kwargs,
-        )
-        response_poll = operation.execute()
-
-        vid_response = requests.get(response_poll.assets.video)
-        return (VideoFromFile(BytesIO(vid_response.content)),)
-
-
-class LumaImageToVideoGenerationNode(ComfyNodeABC):
-    """
-    Generates videos synchronously based on prompt, input images, and output_size.
-    """
-
-    RETURN_TYPES = (IO.VIDEO,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/video/Luma"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the video generation",
-                    },
-                ),
-                "model": ([model.value for model in LumaVideoModel],),
-                # "aspect_ratio": ([ratio.value for ratio in LumaAspectRatio], {
-                #     "default": LumaAspectRatio.ratio_16_9,
-                # }),
-                "resolution": (
-                    [resolution.value for resolution in LumaVideoOutputResolution],
-                    {
-                        "default": LumaVideoOutputResolution.res_540p,
-                    },
-                ),
-                "duration": ([dur.value for dur in LumaVideoModelOutputDuration],),
-                "loop": (
-                    IO.BOOLEAN,
-                    {
-                        "default": False,
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-            },
-            "optional": {
-                "first_image": (
-                    IO.IMAGE,
-                    {"tooltip": "First frame of generated video."},
-                ),
-                "last_image": (IO.IMAGE, {"tooltip": "Last frame of generated video."}),
-                "luma_concepts": (
-                    LumaIO.LUMA_CONCEPTS,
-                    {
-                        "tooltip": "Optional Camera Concepts to dictate camera motion via the Luma Concepts node."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        model: str,
-        resolution: str,
-        duration: str,
-        loop: bool,
-        seed,
-        first_image: torch.Tensor = None,
-        last_image: torch.Tensor = None,
-        luma_concepts: LumaConceptChain = None,
-        unique_id: str = None,
-        **kwargs,
-    ):
-        if first_image is None and last_image is None:
-            raise Exception(
-                "At least one of first_image and last_image requires an input."
-            )
-        keyframes = self._convert_to_keyframes(first_image, last_image, auth_kwargs=kwargs)
-        duration = duration if model != LumaVideoModel.ray_1_6 else None
-        resolution = resolution if model != LumaVideoModel.ray_1_6 else None
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/luma/generations",
-                method=HttpMethod.POST,
-                request_model=LumaGenerationRequest,
-                response_model=LumaGeneration,
-            ),
-            request=LumaGenerationRequest(
-                prompt=prompt,
-                model=model,
-                aspect_ratio=LumaAspectRatio.ratio_16_9,  # ignored, but still needed by the API for some reason
-                resolution=resolution,
-                duration=duration,
-                loop=loop,
-                keyframes=keyframes,
-                concepts=luma_concepts.create_api_model() if luma_concepts else None,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response_api: LumaGeneration = operation.execute()
-
-        if unique_id:
-            PromptServer.instance.send_progress_text(f"Luma video generation started: {response_api.id}", unique_id)
-
-        operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"/proxy/luma/generations/{response_api.id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=LumaGeneration,
-            ),
-            completed_statuses=[LumaState.completed],
-            failed_statuses=[LumaState.failed],
-            status_extractor=lambda x: x.state,
-            result_url_extractor=video_result_url_extractor,
-            node_id=unique_id,
-            estimated_duration=LUMA_I2V_AVERAGE_DURATION,
-            auth_kwargs=kwargs,
-        )
-        response_poll = operation.execute()
-
-        vid_response = requests.get(response_poll.assets.video)
-        return (VideoFromFile(BytesIO(vid_response.content)),)
-
-    def _convert_to_keyframes(
-        self,
-        first_image: torch.Tensor = None,
-        last_image: torch.Tensor = None,
-        auth_kwargs: Optional[dict[str,str]] = None,
-    ):
-        if first_image is None and last_image is None:
-            return None
-        frame0 = None
-        frame1 = None
-        if first_image is not None:
-            download_urls = upload_images_to_comfyapi(
-                first_image, max_images=1, auth_kwargs=auth_kwargs,
-            )
-            frame0 = LumaImageReference(type="image", url=download_urls[0])
-        if last_image is not None:
-            download_urls = upload_images_to_comfyapi(
-                last_image, max_images=1, auth_kwargs=auth_kwargs,
-            )
-            frame1 = LumaImageReference(type="image", url=download_urls[0])
-        return LumaKeyframes(frame0=frame0, frame1=frame1)
-
-
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
-    "LumaImageNode": LumaImageGenerationNode,
-    "LumaImageModifyNode": LumaImageModifyNode,
-    "LumaVideoNode": LumaTextToVideoGenerationNode,
-    "LumaImageToVideoNode": LumaImageToVideoGenerationNode,
-    "LumaReferenceNode": LumaReferenceNode,
-    "LumaConceptsNode": LumaConceptsNode,
-}
-
-# A dictionary that contains the friendly/humanly readable titles for the nodes
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "LumaImageNode": "Luma Text to Image",
-    "LumaImageModifyNode": "Luma Image to Image",
-    "LumaVideoNode": "Luma Text to Video",
-    "LumaImageToVideoNode": "Luma Image to Video",
-    "LumaReferenceNode": "Luma Reference",
-    "LumaConceptsNode": "Luma Concepts",
-}

comfy_api_nodes/nodes_minimax.py

@@ -1,332 +0,0 @@
-from typing import Union
-import logging
-import torch
-
-from comfy.comfy_types.node_typing import IO
-from comfy_api.input_impl.video_types import VideoFromFile
-from comfy_api_nodes.apis import (
-    MinimaxVideoGenerationRequest,
-    MinimaxVideoGenerationResponse,
-    MinimaxFileRetrieveResponse,
-    MinimaxTaskResultResponse,
-    SubjectReferenceItem,
-    Model
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    download_url_to_bytesio,
-    upload_images_to_comfyapi,
-    validate_string,
-)
-from server import PromptServer
-
-
-I2V_AVERAGE_DURATION = 114
-T2V_AVERAGE_DURATION = 234
-
-class MinimaxTextToVideoNode:
-    """
-    Generates videos synchronously based on a prompt, and optional parameters using MiniMax's API.
-    """
-
-    AVERAGE_DURATION = T2V_AVERAGE_DURATION
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt_text": (
-                    "STRING",
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text prompt to guide the video generation",
-                    },
-                ),
-                "model": (
-                    [
-                        "T2V-01",
-                        "T2V-01-Director",
-                    ],
-                    {
-                        "default": "T2V-01",
-                        "tooltip": "Model to use for video generation",
-                    },
-                ),
-            },
-            "optional": {
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("VIDEO",)
-    DESCRIPTION = "Generates videos from prompts using MiniMax's API"
-    FUNCTION = "generate_video"
-    CATEGORY = "api node/video/MiniMax"
-    API_NODE = True
-    OUTPUT_NODE = True
-
-    def generate_video(
-        self,
-        prompt_text,
-        seed=0,
-        model="T2V-01",
-        image: torch.Tensor=None, # used for ImageToVideo
-        subject: torch.Tensor=None, # used for SubjectToVideo
-        unique_id: Union[str, None]=None,
-        **kwargs,
-    ):
-        '''
-        Function used between MiniMax nodes - supports T2V, I2V, and S2V, based on provided arguments.
-        '''
-        if image is None:
-            validate_string(prompt_text, field_name="prompt_text")
-        # upload image, if passed in
-        image_url = None
-        if image is not None:
-            image_url = upload_images_to_comfyapi(image, max_images=1, auth_kwargs=kwargs)[0]
-
-        # TODO: figure out how to deal with subject properly, API returns invalid params when using S2V-01 model
-        subject_reference = None
-        if subject is not None:
-            subject_url = upload_images_to_comfyapi(subject, max_images=1, auth_kwargs=kwargs)[0]
-            subject_reference = [SubjectReferenceItem(image=subject_url)]
-
-
-        video_generate_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/minimax/video_generation",
-                method=HttpMethod.POST,
-                request_model=MinimaxVideoGenerationRequest,
-                response_model=MinimaxVideoGenerationResponse,
-            ),
-            request=MinimaxVideoGenerationRequest(
-                model=Model(model),
-                prompt=prompt_text,
-                callback_url=None,
-                first_frame_image=image_url,
-                subject_reference=subject_reference,
-                prompt_optimizer=None,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response = video_generate_operation.execute()
-
-        task_id = response.task_id
-        if not task_id:
-            raise Exception(f"MiniMax generation failed: {response.base_resp}")
-
-        video_generate_operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path="/proxy/minimax/query/video_generation",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=MinimaxTaskResultResponse,
-                query_params={"task_id": task_id},
-            ),
-            completed_statuses=["Success"],
-            failed_statuses=["Fail"],
-            status_extractor=lambda x: x.status.value,
-            estimated_duration=self.AVERAGE_DURATION,
-            node_id=unique_id,
-            auth_kwargs=kwargs,
-        )
-        task_result = video_generate_operation.execute()
-
-        file_id = task_result.file_id
-        if file_id is None:
-            raise Exception("Request was not successful. Missing file ID.")
-        file_retrieve_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/minimax/files/retrieve",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=MinimaxFileRetrieveResponse,
-                query_params={"file_id": int(file_id)},
-            ),
-            request=EmptyRequest(),
-            auth_kwargs=kwargs,
-        )
-        file_result = file_retrieve_operation.execute()
-
-        file_url = file_result.file.download_url
-        if file_url is None:
-            raise Exception(
-                f"No video was found in the response. Full response: {file_result.model_dump()}"
-            )
-        logging.info(f"Generated video URL: {file_url}")
-        if unique_id:
-            if hasattr(file_result.file, "backup_download_url"):
-                message = f"Result URL: {file_url}\nBackup URL: {file_result.file.backup_download_url}"
-            else:
-                message = f"Result URL: {file_url}"
-            PromptServer.instance.send_progress_text(message, unique_id)
-
-        video_io = download_url_to_bytesio(file_url)
-        if video_io is None:
-            error_msg = f"Failed to download video from {file_url}"
-            logging.error(error_msg)
-            raise Exception(error_msg)
-        return (VideoFromFile(video_io),)
-
-
-class MinimaxImageToVideoNode(MinimaxTextToVideoNode):
-    """
-    Generates videos synchronously based on an image and prompt, and optional parameters using MiniMax's API.
-    """
-
-    AVERAGE_DURATION = I2V_AVERAGE_DURATION
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (
-                    IO.IMAGE,
-                    {
-                        "tooltip": "Image to use as first frame of video generation"
-                    },
-                ),
-                "prompt_text": (
-                    "STRING",
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text prompt to guide the video generation",
-                    },
-                ),
-                "model": (
-                    [
-                        "I2V-01-Director",
-                        "I2V-01",
-                        "I2V-01-live",
-                    ],
-                    {
-                        "default": "I2V-01",
-                        "tooltip": "Model to use for video generation",
-                    },
-                ),
-            },
-            "optional": {
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("VIDEO",)
-    DESCRIPTION = "Generates videos from an image and prompts using MiniMax's API"
-    FUNCTION = "generate_video"
-    CATEGORY = "api node/video/MiniMax"
-    API_NODE = True
-    OUTPUT_NODE = True
-
-
-class MinimaxSubjectToVideoNode(MinimaxTextToVideoNode):
-    """
-    Generates videos synchronously based on an image and prompt, and optional parameters using MiniMax's API.
-    """
-
-    AVERAGE_DURATION = T2V_AVERAGE_DURATION
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "subject": (
-                    IO.IMAGE,
-                    {
-                        "tooltip": "Image of subject to reference video generation"
-                    },
-                ),
-                "prompt_text": (
-                    "STRING",
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text prompt to guide the video generation",
-                    },
-                ),
-                "model": (
-                    [
-                        "S2V-01",
-                    ],
-                    {
-                        "default": "S2V-01",
-                        "tooltip": "Model to use for video generation",
-                    },
-                ),
-            },
-            "optional": {
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("VIDEO",)
-    DESCRIPTION = "Generates videos from an image and prompts using MiniMax's API"
-    FUNCTION = "generate_video"
-    CATEGORY = "api node/video/MiniMax"
-    API_NODE = True
-    OUTPUT_NODE = True
-
-
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
-    "MinimaxTextToVideoNode": MinimaxTextToVideoNode,
-    "MinimaxImageToVideoNode": MinimaxImageToVideoNode,
-    # "MinimaxSubjectToVideoNode": MinimaxSubjectToVideoNode,
-}
-
-# A dictionary that contains the friendly/humanly readable titles for the nodes
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "MinimaxTextToVideoNode": "MiniMax Text to Video",
-    "MinimaxImageToVideoNode": "MiniMax Image to Video",
-    "MinimaxSubjectToVideoNode": "MiniMax Subject to Video",
-}

comfy_api_nodes/nodes_moonvalley.py

@@ -1,639 +0,0 @@
-import logging
-from typing import Any, Callable, Optional, TypeVar
-import random
-import torch
-from comfy_api_nodes.util.validation_utils import get_image_dimensions, validate_image_dimensions, validate_video_dimensions
-
-
-from comfy_api_nodes.apis import (
-    MoonvalleyTextToVideoRequest,
-    MoonvalleyTextToVideoInferenceParams,
-    MoonvalleyVideoToVideoInferenceParams,
-    MoonvalleyVideoToVideoRequest,
-    MoonvalleyPromptResponse
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    download_url_to_video_output,
-    upload_images_to_comfyapi,
-    upload_video_to_comfyapi,
-)
-from comfy_api_nodes.mapper_utils import model_field_to_node_input
-
-from comfy_api.input.video_types import VideoInput
-from comfy.comfy_types.node_typing import IO
-from comfy_api.input_impl import VideoFromFile
-import av
-import io
-
-API_UPLOADS_ENDPOINT = "/proxy/moonvalley/uploads"
-API_PROMPTS_ENDPOINT = "/proxy/moonvalley/prompts"
-API_VIDEO2VIDEO_ENDPOINT = "/proxy/moonvalley/prompts/video-to-video"
-API_TXT2VIDEO_ENDPOINT = "/proxy/moonvalley/prompts/text-to-video"
-API_IMG2VIDEO_ENDPOINT = "/proxy/moonvalley/prompts/image-to-video"
-
-MIN_WIDTH = 300
-MIN_HEIGHT = 300
-
-MAX_WIDTH = 10000
-MAX_HEIGHT = 10000
-
-MIN_VID_WIDTH = 300
-MIN_VID_HEIGHT = 300
-
-MAX_VID_WIDTH = 10000
-MAX_VID_HEIGHT = 10000
-
-MAX_VIDEO_SIZE = 1024 * 1024 * 1024  # 1 GB max for in-memory video processing
-
-MOONVALLEY_MAREY_MAX_PROMPT_LENGTH = 5000
-R = TypeVar("R")
-class MoonvalleyApiError(Exception):
-    """Base exception for Moonvalley API errors."""
-    pass
-
-def is_valid_task_creation_response(response: MoonvalleyPromptResponse) -> bool:
-    """Verifies that the initial response contains a task ID."""
-    return bool(response.id)
-
-def validate_task_creation_response(response) -> None:
-    if not is_valid_task_creation_response(response):
-        error_msg = f"Moonvalley Marey API: Initial request failed. Code: {response.code}, Message: {response.message}, Data: {response}"
-        logging.error(error_msg)
-        raise MoonvalleyApiError(error_msg)
-
-def get_video_from_response(response):
-    video = response.output_url
-    logging.info(
-        "Moonvalley Marey API: Task %s succeeded. Video URL: %s", response.id, video
-    )
-    return video
-
-
-def get_video_url_from_response(response) -> Optional[str]:
-    """Returns the first video url from the Moonvalley video generation task result.
-    Will not raise an error if the response is not valid.
-    """
-    if response:
-        return str(get_video_from_response(response))
-    else:
-        return None
-
-
-def poll_until_finished(
-    auth_kwargs: dict[str, str],
-    api_endpoint: ApiEndpoint[Any, R],
-    result_url_extractor: Optional[Callable[[R], str]] = None,
-    node_id: Optional[str] = None,
-) -> R:
-    """Polls the Moonvalley API endpoint until the task reaches a terminal state, then returns the response."""
-    return PollingOperation(
-        poll_endpoint=api_endpoint,
-        completed_statuses=[
-            "completed",
-        ],
-        max_poll_attempts=240,  # 64 minutes with 16s interval
-        poll_interval=16.0,
-        failed_statuses=["error"],
-        status_extractor=lambda response: (
-            response.status
-            if response and response.status
-            else None
-        ),
-        auth_kwargs=auth_kwargs,
-        result_url_extractor=result_url_extractor,
-        node_id=node_id,
-    ).execute()
-
-def validate_prompts(prompt:str, negative_prompt: str, max_length=MOONVALLEY_MAREY_MAX_PROMPT_LENGTH):
-    """Verifies that the prompt isn't empty and that neither prompt is too long."""
-    if not prompt:
-        raise ValueError("Positive prompt is empty")
-    if len(prompt) > max_length:
-        raise ValueError(f"Positive prompt is too long: {len(prompt)} characters")
-    if negative_prompt and len(negative_prompt) > max_length:
-        raise ValueError(
-            f"Negative prompt is too long: {len(negative_prompt)} characters"
-        )
-    return True
-
-def validate_input_media(width, height, with_frame_conditioning, num_frames_in=None):
-        # inference validation
-        # T = num_frames
-        # in all cases, the following must be true: T divisible by 16 and H,W by 8. in addition...
-        # with image conditioning: H*W must be divisible by 8192
-        # without image conditioning: T divisible by 32
-    if num_frames_in and not num_frames_in % 16 == 0 :
-        return False, (
-            "The input video total frame count must be divisible by 16!"
-        )
-
-    if height % 8 != 0 or width % 8 != 0:
-        return False, (
-            f"Height ({height}) and width ({width}) must be " "divisible by 8"
-        )
-
-    if with_frame_conditioning:
-        if (height * width) % 8192 != 0:
-            return False, (
-                f"Height * width ({height * width}) must be "
-                "divisible by 8192 for frame conditioning"
-            )
-    else:
-        if num_frames_in and not num_frames_in % 32 == 0 :
-            return False, (
-                "The input video total frame count must be divisible by 32!"
-            )
-
-
-def validate_input_image(image: torch.Tensor, with_frame_conditioning: bool=False) -> None:
-    """
-    Validates the input image adheres to the expectations of the API:
-    - The image resolution should not be less than 300*300px
-    - The aspect ratio of the image should be between 1:2.5 ~ 2.5:1
-
-    """
-    height, width = get_image_dimensions(image)
-    validate_input_media(width, height, with_frame_conditioning )
-    validate_image_dimensions(image, min_width=300, min_height=300, max_height=MAX_HEIGHT, max_width=MAX_WIDTH)
-
-def validate_input_video(video: VideoInput, num_frames_out: int, with_frame_conditioning: bool=False):
-    try:
-        width, height = video.get_dimensions()
-    except Exception as e:
-        logging.error("Error getting dimensions of video: %s", e)
-        raise ValueError(f"Cannot get video dimensions: {e}") from e
-
-    validate_input_media(width, height, with_frame_conditioning)
-    validate_video_dimensions(video, min_width=MIN_VID_WIDTH, min_height=MIN_VID_HEIGHT, max_width=MAX_VID_WIDTH, max_height=MAX_VID_HEIGHT)
-
-    trimmed_video = validate_input_video_length(video, num_frames_out)
-    return trimmed_video
-
-
-def validate_input_video_length(video: VideoInput, num_frames: int):
-
-    if video.get_duration() > 60:
-        raise MoonvalleyApiError("Input Video lenth should be less than 1min. Please trim.")
-
-    if num_frames == 128:
-       if video.get_duration() < 5:
-           raise MoonvalleyApiError("Input Video length is less than 5s. Please use a video longer than or equal to 5s.")
-       if video.get_duration() > 5:
-        #    trim video to 5s
-        video = trim_video(video, 5)
-    if num_frames == 256:
-        if video.get_duration() < 10:
-            raise MoonvalleyApiError("Input Video length is less than 10s. Please use a video longer than or equal to 10s.")
-        if video.get_duration() > 10:
-            # trim video to 10s
-            video = trim_video(video, 10)
-    return video
-
-def trim_video(video: VideoInput, duration_sec: float) -> VideoInput:
-    """
-    Returns a new VideoInput object trimmed from the beginning to the specified duration,
-    using av to avoid loading entire video into memory.
-
-    Args:
-        video: Input video to trim
-        duration_sec: Duration in seconds to keep from the beginning
-
-    Returns:
-        VideoFromFile object that owns the output buffer
-    """
-    output_buffer = io.BytesIO()
-
-    input_container = None
-    output_container = None
-
-    try:
-        # Get the stream source - this avoids loading entire video into memory
-        # when the source is already a file path
-        input_source = video.get_stream_source()
-
-        # Open containers
-        input_container = av.open(input_source, mode='r')
-        output_container = av.open(output_buffer, mode='w', format='mp4')
-
-        # Set up output streams for re-encoding
-        video_stream = None
-        audio_stream = None
-
-        for stream in input_container.streams:
-            logging.info(f"Found stream: type={stream.type}, class={type(stream)}")
-            if isinstance(stream, av.VideoStream):
-                # Create output video stream with same parameters
-                video_stream = output_container.add_stream('h264', rate=stream.average_rate)
-                video_stream.width = stream.width
-                video_stream.height = stream.height
-                video_stream.pix_fmt = 'yuv420p'
-                logging.info(f"Added video stream: {stream.width}x{stream.height} @ {stream.average_rate}fps")
-            elif isinstance(stream, av.AudioStream):
-                # Create output audio stream with same parameters
-                audio_stream = output_container.add_stream('aac', rate=stream.sample_rate)
-                audio_stream.sample_rate = stream.sample_rate
-                audio_stream.layout = stream.layout
-                logging.info(f"Added audio stream: {stream.sample_rate}Hz, {stream.channels} channels")
-
-        # Calculate target frame count that's divisible by 32
-        fps = input_container.streams.video[0].average_rate
-        estimated_frames = int(duration_sec * fps)
-        target_frames = (estimated_frames // 32) * 32  # Round down to nearest multiple of 32
-
-        if target_frames == 0:
-            raise ValueError("Video too short: need at least 32 frames for Moonvalley")
-
-        frame_count = 0
-        audio_frame_count = 0
-
-        # Decode and re-encode video frames
-        if video_stream:
-            for frame in input_container.decode(video=0):
-                if frame_count >= target_frames:
-                    break
-
-                # Re-encode frame
-                for packet in video_stream.encode(frame):
-                    output_container.mux(packet)
-                frame_count += 1
-
-            # Flush encoder
-            for packet in video_stream.encode():
-                output_container.mux(packet)
-
-            logging.info(f"Encoded {frame_count} video frames (target: {target_frames})")
-
-        # Decode and re-encode audio frames
-        if audio_stream:
-            input_container.seek(0)  # Reset to beginning for audio
-            for frame in input_container.decode(audio=0):
-                if frame.time >= duration_sec:
-                    break
-
-                # Re-encode frame
-                for packet in audio_stream.encode(frame):
-                    output_container.mux(packet)
-                audio_frame_count += 1
-
-            # Flush encoder
-            for packet in audio_stream.encode():
-                output_container.mux(packet)
-
-            logging.info(f"Encoded {audio_frame_count} audio frames")
-
-        # Close containers
-        output_container.close()
-        input_container.close()
-
-
-        # Return as VideoFromFile using the buffer
-        output_buffer.seek(0)
-        return VideoFromFile(output_buffer)
-
-    except Exception as e:
-        # Clean up on error
-        if input_container is not None:
-            input_container.close()
-        if output_container is not None:
-            output_container.close()
-        raise RuntimeError(f"Failed to trim video: {str(e)}") from e
-
-# --- BaseMoonvalleyVideoNode ---
-class BaseMoonvalleyVideoNode:
-    def parseWidthHeightFromRes(self, resolution: str):
-        # Accepts a string like "16:9 (1920 x 1080)" and returns width, height as a dict
-        res_map = {
-            "16:9 (1920 x 1080)": {"width": 1920, "height": 1080},
-            "9:16 (1080 x 1920)": {"width": 1080, "height": 1920},
-            "1:1 (1152 x 1152)": {"width": 1152, "height": 1152},
-            "4:3 (1440 x 1080)": {"width": 1440, "height": 1080},
-            "3:4 (1080 x 1440)": {"width": 1080, "height": 1440},
-            "21:9 (2560 x 1080)": {"width": 2560, "height": 1080},
-        }
-        if resolution in res_map:
-            return res_map[resolution]
-        else:
-            # Default to 1920x1080 if unknown
-            return {"width": 1920, "height": 1080}
-
-    def parseControlParameter(self, value):
-        control_map = {
-            "Motion Transfer": "motion_control",
-            "Canny": "canny_control",
-            "Pose Transfer": "pose_control",
-            "Depth": "depth_control"
-        }
-        if value in control_map:
-            return control_map[value]
-        else:
-            return control_map["Motion Transfer"]
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> MoonvalleyPromptResponse:
-        return poll_until_finished(
-            auth_kwargs,
-            ApiEndpoint(
-                path=f"{API_PROMPTS_ENDPOINT}/{task_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=MoonvalleyPromptResponse,
-            ),
-            result_url_extractor=get_video_url_from_response,
-            node_id=node_id,
-        )
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "prompt": model_field_to_node_input(
-                    IO.STRING, MoonvalleyTextToVideoRequest, "prompt_text",
-                    multiline=True
-                ),
-                "negative_prompt": model_field_to_node_input(
-                    IO.STRING,
-                    MoonvalleyTextToVideoInferenceParams,
-                    "negative_prompt",
-                    multiline=True,
-                    default="gopro, bright, contrast, static, overexposed, bright, vignette, artifacts, still, noise, texture, scanlines, videogame, 360 camera, VR, transition, flare, saturation, distorted, warped, wide angle, contrast, saturated, vibrant, glowing, cross dissolve, texture, videogame, saturation, cheesy, ugly hands, mutated hands, mutant, disfigured, extra fingers, blown out, horrible, blurry, worst quality, bad, transition, dissolve, cross-dissolve, melt, fade in, fade out, wobbly, weird, low quality, plastic, stock footage, video camera, boring, static",
-                ),
-
-                "resolution": (IO.COMBO, {
-                        "options": ["16:9 (1920 x 1080)",
-                                    "9:16 (1080 x 1920)",
-                                    "1:1 (1152 x 1152)",
-                                    "4:3 (1440 x 1080)",
-                                    "3:4 (1080 x 1440)",
-                                    "21:9 (2560 x 1080)"],
-                        "default": "16:9 (1920 x 1080)",
-                        "tooltip": "Resolution of the output video",
-                    }),
-                # "length": (IO.COMBO,{"options":['5s','10s'], "default": '5s'}),
-                "prompt_adherence": model_field_to_node_input(IO.FLOAT,MoonvalleyTextToVideoInferenceParams,"guidance_scale",default=7.0, step=1, min=1, max=20),
-                "seed": model_field_to_node_input(IO.INT,MoonvalleyTextToVideoInferenceParams, "seed", default=random.randint(0, 2**32 - 1), min=0, max=4294967295, step=1, display="number", tooltip="Random seed value", control_after_generate=True),
-                "steps": model_field_to_node_input(IO.INT, MoonvalleyTextToVideoInferenceParams, "steps", default=100, min=1, max=100),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-            "optional": {
-                "image": model_field_to_node_input(
-                    IO.IMAGE,
-                    MoonvalleyTextToVideoRequest,
-                    "image_url",
-                    tooltip="The reference image used to generate the video",
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("STRING",)
-    FUNCTION = "generate"
-    CATEGORY = "api node/video/Moonvalley Marey"
-    API_NODE = True
-
-    def generate(self, **kwargs):
-        return None
-
-# --- MoonvalleyImg2VideoNode ---
-class MoonvalleyImg2VideoNode(BaseMoonvalleyVideoNode):
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return super().INPUT_TYPES()
-
-    RETURN_TYPES = ("VIDEO",)
-    RETURN_NAMES = ("video",)
-    DESCRIPTION = "Moonvalley Marey Image to Video Node"
-
-    def generate(self, prompt, negative_prompt, unique_id: Optional[str] = None, **kwargs):
-        image = kwargs.get("image", None)
-        if (image is None):
-            raise MoonvalleyApiError("image is required")
-        total_frames = get_total_frames_from_length()
-
-        validate_input_image(image,True)
-        validate_prompts(prompt, negative_prompt, MOONVALLEY_MAREY_MAX_PROMPT_LENGTH)
-        width_height = self.parseWidthHeightFromRes(kwargs.get("resolution"))
-
-        inference_params=MoonvalleyTextToVideoInferenceParams(
-                    negative_prompt=negative_prompt,
-                    steps=kwargs.get("steps"),
-                    seed=kwargs.get("seed"),
-                    guidance_scale=kwargs.get("prompt_adherence"),
-                    num_frames=total_frames,
-                    width=width_height.get("width"),
-                    height=width_height.get("height"),
-                    use_negative_prompts=True
-                )
-        """Upload image to comfy backend to have a URL available for further processing"""
-        # Get MIME type from tensor - assuming PNG format for image tensors
-        mime_type = "image/png"
-
-        image_url = upload_images_to_comfyapi(image, max_images=1, auth_kwargs=kwargs, mime_type=mime_type)[0]
-
-        request = MoonvalleyTextToVideoRequest(
-                image_url=image_url,
-                prompt_text=prompt,
-                inference_params=inference_params
-            )
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(path=API_IMG2VIDEO_ENDPOINT,
-                                 method=HttpMethod.POST,
-                                 request_model=MoonvalleyTextToVideoRequest,
-                                 response_model=MoonvalleyPromptResponse
-                                 ),
-            request=request,
-            auth_kwargs=kwargs,
-        )
-        task_creation_response = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.id
-
-        final_response = self.get_response(
-            task_id, auth_kwargs=kwargs, node_id=unique_id
-        )
-        video = download_url_to_video_output(final_response.output_url)
-        return (video, )
-
-# --- MoonvalleyVid2VidNode ---
-class MoonvalleyVideo2VideoNode(BaseMoonvalleyVideoNode):
-    def __init__(self):
-        super().__init__()
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        input_types = super().INPUT_TYPES()
-        for param in ["resolution", "image"]:
-            if param in input_types["required"]:
-                del input_types["required"][param]
-            if param in input_types["optional"]:
-                del input_types["optional"][param]
-        input_types["optional"] = {
-                "video": (IO.VIDEO, {"default": "", "multiline": False, "tooltip": "The reference video used to generate the output video. Input a 5s video for 128 frames and a 10s video for 256 frames. Longer videos will be trimmed automatically."}),
-                "control_type": (
-                    ["Motion Transfer", "Pose Transfer"],
-                    {"default": "Motion Transfer"},
-                ),
-                "motion_intensity": (
-                    "INT",
-                    {
-                        "default": 100,
-                        "step": 1,
-                        "min": 0,
-                        "max": 100,
-                        "tooltip": "Only used if control_type is 'Motion Transfer'",
-                    },
-                )
-            }
-
-        return input_types
-
-    RETURN_TYPES = ("VIDEO",)
-    RETURN_NAMES = ("video",)
-
-    def generate(self, prompt, negative_prompt, unique_id: Optional[str] = None, **kwargs):
-        video = kwargs.get("video")
-        num_frames = get_total_frames_from_length()
-
-        if not video :
-            raise MoonvalleyApiError("video is required")
-
-
-        """Validate video input"""
-        video_url=""
-        if video:
-            validated_video = validate_input_video(video, num_frames, False)
-            video_url = upload_video_to_comfyapi(validated_video, auth_kwargs=kwargs)
-
-        control_type = kwargs.get("control_type")
-        motion_intensity = kwargs.get("motion_intensity")
-
-        """Validate prompts and inference input"""
-        validate_prompts(prompt, negative_prompt)
-        inference_params=MoonvalleyVideoToVideoInferenceParams(
-            negative_prompt=negative_prompt,
-            steps=kwargs.get("steps"),
-            seed=kwargs.get("seed"),
-            guidance_scale=kwargs.get("prompt_adherence"),
-            control_params={'motion_intensity': motion_intensity}
-        )
-
-        control = self.parseControlParameter(control_type)
-
-        request = MoonvalleyVideoToVideoRequest(
-                control_type=control,
-                video_url=video_url,
-                prompt_text=prompt,
-                inference_params=inference_params
-            )
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(path=API_VIDEO2VIDEO_ENDPOINT,
-                                 method=HttpMethod.POST,
-                                 request_model=MoonvalleyVideoToVideoRequest,
-                                 response_model=MoonvalleyPromptResponse
-                                 ),
-            request=request,
-            auth_kwargs=kwargs,
-        )
-        task_creation_response = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.id
-
-        final_response = self.get_response(
-            task_id, auth_kwargs=kwargs, node_id=unique_id
-        )
-
-        video = download_url_to_video_output(final_response.output_url)
-
-        return (video, )
-
-# --- MoonvalleyTxt2VideoNode ---
-class MoonvalleyTxt2VideoNode(BaseMoonvalleyVideoNode):
-    def __init__(self):
-        super().__init__()
-
-    RETURN_TYPES = ("VIDEO",)
-    RETURN_NAMES = ("video",)
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        input_types = super().INPUT_TYPES()
-        # Remove image-specific parameters
-        for param in ["image"]:
-            if param in input_types["optional"]:
-                del input_types["optional"][param]
-        return input_types
-
-    def generate(self, prompt, negative_prompt, unique_id: Optional[str] = None, **kwargs):
-        validate_prompts(prompt, negative_prompt, MOONVALLEY_MAREY_MAX_PROMPT_LENGTH)
-        width_height = self.parseWidthHeightFromRes(kwargs.get("resolution"))
-        num_frames = get_total_frames_from_length()
-
-        inference_params=MoonvalleyTextToVideoInferenceParams(
-                    negative_prompt=negative_prompt,
-                    steps=kwargs.get("steps"),
-                    seed=kwargs.get("seed"),
-                    guidance_scale=kwargs.get("prompt_adherence"),
-                    num_frames=num_frames,
-                    width=width_height.get("width"),
-                    height=width_height.get("height"),
-                )
-        request = MoonvalleyTextToVideoRequest(
-                prompt_text=prompt,
-                inference_params=inference_params
-            )
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(path=API_TXT2VIDEO_ENDPOINT,
-                                 method=HttpMethod.POST,
-                                 request_model=MoonvalleyTextToVideoRequest,
-                                 response_model=MoonvalleyPromptResponse
-                                 ),
-            request=request,
-            auth_kwargs=kwargs,
-        )
-        task_creation_response = initial_operation.execute()
-        validate_task_creation_response(task_creation_response)
-        task_id = task_creation_response.id
-
-        final_response = self.get_response(
-            task_id, auth_kwargs=kwargs, node_id=unique_id
-        )
-
-        video = download_url_to_video_output(final_response.output_url)
-        return (video, )
-
-
-
-NODE_CLASS_MAPPINGS = {
-    "MoonvalleyImg2VideoNode": MoonvalleyImg2VideoNode,
-    "MoonvalleyTxt2VideoNode": MoonvalleyTxt2VideoNode,
-    # "MoonvalleyVideo2VideoNode": MoonvalleyVideo2VideoNode,
-}
-
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "MoonvalleyImg2VideoNode": "Moonvalley Marey Image to Video",
-    "MoonvalleyTxt2VideoNode": "Moonvalley Marey Text to Video",
-    # "MoonvalleyVideo2VideoNode": "Moonvalley Marey Video to Video",
-}
-
-def get_total_frames_from_length(length="5s"):
-    # if length == '5s':
-    #     return 128
-    # elif length == '10s':
-    #     return 256
-    return 128
-    # else:
-    #     raise MoonvalleyApiError("length is required")

comfy_api_nodes/nodes_openai.py

@@ -1,1008 +0,0 @@
-import io
-from typing import TypedDict, Optional
-import json
-import os
-import time
-import re
-import uuid
-from enum import Enum
-from inspect import cleandoc
-import numpy as np
-import torch
-from PIL import Image
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC, InputTypeDict
-from server import PromptServer
-import folder_paths
-
-
-from comfy_api_nodes.apis import (
-    OpenAIImageGenerationRequest,
-    OpenAIImageEditRequest,
-    OpenAIImageGenerationResponse,
-    OpenAICreateResponse,
-    OpenAIResponse,
-    CreateModelResponseProperties,
-    Item,
-    Includable,
-    OutputContent,
-    InputImageContent,
-    Detail,
-    InputTextContent,
-    InputMessage,
-    InputMessageContentList,
-    InputContent,
-    InputFileContent,
-)
-
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-
-from comfy_api_nodes.apinode_utils import (
-    downscale_image_tensor,
-    validate_and_cast_response,
-    validate_string,
-    tensor_to_base64_string,
-    text_filepath_to_data_uri,
-)
-from comfy_api_nodes.mapper_utils import model_field_to_node_input
-
-
-RESPONSES_ENDPOINT = "/proxy/openai/v1/responses"
-STARTING_POINT_ID_PATTERN = r"<starting_point_id:(.*)>"
-
-
-class HistoryEntry(TypedDict):
-    """Type definition for a single history entry in the chat."""
-
-    prompt: str
-    response: str
-    response_id: str
-    timestamp: float
-
-
-class ChatHistory(TypedDict):
-    """Type definition for the chat history dictionary."""
-
-    __annotations__: dict[str, list[HistoryEntry]]
-
-
-class SupportedOpenAIModel(str, Enum):
-    o4_mini = "o4-mini"
-    o1 = "o1"
-    o3 = "o3"
-    o1_pro = "o1-pro"
-    gpt_4o = "gpt-4o"
-    gpt_4_1 = "gpt-4.1"
-    gpt_4_1_mini = "gpt-4.1-mini"
-    gpt_4_1_nano = "gpt-4.1-nano"
-
-
-class OpenAIDalle2(ComfyNodeABC):
-    """
-    Generates images synchronously via OpenAI's DALL·E 2 endpoint.
-    """
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text prompt for DALL·E",
-                    },
-                ),
-            },
-            "optional": {
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2**31 - 1,
-                        "step": 1,
-                        "display": "number",
-                        "control_after_generate": True,
-                        "tooltip": "not implemented yet in backend",
-                    },
-                ),
-                "size": (
-                    IO.COMBO,
-                    {
-                        "options": ["256x256", "512x512", "1024x1024"],
-                        "default": "1024x1024",
-                        "tooltip": "Image size",
-                    },
-                ),
-                "n": (
-                    IO.INT,
-                    {
-                        "default": 1,
-                        "min": 1,
-                        "max": 8,
-                        "step": 1,
-                        "display": "number",
-                        "tooltip": "How many images to generate",
-                    },
-                ),
-                "image": (
-                    IO.IMAGE,
-                    {
-                        "default": None,
-                        "tooltip": "Optional reference image for image editing.",
-                    },
-                ),
-                "mask": (
-                    IO.MASK,
-                    {
-                        "default": None,
-                        "tooltip": "Optional mask for inpainting (white areas will be replaced)",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/image/OpenAI"
-    DESCRIPTION = cleandoc(__doc__ or "")
-    API_NODE = True
-
-    def api_call(
-        self,
-        prompt,
-        seed=0,
-        image=None,
-        mask=None,
-        n=1,
-        size="1024x1024",
-        unique_id=None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False)
-        model = "dall-e-2"
-        path = "/proxy/openai/images/generations"
-        content_type = "application/json"
-        request_class = OpenAIImageGenerationRequest
-        img_binary = None
-
-        if image is not None and mask is not None:
-            path = "/proxy/openai/images/edits"
-            content_type = "multipart/form-data"
-            request_class = OpenAIImageEditRequest
-
-            input_tensor = image.squeeze().cpu()
-            height, width, channels = input_tensor.shape
-            rgba_tensor = torch.ones(height, width, 4, device="cpu")
-            rgba_tensor[:, :, :channels] = input_tensor
-
-            if mask.shape[1:] != image.shape[1:-1]:
-                raise Exception("Mask and Image must be the same size")
-            rgba_tensor[:, :, 3] = 1 - mask.squeeze().cpu()
-
-            rgba_tensor = downscale_image_tensor(rgba_tensor.unsqueeze(0)).squeeze()
-
-            image_np = (rgba_tensor.numpy() * 255).astype(np.uint8)
-            img = Image.fromarray(image_np)
-            img_byte_arr = io.BytesIO()
-            img.save(img_byte_arr, format="PNG")
-            img_byte_arr.seek(0)
-            img_binary = img_byte_arr  # .getvalue()
-            img_binary.name = "image.png"
-        elif image is not None or mask is not None:
-            raise Exception("Dall-E 2 image editing requires an image AND a mask")
-
-        # Build the operation
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=path,
-                method=HttpMethod.POST,
-                request_model=request_class,
-                response_model=OpenAIImageGenerationResponse,
-            ),
-            request=request_class(
-                model=model,
-                prompt=prompt,
-                n=n,
-                size=size,
-                seed=seed,
-            ),
-            files=(
-                {
-                    "image": img_binary,
-                }
-                if img_binary
-                else None
-            ),
-            content_type=content_type,
-            auth_kwargs=kwargs,
-        )
-
-        response = operation.execute()
-
-        img_tensor = validate_and_cast_response(response, node_id=unique_id)
-        return (img_tensor,)
-
-
-class OpenAIDalle3(ComfyNodeABC):
-    """
-    Generates images synchronously via OpenAI's DALL·E 3 endpoint.
-    """
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text prompt for DALL·E",
-                    },
-                ),
-            },
-            "optional": {
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2**31 - 1,
-                        "step": 1,
-                        "display": "number",
-                        "control_after_generate": True,
-                        "tooltip": "not implemented yet in backend",
-                    },
-                ),
-                "quality": (
-                    IO.COMBO,
-                    {
-                        "options": ["standard", "hd"],
-                        "default": "standard",
-                        "tooltip": "Image quality",
-                    },
-                ),
-                "style": (
-                    IO.COMBO,
-                    {
-                        "options": ["natural", "vivid"],
-                        "default": "natural",
-                        "tooltip": "Vivid causes the model to lean towards generating hyper-real and dramatic images. Natural causes the model to produce more natural, less hyper-real looking images.",
-                    },
-                ),
-                "size": (
-                    IO.COMBO,
-                    {
-                        "options": ["1024x1024", "1024x1792", "1792x1024"],
-                        "default": "1024x1024",
-                        "tooltip": "Image size",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/image/OpenAI"
-    DESCRIPTION = cleandoc(__doc__ or "")
-    API_NODE = True
-
-    def api_call(
-        self,
-        prompt,
-        seed=0,
-        style="natural",
-        quality="standard",
-        size="1024x1024",
-        unique_id=None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False)
-        model = "dall-e-3"
-
-        # build the operation
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/openai/images/generations",
-                method=HttpMethod.POST,
-                request_model=OpenAIImageGenerationRequest,
-                response_model=OpenAIImageGenerationResponse,
-            ),
-            request=OpenAIImageGenerationRequest(
-                model=model,
-                prompt=prompt,
-                quality=quality,
-                size=size,
-                style=style,
-                seed=seed,
-            ),
-            auth_kwargs=kwargs,
-        )
-
-        response = operation.execute()
-
-        img_tensor = validate_and_cast_response(response, node_id=unique_id)
-        return (img_tensor,)
-
-
-class OpenAIGPTImage1(ComfyNodeABC):
-    """
-    Generates images synchronously via OpenAI's GPT Image 1 endpoint.
-    """
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text prompt for GPT Image 1",
-                    },
-                ),
-            },
-            "optional": {
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2**31 - 1,
-                        "step": 1,
-                        "display": "number",
-                        "control_after_generate": True,
-                        "tooltip": "not implemented yet in backend",
-                    },
-                ),
-                "quality": (
-                    IO.COMBO,
-                    {
-                        "options": ["low", "medium", "high"],
-                        "default": "low",
-                        "tooltip": "Image quality, affects cost and generation time.",
-                    },
-                ),
-                "background": (
-                    IO.COMBO,
-                    {
-                        "options": ["opaque", "transparent"],
-                        "default": "opaque",
-                        "tooltip": "Return image with or without background",
-                    },
-                ),
-                "size": (
-                    IO.COMBO,
-                    {
-                        "options": ["auto", "1024x1024", "1024x1536", "1536x1024"],
-                        "default": "auto",
-                        "tooltip": "Image size",
-                    },
-                ),
-                "n": (
-                    IO.INT,
-                    {
-                        "default": 1,
-                        "min": 1,
-                        "max": 8,
-                        "step": 1,
-                        "display": "number",
-                        "tooltip": "How many images to generate",
-                    },
-                ),
-                "image": (
-                    IO.IMAGE,
-                    {
-                        "default": None,
-                        "tooltip": "Optional reference image for image editing.",
-                    },
-                ),
-                "mask": (
-                    IO.MASK,
-                    {
-                        "default": None,
-                        "tooltip": "Optional mask for inpainting (white areas will be replaced)",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.IMAGE,)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/image/OpenAI"
-    DESCRIPTION = cleandoc(__doc__ or "")
-    API_NODE = True
-
-    def api_call(
-        self,
-        prompt,
-        seed=0,
-        quality="low",
-        background="opaque",
-        image=None,
-        mask=None,
-        n=1,
-        size="1024x1024",
-        unique_id=None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False)
-        model = "gpt-image-1"
-        path = "/proxy/openai/images/generations"
-        content_type = "application/json"
-        request_class = OpenAIImageGenerationRequest
-        img_binaries = []
-        mask_binary = None
-        files = []
-
-        if image is not None:
-            path = "/proxy/openai/images/edits"
-            request_class = OpenAIImageEditRequest
-            content_type = "multipart/form-data"
-
-            batch_size = image.shape[0]
-
-            for i in range(batch_size):
-                single_image = image[i : i + 1]
-                scaled_image = downscale_image_tensor(single_image).squeeze()
-
-                image_np = (scaled_image.numpy() * 255).astype(np.uint8)
-                img = Image.fromarray(image_np)
-                img_byte_arr = io.BytesIO()
-                img.save(img_byte_arr, format="PNG")
-                img_byte_arr.seek(0)
-                img_binary = img_byte_arr
-                img_binary.name = f"image_{i}.png"
-
-                img_binaries.append(img_binary)
-                if batch_size == 1:
-                    files.append(("image", img_binary))
-                else:
-                    files.append(("image[]", img_binary))
-
-        if mask is not None:
-            if image is None:
-                raise Exception("Cannot use a mask without an input image")
-            if image.shape[0] != 1:
-                raise Exception("Cannot use a mask with multiple image")
-            if mask.shape[1:] != image.shape[1:-1]:
-                raise Exception("Mask and Image must be the same size")
-            batch, height, width = mask.shape
-            rgba_mask = torch.zeros(height, width, 4, device="cpu")
-            rgba_mask[:, :, 3] = 1 - mask.squeeze().cpu()
-
-            scaled_mask = downscale_image_tensor(rgba_mask.unsqueeze(0)).squeeze()
-
-            mask_np = (scaled_mask.numpy() * 255).astype(np.uint8)
-            mask_img = Image.fromarray(mask_np)
-            mask_img_byte_arr = io.BytesIO()
-            mask_img.save(mask_img_byte_arr, format="PNG")
-            mask_img_byte_arr.seek(0)
-            mask_binary = mask_img_byte_arr
-            mask_binary.name = "mask.png"
-            files.append(("mask", mask_binary))
-
-        # Build the operation
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=path,
-                method=HttpMethod.POST,
-                request_model=request_class,
-                response_model=OpenAIImageGenerationResponse,
-            ),
-            request=request_class(
-                model=model,
-                prompt=prompt,
-                quality=quality,
-                background=background,
-                n=n,
-                seed=seed,
-                size=size,
-            ),
-            files=files if files else None,
-            content_type=content_type,
-            auth_kwargs=kwargs,
-        )
-
-        response = operation.execute()
-
-        img_tensor = validate_and_cast_response(response, node_id=unique_id)
-        return (img_tensor,)
-
-
-class OpenAITextNode(ComfyNodeABC):
-    """
-    Base class for OpenAI text generation nodes.
-    """
-
-    RETURN_TYPES = (IO.STRING,)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/text/OpenAI"
-    API_NODE = True
-
-
-class OpenAIChatNode(OpenAITextNode):
-    """
-    Node to generate text responses from an OpenAI model.
-    """
-
-    def __init__(self) -> None:
-        """Initialize the chat node with a new session ID and empty history."""
-        self.current_session_id: str = str(uuid.uuid4())
-        self.history: dict[str, list[HistoryEntry]] = {}
-        self.previous_response_id: Optional[str] = None
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text inputs to the model, used to generate a response.",
-                    },
-                ),
-                "persist_context": (
-                    IO.BOOLEAN,
-                    {
-                        "default": True,
-                        "tooltip": "Persist chat context between calls (multi-turn conversation)",
-                    },
-                ),
-                "model": model_field_to_node_input(
-                    IO.COMBO,
-                    OpenAICreateResponse,
-                    "model",
-                    enum_type=SupportedOpenAIModel,
-                ),
-            },
-            "optional": {
-                "images": (
-                    IO.IMAGE,
-                    {
-                        "default": None,
-                        "tooltip": "Optional image(s) to use as context for the model. To include multiple images, you can use the Batch Images node.",
-                    },
-                ),
-                "files": (
-                    "OPENAI_INPUT_FILES",
-                    {
-                        "default": None,
-                        "tooltip": "Optional file(s) to use as context for the model. Accepts inputs from the OpenAI Chat Input Files node.",
-                    },
-                ),
-                "advanced_options": (
-                    "OPENAI_CHAT_CONFIG",
-                    {
-                        "default": None,
-                        "tooltip": "Optional configuration for the model. Accepts inputs from the OpenAI Chat Advanced Options node.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Generate text responses from an OpenAI model."
-
-    def get_result_response(
-        self,
-        response_id: str,
-        include: Optional[list[Includable]] = None,
-        auth_kwargs: Optional[dict[str, str]] = None,
-    ) -> OpenAIResponse:
-        """
-        Retrieve a model response with the given ID from the OpenAI API.
-
-        Args:
-            response_id (str): The ID of the response to retrieve.
-            include (Optional[List[Includable]]): Additional fields to include
-                in the response. See the `include` parameter for Response
-                creation above for more information.
-
-        """
-        return PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"{RESPONSES_ENDPOINT}/{response_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=OpenAIResponse,
-                query_params={"include": include},
-            ),
-            completed_statuses=["completed"],
-            failed_statuses=["failed"],
-            status_extractor=lambda response: response.status,
-            auth_kwargs=auth_kwargs,
-        ).execute()
-
-    def get_message_content_from_response(
-        self, response: OpenAIResponse
-    ) -> list[OutputContent]:
-        """Extract message content from the API response."""
-        for output in response.output:
-            if output.root.type == "message":
-                return output.root.content
-        raise TypeError("No output message found in response")
-
-    def get_text_from_message_content(
-        self, message_content: list[OutputContent]
-    ) -> str:
-        """Extract text content from message content."""
-        for content_item in message_content:
-            if content_item.root.type == "output_text":
-                return str(content_item.root.text)
-        return "No text output found in response"
-
-    def get_history_text(self, session_id: str) -> str:
-        """Convert the entire history for a given session to JSON string."""
-        return json.dumps(self.history[session_id])
-
-    def display_history_on_node(self, session_id: str, node_id: str) -> None:
-        """Display formatted chat history on the node UI."""
-        render_spec = {
-            "node_id": node_id,
-            "component": "ChatHistoryWidget",
-            "props": {
-                "history": self.get_history_text(session_id),
-            },
-        }
-        PromptServer.instance.send_sync(
-            "display_component",
-            render_spec,
-        )
-
-    def add_to_history(
-        self, session_id: str, prompt: str, output_text: str, response_id: str
-    ) -> None:
-        """Add a new entry to the chat history."""
-        if session_id not in self.history:
-            self.history[session_id] = []
-        self.history[session_id].append(
-            {
-                "prompt": prompt,
-                "response": output_text,
-                "response_id": response_id,
-                "timestamp": time.time(),
-            }
-        )
-
-    def parse_output_text_from_response(self, response: OpenAIResponse) -> str:
-        """Extract text output from the API response."""
-        message_contents = self.get_message_content_from_response(response)
-        return self.get_text_from_message_content(message_contents)
-
-    def generate_new_session_id(self) -> str:
-        """Generate a new unique session ID."""
-        return str(uuid.uuid4())
-
-    def get_session_id(self, persist_context: bool) -> str:
-        """Get the current or generate a new session ID based on context persistence."""
-        return (
-            self.current_session_id
-            if persist_context
-            else self.generate_new_session_id()
-        )
-
-    def tensor_to_input_image_content(
-        self, image: torch.Tensor, detail_level: Detail = "auto"
-    ) -> InputImageContent:
-        """Convert a tensor to an input image content object."""
-        return InputImageContent(
-            detail=detail_level,
-            image_url=f"data:image/png;base64,{tensor_to_base64_string(image)}",
-            type="input_image",
-        )
-
-    def create_input_message_contents(
-        self,
-        prompt: str,
-        image: Optional[torch.Tensor] = None,
-        files: Optional[list[InputFileContent]] = None,
-    ) -> InputMessageContentList:
-        """Create a list of input message contents from prompt and optional image."""
-        content_list: list[InputContent] = [
-            InputTextContent(text=prompt, type="input_text"),
-        ]
-        if image is not None:
-            for i in range(image.shape[0]):
-                content_list.append(
-                    self.tensor_to_input_image_content(image[i].unsqueeze(0))
-                )
-        if files is not None:
-            content_list.extend(files)
-
-        return InputMessageContentList(
-            root=content_list,
-        )
-
-    def parse_response_id_from_prompt(self, prompt: str) -> Optional[str]:
-        """Extract response ID from prompt if it exists."""
-        parsed_id = re.search(STARTING_POINT_ID_PATTERN, prompt)
-        return parsed_id.group(1) if parsed_id else None
-
-    def strip_response_tag_from_prompt(self, prompt: str) -> str:
-        """Remove the response ID tag from the prompt."""
-        return re.sub(STARTING_POINT_ID_PATTERN, "", prompt.strip())
-
-    def delete_history_after_response_id(
-        self, new_start_id: str, session_id: str
-    ) -> None:
-        """Delete history entries after a specific response ID."""
-        if session_id not in self.history:
-            return
-
-        new_history = []
-        i = 0
-        while (
-            i < len(self.history[session_id])
-            and self.history[session_id][i]["response_id"] != new_start_id
-        ):
-            new_history.append(self.history[session_id][i])
-            i += 1
-
-        # Since it's the new starting point (not the response being edited), we include it as well
-        if i < len(self.history[session_id]):
-            new_history.append(self.history[session_id][i])
-
-        self.history[session_id] = new_history
-
-    def api_call(
-        self,
-        prompt: str,
-        persist_context: bool,
-        model: SupportedOpenAIModel,
-        unique_id: Optional[str] = None,
-        images: Optional[torch.Tensor] = None,
-        files: Optional[list[InputFileContent]] = None,
-        advanced_options: Optional[CreateModelResponseProperties] = None,
-        **kwargs,
-    ) -> tuple[str]:
-        # Validate inputs
-        validate_string(prompt, strip_whitespace=False)
-
-        session_id = self.get_session_id(persist_context)
-        response_id_override = self.parse_response_id_from_prompt(prompt)
-        if response_id_override:
-            is_starting_from_beginning = response_id_override == "start"
-            if is_starting_from_beginning:
-                self.history[session_id] = []
-                previous_response_id = None
-            else:
-                previous_response_id = response_id_override
-                self.delete_history_after_response_id(response_id_override, session_id)
-            prompt = self.strip_response_tag_from_prompt(prompt)
-        elif persist_context:
-            previous_response_id = self.previous_response_id
-        else:
-            previous_response_id = None
-
-        # Create response
-        create_response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=RESPONSES_ENDPOINT,
-                method=HttpMethod.POST,
-                request_model=OpenAICreateResponse,
-                response_model=OpenAIResponse,
-            ),
-            request=OpenAICreateResponse(
-                input=[
-                    Item(
-                        root=InputMessage(
-                            content=self.create_input_message_contents(
-                                prompt, images, files
-                            ),
-                            role="user",
-                        )
-                    ),
-                ],
-                store=True,
-                stream=False,
-                model=model,
-                previous_response_id=previous_response_id,
-                **(
-                    advanced_options.model_dump(exclude_none=True)
-                    if advanced_options
-                    else {}
-                ),
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        response_id = create_response.id
-
-        # Get result output
-        result_response = self.get_result_response(response_id, auth_kwargs=kwargs)
-        output_text = self.parse_output_text_from_response(result_response)
-
-        # Update history
-        self.add_to_history(session_id, prompt, output_text, response_id)
-        self.display_history_on_node(session_id, unique_id)
-        self.previous_response_id = response_id
-
-        return (output_text,)
-
-
-class OpenAIInputFiles(ComfyNodeABC):
-    """
-    Loads and formats input files for OpenAI API.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        """
-        For details about the supported file input types, see:
-        https://platform.openai.com/docs/guides/pdf-files?api-mode=responses
-        """
-        input_dir = folder_paths.get_input_directory()
-        input_files = [
-            f
-            for f in os.scandir(input_dir)
-            if f.is_file()
-            and (f.name.endswith(".txt") or f.name.endswith(".pdf"))
-            and f.stat().st_size < 32 * 1024 * 1024
-        ]
-        input_files = sorted(input_files, key=lambda x: x.name)
-        input_files = [f.name for f in input_files]
-        return {
-            "required": {
-                "file": (
-                    IO.COMBO,
-                    {
-                        "tooltip": "Input files to include as context for the model. Only accepts text (.txt) and PDF (.pdf) files for now.",
-                        "options": input_files,
-                        "default": input_files[0] if input_files else None,
-                    },
-                ),
-            },
-            "optional": {
-                "OPENAI_INPUT_FILES": (
-                    "OPENAI_INPUT_FILES",
-                    {
-                        "tooltip": "An optional additional file(s) to batch together with the file loaded from this node. Allows chaining of input files so that a single message can include multiple input files.",
-                        "default": None,
-                    },
-                ),
-            },
-        }
-
-    DESCRIPTION = "Loads and prepares input files (text, pdf, etc.) to include as inputs for the OpenAI Chat Node. The files will be read by the OpenAI model when generating a response. 🛈 TIP: Can be chained together with other OpenAI Input File nodes."
-    RETURN_TYPES = ("OPENAI_INPUT_FILES",)
-    FUNCTION = "prepare_files"
-    CATEGORY = "api node/text/OpenAI"
-
-    def create_input_file_content(self, file_path: str) -> InputFileContent:
-        return InputFileContent(
-            file_data=text_filepath_to_data_uri(file_path),
-            filename=os.path.basename(file_path),
-            type="input_file",
-        )
-
-    def prepare_files(
-        self, file: str, OPENAI_INPUT_FILES: list[InputFileContent] = []
-    ) -> tuple[list[InputFileContent]]:
-        """
-        Loads and formats input files for OpenAI API.
-        """
-        file_path = folder_paths.get_annotated_filepath(file)
-        input_file_content = self.create_input_file_content(file_path)
-        files = [input_file_content] + OPENAI_INPUT_FILES
-        return (files,)
-
-
-class OpenAIChatConfig(ComfyNodeABC):
-    """Allows setting additional configuration for the OpenAI Chat Node."""
-
-    RETURN_TYPES = ("OPENAI_CHAT_CONFIG",)
-    FUNCTION = "configure"
-    DESCRIPTION = (
-        "Allows specifying advanced configuration options for the OpenAI Chat Nodes."
-    )
-    CATEGORY = "api node/text/OpenAI"
-
-    @classmethod
-    def INPUT_TYPES(cls) -> InputTypeDict:
-        return {
-            "required": {
-                "truncation": (
-                    IO.COMBO,
-                    {
-                        "options": ["auto", "disabled"],
-                        "default": "auto",
-                        "tooltip": "The truncation strategy to use for the model response. auto: If the context of this response and previous ones exceeds the model's context window size, the model will truncate the response to fit the context window by dropping input items in the middle of the conversation.disabled: If a model response will exceed the context window size for a model, the request will fail with a 400 error",
-                    },
-                ),
-            },
-            "optional": {
-                "max_output_tokens": model_field_to_node_input(
-                    IO.INT,
-                    OpenAICreateResponse,
-                    "max_output_tokens",
-                    min=16,
-                    default=4096,
-                    max=16384,
-                    tooltip="An upper bound for the number of tokens that can be generated for a response, including visible output tokens",
-                ),
-                "instructions": model_field_to_node_input(
-                    IO.STRING, OpenAICreateResponse, "instructions", multiline=True
-                ),
-            },
-        }
-
-    def configure(
-        self,
-        truncation: bool,
-        instructions: Optional[str] = None,
-        max_output_tokens: Optional[int] = None,
-    ) -> tuple[CreateModelResponseProperties]:
-        """
-        Configure advanced options for the OpenAI Chat Node.
-
-        Note:
-            While `top_p` and `temperature` are listed as properties in the
-            spec, they are not supported for all models (e.g., o4-mini).
-            They are not exposed as inputs at all to avoid having to manually
-            remove depending on model choice.
-        """
-        return (
-            CreateModelResponseProperties(
-                instructions=instructions,
-                truncation=truncation,
-                max_output_tokens=max_output_tokens,
-            ),
-        )
-
-
-NODE_CLASS_MAPPINGS = {
-    "OpenAIDalle2": OpenAIDalle2,
-    "OpenAIDalle3": OpenAIDalle3,
-    "OpenAIGPTImage1": OpenAIGPTImage1,
-    "OpenAIChatNode": OpenAIChatNode,
-    "OpenAIInputFiles": OpenAIInputFiles,
-    "OpenAIChatConfig": OpenAIChatConfig,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "OpenAIDalle2": "OpenAI DALL·E 2",
-    "OpenAIDalle3": "OpenAI DALL·E 3",
-    "OpenAIGPTImage1": "OpenAI GPT Image 1",
-    "OpenAIChatNode": "OpenAI Chat",
-    "OpenAIInputFiles": "OpenAI Chat Input Files",
-    "OpenAIChatConfig": "OpenAI Chat Advanced Options",
-}

comfy_api_nodes/nodes_pika.py

@@ -1,782 +0,0 @@
-"""
-Pika x ComfyUI API Nodes
-
-Pika API docs: https://pika-827374fb.mintlify.app/api-reference
-"""
-from __future__ import annotations
-
-import io
-import logging
-from typing import Optional, TypeVar
-
-import numpy as np
-import torch
-
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC, InputTypeOptions
-from comfy_api.input_impl import VideoFromFile
-from comfy_api.input_impl.video_types import VideoCodec, VideoContainer, VideoInput
-from comfy_api_nodes.apinode_utils import (
-    download_url_to_video_output,
-    tensor_to_bytesio,
-)
-from comfy_api_nodes.apis import (
-    IngredientsMode,
-    PikaBodyGenerate22C2vGenerate22PikascenesPost,
-    PikaBodyGenerate22I2vGenerate22I2vPost,
-    PikaBodyGenerate22KeyframeGenerate22PikaframesPost,
-    PikaBodyGenerate22T2vGenerate22T2vPost,
-    PikaBodyGeneratePikadditionsGeneratePikadditionsPost,
-    PikaBodyGeneratePikaffectsGeneratePikaffectsPost,
-    PikaBodyGeneratePikaswapsGeneratePikaswapsPost,
-    PikaDurationEnum,
-    Pikaffect,
-    PikaGenerateResponse,
-    PikaResolutionEnum,
-    PikaVideoResponse,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    EmptyRequest,
-    HttpMethod,
-    PollingOperation,
-    SynchronousOperation,
-)
-from comfy_api_nodes.mapper_utils import model_field_to_node_input
-
-R = TypeVar("R")
-
-PATH_PIKADDITIONS = "/proxy/pika/generate/pikadditions"
-PATH_PIKASWAPS = "/proxy/pika/generate/pikaswaps"
-PATH_PIKAFFECTS = "/proxy/pika/generate/pikaffects"
-
-PIKA_API_VERSION = "2.2"
-PATH_TEXT_TO_VIDEO = f"/proxy/pika/generate/{PIKA_API_VERSION}/t2v"
-PATH_IMAGE_TO_VIDEO = f"/proxy/pika/generate/{PIKA_API_VERSION}/i2v"
-PATH_PIKAFRAMES = f"/proxy/pika/generate/{PIKA_API_VERSION}/pikaframes"
-PATH_PIKASCENES = f"/proxy/pika/generate/{PIKA_API_VERSION}/pikascenes"
-
-PATH_VIDEO_GET = "/proxy/pika/videos"
-
-
-class PikaApiError(Exception):
-    """Exception for Pika API errors."""
-
-    pass
-
-
-def is_valid_video_response(response: PikaVideoResponse) -> bool:
-    """Check if the video response is valid."""
-    return hasattr(response, "url") and response.url is not None
-
-
-def is_valid_initial_response(response: PikaGenerateResponse) -> bool:
-    """Check if the initial response is valid."""
-    return hasattr(response, "video_id") and response.video_id is not None
-
-
-class PikaNodeBase(ComfyNodeABC):
-    """Base class for Pika nodes."""
-
-    @classmethod
-    def get_base_inputs_types(
-        cls, request_model
-    ) -> dict[str, tuple[IO, InputTypeOptions]]:
-        """Get the base required inputs types common to all Pika nodes."""
-        return {
-            "prompt_text": model_field_to_node_input(
-                IO.STRING,
-                request_model,
-                "promptText",
-                multiline=True,
-            ),
-            "negative_prompt": model_field_to_node_input(
-                IO.STRING,
-                request_model,
-                "negativePrompt",
-                multiline=True,
-            ),
-            "seed": model_field_to_node_input(
-                IO.INT,
-                request_model,
-                "seed",
-                min=0,
-                max=0xFFFFFFFF,
-                control_after_generate=True,
-            ),
-            "resolution": model_field_to_node_input(
-                IO.COMBO,
-                request_model,
-                "resolution",
-                enum_type=PikaResolutionEnum,
-            ),
-            "duration": model_field_to_node_input(
-                IO.COMBO,
-                request_model,
-                "duration",
-                enum_type=PikaDurationEnum,
-            ),
-        }
-
-    CATEGORY = "api node/video/Pika"
-    API_NODE = True
-    FUNCTION = "api_call"
-    RETURN_TYPES = ("VIDEO",)
-
-    def poll_for_task_status(
-        self,
-        task_id: str,
-        auth_kwargs: Optional[dict[str, str]] = None,
-        node_id: Optional[str] = None,
-    ) -> PikaGenerateResponse:
-        polling_operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"{PATH_VIDEO_GET}/{task_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=PikaVideoResponse,
-            ),
-            completed_statuses=[
-                "finished",
-            ],
-            failed_statuses=["failed", "cancelled"],
-            status_extractor=lambda response: (
-                response.status.value if response.status else None
-            ),
-            progress_extractor=lambda response: (
-                response.progress if hasattr(response, "progress") else None
-            ),
-            auth_kwargs=auth_kwargs,
-            result_url_extractor=lambda response: (
-                response.url if hasattr(response, "url") else None
-            ),
-            node_id=node_id,
-            estimated_duration=60
-        )
-        return polling_operation.execute()
-
-    def execute_task(
-        self,
-        initial_operation: SynchronousOperation[R, PikaGenerateResponse],
-        auth_kwargs: Optional[dict[str, str]] = None,
-        node_id: Optional[str] = None,
-    ) -> tuple[VideoFromFile]:
-        """Executes the initial operation then polls for the task status until it is completed.
-
-        Args:
-            initial_operation: The initial operation to execute.
-            auth_kwargs: The authentication token(s) to use for the API call.
-
-        Returns:
-            A tuple containing the video file as a VIDEO output.
-        """
-        initial_response = initial_operation.execute()
-        if not is_valid_initial_response(initial_response):
-            error_msg = f"Pika initial request failed. Code: {initial_response.code}, Message: {initial_response.message}, Data: {initial_response.data}"
-            logging.error(error_msg)
-            raise PikaApiError(error_msg)
-
-        task_id = initial_response.video_id
-        final_response = self.poll_for_task_status(task_id, auth_kwargs)
-        if not is_valid_video_response(final_response):
-            error_msg = (
-                f"Pika task {task_id} succeeded but no video data found in response."
-            )
-            logging.error(error_msg)
-            raise PikaApiError(error_msg)
-
-        video_url = str(final_response.url)
-        logging.info("Pika task %s succeeded. Video URL: %s", task_id, video_url)
-
-        return (download_url_to_video_output(video_url),)
-
-
-class PikaImageToVideoV2_2(PikaNodeBase):
-    """Pika 2.2 Image to Video Node."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": (
-                    IO.IMAGE,
-                    {"tooltip": "The image to convert to video"},
-                ),
-                **cls.get_base_inputs_types(PikaBodyGenerate22I2vGenerate22I2vPost),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Sends an image and prompt to the Pika API v2.2 to generate a video."
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        prompt_text: str,
-        negative_prompt: str,
-        seed: int,
-        resolution: str,
-        duration: int,
-        unique_id: str,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-        # Convert image to BytesIO
-        image_bytes_io = tensor_to_bytesio(image)
-        image_bytes_io.seek(0)
-
-        pika_files = {"image": ("image.png", image_bytes_io, "image/png")}
-
-        # Prepare non-file data
-        pika_request_data = PikaBodyGenerate22I2vGenerate22I2vPost(
-            promptText=prompt_text,
-            negativePrompt=negative_prompt,
-            seed=seed,
-            resolution=resolution,
-            duration=duration,
-        )
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_IMAGE_TO_VIDEO,
-                method=HttpMethod.POST,
-                request_model=PikaBodyGenerate22I2vGenerate22I2vPost,
-                response_model=PikaGenerateResponse,
-            ),
-            request=pika_request_data,
-            files=pika_files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-
-        return self.execute_task(initial_operation, auth_kwargs=kwargs, node_id=unique_id)
-
-
-class PikaTextToVideoNodeV2_2(PikaNodeBase):
-    """Pika Text2Video v2.2 Node."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                **cls.get_base_inputs_types(PikaBodyGenerate22T2vGenerate22T2vPost),
-                "aspect_ratio": model_field_to_node_input(
-                    IO.FLOAT,
-                    PikaBodyGenerate22T2vGenerate22T2vPost,
-                    "aspectRatio",
-                    step=0.001,
-                    min=0.4,
-                    max=2.5,
-                    default=1.7777777777777777,
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Sends a text prompt to the Pika API v2.2 to generate a video."
-
-    def api_call(
-        self,
-        prompt_text: str,
-        negative_prompt: str,
-        seed: int,
-        resolution: str,
-        duration: int,
-        aspect_ratio: float,
-        unique_id: str,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_TEXT_TO_VIDEO,
-                method=HttpMethod.POST,
-                request_model=PikaBodyGenerate22T2vGenerate22T2vPost,
-                response_model=PikaGenerateResponse,
-            ),
-            request=PikaBodyGenerate22T2vGenerate22T2vPost(
-                promptText=prompt_text,
-                negativePrompt=negative_prompt,
-                seed=seed,
-                resolution=resolution,
-                duration=duration,
-                aspectRatio=aspect_ratio,
-            ),
-            auth_kwargs=kwargs,
-            content_type="application/x-www-form-urlencoded",
-        )
-
-        return self.execute_task(initial_operation, auth_kwargs=kwargs, node_id=unique_id)
-
-
-class PikaScenesV2_2(PikaNodeBase):
-    """PikaScenes v2.2 Node."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        image_ingredient_input = (
-            IO.IMAGE,
-            {"tooltip": "Image that will be used as ingredient to create a video."},
-        )
-        return {
-            "required": {
-                **cls.get_base_inputs_types(
-                    PikaBodyGenerate22C2vGenerate22PikascenesPost,
-                ),
-                "ingredients_mode": model_field_to_node_input(
-                    IO.COMBO,
-                    PikaBodyGenerate22C2vGenerate22PikascenesPost,
-                    "ingredientsMode",
-                    enum_type=IngredientsMode,
-                    default="creative",
-                ),
-                "aspect_ratio": model_field_to_node_input(
-                    IO.FLOAT,
-                    PikaBodyGenerate22C2vGenerate22PikascenesPost,
-                    "aspectRatio",
-                    step=0.001,
-                    min=0.4,
-                    max=2.5,
-                    default=1.7777777777777777,
-                ),
-            },
-            "optional": {
-                "image_ingredient_1": image_ingredient_input,
-                "image_ingredient_2": image_ingredient_input,
-                "image_ingredient_3": image_ingredient_input,
-                "image_ingredient_4": image_ingredient_input,
-                "image_ingredient_5": image_ingredient_input,
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Combine your images to create a video with the objects in them. Upload multiple images as ingredients and generate a high-quality video that incorporates all of them."
-
-    def api_call(
-        self,
-        prompt_text: str,
-        negative_prompt: str,
-        seed: int,
-        resolution: str,
-        duration: int,
-        ingredients_mode: str,
-        aspect_ratio: float,
-        unique_id: str,
-        image_ingredient_1: Optional[torch.Tensor] = None,
-        image_ingredient_2: Optional[torch.Tensor] = None,
-        image_ingredient_3: Optional[torch.Tensor] = None,
-        image_ingredient_4: Optional[torch.Tensor] = None,
-        image_ingredient_5: Optional[torch.Tensor] = None,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-        # Convert all passed images to BytesIO
-        all_image_bytes_io = []
-        for image in [
-            image_ingredient_1,
-            image_ingredient_2,
-            image_ingredient_3,
-            image_ingredient_4,
-            image_ingredient_5,
-        ]:
-            if image is not None:
-                image_bytes_io = tensor_to_bytesio(image)
-                image_bytes_io.seek(0)
-                all_image_bytes_io.append(image_bytes_io)
-
-        pika_files = [
-            ("images", (f"image_{i}.png", image_bytes_io, "image/png"))
-            for i, image_bytes_io in enumerate(all_image_bytes_io)
-        ]
-
-        pika_request_data = PikaBodyGenerate22C2vGenerate22PikascenesPost(
-            ingredientsMode=ingredients_mode,
-            promptText=prompt_text,
-            negativePrompt=negative_prompt,
-            seed=seed,
-            resolution=resolution,
-            duration=duration,
-            aspectRatio=aspect_ratio,
-        )
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_PIKASCENES,
-                method=HttpMethod.POST,
-                request_model=PikaBodyGenerate22C2vGenerate22PikascenesPost,
-                response_model=PikaGenerateResponse,
-            ),
-            request=pika_request_data,
-            files=pika_files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-
-        return self.execute_task(initial_operation, auth_kwargs=kwargs, node_id=unique_id)
-
-
-class PikAdditionsNode(PikaNodeBase):
-    """Pika Pikadditions Node. Add an image into a video."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "video": (IO.VIDEO, {"tooltip": "The video to add an image to."}),
-                "image": (IO.IMAGE, {"tooltip": "The image to add to the video."}),
-                "prompt_text": model_field_to_node_input(
-                    IO.STRING,
-                    PikaBodyGeneratePikadditionsGeneratePikadditionsPost,
-                    "promptText",
-                    multiline=True,
-                ),
-                "negative_prompt": model_field_to_node_input(
-                    IO.STRING,
-                    PikaBodyGeneratePikadditionsGeneratePikadditionsPost,
-                    "negativePrompt",
-                    multiline=True,
-                ),
-                "seed": model_field_to_node_input(
-                    IO.INT,
-                    PikaBodyGeneratePikadditionsGeneratePikadditionsPost,
-                    "seed",
-                    min=0,
-                    max=0xFFFFFFFF,
-                    control_after_generate=True,
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Add any object or image into your video. Upload a video and specify what you'd like to add to create a seamlessly integrated result."
-
-    def api_call(
-        self,
-        video: VideoInput,
-        image: torch.Tensor,
-        prompt_text: str,
-        negative_prompt: str,
-        seed: int,
-        unique_id: str,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-        # Convert video to BytesIO
-        video_bytes_io = io.BytesIO()
-        video.save_to(video_bytes_io, format=VideoContainer.MP4, codec=VideoCodec.H264)
-        video_bytes_io.seek(0)
-
-        # Convert image to BytesIO
-        image_bytes_io = tensor_to_bytesio(image)
-        image_bytes_io.seek(0)
-
-        pika_files = [
-            ("video", ("video.mp4", video_bytes_io, "video/mp4")),
-            ("image", ("image.png", image_bytes_io, "image/png")),
-        ]
-
-        # Prepare non-file data
-        pika_request_data = PikaBodyGeneratePikadditionsGeneratePikadditionsPost(
-            promptText=prompt_text,
-            negativePrompt=negative_prompt,
-            seed=seed,
-        )
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_PIKADDITIONS,
-                method=HttpMethod.POST,
-                request_model=PikaBodyGeneratePikadditionsGeneratePikadditionsPost,
-                response_model=PikaGenerateResponse,
-            ),
-            request=pika_request_data,
-            files=pika_files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-
-        return self.execute_task(initial_operation, auth_kwargs=kwargs, node_id=unique_id)
-
-
-class PikaSwapsNode(PikaNodeBase):
-    """Pika Pikaswaps Node."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "video": (IO.VIDEO, {"tooltip": "The video to swap an object in."}),
-                "image": (
-                    IO.IMAGE,
-                    {
-                        "tooltip": "The image used to replace the masked object in the video."
-                    },
-                ),
-                "mask": (
-                    IO.MASK,
-                    {"tooltip": "Use the mask to define areas in the video to replace"},
-                ),
-                "prompt_text": model_field_to_node_input(
-                    IO.STRING,
-                    PikaBodyGeneratePikaswapsGeneratePikaswapsPost,
-                    "promptText",
-                    multiline=True,
-                ),
-                "negative_prompt": model_field_to_node_input(
-                    IO.STRING,
-                    PikaBodyGeneratePikaswapsGeneratePikaswapsPost,
-                    "negativePrompt",
-                    multiline=True,
-                ),
-                "seed": model_field_to_node_input(
-                    IO.INT,
-                    PikaBodyGeneratePikaswapsGeneratePikaswapsPost,
-                    "seed",
-                    min=0,
-                    max=0xFFFFFFFF,
-                    control_after_generate=True,
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Swap out any object or region of your video with a new image or object. Define areas to replace either with a mask or coordinates."
-    RETURN_TYPES = ("VIDEO",)
-
-    def api_call(
-        self,
-        video: VideoInput,
-        image: torch.Tensor,
-        mask: torch.Tensor,
-        prompt_text: str,
-        negative_prompt: str,
-        seed: int,
-        unique_id: str,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-        # Convert video to BytesIO
-        video_bytes_io = io.BytesIO()
-        video.save_to(video_bytes_io, format=VideoContainer.MP4, codec=VideoCodec.H264)
-        video_bytes_io.seek(0)
-
-        # Convert mask to binary mask with three channels
-        mask = torch.round(mask)
-        mask = mask.repeat(1, 3, 1, 1)
-
-        # Convert 3-channel binary mask to BytesIO
-        mask_bytes_io = io.BytesIO()
-        mask_bytes_io.write(mask.numpy().astype(np.uint8))
-        mask_bytes_io.seek(0)
-
-        # Convert image to BytesIO
-        image_bytes_io = tensor_to_bytesio(image)
-        image_bytes_io.seek(0)
-
-        pika_files = [
-            ("video", ("video.mp4", video_bytes_io, "video/mp4")),
-            ("image", ("image.png", image_bytes_io, "image/png")),
-            ("modifyRegionMask", ("mask.png", mask_bytes_io, "image/png")),
-        ]
-
-        # Prepare non-file data
-        pika_request_data = PikaBodyGeneratePikaswapsGeneratePikaswapsPost(
-            promptText=prompt_text,
-            negativePrompt=negative_prompt,
-            seed=seed,
-        )
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_PIKADDITIONS,
-                method=HttpMethod.POST,
-                request_model=PikaBodyGeneratePikadditionsGeneratePikadditionsPost,
-                response_model=PikaGenerateResponse,
-            ),
-            request=pika_request_data,
-            files=pika_files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-
-        return self.execute_task(initial_operation, auth_kwargs=kwargs, node_id=unique_id)
-
-
-class PikaffectsNode(PikaNodeBase):
-    """Pika Pikaffects Node."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": (
-                    IO.IMAGE,
-                    {"tooltip": "The reference image to apply the Pikaffect to."},
-                ),
-                "pikaffect": model_field_to_node_input(
-                    IO.COMBO,
-                    PikaBodyGeneratePikaffectsGeneratePikaffectsPost,
-                    "pikaffect",
-                    enum_type=Pikaffect,
-                    default="Cake-ify",
-                ),
-                "prompt_text": model_field_to_node_input(
-                    IO.STRING,
-                    PikaBodyGeneratePikaffectsGeneratePikaffectsPost,
-                    "promptText",
-                    multiline=True,
-                ),
-                "negative_prompt": model_field_to_node_input(
-                    IO.STRING,
-                    PikaBodyGeneratePikaffectsGeneratePikaffectsPost,
-                    "negativePrompt",
-                    multiline=True,
-                ),
-                "seed": model_field_to_node_input(
-                    IO.INT,
-                    PikaBodyGeneratePikaffectsGeneratePikaffectsPost,
-                    "seed",
-                    min=0,
-                    max=0xFFFFFFFF,
-                    control_after_generate=True,
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Generate a video with a specific Pikaffect. Supported Pikaffects: Cake-ify, Crumble, Crush, Decapitate, Deflate, Dissolve, Explode, Eye-pop, Inflate, Levitate, Melt, Peel, Poke, Squish, Ta-da, Tear"
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        pikaffect: str,
-        prompt_text: str,
-        negative_prompt: str,
-        seed: int,
-        unique_id: str,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_PIKAFFECTS,
-                method=HttpMethod.POST,
-                request_model=PikaBodyGeneratePikaffectsGeneratePikaffectsPost,
-                response_model=PikaGenerateResponse,
-            ),
-            request=PikaBodyGeneratePikaffectsGeneratePikaffectsPost(
-                pikaffect=pikaffect,
-                promptText=prompt_text,
-                negativePrompt=negative_prompt,
-                seed=seed,
-            ),
-            files={"image": ("image.png", tensor_to_bytesio(image), "image/png")},
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-
-        return self.execute_task(initial_operation, auth_kwargs=kwargs, node_id=unique_id)
-
-
-class PikaStartEndFrameNode2_2(PikaNodeBase):
-    """PikaFrames v2.2 Node."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image_start": (IO.IMAGE, {"tooltip": "The first image to combine."}),
-                "image_end": (IO.IMAGE, {"tooltip": "The last image to combine."}),
-                **cls.get_base_inputs_types(
-                    PikaBodyGenerate22KeyframeGenerate22PikaframesPost
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Generate a video by combining your first and last frame. Upload two images to define the start and end points, and let the AI create a smooth transition between them."
-
-    def api_call(
-        self,
-        image_start: torch.Tensor,
-        image_end: torch.Tensor,
-        prompt_text: str,
-        negative_prompt: str,
-        seed: int,
-        resolution: str,
-        duration: int,
-        unique_id: str,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-
-        pika_files = [
-            (
-                "keyFrames",
-                ("image_start.png", tensor_to_bytesio(image_start), "image/png"),
-            ),
-            ("keyFrames", ("image_end.png", tensor_to_bytesio(image_end), "image/png")),
-        ]
-
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_PIKAFRAMES,
-                method=HttpMethod.POST,
-                request_model=PikaBodyGenerate22KeyframeGenerate22PikaframesPost,
-                response_model=PikaGenerateResponse,
-            ),
-            request=PikaBodyGenerate22KeyframeGenerate22PikaframesPost(
-                promptText=prompt_text,
-                negativePrompt=negative_prompt,
-                seed=seed,
-                resolution=resolution,
-                duration=duration,
-            ),
-            files=pika_files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-
-        return self.execute_task(initial_operation, auth_kwargs=kwargs, node_id=unique_id)
-
-
-NODE_CLASS_MAPPINGS = {
-    "PikaImageToVideoNode2_2": PikaImageToVideoV2_2,
-    "PikaTextToVideoNode2_2": PikaTextToVideoNodeV2_2,
-    "PikaScenesV2_2": PikaScenesV2_2,
-    "Pikadditions": PikAdditionsNode,
-    "Pikaswaps": PikaSwapsNode,
-    "Pikaffects": PikaffectsNode,
-    "PikaStartEndFrameNode2_2": PikaStartEndFrameNode2_2,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "PikaImageToVideoNode2_2": "Pika Image to Video",
-    "PikaTextToVideoNode2_2": "Pika Text to Video",
-    "PikaScenesV2_2": "Pika Scenes (Video Image Composition)",
-    "Pikadditions": "Pikadditions (Video Object Insertion)",
-    "Pikaswaps": "Pika Swaps (Video Object Replacement)",
-    "Pikaffects": "Pikaffects (Video Effects)",
-    "PikaStartEndFrameNode2_2": "Pika Start and End Frame to Video",
-}

comfy_api_nodes/nodes_pixverse.py

@@ -1,525 +0,0 @@
-from inspect import cleandoc
-from typing import Optional
-from comfy_api_nodes.apis.pixverse_api import (
-    PixverseTextVideoRequest,
-    PixverseImageVideoRequest,
-    PixverseTransitionVideoRequest,
-    PixverseImageUploadResponse,
-    PixverseVideoResponse,
-    PixverseGenerationStatusResponse,
-    PixverseAspectRatio,
-    PixverseQuality,
-    PixverseDuration,
-    PixverseMotionMode,
-    PixverseStatus,
-    PixverseIO,
-    pixverse_templates,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    tensor_to_bytesio,
-    validate_string,
-)
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC
-from comfy_api.input_impl import VideoFromFile
-
-import torch
-import requests
-from io import BytesIO
-
-
-AVERAGE_DURATION_T2V = 32
-AVERAGE_DURATION_I2V = 30
-AVERAGE_DURATION_T2T = 52
-
-
-def get_video_url_from_response(
-    response: PixverseGenerationStatusResponse,
-) -> Optional[str]:
-    if response.Resp is None or response.Resp.url is None:
-        return None
-    return str(response.Resp.url)
-
-
-def upload_image_to_pixverse(image: torch.Tensor, auth_kwargs=None):
-    # first, upload image to Pixverse and get image id to use in actual generation call
-    files = {"image": tensor_to_bytesio(image)}
-    operation = SynchronousOperation(
-        endpoint=ApiEndpoint(
-            path="/proxy/pixverse/image/upload",
-            method=HttpMethod.POST,
-            request_model=EmptyRequest,
-            response_model=PixverseImageUploadResponse,
-        ),
-        request=EmptyRequest(),
-        files=files,
-        content_type="multipart/form-data",
-        auth_kwargs=auth_kwargs,
-    )
-    response_upload: PixverseImageUploadResponse = operation.execute()
-
-    if response_upload.Resp is None:
-        raise Exception(
-            f"PixVerse image upload request failed: '{response_upload.ErrMsg}'"
-        )
-
-    return response_upload.Resp.img_id
-
-
-class PixverseTemplateNode:
-    """
-    Select template for PixVerse Video generation.
-    """
-
-    RETURN_TYPES = (PixverseIO.TEMPLATE,)
-    RETURN_NAMES = ("pixverse_template",)
-    FUNCTION = "create_template"
-    CATEGORY = "api node/video/PixVerse"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "template": (list(pixverse_templates.keys()),),
-            }
-        }
-
-    def create_template(self, template: str):
-        template_id = pixverse_templates.get(template, None)
-        if template_id is None:
-            raise Exception(f"Template '{template}' is not recognized.")
-        # just return the integer
-        return (template_id,)
-
-
-class PixverseTextToVideoNode(ComfyNodeABC):
-    """
-    Generates videos based on prompt and output_size.
-    """
-
-    RETURN_TYPES = (IO.VIDEO,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/video/PixVerse"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the video generation",
-                    },
-                ),
-                "aspect_ratio": ([ratio.value for ratio in PixverseAspectRatio],),
-                "quality": (
-                    [resolution.value for resolution in PixverseQuality],
-                    {
-                        "default": PixverseQuality.res_540p,
-                    },
-                ),
-                "duration_seconds": ([dur.value for dur in PixverseDuration],),
-                "motion_mode": ([mode.value for mode in PixverseMotionMode],),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2147483647,
-                        "control_after_generate": True,
-                        "tooltip": "Seed for video generation.",
-                    },
-                ),
-            },
-            "optional": {
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "An optional text description of undesired elements on an image.",
-                    },
-                ),
-                "pixverse_template": (
-                    PixverseIO.TEMPLATE,
-                    {
-                        "tooltip": "An optional template to influence style of generation, created by the PixVerse Template node."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        aspect_ratio: str,
-        quality: str,
-        duration_seconds: int,
-        motion_mode: str,
-        seed,
-        negative_prompt: str = None,
-        pixverse_template: int = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False)
-        # 1080p is limited to 5 seconds duration
-        # only normal motion_mode supported for 1080p or for non-5 second duration
-        if quality == PixverseQuality.res_1080p:
-            motion_mode = PixverseMotionMode.normal
-            duration_seconds = PixverseDuration.dur_5
-        elif duration_seconds != PixverseDuration.dur_5:
-            motion_mode = PixverseMotionMode.normal
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/pixverse/video/text/generate",
-                method=HttpMethod.POST,
-                request_model=PixverseTextVideoRequest,
-                response_model=PixverseVideoResponse,
-            ),
-            request=PixverseTextVideoRequest(
-                prompt=prompt,
-                aspect_ratio=aspect_ratio,
-                quality=quality,
-                duration=duration_seconds,
-                motion_mode=motion_mode,
-                negative_prompt=negative_prompt if negative_prompt else None,
-                template_id=pixverse_template,
-                seed=seed,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response_api = operation.execute()
-
-        if response_api.Resp is None:
-            raise Exception(f"PixVerse request failed: '{response_api.ErrMsg}'")
-
-        operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"/proxy/pixverse/video/result/{response_api.Resp.video_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=PixverseGenerationStatusResponse,
-            ),
-            completed_statuses=[PixverseStatus.successful],
-            failed_statuses=[
-                PixverseStatus.contents_moderation,
-                PixverseStatus.failed,
-                PixverseStatus.deleted,
-            ],
-            status_extractor=lambda x: x.Resp.status,
-            auth_kwargs=kwargs,
-            node_id=unique_id,
-            result_url_extractor=get_video_url_from_response,
-            estimated_duration=AVERAGE_DURATION_T2V,
-        )
-        response_poll = operation.execute()
-
-        vid_response = requests.get(response_poll.Resp.url)
-
-        return (VideoFromFile(BytesIO(vid_response.content)),)
-
-
-class PixverseImageToVideoNode(ComfyNodeABC):
-    """
-    Generates videos based on prompt and output_size.
-    """
-
-    RETURN_TYPES = (IO.VIDEO,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/video/PixVerse"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the video generation",
-                    },
-                ),
-                "quality": (
-                    [resolution.value for resolution in PixverseQuality],
-                    {
-                        "default": PixverseQuality.res_540p,
-                    },
-                ),
-                "duration_seconds": ([dur.value for dur in PixverseDuration],),
-                "motion_mode": ([mode.value for mode in PixverseMotionMode],),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2147483647,
-                        "control_after_generate": True,
-                        "tooltip": "Seed for video generation.",
-                    },
-                ),
-            },
-            "optional": {
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "An optional text description of undesired elements on an image.",
-                    },
-                ),
-                "pixverse_template": (
-                    PixverseIO.TEMPLATE,
-                    {
-                        "tooltip": "An optional template to influence style of generation, created by the PixVerse Template node."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        prompt: str,
-        quality: str,
-        duration_seconds: int,
-        motion_mode: str,
-        seed,
-        negative_prompt: str = None,
-        pixverse_template: int = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False)
-        img_id = upload_image_to_pixverse(image, auth_kwargs=kwargs)
-
-        # 1080p is limited to 5 seconds duration
-        # only normal motion_mode supported for 1080p or for non-5 second duration
-        if quality == PixverseQuality.res_1080p:
-            motion_mode = PixverseMotionMode.normal
-            duration_seconds = PixverseDuration.dur_5
-        elif duration_seconds != PixverseDuration.dur_5:
-            motion_mode = PixverseMotionMode.normal
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/pixverse/video/img/generate",
-                method=HttpMethod.POST,
-                request_model=PixverseImageVideoRequest,
-                response_model=PixverseVideoResponse,
-            ),
-            request=PixverseImageVideoRequest(
-                img_id=img_id,
-                prompt=prompt,
-                quality=quality,
-                duration=duration_seconds,
-                motion_mode=motion_mode,
-                negative_prompt=negative_prompt if negative_prompt else None,
-                template_id=pixverse_template,
-                seed=seed,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response_api = operation.execute()
-
-        if response_api.Resp is None:
-            raise Exception(f"PixVerse request failed: '{response_api.ErrMsg}'")
-
-        operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"/proxy/pixverse/video/result/{response_api.Resp.video_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=PixverseGenerationStatusResponse,
-            ),
-            completed_statuses=[PixverseStatus.successful],
-            failed_statuses=[
-                PixverseStatus.contents_moderation,
-                PixverseStatus.failed,
-                PixverseStatus.deleted,
-            ],
-            status_extractor=lambda x: x.Resp.status,
-            auth_kwargs=kwargs,
-            node_id=unique_id,
-            result_url_extractor=get_video_url_from_response,
-            estimated_duration=AVERAGE_DURATION_I2V,
-        )
-        response_poll = operation.execute()
-
-        vid_response = requests.get(response_poll.Resp.url)
-        return (VideoFromFile(BytesIO(vid_response.content)),)
-
-
-class PixverseTransitionVideoNode(ComfyNodeABC):
-    """
-    Generates videos based on prompt and output_size.
-    """
-
-    RETURN_TYPES = (IO.VIDEO,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/video/PixVerse"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "first_frame": (IO.IMAGE,),
-                "last_frame": (IO.IMAGE,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the video generation",
-                    },
-                ),
-                "quality": (
-                    [resolution.value for resolution in PixverseQuality],
-                    {
-                        "default": PixverseQuality.res_540p,
-                    },
-                ),
-                "duration_seconds": ([dur.value for dur in PixverseDuration],),
-                "motion_mode": ([mode.value for mode in PixverseMotionMode],),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 2147483647,
-                        "control_after_generate": True,
-                        "tooltip": "Seed for video generation.",
-                    },
-                ),
-            },
-            "optional": {
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "An optional text description of undesired elements on an image.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        first_frame: torch.Tensor,
-        last_frame: torch.Tensor,
-        prompt: str,
-        quality: str,
-        duration_seconds: int,
-        motion_mode: str,
-        seed,
-        negative_prompt: str = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False)
-        first_frame_id = upload_image_to_pixverse(first_frame, auth_kwargs=kwargs)
-        last_frame_id = upload_image_to_pixverse(last_frame, auth_kwargs=kwargs)
-
-        # 1080p is limited to 5 seconds duration
-        # only normal motion_mode supported for 1080p or for non-5 second duration
-        if quality == PixverseQuality.res_1080p:
-            motion_mode = PixverseMotionMode.normal
-            duration_seconds = PixverseDuration.dur_5
-        elif duration_seconds != PixverseDuration.dur_5:
-            motion_mode = PixverseMotionMode.normal
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/pixverse/video/transition/generate",
-                method=HttpMethod.POST,
-                request_model=PixverseTransitionVideoRequest,
-                response_model=PixverseVideoResponse,
-            ),
-            request=PixverseTransitionVideoRequest(
-                first_frame_img=first_frame_id,
-                last_frame_img=last_frame_id,
-                prompt=prompt,
-                quality=quality,
-                duration=duration_seconds,
-                motion_mode=motion_mode,
-                negative_prompt=negative_prompt if negative_prompt else None,
-                seed=seed,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response_api = operation.execute()
-
-        if response_api.Resp is None:
-            raise Exception(f"PixVerse request failed: '{response_api.ErrMsg}'")
-
-        operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"/proxy/pixverse/video/result/{response_api.Resp.video_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=PixverseGenerationStatusResponse,
-            ),
-            completed_statuses=[PixverseStatus.successful],
-            failed_statuses=[
-                PixverseStatus.contents_moderation,
-                PixverseStatus.failed,
-                PixverseStatus.deleted,
-            ],
-            status_extractor=lambda x: x.Resp.status,
-            auth_kwargs=kwargs,
-            node_id=unique_id,
-            result_url_extractor=get_video_url_from_response,
-            estimated_duration=AVERAGE_DURATION_T2V,
-        )
-        response_poll = operation.execute()
-
-        vid_response = requests.get(response_poll.Resp.url)
-        return (VideoFromFile(BytesIO(vid_response.content)),)
-
-
-NODE_CLASS_MAPPINGS = {
-    "PixverseTextToVideoNode": PixverseTextToVideoNode,
-    "PixverseImageToVideoNode": PixverseImageToVideoNode,
-    "PixverseTransitionVideoNode": PixverseTransitionVideoNode,
-    "PixverseTemplateNode": PixverseTemplateNode,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "PixverseTextToVideoNode": "PixVerse Text to Video",
-    "PixverseImageToVideoNode": "PixVerse Image to Video",
-    "PixverseTransitionVideoNode": "PixVerse Transition Video",
-    "PixverseTemplateNode": "PixVerse Template",
-}

comfy_api_nodes/nodes_recraft.py

@@ -1,1138 +0,0 @@
-from __future__ import annotations
-from inspect import cleandoc
-from typing import Optional
-from comfy.utils import ProgressBar
-from comfy_extras.nodes_images import SVG # Added
-from comfy.comfy_types.node_typing import IO
-from comfy_api_nodes.apis.recraft_api import (
-    RecraftImageGenerationRequest,
-    RecraftImageGenerationResponse,
-    RecraftImageSize,
-    RecraftModel,
-    RecraftStyle,
-    RecraftStyleV3,
-    RecraftColor,
-    RecraftColorChain,
-    RecraftControls,
-    RecraftIO,
-    get_v3_substyles,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    bytesio_to_image_tensor,
-    download_url_to_bytesio,
-    tensor_to_bytesio,
-    resize_mask_to_image,
-    validate_string,
-)
-from server import PromptServer
-
-import torch
-from io import BytesIO
-from PIL import UnidentifiedImageError
-
-
-def handle_recraft_file_request(
-        image: torch.Tensor,
-        path: str,
-        mask: torch.Tensor=None,
-        total_pixels=4096*4096,
-        timeout=1024,
-        request=None,
-        auth_kwargs: dict[str,str] = None,
-    ) -> list[BytesIO]:
-        """
-        Handle sending common Recraft file-only request to get back file bytes.
-        """
-        if request is None:
-            request = EmptyRequest()
-
-        files = {
-            'image': tensor_to_bytesio(image, total_pixels=total_pixels).read()
-        }
-        if mask is not None:
-            files['mask'] = tensor_to_bytesio(mask, total_pixels=total_pixels).read()
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=path,
-                method=HttpMethod.POST,
-                request_model=type(request),
-                response_model=RecraftImageGenerationResponse,
-            ),
-            request=request,
-            files=files,
-            content_type="multipart/form-data",
-            auth_kwargs=auth_kwargs,
-            multipart_parser=recraft_multipart_parser,
-        )
-        response: RecraftImageGenerationResponse = operation.execute()
-        all_bytesio = []
-        if response.image is not None:
-            all_bytesio.append(download_url_to_bytesio(response.image.url, timeout=timeout))
-        else:
-            for data in response.data:
-                all_bytesio.append(download_url_to_bytesio(data.url, timeout=timeout))
-
-        return all_bytesio
-
-
-def recraft_multipart_parser(data, parent_key=None, formatter: callable=None, converted_to_check: list[list]=None, is_list=False) -> dict:
-    """
-    Formats data such that multipart/form-data will work with requests library
-    when both files and data are present.
-
-    The OpenAI client that Recraft uses has a bizarre way of serializing lists:
-
-    It does NOT keep track of indeces of each list, so for background_color, that must be serialized as:
-        'background_color[rgb][]' = [0, 0, 255]
-    where the array is assigned to a key that has '[]' at the end, to signal it's an array.
-
-    This has the consequence of nested lists having the exact same key, forcing arrays to merge; all colors inputs fall under the same key:
-        if 1 color  -> 'controls[colors][][rgb][]' = [0, 0, 255]
-        if 2 colors -> 'controls[colors][][rgb][]' = [0, 0, 255, 255, 0, 0]
-        if 3 colors -> 'controls[colors][][rgb][]' = [0, 0, 255, 255, 0, 0, 0, 255, 0]
-        etc.
-    Whoever made this serialization up at OpenAI added the constraint that lists must be of uniform length on objects of same 'type'.
-    """
-    # Modification of a function that handled a different type of multipart parsing, big ups:
-    # https://gist.github.com/kazqvaizer/4cebebe5db654a414132809f9f88067b
-
-    def handle_converted_lists(data, parent_key, lists_to_check=tuple[list]):
-        # if list already exists exists, just extend list with data
-        for check_list in lists_to_check:
-            for conv_tuple in check_list:
-                if conv_tuple[0] == parent_key and type(conv_tuple[1]) is list:
-                    conv_tuple[1].append(formatter(data))
-                    return True
-        return False
-
-    if converted_to_check is None:
-        converted_to_check = []
-
-
-    if formatter is None:
-        formatter = lambda v: v  # Multipart representation of value
-
-    if type(data) is not dict:
-        # if list already exists exists, just extend list with data
-        added = handle_converted_lists(data, parent_key, converted_to_check)
-        if added:
-            return {}
-        # otherwise if is_list, create new list with data
-        if is_list:
-            return {parent_key: [formatter(data)]}
-        # return new key with data
-        return {parent_key: formatter(data)}
-
-    converted = []
-    next_check = [converted]
-    next_check.extend(converted_to_check)
-
-    for key, value in data.items():
-        current_key = key if parent_key is None else f"{parent_key}[{key}]"
-        if type(value) is dict:
-            converted.extend(recraft_multipart_parser(value, current_key, formatter, next_check).items())
-        elif type(value) is list:
-            for ind, list_value in enumerate(value):
-                iter_key = f"{current_key}[]"
-                converted.extend(recraft_multipart_parser(list_value, iter_key, formatter, next_check, is_list=True).items())
-        else:
-            converted.append((current_key, formatter(value)))
-
-    return dict(converted)
-
-
-class handle_recraft_image_output:
-    """
-    Catch an exception related to receiving SVG data instead of image, when Infinite Style Library style_id is in use.
-    """
-    def __init__(self):
-        pass
-
-    def __enter__(self):
-        pass
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is not None and exc_type is UnidentifiedImageError:
-            raise Exception("Received output data was not an image; likely an SVG. If you used style_id, make sure it is not a Vector art style.")
-
-
-class RecraftColorRGBNode:
-    """
-    Create Recraft Color by choosing specific RGB values.
-    """
-
-    RETURN_TYPES = (RecraftIO.COLOR,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    RETURN_NAMES = ("recraft_color",)
-    FUNCTION = "create_color"
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "r": (IO.INT, {
-                    "default": 0,
-                    "min": 0,
-                    "max": 255,
-                    "tooltip": "Red value of color."
-                }),
-                "g": (IO.INT, {
-                    "default": 0,
-                    "min": 0,
-                    "max": 255,
-                    "tooltip": "Green value of color."
-                }),
-                "b": (IO.INT, {
-                    "default": 0,
-                    "min": 0,
-                    "max": 255,
-                    "tooltip": "Blue value of color."
-                }),
-            },
-            "optional": {
-                "recraft_color": (RecraftIO.COLOR,),
-            }
-        }
-
-    def create_color(self, r: int, g: int, b: int, recraft_color: RecraftColorChain=None):
-        recraft_color = recraft_color.clone() if recraft_color else RecraftColorChain()
-        recraft_color.add(RecraftColor(r, g, b))
-        return (recraft_color, )
-
-
-class RecraftControlsNode:
-    """
-    Create Recraft Controls for customizing Recraft generation.
-    """
-
-    RETURN_TYPES = (RecraftIO.CONTROLS,)
-    RETURN_NAMES = ("recraft_controls",)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "create_controls"
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-            },
-            "optional": {
-                "colors": (RecraftIO.COLOR,),
-                "background_color": (RecraftIO.COLOR,),
-            }
-        }
-
-    def create_controls(self, colors: RecraftColorChain=None, background_color: RecraftColorChain=None):
-        return (RecraftControls(colors=colors, background_color=background_color), )
-
-
-class RecraftStyleV3RealisticImageNode:
-    """
-    Select realistic_image style and optional substyle.
-    """
-
-    RETURN_TYPES = (RecraftIO.STYLEV3,)
-    RETURN_NAMES = ("recraft_style",)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "create_style"
-    CATEGORY = "api node/image/Recraft"
-
-    RECRAFT_STYLE = RecraftStyleV3.realistic_image
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "substyle": (get_v3_substyles(s.RECRAFT_STYLE),),
-            }
-        }
-
-    def create_style(self, substyle: str):
-        if substyle == "None":
-            substyle = None
-        return (RecraftStyle(self.RECRAFT_STYLE, substyle),)
-
-
-class RecraftStyleV3DigitalIllustrationNode(RecraftStyleV3RealisticImageNode):
-    """
-    Select digital_illustration style and optional substyle.
-    """
-
-    RECRAFT_STYLE = RecraftStyleV3.digital_illustration
-
-
-class RecraftStyleV3VectorIllustrationNode(RecraftStyleV3RealisticImageNode):
-    """
-    Select vector_illustration style and optional substyle.
-    """
-
-    RECRAFT_STYLE = RecraftStyleV3.vector_illustration
-
-
-class RecraftStyleV3LogoRasterNode(RecraftStyleV3RealisticImageNode):
-    """
-    Select vector_illustration style and optional substyle.
-    """
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "substyle": (get_v3_substyles(s.RECRAFT_STYLE, include_none=False),),
-            }
-        }
-
-    RECRAFT_STYLE = RecraftStyleV3.logo_raster
-
-
-class RecraftStyleInfiniteStyleLibrary:
-    """
-    Select style based on preexisting UUID from Recraft's Infinite Style Library.
-    """
-
-    RETURN_TYPES = (RecraftIO.STYLEV3,)
-    RETURN_NAMES = ("recraft_style",)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "create_style"
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "style_id": (IO.STRING, {
-                    "default": "",
-                    "tooltip": "UUID of style from Infinite Style Library.",
-                })
-            }
-        }
-
-    def create_style(self, style_id: str):
-        if not style_id:
-            raise Exception("The style_id input cannot be empty.")
-        return (RecraftStyle(style_id=style_id),)
-
-
-class RecraftTextToImageNode:
-    """
-    Generates images synchronously based on prompt and resolution.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation.",
-                    },
-                ),
-                "size": (
-                    [res.value for res in RecraftImageSize],
-                    {
-                        "default": RecraftImageSize.res_1024x1024,
-                        "tooltip": "The size of the generated image.",
-                    },
-                ),
-                "n": (
-                    IO.INT,
-                    {
-                        "default": 1,
-                        "min": 1,
-                        "max": 6,
-                        "tooltip": "The number of images to generate.",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-            },
-            "optional": {
-                "recraft_style": (RecraftIO.STYLEV3,),
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "An optional text description of undesired elements on an image.",
-                    },
-                ),
-                "recraft_controls": (
-                    RecraftIO.CONTROLS,
-                    {
-                        "tooltip": "Optional additional controls over the generation via the Recraft Controls node."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        size: str,
-        n: int,
-        seed,
-        recraft_style: RecraftStyle = None,
-        negative_prompt: str = None,
-        recraft_controls: RecraftControls = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False, max_length=1000)
-        default_style = RecraftStyle(RecraftStyleV3.realistic_image)
-        if recraft_style is None:
-            recraft_style = default_style
-
-        controls_api = None
-        if recraft_controls:
-            controls_api = recraft_controls.create_api_model()
-
-        if not negative_prompt:
-            negative_prompt = None
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/recraft/image_generation",
-                method=HttpMethod.POST,
-                request_model=RecraftImageGenerationRequest,
-                response_model=RecraftImageGenerationResponse,
-            ),
-            request=RecraftImageGenerationRequest(
-                prompt=prompt,
-                negative_prompt=negative_prompt,
-                model=RecraftModel.recraftv3,
-                size=size,
-                n=n,
-                style=recraft_style.style,
-                substyle=recraft_style.substyle,
-                style_id=recraft_style.style_id,
-                controls=controls_api,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response: RecraftImageGenerationResponse = operation.execute()
-        images = []
-        urls = []
-        for data in response.data:
-            with handle_recraft_image_output():
-                if unique_id and data.url:
-                    urls.append(data.url)
-                    urls_string = '\n'.join(urls)
-                    PromptServer.instance.send_progress_text(
-                        f"Result URL: {urls_string}", unique_id
-                    )
-                image = bytesio_to_image_tensor(
-                    download_url_to_bytesio(data.url, timeout=1024)
-                )
-            if len(image.shape) < 4:
-                image = image.unsqueeze(0)
-            images.append(image)
-        output_image = torch.cat(images, dim=0)
-
-        return (output_image,)
-
-
-class RecraftImageToImageNode:
-    """
-    Modify image based on prompt and strength.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE, ),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation.",
-                    },
-                ),
-                "n": (
-                    IO.INT,
-                    {
-                        "default": 1,
-                        "min": 1,
-                        "max": 6,
-                        "tooltip": "The number of images to generate.",
-                    },
-                ),
-                "strength": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.5,
-                        "min": 0.0,
-                        "max": 1.0,
-                        "step": 0.01,
-                        "tooltip": "Defines the difference with the original image, should lie in [0, 1], where 0 means almost identical, and 1 means miserable similarity."
-                    }
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-            },
-            "optional": {
-                "recraft_style": (RecraftIO.STYLEV3,),
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "An optional text description of undesired elements on an image.",
-                    },
-                ),
-                "recraft_controls": (
-                    RecraftIO.CONTROLS,
-                    {
-                        "tooltip": "Optional additional controls over the generation via the Recraft Controls node."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        prompt: str,
-        n: int,
-        strength: float,
-        seed,
-        recraft_style: RecraftStyle = None,
-        negative_prompt: str = None,
-        recraft_controls: RecraftControls = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False, max_length=1000)
-        default_style = RecraftStyle(RecraftStyleV3.realistic_image)
-        if recraft_style is None:
-            recraft_style = default_style
-
-        controls_api = None
-        if recraft_controls:
-            controls_api = recraft_controls.create_api_model()
-
-        if not negative_prompt:
-            negative_prompt = None
-
-        request = RecraftImageGenerationRequest(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            model=RecraftModel.recraftv3,
-            n=n,
-            strength=round(strength, 2),
-            style=recraft_style.style,
-            substyle=recraft_style.substyle,
-            style_id=recraft_style.style_id,
-            controls=controls_api,
-        )
-
-        images = []
-        total = image.shape[0]
-        pbar = ProgressBar(total)
-        for i in range(total):
-            sub_bytes = handle_recraft_file_request(
-                image=image[i],
-                path="/proxy/recraft/images/imageToImage",
-                request=request,
-                auth_kwargs=kwargs,
-            )
-            with handle_recraft_image_output():
-                images.append(torch.cat([bytesio_to_image_tensor(x) for x in sub_bytes], dim=0))
-            pbar.update(1)
-
-        images_tensor = torch.cat(images, dim=0)
-        return (images_tensor, )
-
-
-class RecraftImageInpaintingNode:
-    """
-    Modify image based on prompt and mask.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE, ),
-                "mask": (IO.MASK, ),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation.",
-                    },
-                ),
-                "n": (
-                    IO.INT,
-                    {
-                        "default": 1,
-                        "min": 1,
-                        "max": 6,
-                        "tooltip": "The number of images to generate.",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-            },
-            "optional": {
-                "recraft_style": (RecraftIO.STYLEV3,),
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "An optional text description of undesired elements on an image.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        mask: torch.Tensor,
-        prompt: str,
-        n: int,
-        seed,
-        recraft_style: RecraftStyle = None,
-        negative_prompt: str = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False, max_length=1000)
-        default_style = RecraftStyle(RecraftStyleV3.realistic_image)
-        if recraft_style is None:
-            recraft_style = default_style
-
-        if not negative_prompt:
-            negative_prompt = None
-
-        request = RecraftImageGenerationRequest(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            model=RecraftModel.recraftv3,
-            n=n,
-            style=recraft_style.style,
-            substyle=recraft_style.substyle,
-            style_id=recraft_style.style_id,
-        )
-
-        # prepare mask tensor
-        mask = resize_mask_to_image(mask, image, allow_gradient=False, add_channel_dim=True)
-
-        images = []
-        total = image.shape[0]
-        pbar = ProgressBar(total)
-        for i in range(total):
-            sub_bytes = handle_recraft_file_request(
-                image=image[i],
-                mask=mask[i:i+1],
-                path="/proxy/recraft/images/inpaint",
-                request=request,
-                auth_kwargs=kwargs,
-            )
-            with handle_recraft_image_output():
-                images.append(torch.cat([bytesio_to_image_tensor(x) for x in sub_bytes], dim=0))
-            pbar.update(1)
-
-        images_tensor = torch.cat(images, dim=0)
-        return (images_tensor, )
-
-
-class RecraftTextToVectorNode:
-    """
-    Generates SVG synchronously based on prompt and resolution.
-    """
-
-    RETURN_TYPES = ("SVG",) # Changed
-    DESCRIPTION = cleandoc(__doc__ or "") if 'cleandoc' in globals() else __doc__ # Keep cleandoc if other nodes use it
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation.",
-                    },
-                ),
-                "substyle": (get_v3_substyles(RecraftStyleV3.vector_illustration),),
-                "size": (
-                    [res.value for res in RecraftImageSize],
-                    {
-                        "default": RecraftImageSize.res_1024x1024,
-                        "tooltip": "The size of the generated image.",
-                    },
-                ),
-                "n": (
-                    IO.INT,
-                    {
-                        "default": 1,
-                        "min": 1,
-                        "max": 6,
-                        "tooltip": "The number of images to generate.",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-            },
-            "optional": {
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "An optional text description of undesired elements on an image.",
-                    },
-                ),
-                "recraft_controls": (
-                    RecraftIO.CONTROLS,
-                    {
-                        "tooltip": "Optional additional controls over the generation via the Recraft Controls node."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        substyle: str,
-        size: str,
-        n: int,
-        seed,
-        negative_prompt: str = None,
-        recraft_controls: RecraftControls = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        validate_string(prompt, strip_whitespace=False, max_length=1000)
-        # create RecraftStyle so strings will be formatted properly (i.e. "None" will become None)
-        recraft_style = RecraftStyle(RecraftStyleV3.vector_illustration, substyle=substyle)
-
-        controls_api = None
-        if recraft_controls:
-            controls_api = recraft_controls.create_api_model()
-
-        if not negative_prompt:
-            negative_prompt = None
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/recraft/image_generation",
-                method=HttpMethod.POST,
-                request_model=RecraftImageGenerationRequest,
-                response_model=RecraftImageGenerationResponse,
-            ),
-            request=RecraftImageGenerationRequest(
-                prompt=prompt,
-                negative_prompt=negative_prompt,
-                model=RecraftModel.recraftv3,
-                size=size,
-                n=n,
-                style=recraft_style.style,
-                substyle=recraft_style.substyle,
-                controls=controls_api,
-            ),
-            auth_kwargs=kwargs,
-        )
-        response: RecraftImageGenerationResponse = operation.execute()
-        svg_data = []
-        urls = []
-        for data in response.data:
-            if unique_id and data.url:
-                urls.append(data.url)
-                # Print result on each iteration in case of error
-                PromptServer.instance.send_progress_text(
-                    f"Result URL: {' '.join(urls)}", unique_id
-                )
-            svg_data.append(download_url_to_bytesio(data.url, timeout=1024))
-
-        return (SVG(svg_data),)
-
-
-class RecraftVectorizeImageNode:
-    """
-    Generates SVG synchronously from an input image.
-    """
-
-    RETURN_TYPES = ("SVG",) # Changed
-    DESCRIPTION = cleandoc(__doc__ or "") if 'cleandoc' in globals() else __doc__ # Keep cleandoc if other nodes use it
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE, ),
-            },
-            "optional": {
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        **kwargs,
-    ):
-        svgs = []
-        total = image.shape[0]
-        pbar = ProgressBar(total)
-        for i in range(total):
-            sub_bytes = handle_recraft_file_request(
-                image=image[i],
-                path="/proxy/recraft/images/vectorize",
-                auth_kwargs=kwargs,
-            )
-            svgs.append(SVG(sub_bytes))
-            pbar.update(1)
-
-        return (SVG.combine_all(svgs), )
-
-
-class RecraftReplaceBackgroundNode:
-    """
-    Replace background on image, based on provided prompt.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE, ),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Prompt for the image generation.",
-                    },
-                ),
-                "n": (
-                    IO.INT,
-                    {
-                        "default": 1,
-                        "min": 1,
-                        "max": 6,
-                        "tooltip": "The number of images to generate.",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                        "tooltip": "Seed to determine if node should re-run; actual results are nondeterministic regardless of seed.",
-                    },
-                ),
-            },
-            "optional": {
-                "recraft_style": (RecraftIO.STYLEV3,),
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "An optional text description of undesired elements on an image.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        prompt: str,
-        n: int,
-        seed,
-        recraft_style: RecraftStyle = None,
-        negative_prompt: str = None,
-        **kwargs,
-    ):
-        default_style = RecraftStyle(RecraftStyleV3.realistic_image)
-        if recraft_style is None:
-            recraft_style = default_style
-
-        if not negative_prompt:
-            negative_prompt = None
-
-        request = RecraftImageGenerationRequest(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            model=RecraftModel.recraftv3,
-            n=n,
-            style=recraft_style.style,
-            substyle=recraft_style.substyle,
-            style_id=recraft_style.style_id,
-        )
-
-        images = []
-        total = image.shape[0]
-        pbar = ProgressBar(total)
-        for i in range(total):
-            sub_bytes = handle_recraft_file_request(
-                image=image[i],
-                path="/proxy/recraft/images/replaceBackground",
-                request=request,
-                auth_kwargs=kwargs,
-            )
-            images.append(torch.cat([bytesio_to_image_tensor(x) for x in sub_bytes], dim=0))
-            pbar.update(1)
-
-        images_tensor = torch.cat(images, dim=0)
-        return (images_tensor, )
-
-
-class RecraftRemoveBackgroundNode:
-    """
-    Remove background from image, and return processed image and mask.
-    """
-
-    RETURN_TYPES = (IO.IMAGE, IO.MASK)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE, ),
-            },
-            "optional": {
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        **kwargs,
-    ):
-        images = []
-        total = image.shape[0]
-        pbar = ProgressBar(total)
-        for i in range(total):
-            sub_bytes = handle_recraft_file_request(
-                image=image[i],
-                path="/proxy/recraft/images/removeBackground",
-                auth_kwargs=kwargs,
-            )
-            images.append(torch.cat([bytesio_to_image_tensor(x) for x in sub_bytes], dim=0))
-            pbar.update(1)
-
-        images_tensor = torch.cat(images, dim=0)
-        # use alpha channel as masks, in B,H,W format
-        masks_tensor = images_tensor[:,:,:,-1:].squeeze(-1)
-        return (images_tensor, masks_tensor)
-
-
-class RecraftCrispUpscaleNode:
-    """
-    Upscale image synchronously.
-    Enhances a given raster image using ‘crisp upscale’ tool, increasing image resolution, making the image sharper and cleaner.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    RECRAFT_PATH = "/proxy/recraft/images/crispUpscale"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE, ),
-            },
-            "optional": {
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        image: torch.Tensor,
-        **kwargs,
-    ):
-        images = []
-        total = image.shape[0]
-        pbar = ProgressBar(total)
-        for i in range(total):
-            sub_bytes = handle_recraft_file_request(
-                image=image[i],
-                path=self.RECRAFT_PATH,
-                auth_kwargs=kwargs,
-            )
-            images.append(torch.cat([bytesio_to_image_tensor(x) for x in sub_bytes], dim=0))
-            pbar.update(1)
-
-        images_tensor = torch.cat(images, dim=0)
-        return (images_tensor,)
-
-
-class RecraftCreativeUpscaleNode(RecraftCrispUpscaleNode):
-    """
-    Upscale image synchronously.
-    Enhances a given raster image using ‘creative upscale’ tool, boosting resolution with a focus on refining small details and faces.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Recraft"
-
-    RECRAFT_PATH = "/proxy/recraft/images/creativeUpscale"
-
-
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
-    "RecraftTextToImageNode": RecraftTextToImageNode,
-    "RecraftImageToImageNode": RecraftImageToImageNode,
-    "RecraftImageInpaintingNode": RecraftImageInpaintingNode,
-    "RecraftTextToVectorNode": RecraftTextToVectorNode,
-    "RecraftVectorizeImageNode": RecraftVectorizeImageNode,
-    "RecraftRemoveBackgroundNode": RecraftRemoveBackgroundNode,
-    "RecraftReplaceBackgroundNode": RecraftReplaceBackgroundNode,
-    "RecraftCrispUpscaleNode": RecraftCrispUpscaleNode,
-    "RecraftCreativeUpscaleNode": RecraftCreativeUpscaleNode,
-    "RecraftStyleV3RealisticImage": RecraftStyleV3RealisticImageNode,
-    "RecraftStyleV3DigitalIllustration": RecraftStyleV3DigitalIllustrationNode,
-    "RecraftStyleV3LogoRaster": RecraftStyleV3LogoRasterNode,
-    "RecraftStyleV3InfiniteStyleLibrary": RecraftStyleInfiniteStyleLibrary,
-    "RecraftColorRGB": RecraftColorRGBNode,
-    "RecraftControls": RecraftControlsNode,
-}
-
-# A dictionary that contains the friendly/humanly readable titles for the nodes
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "RecraftTextToImageNode": "Recraft Text to Image",
-    "RecraftImageToImageNode": "Recraft Image to Image",
-    "RecraftImageInpaintingNode": "Recraft Image Inpainting",
-    "RecraftTextToVectorNode": "Recraft Text to Vector",
-    "RecraftVectorizeImageNode": "Recraft Vectorize Image",
-    "RecraftRemoveBackgroundNode": "Recraft Remove Background",
-    "RecraftReplaceBackgroundNode": "Recraft Replace Background",
-    "RecraftCrispUpscaleNode": "Recraft Crisp Upscale Image",
-    "RecraftCreativeUpscaleNode": "Recraft Creative Upscale Image",
-    "RecraftStyleV3RealisticImage": "Recraft Style - Realistic Image",
-    "RecraftStyleV3DigitalIllustration": "Recraft Style - Digital Illustration",
-    "RecraftStyleV3LogoRaster": "Recraft Style - Logo Raster",
-    "RecraftStyleV3InfiniteStyleLibrary": "Recraft Style - Infinite Style Library",
-    "RecraftColorRGB": "Recraft Color RGB",
-    "RecraftControls": "Recraft Controls",
-}

comfy_api_nodes/nodes_rodin.py

@@ -1,462 +0,0 @@
-"""
-ComfyUI X Rodin3D(Deemos) API Nodes
-
-Rodin API docs: https://developer.hyper3d.ai/
-
-"""
-
-from __future__ import annotations
-from inspect import cleandoc
-from comfy.comfy_types.node_typing import IO
-import folder_paths as comfy_paths
-import requests
-import os
-import datetime
-import shutil
-import time
-import io
-import logging
-import math
-from PIL import Image
-from comfy_api_nodes.apis.rodin_api import (
-    Rodin3DGenerateRequest,
-    Rodin3DGenerateResponse,
-    Rodin3DCheckStatusRequest,
-    Rodin3DCheckStatusResponse,
-    Rodin3DDownloadRequest,
-    Rodin3DDownloadResponse,
-    JobStatus,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-)
-
-
-COMMON_PARAMETERS = {
-    "Seed": (
-        IO.INT,
-        {
-            "default":0,
-            "min":0,
-            "max":65535,
-            "display":"number"
-        }
-    ),
-    "Material_Type": (
-        IO.COMBO,
-        {
-            "options": ["PBR", "Shaded"],
-            "default": "PBR"
-        }
-    ),
-    "Polygon_count": (
-        IO.COMBO,
-        {
-            "options": ["4K-Quad", "8K-Quad", "18K-Quad", "50K-Quad", "200K-Triangle"],
-            "default": "18K-Quad"
-        }
-    )
-}
-
-def create_task_error(response: Rodin3DGenerateResponse):
-    """Check if the response has error"""
-    return hasattr(response, "error")
-
-
-
-class Rodin3DAPI:
-    """
-    Generate 3D Assets using Rodin API
-    """
-    RETURN_TYPES = (IO.STRING,)
-    RETURN_NAMES = ("3D Model Path",)
-    CATEGORY = "api node/3d/Rodin"
-    DESCRIPTION = cleandoc(__doc__ or "")
-    FUNCTION = "api_call"
-    API_NODE = True
-
-    def tensor_to_filelike(self, tensor, max_pixels: int = 2048*2048):
-        """
-        Converts a PyTorch tensor to a file-like object.
-
-        Args:
-        - tensor (torch.Tensor): A tensor representing an image of shape (H, W, C)
-          where C is the number of channels (3 for RGB), H is height, and W is width.
-
-        Returns:
-        - io.BytesIO: A file-like object containing the image data.
-        """
-        array = tensor.cpu().numpy()
-        array = (array * 255).astype('uint8')
-        image = Image.fromarray(array, 'RGB')
-
-        original_width, original_height = image.size
-        original_pixels = original_width * original_height
-        if original_pixels > max_pixels:
-            scale = math.sqrt(max_pixels / original_pixels)
-            new_width = int(original_width * scale)
-            new_height = int(original_height * scale)
-        else:
-            new_width, new_height = original_width, original_height
-
-        if new_width != original_width or new_height != original_height:
-            image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
-
-        img_byte_arr = io.BytesIO()
-        image.save(img_byte_arr, format='PNG')  # PNG is used for lossless compression
-        img_byte_arr.seek(0)
-        return img_byte_arr
-
-    def check_rodin_status(self, response: Rodin3DCheckStatusResponse) -> str:
-        has_failed = any(job.status == JobStatus.Failed for job in response.jobs)
-        all_done = all(job.status == JobStatus.Done for job in response.jobs)
-        status_list = [str(job.status) for job in response.jobs]
-        logging.info(f"[ Rodin3D API - CheckStatus ] Generate Status: {status_list}")
-        if has_failed:
-            logging.error(f"[ Rodin3D API - CheckStatus ] Generate Failed: {status_list}, Please try again.")
-            raise Exception("[ Rodin3D API ] Generate Failed, Please Try again.")
-        elif all_done:
-            return "DONE"
-        else:
-            return "Generating"
-
-    def CreateGenerateTask(self, images=None, seed=1, material="PBR", quality="medium", tier="Regular", mesh_mode="Quad", **kwargs):
-        if images == None:
-            raise Exception("Rodin 3D generate requires at least 1 image.")
-        if len(images) >= 5:
-            raise Exception("Rodin 3D generate requires up to 5 image.")
-
-        path = "/proxy/rodin/api/v2/rodin"
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=path,
-                method=HttpMethod.POST,
-                request_model=Rodin3DGenerateRequest,
-                response_model=Rodin3DGenerateResponse,
-            ),
-            request=Rodin3DGenerateRequest(
-                seed=seed,
-                tier=tier,
-                material=material,
-                quality=quality,
-                mesh_mode=mesh_mode
-            ),
-            files=[
-                (
-                    "images",
-                    open(image, "rb") if isinstance(image, str) else self.tensor_to_filelike(image)
-                )
-                for image in images if image is not None
-            ],
-            content_type = "multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-
-        response = operation.execute()
-
-        if create_task_error(response):
-            error_message = f"Rodin3D Create 3D generate Task Failed. Message: {response.message}, error: {response.error}"
-            logging.error(error_message)
-            raise Exception(error_message)
-
-        logging.info("[ Rodin3D API - Submit Jobs ] Submit Generate Task Success!")
-        subscription_key = response.jobs.subscription_key
-        task_uuid = response.uuid
-        logging.info(f"[ Rodin3D API - Submit Jobs ] UUID: {task_uuid}")
-        return task_uuid, subscription_key
-
-    def poll_for_task_status(self, subscription_key, **kwargs) -> Rodin3DCheckStatusResponse:
-
-        path = "/proxy/rodin/api/v2/status"
-
-        poll_operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path = path,
-                method=HttpMethod.POST,
-                request_model=Rodin3DCheckStatusRequest,
-                response_model=Rodin3DCheckStatusResponse,
-            ),
-            request=Rodin3DCheckStatusRequest(
-                subscription_key = subscription_key
-            ),
-            completed_statuses=["DONE"],
-            failed_statuses=["FAILED"],
-            status_extractor=self.check_rodin_status,
-            poll_interval=3.0,
-            auth_kwargs=kwargs,
-        )
-
-        logging.info("[ Rodin3D API - CheckStatus ] Generate Start!")
-
-        return poll_operation.execute()
-
-
-
-    def GetRodinDownloadList(self, uuid, **kwargs) -> Rodin3DDownloadResponse:
-        logging.info("[ Rodin3D API - Downloading ] Generate Successfully!")
-
-        path = "/proxy/rodin/api/v2/download"
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=path,
-                method=HttpMethod.POST,
-                request_model=Rodin3DDownloadRequest,
-                response_model=Rodin3DDownloadResponse,
-            ),
-            request=Rodin3DDownloadRequest(
-                task_uuid=uuid
-            ),
-            auth_kwargs=kwargs
-        )
-
-        return operation.execute()
-
-    def GetQualityAndMode(self, PolyCount):
-        if PolyCount == "200K-Triangle":
-            mesh_mode = "Raw"
-            quality = "medium"
-        else:
-            mesh_mode = "Quad"
-            if PolyCount == "4K-Quad":
-                quality = "extra-low"
-            elif PolyCount == "8K-Quad":
-                quality = "low"
-            elif PolyCount == "18K-Quad":
-                quality = "medium"
-            elif PolyCount == "50K-Quad":
-                quality = "high"
-            else:
-                quality = "medium"
-
-        return mesh_mode, quality
-
-    def DownLoadFiles(self, Url_List):
-        Save_path = os.path.join(comfy_paths.get_output_directory(), "Rodin3D", datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
-        os.makedirs(Save_path, exist_ok=True)
-        model_file_path = None
-        for Item in Url_List.list:
-            url = Item.url
-            file_name = Item.name
-            file_path = os.path.join(Save_path, file_name)
-            if file_path.endswith(".glb"):
-                model_file_path = file_path
-            logging.info(f"[ Rodin3D API - download_files ] Downloading file: {file_path}")
-            max_retries = 5
-            for attempt in range(max_retries):
-                try:
-                    with requests.get(url, stream=True) as r:
-                        r.raise_for_status()
-                        with open(file_path, "wb") as f:
-                            shutil.copyfileobj(r.raw, f)
-                    break
-                except Exception as e:
-                    logging.info(f"[ Rodin3D API - download_files ] Error downloading {file_path}:{e}")
-                    if attempt < max_retries - 1:
-                        logging.info("Retrying...")
-                        time.sleep(2)
-                    else:
-                        logging.info(f"[ Rodin3D API - download_files ] Failed to download {file_path} after {max_retries} attempts.")
-
-        return model_file_path
-
-
-class Rodin3D_Regular(Rodin3DAPI):
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "Images":
-                (
-                    IO.IMAGE,
-                    {
-                        "forceInput":True,
-                    }
-                )
-            },
-            "optional": {
-                **COMMON_PARAMETERS
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        Images,
-        Seed,
-        Material_Type,
-        Polygon_count,
-        **kwargs
-    ):
-        tier = "Regular"
-        num_images = Images.shape[0]
-        m_images = []
-        for i in range(num_images):
-            m_images.append(Images[i])
-        mesh_mode, quality = self.GetQualityAndMode(Polygon_count)
-        task_uuid, subscription_key = self.CreateGenerateTask(images=m_images, seed=Seed, material=Material_Type, quality=quality, tier=tier, mesh_mode=mesh_mode, **kwargs)
-        self.poll_for_task_status(subscription_key, **kwargs)
-        Download_List = self.GetRodinDownloadList(task_uuid, **kwargs)
-        model = self.DownLoadFiles(Download_List)
-
-        return (model,)
-
-class Rodin3D_Detail(Rodin3DAPI):
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "Images":
-                (
-                    IO.IMAGE,
-                    {
-                        "forceInput":True,
-                    }
-                )
-            },
-            "optional": {
-                **COMMON_PARAMETERS
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        Images,
-        Seed,
-        Material_Type,
-        Polygon_count,
-        **kwargs
-    ):
-        tier = "Detail"
-        num_images = Images.shape[0]
-        m_images = []
-        for i in range(num_images):
-            m_images.append(Images[i])
-        mesh_mode, quality = self.GetQualityAndMode(Polygon_count)
-        task_uuid, subscription_key = self.CreateGenerateTask(images=m_images, seed=Seed, material=Material_Type, quality=quality, tier=tier, mesh_mode=mesh_mode, **kwargs)
-        self.poll_for_task_status(subscription_key, **kwargs)
-        Download_List = self.GetRodinDownloadList(task_uuid, **kwargs)
-        model = self.DownLoadFiles(Download_List)
-
-        return (model,)
-
-class Rodin3D_Smooth(Rodin3DAPI):
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "Images":
-                (
-                    IO.IMAGE,
-                    {
-                        "forceInput":True,
-                    }
-                )
-            },
-            "optional": {
-                **COMMON_PARAMETERS
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        Images,
-        Seed,
-        Material_Type,
-        Polygon_count,
-        **kwargs
-    ):
-        tier = "Smooth"
-        num_images = Images.shape[0]
-        m_images = []
-        for i in range(num_images):
-            m_images.append(Images[i])
-        mesh_mode, quality = self.GetQualityAndMode(Polygon_count)
-        task_uuid, subscription_key = self.CreateGenerateTask(images=m_images, seed=Seed, material=Material_Type, quality=quality, tier=tier, mesh_mode=mesh_mode, **kwargs)
-        self.poll_for_task_status(subscription_key, **kwargs)
-        Download_List = self.GetRodinDownloadList(task_uuid, **kwargs)
-        model = self.DownLoadFiles(Download_List)
-
-        return (model,)
-
-class Rodin3D_Sketch(Rodin3DAPI):
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "Images":
-                (
-                    IO.IMAGE,
-                    {
-                        "forceInput":True,
-                    }
-                )
-            },
-            "optional": {
-                "Seed":
-                (
-                    IO.INT,
-                    {
-                        "default":0,
-                        "min":0,
-                        "max":65535,
-                        "display":"number"
-                    }
-                )
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        Images,
-        Seed,
-        **kwargs
-    ):
-        tier = "Sketch"
-        num_images = Images.shape[0]
-        m_images = []
-        for i in range(num_images):
-            m_images.append(Images[i])
-        material_type = "PBR"
-        quality = "medium"
-        mesh_mode = "Quad"
-        task_uuid, subscription_key = self.CreateGenerateTask(images=m_images, seed=Seed, material=material_type, quality=quality, tier=tier, mesh_mode=mesh_mode, **kwargs)
-        self.poll_for_task_status(subscription_key, **kwargs)
-        Download_List = self.GetRodinDownloadList(task_uuid, **kwargs)
-        model = self.DownLoadFiles(Download_List)
-
-        return (model,)
-
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
-    "Rodin3D_Regular": Rodin3D_Regular,
-    "Rodin3D_Detail": Rodin3D_Detail,
-    "Rodin3D_Smooth": Rodin3D_Smooth,
-    "Rodin3D_Sketch": Rodin3D_Sketch,
-}
-
-# A dictionary that contains the friendly/humanly readable titles for the nodes
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "Rodin3D_Regular": "Rodin 3D Generate - Regular Generate",
-    "Rodin3D_Detail": "Rodin 3D Generate - Detail Generate",
-    "Rodin3D_Smooth": "Rodin 3D Generate - Smooth Generate",
-    "Rodin3D_Sketch": "Rodin 3D Generate - Sketch Generate",
-}

comfy_api_nodes/nodes_runway.py

@@ -1,635 +0,0 @@
-"""Runway API Nodes
-
-API Docs:
-  - https://docs.dev.runwayml.com/api/#tag/Task-management/paths/~1v1~1tasks~1%7Bid%7D/delete
-
-User Guides:
-  - https://help.runwayml.com/hc/en-us/sections/30265301423635-Gen-3-Alpha
-  - https://help.runwayml.com/hc/en-us/articles/37327109429011-Creating-with-Gen-4-Video
-  - https://help.runwayml.com/hc/en-us/articles/33927968552339-Creating-with-Act-One-on-Gen-3-Alpha-and-Turbo
-  - https://help.runwayml.com/hc/en-us/articles/34170748696595-Creating-with-Keyframes-on-Gen-3
-
-"""
-
-from typing import Union, Optional, Any
-from enum import Enum
-
-import torch
-
-from comfy_api_nodes.apis import (
-    RunwayImageToVideoRequest,
-    RunwayImageToVideoResponse,
-    RunwayTaskStatusResponse as TaskStatusResponse,
-    RunwayTaskStatusEnum as TaskStatus,
-    RunwayModelEnum as Model,
-    RunwayDurationEnum as Duration,
-    RunwayAspectRatioEnum as AspectRatio,
-    RunwayPromptImageObject,
-    RunwayPromptImageDetailedObject,
-    RunwayTextToImageRequest,
-    RunwayTextToImageResponse,
-    Model4,
-    ReferenceImage,
-    RunwayTextToImageAspectRatioEnum,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    upload_images_to_comfyapi,
-    download_url_to_video_output,
-    image_tensor_pair_to_batch,
-    validate_string,
-    download_url_to_image_tensor,
-)
-from comfy_api_nodes.mapper_utils import model_field_to_node_input
-from comfy_api.input_impl import VideoFromFile
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC
-
-PATH_IMAGE_TO_VIDEO = "/proxy/runway/image_to_video"
-PATH_TEXT_TO_IMAGE = "/proxy/runway/text_to_image"
-PATH_GET_TASK_STATUS = "/proxy/runway/tasks"
-
-AVERAGE_DURATION_I2V_SECONDS = 64
-AVERAGE_DURATION_FLF_SECONDS = 256
-AVERAGE_DURATION_T2I_SECONDS = 41
-
-
-class RunwayApiError(Exception):
-    """Base exception for Runway API errors."""
-
-    pass
-
-
-class RunwayGen4TurboAspectRatio(str, Enum):
-    """Aspect ratios supported for Image to Video API when using gen4_turbo model."""
-
-    field_1280_720 = "1280:720"
-    field_720_1280 = "720:1280"
-    field_1104_832 = "1104:832"
-    field_832_1104 = "832:1104"
-    field_960_960 = "960:960"
-    field_1584_672 = "1584:672"
-
-
-class RunwayGen3aAspectRatio(str, Enum):
-    """Aspect ratios supported for Image to Video API when using gen3a_turbo model."""
-
-    field_768_1280 = "768:1280"
-    field_1280_768 = "1280:768"
-
-
-def get_video_url_from_task_status(response: TaskStatusResponse) -> Union[str, None]:
-    """Returns the video URL from the task status response if it exists."""
-    if response.output and len(response.output) > 0:
-        return response.output[0]
-    return None
-
-
-# TODO: replace with updated image validation utils (upstream)
-def validate_input_image(image: torch.Tensor) -> bool:
-    """
-    Validate the input image is within the size limits for the Runway API.
-    See: https://docs.dev.runwayml.com/assets/inputs/#common-error-reasons
-    """
-    return image.shape[2] < 8000 and image.shape[1] < 8000
-
-
-def poll_until_finished(
-    auth_kwargs: dict[str, str],
-    api_endpoint: ApiEndpoint[Any, TaskStatusResponse],
-    estimated_duration: Optional[int] = None,
-    node_id: Optional[str] = None,
-) -> TaskStatusResponse:
-    """Polls the Runway API endpoint until the task reaches a terminal state, then returns the response."""
-    return PollingOperation(
-        poll_endpoint=api_endpoint,
-        completed_statuses=[
-            TaskStatus.SUCCEEDED.value,
-        ],
-        failed_statuses=[
-            TaskStatus.FAILED.value,
-            TaskStatus.CANCELLED.value,
-        ],
-        status_extractor=lambda response: (response.status.value),
-        auth_kwargs=auth_kwargs,
-        result_url_extractor=get_video_url_from_task_status,
-        estimated_duration=estimated_duration,
-        node_id=node_id,
-        progress_extractor=extract_progress_from_task_status,
-    ).execute()
-
-
-def extract_progress_from_task_status(
-    response: TaskStatusResponse,
-) -> Union[float, None]:
-    if hasattr(response, "progress") and response.progress is not None:
-        return response.progress * 100
-    return None
-
-
-def get_image_url_from_task_status(response: TaskStatusResponse) -> Union[str, None]:
-    """Returns the image URL from the task status response if it exists."""
-    if response.output and len(response.output) > 0:
-        return response.output[0]
-    return None
-
-
-class RunwayVideoGenNode(ComfyNodeABC):
-    """Runway Video Node Base."""
-
-    RETURN_TYPES = ("VIDEO",)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/video/Runway"
-    API_NODE = True
-
-    def validate_task_created(self, response: RunwayImageToVideoResponse) -> bool:
-        """
-        Validate the task creation response from the Runway API matches
-        expected format.
-        """
-        if not bool(response.id):
-            raise RunwayApiError("Invalid initial response from Runway API.")
-        return True
-
-    def validate_response(self, response: RunwayImageToVideoResponse) -> bool:
-        """
-        Validate the successful task status response from the Runway API
-        matches expected format.
-        """
-        if not response.output or len(response.output) == 0:
-            raise RunwayApiError(
-                "Runway task succeeded but no video data found in response."
-            )
-        return True
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> RunwayImageToVideoResponse:
-        """Poll the task status until it is finished then get the response."""
-        return poll_until_finished(
-            auth_kwargs,
-            ApiEndpoint(
-                path=f"{PATH_GET_TASK_STATUS}/{task_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=TaskStatusResponse,
-            ),
-            estimated_duration=AVERAGE_DURATION_FLF_SECONDS,
-            node_id=node_id,
-        )
-
-    def generate_video(
-        self,
-        request: RunwayImageToVideoRequest,
-        auth_kwargs: dict[str, str],
-        node_id: Optional[str] = None,
-    ) -> tuple[VideoFromFile]:
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_IMAGE_TO_VIDEO,
-                method=HttpMethod.POST,
-                request_model=RunwayImageToVideoRequest,
-                response_model=RunwayImageToVideoResponse,
-            ),
-            request=request,
-            auth_kwargs=auth_kwargs,
-        )
-
-        initial_response = initial_operation.execute()
-        self.validate_task_created(initial_response)
-        task_id = initial_response.id
-
-        final_response = self.get_response(task_id, auth_kwargs, node_id)
-        self.validate_response(final_response)
-
-        video_url = get_video_url_from_task_status(final_response)
-        return (download_url_to_video_output(video_url),)
-
-
-class RunwayImageToVideoNodeGen3a(RunwayVideoGenNode):
-    """Runway Image to Video Node using Gen3a Turbo model."""
-
-    DESCRIPTION = "Generate a video from a single starting frame using Gen3a Turbo model. Before diving in, review these best practices to ensure that your input selections will set your generation up for success: https://help.runwayml.com/hc/en-us/articles/33927968552339-Creating-with-Act-One-on-Gen-3-Alpha-and-Turbo."
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": model_field_to_node_input(
-                    IO.STRING, RunwayImageToVideoRequest, "promptText", multiline=True
-                ),
-                "start_frame": (
-                    IO.IMAGE,
-                    {"tooltip": "Start frame to be used for the video"},
-                ),
-                "duration": model_field_to_node_input(
-                    IO.COMBO, RunwayImageToVideoRequest, "duration", enum_type=Duration
-                ),
-                "ratio": model_field_to_node_input(
-                    IO.COMBO,
-                    RunwayImageToVideoRequest,
-                    "ratio",
-                    enum_type=RunwayGen3aAspectRatio,
-                ),
-                "seed": model_field_to_node_input(
-                    IO.INT,
-                    RunwayImageToVideoRequest,
-                    "seed",
-                    control_after_generate=True,
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        start_frame: torch.Tensor,
-        duration: str,
-        ratio: str,
-        seed: int,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-        # Validate inputs
-        validate_string(prompt, min_length=1)
-        validate_input_image(start_frame)
-
-        # Upload image
-        download_urls = upload_images_to_comfyapi(
-            start_frame,
-            max_images=1,
-            mime_type="image/png",
-            auth_kwargs=kwargs,
-        )
-        if len(download_urls) != 1:
-            raise RunwayApiError("Failed to upload one or more images to comfy api.")
-
-        return self.generate_video(
-            RunwayImageToVideoRequest(
-                promptText=prompt,
-                seed=seed,
-                model=Model("gen3a_turbo"),
-                duration=Duration(duration),
-                ratio=AspectRatio(ratio),
-                promptImage=RunwayPromptImageObject(
-                    root=[
-                        RunwayPromptImageDetailedObject(
-                            uri=str(download_urls[0]), position="first"
-                        )
-                    ]
-                ),
-            ),
-            auth_kwargs=kwargs,
-            node_id=unique_id,
-        )
-
-
-class RunwayImageToVideoNodeGen4(RunwayVideoGenNode):
-    """Runway Image to Video Node using Gen4 Turbo model."""
-
-    DESCRIPTION = "Generate a video from a single starting frame using Gen4 Turbo model. Before diving in, review these best practices to ensure that your input selections will set your generation up for success: https://help.runwayml.com/hc/en-us/articles/37327109429011-Creating-with-Gen-4-Video."
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": model_field_to_node_input(
-                    IO.STRING, RunwayImageToVideoRequest, "promptText", multiline=True
-                ),
-                "start_frame": (
-                    IO.IMAGE,
-                    {"tooltip": "Start frame to be used for the video"},
-                ),
-                "duration": model_field_to_node_input(
-                    IO.COMBO, RunwayImageToVideoRequest, "duration", enum_type=Duration
-                ),
-                "ratio": model_field_to_node_input(
-                    IO.COMBO,
-                    RunwayImageToVideoRequest,
-                    "ratio",
-                    enum_type=RunwayGen4TurboAspectRatio,
-                ),
-                "seed": model_field_to_node_input(
-                    IO.INT,
-                    RunwayImageToVideoRequest,
-                    "seed",
-                    control_after_generate=True,
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        start_frame: torch.Tensor,
-        duration: str,
-        ratio: str,
-        seed: int,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-        # Validate inputs
-        validate_string(prompt, min_length=1)
-        validate_input_image(start_frame)
-
-        # Upload image
-        download_urls = upload_images_to_comfyapi(
-            start_frame,
-            max_images=1,
-            mime_type="image/png",
-            auth_kwargs=kwargs,
-        )
-        if len(download_urls) != 1:
-            raise RunwayApiError("Failed to upload one or more images to comfy api.")
-
-        return self.generate_video(
-            RunwayImageToVideoRequest(
-                promptText=prompt,
-                seed=seed,
-                model=Model("gen4_turbo"),
-                duration=Duration(duration),
-                ratio=AspectRatio(ratio),
-                promptImage=RunwayPromptImageObject(
-                    root=[
-                        RunwayPromptImageDetailedObject(
-                            uri=str(download_urls[0]), position="first"
-                        )
-                    ]
-                ),
-            ),
-            auth_kwargs=kwargs,
-            node_id=unique_id,
-        )
-
-
-class RunwayFirstLastFrameNode(RunwayVideoGenNode):
-    """Runway First-Last Frame Node."""
-
-    DESCRIPTION = "Upload first and last keyframes, draft a prompt, and generate a video. More complex transitions, such as cases where the Last frame is completely different from the First frame, may benefit from the longer 10s duration. This would give the generation more time to smoothly transition between the two inputs. Before diving in, review these best practices to ensure that your input selections will set your generation up for success: https://help.runwayml.com/hc/en-us/articles/34170748696595-Creating-with-Keyframes-on-Gen-3."
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> RunwayImageToVideoResponse:
-        return poll_until_finished(
-            auth_kwargs,
-            ApiEndpoint(
-                path=f"{PATH_GET_TASK_STATUS}/{task_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=TaskStatusResponse,
-            ),
-            estimated_duration=AVERAGE_DURATION_FLF_SECONDS,
-            node_id=node_id,
-        )
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": model_field_to_node_input(
-                    IO.STRING, RunwayImageToVideoRequest, "promptText", multiline=True
-                ),
-                "start_frame": (
-                    IO.IMAGE,
-                    {"tooltip": "Start frame to be used for the video"},
-                ),
-                "end_frame": (
-                    IO.IMAGE,
-                    {
-                        "tooltip": "End frame to be used for the video. Supported for gen3a_turbo only."
-                    },
-                ),
-                "duration": model_field_to_node_input(
-                    IO.COMBO, RunwayImageToVideoRequest, "duration", enum_type=Duration
-                ),
-                "ratio": model_field_to_node_input(
-                    IO.COMBO,
-                    RunwayImageToVideoRequest,
-                    "ratio",
-                    enum_type=RunwayGen3aAspectRatio,
-                ),
-                "seed": model_field_to_node_input(
-                    IO.INT,
-                    RunwayImageToVideoRequest,
-                    "seed",
-                    control_after_generate=True,
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(
-        self,
-        prompt: str,
-        start_frame: torch.Tensor,
-        end_frame: torch.Tensor,
-        duration: str,
-        ratio: str,
-        seed: int,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ) -> tuple[VideoFromFile]:
-        # Validate inputs
-        validate_string(prompt, min_length=1)
-        validate_input_image(start_frame)
-        validate_input_image(end_frame)
-
-        # Upload images
-        stacked_input_images = image_tensor_pair_to_batch(start_frame, end_frame)
-        download_urls = upload_images_to_comfyapi(
-            stacked_input_images,
-            max_images=2,
-            mime_type="image/png",
-            auth_kwargs=kwargs,
-        )
-        if len(download_urls) != 2:
-            raise RunwayApiError("Failed to upload one or more images to comfy api.")
-
-        return self.generate_video(
-            RunwayImageToVideoRequest(
-                promptText=prompt,
-                seed=seed,
-                model=Model("gen3a_turbo"),
-                duration=Duration(duration),
-                ratio=AspectRatio(ratio),
-                promptImage=RunwayPromptImageObject(
-                    root=[
-                        RunwayPromptImageDetailedObject(
-                            uri=str(download_urls[0]), position="first"
-                        ),
-                        RunwayPromptImageDetailedObject(
-                            uri=str(download_urls[1]), position="last"
-                        ),
-                    ]
-                ),
-            ),
-            auth_kwargs=kwargs,
-            node_id=unique_id,
-        )
-
-
-class RunwayTextToImageNode(ComfyNodeABC):
-    """Runway Text to Image Node."""
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "api_call"
-    CATEGORY = "api node/image/Runway"
-    API_NODE = True
-    DESCRIPTION = "Generate an image from a text prompt using Runway's Gen 4 model. You can also include reference images to guide the generation."
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": model_field_to_node_input(
-                    IO.STRING, RunwayTextToImageRequest, "promptText", multiline=True
-                ),
-                "ratio": model_field_to_node_input(
-                    IO.COMBO,
-                    RunwayTextToImageRequest,
-                    "ratio",
-                    enum_type=RunwayTextToImageAspectRatioEnum,
-                ),
-            },
-            "optional": {
-                "reference_image": (
-                    IO.IMAGE,
-                    {"tooltip": "Optional reference image to guide the generation"},
-                )
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    def validate_task_created(self, response: RunwayTextToImageResponse) -> bool:
-        """
-        Validate the task creation response from the Runway API matches
-        expected format.
-        """
-        if not bool(response.id):
-            raise RunwayApiError("Invalid initial response from Runway API.")
-        return True
-
-    def validate_response(self, response: TaskStatusResponse) -> bool:
-        """
-        Validate the successful task status response from the Runway API
-        matches expected format.
-        """
-        if not response.output or len(response.output) == 0:
-            raise RunwayApiError(
-                "Runway task succeeded but no image data found in response."
-            )
-        return True
-
-    def get_response(
-        self, task_id: str, auth_kwargs: dict[str, str], node_id: Optional[str] = None
-    ) -> TaskStatusResponse:
-        """Poll the task status until it is finished then get the response."""
-        return poll_until_finished(
-            auth_kwargs,
-            ApiEndpoint(
-                path=f"{PATH_GET_TASK_STATUS}/{task_id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=TaskStatusResponse,
-            ),
-            estimated_duration=AVERAGE_DURATION_T2I_SECONDS,
-            node_id=node_id,
-        )
-
-    def api_call(
-        self,
-        prompt: str,
-        ratio: str,
-        reference_image: Optional[torch.Tensor] = None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ) -> tuple[torch.Tensor]:
-        # Validate inputs
-        validate_string(prompt, min_length=1)
-
-        # Prepare reference images if provided
-        reference_images = None
-        if reference_image is not None:
-            validate_input_image(reference_image)
-            download_urls = upload_images_to_comfyapi(
-                reference_image,
-                max_images=1,
-                mime_type="image/png",
-                auth_kwargs=kwargs,
-            )
-            if len(download_urls) != 1:
-                raise RunwayApiError("Failed to upload reference image to comfy api.")
-
-            reference_images = [ReferenceImage(uri=str(download_urls[0]))]
-
-        # Create request
-        request = RunwayTextToImageRequest(
-            promptText=prompt,
-            model=Model4.gen4_image,
-            ratio=ratio,
-            referenceImages=reference_images,
-        )
-
-        # Execute initial request
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path=PATH_TEXT_TO_IMAGE,
-                method=HttpMethod.POST,
-                request_model=RunwayTextToImageRequest,
-                response_model=RunwayTextToImageResponse,
-            ),
-            request=request,
-            auth_kwargs=kwargs,
-        )
-
-        initial_response = initial_operation.execute()
-        self.validate_task_created(initial_response)
-        task_id = initial_response.id
-
-        # Poll for completion
-        final_response = self.get_response(
-            task_id, auth_kwargs=kwargs, node_id=unique_id
-        )
-        self.validate_response(final_response)
-
-        # Download and return image
-        image_url = get_image_url_from_task_status(final_response)
-        return (download_url_to_image_tensor(image_url),)
-
-
-NODE_CLASS_MAPPINGS = {
-    "RunwayFirstLastFrameNode": RunwayFirstLastFrameNode,
-    "RunwayImageToVideoNodeGen3a": RunwayImageToVideoNodeGen3a,
-    "RunwayImageToVideoNodeGen4": RunwayImageToVideoNodeGen4,
-    "RunwayTextToImageNode": RunwayTextToImageNode,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "RunwayFirstLastFrameNode": "Runway First-Last-Frame to Video",
-    "RunwayImageToVideoNodeGen3a": "Runway Image to Video (Gen3a Turbo)",
-    "RunwayImageToVideoNodeGen4": "Runway Image to Video (Gen4 Turbo)",
-    "RunwayTextToImageNode": "Runway Text to Image",
-}

comfy_api_nodes/nodes_stability.py

@@ -1,614 +0,0 @@
-from inspect import cleandoc
-from comfy.comfy_types.node_typing import IO
-from comfy_api_nodes.apis.stability_api import (
-    StabilityUpscaleConservativeRequest,
-    StabilityUpscaleCreativeRequest,
-    StabilityAsyncResponse,
-    StabilityResultsGetResponse,
-    StabilityStable3_5Request,
-    StabilityStableUltraRequest,
-    StabilityStableUltraResponse,
-    StabilityAspectRatio,
-    Stability_SD3_5_Model,
-    Stability_SD3_5_GenerationMode,
-    get_stability_style_presets,
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    bytesio_to_image_tensor,
-    tensor_to_bytesio,
-    validate_string,
-)
-
-import torch
-import base64
-from io import BytesIO
-from enum import Enum
-
-
-class StabilityPollStatus(str, Enum):
-    finished = "finished"
-    in_progress = "in_progress"
-    failed = "failed"
-
-
-def get_async_dummy_status(x: StabilityResultsGetResponse):
-    if x.name is not None or x.errors is not None:
-        return StabilityPollStatus.failed
-    elif x.finish_reason is not None:
-        return StabilityPollStatus.finished
-    return StabilityPollStatus.in_progress
-
-
-class StabilityStableImageUltraNode:
-    """
-    Generates images synchronously based on prompt and resolution.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Stability AI"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "What you wish to see in the output image. A strong, descriptive prompt that clearly defines" +
-                                    "What you wish to see in the output image. A strong, descriptive prompt that clearly defines" +
-                                    "elements, colors, and subjects will lead to better results. " +
-                                    "To control the weight of a given word use the format `(word:weight)`," +
-                                    "where `word` is the word you'd like to control the weight of and `weight`" +
-                                    "is a value between 0 and 1. For example: `The sky was a crisp (blue:0.3) and (green:0.8)`" +
-                                    "would convey a sky that was blue and green, but more green than blue."
-                    },
-                ),
-                "aspect_ratio": ([x.value for x in StabilityAspectRatio],
-                    {
-                        "default": StabilityAspectRatio.ratio_1_1,
-                        "tooltip": "Aspect ratio of generated image.",
-                    },
-                ),
-                "style_preset": (get_stability_style_presets(),
-                    {
-                        "tooltip": "Optional desired style of generated image.",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 4294967294,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {
-                "image": (IO.IMAGE,),
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "A blurb of text describing what you do not wish to see in the output image. This is an advanced feature."
-                    },
-                ),
-                "image_denoise": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.5,
-                        "min": 0.0,
-                        "max": 1.0,
-                        "step": 0.01,
-                        "tooltip": "Denoise of input image; 0.0 yields image identical to input, 1.0 is as if no image was provided at all.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(self, prompt: str, aspect_ratio: str, style_preset: str, seed: int,
-                 negative_prompt: str=None, image: torch.Tensor = None, image_denoise: float=None,
-                 **kwargs):
-        validate_string(prompt, strip_whitespace=False)
-        # prepare image binary if image present
-        image_binary = None
-        if image is not None:
-            image_binary = tensor_to_bytesio(image, total_pixels=1504*1504).read()
-        else:
-            image_denoise = None
-
-        if not negative_prompt:
-            negative_prompt = None
-        if style_preset == "None":
-            style_preset = None
-
-        files = {
-            "image": image_binary
-        }
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/stability/v2beta/stable-image/generate/ultra",
-                method=HttpMethod.POST,
-                request_model=StabilityStableUltraRequest,
-                response_model=StabilityStableUltraResponse,
-            ),
-            request=StabilityStableUltraRequest(
-                prompt=prompt,
-                negative_prompt=negative_prompt,
-                aspect_ratio=aspect_ratio,
-                seed=seed,
-                strength=image_denoise,
-                style_preset=style_preset,
-            ),
-            files=files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-        response_api = operation.execute()
-
-        if response_api.finish_reason != "SUCCESS":
-            raise Exception(f"Stable Image Ultra generation failed: {response_api.finish_reason}.")
-
-        image_data = base64.b64decode(response_api.image)
-        returned_image = bytesio_to_image_tensor(BytesIO(image_data))
-
-        return (returned_image,)
-
-
-class StabilityStableImageSD_3_5Node:
-    """
-    Generates images synchronously based on prompt and resolution.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Stability AI"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "What you wish to see in the output image. A strong, descriptive prompt that clearly defines elements, colors, and subjects will lead to better results."
-                    },
-                ),
-                "model": ([x.value for x in Stability_SD3_5_Model],),
-                "aspect_ratio": ([x.value for x in StabilityAspectRatio],
-                    {
-                        "default": StabilityAspectRatio.ratio_1_1,
-                        "tooltip": "Aspect ratio of generated image.",
-                    },
-                ),
-                "style_preset": (get_stability_style_presets(),
-                    {
-                        "tooltip": "Optional desired style of generated image.",
-                    },
-                ),
-                "cfg_scale": (
-                    IO.FLOAT,
-                    {
-                        "default": 4.0,
-                        "min": 1.0,
-                        "max": 10.0,
-                        "step": 0.1,
-                        "tooltip": "How strictly the diffusion process adheres to the prompt text (higher values keep your image closer to your prompt)",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 4294967294,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {
-                "image": (IO.IMAGE,),
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "Keywords of what you do not wish to see in the output image. This is an advanced feature."
-                    },
-                ),
-                "image_denoise": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.5,
-                        "min": 0.0,
-                        "max": 1.0,
-                        "step": 0.01,
-                        "tooltip": "Denoise of input image; 0.0 yields image identical to input, 1.0 is as if no image was provided at all.",
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(self, model: str, prompt: str, aspect_ratio: str, style_preset: str, seed: int, cfg_scale: float,
-                 negative_prompt: str=None, image: torch.Tensor = None, image_denoise: float=None,
-                 **kwargs):
-        validate_string(prompt, strip_whitespace=False)
-        # prepare image binary if image present
-        image_binary = None
-        mode = Stability_SD3_5_GenerationMode.text_to_image
-        if image is not None:
-            image_binary = tensor_to_bytesio(image, total_pixels=1504*1504).read()
-            mode = Stability_SD3_5_GenerationMode.image_to_image
-            aspect_ratio = None
-        else:
-            image_denoise = None
-
-        if not negative_prompt:
-            negative_prompt = None
-        if style_preset == "None":
-            style_preset = None
-
-        files = {
-            "image": image_binary
-        }
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/stability/v2beta/stable-image/generate/sd3",
-                method=HttpMethod.POST,
-                request_model=StabilityStable3_5Request,
-                response_model=StabilityStableUltraResponse,
-            ),
-            request=StabilityStable3_5Request(
-                prompt=prompt,
-                negative_prompt=negative_prompt,
-                aspect_ratio=aspect_ratio,
-                seed=seed,
-                strength=image_denoise,
-                style_preset=style_preset,
-                cfg_scale=cfg_scale,
-                model=model,
-                mode=mode,
-            ),
-            files=files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-        response_api = operation.execute()
-
-        if response_api.finish_reason != "SUCCESS":
-            raise Exception(f"Stable Diffusion 3.5 Image generation failed: {response_api.finish_reason}.")
-
-        image_data = base64.b64decode(response_api.image)
-        returned_image = bytesio_to_image_tensor(BytesIO(image_data))
-
-        return (returned_image,)
-
-
-class StabilityUpscaleConservativeNode:
-    """
-    Upscale image with minimal alterations to 4K resolution.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Stability AI"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "What you wish to see in the output image. A strong, descriptive prompt that clearly defines elements, colors, and subjects will lead to better results."
-                    },
-                ),
-                "creativity": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.35,
-                        "min": 0.2,
-                        "max": 0.5,
-                        "step": 0.01,
-                        "tooltip": "Controls the likelihood of creating additional details not heavily conditioned by the init image.",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 4294967294,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "Keywords of what you do not wish to see in the output image. This is an advanced feature."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(self, image: torch.Tensor, prompt: str, creativity: float, seed: int, negative_prompt: str=None,
-                 **kwargs):
-        validate_string(prompt, strip_whitespace=False)
-        image_binary = tensor_to_bytesio(image, total_pixels=1024*1024).read()
-
-        if not negative_prompt:
-            negative_prompt = None
-
-        files = {
-            "image": image_binary
-        }
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/stability/v2beta/stable-image/upscale/conservative",
-                method=HttpMethod.POST,
-                request_model=StabilityUpscaleConservativeRequest,
-                response_model=StabilityStableUltraResponse,
-            ),
-            request=StabilityUpscaleConservativeRequest(
-                prompt=prompt,
-                negative_prompt=negative_prompt,
-                creativity=round(creativity,2),
-                seed=seed,
-            ),
-            files=files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-        response_api = operation.execute()
-
-        if response_api.finish_reason != "SUCCESS":
-            raise Exception(f"Stability Upscale Conservative generation failed: {response_api.finish_reason}.")
-
-        image_data = base64.b64decode(response_api.image)
-        returned_image = bytesio_to_image_tensor(BytesIO(image_data))
-
-        return (returned_image,)
-
-
-class StabilityUpscaleCreativeNode:
-    """
-    Upscale image with minimal alterations to 4K resolution.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Stability AI"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE,),
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "What you wish to see in the output image. A strong, descriptive prompt that clearly defines elements, colors, and subjects will lead to better results."
-                    },
-                ),
-                "creativity": (
-                    IO.FLOAT,
-                    {
-                        "default": 0.3,
-                        "min": 0.1,
-                        "max": 0.5,
-                        "step": 0.01,
-                        "tooltip": "Controls the likelihood of creating additional details not heavily conditioned by the init image.",
-                    },
-                ),
-                "style_preset": (get_stability_style_presets(),
-                    {
-                        "tooltip": "Optional desired style of generated image.",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 4294967294,
-                        "control_after_generate": True,
-                        "tooltip": "The random seed used for creating the noise.",
-                    },
-                ),
-            },
-            "optional": {
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "default": "",
-                        "forceInput": True,
-                        "tooltip": "Keywords of what you do not wish to see in the output image. This is an advanced feature."
-                    },
-                ),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(self, image: torch.Tensor, prompt: str, creativity: float, style_preset: str, seed: int, negative_prompt: str=None,
-                 **kwargs):
-        validate_string(prompt, strip_whitespace=False)
-        image_binary = tensor_to_bytesio(image, total_pixels=1024*1024).read()
-
-        if not negative_prompt:
-            negative_prompt = None
-        if style_preset == "None":
-            style_preset = None
-
-        files = {
-            "image": image_binary
-        }
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/stability/v2beta/stable-image/upscale/creative",
-                method=HttpMethod.POST,
-                request_model=StabilityUpscaleCreativeRequest,
-                response_model=StabilityAsyncResponse,
-            ),
-            request=StabilityUpscaleCreativeRequest(
-                prompt=prompt,
-                negative_prompt=negative_prompt,
-                creativity=round(creativity,2),
-                style_preset=style_preset,
-                seed=seed,
-            ),
-            files=files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-        response_api = operation.execute()
-
-        operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path=f"/proxy/stability/v2beta/results/{response_api.id}",
-                method=HttpMethod.GET,
-                request_model=EmptyRequest,
-                response_model=StabilityResultsGetResponse,
-            ),
-            poll_interval=3,
-            completed_statuses=[StabilityPollStatus.finished],
-            failed_statuses=[StabilityPollStatus.failed],
-            status_extractor=lambda x: get_async_dummy_status(x),
-            auth_kwargs=kwargs,
-        )
-        response_poll: StabilityResultsGetResponse = operation.execute()
-
-        if response_poll.finish_reason != "SUCCESS":
-            raise Exception(f"Stability Upscale Creative generation failed: {response_poll.finish_reason}.")
-
-        image_data = base64.b64decode(response_poll.result)
-        returned_image = bytesio_to_image_tensor(BytesIO(image_data))
-
-        return (returned_image,)
-
-
-class StabilityUpscaleFastNode:
-    """
-    Quickly upscales an image via Stability API call to 4x its original size; intended for upscaling low-quality/compressed images.
-    """
-
-    RETURN_TYPES = (IO.IMAGE,)
-    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
-    FUNCTION = "api_call"
-    API_NODE = True
-    CATEGORY = "api node/image/Stability AI"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": (IO.IMAGE,),
-            },
-            "optional": {
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-            },
-        }
-
-    def api_call(self, image: torch.Tensor,
-                 **kwargs):
-        image_binary = tensor_to_bytesio(image, total_pixels=4096*4096).read()
-
-        files = {
-            "image": image_binary
-        }
-
-        operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/stability/v2beta/stable-image/upscale/fast",
-                method=HttpMethod.POST,
-                request_model=EmptyRequest,
-                response_model=StabilityStableUltraResponse,
-            ),
-            request=EmptyRequest(),
-            files=files,
-            content_type="multipart/form-data",
-            auth_kwargs=kwargs,
-        )
-        response_api = operation.execute()
-
-        if response_api.finish_reason != "SUCCESS":
-            raise Exception(f"Stability Upscale Fast failed: {response_api.finish_reason}.")
-
-        image_data = base64.b64decode(response_api.image)
-        returned_image = bytesio_to_image_tensor(BytesIO(image_data))
-
-        return (returned_image,)
-
-
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
-    "StabilityStableImageUltraNode": StabilityStableImageUltraNode,
-    "StabilityStableImageSD_3_5Node": StabilityStableImageSD_3_5Node,
-    "StabilityUpscaleConservativeNode": StabilityUpscaleConservativeNode,
-    "StabilityUpscaleCreativeNode": StabilityUpscaleCreativeNode,
-    "StabilityUpscaleFastNode": StabilityUpscaleFastNode,
-}
-
-# A dictionary that contains the friendly/humanly readable titles for the nodes
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "StabilityStableImageUltraNode": "Stability AI Stable Image Ultra",
-    "StabilityStableImageSD_3_5Node": "Stability AI Stable Diffusion 3.5 Image",
-    "StabilityUpscaleConservativeNode": "Stability AI Upscale Conservative",
-    "StabilityUpscaleCreativeNode": "Stability AI Upscale Creative",
-    "StabilityUpscaleFastNode": "Stability AI Upscale Fast",
-}

comfy_api_nodes/nodes_tripo.py

@@ -1,574 +0,0 @@
-import os
-from folder_paths import get_output_directory
-from comfy_api_nodes.mapper_utils import model_field_to_node_input
-from comfy.comfy_types.node_typing import IO
-from comfy_api_nodes.apis import (
-    TripoOrientation,
-    TripoModelVersion,
-)
-from comfy_api_nodes.apis.tripo_api import (
-    TripoTaskType,
-    TripoStyle,
-    TripoFileReference,
-    TripoFileEmptyReference,
-    TripoUrlReference,
-    TripoTaskResponse,
-    TripoTaskStatus,
-    TripoTextToModelRequest,
-    TripoImageToModelRequest,
-    TripoMultiviewToModelRequest,
-    TripoTextureModelRequest,
-    TripoRefineModelRequest,
-    TripoAnimateRigRequest,
-    TripoAnimateRetargetRequest,
-    TripoConvertModelRequest,
-)
-
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-    EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
-    upload_images_to_comfyapi,
-    download_url_to_bytesio,
-)
-
-
-def upload_image_to_tripo(image, **kwargs):
-    urls = upload_images_to_comfyapi(image, max_images=1, auth_kwargs=kwargs)
-    return TripoFileReference(TripoUrlReference(url=urls[0], type="jpeg"))
-
-def get_model_url_from_response(response: TripoTaskResponse) -> str:
-    if response.data is not None:
-        for key in ["pbr_model", "model", "base_model"]:
-            if getattr(response.data.output, key, None) is not None:
-                return getattr(response.data.output, key)
-    raise RuntimeError(f"Failed to get model url from response: {response}")
-
-
-def poll_until_finished(
-    kwargs: dict[str, str],
-    response: TripoTaskResponse,
-) -> tuple[str, str]:
-    """Polls the Tripo API endpoint until the task reaches a terminal state, then returns the response."""
-    if response.code != 0:
-        raise RuntimeError(f"Failed to generate mesh: {response.error}")
-    task_id = response.data.task_id
-    response_poll = PollingOperation(
-        poll_endpoint=ApiEndpoint(
-            path=f"/proxy/tripo/v2/openapi/task/{task_id}",
-            method=HttpMethod.GET,
-            request_model=EmptyRequest,
-            response_model=TripoTaskResponse,
-        ),
-        completed_statuses=[TripoTaskStatus.SUCCESS],
-        failed_statuses=[
-            TripoTaskStatus.FAILED,
-            TripoTaskStatus.CANCELLED,
-            TripoTaskStatus.UNKNOWN,
-            TripoTaskStatus.BANNED,
-            TripoTaskStatus.EXPIRED,
-        ],
-        status_extractor=lambda x: x.data.status,
-        auth_kwargs=kwargs,
-        node_id=kwargs["unique_id"],
-        result_url_extractor=get_model_url_from_response,
-        progress_extractor=lambda x: x.data.progress,
-    ).execute()
-    if response_poll.data.status == TripoTaskStatus.SUCCESS:
-        url = get_model_url_from_response(response_poll)
-        bytesio = download_url_to_bytesio(url)
-        # Save the downloaded model file
-        model_file = f"tripo_model_{task_id}.glb"
-        with open(os.path.join(get_output_directory(), model_file), "wb") as f:
-            f.write(bytesio.getvalue())
-        return model_file, task_id
-    raise RuntimeError(f"Failed to generate mesh: {response_poll}")
-
-class TripoTextToModelNode:
-    """
-    Generates 3D models synchronously based on a text prompt using Tripo's API.
-    """
-    AVERAGE_DURATION = 80
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": ("STRING", {"multiline": True}),
-            },
-            "optional": {
-                "negative_prompt": ("STRING", {"multiline": True}),
-                "model_version": model_field_to_node_input(IO.COMBO, TripoTextToModelRequest, "model_version", enum_type=TripoModelVersion),
-                "style": model_field_to_node_input(IO.COMBO, TripoTextToModelRequest, "style", enum_type=TripoStyle, default="None"),
-                "texture": ("BOOLEAN", {"default": True}),
-                "pbr": ("BOOLEAN", {"default": True}),
-                "image_seed": ("INT", {"default": 42}),
-                "model_seed": ("INT", {"default": 42}),
-                "texture_seed": ("INT", {"default": 42}),
-                "texture_quality": (["standard", "detailed"], {"default": "standard"}),
-                "face_limit": ("INT", {"min": -1, "max": 500000, "default": -1}),
-                "quad": ("BOOLEAN", {"default": False})
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "MODEL_TASK_ID",)
-    RETURN_NAMES = ("model_file", "model task_id")
-    FUNCTION = "generate_mesh"
-    CATEGORY = "api node/3d/Tripo"
-    API_NODE = True
-    OUTPUT_NODE = True
-
-    def generate_mesh(self, prompt, negative_prompt=None, model_version=None, style=None, texture=None, pbr=None, image_seed=None, model_seed=None, texture_seed=None, texture_quality=None, face_limit=None, quad=None, **kwargs):
-        style_enum = None if style == "None" else style
-        if not prompt:
-            raise RuntimeError("Prompt is required")
-        response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/tripo/v2/openapi/task",
-                method=HttpMethod.POST,
-                request_model=TripoTextToModelRequest,
-                response_model=TripoTaskResponse,
-            ),
-            request=TripoTextToModelRequest(
-                type=TripoTaskType.TEXT_TO_MODEL,
-                prompt=prompt,
-                negative_prompt=negative_prompt if negative_prompt else None,
-                model_version=model_version,
-                style=style_enum,
-                texture=texture,
-                pbr=pbr,
-                image_seed=image_seed,
-                model_seed=model_seed,
-                texture_seed=texture_seed,
-                texture_quality=texture_quality,
-                face_limit=face_limit,
-                auto_size=True,
-                quad=quad
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        return poll_until_finished(kwargs, response)
-
-class TripoImageToModelNode:
-    """
-    Generates 3D models synchronously based on a single image using Tripo's API.
-    """
-    AVERAGE_DURATION = 80
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-            },
-            "optional": {
-                "model_version": model_field_to_node_input(IO.COMBO, TripoImageToModelRequest, "model_version", enum_type=TripoModelVersion),
-                "style": model_field_to_node_input(IO.COMBO, TripoTextToModelRequest, "style", enum_type=TripoStyle, default="None"),
-                "texture": ("BOOLEAN", {"default": True}),
-                "pbr": ("BOOLEAN", {"default": True}),
-                "model_seed": ("INT", {"default": 42}),
-                "orientation": model_field_to_node_input(IO.COMBO, TripoImageToModelRequest, "orientation", enum_type=TripoOrientation),
-                "texture_seed": ("INT", {"default": 42}),
-                "texture_quality": (["standard", "detailed"], {"default": "standard"}),
-                "texture_alignment": (["original_image", "geometry"], {"default": "original_image"}),
-                "face_limit": ("INT", {"min": -1, "max": 500000, "default": -1}),
-                "quad": ("BOOLEAN", {"default": False})
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "MODEL_TASK_ID",)
-    RETURN_NAMES = ("model_file", "model task_id")
-    FUNCTION = "generate_mesh"
-    CATEGORY = "api node/3d/Tripo"
-    API_NODE = True
-    OUTPUT_NODE = True
-
-    def generate_mesh(self, image, model_version=None, style=None, texture=None, pbr=None, model_seed=None, orientation=None, texture_alignment=None, texture_seed=None, texture_quality=None, face_limit=None, quad=None, **kwargs):
-        style_enum = None if style == "None" else style
-        if image is None:
-            raise RuntimeError("Image is required")
-        tripo_file = upload_image_to_tripo(image, **kwargs)
-        response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/tripo/v2/openapi/task",
-                method=HttpMethod.POST,
-                request_model=TripoImageToModelRequest,
-                response_model=TripoTaskResponse,
-            ),
-            request=TripoImageToModelRequest(
-                type=TripoTaskType.IMAGE_TO_MODEL,
-                file=tripo_file,
-                model_version=model_version,
-                style=style_enum,
-                texture=texture,
-                pbr=pbr,
-                model_seed=model_seed,
-                orientation=orientation,
-                texture_alignment=texture_alignment,
-                texture_seed=texture_seed,
-                texture_quality=texture_quality,
-                face_limit=face_limit,
-                auto_size=True,
-                quad=quad
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        return poll_until_finished(kwargs, response)
-
-class TripoMultiviewToModelNode:
-    """
-    Generates 3D models synchronously based on up to four images (front, left, back, right) using Tripo's API.
-    """
-    AVERAGE_DURATION = 80
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-            },
-            "optional": {
-                "image_left": ("IMAGE",),
-                "image_back": ("IMAGE",),
-                "image_right": ("IMAGE",),
-                "model_version": model_field_to_node_input(IO.COMBO, TripoMultiviewToModelRequest, "model_version", enum_type=TripoModelVersion),
-                "orientation": model_field_to_node_input(IO.COMBO, TripoImageToModelRequest, "orientation", enum_type=TripoOrientation),
-                "texture": ("BOOLEAN", {"default": True}),
-                "pbr": ("BOOLEAN", {"default": True}),
-                "model_seed": ("INT", {"default": 42}),
-                "texture_seed": ("INT", {"default": 42}),
-                "texture_quality": (["standard", "detailed"], {"default": "standard"}),
-                "texture_alignment": (["original_image", "geometry"], {"default": "original_image"}),
-                "face_limit": ("INT", {"min": -1, "max": 500000, "default": -1}),
-                "quad": ("BOOLEAN", {"default": False})
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "MODEL_TASK_ID",)
-    RETURN_NAMES = ("model_file", "model task_id")
-    FUNCTION = "generate_mesh"
-    CATEGORY = "api node/3d/Tripo"
-    API_NODE = True
-    OUTPUT_NODE = True
-
-    def generate_mesh(self, image, image_left=None, image_back=None, image_right=None, model_version=None, orientation=None, texture=None, pbr=None, model_seed=None, texture_seed=None, texture_quality=None, texture_alignment=None, face_limit=None, quad=None, **kwargs):
-        if image is None:
-            raise RuntimeError("front image for multiview is required")
-        images = []
-        image_dict = {
-            "image": image,
-            "image_left": image_left,
-            "image_back": image_back,
-            "image_right": image_right
-        }
-        if image_left is None and image_back is None and image_right is None:
-            raise RuntimeError("At least one of left, back, or right image must be provided for multiview")
-        for image_name in ["image", "image_left", "image_back", "image_right"]:
-            image_ = image_dict[image_name]
-            if image_ is not None:
-                tripo_file = upload_image_to_tripo(image_, **kwargs)
-                images.append(tripo_file)
-            else:
-                images.append(TripoFileEmptyReference())
-        response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/tripo/v2/openapi/task",
-                method=HttpMethod.POST,
-                request_model=TripoMultiviewToModelRequest,
-                response_model=TripoTaskResponse,
-            ),
-            request=TripoMultiviewToModelRequest(
-                type=TripoTaskType.MULTIVIEW_TO_MODEL,
-                files=images,
-                model_version=model_version,
-                orientation=orientation,
-                texture=texture,
-                pbr=pbr,
-                model_seed=model_seed,
-                texture_seed=texture_seed,
-                texture_quality=texture_quality,
-                texture_alignment=texture_alignment,
-                face_limit=face_limit,
-                quad=quad,
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        return poll_until_finished(kwargs, response)
-
-class TripoTextureNode:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "model_task_id": ("MODEL_TASK_ID",),
-            },
-            "optional": {
-                "texture": ("BOOLEAN", {"default": True}),
-                "pbr": ("BOOLEAN", {"default": True}),
-                "texture_seed": ("INT", {"default": 42}),
-                "texture_quality": (["standard", "detailed"], {"default": "standard"}),
-                "texture_alignment": (["original_image", "geometry"], {"default": "original_image"}),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "MODEL_TASK_ID",)
-    RETURN_NAMES = ("model_file", "model task_id")
-    FUNCTION = "generate_mesh"
-    CATEGORY = "api node/3d/Tripo"
-    API_NODE = True
-    OUTPUT_NODE = True
-    AVERAGE_DURATION = 80
-
-    def generate_mesh(self, model_task_id, texture=None, pbr=None, texture_seed=None, texture_quality=None, texture_alignment=None, **kwargs):
-        response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/tripo/v2/openapi/task",
-                method=HttpMethod.POST,
-                request_model=TripoTextureModelRequest,
-                response_model=TripoTaskResponse,
-            ),
-            request=TripoTextureModelRequest(
-                original_model_task_id=model_task_id,
-                texture=texture,
-                pbr=pbr,
-                texture_seed=texture_seed,
-                texture_quality=texture_quality,
-                texture_alignment=texture_alignment
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        return poll_until_finished(kwargs, response)
-
-
-class TripoRefineNode:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "model_task_id": ("MODEL_TASK_ID", {
-                    "tooltip": "Must be a v1.4 Tripo model"
-                }),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    DESCRIPTION = "Refine a draft model created by v1.4 Tripo models only."
-
-    RETURN_TYPES = ("STRING", "MODEL_TASK_ID",)
-    RETURN_NAMES = ("model_file", "model task_id")
-    FUNCTION = "generate_mesh"
-    CATEGORY = "api node/3d/Tripo"
-    API_NODE = True
-    OUTPUT_NODE = True
-    AVERAGE_DURATION = 240
-
-    def generate_mesh(self, model_task_id, **kwargs):
-        response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/tripo/v2/openapi/task",
-                method=HttpMethod.POST,
-                request_model=TripoRefineModelRequest,
-                response_model=TripoTaskResponse,
-            ),
-            request=TripoRefineModelRequest(
-                draft_model_task_id=model_task_id
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        return poll_until_finished(kwargs, response)
-
-
-class TripoRigNode:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "original_model_task_id": ("MODEL_TASK_ID",),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "RIG_TASK_ID")
-    RETURN_NAMES = ("model_file", "rig task_id")
-    FUNCTION = "generate_mesh"
-    CATEGORY = "api node/3d/Tripo"
-    API_NODE = True
-    OUTPUT_NODE = True
-    AVERAGE_DURATION = 180
-
-    def generate_mesh(self, original_model_task_id, **kwargs):
-        response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/tripo/v2/openapi/task",
-                method=HttpMethod.POST,
-                request_model=TripoAnimateRigRequest,
-                response_model=TripoTaskResponse,
-            ),
-            request=TripoAnimateRigRequest(
-                original_model_task_id=original_model_task_id,
-                out_format="glb",
-                spec="tripo"
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        return poll_until_finished(kwargs, response)
-
-class TripoRetargetNode:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "original_model_task_id": ("RIG_TASK_ID",),
-                "animation": ([
-                    "preset:idle",
-                    "preset:walk",
-                    "preset:climb",
-                    "preset:jump",
-                    "preset:slash",
-                    "preset:shoot",
-                    "preset:hurt",
-                    "preset:fall",
-                    "preset:turn",
-                ],),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "RETARGET_TASK_ID")
-    RETURN_NAMES = ("model_file", "retarget task_id")
-    FUNCTION = "generate_mesh"
-    CATEGORY = "api node/3d/Tripo"
-    API_NODE = True
-    OUTPUT_NODE = True
-    AVERAGE_DURATION = 30
-
-    def generate_mesh(self, animation, original_model_task_id, **kwargs):
-        response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/tripo/v2/openapi/task",
-                method=HttpMethod.POST,
-                request_model=TripoAnimateRetargetRequest,
-                response_model=TripoTaskResponse,
-            ),
-            request=TripoAnimateRetargetRequest(
-                original_model_task_id=original_model_task_id,
-                animation=animation,
-                out_format="glb",
-                bake_animation=True
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        return poll_until_finished(kwargs, response)
-
-class TripoConversionNode:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "original_model_task_id": ("MODEL_TASK_ID,RIG_TASK_ID,RETARGET_TASK_ID",),
-                "format": (["GLTF", "USDZ", "FBX", "OBJ", "STL", "3MF"],),
-            },
-            "optional": {
-                "quad": ("BOOLEAN", {"default": False}),
-                "face_limit": ("INT", {"min": -1, "max": 500000, "default": -1}),
-                "texture_size": ("INT", {"min": 128, "max": 4096, "default": 4096}),
-                "texture_format": (["BMP", "DPX", "HDR", "JPEG", "OPEN_EXR", "PNG", "TARGA", "TIFF", "WEBP"], {"default": "JPEG"})
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    @classmethod
-    def VALIDATE_INPUTS(cls, input_types):
-        # The min and max of input1 and input2 are still validated because
-        # we didn't take `input1` or `input2` as arguments
-        if input_types["original_model_task_id"] not in ("MODEL_TASK_ID", "RIG_TASK_ID", "RETARGET_TASK_ID"):
-            return "original_model_task_id must be MODEL_TASK_ID, RIG_TASK_ID or RETARGET_TASK_ID type"
-        return True
-
-    RETURN_TYPES = ()
-    FUNCTION = "generate_mesh"
-    CATEGORY = "api node/3d/Tripo"
-    API_NODE = True
-    OUTPUT_NODE = True
-    AVERAGE_DURATION = 30
-
-    def generate_mesh(self, original_model_task_id, format, quad, face_limit, texture_size, texture_format, **kwargs):
-        if not original_model_task_id:
-            raise RuntimeError("original_model_task_id is required")
-        response = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/tripo/v2/openapi/task",
-                method=HttpMethod.POST,
-                request_model=TripoConvertModelRequest,
-                response_model=TripoTaskResponse,
-            ),
-            request=TripoConvertModelRequest(
-                original_model_task_id=original_model_task_id,
-                format=format,
-                quad=quad if quad else None,
-                face_limit=face_limit if face_limit != -1 else None,
-                texture_size=texture_size if texture_size != 4096 else None,
-                texture_format=texture_format if texture_format != "JPEG" else None
-            ),
-            auth_kwargs=kwargs,
-        ).execute()
-        return poll_until_finished(kwargs, response)
-
-NODE_CLASS_MAPPINGS = {
-    "TripoTextToModelNode": TripoTextToModelNode,
-    "TripoImageToModelNode": TripoImageToModelNode,
-    "TripoMultiviewToModelNode": TripoMultiviewToModelNode,
-    "TripoTextureNode": TripoTextureNode,
-    "TripoRefineNode": TripoRefineNode,
-    "TripoRigNode": TripoRigNode,
-    "TripoRetargetNode": TripoRetargetNode,
-    "TripoConversionNode": TripoConversionNode,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "TripoTextToModelNode": "Tripo: Text to Model",
-    "TripoImageToModelNode": "Tripo: Image to Model",
-    "TripoMultiviewToModelNode": "Tripo: Multiview to Model",
-    "TripoTextureNode": "Tripo: Texture model",
-    "TripoRefineNode": "Tripo: Refine Draft model",
-    "TripoRigNode": "Tripo: Rig model",
-    "TripoRetargetNode": "Tripo: Retarget rigged model",
-    "TripoConversionNode": "Tripo: Convert model",
-}

comfy_api_nodes/nodes_veo2.py

@@ -1,308 +0,0 @@
-import io
-import logging
-import base64
-import requests
-import torch
-from typing import Optional
-
-from comfy.comfy_types.node_typing import IO, ComfyNodeABC
-from comfy_api.input_impl.video_types import VideoFromFile
-from comfy_api_nodes.apis import (
-    Veo2GenVidRequest,
-    Veo2GenVidResponse,
-    Veo2GenVidPollRequest,
-    Veo2GenVidPollResponse
-)
-from comfy_api_nodes.apis.client import (
-    ApiEndpoint,
-    HttpMethod,
-    SynchronousOperation,
-    PollingOperation,
-)
-
-from comfy_api_nodes.apinode_utils import (
-    downscale_image_tensor,
-    tensor_to_base64_string
-)
-
-AVERAGE_DURATION_VIDEO_GEN = 32
-
-def convert_image_to_base64(image: torch.Tensor):
-    if image is None:
-        return None
-
-    scaled_image = downscale_image_tensor(image, total_pixels=2048*2048)
-    return tensor_to_base64_string(scaled_image)
-
-
-def get_video_url_from_response(poll_response: Veo2GenVidPollResponse) -> Optional[str]:
-    if (
-        poll_response.response
-        and hasattr(poll_response.response, "videos")
-        and poll_response.response.videos
-        and len(poll_response.response.videos) > 0
-    ):
-        video = poll_response.response.videos[0]
-    else:
-        return None
-    if hasattr(video, "gcsUri") and video.gcsUri:
-        return str(video.gcsUri)
-    return None
-
-
-class VeoVideoGenerationNode(ComfyNodeABC):
-    """
-    Generates videos from text prompts using Google's Veo API.
-
-    This node can create videos from text descriptions and optional image inputs,
-    with control over parameters like aspect ratio, duration, and more.
-    """
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Text description of the video",
-                    },
-                ),
-                "aspect_ratio": (
-                    IO.COMBO,
-                    {
-                        "options": ["16:9", "9:16"],
-                        "default": "16:9",
-                        "tooltip": "Aspect ratio of the output video",
-                    },
-                ),
-            },
-            "optional": {
-                "negative_prompt": (
-                    IO.STRING,
-                    {
-                        "multiline": True,
-                        "default": "",
-                        "tooltip": "Negative text prompt to guide what to avoid in the video",
-                    },
-                ),
-                "duration_seconds": (
-                    IO.INT,
-                    {
-                        "default": 5,
-                        "min": 5,
-                        "max": 8,
-                        "step": 1,
-                        "display": "number",
-                        "tooltip": "Duration of the output video in seconds",
-                    },
-                ),
-                "enhance_prompt": (
-                    IO.BOOLEAN,
-                    {
-                        "default": True,
-                        "tooltip": "Whether to enhance the prompt with AI assistance",
-                    }
-                ),
-                "person_generation": (
-                    IO.COMBO,
-                    {
-                        "options": ["ALLOW", "BLOCK"],
-                        "default": "ALLOW",
-                        "tooltip": "Whether to allow generating people in the video",
-                    },
-                ),
-                "seed": (
-                    IO.INT,
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFF,
-                        "step": 1,
-                        "display": "number",
-                        "control_after_generate": True,
-                        "tooltip": "Seed for video generation (0 for random)",
-                    },
-                ),
-                "image": (IO.IMAGE, {
-                    "default": None,
-                    "tooltip": "Optional reference image to guide video generation",
-                }),
-            },
-            "hidden": {
-                "auth_token": "AUTH_TOKEN_COMFY_ORG",
-                "comfy_api_key": "API_KEY_COMFY_ORG",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (IO.VIDEO,)
-    FUNCTION = "generate_video"
-    CATEGORY = "api node/video/Veo"
-    DESCRIPTION = "Generates videos from text prompts using Google's Veo API"
-    API_NODE = True
-
-    def generate_video(
-        self,
-        prompt,
-        aspect_ratio="16:9",
-        negative_prompt="",
-        duration_seconds=5,
-        enhance_prompt=True,
-        person_generation="ALLOW",
-        seed=0,
-        image=None,
-        unique_id: Optional[str] = None,
-        **kwargs,
-    ):
-        # Prepare the instances for the request
-        instances = []
-
-        instance = {
-            "prompt": prompt
-        }
-
-        # Add image if provided
-        if image is not None:
-            image_base64 = convert_image_to_base64(image)
-            if image_base64:
-                instance["image"] = {
-                    "bytesBase64Encoded": image_base64,
-                    "mimeType": "image/png"
-                }
-
-        instances.append(instance)
-
-        # Create parameters dictionary
-        parameters = {
-            "aspectRatio": aspect_ratio,
-            "personGeneration": person_generation,
-            "durationSeconds": duration_seconds,
-            "enhancePrompt": enhance_prompt,
-        }
-
-        # Add optional parameters if provided
-        if negative_prompt:
-            parameters["negativePrompt"] = negative_prompt
-        if seed > 0:
-            parameters["seed"] = seed
-
-        # Initial request to start video generation
-        initial_operation = SynchronousOperation(
-            endpoint=ApiEndpoint(
-                path="/proxy/veo/generate",
-                method=HttpMethod.POST,
-                request_model=Veo2GenVidRequest,
-                response_model=Veo2GenVidResponse
-            ),
-            request=Veo2GenVidRequest(
-                instances=instances,
-                parameters=parameters
-            ),
-            auth_kwargs=kwargs,
-        )
-
-        initial_response = initial_operation.execute()
-        operation_name = initial_response.name
-
-        logging.info(f"Veo generation started with operation name: {operation_name}")
-
-        # Define status extractor function
-        def status_extractor(response):
-            # Only return "completed" if the operation is done, regardless of success or failure
-            # We'll check for errors after polling completes
-            return "completed" if response.done else "pending"
-
-        # Define progress extractor function
-        def progress_extractor(response):
-            # Could be enhanced if the API provides progress information
-            return None
-
-        # Define the polling operation
-        poll_operation = PollingOperation(
-            poll_endpoint=ApiEndpoint(
-                path="/proxy/veo/poll",
-                method=HttpMethod.POST,
-                request_model=Veo2GenVidPollRequest,
-                response_model=Veo2GenVidPollResponse
-            ),
-            completed_statuses=["completed"],
-            failed_statuses=[],  # No failed statuses, we'll handle errors after polling
-            status_extractor=status_extractor,
-            progress_extractor=progress_extractor,
-            request=Veo2GenVidPollRequest(
-                operationName=operation_name
-            ),
-            auth_kwargs=kwargs,
-            poll_interval=5.0,
-            result_url_extractor=get_video_url_from_response,
-            node_id=unique_id,
-            estimated_duration=AVERAGE_DURATION_VIDEO_GEN,
-        )
-
-        # Execute the polling operation
-        poll_response = poll_operation.execute()
-
-        # Now check for errors in the final response
-        # Check for error in poll response
-        if hasattr(poll_response, 'error') and poll_response.error:
-            error_message = f"Veo API error: {poll_response.error.message} (code: {poll_response.error.code})"
-            logging.error(error_message)
-            raise Exception(error_message)
-
-        # Check for RAI filtered content
-        if (hasattr(poll_response.response, 'raiMediaFilteredCount') and
-            poll_response.response.raiMediaFilteredCount > 0):
-
-            # Extract reason message if available
-            if (hasattr(poll_response.response, 'raiMediaFilteredReasons') and
-                poll_response.response.raiMediaFilteredReasons):
-                reason = poll_response.response.raiMediaFilteredReasons[0]
-                error_message = f"Content filtered by Google's Responsible AI practices: {reason} ({poll_response.response.raiMediaFilteredCount} videos filtered.)"
-            else:
-                error_message = f"Content filtered by Google's Responsible AI practices ({poll_response.response.raiMediaFilteredCount} videos filtered.)"
-
-            logging.error(error_message)
-            raise Exception(error_message)
-
-        # Extract video data
-        video_data = None
-        if poll_response.response and hasattr(poll_response.response, 'videos') and poll_response.response.videos and len(poll_response.response.videos) > 0:
-            video = poll_response.response.videos[0]
-
-            # Check if video is provided as base64 or URL
-            if hasattr(video, 'bytesBase64Encoded') and video.bytesBase64Encoded:
-                # Decode base64 string to bytes
-                video_data = base64.b64decode(video.bytesBase64Encoded)
-            elif hasattr(video, 'gcsUri') and video.gcsUri:
-                # Download from URL
-                video_url = video.gcsUri
-                video_response = requests.get(video_url)
-                video_data = video_response.content
-            else:
-                raise Exception("Video returned but no data or URL was provided")
-        else:
-            raise Exception("Video generation completed but no video was returned")
-
-        if not video_data:
-            raise Exception("No video data was returned")
-
-        logging.info("Video generation completed successfully")
-
-        # Convert video data to BytesIO object
-        video_io = io.BytesIO(video_data)
-
-        # Return VideoFromFile object
-        return (VideoFromFile(video_io),)
-
-
-# Register the node
-NODE_CLASS_MAPPINGS = {
-    "VeoVideoGenerationNode": VeoVideoGenerationNode,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "VeoVideoGenerationNode": "Google Veo2 Video Generation",
-}

comfy_api_nodes/redocly-dev.yaml

@@ -1,10 +0,0 @@
-# This file is used to filter the Comfy Org OpenAPI spec for schemas related to API Nodes.
-# This is used for development purposes to generate stubs for unreleased API endpoints.
-apis:
-  filter:
-    root: openapi.yaml
-    decorators:
-      filter-in:
-        property: tags
-        value: ['API Nodes']
-        matchStrategy: all

comfy_api_nodes/redocly.yaml

@@ -1,10 +0,0 @@
-# This file is used to filter the Comfy Org OpenAPI spec for schemas related to API Nodes.
-
-apis:
-  filter:
-    root: openapi.yaml
-    decorators:
-      filter-in:
-        property: tags
-        value: ['API Nodes', 'Released']
-        matchStrategy: all

comfy_api_nodes/util/validation_utils.py

@@ -1,100 +0,0 @@
-import logging
-from typing import Optional
-
-import torch
-from comfy_api.input.video_types import VideoInput
-
-
-def get_image_dimensions(image: torch.Tensor) -> tuple[int, int]:
-    if len(image.shape) == 4:
-        return image.shape[1], image.shape[2]
-    elif len(image.shape) == 3:
-        return image.shape[0], image.shape[1]
-    else:
-        raise ValueError("Invalid image tensor shape.")
-
-
-def validate_image_dimensions(
-    image: torch.Tensor,
-    min_width: Optional[int] = None,
-    max_width: Optional[int] = None,
-    min_height: Optional[int] = None,
-    max_height: Optional[int] = None,
-):
-    height, width = get_image_dimensions(image)
-
-    if min_width is not None and width < min_width:
-        raise ValueError(f"Image width must be at least {min_width}px, got {width}px")
-    if max_width is not None and width > max_width:
-        raise ValueError(f"Image width must be at most {max_width}px, got {width}px")
-    if min_height is not None and height < min_height:
-        raise ValueError(
-            f"Image height must be at least {min_height}px, got {height}px"
-        )
-    if max_height is not None and height > max_height:
-        raise ValueError(f"Image height must be at most {max_height}px, got {height}px")
-
-
-def validate_image_aspect_ratio(
-    image: torch.Tensor,
-    min_aspect_ratio: Optional[float] = None,
-    max_aspect_ratio: Optional[float] = None,
-):
-    width, height = get_image_dimensions(image)
-    aspect_ratio = width / height
-
-    if min_aspect_ratio is not None and aspect_ratio < min_aspect_ratio:
-        raise ValueError(
-            f"Image aspect ratio must be at least {min_aspect_ratio}, got {aspect_ratio}"
-        )
-    if max_aspect_ratio is not None and aspect_ratio > max_aspect_ratio:
-        raise ValueError(
-            f"Image aspect ratio must be at most {max_aspect_ratio}, got {aspect_ratio}"
-        )
-
-
-def validate_video_dimensions(
-    video: VideoInput,
-    min_width: Optional[int] = None,
-    max_width: Optional[int] = None,
-    min_height: Optional[int] = None,
-    max_height: Optional[int] = None,
-):
-    try:
-        width, height = video.get_dimensions()
-    except Exception as e:
-        logging.error("Error getting dimensions of video: %s", e)
-        return
-
-    if min_width is not None and width < min_width:
-        raise ValueError(f"Video width must be at least {min_width}px, got {width}px")
-    if max_width is not None and width > max_width:
-        raise ValueError(f"Video width must be at most {max_width}px, got {width}px")
-    if min_height is not None and height < min_height:
-        raise ValueError(
-            f"Video height must be at least {min_height}px, got {height}px"
-        )
-    if max_height is not None and height > max_height:
-        raise ValueError(f"Video height must be at most {max_height}px, got {height}px")
-
-
-def validate_video_duration(
-    video: VideoInput,
-    min_duration: Optional[float] = None,
-    max_duration: Optional[float] = None,
-):
-    try:
-        duration = video.get_duration()
-    except Exception as e:
-        logging.error("Error getting duration of video: %s", e)
-        return
-
-    epsilon = 0.0001
-    if min_duration is not None and min_duration - epsilon > duration:
-        raise ValueError(
-            f"Video duration must be at least {min_duration}s, got {duration}s"
-        )
-    if max_duration is not None and duration > max_duration + epsilon:
-        raise ValueError(
-            f"Video duration must be at most {max_duration}s, got {duration}s"
-        )