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.

feat(api-nodes): add Topaz API nodes (#10755)

Alexander Piskun394348f5caaa
diff --git a/comfy_api_nodes/apis/topaz_api.py b/comfy_api_nodes/apis/topaz_api.py
new file mode 100644
index 000000000..4d9e62e72
--- /dev/null
+++ b/comfy_api_nodes/apis/topaz_api.py
@@ -0,0 +1,133 @@
+from typing import Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class ImageEnhanceRequest(BaseModel):
+ model: str = Field("Reimagine")
+ output_format: str = Field("jpeg")
+ subject_detection: str = Field("All")
+ face_enhancement: bool = Field(True)
+ face_enhancement_creativity: float = Field(0, description="Is ignored if face_enhancement is false")
+ face_enhancement_strength: float = Field(0.8, description="Is ignored if face_enhancement is false")
+ source_url: str = Field(...)
+ output_width: Optional[int] = Field(None)
+ output_height: Optional[int] = Field(None)
+ crop_to_fill: bool = Field(False)
+ prompt: Optional[str] = Field(None, description="Text prompt for creative upscaling guidance")
+ creativity: int = Field(3, description="Creativity settings range from 1 to 9")
+ face_preservation: str = Field("true", description="To preserve the identity of characters")
+ color_preservation: str = Field("true", description="To preserve the original color")
+
+
+class ImageAsyncTaskResponse(BaseModel):
+ process_id: str = Field(...)
+
+
+class ImageStatusResponse(BaseModel):
+ process_id: str = Field(...)
+ status: str = Field(...)
+ progress: Optional[int] = Field(None)
+ credits: int = Field(...)
+
+
+class ImageDownloadResponse(BaseModel):
+ download_url: str = Field(...)
+ expiry: int = Field(...)
+
+
+class Resolution(BaseModel):
+ width: int = Field(...)
+ height: int = Field(...)
+
+
+class CreateCreateVideoRequestSource(BaseModel):
+ container: str = Field(...)
+ size: int = Field(..., description="Size of the video file in bytes")
+ duration: int = Field(..., description="Duration of the video file in seconds")
+ frameCount: int = Field(..., description="Total number of frames in the video")
+ frameRate: int = Field(...)
+ resolution: Resolution = Field(...)
+
+
+class VideoFrameInterpolationFilter(BaseModel):
+ model: str = Field(...)
+ slowmo: Optional[int] = Field(None)
+ fps: int = Field(...)
+ duplicate: bool = Field(...)
+ duplicate_threshold: float = Field(...)
+
+
+class VideoEnhancementFilter(BaseModel):
+ model: str = Field(...)
+ auto: Optional[str] = Field(None, description="Auto, Manual, Relative")
+ focusFixLevel: Optional[str] = Field(None, description="Downscales video input for correction of blurred subjects")
+ compression: Optional[float] = Field(None, description="Strength of compression recovery")
+ details: Optional[float] = Field(None, description="Amount of detail reconstruction")
+ prenoise: Optional[float] = Field(None, description="Amount of noise to add to input to reduce over-smoothing")
+ noise: Optional[float] = Field(None, description="Amount of noise reduction")
+ halo: Optional[float] = Field(None, description="Amount of halo reduction")
+ preblur: Optional[float] = Field(None, description="Anti-aliasing and deblurring strength")
+ blur: Optional[float] = Field(None, description="Amount of sharpness applied")
+ grain: Optional[float] = Field(None, description="Grain after AI model processing")
+ grainSize: Optional[float] = Field(None, description="Size of generated grain")
+ recoverOriginalDetailValue: Optional[float] = Field(None, description="Source details into the output video")
+ creativity: Optional[str] = Field(None, description="Creativity level(high, low) for slc-1 only")
+ isOptimizedMode: Optional[bool] = Field(None, description="Set to true for Starlight Creative (slc-1) only")
+
+
+class OutputInformationVideo(BaseModel):
+ resolution: Resolution = Field(...)
+ frameRate: int = Field(...)
+ audioCodec: Optional[str] = Field(..., description="Required if audioTransfer is Copy or Convert")
+ audioTransfer: str = Field(..., description="Copy, Convert, None")
+ dynamicCompressionLevel: str = Field(..., description="Low, Mid, High")
+
+
+class Overrides(BaseModel):
+ isPaidDiffusion: bool = Field(True)
+
+
+class CreateVideoRequest(BaseModel):
+ source: CreateCreateVideoRequestSource = Field(...)
+ filters: list[Union[VideoFrameInterpolationFilter, VideoEnhancementFilter]] = Field(...)
+ output: OutputInformationVideo = Field(...)
+ overrides: Overrides = Field(Overrides(isPaidDiffusion=True))
+
+
+class CreateVideoResponse(BaseModel):
+ requestId: str = Field(...)
+
+
+class VideoAcceptResponse(BaseModel):
+ uploadId: str = Field(...)
+ urls: list[str] = Field(...)
+
+
+class VideoCompleteUploadRequestPart(BaseModel):
+ partNum: int = Field(...)
+ eTag: str = Field(...)
+
+
+class VideoCompleteUploadRequest(BaseModel):
+ uploadResults: list[VideoCompleteUploadRequestPart] = Field(...)
+
+
+class VideoCompleteUploadResponse(BaseModel):
+ message: str = Field(..., description="Confirmation message")
+
+
+class VideoStatusResponseEstimates(BaseModel):
+ cost: list[int] = Field(...)
+
+
+class VideoStatusResponseDownloadUrl(BaseModel):
+ url: str = Field(...)
+
+
+class VideoStatusResponse(BaseModel):
+ status: str = Field(...)
+ estimates: Optional[VideoStatusResponseEstimates] = Field(None)
+ progress: Optional[float] = Field(None)
+ message: Optional[str] = Field("")
+ download: Optional[VideoStatusResponseDownloadUrl] = Field(None)
diff --git a/comfy_api_nodes/nodes_topaz.py b/comfy_api_nodes/nodes_topaz.py
new file mode 100644
index 000000000..79c7bf43d
--- /dev/null
+++ b/comfy_api_nodes/nodes_topaz.py
@@ -0,0 +1,421 @@
+import builtins
+from io import BytesIO
+
+import aiohttp
+import torch
+from typing_extensions import override
+
+from comfy_api.input.video_types import VideoInput
+from comfy_api.latest import IO, ComfyExtension
+from comfy_api_nodes.apis import topaz_api
+from comfy_api_nodes.util import (
+ ApiEndpoint,
+ download_url_to_image_tensor,
+ download_url_to_video_output,
+ get_fs_object_size,
+ get_number_of_images,
+ poll_op,
+ sync_op,
+ upload_images_to_comfyapi,
+ validate_container_format_is_mp4,
+)
+
+UPSCALER_MODELS_MAP = {
+ "Starlight (Astra) Fast": "slf-1",
+ "Starlight (Astra) Creative": "slc-1",
+}
+UPSCALER_VALUES_MAP = {
+ "FullHD (1080p)": 1920,
+ "4K (2160p)": 3840,
+}
+
+
+class TopazImageEnhance(IO.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+ return IO.Schema(
+ node_id="TopazImageEnhance",
+ display_name="Topaz Image Enhance",
+ category="api node/image/Topaz",
+ description="Industry-standard upscaling and image enhancement.",
+ inputs=[
+ IO.Combo.Input("model", options=["Reimagine"]),
+ IO.Image.Input("image"),
+ IO.String.Input(
+ "prompt",
+ multiline=True,
+ default="",
+ tooltip="Optional text prompt for creative upscaling guidance.",
+ optional=True,
+ ),
+ IO.Combo.Input(
+ "subject_detection",
+ options=["All", "Foreground", "Background"],
+ optional=True,
+ ),
+ IO.Boolean.Input(
+ "face_enhancement",
+ default=True,
+ optional=True,
+ tooltip="Enhance faces (if present) during processing.",
+ ),
+ IO.Float.Input(
+ "face_enhancement_creativity",
+ default=0.0,
+ min=0.0,
+ max=1.0,
+ step=0.01,
+ display_mode=IO.NumberDisplay.number,
+ optional=True,
+ tooltip="Set the creativity level for face enhancement.",
+ ),
+ IO.Float.Input(
+ "face_enhancement_strength",
+ default=1.0,
+ min=0.0,
+ max=1.0,
+ step=0.01,
+ display_mode=IO.NumberDisplay.number,
+ optional=True,
+ tooltip="Controls how sharp enhanced faces are relative to the background.",
+ ),
+ IO.Boolean.Input(
+ "crop_to_fill",
+ default=False,
+ optional=True,
+ tooltip="By default, the image is letterboxed when the output aspect ratio differs. "
+ "Enable to crop the image to fill the output dimensions.",
+ ),
+ IO.Int.Input(
+ "output_width",
+ default=0,
+ min=0,
+ max=32000,
+ step=1,
+ display_mode=IO.NumberDisplay.number,
+ optional=True,
+ tooltip="Zero value means to calculate automatically (usually it will be original size or output_height if specified).",
+ ),
+ IO.Int.Input(
+ "output_height",
+ default=0,
+ min=0,
+ max=32000,
+ step=1,
+ display_mode=IO.NumberDisplay.number,
+ optional=True,
+ tooltip="Zero value means to output in the same height as original or output width.",
+ ),
+ IO.Int.Input(
+ "creativity",
+ default=3,
+ min=1,
+ max=9,
+ step=1,
+ display_mode=IO.NumberDisplay.slider,
+ optional=True,
+ ),
+ IO.Boolean.Input(
+ "face_preservation",
+ default=True,
+ optional=True,
+ tooltip="Preserve subjects' facial identity.",
+ ),
+ IO.Boolean.Input(
+ "color_preservation",
+ default=True,
+ optional=True,
+ tooltip="Preserve the original colors.",
+ ),
+ ],
+ outputs=[
+ IO.Image.Output(),
+ ],
+ hidden=[
+ IO.Hidden.auth_token_comfy_org,
+ IO.Hidden.api_key_comfy_org,
+ IO.Hidden.unique_id,
+ ],
+ is_api_node=True,
+ )
+
+ @classmethod
+ async def execute(
+ cls,
+ model: str,
+ image: torch.Tensor,
+ prompt: str = "",
+ subject_detection: str = "All",
+ face_enhancement: bool = True,
+ face_enhancement_creativity: float = 1.0,
+ face_enhancement_strength: float = 0.8,
+ crop_to_fill: bool = False,
+ output_width: int = 0,
+ output_height: int = 0,
+ creativity: int = 3,
+ face_preservation: bool = True,
+ color_preservation: bool = True,
+ ) -> IO.NodeOutput:
+ if get_number_of_images(image) != 1:
+ raise ValueError("Only one input image is supported.")
+ download_url = await upload_images_to_comfyapi(cls, image, max_images=1, mime_type="image/png")
+ initial_response = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/topaz/image/v1/enhance-gen/async", method="POST"),
+ response_model=topaz_api.ImageAsyncTaskResponse,
+ data=topaz_api.ImageEnhanceRequest(
+ model=model,
+ prompt=prompt,
+ subject_detection=subject_detection,
+ face_enhancement=face_enhancement,
+ face_enhancement_creativity=face_enhancement_creativity,
+ face_enhancement_strength=face_enhancement_strength,
+ crop_to_fill=crop_to_fill,
+ output_width=output_width if output_width else None,
+ output_height=output_height if output_height else None,
+ creativity=creativity,
+ face_preservation=str(face_preservation).lower(),
+ color_preservation=str(color_preservation).lower(),
+ source_url=download_url[0],
+ output_format="png",
+ ),
+ content_type="multipart/form-data",
+ )
+
+ await poll_op(
+ cls,
+ poll_endpoint=ApiEndpoint(path=f"/proxy/topaz/image/v1/status/{initial_response.process_id}"),
+ response_model=topaz_api.ImageStatusResponse,
+ status_extractor=lambda x: x.status,
+ progress_extractor=lambda x: getattr(x, "progress", 0),
+ price_extractor=lambda x: x.credits * 0.08,
+ poll_interval=8.0,
+ max_poll_attempts=160,
+ estimated_duration=60,
+ )
+
+ results = await sync_op(
+ cls,
+ ApiEndpoint(path=f"/proxy/topaz/image/v1/download/{initial_response.process_id}"),
+ response_model=topaz_api.ImageDownloadResponse,
+ monitor_progress=False,
+ )
+ return IO.NodeOutput(await download_url_to_image_tensor(results.download_url))
+
+
+class TopazVideoEnhance(IO.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+ return IO.Schema(
+ node_id="TopazVideoEnhance",
+ display_name="Topaz Video Enhance",
+ category="api node/video/Topaz",
+ description="Breathe new life into video with powerful upscaling and recovery technology.",
+ inputs=[
+ IO.Video.Input("video"),
+ IO.Boolean.Input("upscaler_enabled", default=True),
+ IO.Combo.Input("upscaler_model", options=list(UPSCALER_MODELS_MAP.keys())),
+ IO.Combo.Input("upscaler_resolution", options=list(UPSCALER_VALUES_MAP.keys())),
+ IO.Combo.Input(
+ "upscaler_creativity",
+ options=["low", "middle", "high"],
+ default="low",
+ tooltip="Creativity level (applies only to Starlight (Astra) Creative).",
+ optional=True,
+ ),
+ IO.Boolean.Input("interpolation_enabled", default=False, optional=True),
+ IO.Combo.Input("interpolation_model", options=["apo-8"], default="apo-8", optional=True),
+ IO.Int.Input(
+ "interpolation_slowmo",
+ default=1,
+ min=1,
+ max=16,
+ display_mode=IO.NumberDisplay.number,
+ tooltip="Slow-motion factor applied to the input video. "
+ "For example, 2 makes the output twice as slow and doubles the duration.",
+ optional=True,
+ ),
+ IO.Int.Input(
+ "interpolation_frame_rate",
+ default=60,
+ min=15,
+ max=240,
+ display_mode=IO.NumberDisplay.number,
+ tooltip="Output frame rate.",
+ optional=True,
+ ),
+ IO.Boolean.Input(
+ "interpolation_duplicate",
+ default=False,
+ tooltip="Analyze the input for duplicate frames and remove them.",
+ optional=True,
+ ),
+ IO.Float.Input(
+ "interpolation_duplicate_threshold",
+ default=0.01,
+ min=0.001,
+ max=0.1,
+ step=0.001,
+ display_mode=IO.NumberDisplay.number,
+ tooltip="Detection sensitivity for duplicate frames.",
+ optional=True,
+ ),
+ IO.Combo.Input(
+ "dynamic_compression_level",
+ options=["Low", "Mid", "High"],
+ default="Low",
+ tooltip="CQP level.",
+ optional=True,
+ ),
+ ],
+ outputs=[
+ IO.Video.Output(),
+ ],
+ hidden=[
+ IO.Hidden.auth_token_comfy_org,
+ IO.Hidden.api_key_comfy_org,
+ IO.Hidden.unique_id,
+ ],
+ is_api_node=True,
+ )
+
+ @classmethod
+ async def execute(
+ cls,
+ video: VideoInput,
+ upscaler_enabled: bool,
+ upscaler_model: str,
+ upscaler_resolution: str,
+ upscaler_creativity: str = "low",
+ interpolation_enabled: bool = False,
+ interpolation_model: str = "apo-8",
+ interpolation_slowmo: int = 1,
+ interpolation_frame_rate: int = 60,
+ interpolation_duplicate: bool = False,
+ interpolation_duplicate_threshold: float = 0.01,
+ dynamic_compression_level: str = "Low",
+ ) -> IO.NodeOutput:
+ if upscaler_enabled is False and interpolation_enabled is False:
+ raise ValueError("There is nothing to do: both upscaling and interpolation are disabled.")
+ src_width, src_height = video.get_dimensions()
+ video_components = video.get_components()
+ src_frame_rate = int(video_components.frame_rate)
+ duration_sec = video.get_duration()
+ estimated_frames = int(duration_sec * src_frame_rate)
+ validate_container_format_is_mp4(video)
+ src_video_stream = video.get_stream_source()
+ target_width = src_width
+ target_height = src_height
+ target_frame_rate = src_frame_rate
+ filters = []
+ if upscaler_enabled:
+ target_width = UPSCALER_VALUES_MAP[upscaler_resolution]
+ target_height = UPSCALER_VALUES_MAP[upscaler_resolution]
+ filters.append(
+ topaz_api.VideoEnhancementFilter(
+ model=UPSCALER_MODELS_MAP[upscaler_model],
+ creativity=(upscaler_creativity if UPSCALER_MODELS_MAP[upscaler_model] == "slc-1" else None),
+ isOptimizedMode=(True if UPSCALER_MODELS_MAP[upscaler_model] == "slc-1" else None),
+ ),
+ )
+ if interpolation_enabled:
+ target_frame_rate = interpolation_frame_rate
+ filters.append(
+ topaz_api.VideoFrameInterpolationFilter(
+ model=interpolation_model,
+ slowmo=interpolation_slowmo,
+ fps=interpolation_frame_rate,
+ duplicate=interpolation_duplicate,
+ duplicate_threshold=interpolation_duplicate_threshold,
+ ),
+ )
+ initial_res = await sync_op(
+ cls,
+ ApiEndpoint(path="/proxy/topaz/video/", method="POST"),
+ response_model=topaz_api.CreateVideoResponse,
+ data=topaz_api.CreateVideoRequest(
+ source=topaz_api.CreateCreateVideoRequestSource(
+ container="mp4",
+ size=get_fs_object_size(src_video_stream),
+ duration=int(duration_sec),
+ frameCount=estimated_frames,
+ frameRate=src_frame_rate,
+ resolution=topaz_api.Resolution(width=src_width, height=src_height),
+ ),
+ filters=filters,
+ output=topaz_api.OutputInformationVideo(
+ resolution=topaz_api.Resolution(width=target_width, height=target_height),
+ frameRate=target_frame_rate,
+ audioCodec="AAC",
+ audioTransfer="Copy",
+ dynamicCompressionLevel=dynamic_compression_level,
+ ),
+ ),
+ wait_label="Creating task",
+ final_label_on_success="Task created",
+ )
+ upload_res = await sync_op(
+ cls,
+ ApiEndpoint(
+ path=f"/proxy/topaz/video/{initial_res.requestId}/accept",
+ method="PATCH",
+ ),
+ response_model=topaz_api.VideoAcceptResponse,
+ wait_label="Preparing upload",
+ final_label_on_success="Upload started",
+ )
+ if len(upload_res.urls) > 1:
+ raise NotImplementedError(
+ "Large files are not currently supported. Please open an issue in the ComfyUI repository."
+ )
+ async with aiohttp.ClientSession(headers={"Content-Type": "video/mp4"}) as session:
+ if isinstance(src_video_stream, BytesIO):
+ src_video_stream.seek(0)
+ async with session.put(upload_res.urls[0], data=src_video_stream, raise_for_status=True) as res:
+ upload_etag = res.headers["Etag"]
+ else:
+ with builtins.open(src_video_stream, "rb") as video_file:
+ async with session.put(upload_res.urls[0], data=video_file, raise_for_status=True) as res:
+ upload_etag = res.headers["Etag"]
+ await sync_op(
+ cls,
+ ApiEndpoint(
+ path=f"/proxy/topaz/video/{initial_res.requestId}/complete-upload",
+ method="PATCH",
+ ),
+ response_model=topaz_api.VideoCompleteUploadResponse,
+ data=topaz_api.VideoCompleteUploadRequest(
+ uploadResults=[
+ topaz_api.VideoCompleteUploadRequestPart(
+ partNum=1,
+ eTag=upload_etag,
+ ),
+ ],
+ ),
+ wait_label="Finalizing upload",
+ final_label_on_success="Upload completed",
+ )
+ final_response = await poll_op(
+ cls,
+ ApiEndpoint(path=f"/proxy/topaz/video/{initial_res.requestId}/status"),
+ response_model=topaz_api.VideoStatusResponse,
+ status_extractor=lambda x: x.status,
+ progress_extractor=lambda x: getattr(x, "progress", 0),
+ price_extractor=lambda x: (x.estimates.cost[0] * 0.08 if x.estimates and x.estimates.cost[0] else None),
+ poll_interval=10.0,
+ max_poll_attempts=320,
+ )
+ return IO.NodeOutput(await download_url_to_video_output(final_response.download.url))
+
+
+class TopazExtension(ComfyExtension):
+ @override
+ async def get_node_list(self) -> list[type[IO.ComfyNode]]:
+ return [
+ TopazImageEnhance,
+ TopazVideoEnhance,
+ ]
+
+
+async def comfy_entrypoint() -> TopazExtension:
+ return TopazExtension()
diff --git a/comfy_api_nodes/util/client.py b/comfy_api_nodes/util/client.py
index 2d5dcd648..ad6e3c0d0 100644
--- a/comfy_api_nodes/util/client.py
+++ b/comfy_api_nodes/util/client.py
@@ -77,9 +77,9 @@ class _PollUIState:
_RETRY_STATUS = {408, 429, 500, 502, 503, 504}
-COMPLETED_STATUSES = ["succeeded", "succeed", "success", "completed", "finished", "done"]
-FAILED_STATUSES = ["cancelled", "canceled", "fail", "failed", "error"]
-QUEUED_STATUSES = ["created", "queued", "queueing", "submitted"]
+COMPLETED_STATUSES = ["succeeded", "succeed", "success", "completed", "finished", "done", "complete"]
+FAILED_STATUSES = ["cancelled", "canceled", "canceling", "fail", "failed", "error"]
+QUEUED_STATUSES = ["created", "queued", "queueing", "submitted", "initializing"]
async def sync_op(
@@ -424,7 +424,8 @@ def _display_text(
if status:
display_lines.append(f"Status: {status.capitalize() if isinstance(status, str) else status}")
if price is not None:
- display_lines.append(f"Price: ${float(price):,.4f}")
+ p = f"{float(price):,.4f}".rstrip("0").rstrip(".")
+ display_lines.append(f"Price: ${p}")
if text is not None:
display_lines.append(text)
if display_lines:
diff --git a/nodes.py b/nodes.py
index f6aeedc78..ac14e39a7 100644
--- a/nodes.py
+++ b/nodes.py
@@ -2359,6 +2359,7 @@ async def init_builtin_api_nodes():
"nodes_pika.py",
"nodes_runway.py",
"nodes_sora.py",
+ "nodes_topaz.py",
"nodes_tripo.py",
"nodes_moonvalley.py",
"nodes_rodin.py",