Support FORM post request, Add Chainable Image, and Image Converters (Base64 / Blob)

Author: felixszeto

README.md

@@ -8,8 +8,12 @@ ComfyUI-RequestNodes is a custom node plugin for ComfyUI that provides functiona
 
 *   **Get Request Node**: Sends GET requests and retrieves responses.
 *   **Post Request Node**: Sends POST requests and retrieves responses.
+*   **Form Post Request Node**: Sends POST requests in `multipart/form-data` format, supporting file (image) uploads.
 *   **Rest Api Node**: A versatile node for sending various HTTP methods (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS) with retry settings.
+*   **Image to Base64 Node**: Converts an image to a Base64 encoded string.
+*   **Image to Blob Node**: Converts an image to a Blob (Binary Large Object).
 *   **Key/Value Node**: Creates key/value pairs for building request parameters, headers, or other dictionary-like structures.
+*   **Chain Image Node**: Uploads an image and adds it to an image batch, allowing for chaining to build a batch from multiple images.
 *   **String Replace Node**: Replaces placeholders in a string with provided values.
 *   **Retry Settings Node**: Creates retry setting configurations for the Rest Api Node.
 
@@ -21,6 +25,8 @@ The plugin includes the following test resources:
 ![rest_node](workflows/get_node.png)
 * `post_node.json` - POST request workflow template
 ![rest_node](workflows/post_node.png)
+* `form-post-request-node.json` - FORM POST request workflow template
+![rest_node](workflows/form-post-request-node.png)
 * `workflows/rest_node.json` - REST API request workflow template
 ![rest_node](workflows/rest_node.png)
 
