Skip to content

The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.

use new API client in Luma and Minimax nodes (#10528)

Alexander Piskun6c14f3afac0e
diff --git a/comfy_api_nodes/apinode_utils.py b/comfy_api_nodes/apinode_utils.py
index 4182c8f80..6a72b9d1d 100644
--- a/comfy_api_nodes/apinode_utils.py
+++ b/comfy_api_nodes/apinode_utils.py
@@ -3,14 +3,6 @@ import aiohttp
import mimetypes
from typing import Optional, Union
from comfy.utils import common_upscale
-from comfy_api_nodes.apis.client import (
- ApiClient,
- ApiEndpoint,
- HttpMethod,
- SynchronousOperation,
- UploadRequest,
- UploadResponse,
-)
from server import PromptServer
from comfy.cli_args import args
@@ -19,7 +11,6 @@ from PIL import Image
import torch
import math
import base64
-from .util import tensor_to_bytesio, bytesio_to_image_tensor
from io import BytesIO
@@ -148,11 +139,6 @@ async def download_url_to_bytesio(
return BytesIO(await resp.read())
-def process_image_response(response_content: bytes | str) -> torch.Tensor:
- """Uses content from a Response object and converts it to a torch.Tensor"""
- return bytesio_to_image_tensor(BytesIO(response_content))
-
-
def text_filepath_to_base64_string(filepath: str) -> str:
"""Converts a text file to a base64 string."""
with open(filepath, "rb") as f:
@@ -169,73 +155,6 @@ def text_filepath_to_data_uri(filepath: str) -> str:
return f"data:{mime_type};base64,{base64_string}"
-async def upload_file_to_comfyapi(
- file_bytes_io: BytesIO,
- filename: str,
- upload_mime_type: Optional[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.
- """
- if upload_mime_type is None:
- request_object = UploadRequest(file_name=filename)
- else:
- 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 = await operation.execute()
- await ApiClient.upload_file(response.upload_url, file_bytes_io, content_type=upload_mime_type)
- return response.download_url
-
-
-async 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
- download_urls: list[str] = []
- is_batch = len(image.shape) > 3
- batch_len = image.shape[0] if is_batch else 1
-
- for idx in range(min(batch_len, max_images)):
- tensor = image[idx] if is_batch else image
- img_io = tensor_to_bytesio(tensor, mime_type=mime_type)
- url = await upload_file_to_comfyapi(img_io, img_io.name, mime_type, auth_kwargs)
- download_urls.append(url)
- return download_urls
-
-
def resize_mask_to_image(
mask: torch.Tensor,
image: torch.Tensor,
diff --git a/comfy_api_nodes/apis/minimax_api.py b/comfy_api_nodes/apis/minimax_api.py
new file mode 100644
index 000000000..d747e177a
--- /dev/null
+++ b/comfy_api_nodes/apis/minimax_api.py
@@ -0,0 +1,120 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class MinimaxBaseResponse(BaseModel):
+ status_code: int = Field(
+ ...,
+ description='Status code. 0 indicates success, other values indicate errors.',
+ )
+ status_msg: str = Field(
+ ..., description='Specific error details or success message.'
+ )
+
+
+class File(BaseModel):
+ bytes: Optional[int] = Field(None, description='File size in bytes')
+ created_at: Optional[int] = Field(
+ None, description='Unix timestamp when the file was created, in seconds'
+ )
+ download_url: Optional[str] = Field(
+ None, description='The URL to download the video'
+ )
+ backup_download_url: Optional[str] = Field(
+ None, description='The backup URL to download the video'
+ )
+
+ file_id: Optional[int] = Field(None, description='Unique identifier for the file')
+ filename: Optional[str] = Field(None, description='The name of the file')
+ purpose: Optional[str] = Field(None, description='The purpose of using the file')
+
+
+class MinimaxFileRetrieveResponse(BaseModel):
+ base_resp: MinimaxBaseResponse
+ file: File
+
+
+class MiniMaxModel(str, Enum):
+ T2V_01_Director = 'T2V-01-Director'
+ I2V_01_Director = 'I2V-01-Director'
+ S2V_01 = 'S2V-01'
+ I2V_01 = 'I2V-01'
+ I2V_01_live = 'I2V-01-live'
+ T2V_01 = 'T2V-01'
+ Hailuo_02 = 'MiniMax-Hailuo-02'
+
+
+class Status6(str, Enum):
+ Queueing = 'Queueing'
+ Preparing = 'Preparing'
+ Processing = 'Processing'
+ Success = 'Success'
+ Fail = 'Fail'
+
+
+class MinimaxTaskResultResponse(BaseModel):
+ base_resp: MinimaxBaseResponse
+ file_id: Optional[str] = Field(
+ None,
+ description='After the task status changes to Success, this field returns the file ID corresponding to the generated video.',
+ )
+ status: Status6 = Field(
+ ...,
+ description="Task status: 'Queueing' (in queue), 'Preparing' (task is preparing), 'Processing' (generating), 'Success' (task completed successfully), or 'Fail' (task failed).",
+ )
+ task_id: str = Field(..., description='The task ID being queried.')
+
+
+class SubjectReferenceItem(BaseModel):
+ image: Optional[str] = Field(
+ None, description='URL or base64 encoding of the subject reference image.'
+ )
+ mask: Optional[str] = Field(
+ None,
+ description='URL or base64 encoding of the mask for the subject reference image.',
+ )
+
+
+class MinimaxVideoGenerationRequest(BaseModel):
+ callback_url: Optional[str] = Field(
+ None,
+ description='Optional. URL to receive real-time status updates about the video generation task.',
+ )
+ first_frame_image: Optional[str] = Field(
+ None,
+ description='URL or base64 encoding of the first frame image. Required when model is I2V-01, I2V-01-Director, or I2V-01-live.',
+ )
+ model: MiniMaxModel = Field(
+ ...,
+ description='Required. ID of model. Options: T2V-01-Director, I2V-01-Director, S2V-01, I2V-01, I2V-01-live, T2V-01',
+ )
+ prompt: Optional[str] = Field(
+ None,
+ description='Description of the video. Should be less than 2000 characters. Supports camera movement instructions in [brackets].',
+ max_length=2000,
+ )
+ prompt_optimizer: Optional[bool] = Field(
+ True,
+ description='If true (default), the model will automatically optimize the prompt. Set to false for more precise control.',
+ )
+ subject_reference: Optional[list[SubjectReferenceItem]] = Field(
+ None,
+ description='Only available when model is S2V-01. The model will generate a video based on the subject uploaded through this parameter.',
+ )
+ duration: Optional[int] = Field(
+ None,
+ description="The length of the output video in seconds."
+ )
+ resolution: Optional[str] = Field(
+ None,
+ description="The dimensions of the video display. 1080p corresponds to 1920 x 1080 pixels, 768p corresponds to 1366 x 768 pixels."
+ )
+
+
+class MinimaxVideoGenerationResponse(BaseModel):
+ base_resp: MinimaxBaseResponse
+ task_id: str = Field(
+ ..., description='The task ID for the asynchronous video generation task.'
+ )
diff --git a/comfy_api_nodes/nodes_ideogram.py b/comfy_api_nodes/nodes_ideogram.py
index 9eae5f11a..d8fd3378b 100644
--- a/comfy_api_nodes/nodes_ideogram.py
+++ b/comfy_api_nodes/nodes_ideogram.py
@@ -20,9 +20,9 @@ from comfy_api_nodes.apis.client import (
from comfy_api_nodes.apinode_utils import (
download_url_to_bytesio,
- bytesio_to_image_tensor,
resize_mask_to_image,
)
+from comfy_api_nodes.util import bytesio_to_image_tensor
from server import PromptServer
V1_V1_RES_MAP = {
diff --git a/comfy_api_nodes/nodes_luma.py b/comfy_api_nodes/nodes_luma.py
index e74441e5e..894f2b08c 100644
--- a/comfy_api_nodes/nodes_luma.py
+++ b/comfy_api_nodes/nodes_luma.py
@@ -1,69 +1,51 @@
-from __future__ import annotations
-from inspect import cleandoc
from typing import Optional
+
+import torch
from typing_extensions import override
-from comfy_api.latest import ComfyExtension, IO
-from comfy_api.input_impl.video_types import VideoFromFile
+
+from comfy_api.latest import IO, ComfyExtension
from comfy_api_nodes.apis.luma_api import (
- LumaImageModel,
- LumaVideoModel,
- LumaVideoOutputResolution,
- LumaVideoModelOutputDuration,
LumaAspectRatio,
- LumaState,
- LumaImageGenerationRequest,
- LumaGenerationRequest,
- LumaGeneration,
LumaCharacterRef,
- LumaModifyImageRef,
+ LumaConceptChain,
+ LumaGeneration,
+ LumaGenerationRequest,
+ LumaImageGenerationRequest,
LumaImageIdentity,
- LumaReference,
- LumaReferenceChain,
+ LumaImageModel,
LumaImageReference,
- LumaKeyframes,
- LumaConceptChain,
LumaIO,
+ LumaKeyframes,
+ LumaModifyImageRef,
+ LumaReference,
+ LumaReferenceChain,
+ LumaVideoModel,
+ LumaVideoModelOutputDuration,
+ LumaVideoOutputResolution,
get_luma_concepts,
)
-from comfy_api_nodes.apis.client import (
+from comfy_api_nodes.util import (
ApiEndpoint,
- HttpMethod,
- SynchronousOperation,
- PollingOperation,
- EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
+ download_url_to_image_tensor,
+ download_url_to_video_output,
+ poll_op,
+ sync_op,
upload_images_to_comfyapi,
- process_image_response,
+ validate_string,
)
-from server import PromptServer
-from comfy_api_nodes.util import validate_string
-
-import aiohttp
-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(IO.ComfyNode):
- """
- Holds an image and weight for use with Luma Generate Image node.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="LumaReferenceNode",
display_name="Luma Reference",
category="api node/image/Luma",
- description=cleandoc(cls.__doc__ or ""),
+ description="Holds an image and weight for use with Luma Generate Image node.",
inputs=[
IO.Image.Input(
"image",
@@ -83,17 +65,10 @@ class LumaReferenceNode(IO.ComfyNode):
),
],
outputs=[IO.Custom(LumaIO.LUMA_REF).Output(display_name="luma_ref")],
- hidden=[
- IO.Hidden.auth_token_comfy_org,
- IO.Hidden.api_key_comfy_org,
- IO.Hidden.unique_id,
- ],
)
@classmethod
- def execute(
- cls, image: torch.Tensor, weight: float, luma_ref: LumaReferenceChain = None
- ) -> IO.NodeOutput:
+ def execute(cls, image: torch.Tensor, weight: float, luma_ref: LumaReferenceChain = None) -> IO.NodeOutput:
if luma_ref is not None:
luma_ref = luma_ref.clone()
else:
@@ -103,17 +78,13 @@ class LumaReferenceNode(IO.ComfyNode):
class LumaConceptsNode(IO.ComfyNode):
- """
- Holds one or more Camera Concepts for use with Luma Text to Video and Luma Image to Video nodes.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="LumaConceptsNode",
display_name="Luma Concepts",
category="api node/video/Luma",
- description=cleandoc(cls.__doc__ or ""),
+ description="Camera Concepts for use with Luma Text to Video and Luma Image to Video nodes.",
inputs=[
IO.Combo.Input(
"concept1",
@@ -138,11 +109,6 @@ class LumaConceptsNode(IO.ComfyNode):
),
],
outputs=[IO.Custom(LumaIO.LUMA_CONCEPTS).Output(display_name="luma_concepts")],
- hidden=[
- IO.Hidden.auth_token_comfy_org,
- IO.Hidden.api_key_comfy_org,
- IO.Hidden.unique_id,
- ],
)
@classmethod
@@ -161,17 +127,13 @@ class LumaConceptsNode(IO.ComfyNode):
class LumaImageGenerationNode(IO.ComfyNode):
- """
- Generates images synchronously based on prompt and aspect ratio.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="LumaImageNode",
display_name="Luma Text to Image",
category="api node/image/Luma",
- description=cleandoc(cls.__doc__ or ""),
+ description="Generates images synchronously based on prompt and aspect ratio.",
inputs=[
IO.String.Input(
"prompt",
@@ -237,45 +199,30 @@ class LumaImageGenerationNode(IO.ComfyNode):
aspect_ratio: str,
seed,
style_image_weight: float,
- image_luma_ref: LumaReferenceChain = None,
- style_image: torch.Tensor = None,
- character_image: torch.Tensor = None,
+ image_luma_ref: Optional[LumaReferenceChain] = None,
+ style_image: Optional[torch.Tensor] = None,
+ character_image: Optional[torch.Tensor] = None,
) -> IO.NodeOutput:
validate_string(prompt, strip_whitespace=True, min_length=3)
- auth_kwargs = {
- "auth_token": cls.hidden.auth_token_comfy_org,
- "comfy_api_key": cls.hidden.api_key_comfy_org,
- }
# handle image_luma_ref
api_image_ref = None
if image_luma_ref is not None:
- api_image_ref = await cls._convert_luma_refs(
- image_luma_ref, max_refs=4, auth_kwargs=auth_kwargs,
- )
+ api_image_ref = await cls._convert_luma_refs(image_luma_ref, max_refs=4)
# handle style_luma_ref
api_style_ref = None
if style_image is not None:
- api_style_ref = await cls._convert_style_image(
- style_image, weight=style_image_weight, auth_kwargs=auth_kwargs,
- )
+ api_style_ref = await cls._convert_style_image(style_image, weight=style_image_weight)
# handle character_ref images
character_ref = None
if character_image is not None:
- download_urls = await upload_images_to_comfyapi(
- character_image, max_images=4, auth_kwargs=auth_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(
+ download_urls = await upload_images_to_comfyapi(cls, character_image, max_images=4)
+ character_ref = LumaCharacterRef(identity0=LumaImageIdentity(images=download_urls))
+
+ response_api = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/luma/generations/image", method="POST"),
+ response_model=LumaGeneration,
+ data=LumaImageGenerationRequest(
prompt=prompt,
model=model,
aspect_ratio=aspect_ratio,
@@ -283,41 +230,21 @@ class LumaImageGenerationNode(IO.ComfyNode):
style_ref=api_style_ref,
character_ref=character_ref,
),
- auth_kwargs=auth_kwargs,
)
- response_api: LumaGeneration = await 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],
+ response_poll = await poll_op(
+ cls,
+ ApiEndpoint(path=f"/proxy/luma/generations/{response_api.id}"),
+ response_model=LumaGeneration,
status_extractor=lambda x: x.state,
- result_url_extractor=image_result_url_extractor,
- node_id=cls.hidden.unique_id,
- auth_kwargs=auth_kwargs,
)
- response_poll = await operation.execute()
-
- async with aiohttp.ClientSession() as session:
- async with session.get(response_poll.assets.image) as img_response:
- img = process_image_response(await img_response.content.read())
- return IO.NodeOutput(img)
+ return IO.NodeOutput(await download_url_to_image_tensor(response_poll.assets.image))
@classmethod
- async def _convert_luma_refs(
- cls, luma_ref: LumaReferenceChain, max_refs: int, auth_kwargs: Optional[dict[str,str]] = None
- ):
+ async def _convert_luma_refs(cls, luma_ref: LumaReferenceChain, max_refs: int):
luma_urls = []
ref_count = 0
for ref in luma_ref.refs:
- download_urls = await upload_images_to_comfyapi(
- ref.image, max_images=1, auth_kwargs=auth_kwargs
- )
+ download_urls = await upload_images_to_comfyapi(cls, ref.image, max_images=1)
luma_urls.append(download_urls[0])
ref_count += 1
if ref_count >= max_refs:
@@ -325,27 +252,19 @@ class LumaImageGenerationNode(IO.ComfyNode):
return luma_ref.create_api_model(download_urls=luma_urls, max_refs=max_refs)
@classmethod
- async def _convert_style_image(
- cls, style_image: torch.Tensor, weight: float, auth_kwargs: Optional[dict[str,str]] = None
- ):
- chain = LumaReferenceChain(
- first_ref=LumaReference(image=style_image, weight=weight)
- )
- return await cls._convert_luma_refs(chain, max_refs=1, auth_kwargs=auth_kwargs)
+ async def _convert_style_image(cls, style_image: torch.Tensor, weight: float):
+ chain = LumaReferenceChain(first_ref=LumaReference(image=style_image, weight=weight))
+ return await cls._convert_luma_refs(chain, max_refs=1)
class LumaImageModifyNode(IO.ComfyNode):
- """
- Modifies images synchronously based on prompt and aspect ratio.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="LumaImageModifyNode",
display_name="Luma Image to Image",
category="api node/image/Luma",
- description=cleandoc(cls.__doc__ or ""),
+ description="Modifies images synchronously based on prompt and aspect ratio.",
inputs=[
IO.Image.Input(
"image",
@@ -395,68 +314,37 @@ class LumaImageModifyNode(IO.ComfyNode):
image_weight: float,
seed,
) -> IO.NodeOutput:
- auth_kwargs = {
- "auth_token": cls.hidden.auth_token_comfy_org,
- "comfy_api_key": cls.hidden.api_key_comfy_org,
- }
- # first, upload image
- download_urls = await upload_images_to_comfyapi(
- image, max_images=1, auth_kwargs=auth_kwargs,
- )
+ download_urls = await upload_images_to_comfyapi(cls, image, max_images=1)
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(
+ response_api = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/luma/generations/image", method="POST"),
+ response_model=LumaGeneration,
+ data=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)
+ url=image_url, weight=round(max(min(1.0 - image_weight, 0.98), 0.0), 2)
),
),
- auth_kwargs=auth_kwargs,
)
- response_api: LumaGeneration = await 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],
+ response_poll = await poll_op(
+ cls,
+ ApiEndpoint(path=f"/proxy/luma/generations/{response_api.id}"),
+ response_model=LumaGeneration,
status_extractor=lambda x: x.state,
- result_url_extractor=image_result_url_extractor,
- node_id=cls.hidden.unique_id,
- auth_kwargs=auth_kwargs,
)
- response_poll = await operation.execute()
-
- async with aiohttp.ClientSession() as session:
- async with session.get(response_poll.assets.image) as img_response:
- img = process_image_response(await img_response.content.read())
- return IO.NodeOutput(img)
+ return IO.NodeOutput(await download_url_to_image_tensor(response_poll.assets.image))
class LumaTextToVideoGenerationNode(IO.ComfyNode):
- """
- Generates videos synchronously based on prompt and output_size.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="LumaVideoNode",
display_name="Luma Text to Video",
category="api node/video/Luma",
- description=cleandoc(cls.__doc__ or ""),
+ description="Generates videos synchronously based on prompt and output_size.",
inputs=[
IO.String.Input(
"prompt",
@@ -498,7 +386,7 @@ class LumaTextToVideoGenerationNode(IO.ComfyNode):
"luma_concepts",
tooltip="Optional Camera Concepts to dictate camera motion via the Luma Concepts node.",
optional=True,
- )
+ ),
],
outputs=[IO.Video.Output()],
hidden=[
@@ -519,24 +407,17 @@ class LumaTextToVideoGenerationNode(IO.ComfyNode):
duration: str,
loop: bool,
seed,
- luma_concepts: LumaConceptChain = None,
+ luma_concepts: Optional[LumaConceptChain] = None,
) -> IO.NodeOutput:
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
- auth_kwargs = {
- "auth_token": cls.hidden.auth_token_comfy_org,
- "comfy_api_key": cls.hidden.api_key_comfy_org,
- }
- operation = SynchronousOperation(
- endpoint=ApiEndpoint(
- path="/proxy/luma/generations",
- method=HttpMethod.POST,
- request_model=LumaGenerationRequest,
- response_model=LumaGeneration,
- ),
- request=LumaGenerationRequest(
+ response_api = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/luma/generations", method="POST"),
+ response_model=LumaGeneration,
+ data=LumaGenerationRequest(
prompt=prompt,
model=model,
resolution=resolution,
@@ -545,47 +426,25 @@ class LumaTextToVideoGenerationNode(IO.ComfyNode):
loop=loop,
concepts=luma_concepts.create_api_model() if luma_concepts else None,
),
- auth_kwargs=auth_kwargs,
)
- response_api: LumaGeneration = await operation.execute()
-
- if cls.hidden.unique_id:
- PromptServer.instance.send_progress_text(f"Luma video generation started: {response_api.id}", cls.hidden.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],
+ response_poll = await poll_op(
+ cls,
+ ApiEndpoint(path=f"/proxy/luma/generations/{response_api.id}"),
+ response_model=LumaGeneration,
status_extractor=lambda x: x.state,
- result_url_extractor=video_result_url_extractor,
- node_id=cls.hidden.unique_id,
estimated_duration=LUMA_T2V_AVERAGE_DURATION,
- auth_kwargs=auth_kwargs,
)
- response_poll = await operation.execute()
-
- async with aiohttp.ClientSession() as session:
- async with session.get(response_poll.assets.video) as vid_response:
- return IO.NodeOutput(VideoFromFile(BytesIO(await vid_response.content.read())))
+ return IO.NodeOutput(await download_url_to_video_output(response_poll.assets.video))
class LumaImageToVideoGenerationNode(IO.ComfyNode):
- """
- Generates videos synchronously based on prompt, input images, and output_size.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="LumaImageToVideoNode",
display_name="Luma Image to Video",
category="api node/video/Luma",
- description=cleandoc(cls.__doc__ or ""),
+ description="Generates videos synchronously based on prompt, input images, and output_size.",
inputs=[
IO.String.Input(
"prompt",
@@ -637,7 +496,7 @@ class LumaImageToVideoGenerationNode(IO.ComfyNode):
"luma_concepts",
tooltip="Optional Camera Concepts to dictate camera motion via the Luma Concepts node.",
optional=True,
- )
+ ),
],
outputs=[IO.Video.Output()],
hidden=[
@@ -662,25 +521,15 @@ class LumaImageToVideoGenerationNode(IO.ComfyNode):
luma_concepts: LumaConceptChain = None,
) -> IO.NodeOutput:
if first_image is None and last_image is None:
- raise Exception(
- "At least one of first_image and last_image requires an input."
- )
- auth_kwargs = {
- "auth_token": cls.hidden.auth_token_comfy_org,
- "comfy_api_key": cls.hidden.api_key_comfy_org,
- }
- keyframes = await cls._convert_to_keyframes(first_image, last_image, auth_kwargs=auth_kwargs)
+ raise Exception("At least one of first_image and last_image requires an input.")
+ keyframes = await cls._convert_to_keyframes(first_image, last_image)
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(
+ response_api = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/luma/generations", method="POST"),
+ response_model=LumaGeneration,
+ data=LumaGenerationRequest(
prompt=prompt,
model=model,
aspect_ratio=LumaAspectRatio.ratio_16_9, # ignored, but still needed by the API for some reason
@@ -690,54 +539,31 @@ class LumaImageToVideoGenerationNode(IO.ComfyNode):
keyframes=keyframes,
concepts=luma_concepts.create_api_model() if luma_concepts else None,
),
- auth_kwargs=auth_kwargs,
)
- response_api: LumaGeneration = await operation.execute()
-
- if cls.hidden.unique_id:
- PromptServer.instance.send_progress_text(f"Luma video generation started: {response_api.id}", cls.hidden.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],
+ response_poll = await poll_op(
+ cls,
+ poll_endpoint=ApiEndpoint(path=f"/proxy/luma/generations/{response_api.id}"),
+ response_model=LumaGeneration,
status_extractor=lambda x: x.state,
- result_url_extractor=video_result_url_extractor,
- node_id=cls.hidden.unique_id,
estimated_duration=LUMA_I2V_AVERAGE_DURATION,
- auth_kwargs=auth_kwargs,
)
- response_poll = await operation.execute()
-
- async with aiohttp.ClientSession() as session:
- async with session.get(response_poll.assets.video) as vid_response:
- return IO.NodeOutput(VideoFromFile(BytesIO(await vid_response.content.read())))
+ return IO.NodeOutput(await download_url_to_video_output(response_poll.assets.video))
@classmethod
async def _convert_to_keyframes(
cls,
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 = await upload_images_to_comfyapi(
- first_image, max_images=1, auth_kwargs=auth_kwargs,
- )
+ download_urls = await upload_images_to_comfyapi(cls, first_image, max_images=1)
frame0 = LumaImageReference(type="image", url=download_urls[0])
if last_image is not None:
- download_urls = await upload_images_to_comfyapi(
- last_image, max_images=1, auth_kwargs=auth_kwargs,
- )
+ download_urls = await upload_images_to_comfyapi(cls, last_image, max_images=1)
frame1 = LumaImageReference(type="image", url=download_urls[0])
return LumaKeyframes(frame0=frame0, frame1=frame1)
diff --git a/comfy_api_nodes/nodes_minimax.py b/comfy_api_nodes/nodes_minimax.py
index e3722e79b..05cbb700f 100644
--- a/comfy_api_nodes/nodes_minimax.py
+++ b/comfy_api_nodes/nodes_minimax.py
@@ -1,71 +1,57 @@
-from inspect import cleandoc
from typing import Optional
-import logging
-import torch
+import torch
from typing_extensions import override
-from comfy_api.latest import ComfyExtension, IO
-from comfy_api.input_impl.video_types import VideoFromFile
-from comfy_api_nodes.apis import (
- MinimaxVideoGenerationRequest,
- MinimaxVideoGenerationResponse,
+
+from comfy_api.latest import IO, ComfyExtension
+from comfy_api_nodes.apis.minimax_api import (
MinimaxFileRetrieveResponse,
+ MiniMaxModel,
MinimaxTaskResultResponse,
+ MinimaxVideoGenerationRequest,
+ MinimaxVideoGenerationResponse,
SubjectReferenceItem,
- MiniMaxModel,
)
-from comfy_api_nodes.apis.client import (
+from comfy_api_nodes.util import (
ApiEndpoint,
- HttpMethod,
- SynchronousOperation,
- PollingOperation,
- EmptyRequest,
-)
-from comfy_api_nodes.apinode_utils import (
- download_url_to_bytesio,
+ download_url_to_video_output,
+ poll_op,
+ sync_op,
upload_images_to_comfyapi,
+ validate_string,
)
-from comfy_api_nodes.util import validate_string
-from server import PromptServer
-
I2V_AVERAGE_DURATION = 114
T2V_AVERAGE_DURATION = 234
async def _generate_mm_video(
+ cls: type[IO.ComfyNode],
*,
- auth: dict[str, str],
- node_id: str,
prompt_text: str,
seed: int,
model: str,
- image: Optional[torch.Tensor] = None, # used for ImageToVideo
- subject: Optional[torch.Tensor] = None, # used for SubjectToVideo
+ image: Optional[torch.Tensor] = None, # used for ImageToVideo
+ subject: Optional[torch.Tensor] = None, # used for SubjectToVideo
average_duration: Optional[int] = None,
) -> IO.NodeOutput:
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 = (await upload_images_to_comfyapi(image, max_images=1, auth_kwargs=auth))[0]
+ image_url = (await upload_images_to_comfyapi(cls, image, max_images=1))[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 = (await upload_images_to_comfyapi(subject, max_images=1, auth_kwargs=auth))[0]
+ subject_url = (await upload_images_to_comfyapi(cls, subject, max_images=1))[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(
+ response = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/minimax/video_generation", method="POST"),
+ response_model=MinimaxVideoGenerationResponse,
+ data=MinimaxVideoGenerationRequest(
model=MiniMaxModel(model),
prompt=prompt_text,
callback_url=None,
@@ -73,81 +59,50 @@ async def _generate_mm_video(
subject_reference=subject_reference,
prompt_optimizer=None,
),
- auth_kwargs=auth,
)
- response = await 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"],
+ task_result = await poll_op(
+ cls,
+ ApiEndpoint(path="/proxy/minimax/query/video_generation", query_params={"task_id": task_id}),
+ response_model=MinimaxTaskResultResponse,
status_extractor=lambda x: x.status.value,
estimated_duration=average_duration,
- node_id=node_id,
- auth_kwargs=auth,
)
- task_result = await 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=auth,
+ file_result = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/minimax/files/retrieve", query_params={"file_id": int(file_id)}),
+ response_model=MinimaxFileRetrieveResponse,
)
- file_result = await 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("Generated video URL: %s", file_url)
- if node_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, node_id)
-
- # Download and return as VideoFromFile
- video_io = await 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 IO.NodeOutput(VideoFromFile(video_io))
+ raise Exception(f"No video was found in the response. Full response: {file_result.model_dump()}")
+ if file_result.file.backup_download_url:
+ try:
+ return IO.NodeOutput(await download_url_to_video_output(file_url, timeout=10, max_retries=2))
+ except Exception: # if we have a second URL to retrieve the result, try again using that one
+ return IO.NodeOutput(
+ await download_url_to_video_output(file_result.file.backup_download_url, max_retries=3)
+ )
+ return IO.NodeOutput(await download_url_to_video_output(file_url))
class MinimaxTextToVideoNode(IO.ComfyNode):
- """
- Generates videos synchronously based on a prompt, and optional parameters using MiniMax's API.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="MinimaxTextToVideoNode",
display_name="MiniMax Text to Video",
category="api node/video/MiniMax",
- description=cleandoc(cls.__doc__ or ""),
+ description="Generates videos synchronously based on a prompt, and optional parameters.",
inputs=[
IO.String.Input(
"prompt_text",
@@ -189,11 +144,7 @@ class MinimaxTextToVideoNode(IO.ComfyNode):
seed: int = 0,
) -> IO.NodeOutput:
return await _generate_mm_video(
- auth={
- "auth_token": cls.hidden.auth_token_comfy_org,
- "comfy_api_key": cls.hidden.api_key_comfy_org,
- },
- node_id=cls.hidden.unique_id,
+ cls,
prompt_text=prompt_text,
seed=seed,
model=model,
@@ -204,17 +155,13 @@ class MinimaxTextToVideoNode(IO.ComfyNode):
class MinimaxImageToVideoNode(IO.ComfyNode):
- """
- Generates videos synchronously based on an image and prompt, and optional parameters using MiniMax's API.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="MinimaxImageToVideoNode",
display_name="MiniMax Image to Video",
category="api node/video/MiniMax",
- description=cleandoc(cls.__doc__ or ""),
+ description="Generates videos synchronously based on an image and prompt, and optional parameters.",
inputs=[
IO.Image.Input(
"image",
@@ -261,11 +208,7 @@ class MinimaxImageToVideoNode(IO.ComfyNode):
seed: int = 0,
) -> IO.NodeOutput:
return await _generate_mm_video(
- auth={
- "auth_token": cls.hidden.auth_token_comfy_org,
- "comfy_api_key": cls.hidden.api_key_comfy_org,
- },
- node_id=cls.hidden.unique_id,
+ cls,
prompt_text=prompt_text,
seed=seed,
model=model,
@@ -276,17 +219,13 @@ class MinimaxImageToVideoNode(IO.ComfyNode):
class MinimaxSubjectToVideoNode(IO.ComfyNode):
- """
- Generates videos synchronously based on an image and prompt, and optional parameters using MiniMax's API.
- """
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="MinimaxSubjectToVideoNode",
display_name="MiniMax Subject to Video",
category="api node/video/MiniMax",
- description=cleandoc(cls.__doc__ or ""),
+ description="Generates videos synchronously based on an image and prompt, and optional parameters.",
inputs=[
IO.Image.Input(
"subject",
@@ -333,11 +272,7 @@ class MinimaxSubjectToVideoNode(IO.ComfyNode):
seed: int = 0,
) -> IO.NodeOutput:
return await _generate_mm_video(
- auth={
- "auth_token": cls.hidden.auth_token_comfy_org,
- "comfy_api_key": cls.hidden.api_key_comfy_org,
- },
- node_id=cls.hidden.unique_id,
+ cls,
prompt_text=prompt_text,
seed=seed,
model=model,
@@ -348,15 +283,13 @@ class MinimaxSubjectToVideoNode(IO.ComfyNode):
class MinimaxHailuoVideoNode(IO.ComfyNode):
- """Generates videos from prompt, with optional start frame using the new MiniMax Hailuo-02 model."""
-
@classmethod
def define_schema(cls) -> IO.Schema:
return IO.Schema(
node_id="MinimaxHailuoVideoNode",
display_name="MiniMax Hailuo Video",
category="api node/video/MiniMax",
- description=cleandoc(cls.__doc__ or ""),
+ description="Generates videos from prompt, with optional start frame using the new MiniMax Hailuo-02 model.",
inputs=[
IO.String.Input(
"prompt_text",
@@ -420,10 +353,6 @@ class MinimaxHailuoVideoNode(IO.ComfyNode):
resolution: str = "768P",
model: str = "MiniMax-Hailuo-02",
) -> IO.NodeOutput:
- auth = {
- "auth_token": cls.hidden.auth_token_comfy_org,
- "comfy_api_key": cls.hidden.api_key_comfy_org,
- }
if first_frame_image is None:
validate_string(prompt_text, field_name="prompt_text")
@@ -435,16 +364,13 @@ class MinimaxHailuoVideoNode(IO.ComfyNode):
# upload image, if passed in
image_url = None
if first_frame_image is not None:
- image_url = (await upload_images_to_comfyapi(first_frame_image, max_images=1, auth_kwargs=auth))[0]
-
- video_generate_operation = SynchronousOperation(
- endpoint=ApiEndpoint(
- path="/proxy/minimax/video_generation",
- method=HttpMethod.POST,
- request_model=MinimaxVideoGenerationRequest,
- response_model=MinimaxVideoGenerationResponse,
- ),
- request=MinimaxVideoGenerationRequest(
+ image_url = (await upload_images_to_comfyapi(cls, first_frame_image, max_images=1))[0]
+
+ response = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/minimax/video_generation", method="POST"),
+ response_model=MinimaxVideoGenerationResponse,
+ data=MinimaxVideoGenerationRequest(
model=MiniMaxModel(model),
prompt=prompt_text,
callback_url=None,
@@ -453,67 +379,42 @@ class MinimaxHailuoVideoNode(IO.ComfyNode):
duration=duration,
resolution=resolution,
),
- auth_kwargs=auth,
)
- response = await video_generate_operation.execute()
task_id = response.task_id
if not task_id:
raise Exception(f"MiniMax generation failed: {response.base_resp}")
average_duration = 120 if resolution == "768P" else 240
- 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"],
+ task_result = await poll_op(
+ cls,
+ ApiEndpoint(path="/proxy/minimax/query/video_generation", query_params={"task_id": task_id}),
+ response_model=MinimaxTaskResultResponse,
status_extractor=lambda x: x.status.value,
estimated_duration=average_duration,
- node_id=cls.hidden.unique_id,
- auth_kwargs=auth,
)
- task_result = await 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=auth,
+ file_result = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/minimax/files/retrieve", query_params={"file_id": int(file_id)}),
+ response_model=MinimaxFileRetrieveResponse,
)
- file_result = await 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("Generated video URL: %s", file_url)
- if cls.hidden.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, cls.hidden.unique_id)
-
- video_io = await 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 IO.NodeOutput(VideoFromFile(video_io))
+ raise Exception(f"No video was found in the response. Full response: {file_result.model_dump()}")
+
+ if file_result.file.backup_download_url:
+ try:
+ return IO.NodeOutput(await download_url_to_video_output(file_url, timeout=10, max_retries=2))
+ except Exception: # if we have a second URL to retrieve the result, try again using that one
+ return IO.NodeOutput(
+ await download_url_to_video_output(file_result.file.backup_download_url, max_retries=3)
+ )
+ return IO.NodeOutput(await download_url_to_video_output(file_url))
class MinimaxExtension(ComfyExtension):
diff --git a/comfy_api_nodes/util/client.py b/comfy_api_nodes/util/client.py
index 9c036d64b..9ae512fe5 100644
--- a/comfy_api_nodes/util/client.py
+++ b/comfy_api_nodes/util/client.py
@@ -78,7 +78,7 @@ class _PollUIState:
_RETRY_STATUS = {408, 429, 500, 502, 503, 504}
COMPLETED_STATUSES = ["succeeded", "succeed", "success", "completed"]
-FAILED_STATUSES = ["cancelled", "canceled", "failed", "error"]
+FAILED_STATUSES = ["cancelled", "canceled", "fail", "failed", "error"]
QUEUED_STATUSES = ["created", "queued", "queueing", "submitted"]
diff --git a/comfy_api_nodes/util/download_helpers.py b/comfy_api_nodes/util/download_helpers.py
index f89045e12..364874bed 100644
--- a/comfy_api_nodes/util/download_helpers.py
+++ b/comfy_api_nodes/util/download_helpers.py
@@ -232,11 +232,12 @@ async def download_url_to_video_output(
video_url: str,
*,
timeout: float = None,
+ max_retries: int = 5,
cls: type[COMFY_IO.ComfyNode] = None,
) -> VideoFromFile:
"""Downloads a video from a URL and returns a `VIDEO` output."""
result = BytesIO()
- await download_url_to_bytesio(video_url, result, timeout=timeout, cls=cls)
+ await download_url_to_bytesio(video_url, result, timeout=timeout, max_retries=max_retries, cls=cls)
return VideoFromFile(result)