bizydraft 0.1.30__py3-none-any.whl → 0.2.1__py3-none-any.whl

bizydraft/static/js/nodeParamsFilter.js

@@ -0,0 +1,136 @@
+/**
+ * 节点参数过滤工具
+ * 用于处理节点参数在发布模式下的过滤
+ */
+
+// 存储从服务端获取的节点参数信息
+let nodeParamsMap = new Map();
+
+/**
+ * 设置节点参数映射
+ * @param {Array} inputsData - 服务端返回的inputs数组
+ */
+function setNodeParams(inputsData) {
+    if (!Array.isArray(inputsData)) {
+        console.error('Invalid inputs data format:', inputsData);
+        return;
+    }
+
+    // 清空现有映射
+    nodeParamsMap.clear();
+
+    // 构建新的映射
+    inputsData.forEach(nodeInfo => {
+        if (nodeInfo && nodeInfo.nodeId && Array.isArray(nodeInfo.params)) {
+            // 以nodeId为键，存储参数信息
+            const paramNames = nodeInfo.params.map(param => param.name);
+            nodeParamsMap.set(nodeInfo.nodeId, {
+                name: nodeInfo.name,
+                displayName: nodeInfo.displayName,
+                paramNames: paramNames,
+                params: nodeInfo.params
+            });
+        }
+    });
+
+    console.log('节点参数映射已更新:', nodeParamsMap);
+}
+
+/**
+ * 过滤节点参数
+ * @param {Object} node - 节点对象
+ * @returns {Object|null} - 过滤后的节点信息，如果节点不符合条件则返回null
+ */
+function filterNodeWidgets(node) {
+    if (!node || !node.id) return null;
+
+    // 如果节点ID不在参数映射中，则不是可配置节点
+    if (!nodeParamsMap.has(String(node.id))) {
+        console.log(`节点 ${node.id} 不在可配置列表中`);
+        return null;
+    }
+
+    // 获取节点的允许参数列表
+    const nodeParamsInfo = nodeParamsMap.get(String(node.id));
+    const allowedParamNames = nodeParamsInfo.paramNames;
+
+    // 提取节点信息
+    const nodeInfo = {
+        id: node.id,
+        type: node.type,
+        comfyClass: node.comfyClass,
+        title: node.title || nodeParamsInfo.displayName,
+        widgets: []
+    };
+
+    // 过滤widgets，只保留在allowedParamNames中的widget
+    if (node.widgets && node.widgets.length > 0) {
+        nodeInfo.widgets = node.widgets
+            .filter(widget => {
+                return widget.type !== "hidden" &&
+                       !widget.disabled &&
+                       allowedParamNames.includes(String(widget.name));
+            })
+            .map(widget => {
+                const widgetInfo = {
+                    name: String(widget.name || ""),
+                    value: widget.value != null ? widget.value : "",
+                    type: String(widget.type || "")
+                };
+
+                // 处理options属性
+                if (widget.options && widget.options.values) {
+                    widgetInfo.options = { values: [] };
+
+                    if (Array.isArray(widget.options.values)) {
+                        widgetInfo.options.values = [...widget.options.values];
+                    } else if (typeof widget.options.values === 'function') {
+                        try {
+                            const values = widget.options.values();
+                            if (Array.isArray(values)) {
+                                widgetInfo.options.values = [...values];
+                            }
+                        } catch (e) {
+                            // 忽略错误
+                        }
+                    }
+                }
+
+                return widgetInfo;
+            });
+    }
+
+    // 如果过滤后没有可配置的参数，则不符合条件
+    if (nodeInfo.widgets.length === 0) {
+        console.log(`节点 ${node.id} 没有可配置的参数`);
+        return null;
+    }
+
+    return nodeInfo;
+}
+
+/**
+ * 检查节点是否可配置
+ * @param {number|string} nodeId - 节点ID
+ * @returns {boolean} - 节点是否可配置
+ */
+function isConfigurableNode(nodeId) {
+    return nodeParamsMap.has(String(nodeId));
+}
+
+/**
+ * 获取节点原始参数信息
+ * @param {number|string} nodeId - 节点ID
+ * @returns {Object|null} - 节点参数信息
+ */
+function getNodeParamsInfo(nodeId) {
+    return nodeParamsMap.get(String(nodeId)) || null;
+}
+
+// 导出模块
+export {
+    setNodeParams,
+    filterNodeWidgets,
+    isConfigurableNode,
+    getNodeParamsInfo
+};