@@ -73,6 +79,33 @@ After installation, you can find the nodes under the "RequestNode" category in t
         *   `any` (ANY): The raw response content.
     *   ![image](https://github.com/user-attachments/assets/6eda9fef-48cf-478c-875e-6bd6d850bff2)
 
+*   **Form Post Request Node**:
+    *   **Category**: RequestNode/Post Request
+    *   **Inputs**:
+        *   `target_url` (STRING, required): The URL to send the POST request to.
+        *   `image` (IMAGE, required): The image or image batch to upload. If an image batch is provided, all images will be sent in the same request.
+        *   `image_field_name` (STRING, required): The field name for the image in the form.
+        *   `form_fields` (KEY_VALUE, optional): Other form fields, typically from a Key/Value Node.
+        *   `headers` (KEY_VALUE, optional): Request headers, typically from a Key/Value Node.
+    *   **Outputs**:
+        *   `text` (STRING): The response body as text.
+        *   `json` (JSON): The response body parsed as JSON (if valid).
+        *   `any` (ANY): The raw response content.
+
+*   **Image to Base64 Node**:
+    *   **Category**: RequestNode/Converters
+    *   **Inputs**:
+        *   `image` (IMAGE, required): The image to convert.
+    *   **Outputs**:
+        *   `STRING`: The Base64 encoded image string.
+
+*   **Image to Blob Node**:
+    *   **Category**: RequestNode/Converters
+    *   **Inputs**:
+        *   `image` (IMAGE, required): The image to convert.
+    *   **Outputs**:
+        *   `BYTES`: The raw binary data of the image.
+
 *   **Rest Api Node**:
     *   **Category**: RequestNode/REST API
     *   **Inputs**:
@@ -99,6 +132,17 @@ After installation, you can find the nodes under the "RequestNode" category in t
         *   `KEY_VALUE` (KEY_VALUE): A dictionary containing the key/value pair(s).
     *   ![image](https://github.com/user-attachments/assets/dfe7dab0-2b1b-4f99-ac6f-89e01d03b7e0)
 
+*   **Chain Image Node**:
+    *   **Category**: RequestNode/Utils
+    *   **Description**: This node allows you to upload an image and add it to an image batch. You can chain multiple nodes of this type together to create a batch of several images. If you upload images with different dimensions, this node will automatically resize subsequent images to match the dimensions of the first one in the batch.
+    *   **Inputs**:
+        *   `image` (IMAGE, required): The image to upload. Use the "choose file to upload" button.
+        *   `image_batch_in` (IMAGE, optional): An existing image batch to append the newly uploaded image to. This can be connected from another `Chain Image Node` to build a batch.
+    *   **Outputs**:
+        *   `image_batch_out` (IMAGE): The combined image batch.
+    *   **Example**:
+    *   ![image](workflows/chainable_upload_image_node.png)
+
 *   **String Replace Node**:
     *   **Category**: RequestNode/Utils
     *   **Inputs**:

README_zh.md

@@ -8,8 +8,12 @@ ComfyUI-RequestNodes 是一個用於 ComfyUI 的自訂節點插件，提供了
 
 *   **Get Request Node**: 發送 GET 請求並檢索響應。
 *   **Post Request Node**: 發送 POST 請求並檢索響應。
+*   **Form Post Request Node**: 發送 `multipart/form-data` 格式的 POST 請求，支援檔案（圖片）上傳。
 *   **Rest Api Node**: 一個多功能的節點，用於發送各種 HTTP 方法 (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS) 並支援重試設定。
+*   **Image to Base64 Node**: 將圖片轉換為 Base64 編碼的字串。
+*   **Image to Blob Node**: 將圖片轉換為 Blob (二進位大型物件)。
 *   **Key/Value Node**: 創建鍵/值對，用於構建請求參數、標頭或其他類似字典的結構。
+*   **Chain Image Node**: 上傳圖片並將其添加到圖片批次中，支援鏈式操作以構建多圖批次。
 *   **String Replace Node**: 使用提供的值替換字串中的佔位符。
 *   **Retry Settings Node**: 為 Rest Api Node 創建重試設定配置。
 
@@ -21,6 +25,8 @@ ComfyUI-RequestNodes 是一個用於 ComfyUI 的自訂節點插件，提供了
 ![rest_node](workflows/get_node.png)
 * `post_node.json` - POST 請求工作流程模板
 ![rest_node](workflows/post_node.png)
+* `form-post-request-node.json` - FORM POST 請求工作流程模板
+![rest_node](workflows/form-post-request-node.png)
 * `workflows/rest_node.json` - REST API 請求工作流程模板
 ![rest_node](workflows/rest_node.png)
 
@@ -73,6 +79,33 @@ ComfyUI-RequestNodes 是一個用於 ComfyUI 的自訂節點插件，提供了
         *   `any` (ANY): 原始響應內容。
     *   ![image](https://github.com/user-attachments/assets/6eda9fef-48cf-478c-875e-6bd6d850bff2)
 
+*   **Form Post Request Node**:
+    *   **分類**: RequestNode/Post Request
+    *   **輸入**:
+        *   `target_url` (STRING, 必需): 要發送 POST 請求的 URL。
+        *   `image` (IMAGE, 必需): 要上傳的圖片或圖片批次。如果提供圖片批次，所有圖片將在同一個請求中發送。
+        *   `image_field_name` (STRING, 必需): 圖片在表單中的欄位名稱。
+        *   `form_fields` (KEY_VALUE, 可選): 其他表單欄位，通常來自 Key/Value Node。
+        *   `headers` (KEY_VALUE, 可選): 請求標頭，通常來自 Key/Value Node。
+    *   **輸出**:
+        *   `text` (STRING): 響應主體作為文本。
+        *   `json` (JSON): 響應主體解析為 JSON (如果有效)。
+        *   `any` (ANY): 原始響應內容。
+
+*   **Image to Base64 Node**:
+    *   **分類**: RequestNode/Converters
+    *   **輸入**:
+        *   `image` (IMAGE, 必需): 要轉換的圖片。
+    *   **輸出**:
+        *   `STRING`: Base64 編碼的圖片字串。
+
+*   **Image to Blob Node**:
+    *   **分類**: RequestNode/Converters
+    *   **輸入**:
+        *   `image` (IMAGE, 必需): 要轉換的圖片。
+    *   **輸出**:
+        *   `BYTES`: 圖片的原始二進位資料。
+
 *   **Rest Api Node**:
     *   **分類**: RequestNode/REST API
     *   **輸入**:
@@ -99,6 +132,17 @@ ComfyUI-RequestNodes 是一個用於 ComfyUI 的自訂節點插件，提供了
         *   `KEY_VALUE` (KEY_VALUE): 包含鍵值對的字典。
     *   ![image](https://github.com/user-attachments/assets/dfe7dab0-2b1b-4f99-ac6f-89e01d03b7e0)
 
+*   **Chain Image Node**:
+    *   **分類**: RequestNode/Utils
+    *   **說明**: 此節點允許您上傳一張圖片並將其添加到圖片批次中。您可以將多個此類型的節點鏈接在一起，以創建包含多張圖片的批次。如果您上傳的圖片尺寸不同，此節點會自動將後續圖片的大小調整為與批次中第一張圖片的尺寸相符。
+    *   **輸入**:
+        *   `image` (IMAGE, 必需): 要上傳的圖片。請使用 "choose file to upload" 按鈕。
+        *   `image_batch_in` (IMAGE, 可選): 一個已有的圖片批次，用於附加新上傳的圖片。可連接另一個 `Chain Image Node` 的輸出來構建批次。
+    *   **輸出**:
+        *   `image_batch_out` (IMAGE): 合併後的圖片批次。
+    *   **範例**:
+    *   ![image](workflows/chainable_upload_image_node.png)
+
 *   **String Replace Node**:
     *   **分類**: RequestNode/Utils
     *   **輸入**:

__init__.py

@@ -6,13 +6,22 @@
 from .rest_api_node import RestApiNode
 from .string_replace_node import StringReplaceNode
 from .retry_setting_node import RetrySettingNode
+from .form_post_node import FormPostRequestNode
+from .image_to_base64_node import ImageToBase64Node
+from .image_to_blob_node import ImageToBlobNode
+from .image_list_combiner_node import ChainableUploadImage
 
 
-NODE_CLASS_MAPPINGS = { 
+
+NODE_CLASS_MAPPINGS = {
     "Get Request Node": GetRequestNode,
     "Post Request Node": PostRequestNode,
+    "Form Post Request Node": FormPostRequestNode,
     "Rest Api Node": RestApiNode,
     "Key/Value Node": KeyValueNode,
     "String Replace Node": StringReplaceNode,
-    "Retry Settings Node": RetrySettingNode
-}
+    "Retry Settings Node": RetrySettingNode,
+    "Image To Base64 Node": ImageToBase64Node,
+    "Image To Blob Node": ImageToBlobNode,
+    "Chainable Upload Image": ChainableUploadImage,
+}

base_flask_server.py

@@ -6,6 +6,7 @@
 import traceback
 from werkzeug.exceptions import HTTPException
 import random
+import os
 
 app = Flask(__name__)
 CORS(app)
@@ -150,6 +151,40 @@ def return_request_info():
         print(f"处理 /api/request_info 请求时出错: {str(e)}")
         return jsonify({"error": "处理请求时发生错误", "details": str(e)}), 500
 
+@app.route('/api/form_test', methods=['POST'])
+def handle_form_post():
+    print(f"Received POST request on /api/form_test")
+    try:
+        form_data = request.form.to_dict()
+        files_info = {}
+        if request.files:
+            upload_folder = 'uploads'
+            if not os.path.exists(upload_folder):
+                os.makedirs(upload_folder)
+            
+            for field_name in request.files:
+                files_info[field_name] = []
+                for file_storage in request.files.getlist(field_name):
+                    filename = file_storage.filename
+                    file_path = os.path.join(upload_folder, filename)
+                    file_storage.save(file_path)
+                    
+                    files_info[field_name].append({
+                        "filename": filename,
+                        "content_type": file_storage.content_type,
+                        "saved_path": file_path
+                    })
+
+        response_data = {
+            "received_form_data": form_data,
+            "received_files_info": files_info
+        }
+        print(f"Form test data: {response_data}")
+        return jsonify(response_data)
+    except Exception as e:
+        print(f"处理 /api/form_test 请求时出错: {str(e)}")
+        return jsonify({"error": "处理请求时发生错误", "details": str(e)}), 500
+
 
 if __name__ == "__main__":
     print("Starting RestApiNode test server...")

form_post_node.py

@@ -0,0 +1,79 @@
+import requests
+import json
+import io
+import torch
+import numpy as np
+from PIL import Image
+
+class FormPostRequestNode:
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "target_url": ("STRING", {"default": "http://127.0.0.1:7788/api/echo"}),
+                "image": ("IMAGE",),
+                "image_field_name": ("STRING", {"default": "image"}),
+            },
+            "optional": {
+                "form_fields": ("KEY_VALUE",),
+                "headers": ("KEY_VALUE",),
+            }
+        }
+ 
+    RETURN_TYPES = ("STRING", "JSON", "ANY")
+    RETURN_NAMES = ("text", "json", "any")
+ 
+    FUNCTION = "make_form_post_request"
+ 
+    CATEGORY = "RequestNode/Post Request"
+ 
+    def make_form_post_request(self, target_url, image, image_field_name, form_fields=None, headers=None):
+        files = []
+        for i, single_image in enumerate(image):
+            # Convert tensor to PIL Image
+            img_np = 255. * single_image.cpu().numpy()
+            img = Image.fromarray(np.clip(img_np, 0, 255).astype(np.uint8))
+            
+            # Save image to a byte buffer
+            buffer = io.BytesIO()
+            img.save(buffer, format='PNG')
+            buffer.seek(0)
+            
+            files.append((image_field_name, (f'image_{i}.png', buffer, 'image/png')))
+        
+        data = form_fields if form_fields else {}
+        
+        request_headers = {}
+        if headers:
+            request_headers.update(headers)
+            
+        try:
+            response = requests.post(target_url, files=files, data=data, headers=request_headers)
+            
+            text_output = response.text
+            
+            try:
+                json_output = response.json()
+            except json.JSONDecodeError:
+                json_output = {"error": "Response is not valid JSON"}
+            
+            any_output = response.content
+            
+        except Exception as e:
+            error_message = str(e)
+            text_output = error_message
+            json_output = {"error": error_message}
+            any_output = error_message.encode()
+        
+        return (text_output, json_output, any_output)
+ 
+NODE_CLASS_MAPPINGS = {
+    "FormPostRequestNode": FormPostRequestNode
+}
+ 
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "FormPostRequestNode": "Form Post Request Node"
+}

image_list_combiner_node.py

@@ -0,0 +1,78 @@
+import torch
+import time
+import torch.nn.functional as F
+
+class ChainableUploadImage:
+    """
+    A node that allows uploading an image and adding it to an image batch.
+    It can be chained with other nodes of the same type to build a batch of images,
+    similar to the default 'Load Image' node but with chaining capability.
+    """
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                # This widget tells the frontend to show an upload button
+                "image": ("IMAGE", {"image_upload": True})
+            },
+            "optional": {
+                "image_batch_in": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image_batch_out",)
+    FUNCTION = "load_and_chain"
+    CATEGORY = "RequestNode/Utils"
+
+    def load_and_chain(self, image, image_batch_in=None):
+        # The 'image' parameter from the upload widget is already a tensor.
+        # No file loading or conversion is needed.
+        
+        # 'image' is a tensor of shape [1, H, W, C]
+        if image_batch_in is None:
+            # Start a new batch with the uploaded image.
+            return (image,)
+        else:
+            # Get the dimensions of the incoming batch
+            target_h = image_batch_in.shape[1]
+            target_w = image_batch_in.shape[2]
+
+            # Get the dimensions of the new image
+            current_h = image.shape[1]
+            current_w = image.shape[2]
+
+            # Resize if dimensions don't match
+            if current_h != target_h or current_w != target_w:
+                # Permute from [B, H, W, C] to [B, C, H, W] for interpolation
+                image_permuted = image.permute(0, 3, 1, 2)
+                # Resize
+                resized_image_permuted = F.interpolate(
+                    image_permuted,
+                    size=(target_h, target_w),
+                    mode='bilinear',
+                    align_corners=False
+                )
+                # Permute back to [B, H, W, C]
+                image = resized_image_permuted.permute(0, 2, 3, 1)
+
+            # Concatenate the incoming batch with the new (potentially resized) image tensor.
+            combined_tensor = torch.cat((image_batch_in, image), dim=0)
+            return (combined_tensor,)
+
+    @classmethod
+    def IS_CHANGED(s, image, image_batch_in=None):
+        # Since the image is an uploaded tensor, we can't hash a file.
+        # We'll return the current time to ensure the node re-executes
+        # whenever a new image is uploaded.
+        return time.time()
+
+# For ComfyUI to discover this node
+NODE_CLASS_MAPPINGS = {
+    "ChainableUploadImage": ChainableUploadImage
+}
+
+# A friendly name for the node in the UI
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ChainableUploadImage": "Upload and Chain Image"
+}