bizydraft/static/js/postEvent.js

@@ -1,4 +1,6 @@
 import { app } from "../../scripts/app.js";
+import { enableAIAppMode, disableAIAppMode, selectInputNode, deselectInputNode, updateInputNodeWidget, getSelectedInputNodes, clearSelectedInputNodes, toggleExportMode } from "./aiAppHandler.js";
+import { focusNodeOnly } from "./nodeFocusHandler.js";
 
 app.registerExtension({
     name: "comfy.BizyAir.Socket",
@@ -184,8 +186,15 @@ app.registerExtension({
                             method: 'progress_info_change',
                             result: msg.progress_info
                         }, '*');
-
                         switch (msg.type) {
+                            case 'load_start':
+                            case 'load_end':
+                            case 'prompt_id':
+                                window.parent.postMessage({
+                                    type: 'functionResult',
+                                    method: 'preparingStatus',
+                                    result: msg
+                                }, '*')
                             case 'status':
                                 if (msg.data.sid) {
                                     const clientId = msg.data.sid;
@@ -209,6 +218,17 @@ app.registerExtension({
                                 }
                                 dispatchCustomEvent(msg.type, msg.data);
                                 break;
+                            case 'error':
+                                self.taskRunning = false;
+                                dispatchCustomEvent('execution_error', {
+                                    exception_message: msg.data.error_message || 'Unknown error',
+                                    traceback: ['Manual error triggered'],
+                                    executed: [],
+                                    prompt_id: 'manual',
+                                    node_id: '0',
+                                    node_type: 'RunError',
+                                });
+                                break;
                             case 'execution_error':
                             case 'execution_interrupted':
                                 self.taskRunning = false;
@@ -411,14 +431,11 @@ app.registerExtension({
 
     async setup() {
         const createSocket = this.createSocket.bind(this);
-        const getSocket = this.getSocket.bind(this);
-        const getSocketAsync = this.getSocketAsync.bind(this);
         const closeSocket = this.closeSocket.bind(this);
-        const changeSocketUrl = this.changeSocketUrl.bind(this);
-        const sendSocketMessage = this.sendSocketMessage.bind(this);
-        const sendPrompt = this.sendPrompt.bind(this);
-        const startPing = this.startPing.bind(this);
-        const stopPing = this.stopPing.bind(this);
+
+        const customErrorStyles = new Map()
+
+
 
         // 方法映射
         const methods = {
@@ -432,26 +449,6 @@ app.registerExtension({
                 return socket;
             },
 
-            startSocket: async function (params) {
-                try {
-                    const socket = await getSocketAsync(params.url);
-                    window.parent.postMessage({
-                        type: 'functionResult',
-                        method: 'startSocket',
-                        result: 'Socket连接已启动'
-                    }, '*');
-                    return socket;
-                } catch (error) {
-                    window.parent.postMessage({
-                        type: 'functionResult',
-                        method: 'startSocket',
-                        result: 'Socket连接失败: ' + error.message,
-                        error: true
-                    }, '*');
-                    return null;
-                }
-            },
-
             closeSocket: function () {
                 const result = closeSocket();
                 window.parent.postMessage({
@@ -462,34 +459,6 @@ app.registerExtension({
                 return result;
             },
 
-            changeSocketUrl: function (params) {
-                if (!params.url) {
-                    console.error('缺少url参数');
-                    return false;
-                }
-                const socket = changeSocketUrl(params.url);
-                window.parent.postMessage({
-                    type: 'functionResult',
-                    method: 'changeSocketUrl',
-                    result: 'Socket URL已更改为' + params.url
-                }, '*');
-                return socket;
-            },
-
-            sendSocketMessage: async function (params) {
-                if (!params.message) {
-                    console.error('缺少message参数');
-                    return false;
-                }
-                const result = await sendSocketMessage(params.message);
-                window.parent.postMessage({
-                    type: 'functionResult',
-                    method: 'sendSocketMessage',
-                    result: result ? '消息发送成功' : '消息发送失败'
-                }, '*');
-                return result;
-            },
-
             clearCanvas: function () {
                 app.graph.clear();
                 window.parent.postMessage({
@@ -499,11 +468,10 @@ app.registerExtension({
                 }, '*');
                 return true;
             },
-
             loadWorkflow: function (params) {
                 app.graph.clear();
                 document.dispatchEvent(new CustomEvent('workflowLoaded', {
-                    detail: params
+                    detail: params.json
                 }));
                 if (params.json.version) {
                     app.loadGraphData(params.json);
@@ -537,6 +505,19 @@ app.registerExtension({
                 }, '*');
                 return graph.workflow;
             },
+            // 新增：获取 workflow 和 output
+            getWorkflowWithOutput: async function () {
+                const graph = await app.graphToPrompt();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'getWorkflowWithOutput',
+                    result: {
+                        workflow: graph.workflow,
+                        output: graph.output
+                    }
+                }, '*');
+                return { workflow: graph.workflow, output: graph.output };
+            },
             saveApiJson: async function (params) {
                 const graph = await app.graphToPrompt();
                 window.parent.postMessage({
@@ -562,6 +543,7 @@ app.registerExtension({
 
                     const graph = await app.graphToPrompt();
                     const clientId = sessionStorage.getItem("clientId");
+                    await app.queuePrompt(graph.output);
                     const resPrompt = await fetch("api/prompt", {
                         method: "POST",
                         body: JSON.stringify({
@@ -577,8 +559,45 @@ app.registerExtension({
                     });
                     const resPromptJson = await resPrompt.json();
                     if (resPromptJson.error) {
-                        await app.queuePrompt(graph.output);
+                        this.openCustomError({
+                            nodeId: resPromptJson.node_id,
+                            nodeType: resPromptJson.node_type,
+                            errorMessage: resPromptJson.error,
+                            borderColor: '#FF0000'
+                        })
+                        return
+                    }
+
+                    for (const i in resPromptJson.node_errors) {
+
+                        if (resPromptJson.node_errors[i].errors) {
+                            const err = resPromptJson.node_errors[i].errors[0]
+                            if (err) return
+                            this.openCustomError({
+                                nodeId: i,
+                                nodeType: err.type,
+                                errorMessage: err.error,
+                                borderColor: '#FF0000'
+                            })
+                            return
+                        } else {
+                            console.log(resPromptJson.node_errors[i])
+                        }
                     }
+
+                    if (Object.keys(resPromptJson.node_errors).length) return
+                    graph.workflow.nodes.forEach(node => {
+                        for (const key in graph.output) {
+                            if (graph.output[key].class_type === node.type) {
+                                if (!graph.output[key]._meta) {
+                                    graph.output[key]._meta = {};
+                                }
+                                graph.output[key]._meta.id = node.id;
+                                break; // 找到匹配的就跳出循环
+                            }
+                        }
+                    });
+                    console.log(graph.output)
                     window.parent.postMessage({
                         type: 'functionResult',
                         method: 'runWorkflow',
@@ -611,7 +630,8 @@ app.registerExtension({
                     }
                     document.cookie = name + "=" + (value || "") + expires + "; path=/";
                 };
-                console.log("-----------setCookie-----------", params)
+                // console.log("-----------setCookie-----------", params)
+                // console.log("-----------setCookie-----------", params)
                 setCookie(params.name, params.value, params.days);
 
 
@@ -675,11 +695,13 @@ app.registerExtension({
                 return graph.workflow;
             },
 
-            graphToPrompt: async function () {
+            graphToPrompt: async function (params) {
+                console.log('postEvent.js - graphToPrompt被调用，参数:', params);
                 const graph = await app.graphToPrompt();
                 window.parent.postMessage({
                     type: 'functionResult',
                     method: 'graphToPrompt',
+                    params: params, // 传递原始参数
                     result: {
                         workflow: graph.workflow,
                         output: graph.output
@@ -703,8 +725,204 @@ app.registerExtension({
                     }, '*');
                     return true;
             },
+
+            // AI应用相关方法
+            toggleAIAppMode: function(params) {
+                const enable = params.enable === true;
+                const result = enable ? enableAIAppMode() : disableAIAppMode();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'toggleAIAppMode',
+                    result: result
+                }, '*');
+                return result;
+            },
+
+            selectInputNode: function(params) {
+                if (!params.nodeId) return false;
+                const result = selectInputNode(params.nodeId);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'selectInputNode',
+                    result: result
+                }, '*');
+                return result;
+            },
+
+            selectExportNode: function(params) {
+                if (!params.nodeId) return false;
+                const result = selectInputNode(params.nodeId);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'selectExportNode',
+                    result: result
+                }, '*');
+                return result;
+            },
+
+            deselectInputNode: function(params) {
+                if (!params.nodeId) return false;
+                const result = deselectInputNode(params.nodeId);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'deselectInputNode',
+                    result: result
+                }, '*');
+                return result;
+            },
+
+            updateInputNodeWidget: function(params) {
+                if (!params.nodeId || params.widgetName === undefined) return false;
+                const result = updateInputNodeWidget(params.nodeId, params.widgetName, params.value);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'updateInputNodeWidget',
+                    result: result
+                }, '*');
+                return result;
+            },
+
+            getInputNodes: function() {
+                const result = getSelectedInputNodes();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'getInputNodes',
+                    result: result
+                }, '*');
+                return result;
+            },
+
+            clearInputNodes: function() {
+                const result = clearSelectedInputNodes();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'clearInputNodes',
+                    result: result
+                }, '*');
+                return result;
+            },
+            toggleExportMode: function(params) {
+                const result = toggleExportMode(params);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'toggleExportMode',
+                    result: result
+                }, '*');
+                return result;
+            },
+            openCustomError: function (params) {
+                const { nodeId, nodeType, errorMessage, borderColor='#FF0000' } = params;
+                const nodeIds = Array.isArray(nodeId) ? nodeId : [nodeId];
+                function injectErrorDialogStyles() {
+                    const styleId = 'custom-error-dialog-styles';
+                    if (document.getElementById(styleId)) {
+                        return; // 样式已经存在
+                    }
+
+                    const style = document.createElement('style');
+                    style.id = styleId;
+                    style.textContent = `
+                        .comfy-error-report .no-results-placeholder p {
+                            text-align: left;
+                        }
+                    `;
+                    document.head.appendChild(style);
+                };
+                injectErrorDialogStyles()
+                function simulateExecutionError(nodeId, nodeType, errorMessage, borderColor) {
+                    // const originalNodeErrorStyle = node.strokeStyles?.['nodeError']
+                    const node = app.graph.getNodeById(nodeId)
+                    if (!node) return
+                    if (!customErrorStyles.has(nodeId)) {
+                        customErrorStyles.set(nodeId, {
+                          originalStyle: node.strokeStyles?.['nodeError'],
+                          customColor: borderColor,
+                          nodeId: nodeId
+                        })
+                    }
+                    node.strokeStyles = node.strokeStyles || {}
+                    node.strokeStyles['nodeError'] = function () {
+                        // if (this.id === nodeId) {
+                        return { color: borderColor, lineWidth: 2 } // 自定义颜色和线宽
+                        // }
+                    }
+                    const mockErrorEvent = {
+                        detail: {
+                            node_id: nodeId,
+                            node_type: nodeType,
+                            exception_message: errorMessage,
+                            exception_type: 'ManualError',
+                            traceback: ['Manual error triggered'],
+                            executed: [],
+                            prompt_id: 'manual',
+                            timestamp: Date.now()
+                        }
+                    }
+
+                    // 手动触发事件监听器
+                    app.api.dispatchCustomEvent('execution_error', mockErrorEvent.detail)
+                }
+
+                nodeIds.forEach(id => {
+                    simulateExecutionError(id, nodeType, errorMessage, borderColor)
+                })
+
+                app.canvas.draw(true, true)
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'openCustomError',
+                    result: true
+                }, '*');
+            },
+            clearAllCustomStyles: function () {
+                customErrorStyles.forEach((styleInfo, nodeId) => {
+                  const node = app.graph.getNodeById(nodeId)
+                  if (!node) return
+                  console.log(node)
+                  // 恢复原始样式
+                  if (styleInfo.originalStyle) {
+                    node.strokeStyles['nodeError'] = styleInfo.originalStyle
+                  } else {
+                    delete node.strokeStyles['nodeError']
+                  }
+
+                  // 从映射中移除
+                  customErrorStyles.delete(nodeId)
+                })
+
+                // 重绘画布
+                app.canvas.draw(true, true)
+            },
+            focusNodeOnly: function(params) {
+                if (!params.nodeId) return false;
+                const result = focusNodeOnly(params.nodeId);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'focusNodeOnly',
+                    result: result
+                }, '*');
+                return result;
+            },
         };
 
+        methods.deselectExportNode = function(params) {
+            if (params && params.nodeId !== undefined) {
+                if (typeof window.deselectInputNode === 'function') {
+                    window.deselectInputNode(params.nodeId);
+                }
+            }
+        };
+        methods.clearExportNodes = function() {
+            if (typeof window.clearExportNodes === 'function') {
+                window.clearExportNodes();
+            }
+        };
+        // 保存工作流的原始节点颜色信息
+        methods.saveOriginalNodeColors = function(params) {
+            if (typeof window.saveOriginalNodeColors === 'function') {
+                window.saveOriginalNodeColors(params.workflowId);
+            }
+        };
         window.addEventListener('message', function (event) {
             if (event.data && event.data.type === 'callMethod') {
                 const methodName = event.data.method;
@@ -732,5 +950,17 @@ app.registerExtension({
             }
         });
         window.parent.postMessage({ type: 'iframeReady' }, '*');
+        app.api.addEventListener('graphChanged', (e) => {
+            console.log('Graph 发生变化，当前 workflow JSON:', e.detail)
+            window.parent.postMessage({
+                type: 'functionResult',
+                method: 'workflowChanged',
+                result: e.detail
+            }, '*');
+
+            document.dispatchEvent(new CustomEvent('workflowLoaded', {
+                detail: e.detail
+            }));
+        })
     }
 });

bizydraft/static/js/tool.js

@@ -1,3 +1,17 @@
+const loadNodeList = [
+    'LoadImage',
+    'LoadImageMask',
+    'LoadAudio',
+    'LoadVideo',
+    'Load3D',
+]
+const extMap = {
+    'LoadImage': '.png,.jpg,.jpeg,.webp,.gif,.svg,.ico,.bmp,.tiff,.tif,.heic,.heif',
+    'LoadImageMask': '.png,.jpg,.jpeg,.webp,.gif,.svg,.ico,.bmp,.tiff,.tif,.heic,.heif',
+    'LoadAudio': '.mp3,.wav,.ogg,.m4a,.aac,.flac,.wma,.m4r',
+    'LoadVideo': '.mp4,.mov,.avi,.mkv,.webm,.flv,.wmv,.m4v',
+    'Load3D': '.glb,.gltf,.fbx,.obj,.dae,.ply,.stl',
+}
 export function getCookie(name) {
     const value = `; ${document.cookie}`;
     const parts = value.split(`; ${name}=`);
@@ -22,3 +36,49 @@ export const hideWidget = (node, widget_name) => {
         widget.height = undefined;
     };
 }
+export const computeIsLoadNode = (nodeName) => {
+
+    return loadNodeList.includes(nodeName)
+}
+export const computeExt = (nodeName) => {
+
+    return extMap[nodeName] || ''
+}
+/**
+ * 判断节点名是否为模型加载类（不包含 bizyair）
+ * @param {string} nodeName
+ * @returns {boolean}
+ */
+function isModelLoaderType(nodeName) {
+    const regex = /^(\w+).*Loader.*/i;
+    return regex.test(nodeName);
+}
+
+/**
+ * 处理 graphData.output
+ * @param {Object} output - graphData.output 对象
+ * @returns {Object} 处理后的新对象
+ */
+export function processGraphOutput(output) {
+    const newOutput = JSON.parse(JSON.stringify(output));
+    for (const key in newOutput) {
+        const node = newOutput[key];
+        // 1. 如果 class_type 在 loadNodeList 里，删除 inputs.image_name
+        if (loadNodeList.includes(node.class_type) && node.inputs && node.inputs.image_name !== undefined) {
+            delete node.inputs.image_name;
+        }
+        if (isModelLoaderType(node.class_type)) {
+            delete newOutput[key];
+        }
+        // 2. 如果 class_type 满足 Loader 正则且不包含 bizyair，删除 inputs.model_version_id
+        if (isModelLoaderType(node.class_type) && node.inputs) {
+            if (node.inputs.model_version_id !== undefined) {
+                delete node.inputs.model_version_id;
+            }
+            if (node.inputs.ckpt_name !== undefined) {
+                delete node.inputs.ckpt_name;
+            }
+        }
+    }
+    return newOutput;
+}

bizydraft/workflow_io.py

@@ -83,10 +83,10 @@ def summarize_params(
 
 
 def get_node_id_from_wf_nodes(
-    wf_nodes: List[Dict[str, Any]], node_id: int
+    wf_nodes: List[Dict[str, Any]], node_id: str
 ) -> Dict[str, Any]:
     for wf_node in wf_nodes:
-        if wf_node.get("id", 0) == node_id:
+        if str(wf_node.get("id", 0)) == node_id:
             return wf_node
     return None
 

{bizydraft-0.1.30.dist-info → bizydraft-0.2.1.dist-info}/METADATA

@@ -1,4 +1,4 @@
 Metadata-Version: 2.4
 Name: bizydraft
-Version: 0.1.30
+Version: 0.2.1
 Summary: bizydraft