Update v1.2.2 to comfyRegistry

Fix after using fooocus inpaint,all models become unusable #354
Add more categories to swap nodes on contextmenu
2024-09-04 11:46:12 +08:00 · 2024-09-03 14:41:55 +08:00 · 2024-09-02 18:17:06 +08:00 · 2024-09-02 15:33:17 +08:00 · 2024-09-01 19:05:33 +08:00 · 2024-09-01 09:08:16 +08:00
141 changed files with 25386 additions and 3225 deletions
@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+custom: ["https://space.bilibili.com/1840885116"]
@@ -0,0 +1,21 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
@@ -7,7 +7,12 @@ wildcards/**
 styles/**
 workflow/**
 autocomplete/**
+web_beta/**
+web_version/dev/**
+ComfyUI-Easy-Use-Frontend/
 docs/**
 .vscode/
 .idea/
-mmb-preset.custom.txt
+mmb-preset.custom.txt
+config.yaml
+node.tar.gz
@@ -0,0 +1,465 @@
+![comfyui-easy-use](https://github.com/user-attachments/assets/9b7a5e44-f5e2-4c27-aed2-d0e6b50c46bb)
+
+<div align="center">
+<a href="https://space.bilibili.com/1840885116">视频介绍</a> |
+文档 (康明孙) | 
+<a href="https://github.com/yolain/ComfyUI-Yolain-Workflows">工作流合集</a> |
+<a href="#%EF%B8%8F-donation">捐助</a> 
+<br><br>
+<a href="./README.md"><img src="https://img.shields.io/badge/🇬🇧English-e9e9e9"></a>
+<a href="./README.ZH_CN.md"><img src="https://img.shields.io/badge/🇨🇳中文简体-0b8cf5"></a>
+</div>
+
+**ComfyUI-Easy-Use** 是一个化繁为简的节点整合包, 在 [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) 的基础上进行延展，并针对了诸多主流的节点包做了整合与优化，以达到更快更方便使用ComfyUI的目的，在保证自由度的同时还原了本属于Stable Diffusion的极致畅快出图体验。
+
+## 👨🏻‍🎨 特色介绍
+
+- 沿用了 [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) 的思路，大大减少了折腾工作流的时间成本。
+- UI界面美化，首次安装的用户，如需使用UI主题，请在 Settings -> Color Palette 中自行切换主题并**刷新页面**即可
+- 增加了预采样参数配置的节点，可与采样节点分离，更方便预览。
+- 支持通配符与Lora的提示词节点，如需使用Lora Block Weight用法，需先保证自定义节点包中安装了 [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack)
+- 可多选的风格化提示词选择器，默认是Fooocus的样式json，可自定义json放在styles底下，samples文件夹里可放预览图(名称和name一致,图片文件名如有空格需转为下划线'_')
+- 加载器可开启A1111提示词风格模式，可重现与webui生成近乎相同的图像，需先安装 [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes)
+- 可使用`easy latentNoisy`或`easy preSamplingNoiseIn`节点实现对潜空间的噪声注入
+- 简化 SD1.x、SD2.x、SDXL、SVD、Zero123等流程 
+- 简化 Stable Cascade [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#1-13-stable-cascade)
+- 简化 Layer Diffuse [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-3-layerdiffusion)
+- 简化 InstantID [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-2-instantid), 需先保证自定义节点包中安装了 [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID)
+- 简化 IPAdapter, 需先保证自定义节点包中安装最新版v2的 [ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus)
+- 扩展 XYplot 的可用性
+- 整合了Fooocus Inpaint功能
+- 整合了常用的逻辑计算、转换类型、展示所有类型等
+- 支持节点上checkpoint、lora模型子目录分类及预览图 (请在设置中开启上下文菜单嵌套子目录)
+- 支持BriaAI的RMBG-1.4模型的背景去除节点，[技术参考](https://huggingface.co/briaai/RMBG-1.4)
+- 支持 强制清理comfyUI模型显存占用
+- 支持Stable Diffusion 3 多账号API节点
+- 支持IC-Light的应用 [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-5-ic-light) | [代码整合来源](https://github.com/huchenlei/ComfyUI-IC-Light) | [技术参考](https://github.com/lllyasviel/IC-Light)
+- 中文提示词自动识别，使用[opus-mt-zh-en模型](https://huggingface.co/Helsinki-NLP/opus-mt-zh-en)
+- 支持 sd3 模型
+- 支持 kolors 模型
+- 支持 flux 模型
+- 支持 惰性条件判断（ifElse）和 for循环
+
+## 👨🏻‍🔧 安装
+
+1. 将存储库克隆到 **custom_nodes** 目录并安装依赖
+```shell
+#1. git下载
+git clone https://github.com/yolain/ComfyUI-Easy-Use
+#2. 安装依赖
+双击install.bat安装依赖
+```
+
+## 👨🏻‍🚀 计划
+
+- [x] 更新便于维护的新前端代码
+  - [x] 使用sass维护css样式
+  - [x] 对原有扩展进行优化
+  - [x] 增加新的组件（如节点时间统计等） 
+- [ ] 在[ComfyUI-Yolain-Workflows](https://github.com/yolain/ComfyUI-Yolain-Workflows)中上传更多的工作流（如kolors,sd3等），并更新english版本的readme  
+- [ ] 更详细功能介绍的 gitbook   
+
+## 📜 更新日志
+
+**v1.2.2**
+
+- 增加 `easy batchAny`
+- 增加 `easy anythingIndexSwitch`
+- 增加 `easy forLoopStart` 和 `easy forLoopEnd`  
+- 增加 `easy ifElse`
+- 增加 v2 版本新前端代码
+- 增加 `easy fluxLoader`
+- 增加 `controlnetApply` 相关节点对sd3和hunyuanDiT的支持
+- 修复 当使用fooocus inpaint后，再使用Lora模型无法生效的问题
+
+**v1.2.1**
+
+- 增加 `easy ipadapterApplyFaceIDKolors`
+- `easy ipadapterApply` 和 `easy ipadapterApplyADV` 增加 **PLUS (kolors genernal)** 和 **FACEID PLUS KOLORS** 预置项
+- `easy imageRemBg` 增加 **inspyrenet** 选项
+- 增加 `easy controlnetLoader++`
+- 去除 `easy positive` `easy negative` 等prompt节点的自动将中文翻译功能，自动翻译仅在 `easy a1111Loader` 等不支持中文TE的加载器中生效
+- 增加 `easy kolorsLoader` - 可灵加载器，参考了 [MinusZoneAI](https://github.com/MinusZoneAI/ComfyUI-Kolors-MZ) 和 [kijai](https://github.com/kijai/ComfyUI-KwaiKolorsWrapper) 的代码。
+
+**v1.2.0**
+
+- 增加 `easy pulIDApply` 和 `easy pulIDApplyADV`
+- 增加 `easy hunyuanDiTLoader` 和 `easy pixArtLoader`
+- 当新菜单的位置在上或者下时增加上 crystools 的显示，推荐开两个就好（如果后续crystools有更新UI适配我可能会删除掉）
+- 增加 **easy sliderControl** - 滑块控制节点，当前可用于控制ipadapterMS的参数 (双击滑块可重置为默认值)
+- 增加 **layer_weights** 属性在 `easy ipadapterApplyADV` 节点
+
+**v1.1.9**
+
+- 增加 新的调度器 **gitsScheduler**
+- 增加 `easy imageBatchToImageList` 和 `easy imageListToImageBatch` (修复Impact版的一点小问题)
+- 递归模型子目录嵌套
+- 支持 sd3 模型 
+- 增加 `easy applyInpaint` - 局部重绘全模式节点 (相比与之前的kSamplerInpating节点逻辑会更合理些)
+
+**v1.1.8**
+
+- 增加中文提示词自动翻译，使用[opus-mt-zh-en模型](https://huggingface.co/Helsinki-NLP/opus-mt-zh-en), 默认已对wildcard、lora正则处理, 其他需要保留的中文，可使用`@你的提示词@`包裹 (若依赖安装完成后报错, 请重启)，测算大约会占0.3GB显存
+- 增加 `easy controlnetStack` - controlnet堆
+- 增加 `easy applyBrushNet` - [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4brushnet_1.1.8.json)
+- 增加 `easy applyPowerPaint` - [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4powerpaint_outpaint_1.1.8.json)
+
+**v1.1.7**
+
+- 修复 一些模型(如controlnet模型等)未成功写入缓存，导致修改前置节点束参数（如提示词）需要二次载入模型的问题
+- 增加 `easy prompt` - 主体和光影预置项，后期可能会调整
+- 增加 `easy icLightApply` - 重绘光影, 从[ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light)优化
+- 增加 `easy imageSplitGrid` - 图像网格拆分
+- `easy kSamplerInpainting` 的 **additional** 属性增加差异扩散和brushnet等相关选项 
+- 增加 brushnet模型加载的支持 - [ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet)
+- 增加 `easy applyFooocusInpaint` - Fooocus内补节点 替代原有的 FooocusInpaintLoader
+- 移除 `easy fooocusInpaintLoader` - 容易bug，不再使用
+- 修改 easy kSampler等采样器中并联的model 不再替换输出中pipe里的model
+
+**v1.1.6**
+
+- 增加步调齐整适配 - 在所有的预采样和全采样器节点中的 调度器(schedulder) 增加了 **alignYourSteps** 选项
+- `easy kSampler` 和 `easy fullkSampler` 的 **image_output** 增加 **Preview&Choose**选项
+- 增加 `easy styleAlignedBatchAlign` - 风格对齐 [style_aligned_comfy](https://github.com/brianfitzgerald/style_aligned_comfy)
+- 增加 `easy ckptNames`
+- 增加 `easy controlnetNames`
+- 增加 `easy imagesSplitimage` - 批次图像拆分单张
+- 增加 `easy imageCount` - 图像数量
+- 增加 `easy textSwitch` - 文字切换
+
+**v1.1.5**
+
+- 重写 `easy cleanGPUUsed` - 可强制清理comfyUI的模型显存占用
+- 增加 `easy humanSegmentation` - 多类分割、人像分割
+- 增加 `easy imageColorMatch`
+- 增加 `easy ipadapterApplyRegional`
+- 增加 `easy ipadapterApplyFromParams`
+- 增加 `easy imageInterrogator` - 图像反推
+- 增加 `easy stableDiffusion3API` - 简易的Stable Diffusion 3 多账号API节点
+
+**v1.1.4**
+
+- 增加 `easy imageChooser` - 从[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker)简化的图片选择器
+- 增加 `easy preSamplingCustom` - 自定义预采样，可支持cosXL-edit
+- 增加 `easy ipadapterStyleComposition`
+- 增加 在Loaders上右键菜单可查看 checkpoints、lora 信息
+- 修复 `easy preSamplingNoiseIn`、`easy latentNoisy`、`east Unsampler` 以兼容ComfyUI Revision>=2098 [0542088e] 以上版本
+- 修复 FooocusInpaint修改ModelPatcher计算权重引发的问题，理应在生成model后重置ModelPatcher为默认值
+
+**v1.1.3**
+
+- `easy ipadapterApply` 增加 **COMPOSITION** 预置项
+- 增加 对[ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) lora模型 的加载支持
+- 增加 `easy promptLine`
+- 增加 `easy promptReplace`
+- 增加 `easy promptConcat`
+- `easy wildcards` 增加 **multiline_mode**属性 
+- 增加 当节点需要下载模型时，若huggingface连接超时，会切换至镜像地址下载模型
+
+<details>
+<summary><b>v1.1.2</b></summary>
+
+- 改写 EasyUse 相关节点的部分插槽推荐节点
+- 增加 **启用上下文菜单自动嵌套子目录** 设置项，默认为启用状态，可分类子目录及checkpoints、loras预览图
+- 增加 `easy sv3dLoader` 
+- 增加 `easy dynamiCrafterLoader` 
+- 增加 `easy ipadapterApply`
+- 增加 `easy ipadapterApplyADV`
+- 增加 `easy ipadapterApplyEncoder`
+- 增加 `easy ipadapterApplyEmbeds`
+- 增加 `easy preMaskDetailerFix`
+- `easy kSamplerInpainting` 增加 **additional** 属性，可设置成 Differential Diffusion 或 Only InpaintModelConditioning
+- 修复 `easy stylesSelector` 当未选择样式时，原有提示词发生了变化
+- 修复 `easy pipeEdit` 提示词输入lora时报错
+- 修复 layerDiffuse xyplot相关bug
+</details>
+
+<details>
+<summary><b>v1.1.1/b></summary>
+
+- 修复首次添加含seed的节点且当前模式为control_before_generate时，seed为0的问题
+- `easy preSamplingAdvanced` 增加 **return_with_leftover_noise**
+- 修复 `easy stylesSelector` 当选择自定义样式文件时运行队列报错
+- `easy preSamplingLayerDiffusion` 增加 mask 可选传入参数
+- 将所有 **seed_num** 调整回 **seed**
+- 修补官方BUG: 当control_mode为before 在首次加载页面时未修改节点中widget名称为 control_before_generate
+- 去除强制**control_before_generate**设定
+- 增加 `easy imageRemBg` - 默认为BriaAI的RMBG-1.4模型, 移除背景效果更加，速度更快
+</details>
+
+<details>
+<summary><b>v1.1.0</b></summary>
+
+- 增加 `easy imageSplitList` - 拆分每 N 张图像
+- 增加 `easy preSamplingDiffusionADDTL` - 可配置前景、背景、blended的additional_prompt等   
+- 增加 `easy preSamplingNoiseIn` 可替代需要前置的`easy latentNoisy`节点 实现效果更好的噪声注入
+- `easy pipeEdit` 增加 条件拼接模式选择，可选择替换、合并、联结、平均、设置条件时间
+- 增加 `easy pipeEdit` - 可编辑Pipe的节点（包含可重新输入提示词）
+- 增加 `easy preSamplingLayerDiffusion` 与 `easy kSamplerLayerDiffusion` （连接 `easy kSampler` 也能通）
+- 增加 在 加载器、预采样、采样器、Controlnet等节点上右键可快速替换同类型节点的便捷菜单
+- 增加 `easy instantIDApplyADV` 可连入 positive 与 negative
+- 修复 `easy wildcards` 读取lora未填写完整路径时未自动检索导致加载lora失败的问题
+- 修复 `easy instantIDApply` mask 未传入正确值
+- 修复 在 非a1111提示词风格下 BREAK 不生效的问题
+</details>
+
+<details>
+<summary><b>v1.0.9</b></summary>
+
+- 修复未安装 ComfyUI-Impack-Pack 和 ComfyUI_InstantID 时报错
+- 修复 `easy pipeIn` - pipe设为可不必选
+- 增加 `easy instantIDApply` - 需要先安装 [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID), 工作流参考[示例](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-2-instantid)
+- 修复 `easy detailerFix` 未添加到保存图片格式化扩展名可用节点列表
+- 修复 `easy XYInputs: PromptSR` 在替换负面提示词时报错
+</details>
+
+<details>
+<summary><b>v1.0.8</b></summary>
+
+- `easy cascadeLoader` stage_c 与 stage_b 支持checkpoint模型 (需要下载[checkpoints](https://huggingface.co/stabilityai/stable-cascade/tree/main/comfyui_checkpoints)) 
+- `easy styleSelector` 搜索框修改为不区分大小写匹配
+- `easy fullLoader` 增加 **positive**、**negative**、**latent** 输出项
+- 修复 SDXLClipModel 在 ComfyUI 修订版本号 2016[c2cb8e88] 及以上的报错（判断了版本号可兼容老版本）
+- 修复 `easy detailerFix` 批次大小大于1时生成出错
+- 修复`easy preSampling`等 latent传入后无法根据批次索引生成的问题
+- 修复 `easy svdLoader` 报错
+- 优化代码，减少了诸多冗余，提升运行速度
+- 去除中文翻译对照文本
+
+（翻译对照已由 [AIGODLIKE-COMFYUI-TRANSLATION](https://github.com/AIGODLIKE/AIGODLIKE-ComfyUI-Translation) 统一维护啦！
+首次下载或者版本较早的朋友请更新 AIGODLIKE-COMFYUI-TRANSLATION 和本节点包至最新版本。）
+</details>
+
+<details>
+<summary><b>v1.0.7</b></summary>
+
+- 增加 `easy cascadeLoader` - stable cascade 加载器
+- 增加 `easy preSamplingCascade` - stabled cascade stage_c 预采样参数
+- 增加 `easy fullCascadeKSampler` - stable cascade stage_c 完整版采样器
+- 增加 `easy cascadeKSampler` - stable cascade stage-c ksampler simple
+</details>
+
+<details>
+<summary><b>v1.0.6</b></summary>
+
+- 增加 `easy XYInputs: Checkpoint`
+- 增加 `easy XYInputs: Lora`
+- `easy seed` 增加固定种子值时可手动切换随机种
+- 修复 `easy fullLoader`等加载器切换lora时自动调整节点大小的问题
+- 去除原有ttn的图片保存逻辑并适配ComfyUI默认的图片保存格式化扩展
+</details>
+
+<details>
+<summary><b>v1.0.5</b></summary>
+
+- 增加 `easy isSDXL` 
+- `easy svdLoader` 增加提示词控制, 可配合open_clip模型进行使用
+- `easy wildcards` 增加 **populated_text** 可输出通配填充后文本
+</details>
+
+<details>
+<summary><b>v1.0.4</b></summary>
+
+- 增加 `easy showLoaderSettingsNames` 可显示与输出加载器部件中的 模型与VAE名称
+- 增加 `easy promptList` - 提示词列表
+- 增加 `easy fooocusInpaintLoader` - Fooocus内补节点（仅支持XL模型的流程）
+- 增加 **Logic** 逻辑类节点 - 包含类型、计算、判断和转换类型等
+- 增加 `easy imageSave` - 带日期转换和宽高格式化的图像保存节点
+- 增加 `easy joinImageBatch` - 合并图像批次
+- `easy showAnything` 增加支持转换其他类型（如：tensor类型的条件、图像等）
+- `easy kSamplerInpainting` 增加 **patch** 传入值，配合Fooocus内补节点使用
+- `easy imageSave` 增加 **only_preivew**
+
+- 修复 xyplot在pillow>9.5中报错
+- 修复 `easy wildcards` 在使用PS扩展插件运行时报错
+- 修复 `easy latentCompositeMaskedWithCond`
+- 修复 `easy XYInputs: ControlNet` 报错
+- 修复 `easy loraStack` **toggle** 为 disabled 时报错
+
+- 修改首次安装节点包不再自动替换主题，需手动调整并刷新页面
+</details>
+
+<details>
+<summary><b>v1.0.3</b></summary>
+
+- 增加 `easy stylesSelector` 风格化提示词选择器
+- 增加队列进度条设置项，默认为未启用状态
+- `easy controlnetLoader` 和 `easy controlnetLoaderADV` 增加参数 **scale_soft_weights**
+
+
+- 修复 `easy XYInputs: Sampler/Scheduler` 报错
+- 修复 右侧菜单 点击按钮时老是跑位的问题
+- 修复 styles 路径在其他环境报错
+- 修复 `easy comfyLoader` 读取错误
+- 修复 xyPlot 在连接 zero123 时报错
+- 修复加载器中提示词为组件时报错
+- 修复 `easy getNode` 和 `easy setNode` 加载时标题未更改
+- 修复所有采样器中存储图片使用子目录前缀不生效的问题
+
+
+- 调整UI主题
+</details>
+
+<details>
+<summary><b>v1.0.2</b></summary>
+
+- 增加 **autocomplete** 文件夹，如果您安装了 [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts), 将在启动时合并该文件夹下的所有txt文件并覆盖到pyssss包里的autocomplete.txt文件。
+- 增加 `easy XYPlotAdvanced` 和 `easy XYInputs` 等相关节点
+- 增加 **Alt+1到9** 快捷键，可快速粘贴 Node templates 的节点预设 （对应 1到9 顺序）
+
+- 修复 `easy imageInsetCrop` 测量值为百分比时步进为1
+- 修复 开启 `a1111_prompt_style` 时XY图表无法使用的问题
+- 右键菜单中增加了一个 `📜Groups Map(EasyUse)` 
+
+- 修复在Comfy新版本中UI加载失败
+- 修复 `easy pipeToBasicPipe` 报错
+- 修改 `easy fullLoader` 和 `easy a1111Loader` 中的 **a1111_prompt_style** 默认值为 False
+- `easy XYInputs ModelMergeBlocks` 支持csv文件导入数值
+
+- 替换了XY图生成时的字体文件
+
+- 移除 `easy imageRemBg`
+- 移除包中的介绍图和工作流文件，减少包体积
+
+</details>
+
+<details>
+<summary><b>v1.0.1</b></summary>
+
+- 新增 `easy seed` - 简易随机种
+- `easy preDetailerFix` 新增了 `optional_image` 传入图像可选，如未传默认取值为pipe里的图像
+- 新增 `easy kSamplerInpainting` 用于内补潜空间的采样器
+- 新增 `easy pipeToBasicPipe` 用于转换到Impact的某些节点上
+
+- 修复 `easy comfyLoader` 报错
+- 修复所有包含输出图片尺寸的节点取值方式无法批处理的问题
+- 修复 `width` 和 `height` 无法在 `easy svdLoader` 自定义的报错问题
+- 修复所有采样器预览图片的地址链接 (解决在 MACOS 系统中图片无法在采样器中预览的问题）
+- 修复 `vae_name` 在 `easy fullLoader` 和 `easy a1111Loader` 和 `easy comfyLoader` 中选择但未替换原始vae问题
+- 修复 `easy fullkSampler` 除pipe外其他输出值的报错
+- 修复 `easy hiresFix` 输入连接pipe和image、vae同时存在时报错
+- 修复 `easy fullLoader` 中 `model_override` 连接后未执行 
+- 修复 因新增`easy seed` 导致action错误
+- 修复 `easy xyplot` 的字体文件路径读取错误
+- 修复 convert 到 `easy seed` 随机种无法固定的问题
+- 修复 `easy pipeIn` 值传入的报错问题
+- 修复 `easy zero123Loader` 和 `easy svdLoader` 读取模型时将模型加入到缓存中
+- 修复 `easy kSampler` `easy kSamplerTiled` `easy detailerFix` 的 `image_output` 默认值为 Preview
+- `easy fullLoader` 和 `easy a1111Loader` 新增了 `a1111_prompt_style` 参数可以重现和webui生成相同的图像，当前您需要安装 [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) 才能使用此功能
+</details>
+
+<details>
+<summary><b>v1.0.0</b></summary>
+
+- 新增`easy positive` - 简易正面提示词文本
+- 新增`easy negative`  - 简易负面提示词文本
+- 新增`easy wildcards` - 支持通配符和Lora选择的提示词文本
+- 新增`easy portraitMaster` - 肖像大师v2.2
+- 新增`easy loraStack` - Lora堆
+- 新增`easy fullLoader` - 完整版的加载器
+- 新增`easy zero123Loader` - 简易zero123加载器
+- 新增`easy svdLoader` - 简易svd加载器
+- 新增`easy fullkSampler` - 完整版的采样器（无分离）
+- 新增`easy hiresFix` - 支持Pipe的高清修复
+- 新增`easy predetailerFix` `easy DetailerFix` - 支持Pipe的细节修复
+- 新增`easy ultralyticsDetectorPipe` `easy samLoaderPipe` - 检测加载器（细节修复的输入项）
+- 新增`easy pipein` `easy pipeout` - Pipe的输入与输出
+- 新增`easy xyPlot` - 简易的xyplot (后续会更新更多可控参数)
+- 新增`easy imageRemoveBG` - 图像去除背景
+- 新增`easy imagePixelPerfect` - 图像完美像素
+- 新增`easy poseEditor` - 姿势编辑器
+- 新增UI主题（黑曜石）- 默认自动加载UI, 也可在设置中自行更替 
+
+- 修复 `easy globalSeed` 不生效问题
+- 修复所有的`seed_num` 因 [cg-use-everywhere](https://github.com/chrisgoringe/cg-use-everywhere) 实时更新图表导致值错乱的问题
+- 修复`easy imageSize` `easy imageSizeBySide` `easy imageSizeByLongerSide` 可作为终节点
+- 修复 `seed_num` (随机种子值) 在历史记录中读取无法一致的Bug
+</details>
+
+
+<details>
+<summary><b>v0.5</b></summary>
+
+- 新增 `easy controlnetLoaderADV` 节点
+-  新增 `easy imageSizeBySide` 节点，可选输出为长边或短边
+-  新增 `easy LLLiteLoader` 节点，如果您预先安装过 kohya-ss/ControlNet-LLLite-ComfyUI 包，请将 models 里的模型文件移动至 ComfyUI\models\controlnet\ (即comfy默认的controlnet路径里，请勿修改模型的文件名，不然会读取不到)。
+-  新增 `easy imageSize` 和 `easy imageSizeByLongerSize` 输出的尺寸显示。
+-  新增 `easy showSpentTime` 节点用于展示图片推理花费时间与VAE解码花费时间。
+- `easy controlnetLoaderADV` 和 `easy controlnetLoader` 新增 `control_net` 可选传入参数
+- `easy preSampling` 和 `easy preSamplingAdvanced` 新增 `image_to_latent` 可选传入参数
+- `easy a1111Loader` 和 `easy comfyLoader` 新增 `batch_size` 传入参数
+
+-  修改 `easy controlnetLoader` 到 loader 分类底下。
+</details>
+
+## 整合参考到的相关节点包
+
+声明: 非常尊重这些原作者们的付出，开源不易，我仅仅只是做了一些整合与优化。
+
+| 节点名 (搜索名)                      | 相关的库                                                                        | 库相关的节点                  |
+|:-------------------------------|:----------------------------------------------------------------------------|:------------------------|
+| easy setNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.SetNode         |
+| easy getNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.GetNode         |
+| easy bookmark                  | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | Bookmark 🔖             |
+| easy portraitMarker            | [comfyui-portrait-master](https://github.com/florestefano1975/comfyui-portrait-master) | Portrait Master         |
+| easy LLLiteLoader              | [ControlNet-LLLite-ComfyUI](https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI) | LLLiteLoader            |
+| easy globalSeed                | [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) | Global Seed (Inspire)   | 
+| easy preSamplingDynamicCFG     | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull | 
+| dynamicThresholdingFull        | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull | 
+| easy imageInsetCrop            | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | ImageInsetCrop          | 
+| easy poseEditor                | [ComfyUI_Custom_Nodes_AlekPet](https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet) | poseNode                | 
+| easy if                        | [ComfyUI-Logic](https://github.com/theUpsider/ComfyUI-Logic) | IfExecute               | 
+| easy preSamplingLayerDiffusion | [ComfyUI-layerdiffusion](https://github.com/huchenlei/ComfyUI-layerdiffusion) | LayeredDiffusionApply等  | 
+| easy dynamiCrafterLoader       | [ComfyUI-layerdiffusion](https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter) | Apply Dynamicrafter     | 
+| easy imageChooser              | [cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) | Preview Chooser         | 
+| easy styleAlignedBatchAlign    | [style_aligned_comfy](https://github.com/chrisgoringe/cg-image-picker) | styleAlignedBatchAlign  | 
+| easy icLightApply              | [ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light) | ICLightApply等           |
+| easy kolorsLoader              | [ComfyUI-Kolors-MZ](https://github.com/MinusZoneAI/ComfyUI-Kolors-MZ) | kolorsLoader            |
+
+## Credits
+
+[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - 功能强大且模块化的Stable Diffusion GUI
+
+[ComfyUI-ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) - ComfyUI管理器
+
+[tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - 管道节点（节点束）让用户减少了不必要的连接
+
+[ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) - diffus3的获取与设置点让用户可以分离工作流构成
+
+[ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack) - 常规整合包1
+
+[ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) - 常规整合包2
+
+[ComfyUI-Logic](https://github.com/theUpsider/ComfyUI-Logic) -  ComfyUI逻辑运算
+
+[ComfyUI-ResAdapter](https://github.com/jiaxiangc/ComfyUI-ResAdapter) - 让模型生成不受训练分辨率限制
+
+[ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus) - 风格迁移
+
+[ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) - 人脸迁移
+
+[ComfyUI_PuLID](https://github.com/cubiq/PuLID_ComfyUI) - 人脸迁移
+
+[ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) - pyssss 小蛇🐍脚本
+
+[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) - 图片选择器
+
+[ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet) - BrushNet 内补节点
+
+[ComfyUI_ExtraModels](https://github.com/city96/ComfyUI_ExtraModels) - DiT架构相关节点（Pixart、混元DiT等）
+
+## ☕️ Donation
+
+**Comfyui-Easy-Use** 是一个 GPL 许可的开源项目。为了项目取得更好、可持续的发展，我希望能够获得更多的支持。 如果我的自定义节点为您的一天增添了价值，请考虑喝杯咖啡来进一步补充能量！ 💖感谢您的支持，每一杯咖啡都是我创作的动力！
+
+- [BiliBili充电](https://space.bilibili.com/1840885116)
+- [爱发电](https://afdian.com/a/yolain)
+- [Wechat/Alipay](https://github.com/user-attachments/assets/803469bd-ed6a-4fab-932d-50e5088a2d03)
+
+感谢您的捐助，我将用这些费用来租用 GPU 或购买其他 GPT 服务，以便更好地调试和完善 ComfyUI-Easy-Use 功能
+
+##  🌟Stargazers
+
+My gratitude extends to the generous souls who bestow a star. Your support is much appreciated!
+
+[![Stargazers repo roster for @yolain/ComfyUI-Easy-Use](https://reporoster.com/stars/yolain/ComfyUI-Easy-Use)](https://github.com/yolain/ComfyUI-Easy-Use/stargazers)
@@ -1,340 +0,0 @@
-<p align="right">
-   <a href="./README.md">中文</a> | <strong>English</strong>
-</p>
-
-<div align="center">
-
-# ComfyUI Easy Use
-</div>
-
-**ComfyUI-Easy-Use** is a simplified node integration package, which is extended on the basis of [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes), and has been integrated and optimized for many mainstream node packages to achieve the purpose of faster and more convenient use of ComfyUI. While ensuring the degree of freedom, it restores the ultimate smooth image production experience that belongs to Stable Diffusion.
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Docs/workflow_node_compare.png">
-
-## Introduce
-
- Inspire by [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes), which greatly reduces the time cost of tossing workflows。
- UI interface beautification, the first time you install the user, if you need to use the UI theme, please switch the theme in Settings -> Color Palette and refresh page.
- Added a node for pre-sampling parameter configuration, which can be separated from the sampling node for easier previewing
- Wildcards and lora's are supported, for Lora Block Weight usage, ensure that the custom node package has the [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack)
- Multi-selectable styled cue word selector, default is Fooocus style json, custom json can be placed under styles, samples folder can be placed in the preview image (name and name consistent, image file name such as spaces need to be converted to underscores '_')
- The loader enables the A1111 prompt mode, which reproduces nearly identical images to those generated by webui, and needs to be installed [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) first. 
- Noise injection into the latent space can be achieved using the `easy latentNoisy` or `easy preSamplingNoiseIn` node
- Simplified processes for SD1.x, SD2.x, SDXL, SVD, Zero123, etc. [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableDiffusion)
- Simplified Stable Cascade [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableCascade)
- Simplified Layer Diffuse [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#LayerDiffusion)，The first time you use it you may need to run `pip install -r requirements.txt` to install the required dependencies.
- Simplified InstantID [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#InstantID), You need to make sure that the custom node package has the [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID)
- Extending the usability of XYplot
- Fooocus Inpaint integration
- Integration of common logical calculations, conversion of types, display of all types, etc.
- Background removal nodes for the RMBG-1.4 model supporting BriaAI, [BriaAI Guide](https://huggingface.co/briaai/RMBG-1.4)
-
-## Changelog
-
-**v1.1.4 (2024/4/10)**
-
- Added `easy preSamplingCustom` - Custom-PreSampling, can be supported cosXL-edit
- Added `easy ipadapterStyleComposition`
- Added the right-click menu to view checkpoints and lora information in all Loaders
- Fixed `easy preSamplingNoiseIn`、`easy latentNoisy`、`east Unsampler` compatible with ComfyUI Revision>=2098 [0542088e] or later
- 
-
-**v1.1.3 (2024/4/4)**
-
- `easy ipadapterApply` Added **COMPOSITION** preset
- Supported [ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) when load ResAdapter lora
- Added `easy promptLine`
- Added `easy promptReplace`
- Added `easy promptConcat`
- `easy wildcards` Added **multiline_mode**  
-
-**v1.1.2 (39c5ccf)**
-
- Optimized some of the recommended nodes for slots related to EasyUse
- Added **Enable ContextMenu Auto Nest Subdirectories** The setting item is enabled by default, and it can be classified into subdirectories, checkpoints and loras previews
- Added `easy sv3dLoader` 
- Added `easy dynamiCrafterLoader` 
- Added `easy ipadapterApply`
- Added `easy ipadapterApplyADV`
- Added `easy ipadapterApplyEncoder`
- Added `easy ipadapterApplyEmbeds`
- Added `easy preMaskDetailerFix`
- Fixed `easy stylesSelector` is change the prompt when not select the style
- Fixed `easy pipeEdit` error when add lora to prompt
- Fixed layerDiffuse xyplot bug
- `easy kSamplerInpainting` add *additional* widget，you can choose 'Differential Diffusion' or 'Only InpaintModelConditioning'
-
-**v1.1.1 (2024/3/16)**
-
- The issue that the seed is 0 when a node with a seed control is added and **control before generate** is fixed for the first time run queue prompt.
- `easy preSamplingAdvanced` Added **return_with_leftover_noise**
- Fixed `easy stylesSelector` error when choose the custom file
- `easy preSamplingLayerDiffusion` Added optional input parameter for mask
- Renamed all nodes widget name named seed_num to seed
- Remove forced **control_before_generate** settings。 If you want to use control_before_generate, change widget_value_control_mode to before in system settings
- Added `easy imageRemBg` - The default is BriaAI's RMBG-1.4 model, which removes the background effect more and faster
-
-**v1.1.0 (d5ff84e)**
-
- Added `easy imageSplitList` - to split every N images
- Added `easy preSamplingDiffusionADDTL` - It can modify foreground、background or blended additional prompt
- Added `easy preSamplingNoiseIn` It can replace the `easy latentNoisy` node that needs to be fronted to achieve better noise injection
- `easy pipeEdit` Added conditioning splicing mode selection, you can choose to replace, concat, combine, average, and set timestep range
- Added `easy pipeEdit` - nodes that can edit pipes (including re-enterable prompts)
- Added `easy preSamplingLayerDiffusion` and `easy kSamplerLayerDiffusion`
- Added a convenient menu to right-click on nodes such as Loader, Presampler, Sampler, Controlnet, etc. to quickly replace nodes of the same type
- Added `easy instantIDApplyADV` can link positive and negative
- Fixed layerDiffusion error when batch size greater than 1
- Fixed `easy wildcards` When LoRa is not filled in completely, LoRa is not automatically retrieved, resulting in failure to load LoRa
- Fixed the issue that 'BREAK' non-initiation when didn't use a1111 prompt style
- Fixed `easy instantIDApply` mask not input right
-
-
-**v1.0.9 (ff1add1)**
-
- Fixed the error when ComfyUI-Impack-Pack and ComfyUI_InstantID were not installed
- Fixed `easy pipeIn`
- Added `easy instantIDApply` - you need installed [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) fisrt, Workflow[Example](https://github.com/yolain/ComfyUI-Easy-Use/blob/main/README.en.md#InstantID)
- Fixed `easy detailerFix` not added to the list of nodes available for saving images formatting extensions
- Fixed `easy XYInputs: PromptSR` errors are reported when replacing negative prompts
-
-**v1.0.8 (f28cbf7)**
-
- `easy cascadeLoader` stage_c and stage_b support the checkpoint model (Download [checkpoints](https://huggingface.co/stabilityai/stable-cascade/tree/main/comfyui_checkpoints) models) 
- `easy styleSelector` The search box is modified to be case-insensitive
- `easy fullLoader` **positive**、**negative**、**latent** added to the output items
- Fixed the issue that 'easy preSampling' and other similar node, latent could not be generated based on the batch index after passing in
- Fixed `easy svdLoader` error when the positive or negative is empty
- Fixed the error of SDXLClipModel in ComfyUI revision 2016[c2cb8e88] and above (the revision number was judged to be compatible with the old revision)
- Fixed `easy detailerFix` generation error when batch size is greater than 1
- Optimize the code, reduce a lot of redundant code and improve the running speed
-
-**v1.0.7 (2024-02-19)**
-
- Added `easy cascadeLoader` - stable cascade Loader
- Added `easy preSamplingCascade` - stable cascade preSampling Settings
- Added `easy fullCascadeKSampler` - stable cascade stage-c ksampler full
- Added `easy cascadeKSampler` - stable cascade stage-c ksampler simple
- 
- Optimize the image to image[Example](https://github.com/yolain/ComfyUI-Easy-Use/blob/main/README.en.md#image-to-image)
-
-**v1.0.6**
-
- Added `easy XYInputs: Checkpoint`
- Added `easy XYInputs: Lora`
- `easy seed` can manually switch the random seed when increasing the fixed seed value
- Fixed `easy fullLoader` and all loaders to automatically adjust the node size when switching LoRa
- Removed the original ttn image saving logic and adapted to the default image saving format extension of ComfyUI
-
- **v1.0.5**
-
- Added `easy isSDXL` 
- Added prompt word control on `easy svdLoader`, which can be used with open_clip model
- Added **populated_text** on `easy wildcards`, wildcard populated text can be output
-
-**v1.0.4**
-
- `easy showAnything` added support for converting other types (e.g., tensor conditions, images, etc.)
- Added `easy showLoaderSettingsNames` can display the model and VAE name in the output loader assembly
- Added `easy promptList`
- Added `easy fooocusInpaintLoader` （only the process of SDXLModel is supported）
- Added **Logic** nodes
- Added `easy imageSave` - Image saving node with date conversion and aspect and height formatting
- Added `easy joinImageBatch`
- `easy kSamplerInpainting` Added the **patch** input value to be used with the FooocusInpaintLoader node
-
- Fixed xyplot error when with Pillow>9.5
- Fixed `easy wildcards` An error is reported when running with the PS extension
- Fixed `easy XYInputs: ControlNet` Error
- Fixed `easy loraStack` error when **toggle** is disabled
-
-
- Changing the first-time install node package no longer automatically replaces the theme, you need to manually adjust and refresh the page
- `easy imageSave` added **only_preivew**
- Adjust the `easy latentCompositeMaskedWithCond` node
-
-
-**v1.0.3**
-
- Added `easy stylesSelector`
- Added **scale_soft_weights** in `easy controlnetLoader` and `easy controlnetLoaderADV` 
- Added the queue progress bar setting item, which is not enabled by default
-
-
- Fixed `easy XYInputs: Sampler/Scheduler` Error
- Fixed the right menu has a problem when clicking the button
- Fixed `easy comfyLoader` error
- Fixed xyPlot error when connecting to zero123
- Fixed the error message in the loader when the prompt word was component
- Fixed `easy getNode` and `easy setNode` the title does not change when loading
- Fixed all samplers using subdirectories to store images
-
-
- Adjust the UI theme, divided into two sets of styles: the official default background and the dark black background, which can be switched in the color palette in the settings
- Modify the styles path to be compatible with other environments
-
-
-**v1.0.2**
-
- Added `easy XYPlotAdvanced` and some nodes about `easy XYInputs`
- Added **Alt+1-Alt+9** Shortcut keys to quickly paste node presets for Node templates (corresponding to 1~9 sequences)
- Added a `📜Groups Map(EasyUse)` to the context menu.
- An `autocomplete` folder has been added, If you have [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) installed, the txt files in that folder will be merged and overwritten to the autocomplete .txt file of the pyssss package at startup.
-
-
- Fixed XYPlot is not working when `a1111_prompt_style` is True
- Fixed UI loading failure in the new version of ComfyUI
- `easy XYInputs ModelMergeBlocks` Values can be imported from CSV files
- Fixed `easy pipeToBasicPipe` Bug
-
-
- Removed `easy imageRemBg`
- Remove the introductory diagram and workflow files from the package to reduce the package size
- Replaced the font file used in the generation of XY diagrams
-
-
-<details>
-<summary><b>v1.0.1</b></summary>
-
- Fixed `easy comfyLoader` error
- Fixed All nodes that contain the value of the image size
- Added `easy kSamplerInpainting`
- Added `easy pipeToBasicPipe`
- Fixed `width` and `height` can not customize in `easy svdLoader`
- Fixed all preview image path (Previously, it was not possible to preview the image on the Mac system)
- Fixed `vae_name` is not working in `easy fullLoader` and `easy a1111Loader` and `easy comfyLoader`
- Fixed `easy fullkSampler` outputs error
- Fixed `model_override` is not working in `easy fullLoader`
- Fixed `easy hiresFix` error
- Fixed `easy xyplot` font file path error
- Fixed seed that cannot be fixed when you convert `seed_num` to `easy seed` 
- Fixed `easy pipeIn` inputs bug
- `easy preDetailerFix` have added a new parameter `optional_image`
- Fixed `easy zero123Loader` and `easy svdLoader` model into cache.
- Added `easy seed`
- Fixed `image_output` default value is "Preview"
- `easy fullLoader` and `easy a1111Loader` have added a new parameter `a1111_prompt_style`,that can reproduce the same image generated from stable-diffusion-webui on comfyui, but you need to install [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) to use this feature in the current version
-</details>
-
-<details>
-<summary><b>v1.0.0</b></summary>
-
- Added `easy positive` - simple positive prompt text
- Added `easy negative` - simple negative prompt text
- Added `easy wildcards` - support for wildcards and hint text selected by Lora
- Added `easy portraitMaster` - PortraitMaster v2.2
- Added `easy loraStack` - Lora stack
- Added `easy fullLoader` - full version of the loader
- Added `easy zero123Loader` - simple zero123 loader
- Added `easy svdLoader` - easy svd loader
- Added `easy fullkSampler` - full version of the sampler (no separation)
- Added `easy hiresFix` - support for HD repair of Pipe
- Added `easy predetailerFix` and `easy DetailerFix` - support for Pipe detail fixing
- Added `easy ultralyticsDetectorPipe` and `easy samLoaderPipe` - Detect loader (detail fixed input)
- Added `easy pipein` `easy pipeout` - Pipe input and output
- Added `easy xyPlot` - simple xyplot (more controllable parameters will be updated in the future)
- Added `easy imageRemoveBG` - image to remove background
- Added `easy imagePixelPerfect` - image pixel perfect
- Added `easy poseEditor` - Pose editor
- New UI Theme (Obsidian) - Auto-load UI by default, which can also be changed in the settings 
-
- Fixed `easy globalSeed` is not working
- Fixed an issue where all `seed_num` values were out of order due to [cg-use-everywhere](https://github.com/chrisgoringe/cg-use-everywhere) updating the chart in real time
- Fixed `easy imageSize`, `easy imageSizeBySide`, `easy imageSizeByLongerSide` as end nodes
- Fixed the bug that `seed_num` (random seed value) could not be read consistently in history
-</details>
-
-<details>
-<summary><b>Updated at 12/14/2023</b></summary>
-
- `easy a1111Loader` and `easy comfyLoader` added `batch_size` of required input parameters 
- Added the `easy controlnetLoaderADV` node
- `easy controlnetLoaderADV` and `easy controlnetLoader` added `control_net ` of optional input parameters
- `easy preSampling` and `easy preSamplingAdvanced` added `image_to_latent` optional input parameters
- Added the `easy imageSizeBySide` node, which can be output as a long side or a short side
-</details>
-
-<details>
-<summary><b>Updated at 12/13/2023</b></summary>
-
-  Added the `easy LLLiteLoader` node, if you have pre-installed the kohya-ss/ControlNet-LLLite-ComfyUI package, please move the model files in the models to `ComfyUI\models\controlnet\` (i.e. in the default controlnet path of comfy, please do not change the file name of the model, otherwise it will not be read).
-  Modify `easy controlnetLoader` to the bottom of the loader category.
-  Added size display for `easy imageSize` and `easy imageSizeByLongerSize` outputs.
-</details>
-
-<details>
-<summary><b>Updated at 12/11/2023</b></summary>
-  Added the `showSpentTime` node to display the time spent on image diffusion and the time spent on VAE decoding images
-</details>
-
-## The relevant node package involved
-
-Disclaimer: Opened source was not easy. I have a lot of respect for the contributions of these original authors. I just did some integration and optimization.
-
-| Nodes Name(Search Name)        | Related libraries                                                                        | Library-related node     |
-|:-------------------------------|:----------------------------------------------------------------------------|:-------------------------|
-| easy setNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.SetNode          |
-| easy getNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.GetNode          |
-| easy bookmark                  | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | Bookmark 🔖              |
-| easy portraitMarker            | [comfyui-portrait-master](https://github.com/florestefano1975/comfyui-portrait-master) | Portrait Master          |
-| easy LLLiteLoader              | [ControlNet-LLLite-ComfyUI](https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI) | LLLiteLoader             |
-| easy globalSeed                | [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) | Global Seed (Inspire)    | 
-| easy preSamplingDynamicCFG     | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull  | 
-| dynamicThresholdingFull        | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull  | 
-| easy imageInsetCrop            | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | ImageInsetCrop           | 
-| easy poseEditor                | [ComfyUI_Custom_Nodes_AlekPet](https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet) | poseNode                 | 
-| easy preSamplingLayerDiffusion | [ComfyUI-layerdiffusion](https://github.com/huchenlei/ComfyUI-layerdiffusion) | LayeredDiffusionApply... | 
-| easy dynamiCrafterLoader       | [ComfyUI-layerdiffusion](https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter) | Apply Dynamicrafter    | 
-| easy imageChooser              | [cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) | Preview Chooser         | 
-
-## Workflow Examples
-
-### Text to image
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/text_to_image.png">
-
-### Image to image + controlnet
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/image_to_image_controlnet.png">
-
-### SDTurbo + HiresFix + SVD
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/sdturbo_hiresfix_svd.png">
-
-### LayerDiffusion
-#### SD15
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/layer_diffusion_sd15.png">
-
-#### SDXL
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/layer_diffusion_example.png">
-
-### StableCascade
-#### Text to image
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/StableCascade/text_to_image.png">
-
-#### Image to image
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/StableCascade/image_to_image.png">
-
-## Credits
-
-[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - Powerful and modular Stable Diffusion GUI
-
-[ComfyUI-ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) - ComfyUI Manager
-
-[tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - Pipe nodes (node bundles) allow users to reduce unnecessary connections
-
-[ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) - Diffus3 gets and sets points that allow the user to detach the composition of the workflow 
-
-[ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack) - General modpack 1
-
-[ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) - General Modpack 2
-
-[ComfyUI-ResAdapter](https://github.com/jiaxiangc/ComfyUI-ResAdapter) - Make model generation independent of training resolution
-
-[ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus) - Style migration
-
-[ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) - Face migration
-
-[ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) - pyssss🐍
-
-[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) - Image Preview Chooser
@@ -1,357 +1,454 @@
-<p align="right">
-   <strong>中文</strong> | <a href="./README.en.md">English</a>
-</p>
+![comfyui-easy-use](https://github.com/user-attachments/assets/9b7a5e44-f5e2-4c27-aed2-d0e6b50c46bb)

 <div align="center">
-
-# ComfyUI Easy Use
-
-[![Bilibili Badge](https://img.shields.io/badge/1.0版本-00A1D6?style=for-the-badge&logo=bilibili&logoColor=white&link=https://www.bilibili.com/video/BV1Wi4y1h76G)](https://www.bilibili.com/video/BV1Wi4y1h76G)
-[![Bilibili Badge](https://img.shields.io/badge/基本介绍-00A1D6?style=for-the-badge&logo=bilibili&logoColor=white&link=https://www.bilibili.com/video/BV1vQ4y1G7z7)](https://www.bilibili.com/video/BV1vQ4y1G7z7/)
+<a href="https://space.bilibili.com/1840885116">Video Tutorial</a> |
+Docs (Cooming Soon) | 
+<a href="https://github.com/yolain/ComfyUI-Yolain-Workflows">Workflow Collection</a> |
+<a href="#%EF%B8%8F-donation">Donation</a> 
+<br><br>
+<a href="./README.md"><img src="https://img.shields.io/badge/🇬🇧English-0b8cf5"></a>
+<a href="./README.ZH_CN.md"><img src="https://img.shields.io/badge/🇨🇳中文简体-e9e9e9"></a>
 </div>

-**ComfyUI-Easy-Use** 是一个化繁为简的节点整合包, 在 [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) 的基础上进行延展，并针对了诸多主流的节点包做了整合与优化，以达到更快更方便使用ComfyUI的目的，在保证自由度的同时还原了本属于Stable Diffusion的极致畅快出图体验。
+**ComfyUI-Easy-Use** is an efficiency custom nodes integration package, which is extended on the basis of [TinyTerraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes). It has been integrated and optimized for many popular awesome custom nodes to achieve the purpose of faster and more convenient use of ComfyUI. While ensuring the degree of freedom, it restores the ultimate smooth image production experience that belongs to Stable Diffusion.

-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Docs/workflow_node_compare.png">
+## 👨🏻‍🎨 Introduce

-## 特色介绍
+- Inspire by [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes), which greatly reduces the time cost of tossing workflows。
+- UI interface beautification, the first time you install the user, if you need to use the UI theme, please switch the theme in Settings -> Color Palette and refresh page.
+- Added a node for pre-sampling parameter configuration, which can be separated from the sampling node for easier previewing
+- Wildcards and lora's are supported, for Lora Block Weight usage, ensure that the custom node package has the [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack)
+- Multi-selectable styled cue word selector, default is Fooocus style json, custom json can be placed under styles, samples folder can be placed in the preview image (name and name consistent, image file name such as spaces need to be converted to underscores '_')
+- The loader enables the A1111 prompt mode, which reproduces nearly identical images to those generated by webui, and needs to be installed [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) first. 
+- Noise injection into the latent space can be achieved using the `easy latentNoisy` or `easy preSamplingNoiseIn` node
+- Simplified processes for SD1.x, SD2.x, SDXL, SVD, Zero123, etc. [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableDiffusion)
+- Simplified Stable Cascade [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableCascade)
+- Simplified Layer Diffuse [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#LayerDiffusion)，The first time you use it you may need to run `pip install -r requirements.txt` to install the required dependencies.
+- Simplified InstantID [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#InstantID), You need to make sure that the custom node package has the [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID)
+- Extending the usability of XYplot
+- Fooocus Inpaint integration
+- Integration of common logical calculations, conversion of types, display of all types, etc.
+- Background removal nodes for the RMBG-1.4 model supporting BriaAI, [BriaAI Guide](https://huggingface.co/briaai/RMBG-1.4)
+- Forcibly cleared the memory usage of the comfy UI model are supported
+- Stable Diffusion 3 multi-account API nodes are supported
+- Support SD3's model
+- Support Kolors‘s model
+- Support Flux's model
+- Support lazy if else and for loops

- 沿用了 [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) 的思路，大大减少了折腾工作流的时间成本。
- UI界面美化，首次安装的用户，如需使用UI主题，请在 Settings -> Color Palette 中自行切换主题并**刷新页面**即可
- 增加了预采样参数配置的节点，可与采样节点分离，更方便预览。
- 支持通配符与Lora的提示词节点，如需使用Lora Block Weight用法，需先保证自定义节点包中安装了 [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack)
- 可多选的风格化提示词选择器，默认是Fooocus的样式json，可自定义json放在styles底下，samples文件夹里可放预览图(名称和name一致,图片文件名如有空格需转为下划线'_')
- 加载器可开启A1111提示词风格模式，可重现与webui生成近乎相同的图像，需先安装 [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes)
- 可使用`easy latentNoisy`或`easy preSamplingNoiseIn`节点实现对潜空间的噪声注入
- 简化 SD1.x、SD2.x、SDXL、SVD、Zero123等流程 [示例参考](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableDiffusion)
- 简化 Stable Cascade [示例参考](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableCascade)
- 简化 Layer Diffuse [示例参考](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#LayerDiffusion)， 首次使用您可能需要运行 `pip install -r requirements.txt` 安装所需依赖
- 简化 InstantID [示例参考](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#InstantID), 需先保证自定义节点包中安装了 [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID)
- 简化 IPAdapter, 需先保证自定义节点包中安装最新版v2的 [ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus)
- 扩展 XYplot 的可用性
- 整合了Fooocus Inpaint功能
- 整合了常用的逻辑计算、转换类型、展示所有类型等
- 支持BriaAI的RMBG-1.4模型的背景去除节点，[技术参考](https://huggingface.co/briaai/RMBG-1.4)
+## 👨🏻‍🔧 Installation
+Clone the repo into the **custom_nodes** directory and install the requirements:
+```shell
+#1. Clone the repo
+git clone https://github.com/yolain/ComfyUI-Easy-Use
+#2. Install the requirements
+Double-click install.bat to install the required dependencies
+```

-## 更新日志
+## 👨🏻‍🚀 Plan

-**v1.1.4 (2024/4/13)**
+- [x] Updated new front-end code for easier maintenance
+  - [x] Maintain css styles using sass
+  - [x] Optimize existing extensions
+  - [x] Add new components
+- [ ] Upload new workflows to [ComfyUI-Yolain-Workflows](https://github.com/yolain/ComfyUI-Yolain-Workflows) and translate readme to english version.
+- [ ] Write gitbook with more detailed function introdution

- 增加 `easy preSamplingCustom` - 自定义预采样，可支持cosXL-edit
- 增加 `easy ipadapterStyleComposition`
- 增加 在Loaders上右键菜单可查看 checkpoints、lora 信息
- 修复 `easy preSamplingNoiseIn`、`easy latentNoisy`、`east Unsampler` 以兼容ComfyUI Revision>=2098 [0542088e] 以上版本
- 修复 FooocusInpaint修改ModelPatcher计算权重引发的问题，理应在生成model后重置ModelPatcher为默认值
+## 📜 Changelog

-**v1.1.3 (2024/4/4)**
+**v1.2.2**

- `easy ipadapterApply` 增加 **COMPOSITION** 预置项
- 增加 对[ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) lora模型 的加载支持
- 增加 `easy promptLine`
- 增加 `easy promptReplace`
- 增加 `easy promptConcat`
- `easy wildcards` 增加 **multiline_mode**属性 
- 增加 当节点需要下载模型时，若huggingface连接超时，会切换至镜像地址下载模型
+- Added `easy batchAny`
+- Added `easy anythingIndexSwitch`
+- Added `easy forLoopStart` and `easy forLoopEnd`  
+- Added `easy ifElse`  
+- Added v2 web frond-end code
+- Added `easy fluxLoader`
+- Added support for `controlnetApply` Related nodes with SD3 and hunyuanDiT
+- Fixed after using `easy applyFooocusInpaint`, all lora models become unusable

-**v1.1.2 (39c5ccf)**
+**v1.2.1**

- 改写 EasyUse 相关节点的部分插槽推荐节点
- 增加 **启用上下文菜单自动嵌套子目录** 设置项，默认为启用状态，可分类子目录及checkpoints、loras预览图
- 增加 `easy sv3dLoader` 
- 增加 `easy dynamiCrafterLoader` 
- 增加 `easy ipadapterApply`
- 增加 `easy ipadapterApplyADV`
- 增加 `easy ipadapterApplyEncoder`
- 增加 `easy ipadapterApplyEmbeds`
- 增加 `easy preMaskDetailerFix`
- `easy kSamplerInpainting` 增加 **additional** 属性，可设置成 Differential Diffusion 或 Only InpaintModelConditioning
- 修复 `easy stylesSelector` 当未选择样式时，原有提示词发生了变化
- 修复 `easy pipeEdit` 提示词输入lora时报错
- 修复 layerDiffuse xyplot相关bug
+- Added `easy ipadapterApplyFaceIDKolors`
+- Added **inspyrenet** to `easy imageRemBg` 
+- Added `easy controlnetLoader++`
+- Added **PLUS (kolors genernal)** and **FACEID PLUS KOLORS** preset to `easy ipadapterApply` and `easy ipadapterApplyADV` (Supported kolors ipadapter）
+- Added `easy kolorsLoader` - Code based on [MinusZoneAI](https://github.com/MinusZoneAI/ComfyUI-Kolors-MZ)'s and [kijai](https://github.com/kijai/ComfyUI-KwaiKolorsWrapper)'s repo, thanks for their contribution.

-**v1.1.1 (5c8af8f)**
+**v1.2.0**

- 修复首次添加含seed的节点且当前模式为control_before_generate时，seed为0的问题
- `easy preSamplingAdvanced` 增加 **return_with_leftover_noise**
- 修复 `easy stylesSelector` 当选择自定义样式文件时运行队列报错
- `easy preSamplingLayerDiffusion` 增加 mask 可选传入参数
- 将所有 **seed_num** 调整回 **seed**
- 修补官方BUG: 当control_mode为before 在首次加载页面时未修改节点中widget名称为 control_before_generate
- 去除强制**control_before_generate**设定
- 增加 `easy imageRemBg` - 默认为BriaAI的RMBG-1.4模型, 移除背景效果更加，速度更快
+- Added `easy pulIDApply` and `easy pulIDApplyADV`
+- Added `easy huanyuanDiTLoader` and `easy pixArtLoader`
+- Added **easy sliderControl** - Slider control node, which can currently be used to control the parameters of ipadapterMS (double-click the slider to reset to default)
+- Added **layer_weights** in `easy ipadapterApplyADV`

-**v1.1.0 (d5ff84e)**
+**v1.1.9**

- 增加 `easy imageSplitList` - 拆分每 N 张图像
- 增加 `easy preSamplingDiffusionADDTL` - 可配置前景、背景、blended的additional_prompt等   
- 增加 `easy preSamplingNoiseIn` 可替代需要前置的`easy latentNoisy`节点 实现效果更好的噪声注入
- `easy pipeEdit` 增加 条件拼接模式选择，可选择替换、合并、联结、平均、设置条件时间
- 增加 `easy pipeEdit` - 可编辑Pipe的节点（包含可重新输入提示词）
- 增加 `easy preSamplingLayerDiffusion` 与 `easy kSamplerLayerDiffusion` （连接 `easy kSampler` 也能通）
- 增加 在 加载器、预采样、采样器、Controlnet等节点上右键可快速替换同类型节点的便捷菜单
- 增加 `easy instantIDApplyADV` 可连入 positive 与 negative
- 修复 `easy wildcards` 读取lora未填写完整路径时未自动检索导致加载lora失败的问题
- 修复 `easy instantIDApply` mask 未传入正确值
- 修复 在 非a1111提示词风格下 BREAK 不生效的问题
+- Added **gitsScheduler**
+- Added `easy imageBatchToImageList` and `easy imageListToImageBatch` 
+- Recursive subcategories nested for models
+- Support for Stable Diffusion 3 model
+- Added `easy applyInpaint` - All inpainting mode in this node

-**v1.0.9 (ff1add1)**
+**v1.1.8**

- 修复未安装 ComfyUI-Impack-Pack 和 ComfyUI_InstantID 时报错
- 修复 `easy pipeIn` - pipe设为可不必选
- 增加 `easy instantIDApply` - 需要先安装 [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID), 工作流参考[示例](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#InstantID)
- 修复 `easy detailerFix` 未添加到保存图片格式化扩展名可用节点列表
- 修复 `easy XYInputs: PromptSR` 在替换负面提示词时报错
+- Added `easy controlnetStack`
+- Added `easy applyBrushNet` - [Workflow Example](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4brushnet_1.1.8.json)
+- Added `easy applyPowerPaint` - [Workflow Example](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4powerpaint_outpaint_1.1.8.json)

-**v1.0.8 (f28cbf7)**
+**v1.1.7**

- `easy cascadeLoader` stage_c 与 stage_b 支持checkpoint模型 (需要下载[checkpoints](https://huggingface.co/stabilityai/stable-cascade/tree/main/comfyui_checkpoints)) 
- `easy styleSelector` 搜索框修改为不区分大小写匹配
- `easy fullLoader` 增加 **positive**、**negative**、**latent** 输出项
- 修复 SDXLClipModel 在 ComfyUI 修订版本号 2016[c2cb8e88] 及以上的报错（判断了版本号可兼容老版本）
- 修复 `easy detailerFix` 批次大小大于1时生成出错
- 修复`easy preSampling`等 latent传入后无法根据批次索引生成的问题
- 修复 `easy svdLoader` 报错
- 优化代码，减少了诸多冗余，提升运行速度
- 去除中文翻译对照文本
+- Added `easy prompt` - Subject and light presets, maybe adjusted later
+- Added `easy icLightApply` - Light and shadow migration, Code based on [ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light)
+- Added `easy imageSplitGrid`
+- `easy kSamplerInpainting` added options such as different diffusion and brushnet in **additional** widget
+- Support for brushnet model loading - [ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet)
+- Added `easy applyFooocusInpaint` - Replace FooocusInpaintLoader
+- Removed `easy fooocusInpaintLoader`

-（翻译对照已由 [AIGODLIKE-COMFYUI-TRANSLATION](https://github.com/AIGODLIKE/AIGODLIKE-ComfyUI-Translation) 统一维护啦！
-首次下载或者版本较早的朋友请更新 AIGODLIKE-COMFYUI-TRANSLATION 和本节点包至最新版本。）
+**v1.1.6**

-**v1.0.7**
+- Added **alignYourSteps** to **schedulder** widget in all `easy preSampling` and `easy fullkSampler`
+- Added **Preview&Choose** to **image_output** widget in `easy kSampler` & `easy fullkSampler`
+- Added `easy styleAlignedBatchAlign` - Credit of [style_aligned_comfy](https://github.com/brianfitzgerald/style_aligned_comfy)
+- Added `easy ckptNames`
+- Added `easy controlnetNames`
+- Added `easy imagesSplitimage` - Batch images split into single images
+- Added `easy imageCount` - Get Image Count
+- Added `easy textSwitch` - Text Switch

- 增加 `easy cascadeLoader` - stable cascade 加载器
- 增加 `easy preSamplingCascade` - stabled cascade stage_c 预采样参数
- 增加 `easy fullCascadeKSampler` - stable cascade stage_c 完整版采样器
- 增加 `easy cascadeKSampler` - stable cascade stage-c ksampler simple
+**v1.1.5**
+
+- Rewrite `easy cleanGPUUsed` - the memory usage of the comfyUI can to be cleared
+- Added `easy humanSegmentation` - Human Part Segmentation
+- Added `easy imageColorMatch`
+- Added `easy ipadapterApplyRegional`
+- Added `easy ipadapterApplyFromParams`
+- Added `easy imageInterrogator` - Image To Prompt
+- Added `easy stableDiffusion3API` - Easy Stable Diffusion 3 Multiple accounts API Node
+
+**v1.1.4**
+
+- Added `easy preSamplingCustom` - Custom-PreSampling, can be supported cosXL-edit
+- Added `easy ipadapterStyleComposition`
+- Added the right-click menu to view checkpoints and lora information in all Loaders
+- Fixed `easy preSamplingNoiseIn`、`easy latentNoisy`、`east Unsampler` compatible with ComfyUI Revision>=2098 [0542088e] or later
+ 
+
+**v1.1.3**
+
+- `easy ipadapterApply` Added **COMPOSITION** preset
+- Supported [ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) when load ResAdapter lora
+- Added `easy promptLine`
+- Added `easy promptReplace`
+- Added `easy promptConcat`
+- `easy wildcards` Added **multiline_mode**  
+
+<details>
+<summary><b>v1.1.2</b></summary>
+
+- Optimized some of the recommended nodes for slots related to EasyUse
+- Added **Enable ContextMenu Auto Nest Subdirectories** The setting item is enabled by default, and it can be classified into subdirectories, checkpoints and loras previews
+- Added `easy sv3dLoader` 
+- Added `easy dynamiCrafterLoader` 
+- Added `easy ipadapterApply`
+- Added `easy ipadapterApplyADV`
+- Added `easy ipadapterApplyEncoder`
+- Added `easy ipadapterApplyEmbeds`
+- Added `easy preMaskDetailerFix`
+- Fixed `easy stylesSelector` is change the prompt when not select the style
+- Fixed `easy pipeEdit` error when add lora to prompt
+- Fixed layerDiffuse xyplot bug
+- `easy kSamplerInpainting` add *additional* widget，you can choose 'Differential Diffusion' or 'Only InpaintModelConditioning'
+</details>
+
+<details>
+<summary><b>v1.1.1</b></summary>
+
+- The issue that the seed is 0 when a node with a seed control is added and **control before generate** is fixed for the first time run queue prompt.
+- `easy preSamplingAdvanced` Added **return_with_leftover_noise**
+- Fixed `easy stylesSelector` error when choose the custom file
+- `easy preSamplingLayerDiffusion` Added optional input parameter for mask
+- Renamed all nodes widget name named seed_num to seed
+- Remove forced **control_before_generate** settings。 If you want to use control_before_generate, change widget_value_control_mode to before in system settings
+- Added `easy imageRemBg` - The default is BriaAI's RMBG-1.4 model, which removes the background effect more and faster
+</details>
+
+<details>
+<summary><b>v1.1.0</b></summary>
+
+- Added `easy imageSplitList` - to split every N images
+- Added `easy preSamplingDiffusionADDTL` - It can modify foreground、background or blended additional prompt
+- Added `easy preSamplingNoiseIn` It can replace the `easy latentNoisy` node that needs to be fronted to achieve better noise injection
+- `easy pipeEdit` Added conditioning splicing mode selection, you can choose to replace, concat, combine, average, and set timestep range
+- Added `easy pipeEdit` - nodes that can edit pipes (including re-enterable prompts)
+- Added `easy preSamplingLayerDiffusion` and `easy kSamplerLayerDiffusion`
+- Added a convenient menu to right-click on nodes such as Loader, Presampler, Sampler, Controlnet, etc. to quickly replace nodes of the same type
+- Added `easy instantIDApplyADV` can link positive and negative
+- Fixed layerDiffusion error when batch size greater than 1
+- Fixed `easy wildcards` When LoRa is not filled in completely, LoRa is not automatically retrieved, resulting in failure to load LoRa
+- Fixed the issue that 'BREAK' non-initiation when didn't use a1111 prompt style
+- Fixed `easy instantIDApply` mask not input right
+</details>
+
+<details>
+<summary><b>v1.0.9</b></summary>
+
+- Fixed the error when ComfyUI-Impack-Pack and ComfyUI_InstantID were not installed
+- Fixed `easy pipeIn`
+- Added `easy instantIDApply` - you need installed [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) fisrt, Workflow[Example](https://github.com/yolain/ComfyUI-Easy-Use/blob/main/README.en.md#InstantID)
+- Fixed `easy detailerFix` not added to the list of nodes available for saving images formatting extensions
+- Fixed `easy XYInputs: PromptSR` errors are reported when replacing negative prompts
+</details>
+
+<details>
+<summary><b>v1.0.8</b></summary>
+
+- `easy cascadeLoader` stage_c and stage_b support the checkpoint model (Download [checkpoints](https://huggingface.co/stabilityai/stable-cascade/tree/main/comfyui_checkpoints) models) 
+- `easy styleSelector` The search box is modified to be case-insensitive
+- `easy fullLoader` **positive**、**negative**、**latent** added to the output items
+- Fixed the issue that 'easy preSampling' and other similar node, latent could not be generated based on the batch index after passing in
+- Fixed `easy svdLoader` error when the positive or negative is empty
+- Fixed the error of SDXLClipModel in ComfyUI revision 2016[c2cb8e88] and above (the revision number was judged to be compatible with the old revision)
+- Fixed `easy detailerFix` generation error when batch size is greater than 1
+- Optimize the code, reduce a lot of redundant code and improve the running speed
+</details>
+
+<details>
+<summary><b>v1.0.7</b></summary>
+
+- Added `easy cascadeLoader` - stable cascade Loader
+- Added `easy preSamplingCascade` - stable cascade preSampling Settings
+- Added `easy fullCascadeKSampler` - stable cascade stage-c ksampler full
+- Added `easy cascadeKSampler` - stable cascade stage-c ksampler simple
+- 
+- Optimize the image to image[Example](https://github.com/yolain/ComfyUI-Easy-Use/blob/main/README.en.md#image-to-image)
+</details>

 <details>
 <summary><b>v1.0.6</b></summary>

- 增加 `easy XYInputs: Checkpoint`
- 增加 `easy XYInputs: Lora`
- `easy seed` 增加固定种子值时可手动切换随机种
- 修复 `easy fullLoader`等加载器切换lora时自动调整节点大小的问题
- 去除原有ttn的图片保存逻辑并适配ComfyUI默认的图片保存格式化扩展
+- Added `easy XYInputs: Checkpoint`
+- Added `easy XYInputs: Lora`
+- `easy seed` can manually switch the random seed when increasing the fixed seed value
+- Fixed `easy fullLoader` and all loaders to automatically adjust the node size when switching LoRa
+- Removed the original ttn image saving logic and adapted to the default image saving format extension of ComfyUI
 </details>

 <details>
 <summary><b>v1.0.5</b></summary>

- 增加 `easy isSDXL` 
- `easy svdLoader` 增加提示词控制, 可配合open_clip模型进行使用
- `easy wildcards` 增加 **populated_text** 可输出通配填充后文本
+- Added `easy isSDXL` 
+- Added prompt word control on `easy svdLoader`, which can be used with open_clip model
+- Added **populated_text** on `easy wildcards`, wildcard populated text can be output
 </details>

 <details>
 <summary><b>v1.0.4</b></summary>

- 增加 `easy showLoaderSettingsNames` 可显示与输出加载器部件中的 模型与VAE名称
- 增加 `easy promptList` - 提示词列表
- 增加 `easy fooocusInpaintLoader` - Fooocus内补节点（仅支持XL模型的流程）
- 增加 **Logic** 逻辑类节点 - 包含类型、计算、判断和转换类型等
- 增加 `easy imageSave` - 带日期转换和宽高格式化的图像保存节点
- 增加 `easy joinImageBatch` - 合并图像批次
- `easy showAnything` 增加支持转换其他类型（如：tensor类型的条件、图像等）
- `easy kSamplerInpainting` 增加 **patch** 传入值，配合Fooocus内补节点使用
- `easy imageSave` 增加 **only_preivew**
+- `easy showAnything` added support for converting other types (e.g., tensor conditions, images, etc.)
+- Added `easy showLoaderSettingsNames` can display the model and VAE name in the output loader assembly
+- Added `easy promptList`
+- Added `easy fooocusInpaintLoader` （only the process of SDXLModel is supported）
+- Added **Logic** nodes
+- Added `easy imageSave` - Image saving node with date conversion and aspect and height formatting
+- Added `easy joinImageBatch`
+- `easy kSamplerInpainting` Added the **patch** input value to be used with the FooocusInpaintLoader node

- 修复 xyplot在pillow>9.5中报错
- 修复 `easy wildcards` 在使用PS扩展插件运行时报错
- 修复 `easy latentCompositeMaskedWithCond`
- 修复 `easy XYInputs: ControlNet` 报错
- 修复 `easy loraStack` **toggle** 为 disabled 时报错
+- Fixed xyplot error when with Pillow>9.5
+- Fixed `easy wildcards` An error is reported when running with the PS extension
+- Fixed `easy XYInputs: ControlNet` Error
+- Fixed `easy loraStack` error when **toggle** is disabled

- 修改首次安装节点包不再自动替换主题，需手动调整并刷新页面
+
+- Changing the first-time install node package no longer automatically replaces the theme, you need to manually adjust and refresh the page
+- `easy imageSave` added **only_preivew**
+- Adjust the `easy latentCompositeMaskedWithCond` node
 </details>

 <details>
 <summary><b>v1.0.3</b></summary>

- 增加 `easy stylesSelector` 风格化提示词选择器
- 增加队列进度条设置项，默认为未启用状态
- `easy controlnetLoader` 和 `easy controlnetLoaderADV` 增加参数 **scale_soft_weights**
+- Added `easy stylesSelector`
+- Added **scale_soft_weights** in `easy controlnetLoader` and `easy controlnetLoaderADV` 
+- Added the queue progress bar setting item, which is not enabled by default


- 修复 `easy XYInputs: Sampler/Scheduler` 报错
- 修复 右侧菜单 点击按钮时老是跑位的问题
- 修复 styles 路径在其他环境报错
- 修复 `easy comfyLoader` 读取错误
- 修复 xyPlot 在连接 zero123 时报错
- 修复加载器中提示词为组件时报错
- 修复 `easy getNode` 和 `easy setNode` 加载时标题未更改
- 修复所有采样器中存储图片使用子目录前缀不生效的问题
+- Fixed `easy XYInputs: Sampler/Scheduler` Error
+- Fixed the right menu has a problem when clicking the button
+- Fixed `easy comfyLoader` error
+- Fixed xyPlot error when connecting to zero123
+- Fixed the error message in the loader when the prompt word was component
+- Fixed `easy getNode` and `easy setNode` the title does not change when loading
+- Fixed all samplers using subdirectories to store images


- 调整UI主题
+- Adjust the UI theme, divided into two sets of styles: the official default background and the dark black background, which can be switched in the color palette in the settings
+- Modify the styles path to be compatible with other environments
 </details>

 <details>
 <summary><b>v1.0.2</b></summary>

- 增加 **autocomplete** 文件夹，如果您安装了 [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts), 将在启动时合并该文件夹下的所有txt文件并覆盖到pyssss包里的autocomplete.txt文件。
- 增加 `easy XYPlotAdvanced` 和 `easy XYInputs` 等相关节点
- 增加 **Alt+1到9** 快捷键，可快速粘贴 Node templates 的节点预设 （对应 1到9 顺序）
+- Added `easy XYPlotAdvanced` and some nodes about `easy XYInputs`
+- Added **Alt+1-Alt+9** Shortcut keys to quickly paste node presets for Node templates (corresponding to 1~9 sequences)
+- Added a `📜Groups Map(EasyUse)` to the context menu.
+- An `autocomplete` folder has been added, If you have [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) installed, the txt files in that folder will be merged and overwritten to the autocomplete .txt file of the pyssss package at startup.

- 修复 `easy imageInsetCrop` 测量值为百分比时步进为1
- 修复 开启 `a1111_prompt_style` 时XY图表无法使用的问题
- 右键菜单中增加了一个 `📜Groups Map(EasyUse)` 

- 修复在Comfy新版本中UI加载失败
- 修复 `easy pipeToBasicPipe` 报错
- 修改 `easy fullLoader` 和 `easy a1111Loader` 中的 **a1111_prompt_style** 默认值为 False
- `easy XYInputs ModelMergeBlocks` 支持csv文件导入数值
+- Fixed XYPlot is not working when `a1111_prompt_style` is True
+- Fixed UI loading failure in the new version of ComfyUI
+- `easy XYInputs ModelMergeBlocks` Values can be imported from CSV files
+- Fixed `easy pipeToBasicPipe` Bug

- 替换了XY图生成时的字体文件
-
- 移除 `easy imageRemBg`
- 移除包中的介绍图和工作流文件，减少包体积

+- Removed `easy imageRemBg`
+- Remove the introductory diagram and workflow files from the package to reduce the package size
+- Replaced the font file used in the generation of XY diagrams
 </details>

 <details>
 <summary><b>v1.0.1</b></summary>

- 新增 `easy seed` - 简易随机种
- `easy preDetailerFix` 新增了 `optional_image` 传入图像可选，如未传默认取值为pipe里的图像
- 新增 `easy kSamplerInpainting` 用于内补潜空间的采样器
- 新增 `easy pipeToBasicPipe` 用于转换到Impact的某些节点上
-
- 修复 `easy comfyLoader` 报错
- 修复所有包含输出图片尺寸的节点取值方式无法批处理的问题
- 修复 `width` 和 `height` 无法在 `easy svdLoader` 自定义的报错问题
- 修复所有采样器预览图片的地址链接 (解决在 MACOS 系统中图片无法在采样器中预览的问题）
- 修复 `vae_name` 在 `easy fullLoader` 和 `easy a1111Loader` 和 `easy comfyLoader` 中选择但未替换原始vae问题
- 修复 `easy fullkSampler` 除pipe外其他输出值的报错
- 修复 `easy hiresFix` 输入连接pipe和image、vae同时存在时报错
- 修复 `easy fullLoader` 中 `model_override` 连接后未执行 
- 修复 因新增`easy seed` 导致action错误
- 修复 `easy xyplot` 的字体文件路径读取错误
- 修复 convert 到 `easy seed` 随机种无法固定的问题
- 修复 `easy pipeIn` 值传入的报错问题
- 修复 `easy zero123Loader` 和 `easy svdLoader` 读取模型时将模型加入到缓存中
- 修复 `easy kSampler` `easy kSamplerTiled` `easy detailerFix` 的 `image_output` 默认值为 Preview
- `easy fullLoader` 和 `easy a1111Loader` 新增了 `a1111_prompt_style` 参数可以重现和webui生成相同的图像，当前您需要安装 [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) 才能使用此功能
+- Fixed `easy comfyLoader` error
+- Fixed All nodes that contain the value of the image size
+- Added `easy kSamplerInpainting`
+- Added `easy pipeToBasicPipe`
+- Fixed `width` and `height` can not customize in `easy svdLoader`
+- Fixed all preview image path (Previously, it was not possible to preview the image on the Mac system)
+- Fixed `vae_name` is not working in `easy fullLoader` and `easy a1111Loader` and `easy comfyLoader`
+- Fixed `easy fullkSampler` outputs error
+- Fixed `model_override` is not working in `easy fullLoader`
+- Fixed `easy hiresFix` error
+- Fixed `easy xyplot` font file path error
+- Fixed seed that cannot be fixed when you convert `seed_num` to `easy seed` 
+- Fixed `easy pipeIn` inputs bug
+- `easy preDetailerFix` have added a new parameter `optional_image`
+- Fixed `easy zero123Loader` and `easy svdLoader` model into cache.
+- Added `easy seed`
+- Fixed `image_output` default value is "Preview"
+- `easy fullLoader` and `easy a1111Loader` have added a new parameter `a1111_prompt_style`,that can reproduce the same image generated from stable-diffusion-webui on comfyui, but you need to install [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) to use this feature in the current version
 </details>

 <details>
 <summary><b>v1.0.0</b></summary>

- 新增`easy positive` - 简易正面提示词文本
- 新增`easy negative`  - 简易负面提示词文本
- 新增`easy wildcards` - 支持通配符和Lora选择的提示词文本
- 新增`easy portraitMaster` - 肖像大师v2.2
- 新增`easy loraStack` - Lora堆
- 新增`easy fullLoader` - 完整版的加载器
- 新增`easy zero123Loader` - 简易zero123加载器
- 新增`easy svdLoader` - 简易svd加载器
- 新增`easy fullkSampler` - 完整版的采样器（无分离）
- 新增`easy hiresFix` - 支持Pipe的高清修复
- 新增`easy predetailerFix` `easy DetailerFix` - 支持Pipe的细节修复
- 新增`easy ultralyticsDetectorPipe` `easy samLoaderPipe` - 检测加载器（细节修复的输入项）
- 新增`easy pipein` `easy pipeout` - Pipe的输入与输出
- 新增`easy xyPlot` - 简易的xyplot (后续会更新更多可控参数)
- 新增`easy imageRemoveBG` - 图像去除背景
- 新增`easy imagePixelPerfect` - 图像完美像素
- 新增`easy poseEditor` - 姿势编辑器
- 新增UI主题（黑曜石）- 默认自动加载UI, 也可在设置中自行更替 
+- Added `easy positive` - simple positive prompt text
+- Added `easy negative` - simple negative prompt text
+- Added `easy wildcards` - support for wildcards and hint text selected by Lora
+- Added `easy portraitMaster` - PortraitMaster v2.2
+- Added `easy loraStack` - Lora stack
+- Added `easy fullLoader` - full version of the loader
+- Added `easy zero123Loader` - simple zero123 loader
+- Added `easy svdLoader` - easy svd loader
+- Added `easy fullkSampler` - full version of the sampler (no separation)
+- Added `easy hiresFix` - support for HD repair of Pipe
+- Added `easy predetailerFix` and `easy DetailerFix` - support for Pipe detail fixing
+- Added `easy ultralyticsDetectorPipe` and `easy samLoaderPipe` - Detect loader (detail fixed input)
+- Added `easy pipein` `easy pipeout` - Pipe input and output
+- Added `easy xyPlot` - simple xyplot (more controllable parameters will be updated in the future)
+- Added `easy imageRemoveBG` - image to remove background
+- Added `easy imagePixelPerfect` - image pixel perfect
+- Added `easy poseEditor` - Pose editor
+- New UI Theme (Obsidian) - Auto-load UI by default, which can also be changed in the settings 

- 修复 `easy globalSeed` 不生效问题
- 修复所有的`seed_num` 因 [cg-use-everywhere](https://github.com/chrisgoringe/cg-use-everywhere) 实时更新图表导致值错乱的问题
- 修复`easy imageSize` `easy imageSizeBySide` `easy imageSizeByLongerSide` 可作为终节点
- 修复 `seed_num` (随机种子值) 在历史记录中读取无法一致的Bug
+- Fixed `easy globalSeed` is not working
+- Fixed an issue where all `seed_num` values were out of order due to [cg-use-everywhere](https://github.com/chrisgoringe/cg-use-everywhere) updating the chart in real time
+- Fixed `easy imageSize`, `easy imageSizeBySide`, `easy imageSizeByLongerSide` as end nodes
+- Fixed the bug that `seed_num` (random seed value) could not be read consistently in history
 </details>

-
 <details>
-<summary><b>v0.5</b></summary>
+<summary><b>Updated at 12/14/2023</b></summary>

- 新增 `easy controlnetLoaderADV` 节点
-  新增 `easy imageSizeBySide` 节点，可选输出为长边或短边
-  新增 `easy LLLiteLoader` 节点，如果您预先安装过 kohya-ss/ControlNet-LLLite-ComfyUI 包，请将 models 里的模型文件移动至 ComfyUI\models\controlnet\ (即comfy默认的controlnet路径里，请勿修改模型的文件名，不然会读取不到)。
-  新增 `easy imageSize` 和 `easy imageSizeByLongerSize` 输出的尺寸显示。
-  新增 `easy showSpentTime` 节点用于展示图片推理花费时间与VAE解码花费时间。
- `easy controlnetLoaderADV` 和 `easy controlnetLoader` 新增 `control_net` 可选传入参数
- `easy preSampling` 和 `easy preSamplingAdvanced` 新增 `image_to_latent` 可选传入参数
- `easy a1111Loader` 和 `easy comfyLoader` 新增 `batch_size` 传入参数
-
-  修改 `easy controlnetLoader` 到 loader 分类底下。
+- `easy a1111Loader` and `easy comfyLoader` added `batch_size` of required input parameters 
+- Added the `easy controlnetLoaderADV` node
+- `easy controlnetLoaderADV` and `easy controlnetLoader` added `control_net ` of optional input parameters
+- `easy preSampling` and `easy preSamplingAdvanced` added `image_to_latent` optional input parameters
+- Added the `easy imageSizeBySide` node, which can be output as a long side or a short side
 </details>

-## 整合参考到的相关节点包
+<details>
+<summary><b>Updated at 12/13/2023</b></summary>

-声明: 非常尊重这些原作者们的付出，开源不易，我仅仅只是做了一些整合与优化。
+-  Added the `easy LLLiteLoader` node, if you have pre-installed the kohya-ss/ControlNet-LLLite-ComfyUI package, please move the model files in the models to `ComfyUI\models\controlnet\` (i.e. in the default controlnet path of comfy, please do not change the file name of the model, otherwise it will not be read).
+-  Modify `easy controlnetLoader` to the bottom of the loader category.
+-  Added size display for `easy imageSize` and `easy imageSizeByLongerSize` outputs.
+</details>

-| 节点名 (搜索名)                      | 相关的库                                                                        | 库相关的节点                  |
-|:-------------------------------|:----------------------------------------------------------------------------|:------------------------|
-| easy setNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.SetNode         |
-| easy getNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.GetNode         |
-| easy bookmark                  | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | Bookmark 🔖             |
-| easy portraitMarker            | [comfyui-portrait-master](https://github.com/florestefano1975/comfyui-portrait-master) | Portrait Master         |
-| easy LLLiteLoader              | [ControlNet-LLLite-ComfyUI](https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI) | LLLiteLoader            |
-| easy globalSeed                | [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) | Global Seed (Inspire)   | 
-| easy preSamplingDynamicCFG     | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull | 
-| dynamicThresholdingFull        | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull | 
-| easy imageInsetCrop            | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | ImageInsetCrop          | 
-| easy poseEditor                | [ComfyUI_Custom_Nodes_AlekPet](https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet) | poseNode                | 
-| easy if                        | [ComfyUI-Logic](https://github.com/theUpsider/ComfyUI-Logic) | IfExecute               | 
-| easy preSamplingLayerDiffusion | [ComfyUI-layerdiffusion](https://github.com/huchenlei/ComfyUI-layerdiffusion) | LayeredDiffusionApply等  | 
-| easy dynamiCrafterLoader       | [ComfyUI-layerdiffusion](https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter) | Apply Dynamicrafter     | 
+<details>
+<summary><b>Updated at 12/11/2023</b></summary>
+-  Added the `showSpentTime` node to display the time spent on image diffusion and the time spent on VAE decoding images
+</details>
+
+## The relevant node package involved
+
+Disclaimer: Opened source was not easy. I have a lot of respect for the contributions of these original authors. I just did some integration and optimization.
+
+| Nodes Name(Search Name)        | Related libraries                                                                        | Library-related node     |
+|:-------------------------------|:----------------------------------------------------------------------------|:-------------------------|
+| easy setNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.SetNode          |
+| easy getNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.GetNode          |
+| easy bookmark                  | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | Bookmark 🔖              |
+| easy portraitMarker            | [comfyui-portrait-master](https://github.com/florestefano1975/comfyui-portrait-master) | Portrait Master          |
+| easy LLLiteLoader              | [ControlNet-LLLite-ComfyUI](https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI) | LLLiteLoader             |
+| easy globalSeed                | [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) | Global Seed (Inspire)    | 
+| easy preSamplingDynamicCFG     | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull  | 
+| dynamicThresholdingFull        | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull  | 
+| easy imageInsetCrop            | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | ImageInsetCrop           | 
+| easy poseEditor                | [ComfyUI_Custom_Nodes_AlekPet](https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet) | poseNode                 | 
+| easy preSamplingLayerDiffusion | [ComfyUI-layerdiffusion](https://github.com/huchenlei/ComfyUI-layerdiffusion) | LayeredDiffusionApply... | 
+| easy dynamiCrafterLoader       | [ComfyUI-layerdiffusion](https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter) | Apply Dynamicrafter    | 
 | easy imageChooser              | [cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) | Preview Chooser         | 
-
-## 示例
-
-导入后请自行更换您目录里的大模型
-
-### StableDiffusion
-#### 文生图
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/text_to_image.png">
-
-#### 图生图+controlnet
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/image_to_image_controlnet.png">
-
-#### InstantID
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/instantID.png">
-
-### LayerDiffusion
-#### SD15
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/layer_diffusion_sd15.png">
-
-#### SDXL
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/layer_diffusion_example.png">
-
-### StableCascade
-#### 文生图
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/StableCascade/text_to_image.png">
-
-#### 图生图
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/StableCascade/image_to_image.png">
+| easy styleAlignedBatchAlign              | [style_aligned_comfy](https://github.com/chrisgoringe/cg-image-picker) | styleAlignedBatchAlign       | 
+| easy kolorsLoader              | [ComfyUI-Kolors-MZ](https://github.com/MinusZoneAI/ComfyUI-Kolors-MZ) | kolorsLoader            |


 ## Credits

-[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - 功能强大且模块化的Stable Diffusion GUI
+[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - Powerful and modular Stable Diffusion GUI

-[ComfyUI-ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) - ComfyUI管理器
+[ComfyUI-ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) - ComfyUI Manager

-[tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - 管道节点（节点束）让用户减少了不必要的连接
+[tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - Pipe nodes (node bundles) allow users to reduce unnecessary connections

-[ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) - diffus3的获取与设置点让用户可以分离工作流构成
+[ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) - Diffus3 gets and sets points that allow the user to detach the composition of the workflow 

-[ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack) - 常规整合包1
+[ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack) - General modpack 1

-[ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) - 常规整合包2
+[ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) - General Modpack 2

-[ComfyUI-Logic](https://github.com/theUpsider/ComfyUI-Logic) -  ComfyUI逻辑运算
+[ComfyUI-ResAdapter](https://github.com/jiaxiangc/ComfyUI-ResAdapter) - Make model generation independent of training resolution

-[ComfyUI-ResAdapter](https://github.com/jiaxiangc/ComfyUI-ResAdapter) - 让模型生成不受训练分辨率限制
+[ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus) - Style migration

-[ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus) - 风格迁移
+[ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) - Face migration

-[ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) - 人脸迁移
+[ComfyUI_PuLID](https://github.com/cubiq/PuLID_ComfyUI) - Face migration

-[ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) - pyssss 小蛇🐍脚本
+[ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) - pyssss🐍

-[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) - 图片选择器
+[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) - Image Preview Chooser
+
+[ComfyUI_ExtraModels](https://github.com/city96/ComfyUI_ExtraModels) - DiT custom nodes
+
+## ☕️ Donation
+
+**Comfyui-Easy-Use** is an GPL-licensed open source project. In order to achieve better and sustainable development of the project, i expect to gain more backers. <br>
+If my custom nodes has added value to your day, consider indulging in a coffee to fuel it further! <br>
+💖You can support me in any of the following ways:
+
+- [BiliBili](https://space.bilibili.com/1840885116)
+- [Afdian](https://afdian.com/a/yolain)
+- [Wechat / Alipay](https://github.com/user-attachments/assets/803469bd-ed6a-4fab-932d-50e5088a2d03)
+- 🪙 Wallet Address:
+  - ETH: 0x01f7CEd3245CaB3891A0ec8f528178db352EaC74
+  - USDT(tron): TP3AnJXkAzfebL2GKmFAvQvXgsxzivweV6
+
+（This is a newly created wallet, and if it receives sponsorship, I'll use it to rent GPUs or other GPT services for better debugging and refinement of ComfyUI-Easy-Use features.）
+
+##  🌟Stargazers
+
+My gratitude extends to the generous souls who bestow a star. Your support is much appreciated!
+
+[![Stargazers repo roster for @yolain/ComfyUI-Easy-Use](https://reporoster.com/stars/yolain/ComfyUI-Easy-Use)](https://github.com/yolain/ComfyUI-Easy-Use/stargazers)
@@ -1,5 +1,7 @@
+__version__ = "1.2.2"
+
+import yaml
 import os
-import glob
 import folder_paths
 import importlib
 from pathlib import Path
@@ -23,8 +25,8 @@ for module_name in node_list:
 cwd_path = os.path.dirname(os.path.realpath(__file__))
 comfy_path = folder_paths.base_path

-#Wildcards读取
-from .py.wildcards import read_wildcard_dict
+#Wildcards
+from .py.libs.wildcards import read_wildcard_dict
 wildcards_path = os.path.join(os.path.dirname(__file__), "wildcards")
 if os.path.exists(wildcards_path):
    read_wildcard_dict(wildcards_path)
@@ -41,36 +43,7 @@ else:
    os.mkdir(styles_path)
    os.mkdir(samples_path)

-#合并autocomplete覆盖到pyssss包
-pyssss_path = os.path.join(comfy_path, "custom_nodes", "ComfyUI-Custom-Scripts", "user")
-combine_folder = os.path.join(cwd_path, "autocomplete")
-if os.path.exists(combine_folder):
-    pass
-else:
-    os.mkdir(combine_folder)
-if os.path.exists(pyssss_path):
-    output_file = os.path.join(pyssss_path, "autocomplete.txt")
-    # 遍历 combine 目录下的所有 txt 文件，读取内容并合并
-    merged_content = ''
-    for file_path in glob.glob(os.path.join(combine_folder, '*.txt')):
-        with open(file_path, 'r', encoding='utf-8', errors='ignore') as file:
-            try:
-                file_content = file.read()
-                merged_content += file_content + '\n'
-            except UnicodeDecodeError:
-                pass
-    # 备份之前的autocomplete
-    # bak_file = os.path.join(pyssss_path, "autocomplete.txt.bak")
-    # if os.path.exists(bak_file):
-    #     pass
-    # elif os.path.exists(output_file):
-    #     shutil.copy(output_file, bak_file)
-    if merged_content != '':
-        # 将合并的内容写入目标文件 autocomplete.txt，并指定编码为 utf-8
-        with open(output_file, 'w', encoding='utf-8') as target_file:
-            target_file.write(merged_content)
-
-# ComfyUI-Easy-PS相关 (需要把模型预览图暴露给PS读取，此处借鉴了 AIGODLIKE-ComfyUI-Studio 的部分代码)
+# Model thumbnails
 from .py.libs.add_resources import add_static_resource
 from .py.libs.model import easyModelManager
 model_config = easyModelManager().models_config
@@ -81,8 +54,39 @@ for model in model_config:
            continue
        add_static_resource(path, path, limit=True)

-WEB_DIRECTORY = "./web"
+# get comfyui revision
+from .py.libs.utils import compare_revision
+
+new_frontend_revision = 2546
+web_default_version = 'v2' if compare_revision(new_frontend_revision) else 'v1'
+# web directory
+config_path = os.path.join(cwd_path, "config.yaml")
+if os.path.isfile(config_path):
+    with open(config_path, 'r') as f:
+        data = yaml.load(f, Loader=yaml.FullLoader)
+        if data and "WEB_VERSION" in data:
+            directory = f"web_version/{data['WEB_VERSION']}"
+            with open(config_path, 'w') as f:
+                yaml.dump(data, f)
+        elif web_default_version != 'v1':
+            if not data:
+                data = {'WEB_VERSION': web_default_version}
+            elif 'WEB_VERSION' not in data:
+                data = {**data, 'WEB_VERSION': web_default_version}
+            with open(config_path, 'w') as f:
+                yaml.dump(data, f)
+            directory = f"web_version/{web_default_version}"
+        else:
+            directory = f"web_version/v1"
+    if not os.path.exists(os.path.join(cwd_path, directory)):
+        print(f"web root {data['WEB_VERSION']} not found, using default")
+        directory = f"web_version/{web_default_version}"
+    WEB_DIRECTORY = directory
+else:
+    directory = f"web_version/{web_default_version}"
+    WEB_DIRECTORY =  directory
+
 __all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS', "WEB_DIRECTORY"]

-
-print('\033[34mComfy-Easy-Use (v1.1.4): \033[92mLoaded\033[0m')
+print(f'\033[34m[ComfyUI-Easy-Use] server: \033[0mv{__version__} \033[92mLoaded\033[0m')
+print(f'\033[34m[ComfyUI-Easy-Use] web root: \033[0m{os.path.join(cwd_path, directory)} \033[92mLoaded\033[0m')
@@ -0,0 +1,26 @@
+@echo off
+
+set "requirements_txt=%~dp0\requirements.txt"
+set "requirements_repair_txt=%~dp0\repair_dependency_list.txt"
+set "python_exec=..\..\..\python_embeded\python.exe"
+set "aki_python_exec=..\..\python\python.exe"
+
+echo Installing EasyUse Requirements...
+
+if exist "%python_exec%" (
+    echo Installing with ComfyUI Portable
+    "%python_exec%" -s -m pip install -r "%requirements_txt%"
+)^
+else if exist "%aki_python_exec%" (
+    echo Installing with ComfyUI Aki
+    "%aki_python_exec%" -s -m pip install -r "%requirements_txt%"
+    for /f "delims=" %%i in (%requirements_repair_txt%) do (
+        %aki_python_exec% -s -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple "%%i"
+        )
+)^
+else (
+    echo Installing with system Python
+    pip install -r "%requirements_txt%"
+)
+
+pause
@@ -0,0 +1,37 @@
+import folder_paths
+import os
+def add_folder_path_and_extensions(folder_name, full_folder_paths, extensions):
+    for full_folder_path in full_folder_paths:
+        folder_paths.add_model_folder_path(folder_name, full_folder_path)
+    if folder_name in folder_paths.folder_names_and_paths:
+        current_paths, current_extensions = folder_paths.folder_names_and_paths[folder_name]
+        updated_extensions = current_extensions | extensions
+        folder_paths.folder_names_and_paths[folder_name] = (current_paths, updated_extensions)
+    else:
+        folder_paths.folder_names_and_paths[folder_name] = (full_folder_paths, extensions)
+
+image_suffixs = set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".tiff", ".svg", ".ico", ".apng", ".tif", ".hdr", ".exr"])
+
+model_path = folder_paths.models_dir
+add_folder_path_and_extensions("ultralytics_bbox", [os.path.join(model_path, "ultralytics", "bbox")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("ultralytics_segm", [os.path.join(model_path, "ultralytics", "segm")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("ultralytics", [os.path.join(model_path, "ultralytics")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("mmdets_bbox", [os.path.join(model_path, "mmdets", "bbox")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("mmdets_segm", [os.path.join(model_path, "mmdets", "segm")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("mmdets", [os.path.join(model_path, "mmdets")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("sams", [os.path.join(model_path, "sams")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("onnx", [os.path.join(model_path, "onnx")], {'.onnx'})
+add_folder_path_and_extensions("instantid", [os.path.join(model_path, "instantid")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("pulid", [os.path.join(model_path, "pulid")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("layer_model", [os.path.join(model_path, "layer_model")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("rembg", [os.path.join(model_path, "rembg")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("ipadapter", [os.path.join(model_path, "ipadapter")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("dynamicrafter_models", [os.path.join(model_path, "dynamicrafter_models")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("mediapipe", [os.path.join(model_path, "mediapipe")], set(['.tflite','.pth']))
+add_folder_path_and_extensions("inpaint", [os.path.join(model_path, "inpaint")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("prompt_generator", [os.path.join(model_path, "prompt_generator")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("t5", [os.path.join(model_path, "t5")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("llm", [os.path.join(model_path, "LLM")], folder_paths.supported_pt_extensions)
+
+add_folder_path_and_extensions("checkpoints_thumb", [os.path.join(model_path, "checkpoints")], image_suffixs)
+add_folder_path_and_extensions("loras_thumb", [os.path.join(model_path, "loras")], image_suffixs)
@@ -7,9 +7,10 @@ import folder_paths
 from folder_paths import get_directory_by_type
 from server import PromptServer
 from .config import RESOURCES_DIR, FOOOCUS_STYLES_DIR, FOOOCUS_STYLES_SAMPLES
-from .logic import ConvertAnything
 from .libs.model import easyModelManager
-from .libs.utils import getMetadata
+from .libs.utils import getMetadata, cleanGPUUsedForce, get_local_filepath
+from .libs.cache import remove_cache
+from .libs.translate import has_chinese, zh_to_en

 try:
    import aiohttp
@@ -19,8 +20,27 @@ except ImportError:
    print("pip install aiohttp")
    sys.exit()

+@PromptServer.instance.routes.post("/easyuse/cleangpu")
+def cleanGPU(request):
+    try:
+        cleanGPUUsedForce()
+        remove_cache('*')
+        return web.Response(status=200)
+    except Exception as e:
+        return web.Response(status=500)
+        pass
+
+@PromptServer.instance.routes.post("/easyuse/translate")
+async def translate(request):
+    post = await request.post()
+    text = post.get("text")
+    if has_chinese(text):
+        return web.json_response({"text": zh_to_en([text])[0]})
+    else:
+        return web.json_response({"text": text})
+
@PromptServer.instance.routes.get("/easyuse/reboot")
-def reboot(self):
+def reboot(request):
    try:
        sys.stdout.close_log()
    except Exception as e:
@@ -78,6 +98,10 @@ async def getStylesList(request):
                        nd['name_cn'] = cn_data[key] if key in cn_data else key
                    nd["name"] = d['name']
                    nd['imgName'] = img_name
+                    if "prompt" in d:
+                        nd['prompt'] = d['prompt']
+                    if "negative_prompt" in d:
+                        nd['negative_prompt'] = d['negative_prompt']
                    ndata.append(nd)
                return web.json_response(ndata)
    return web.Response(status=400)
@@ -98,18 +122,6 @@ async def getStylesImage(request):
            return web.Response(text=FOOOCUS_STYLES_SAMPLES + name + '.jpg')
    return web.Response(status=400)

-# convert type
-@PromptServer.instance.routes.post("/easyuse/convert")
-async def convertType(request):
-    post = await request.post()
-    type = post.get('type')
-    if type:
-        ConvertAnything.RETURN_TYPES = (type.upper(),)
-        ConvertAnything.RETURN_NAMES = (type,)
-        return web.Response(status=200)
-    else:
-        return web.Response(status=400)
-
 # get models lists
@PromptServer.instance.routes.get("/easyuse/models/list")
 async def getModelsList(request):
@@ -125,11 +137,15 @@ async def getModelsList(request):
 # get models thumbnails
@PromptServer.instance.routes.get("/easyuse/models/thumbnail")
 async def getModelsThumbnail(request):
+    limit = 500
+    if "limit" in request.rel_url.query:
+        limit = request.rel_url.query.get("limit")
+        limit = int(limit)
    checkpoints = folder_paths.get_filename_list("checkpoints_thumb")
    loras = folder_paths.get_filename_list("loras_thumb")
    checkpoints_full = []
    loras_full = []
-    if len(checkpoints) + len(loras) >= 300:
+    if len(checkpoints) + len(loras) >= limit:
        return web.Response(status=400)
    for index, i in enumerate(checkpoints):
        full_path = folder_paths.get_full_path('checkpoints_thumb', str(i))
@@ -259,5 +275,19 @@ async def save_preview(request):
        "image":  type + "/" + os.path.basename(image_path)
    })

+@PromptServer.instance.routes.post("/easyuse/model/download")
+async def download_model(request):
+    post = await request.post()
+    url = post.get("url")
+    local_dir = post.get("local_dir")
+    if local_dir not in ['checkpoints', 'loras', 'controlnet', 'onnx', 'instantid', 'ipadapter', 'dynamicrafter_models', 'mediapipe', 'rembg', 'layer_model']:
+        return web.Response(status=400)
+    local_path = os.path.join(folder_paths.models_dir, local_dir)
+    try:
+        get_local_filepath(url, local_path)
+        return web.Response(status=200)
+    except:
+        return web.Response(status=500)
+
 NODE_CLASS_MAPPINGS = {}
 NODE_DISPLAY_NAME_MAPPINGS = {}
@@ -0,0 +1,167 @@
+#credit to comfyanonymous for this module
+#from https://github.com/comfyanonymous/ComfyUI_bitsandbytes_NF4
+import comfy.ops
+import torch
+import folder_paths
+from ..libs.utils import install_package
+
+try:
+    from bitsandbytes.nn.modules import Params4bit, QuantState
+except ImportError:
+    Params4bit = torch.nn.Parameter
+    raise ImportError("Please install bitsandbytes>=0.43.3")
+
+def functional_linear_4bits(x, weight, bias):
+    try:
+        install_package("bitsandbytes", "0.43.3", True, "0.43.3")
+        import bitsandbytes as bnb
+    except ImportError:
+        raise ImportError("Please install bitsandbytes>=0.43.3")
+
+    out = bnb.matmul_4bit(x, weight.t(), bias=bias, quant_state=weight.quant_state)
+    out = out.to(x)
+    return out
+
+
+def copy_quant_state(state, device: torch.device = None):
+    if state is None:
+        return None
+
+    device = device or state.absmax.device
+
+    state2 = (
+        QuantState(
+            absmax=state.state2.absmax.to(device),
+            shape=state.state2.shape,
+            code=state.state2.code.to(device),
+            blocksize=state.state2.blocksize,
+            quant_type=state.state2.quant_type,
+            dtype=state.state2.dtype,
+        )
+        if state.nested
+        else None
+    )
+
+    return QuantState(
+        absmax=state.absmax.to(device),
+        shape=state.shape,
+        code=state.code.to(device),
+        blocksize=state.blocksize,
+        quant_type=state.quant_type,
+        dtype=state.dtype,
+        offset=state.offset.to(device) if state.nested else None,
+        state2=state2,
+    )
+
+
+class ForgeParams4bit(Params4bit):
+
+    def to(self, *args, **kwargs):
+        device, dtype, non_blocking, convert_to_format = torch._C._nn._parse_to(*args, **kwargs)
+        if device is not None and device.type == "cuda" and not self.bnb_quantized:
+            return self._quantize(device)
+        else:
+            n = ForgeParams4bit(
+                torch.nn.Parameter.to(self, device=device, dtype=dtype, non_blocking=non_blocking),
+                requires_grad=self.requires_grad,
+                quant_state=copy_quant_state(self.quant_state, device),
+                blocksize=self.blocksize,
+                compress_statistics=self.compress_statistics,
+                quant_type=self.quant_type,
+                quant_storage=self.quant_storage,
+                bnb_quantized=self.bnb_quantized,
+                module=self.module
+            )
+            self.module.quant_state = n.quant_state
+            self.data = n.data
+            self.quant_state = n.quant_state
+            return n
+
+class ForgeLoader4Bit(torch.nn.Module):
+    def __init__(self, *, device, dtype, quant_type, **kwargs):
+        super().__init__()
+        self.dummy = torch.nn.Parameter(torch.empty(1, device=device, dtype=dtype))
+        self.weight = None
+        self.quant_state = None
+        self.bias = None
+        self.quant_type = quant_type
+
+    def _save_to_state_dict(self, destination, prefix, keep_vars):
+        super()._save_to_state_dict(destination, prefix, keep_vars)
+        quant_state = getattr(self.weight, "quant_state", None)
+        if quant_state is not None:
+            for k, v in quant_state.as_dict(packed=True).items():
+                destination[prefix + "weight." + k] = v if keep_vars else v.detach()
+        return
+
+    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
+        quant_state_keys = {k[len(prefix + "weight."):] for k in state_dict.keys() if k.startswith(prefix + "weight.")}
+
+        if any('bitsandbytes' in k for k in quant_state_keys):
+            quant_state_dict = {k: state_dict[prefix + "weight." + k] for k in quant_state_keys}
+
+            self.weight = ForgeParams4bit().from_prequantized(
+                data=state_dict[prefix + 'weight'],
+                quantized_stats=quant_state_dict,
+                requires_grad=False,
+                device=self.dummy.device,
+                module=self
+            )
+            self.quant_state = self.weight.quant_state
+
+            if prefix + 'bias' in state_dict:
+                self.bias = torch.nn.Parameter(state_dict[prefix + 'bias'].to(self.dummy))
+
+            del self.dummy
+        elif hasattr(self, 'dummy'):
+            if prefix + 'weight' in state_dict:
+                self.weight = ForgeParams4bit(
+                    state_dict[prefix + 'weight'].to(self.dummy),
+                    requires_grad=False,
+                    compress_statistics=True,
+                    quant_type=self.quant_type,
+                    quant_storage=torch.uint8,
+                    module=self,
+                )
+                self.quant_state = self.weight.quant_state
+
+            if prefix + 'bias' in state_dict:
+                self.bias = torch.nn.Parameter(state_dict[prefix + 'bias'].to(self.dummy))
+
+            del self.dummy
+        else:
+            super()._load_from_state_dict(state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs)
+
+current_device = None
+current_dtype = None
+current_manual_cast_enabled = False
+current_bnb_dtype = None
+
+class OPS(comfy.ops.manual_cast):
+    class Linear(ForgeLoader4Bit):
+        def __init__(self, *args, device=None, dtype=None, **kwargs):
+            super().__init__(device=device, dtype=dtype, quant_type=current_bnb_dtype)
+            self.parameters_manual_cast = current_manual_cast_enabled
+
+        def forward(self, x):
+            self.weight.quant_state = self.quant_state
+
+            if self.bias is not None and self.bias.dtype != x.dtype:
+                # Maybe this can also be set to all non-bnb ops since the cost is very low.
+                # And it only invokes one time, and most linear does not have bias
+                self.bias.data = self.bias.data.to(x.dtype)
+
+            if not self.parameters_manual_cast:
+                return functional_linear_4bits(x, self.weight, self.bias)
+            elif not self.weight.bnb_quantized:
+                assert x.device.type == 'cuda', 'BNB Must Use CUDA as Computation Device!'
+                layer_original_device = self.weight.device
+                self.weight = self.weight._quantize(x.device)
+                bias = self.bias.to(x.device) if self.bias is not None else None
+                out = functional_linear_4bits(x, self.weight, bias)
+                self.weight = self.weight.to(layer_original_device)
+                return out
+            else:
+                weight, bias, signal = weights_manual_cast(self, x, skip_weight_dtype=True, skip_bias_dtype=True)
+                with main_stream_worker(weight, bias, signal):
+                    return functional_linear_4bits(x, weight, bias)
@@ -0,0 +1,806 @@
+#credit to nullquant for this module
+#from https://github.com/nullquant/ComfyUI-BrushNet
+
+import os
+import types
+
+import torch
+from accelerate import init_empty_weights, load_checkpoint_and_dispatch
+
+import comfy
+
+from .model import BrushNetModel, PowerPaintModel
+from .model_patch import add_model_patch_option, patch_model_function_wrapper
+from .powerpaint_utils import TokenizerWrapper, add_tokens
+
+cwd_path = os.path.dirname(os.path.realpath(__file__))
+brushnet_config_file = os.path.join(cwd_path, 'config', 'brushnet.json')
+brushnet_xl_config_file = os.path.join(cwd_path, 'config', 'brushnet_xl.json')
+powerpaint_config_file = os.path.join(cwd_path, 'config', 'powerpaint.json')
+
+sd15_scaling_factor = 0.18215
+sdxl_scaling_factor = 0.13025
+
+ModelsToUnload = [comfy.sd1_clip.SD1ClipModel, comfy.ldm.models.autoencoder.AutoencoderKL]
+
+class BrushNet:
+
+    # Check models compatibility
+    def check_compatibilty(self, model, brushnet):
+        is_SDXL = False
+        is_PP = False
+        if isinstance(model.model.model_config, comfy.supported_models.SD15):
+            print('Base model type: SD1.5')
+            is_SDXL = False
+            if brushnet["SDXL"]:
+                raise Exception("Base model is SD15, but BrushNet is SDXL type")
+            if brushnet["PP"]:
+                is_PP = True
+        elif isinstance(model.model.model_config, comfy.supported_models.SDXL):
+            print('Base model type: SDXL')
+            is_SDXL = True
+            if not brushnet["SDXL"]:
+                raise Exception("Base model is SDXL, but BrushNet is SD15 type")
+        else:
+            print('Base model type: ', type(model.model.model_config))
+            raise Exception("Unsupported model type: " + str(type(model.model.model_config)))
+
+        return (is_SDXL, is_PP)
+
+    def check_image_mask(self, image, mask, name):
+        if len(image.shape) < 4:
+            # image tensor shape should be [B, H, W, C], but batch somehow is missing
+            image = image[None, :, :, :]
+
+        if len(mask.shape) > 3:
+            # mask tensor shape should be [B, H, W] but we get [B, H, W, C], image may be?
+            # take first mask, red channel
+            mask = (mask[:, :, :, 0])[:, :, :]
+        elif len(mask.shape) < 3:
+            # mask tensor shape should be [B, H, W] but batch somehow is missing
+            mask = mask[None, :, :]
+
+        if image.shape[0] > mask.shape[0]:
+            print(name, "gets batch of images (%d) but only %d masks" % (image.shape[0], mask.shape[0]))
+            if mask.shape[0] == 1:
+                print(name, "will copy the mask to fill batch")
+                mask = torch.cat([mask] * image.shape[0], dim=0)
+            else:
+                print(name, "will add empty masks to fill batch")
+                empty_mask = torch.zeros([image.shape[0] - mask.shape[0], mask.shape[1], mask.shape[2]])
+                mask = torch.cat([mask, empty_mask], dim=0)
+        elif image.shape[0] < mask.shape[0]:
+            print(name, "gets batch of images (%d) but too many (%d) masks" % (image.shape[0], mask.shape[0]))
+            mask = mask[:image.shape[0], :, :]
+
+        return (image, mask)
+
+    # Prepare image and mask
+    def prepare_image(self, image, mask):
+
+        image, mask = self.check_image_mask(image, mask, 'BrushNet')
+
+        print("BrushNet image.shape =", image.shape, "mask.shape =", mask.shape)
+
+        if mask.shape[2] != image.shape[2] or mask.shape[1] != image.shape[1]:
+            raise Exception("Image and mask should be the same size")
+
+        # As a suggestion of inferno46n2 (https://github.com/nullquant/ComfyUI-BrushNet/issues/64)
+        mask = mask.round()
+
+        masked_image = image * (1.0 - mask[:, :, :, None])
+
+        return (masked_image, mask)
+
+    # Get origin of the mask
+    def cut_with_mask(self, mask, width, height):
+        iy, ix = (mask == 1).nonzero(as_tuple=True)
+
+        h0, w0 = mask.shape
+
+        if iy.numel() == 0:
+            x_c = w0 / 2.0
+            y_c = h0 / 2.0
+        else:
+            x_min = ix.min().item()
+            x_max = ix.max().item()
+            y_min = iy.min().item()
+            y_max = iy.max().item()
+
+            if x_max - x_min > width or y_max - y_min > height:
+                raise Exception("Mask is bigger than provided dimensions")
+
+            x_c = (x_min + x_max) / 2.0
+            y_c = (y_min + y_max) / 2.0
+
+        width2 = width / 2.0
+        height2 = height / 2.0
+
+        if w0 <= width:
+            x0 = 0
+            w = w0
+        else:
+            x0 = max(0, x_c - width2)
+            w = width
+            if x0 + width > w0:
+                x0 = w0 - width
+
+        if h0 <= height:
+            y0 = 0
+            h = h0
+        else:
+            y0 = max(0, y_c - height2)
+            h = height
+            if y0 + height > h0:
+                y0 = h0 - height
+
+        return (int(x0), int(y0), int(w), int(h))
+
+    # Prepare conditioning_latents
+    @torch.inference_mode()
+    def get_image_latents(self, masked_image, mask, vae, scaling_factor):
+        processed_image = masked_image.to(vae.device)
+        image_latents = vae.encode(processed_image[:, :, :, :3]) * scaling_factor
+        processed_mask = 1. - mask[:, None, :, :]
+        interpolated_mask = torch.nn.functional.interpolate(
+            processed_mask,
+            size=(
+                image_latents.shape[-2],
+                image_latents.shape[-1]
+            )
+        )
+        interpolated_mask = interpolated_mask.to(image_latents.device)
+
+        conditioning_latents = [image_latents, interpolated_mask]
+
+        print('BrushNet CL: image_latents shape =', image_latents.shape, 'interpolated_mask shape =',
+              interpolated_mask.shape)
+
+        return conditioning_latents
+
+    def brushnet_blocks(self, sd):
+        brushnet_down_block = 0
+        brushnet_mid_block = 0
+        brushnet_up_block = 0
+        for key in sd:
+            if 'brushnet_down_block' in key:
+                brushnet_down_block += 1
+            if 'brushnet_mid_block' in key:
+                brushnet_mid_block += 1
+            if 'brushnet_up_block' in key:
+                brushnet_up_block += 1
+        return (brushnet_down_block, brushnet_mid_block, brushnet_up_block, len(sd))
+
+    def get_model_type(self, brushnet_file):
+        sd = comfy.utils.load_torch_file(brushnet_file)
+        brushnet_down_block, brushnet_mid_block, brushnet_up_block, keys = self.brushnet_blocks(sd)
+        del sd
+        if brushnet_down_block == 24 and brushnet_mid_block == 2 and brushnet_up_block == 30:
+            is_SDXL = False
+            if keys == 322:
+                is_PP = False
+                print('BrushNet model type: SD1.5')
+            else:
+                is_PP = True
+                print('PowerPaint model type: SD1.5')
+        elif brushnet_down_block == 18 and brushnet_mid_block == 2 and brushnet_up_block == 22:
+            print('BrushNet model type: Loading SDXL')
+            is_SDXL = True
+            is_PP = False
+        else:
+            raise Exception("Unknown BrushNet model")
+        return is_SDXL, is_PP
+
+    def load_brushnet_model(self, brushnet_file, dtype='float16'):
+        is_SDXL, is_PP = self.get_model_type(brushnet_file)
+        with init_empty_weights():
+            if is_SDXL:
+                brushnet_config = BrushNetModel.load_config(brushnet_xl_config_file)
+                brushnet_model = BrushNetModel.from_config(brushnet_config)
+            elif is_PP:
+                brushnet_config = PowerPaintModel.load_config(powerpaint_config_file)
+                brushnet_model = PowerPaintModel.from_config(brushnet_config)
+            else:
+                brushnet_config = BrushNetModel.load_config(brushnet_config_file)
+                brushnet_model = BrushNetModel.from_config(brushnet_config)
+        if is_PP:
+            print("PowerPaint model file:", brushnet_file)
+        else:
+            print("BrushNet model file:", brushnet_file)
+
+        if dtype == 'float16':
+            torch_dtype = torch.float16
+        elif dtype == 'bfloat16':
+            torch_dtype = torch.bfloat16
+        elif dtype == 'float32':
+            torch_dtype = torch.float32
+        else:
+            torch_dtype = torch.float64
+
+        brushnet_model = load_checkpoint_and_dispatch(
+            brushnet_model,
+            brushnet_file,
+            device_map="sequential",
+            max_memory=None,
+            offload_folder=None,
+            offload_state_dict=False,
+            dtype=torch_dtype,
+            force_hooks=False,
+        )
+
+        if is_PP:
+            print("PowerPaint model is loaded")
+        elif is_SDXL:
+            print("BrushNet SDXL model is loaded")
+        else:
+            print("BrushNet SD1.5 model is loaded")
+
+        return ({"brushnet": brushnet_model, "SDXL": is_SDXL, "PP": is_PP, "dtype": torch_dtype},)
+
+    def brushnet_model_update(self, model, vae, image, mask, brushnet, positive, negative, scale, start_at, end_at):
+
+        is_SDXL, is_PP = self.check_compatibilty(model, brushnet)
+
+        if is_PP:
+            raise Exception("PowerPaint model was loaded, please use PowerPaint node")
+
+            # Make a copy of the model so that we're not patching it everywhere in the workflow.
+        model = model.clone()
+
+        # prepare image and mask
+        # no batches for original image and mask
+        masked_image, mask = self.prepare_image(image, mask)
+
+        batch = masked_image.shape[0]
+        width = masked_image.shape[2]
+        height = masked_image.shape[1]
+
+        if hasattr(model.model.model_config, 'latent_format') and hasattr(model.model.model_config.latent_format,
+                                                                          'scale_factor'):
+            scaling_factor = model.model.model_config.latent_format.scale_factor
+        elif is_SDXL:
+            scaling_factor = sdxl_scaling_factor
+        else:
+            scaling_factor = sd15_scaling_factor
+
+        torch_dtype = brushnet['dtype']
+
+        # prepare conditioning latents
+        conditioning_latents = self.get_image_latents(masked_image, mask, vae, scaling_factor)
+        conditioning_latents[0] = conditioning_latents[0].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+        conditioning_latents[1] = conditioning_latents[1].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+
+        # unload vae
+        del vae
+        for loaded_model in comfy.model_management.current_loaded_models:
+            if type(loaded_model.model.model) in ModelsToUnload:
+                comfy.model_management.current_loaded_models.remove(loaded_model)
+                loaded_model.model_unload()
+                del loaded_model
+
+        # prepare embeddings
+        prompt_embeds = positive[0][0].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+        negative_prompt_embeds = negative[0][0].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+
+        max_tokens = max(prompt_embeds.shape[1], negative_prompt_embeds.shape[1])
+        if prompt_embeds.shape[1] < max_tokens:
+            multiplier = max_tokens // 77 - prompt_embeds.shape[1] // 77
+            prompt_embeds = torch.concat([prompt_embeds] + [prompt_embeds[:, -77:, :]] * multiplier, dim=1)
+            print('BrushNet: negative prompt more than 75 tokens:', negative_prompt_embeds.shape,
+                  'multiplying prompt_embeds')
+        if negative_prompt_embeds.shape[1] < max_tokens:
+            multiplier = max_tokens // 77 - negative_prompt_embeds.shape[1] // 77
+            negative_prompt_embeds = torch.concat(
+                [negative_prompt_embeds] + [negative_prompt_embeds[:, -77:, :]] * multiplier, dim=1)
+            print('BrushNet: positive prompt more than 75 tokens:', prompt_embeds.shape,
+                  'multiplying negative_prompt_embeds')
+
+        if len(positive[0]) > 1 and 'pooled_output' in positive[0][1] and positive[0][1]['pooled_output'] is not None:
+            pooled_prompt_embeds = positive[0][1]['pooled_output'].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+        else:
+            print('BrushNet: positive conditioning has not pooled_output')
+            if is_SDXL:
+                print('BrushNet will not produce correct results')
+            pooled_prompt_embeds = torch.empty([2, 1280], device=brushnet['brushnet'].device).to(dtype=torch_dtype)
+
+        if len(negative[0]) > 1 and 'pooled_output' in negative[0][1] and negative[0][1]['pooled_output'] is not None:
+            negative_pooled_prompt_embeds = negative[0][1]['pooled_output'].to(dtype=torch_dtype).to(
+                brushnet['brushnet'].device)
+        else:
+            print('BrushNet: negative conditioning has not pooled_output')
+            if is_SDXL:
+                print('BrushNet will not produce correct results')
+            negative_pooled_prompt_embeds = torch.empty([1, pooled_prompt_embeds.shape[1]],
+                                                        device=brushnet['brushnet'].device).to(dtype=torch_dtype)
+
+        time_ids = torch.FloatTensor([[height, width, 0., 0., height, width]]).to(dtype=torch_dtype).to(
+            brushnet['brushnet'].device)
+
+        if not is_SDXL:
+            pooled_prompt_embeds = None
+            negative_pooled_prompt_embeds = None
+            time_ids = None
+
+        # apply patch to model
+        brushnet_conditioning_scale = scale
+        control_guidance_start = start_at
+        control_guidance_end = end_at
+
+        add_brushnet_patch(model,
+                           brushnet['brushnet'],
+                           torch_dtype,
+                           conditioning_latents,
+                           (brushnet_conditioning_scale, control_guidance_start, control_guidance_end),
+                           prompt_embeds, negative_prompt_embeds,
+                           pooled_prompt_embeds, negative_pooled_prompt_embeds, time_ids,
+                           False)
+
+        latent = torch.zeros([batch, 4, conditioning_latents[0].shape[2], conditioning_latents[0].shape[3]],
+                             device=brushnet['brushnet'].device)
+
+        return (model, positive, negative, {"samples": latent},)
+
+    #powperpaint
+    def load_powerpaint_clip(self, base_clip_file, pp_clip_file):
+        pp_clip = comfy.sd.load_clip(ckpt_paths=[base_clip_file])
+
+        print('PowerPaint base CLIP file: ', base_clip_file)
+
+        pp_tokenizer = TokenizerWrapper(pp_clip.tokenizer.clip_l.tokenizer)
+        pp_text_encoder = pp_clip.patcher.model.clip_l.transformer
+
+        add_tokens(
+            tokenizer=pp_tokenizer,
+            text_encoder=pp_text_encoder,
+            placeholder_tokens=["P_ctxt", "P_shape", "P_obj"],
+            initialize_tokens=["a", "a", "a"],
+            num_vectors_per_token=10,
+        )
+
+        pp_text_encoder.load_state_dict(comfy.utils.load_torch_file(pp_clip_file), strict=False)
+
+        print('PowerPaint CLIP file: ', pp_clip_file)
+
+        pp_clip.tokenizer.clip_l.tokenizer = pp_tokenizer
+        pp_clip.patcher.model.clip_l.transformer = pp_text_encoder
+
+        return (pp_clip,)
+
+    def powerpaint_model_update(self, model, vae, image, mask, powerpaint, clip, positive, negative, fitting, function, scale, start_at, end_at, save_memory):
+        is_SDXL, is_PP = self.check_compatibilty(model, powerpaint)
+        if not is_PP:
+            raise Exception("BrushNet model was loaded, please use BrushNet node")
+
+            # Make a copy of the model so that we're not patching it everywhere in the workflow.
+        model = model.clone()
+
+        # prepare image and mask
+        # no batches for original image and mask
+        masked_image, mask = self.prepare_image(image, mask)
+
+        batch = masked_image.shape[0]
+        # width = masked_image.shape[2]
+        # height = masked_image.shape[1]
+
+        if hasattr(model.model.model_config, 'latent_format') and hasattr(model.model.model_config.latent_format,
+                                                                          'scale_factor'):
+            scaling_factor = model.model.model_config.latent_format.scale_factor
+        else:
+            scaling_factor = sd15_scaling_factor
+
+        torch_dtype = powerpaint['dtype']
+
+        # prepare conditioning latents
+        conditioning_latents = self.get_image_latents(masked_image, mask, vae, scaling_factor)
+        conditioning_latents[0] = conditioning_latents[0].to(dtype=torch_dtype).to(powerpaint['brushnet'].device)
+        conditioning_latents[1] = conditioning_latents[1].to(dtype=torch_dtype).to(powerpaint['brushnet'].device)
+
+        # prepare embeddings
+
+        if function == "object removal":
+            promptA = "P_ctxt"
+            promptB = "P_ctxt"
+            negative_promptA = "P_obj"
+            negative_promptB = "P_obj"
+            print('You should add to positive prompt: "empty scene blur"')
+            # positive = positive + " empty scene blur"
+        elif function == "context aware":
+            promptA = "P_ctxt"
+            promptB = "P_ctxt"
+            negative_promptA = ""
+            negative_promptB = ""
+            # positive = positive + " empty scene"
+            print('You should add to positive prompt: "empty scene"')
+        elif function == "shape guided":
+            promptA = "P_shape"
+            promptB = "P_ctxt"
+            negative_promptA = "P_shape"
+            negative_promptB = "P_ctxt"
+        elif function == "image outpainting":
+            promptA = "P_ctxt"
+            promptB = "P_ctxt"
+            negative_promptA = "P_obj"
+            negative_promptB = "P_obj"
+            # positive = positive + " empty scene"
+            print('You should add to positive prompt: "empty scene"')
+        else:
+            promptA = "P_obj"
+            promptB = "P_obj"
+            negative_promptA = "P_obj"
+            negative_promptB = "P_obj"
+
+        tokens = clip.tokenize(promptA)
+        prompt_embedsA = clip.encode_from_tokens(tokens, return_pooled=False)
+
+        tokens = clip.tokenize(negative_promptA)
+        negative_prompt_embedsA = clip.encode_from_tokens(tokens, return_pooled=False)
+
+        tokens = clip.tokenize(promptB)
+        prompt_embedsB = clip.encode_from_tokens(tokens, return_pooled=False)
+
+        tokens = clip.tokenize(negative_promptB)
+        negative_prompt_embedsB = clip.encode_from_tokens(tokens, return_pooled=False)
+
+        prompt_embeds_pp = (prompt_embedsA * fitting + (1.0 - fitting) * prompt_embedsB).to(dtype=torch_dtype).to(
+            powerpaint['brushnet'].device)
+        negative_prompt_embeds_pp = (negative_prompt_embedsA * fitting + (1.0 - fitting) * negative_prompt_embedsB).to(
+            dtype=torch_dtype).to(powerpaint['brushnet'].device)
+
+        # unload vae and CLIPs
+        del vae
+        del clip
+        for loaded_model in comfy.model_management.current_loaded_models:
+            if type(loaded_model.model.model) in ModelsToUnload:
+                comfy.model_management.current_loaded_models.remove(loaded_model)
+                loaded_model.model_unload()
+                del loaded_model
+
+        # apply patch to model
+
+        brushnet_conditioning_scale = scale
+        control_guidance_start = start_at
+        control_guidance_end = end_at
+
+        if save_memory != 'none':
+            powerpaint['brushnet'].set_attention_slice(save_memory)
+
+        add_brushnet_patch(model,
+                           powerpaint['brushnet'],
+                           torch_dtype,
+                           conditioning_latents,
+                           (brushnet_conditioning_scale, control_guidance_start, control_guidance_end),
+                           negative_prompt_embeds_pp, prompt_embeds_pp,
+                           None, None, None,
+                           False)
+
+        latent = torch.zeros([batch, 4, conditioning_latents[0].shape[2], conditioning_latents[0].shape[3]],
+                             device=powerpaint['brushnet'].device)
+
+        return (model, positive, negative, {"samples": latent},)
+@torch.inference_mode()
+def brushnet_inference(x, timesteps, transformer_options, debug):
+    if 'model_patch' not in transformer_options:
+        print('BrushNet inference: there is no model_patch key in transformer_options')
+        return ([], 0, [])
+    mp = transformer_options['model_patch']
+    if 'brushnet' not in mp:
+        print('BrushNet inference: there is no brushnet key in mdel_patch')
+        return ([], 0, [])
+    bo = mp['brushnet']
+    if 'model' not in bo:
+        print('BrushNet inference: there is no model key in brushnet')
+        return ([], 0, [])
+    brushnet = bo['model']
+    if not (isinstance(brushnet, BrushNetModel) or isinstance(brushnet, PowerPaintModel)):
+        print('BrushNet model is not a BrushNetModel class')
+        return ([], 0, [])
+
+    torch_dtype = bo['dtype']
+    cl_list = bo['latents']
+    brushnet_conditioning_scale, control_guidance_start, control_guidance_end = bo['controls']
+    pe = bo['prompt_embeds']
+    npe = bo['negative_prompt_embeds']
+    ppe, nppe, time_ids = bo['add_embeds']
+
+    #do_classifier_free_guidance = mp['free_guidance']
+    do_classifier_free_guidance = len(transformer_options['cond_or_uncond']) > 1
+
+    x = x.detach().clone()
+    x = x.to(torch_dtype).to(brushnet.device)
+
+    timesteps = timesteps.detach().clone()
+    timesteps = timesteps.to(torch_dtype).to(brushnet.device)
+
+    total_steps = mp['total_steps']
+    step = mp['step']
+
+    added_cond_kwargs = {}
+
+    if do_classifier_free_guidance and step == 0:
+        print('BrushNet inference: do_classifier_free_guidance is True')
+
+    sub_idx = None
+    if 'ad_params' in transformer_options and 'sub_idxs' in transformer_options['ad_params']:
+        sub_idx = transformer_options['ad_params']['sub_idxs']
+
+    # we have batch input images
+    batch = cl_list[0].shape[0]
+    # we have incoming latents
+    latents_incoming = x.shape[0]
+    # and we already got some
+    latents_got = bo['latent_id']
+    if step == 0 or batch > 1:
+        print('BrushNet inference, step = %d: image batch = %d, got %d latents, starting from %d' \
+                % (step, batch, latents_incoming, latents_got))
+
+    image_latents = []
+    masks = []
+    prompt_embeds = []
+    negative_prompt_embeds = []
+    pooled_prompt_embeds = []
+    negative_pooled_prompt_embeds = []
+    if sub_idx:
+        # AnimateDiff indexes detected
+        if step == 0:
+            print('BrushNet inference: AnimateDiff indexes detected and applied')
+
+        batch = len(sub_idx)
+
+        if do_classifier_free_guidance:
+            for i in sub_idx:
+                image_latents.append(cl_list[0][i][None,:,:,:])
+                masks.append(cl_list[1][i][None,:,:,:])
+                prompt_embeds.append(pe)
+                negative_prompt_embeds.append(npe)
+                pooled_prompt_embeds.append(ppe)
+                negative_pooled_prompt_embeds.append(nppe)
+            for i in sub_idx:
+                image_latents.append(cl_list[0][i][None,:,:,:])
+                masks.append(cl_list[1][i][None,:,:,:])
+        else:
+            for i in sub_idx:
+                image_latents.append(cl_list[0][i][None,:,:,:])
+                masks.append(cl_list[1][i][None,:,:,:])
+                prompt_embeds.append(pe)
+                pooled_prompt_embeds.append(ppe)
+    else:
+        # do_classifier_free_guidance = 2 passes, 1st pass is cond, 2nd is uncond
+        continue_batch = True
+        for i in range(latents_incoming):
+            number = latents_got + i
+            if number < batch:
+                # 1st pass, cond
+                image_latents.append(cl_list[0][number][None,:,:,:])
+                masks.append(cl_list[1][number][None,:,:,:])
+                prompt_embeds.append(pe)
+                pooled_prompt_embeds.append(ppe)
+            elif do_classifier_free_guidance and number < batch * 2:
+                # 2nd pass, uncond
+                image_latents.append(cl_list[0][number-batch][None,:,:,:])
+                masks.append(cl_list[1][number-batch][None,:,:,:])
+                negative_prompt_embeds.append(npe)
+                negative_pooled_prompt_embeds.append(nppe)
+            else:
+                # latent batch
+                image_latents.append(cl_list[0][0][None,:,:,:])
+                masks.append(cl_list[1][0][None,:,:,:])
+                prompt_embeds.append(pe)
+                pooled_prompt_embeds.append(ppe)
+                latents_got = -i
+                continue_batch = False
+
+        if continue_batch:
+            # we don't have full batch yet
+            if do_classifier_free_guidance:
+                if number < batch * 2 - 1:
+                    bo['latent_id'] = number + 1
+                else:
+                    bo['latent_id'] = 0
+            else:
+                if number < batch - 1:
+                    bo['latent_id'] = number + 1
+                else:
+                    bo['latent_id'] = 0
+        else:
+            bo['latent_id'] = 0
+
+    cl = []
+    for il, m in zip(image_latents, masks):
+        cl.append(torch.concat([il, m], dim=1))
+    cl2apply = torch.concat(cl, dim=0)
+
+    conditioning_latents = cl2apply.to(torch_dtype).to(brushnet.device)
+
+    prompt_embeds.extend(negative_prompt_embeds)
+    prompt_embeds = torch.concat(prompt_embeds, dim=0).to(torch_dtype).to(brushnet.device)
+
+    if ppe is not None:
+        added_cond_kwargs = {}
+        added_cond_kwargs['time_ids'] = torch.concat([time_ids] * latents_incoming, dim = 0).to(torch_dtype).to(brushnet.device)
+
+        pooled_prompt_embeds.extend(negative_pooled_prompt_embeds)
+        pooled_prompt_embeds = torch.concat(pooled_prompt_embeds, dim=0).to(torch_dtype).to(brushnet.device)
+        added_cond_kwargs['text_embeds'] = pooled_prompt_embeds
+    else:
+        added_cond_kwargs = None
+
+    if x.shape[2] != conditioning_latents.shape[2] or x.shape[3] != conditioning_latents.shape[3]:
+        if step == 0:
+            print('BrushNet inference: image', conditioning_latents.shape, 'and latent', x.shape, 'have different size, resizing image')
+        conditioning_latents = torch.nn.functional.interpolate(
+            conditioning_latents, size=(
+                x.shape[2],
+                x.shape[3],
+            ), mode='bicubic',
+        ).to(torch_dtype).to(brushnet.device)
+
+    if step == 0:
+        print('BrushNet inference: sample', x.shape, ', CL', conditioning_latents.shape, 'dtype', torch_dtype)
+
+    if debug: print('BrushNet: step =', step)
+
+    if step < control_guidance_start or step > control_guidance_end:
+        cond_scale = 0.0
+    else:
+        cond_scale = brushnet_conditioning_scale
+
+    return brushnet(x,
+        encoder_hidden_states=prompt_embeds,
+        brushnet_cond=conditioning_latents,
+        timestep = timesteps,
+        conditioning_scale=cond_scale,
+        guess_mode=False,
+        added_cond_kwargs=added_cond_kwargs,
+        return_dict=False,
+        debug=debug,
+    )
+
+def add_brushnet_patch(model, brushnet, torch_dtype, conditioning_latents,
+                       controls,
+                       prompt_embeds, negative_prompt_embeds,
+                       pooled_prompt_embeds, negative_pooled_prompt_embeds, time_ids,
+                       debug):
+
+    is_SDXL = isinstance(model.model.model_config, comfy.supported_models.SDXL)
+
+    if is_SDXL:
+        input_blocks = [[0, comfy.ops.disable_weight_init.Conv2d],
+                        [1, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                        [2, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                        [3, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [4, comfy.ldm.modules.attention.SpatialTransformer],
+                        [5, comfy.ldm.modules.attention.SpatialTransformer],
+                        [6, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [7, comfy.ldm.modules.attention.SpatialTransformer],
+                        [8, comfy.ldm.modules.attention.SpatialTransformer]]
+        middle_block = [0, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]
+        output_blocks = [[0, comfy.ldm.modules.attention.SpatialTransformer],
+                         [1, comfy.ldm.modules.attention.SpatialTransformer],
+                         [2, comfy.ldm.modules.attention.SpatialTransformer],
+                         [2, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [3, comfy.ldm.modules.attention.SpatialTransformer],
+                         [4, comfy.ldm.modules.attention.SpatialTransformer],
+                         [5, comfy.ldm.modules.attention.SpatialTransformer],
+                         [5, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [6, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [7, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [8, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]]
+    else:
+        input_blocks = [[0, comfy.ops.disable_weight_init.Conv2d],
+                        [1, comfy.ldm.modules.attention.SpatialTransformer],
+                        [2, comfy.ldm.modules.attention.SpatialTransformer],
+                        [3, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [4, comfy.ldm.modules.attention.SpatialTransformer],
+                        [5, comfy.ldm.modules.attention.SpatialTransformer],
+                        [6, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [7, comfy.ldm.modules.attention.SpatialTransformer],
+                        [8, comfy.ldm.modules.attention.SpatialTransformer],
+                        [9, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [10, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                        [11, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]]
+        middle_block = [0, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]
+        output_blocks = [[0, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [1, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [2, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [2, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [3, comfy.ldm.modules.attention.SpatialTransformer],
+                         [4, comfy.ldm.modules.attention.SpatialTransformer],
+                         [5, comfy.ldm.modules.attention.SpatialTransformer],
+                         [5, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [6, comfy.ldm.modules.attention.SpatialTransformer],
+                         [7, comfy.ldm.modules.attention.SpatialTransformer],
+                         [8, comfy.ldm.modules.attention.SpatialTransformer],
+                         [8, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [9, comfy.ldm.modules.attention.SpatialTransformer],
+                         [10, comfy.ldm.modules.attention.SpatialTransformer],
+                         [11, comfy.ldm.modules.attention.SpatialTransformer]]
+
+    def last_layer_index(block, tp):
+        layer_list = []
+        for layer in block:
+            layer_list.append(type(layer))
+        layer_list.reverse()
+        if tp not in layer_list:
+            return -1, layer_list.reverse()
+        return len(layer_list) - 1 - layer_list.index(tp), layer_list
+
+    def brushnet_forward(model, x, timesteps, transformer_options, control):
+        if 'brushnet' not in transformer_options['model_patch']:
+            input_samples = []
+            mid_sample = 0
+            output_samples = []
+        else:
+            # brushnet inference
+            input_samples, mid_sample, output_samples = brushnet_inference(x, timesteps, transformer_options, debug)
+
+        # give additional samples to blocks
+        for i, tp in input_blocks:
+            idx, layer_list = last_layer_index(model.input_blocks[i], tp)
+            if idx < 0:
+                print("BrushNet can't find", tp, "layer in", i, "input block:", layer_list)
+                continue
+            model.input_blocks[i][idx].add_sample_after = input_samples.pop(0) if input_samples else 0
+
+        idx, layer_list = last_layer_index(model.middle_block, middle_block[1])
+        if idx < 0:
+            print("BrushNet can't find", middle_block[1], "layer in middle block", layer_list)
+        model.middle_block[idx].add_sample_after = mid_sample
+
+        for i, tp in output_blocks:
+            idx, layer_list = last_layer_index(model.output_blocks[i], tp)
+            if idx < 0:
+                print("BrushNet can't find", tp, "layer in", i, "outnput block:", layer_list)
+                continue
+            model.output_blocks[i][idx].add_sample_after = output_samples.pop(0) if output_samples else 0
+
+    patch_model_function_wrapper(model, brushnet_forward)
+
+    to = add_model_patch_option(model)
+    mp = to['model_patch']
+    if 'brushnet' not in mp:
+        mp['brushnet'] = {}
+    bo = mp['brushnet']
+
+    bo['model'] = brushnet
+    bo['dtype'] = torch_dtype
+    bo['latents'] = conditioning_latents
+    bo['controls'] = controls
+    bo['prompt_embeds'] = prompt_embeds
+    bo['negative_prompt_embeds'] = negative_prompt_embeds
+    bo['add_embeds'] = (pooled_prompt_embeds, negative_pooled_prompt_embeds, time_ids)
+    bo['latent_id'] = 0
+
+    # patch layers `forward` so we can apply brushnet
+    def forward_patched_by_brushnet(self, x, *args, **kwargs):
+        h = self.original_forward(x, *args, **kwargs)
+        if hasattr(self, 'add_sample_after') and type(self):
+            to_add = self.add_sample_after
+            if torch.is_tensor(to_add):
+                # interpolate due to RAUNet
+                if h.shape[2] != to_add.shape[2] or h.shape[3] != to_add.shape[3]:
+                    to_add = torch.nn.functional.interpolate(to_add, size=(h.shape[2], h.shape[3]), mode='bicubic')
+                h += to_add.to(h.dtype).to(h.device)
+            else:
+                h += self.add_sample_after
+            self.add_sample_after = 0
+        return h
+
+    for i, block in enumerate(model.model.diffusion_model.input_blocks):
+        for j, layer in enumerate(block):
+            if not hasattr(layer, 'original_forward'):
+                layer.original_forward = layer.forward
+            layer.forward = types.MethodType(forward_patched_by_brushnet, layer)
+            layer.add_sample_after = 0
+
+    for j, layer in enumerate(model.model.diffusion_model.middle_block):
+        if not hasattr(layer, 'original_forward'):
+            layer.original_forward = layer.forward
+        layer.forward = types.MethodType(forward_patched_by_brushnet, layer)
+        layer.add_sample_after = 0
+
+    for i, block in enumerate(model.model.diffusion_model.output_blocks):
+        for j, layer in enumerate(block):
+            if not hasattr(layer, 'original_forward'):
+                layer.original_forward = layer.forward
+            layer.forward = types.MethodType(forward_patched_by_brushnet, layer)
+            layer.add_sample_after = 0
@@ -0,0 +1,58 @@
+{
+  "_class_name": "BrushNetModel",
+  "_diffusers_version": "0.27.0.dev0",
+  "_name_or_path": "runs/logs/brushnet_randommask/checkpoint-100000",
+  "act_fn": "silu",
+  "addition_embed_type": null,
+  "addition_embed_type_num_heads": 64,
+  "addition_time_embed_dim": null,
+  "attention_head_dim": 8,
+  "block_out_channels": [
+    320,
+    640,
+    1280,
+    1280
+  ],
+  "brushnet_conditioning_channel_order": "rgb",
+  "class_embed_type": null,
+  "conditioning_channels": 5,
+  "conditioning_embedding_out_channels": [
+    16,
+    32,
+    96,
+    256
+  ],
+  "cross_attention_dim": 768,
+  "down_block_types": [
+    "DownBlock2D",
+    "DownBlock2D",
+    "DownBlock2D",
+    "DownBlock2D"
+  ],
+  "downsample_padding": 1,
+  "encoder_hid_dim": null,
+  "encoder_hid_dim_type": null,
+  "flip_sin_to_cos": true,
+  "freq_shift": 0,
+  "global_pool_conditions": false,
+  "in_channels": 4,
+  "layers_per_block": 2,
+  "mid_block_scale_factor": 1,
+  "mid_block_type": "MidBlock2D",
+  "norm_eps": 1e-05,
+  "norm_num_groups": 32,
+  "num_attention_heads": null,
+  "num_class_embeds": null,
+  "only_cross_attention": false,
+  "projection_class_embeddings_input_dim": null,
+  "resnet_time_scale_shift": "default",
+  "transformer_layers_per_block": 1,
+  "up_block_types": [
+    "UpBlock2D",
+    "UpBlock2D",
+    "UpBlock2D",
+    "UpBlock2D"
+  ],
+  "upcast_attention": false,
+  "use_linear_projection": false
+}
@@ -0,0 +1,63 @@
+{
+  "_class_name": "BrushNetModel",
+  "_diffusers_version": "0.27.0.dev0",
+  "_name_or_path": "runs/logs/brushnetsdxl_randommask/checkpoint-80000",
+  "act_fn": "silu",
+  "addition_embed_type": "text_time",
+  "addition_embed_type_num_heads": 64,
+  "addition_time_embed_dim": 256,
+  "attention_head_dim": [
+    5,
+    10,
+    20
+  ],
+  "block_out_channels": [
+    320,
+    640,
+    1280
+  ],
+  "brushnet_conditioning_channel_order": "rgb",
+  "class_embed_type": null,
+  "conditioning_channels": 5,
+  "conditioning_embedding_out_channels": [
+    16,
+    32,
+    96,
+    256
+  ],
+  "cross_attention_dim": 2048,
+  "down_block_types": [
+    "DownBlock2D",
+    "DownBlock2D",
+    "DownBlock2D"
+  ],
+  "downsample_padding": 1,
+  "encoder_hid_dim": null,
+  "encoder_hid_dim_type": null,
+  "flip_sin_to_cos": true,
+  "freq_shift": 0,
+  "global_pool_conditions": false,
+  "in_channels": 4,
+  "layers_per_block": 2,
+  "mid_block_scale_factor": 1,
+  "mid_block_type": "MidBlock2D",
+  "norm_eps": 1e-05,
+  "norm_num_groups": 32,
+  "num_attention_heads": null,
+  "num_class_embeds": null,
+  "only_cross_attention": false,
+  "projection_class_embeddings_input_dim": 2816,
+  "resnet_time_scale_shift": "default",
+  "transformer_layers_per_block": [
+    1,
+    2,
+    10
+  ],
+  "up_block_types": [
+    "UpBlock2D",
+    "UpBlock2D",
+    "UpBlock2D"
+  ],
+  "upcast_attention": null,
+  "use_linear_projection": true
+}
@@ -0,0 +1,57 @@
+{
+  "_class_name": "BrushNetModel",
+  "_diffusers_version": "0.27.2",
+  "act_fn": "silu",
+  "addition_embed_type": null,
+  "addition_embed_type_num_heads": 64,
+  "addition_time_embed_dim": null,
+  "attention_head_dim": 8,
+  "block_out_channels": [
+    320,
+    640,
+    1280,
+    1280
+  ],
+  "brushnet_conditioning_channel_order": "rgb",
+  "class_embed_type": null,
+  "conditioning_channels": 5,
+  "conditioning_embedding_out_channels": [
+    16,
+    32,
+    96,
+    256
+  ],
+  "cross_attention_dim": 768,
+  "down_block_types": [
+    "CrossAttnDownBlock2D",
+    "CrossAttnDownBlock2D",
+    "CrossAttnDownBlock2D",
+    "DownBlock2D"
+  ],
+  "downsample_padding": 1,
+  "encoder_hid_dim": null,
+  "encoder_hid_dim_type": null,
+  "flip_sin_to_cos": true,
+  "freq_shift": 0,
+  "global_pool_conditions": false,
+  "in_channels": 4,
+  "layers_per_block": 2,
+  "mid_block_scale_factor": 1,
+  "mid_block_type": "UNetMidBlock2DCrossAttn",
+  "norm_eps": 1e-05,
+  "norm_num_groups": 32,
+  "num_attention_heads": null,
+  "num_class_embeds": null,
+  "only_cross_attention": false,
+  "projection_class_embeddings_input_dim": null,
+  "resnet_time_scale_shift": "default",
+  "transformer_layers_per_block": 1,
+  "up_block_types": [
+    "UpBlock2D",
+    "CrossAttnUpBlock2D",
+    "CrossAttnUpBlock2D",
+    "CrossAttnUpBlock2D"
+  ],
+  "upcast_attention": false,
+  "use_linear_projection": false
+}
@@ -0,0 +1,137 @@
+import torch
+import comfy
+
+# Check and add 'model_patch' to model.model_options['transformer_options']
+def add_model_patch_option(model):
+    if 'transformer_options' not in model.model_options:
+        model.model_options['transformer_options'] = {}
+    to = model.model_options['transformer_options']
+    if "model_patch" not in to:
+        to["model_patch"] = {}
+    return to
+
+
+# Patch model with model_function_wrapper
+def patch_model_function_wrapper(model, forward_patch, remove=False):
+    def brushnet_model_function_wrapper(apply_model_method, options_dict):
+        to = options_dict['c']['transformer_options']
+
+        control = None
+        if 'control' in options_dict['c']:
+            control = options_dict['c']['control']
+
+        x = options_dict['input']
+        timestep = options_dict['timestep']
+
+        # check if there are patches to execute
+        if 'model_patch' not in to or 'forward' not in to['model_patch']:
+            return apply_model_method(x, timestep, **options_dict['c'])
+
+        mp = to['model_patch']
+        unet = mp['unet']
+
+        all_sigmas = mp['all_sigmas']
+        sigma = to['sigmas'][0].item()
+        total_steps = all_sigmas.shape[0] - 1
+        step = torch.argmin((all_sigmas - sigma).abs()).item()
+
+        mp['step'] = step
+        mp['total_steps'] = total_steps
+
+        # comfy.model_base.apply_model
+        xc = model.model.model_sampling.calculate_input(timestep, x)
+        if 'c_concat' in options_dict['c'] and options_dict['c']['c_concat'] is not None:
+            xc = torch.cat([xc] + [options_dict['c']['c_concat']], dim=1)
+        t = model.model.model_sampling.timestep(timestep).float()
+        # execute all patches
+        for method in mp['forward']:
+            method(unet, xc, t, to, control)
+
+        return apply_model_method(x, timestep, **options_dict['c'])
+
+    if "model_function_wrapper" in model.model_options and model.model_options["model_function_wrapper"]:
+        print('BrushNet is going to replace existing model_function_wrapper:',
+              model.model_options["model_function_wrapper"])
+    model.set_model_unet_function_wrapper(brushnet_model_function_wrapper)
+
+    to = add_model_patch_option(model)
+    mp = to['model_patch']
+
+    if isinstance(model.model.model_config, comfy.supported_models.SD15):
+        mp['SDXL'] = False
+    elif isinstance(model.model.model_config, comfy.supported_models.SDXL):
+        mp['SDXL'] = True
+    else:
+        print('Base model type: ', type(model.model.model_config))
+        raise Exception("Unsupported model type: ", type(model.model.model_config))
+
+    if 'forward' not in mp:
+        mp['forward'] = []
+
+    if remove:
+        if forward_patch in mp['forward']:
+            mp['forward'].remove(forward_patch)
+    else:
+        mp['forward'].append(forward_patch)
+
+    mp['unet'] = model.model.diffusion_model
+    mp['step'] = 0
+    mp['total_steps'] = 1
+
+    # apply patches to code
+    if comfy.samplers.sample.__doc__ is None or 'BrushNet' not in comfy.samplers.sample.__doc__:
+        comfy.samplers.original_sample = comfy.samplers.sample
+        comfy.samplers.sample = modified_sample
+
+    if comfy.ldm.modules.diffusionmodules.openaimodel.apply_control.__doc__ is None or \
+            'BrushNet' not in comfy.ldm.modules.diffusionmodules.openaimodel.apply_control.__doc__:
+        comfy.ldm.modules.diffusionmodules.openaimodel.original_apply_control = comfy.ldm.modules.diffusionmodules.openaimodel.apply_control
+        comfy.ldm.modules.diffusionmodules.openaimodel.apply_control = modified_apply_control
+
+
+# Model needs current step number and cfg at inference step. It is possible to write a custom KSampler but I'd like to use ComfyUI's one.
+# The first versions had modified_common_ksampler, but it broke custom KSampler nodes
+def modified_sample(model, noise, positive, negative, cfg, device, sampler, sigmas, model_options={},
+                    latent_image=None, denoise_mask=None, callback=None, disable_pbar=False, seed=None):
+    ''' Modified by BrushNet nodes'''
+    cfg_guider = comfy.samplers.CFGGuider(model)
+    cfg_guider.set_conds(positive, negative)
+    cfg_guider.set_cfg(cfg)
+
+    ### Modified part ######################################################################
+    to = add_model_patch_option(model)
+    to['model_patch']['all_sigmas'] = sigmas
+    #######################################################################################
+
+    return cfg_guider.sample(noise, latent_image, sampler, sigmas, denoise_mask, callback, disable_pbar, seed)
+
+# To use Controlnet with RAUNet it is much easier to modify apply_control a little
+def modified_apply_control(h, control, name):
+    '''Modified by BrushNet nodes'''
+    if control is not None and name in control and len(control[name]) > 0:
+        ctrl = control[name].pop()
+        if ctrl is not None:
+            if h.shape[2] != ctrl.shape[2] or h.shape[3] != ctrl.shape[3]:
+                ctrl = torch.nn.functional.interpolate(ctrl, size=(h.shape[2], h.shape[3]), mode='bicubic').to(
+                    h.dtype).to(h.device)
+            try:
+                h += ctrl
+            except:
+                print.warning("warning control could not be applied {} {}".format(h.shape, ctrl.shape))
+    return h
+
+def add_model_patch(model):
+    to = add_model_patch_option(model)
+    mp = to['model_patch']
+    if "brushnet" in mp:
+        if isinstance(model.model.model_config, comfy.supported_models.SD15):
+            mp['SDXL'] = False
+        elif isinstance(model.model.model_config, comfy.supported_models.SDXL):
+            mp['SDXL'] = True
+        else:
+            print('Base model type: ', type(model.model.model_config))
+            raise Exception("Unsupported model type: ", type(model.model.model_config))
+
+        mp['unet'] = model.model.diffusion_model
+        mp['step'] = 0
+        mp['total_steps'] = 1
@@ -0,0 +1,467 @@
+import copy
+import random
+
+import torch
+import torch.nn as nn
+from transformers import CLIPTokenizer
+from typing import Any, List, Optional, Union
+
+
+class TokenizerWrapper:
+    """Tokenizer wrapper for CLIPTokenizer. Only support CLIPTokenizer
+    currently. This wrapper is modified from https://github.com/huggingface/dif
+    fusers/blob/e51f19aee82c8dd874b715a09dbc521d88835d68/src/diffusers/loaders.
+    py#L358  # noqa.
+
+    Args:
+        from_pretrained (Union[str, os.PathLike], optional): The *model id*
+            of a pretrained model or a path to a *directory* containing
+            model weights and config. Defaults to None.
+        from_config (Union[str, os.PathLike], optional): The *model id*
+            of a pretrained model or a path to a *directory* containing
+            model weights and config. Defaults to None.
+
+        *args, **kwargs: If `from_pretrained` is passed, *args and **kwargs
+            will be passed to `from_pretrained` function. Otherwise, *args
+            and **kwargs will be used to initialize the model by
+            `self._module_cls(*args, **kwargs)`.
+    """
+
+    def __init__(self, tokenizer: CLIPTokenizer):
+        self.wrapped = tokenizer
+        self.token_map = {}
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self.__dict__:
+            return getattr(self, name)
+        # if name == "wrapped":
+        #    return getattr(self, 'wrapped')#super().__getattr__("wrapped")
+
+        try:
+            return getattr(self.wrapped, name)
+        except AttributeError:
+            raise AttributeError(
+                "'name' cannot be found in both "
+                f"'{self.__class__.__name__}' and "
+                f"'{self.__class__.__name__}.tokenizer'."
+            )
+
+    def try_adding_tokens(self, tokens: Union[str, List[str]], *args, **kwargs):
+        """Attempt to add tokens to the tokenizer.
+
+        Args:
+            tokens (Union[str, List[str]]): The tokens to be added.
+        """
+        num_added_tokens = self.wrapped.add_tokens(tokens, *args, **kwargs)
+        assert num_added_tokens != 0, (
+            f"The tokenizer already contains the token {tokens}. Please pass "
+            "a different `placeholder_token` that is not already in the "
+            "tokenizer."
+        )
+
+    def get_token_info(self, token: str) -> dict:
+        """Get the information of a token, including its start and end index in
+        the current tokenizer.
+
+        Args:
+            token (str): The token to be queried.
+
+        Returns:
+            dict: The information of the token, including its start and end
+                index in current tokenizer.
+        """
+        token_ids = self.__call__(token).input_ids
+        start, end = token_ids[1], token_ids[-2] + 1
+        return {"name": token, "start": start, "end": end}
+
+    def add_placeholder_token(self, placeholder_token: str, *args, num_vec_per_token: int = 1, **kwargs):
+        """Add placeholder tokens to the tokenizer.
+
+        Args:
+            placeholder_token (str): The placeholder token to be added.
+            num_vec_per_token (int, optional): The number of vectors of
+                the added placeholder token.
+            *args, **kwargs: The arguments for `self.wrapped.add_tokens`.
+        """
+        output = []
+        if num_vec_per_token == 1:
+            self.try_adding_tokens(placeholder_token, *args, **kwargs)
+            output.append(placeholder_token)
+        else:
+            output = []
+            for i in range(num_vec_per_token):
+                ith_token = placeholder_token + f"_{i}"
+                self.try_adding_tokens(ith_token, *args, **kwargs)
+                output.append(ith_token)
+
+        for token in self.token_map:
+            if token in placeholder_token:
+                raise ValueError(
+                    f"The tokenizer already has placeholder token {token} "
+                    f"that can get confused with {placeholder_token} "
+                    "keep placeholder tokens independent"
+                )
+        self.token_map[placeholder_token] = output
+
+    def replace_placeholder_tokens_in_text(
+            self, text: Union[str, List[str]], vector_shuffle: bool = False, prop_tokens_to_load: float = 1.0
+    ) -> Union[str, List[str]]:
+        """Replace the keywords in text with placeholder tokens. This function
+        will be called in `self.__call__` and `self.encode`.
+
+        Args:
+            text (Union[str, List[str]]): The text to be processed.
+            vector_shuffle (bool, optional): Whether to shuffle the vectors.
+                Defaults to False.
+            prop_tokens_to_load (float, optional): The proportion of tokens to
+                be loaded. If 1.0, all tokens will be loaded. Defaults to 1.0.
+
+        Returns:
+            Union[str, List[str]]: The processed text.
+        """
+        if isinstance(text, list):
+            output = []
+            for i in range(len(text)):
+                output.append(self.replace_placeholder_tokens_in_text(text[i], vector_shuffle=vector_shuffle))
+            return output
+
+        for placeholder_token in self.token_map:
+            if placeholder_token in text:
+                tokens = self.token_map[placeholder_token]
+                tokens = tokens[: 1 + int(len(tokens) * prop_tokens_to_load)]
+                if vector_shuffle:
+                    tokens = copy.copy(tokens)
+                    random.shuffle(tokens)
+                text = text.replace(placeholder_token, " ".join(tokens))
+        return text
+
+    def replace_text_with_placeholder_tokens(self, text: Union[str, List[str]]) -> Union[str, List[str]]:
+        """Replace the placeholder tokens in text with the original keywords.
+        This function will be called in `self.decode`.
+
+        Args:
+            text (Union[str, List[str]]): The text to be processed.
+
+        Returns:
+            Union[str, List[str]]: The processed text.
+        """
+        if isinstance(text, list):
+            output = []
+            for i in range(len(text)):
+                output.append(self.replace_text_with_placeholder_tokens(text[i]))
+            return output
+
+        for placeholder_token, tokens in self.token_map.items():
+            merged_tokens = " ".join(tokens)
+            if merged_tokens in text:
+                text = text.replace(merged_tokens, placeholder_token)
+        return text
+
+    def __call__(
+            self,
+            text: Union[str, List[str]],
+            *args,
+            vector_shuffle: bool = False,
+            prop_tokens_to_load: float = 1.0,
+            **kwargs,
+    ):
+        """The call function of the wrapper.
+
+        Args:
+            text (Union[str, List[str]]): The text to be tokenized.
+            vector_shuffle (bool, optional): Whether to shuffle the vectors.
+                Defaults to False.
+            prop_tokens_to_load (float, optional): The proportion of tokens to
+                be loaded. If 1.0, all tokens will be loaded. Defaults to 1.0
+            *args, **kwargs: The arguments for `self.wrapped.__call__`.
+        """
+        replaced_text = self.replace_placeholder_tokens_in_text(
+            text, vector_shuffle=vector_shuffle, prop_tokens_to_load=prop_tokens_to_load
+        )
+
+        return self.wrapped.__call__(replaced_text, *args, **kwargs)
+
+    def encode(self, text: Union[str, List[str]], *args, **kwargs):
+        """Encode the passed text to token index.
+
+        Args:
+            text (Union[str, List[str]]): The text to be encode.
+            *args, **kwargs: The arguments for `self.wrapped.__call__`.
+        """
+        replaced_text = self.replace_placeholder_tokens_in_text(text)
+        return self.wrapped(replaced_text, *args, **kwargs)
+
+    def decode(self, token_ids, return_raw: bool = False, *args, **kwargs) -> Union[str, List[str]]:
+        """Decode the token index to text.
+
+        Args:
+            token_ids: The token index to be decoded.
+            return_raw: Whether keep the placeholder token in the text.
+                Defaults to False.
+            *args, **kwargs: The arguments for `self.wrapped.decode`.
+
+        Returns:
+            Union[str, List[str]]: The decoded text.
+        """
+        text = self.wrapped.decode(token_ids, *args, **kwargs)
+        if return_raw:
+            return text
+        replaced_text = self.replace_text_with_placeholder_tokens(text)
+        return replaced_text
+
+    def __repr__(self):
+        """The representation of the wrapper."""
+        s = super().__repr__()
+        prefix = f"Wrapped Module Class: {self._module_cls}\n"
+        prefix += f"Wrapped Module Name: {self._module_name}\n"
+        if self._from_pretrained:
+            prefix += f"From Pretrained: {self._from_pretrained}\n"
+        s = prefix + s
+        return s
+
+
+class EmbeddingLayerWithFixes(nn.Module):
+    """The revised embedding layer to support external embeddings. This design
+    of this class is inspired by https://github.com/AUTOMATIC1111/stable-
+    diffusion-webui/blob/22bcc7be428c94e9408f589966c2040187245d81/modules/sd_hi
+    jack.py#L224  # noqa.
+
+    Args:
+        wrapped (nn.Emebdding): The embedding layer to be wrapped.
+        external_embeddings (Union[dict, List[dict]], optional): The external
+            embeddings added to this layer. Defaults to None.
+    """
+
+    def __init__(self, wrapped: nn.Embedding, external_embeddings: Optional[Union[dict, List[dict]]] = None):
+        super().__init__()
+        self.wrapped = wrapped
+        self.num_embeddings = wrapped.weight.shape[0]
+
+        self.external_embeddings = []
+        if external_embeddings:
+            self.add_embeddings(external_embeddings)
+
+        self.trainable_embeddings = nn.ParameterDict()
+
+    @property
+    def weight(self):
+        """Get the weight of wrapped embedding layer."""
+        return self.wrapped.weight
+
+    def check_duplicate_names(self, embeddings: List[dict]):
+        """Check whether duplicate names exist in list of 'external
+        embeddings'.
+
+        Args:
+            embeddings (List[dict]): A list of embedding to be check.
+        """
+        names = [emb["name"] for emb in embeddings]
+        assert len(names) == len(set(names)), (
+            "Found duplicated names in 'external_embeddings'. Name list: " f"'{names}'"
+        )
+
+    def check_ids_overlap(self, embeddings):
+        """Check whether overlap exist in token ids of 'external_embeddings'.
+
+        Args:
+            embeddings (List[dict]): A list of embedding to be check.
+        """
+        ids_range = [[emb["start"], emb["end"], emb["name"]] for emb in embeddings]
+        ids_range.sort()  # sort by 'start'
+        # check if 'end' has overlapping
+        for idx in range(len(ids_range) - 1):
+            name1, name2 = ids_range[idx][-1], ids_range[idx + 1][-1]
+            assert ids_range[idx][1] <= ids_range[idx + 1][0], (
+                f"Found ids overlapping between embeddings '{name1}' " f"and '{name2}'."
+            )
+
+    def add_embeddings(self, embeddings: Optional[Union[dict, List[dict]]]):
+        """Add external embeddings to this layer.
+        Use case:
+        Args:
+            embeddings (Union[dict, list[dict]]): The external embeddings to
+                be added. Each dict must contain the following 4 fields: 'name'
+                (the name of this embedding), 'embedding' (the embedding
+                tensor), 'start' (the start token id of this embedding), 'end'
+                (the end token id of this embedding). For example:
+                `{name: NAME, start: START, end: END, embedding: torch.Tensor}`
+        """
+        if isinstance(embeddings, dict):
+            embeddings = [embeddings]
+
+        self.external_embeddings += embeddings
+        self.check_duplicate_names(self.external_embeddings)
+        self.check_ids_overlap(self.external_embeddings)
+
+        # set for trainable
+        added_trainable_emb_info = []
+        for embedding in embeddings:
+            trainable = embedding.get("trainable", False)
+            if trainable:
+                name = embedding["name"]
+                embedding["embedding"] = torch.nn.Parameter(embedding["embedding"])
+                self.trainable_embeddings[name] = embedding["embedding"]
+                added_trainable_emb_info.append(name)
+
+        added_emb_info = [emb["name"] for emb in embeddings]
+        added_emb_info = ", ".join(added_emb_info)
+        print(f"Successfully add external embeddings: {added_emb_info}.", "current")
+
+        if added_trainable_emb_info:
+            added_trainable_emb_info = ", ".join(added_trainable_emb_info)
+            print("Successfully add trainable external embeddings: " f"{added_trainable_emb_info}", "current")
+
+    def replace_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
+        """Replace external input ids to 0.
+
+        Args:
+            input_ids (torch.Tensor): The input ids to be replaced.
+
+        Returns:
+            torch.Tensor: The replaced input ids.
+        """
+        input_ids_fwd = input_ids.clone()
+        input_ids_fwd[input_ids_fwd >= self.num_embeddings] = 0
+        return input_ids_fwd
+
+    def replace_embeddings(
+            self, input_ids: torch.Tensor, embedding: torch.Tensor, external_embedding: dict
+    ) -> torch.Tensor:
+        """Replace external embedding to the embedding layer. Noted that, in
+        this function we use `torch.cat` to avoid inplace modification.
+
+        Args:
+            input_ids (torch.Tensor): The original token ids. Shape like
+                [LENGTH, ].
+            embedding (torch.Tensor): The embedding of token ids after
+                `replace_input_ids` function.
+            external_embedding (dict): The external embedding to be replaced.
+
+        Returns:
+            torch.Tensor: The replaced embedding.
+        """
+        new_embedding = []
+
+        name = external_embedding["name"]
+        start = external_embedding["start"]
+        end = external_embedding["end"]
+        target_ids_to_replace = [i for i in range(start, end)]
+        ext_emb = external_embedding["embedding"].to(embedding.device)
+
+        # do not need to replace
+        if not (input_ids == start).any():
+            return embedding
+
+        # start replace
+        s_idx, e_idx = 0, 0
+        while e_idx < len(input_ids):
+            if input_ids[e_idx] == start:
+                if e_idx != 0:
+                    # add embedding do not need to replace
+                    new_embedding.append(embedding[s_idx:e_idx])
+
+                # check if the next embedding need to replace is valid
+                actually_ids_to_replace = [int(i) for i in input_ids[e_idx: e_idx + end - start]]
+                assert actually_ids_to_replace == target_ids_to_replace, (
+                    f"Invalid 'input_ids' in position: {s_idx} to {e_idx}. "
+                    f"Expect '{target_ids_to_replace}' for embedding "
+                    f"'{name}' but found '{actually_ids_to_replace}'."
+                )
+
+                new_embedding.append(ext_emb)
+
+                s_idx = e_idx + end - start
+                e_idx = s_idx + 1
+            else:
+                e_idx += 1
+
+        if e_idx == len(input_ids):
+            new_embedding.append(embedding[s_idx:e_idx])
+
+        return torch.cat(new_embedding, dim=0)
+
+    def forward(self, input_ids: torch.Tensor, external_embeddings: Optional[List[dict]] = None, out_dtype = None):
+        """The forward function.
+
+        Args:
+            input_ids (torch.Tensor): The token ids shape like [bz, LENGTH] or
+                [LENGTH, ].
+            external_embeddings (Optional[List[dict]]): The external
+                embeddings. If not passed, only `self.external_embeddings`
+                will be used.  Defaults to None.
+
+        input_ids: shape like [bz, LENGTH] or [LENGTH].
+        """
+        assert input_ids.ndim in [1, 2]
+        if input_ids.ndim == 1:
+            input_ids = input_ids.unsqueeze(0)
+
+        if external_embeddings is None and not self.external_embeddings:
+            return self.wrapped(input_ids, out_dtype=out_dtype)
+
+        input_ids_fwd = self.replace_input_ids(input_ids)
+        inputs_embeds = self.wrapped(input_ids_fwd)
+
+        vecs = []
+
+        if external_embeddings is None:
+            external_embeddings = []
+        elif isinstance(external_embeddings, dict):
+            external_embeddings = [external_embeddings]
+        embeddings = self.external_embeddings + external_embeddings
+
+        for input_id, embedding in zip(input_ids, inputs_embeds):
+            new_embedding = embedding
+            for external_embedding in embeddings:
+                new_embedding = self.replace_embeddings(input_id, new_embedding, external_embedding)
+            vecs.append(new_embedding)
+
+        return torch.stack(vecs).to(out_dtype)
+
+
+def add_tokens(
+        tokenizer, text_encoder, placeholder_tokens: list, initialize_tokens: list = None,
+        num_vectors_per_token: int = 1
+):
+    """Add token for training.
+
+    # TODO: support add tokens as dict, then we can load pretrained tokens.
+    """
+    if initialize_tokens is not None:
+        assert len(initialize_tokens) == len(
+            placeholder_tokens
+        ), "placeholder_token should be the same length as initialize_token"
+    for ii in range(len(placeholder_tokens)):
+        tokenizer.add_placeholder_token(placeholder_tokens[ii], num_vec_per_token=num_vectors_per_token)
+
+    # text_encoder.set_embedding_layer()
+    embedding_layer = text_encoder.text_model.embeddings.token_embedding
+    text_encoder.text_model.embeddings.token_embedding = EmbeddingLayerWithFixes(embedding_layer)
+    embedding_layer = text_encoder.text_model.embeddings.token_embedding
+
+    assert embedding_layer is not None, (
+        "Do not support get embedding layer for current text encoder. " "Please check your configuration."
+    )
+    initialize_embedding = []
+    if initialize_tokens is not None:
+        for ii in range(len(placeholder_tokens)):
+            init_id = tokenizer(initialize_tokens[ii]).input_ids[1]
+            temp_embedding = embedding_layer.weight[init_id]
+            initialize_embedding.append(temp_embedding[None, ...].repeat(num_vectors_per_token, 1))
+    else:
+        for ii in range(len(placeholder_tokens)):
+            init_id = tokenizer("a").input_ids[1]
+            temp_embedding = embedding_layer.weight[init_id]
+            len_emb = temp_embedding.shape[0]
+            init_weight = (torch.rand(num_vectors_per_token, len_emb) - 0.5) / 2.0
+            initialize_embedding.append(init_weight)
+
+    # initialize_embedding  = torch.cat(initialize_embedding,dim=0)
+
+    token_info_all = []
+    for ii in range(len(placeholder_tokens)):
+        token_info = tokenizer.get_token_info(placeholder_tokens[ii])
+        token_info["embedding"] = initialize_embedding[ii]
+        token_info["trainable"] = True
+        token_info_all.append(token_info)
+    embedding_layer.add_embeddings(token_info_all)
@@ -3,7 +3,7 @@ import folder_paths
 from pathlib import Path

 BASE_RESOLUTIONS = [
-    ("自定义", "自定义"),
+    ("width", "height"),
    (512, 512),
    (512, 768),
    (576, 1024),
@@ -15,6 +15,7 @@ BASE_RESOLUTIONS = [
    (768, 1536),
    (816, 1920),
    (832, 1152),
+    (832, 1216),
    (896, 1152),
    (896, 1088),
    (1024, 1024),
@@ -23,6 +24,7 @@ BASE_RESOLUTIONS = [
    (1080, 1920),
    (1440, 2560),
    (1088, 896),
+    (1216, 832),
    (1152, 832),
    (1152, 896),
    (1280, 768),
@@ -38,7 +40,7 @@ MAX_SEED_NUM = 1125899906842624

 RESOURCES_DIR = os.path.join(Path(__file__).parent.parent, "resources")

-# fooocus
+# inpaint
 INPAINT_DIR = os.path.join(folder_paths.models_dir, "inpaint")
 FOOOCUS_STYLES_DIR = os.path.join(Path(__file__).parent.parent, "styles")
 FOOOCUS_STYLES_SAMPLES = 'https://raw.githubusercontent.com/lllyasviel/Fooocus/main/sdxl_styles/samples/'
@@ -58,6 +60,33 @@ FOOOCUS_INPAINT_PATCH = {
        "model_url": "https://huggingface.co/lllyasviel/fooocus_inpaint/resolve/main/inpaint.fooocus.patch"
    },
 }
+BRUSHNET_MODELS = {
+    "random_mask": {
+        "sd1": {
+            "model_url": "https://huggingface.co/Kijai/BrushNet-fp16/resolve/main/brushnet_random_mask_fp16.safetensors"
+        },
+        "sdxl": {
+            "model_url": "https://huggingface.co/yolain/brushnet/resolve/main/brushnet_random_mask_sdxl.safetensors"
+        }
+    },
+    "segmentation_mask": {
+        "sd1": {
+            "model_url": "https://huggingface.co/Kijai/BrushNet-fp16/resolve/main/brushnet_segmentation_mask_fp16.safetensors"
+        },
+        "sdxl": {
+            "model_url": "https://huggingface.co/yolain/brushnet/resolve/main/brushnet_segmentation_mask_sdxl.safetensors"
+        }
+    }
+}
+POWERPAINT_MODELS = {
+    "base_fp16": {
+        "model_url": "https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/text_encoder/model.fp16.safetensors"
+    },
+    "v2.1": {
+        "model_url": "https://huggingface.co/JunhaoZhuang/PowerPaint-v2-1/resolve/main/PowerPaint_Brushnet/diffusion_pytorch_model.safetensors",
+        "clip_url": "https://huggingface.co/JunhaoZhuang/PowerPaint-v2-1/resolve/main/PowerPaint_Brushnet/pytorch_model.bin",
+    }
+}

 # layerDiffuse
 LAYER_DIFFUSION_DIR = os.path.join(folder_paths.models_dir, "layer_model")
@@ -68,7 +97,7 @@ LAYER_DIFFUSION_VAE = {
        }
    },
    "decode": {
-        "sd15": {
+        "sd1": {
            "model_url": "https://huggingface.co/LayerDiffusion/layerdiffusion-v1/resolve/main/layer_sd15_vae_transparent_decoder.safetensors"
        },
        "sdxl": {
@@ -78,7 +107,7 @@ LAYER_DIFFUSION_VAE = {
 }
 LAYER_DIFFUSION = {
    "Attention Injection": {
-        "sd15": {
+        "sd1": {
          "model_url": "https://huggingface.co/LayerDiffusion/layerdiffusion-v1/resolve/main/layer_sd15_transparent_attn.safetensors"
        },
        "sdxl": {
@@ -89,12 +118,12 @@ LAYER_DIFFUSION = {
        "sdxl": {
            "model_url": "https://huggingface.co/LayerDiffusion/layerdiffusion-v1/resolve/main/layer_xl_transparent_conv.safetensors"
        },
-        "sd15": {
+        "sd1": {
            "model_url": None
        }
    },
    "Everything": {
-        "sd15": {
+        "sd1": {
          "model_url": "https://huggingface.co/LayerDiffusion/layerdiffusion-v1/resolve/main/layer_sd15_joint.safetensors"
        },
        "sdxl": {
@@ -102,7 +131,7 @@ LAYER_DIFFUSION = {
        }
    },
    "Foreground": {
-        "sd15": {
+        "sd1": {
          "model_url": "https://huggingface.co/LayerDiffusion/layerdiffusion-v1/resolve/main/layer_sd15_fg2bg.safetensors"
        },
        "sdxl": {
@@ -110,7 +139,7 @@ LAYER_DIFFUSION = {
        }
    },
    "Foreground to Background": {
-        "sd15": {
+        "sd1": {
          "model_url": "https://huggingface.co/LayerDiffusion/layerdiffusion-v1/resolve/main/layer_sd15_fg2bg.safetensors"
        },
        "sdxl": {
@@ -118,7 +147,7 @@ LAYER_DIFFUSION = {
        }
    },
    "Background": {
-        "sd15": {
+        "sd1": {
          "model_url": "https://huggingface.co/LayerDiffusion/layerdiffusion-v1/resolve/main/layer_sd15_bg2fg.safetensors"
        },
        "sdxl": {
@@ -126,7 +155,7 @@ LAYER_DIFFUSION = {
        }
    },
    "Background to Foreground": {
-        "sd15": {
+        "sd1": {
            "model_url": "https://huggingface.co/LayerDiffusion/layerdiffusion-v1/resolve/main/layer_sd15_bg2fg.safetensors"
        },
        "sdxl": {
@@ -135,6 +164,27 @@ LAYER_DIFFUSION = {
    },
 }

+# IC Light
+IC_LIGHT_MODELS = {
+    "Foreground": {
+        "sd1": {
+            "model_url": "https://huggingface.co/huchenlei/IC-Light-ldm/resolve/main/iclight_sd15_fc_unet_ldm.safetensors"
+        },
+        "sdxl": {
+            "model_url": None
+        }
+    },
+    "Foreground&Background": {
+        "sd1": {
+            "model_url": "https://huggingface.co/huchenlei/IC-Light-ldm/resolve/main/iclight_sd15_fbc_unet_ldm.safetensors"
+        },
+        "sdxl": {
+            "model_url": None
+        }
+    }
+}
+
+
 # REMBG
 REMBG_DIR = os.path.join(folder_paths.models_dir, "rembg")
 REMBG_MODELS = {
@@ -159,7 +209,7 @@ IPADAPTER_MODELS = {
            "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter_sd15.safetensors"
        },
        "sdxl": {
-            "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/sdxl_models/ip-adapter_sdxl.safetensors"
+            "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/sdxl_models/ip-adapter_sdxl_vit-h.safetensors"
        }
    },
    "VIT-G (medium strength)": {
@@ -167,7 +217,7 @@ IPADAPTER_MODELS = {
            "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter_sd15_vit-G.safetensors"
        },
        "sdxl": {
-            "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/sdxl_models/ip-adapter_sdxl_vit-h.safetensors"
+            "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/sdxl_models/ip-adapter_sdxl.safetensors"
        }
    },
    "PLUS (high strength)": {
@@ -178,6 +228,14 @@ IPADAPTER_MODELS = {
            "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/sdxl_models/ip-adapter-plus_sdxl_vit-h.safetensors"
        }
    },
+    "PLUS (kolors genernal)":{
+        "sd15":{
+            "model_url":""
+        },
+        "sdxl":{
+            "model_url":"https://huggingface.co/Kwai-Kolors/Kolors-IP-Adapter-Plus/resolve/main/ip_adapter_plus_general.bin"
+        }
+    },
    "PLUS FACE (portraits)": {
        "sd15": {
            "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter-plus-face_sd15.safetensors"
@@ -224,6 +282,14 @@ IPADAPTER_MODELS = {
            "lora_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-plusv2_sdxl_lora.safetensors"
        }
    },
+    "FACEID PLUS KOLORS":{
+        "sd15":{
+
+        },
+        "sdxl":{
+            "model_url":"https://huggingface.co/Kwai-Kolors/Kolors-IP-Adapter-FaceID-Plus/resolve/main/ipa-faceid-plus.bin"
+        }
+    },
    "FACEID PORTRAIT (style transfer)": {
        "sd15": {
            "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-portrait-v11_sd15.bin",
@@ -232,6 +298,14 @@ IPADAPTER_MODELS = {
            "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-portrait_sdxl.bin",
        }
    },
+    "FACEID PORTRAIT UNNORM - SDXL only (strong)": {
+        "sd15": {
+            "model_url":""
+        },
+        "sdxl": {
+            "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-portrait_sdxl_unnorm.bin",
+        }
+    },
    "COMPOSITION": {
        "sd15": {
            "model_url": "https://huggingface.co/ostris/ip-composition-adapter/resolve/main/ip_plus_composition_sd15.safetensors"
@@ -241,6 +315,14 @@ IPADAPTER_MODELS = {
        }
    }
 }
+IPADAPTER_CLIPVISION_MODELS = {
+    "clip-vit-large-patch14-336":{
+        "model_url": "https://huggingface.co/openai/clip-vit-large-patch14-336/resolve/main/pytorch_model.bin"
+    },
+    "clip-vit-h-14-laion2B-s32B-b79K":{
+        "model_url": "https://huggingface.co/laion/CLIP-ViT-H-14-laion2B-s32B-b79K/resolve/main/open_clip_pytorch_model.safetensors"
+    }
+}

 # dynamiCrafter
 DYNAMICRAFTER_DIR = os.path.join(folder_paths.models_dir, "dynamicrafter_models")
@@ -260,4 +342,19 @@ DYNAMICRAFTER_MODELS = {
    "dynamicrafter_unet_256 (2.98GB)": {
        "model_url": "https://huggingface.co/ExponentialML/DynamiCrafterUNet/resolve/main/dynamicrafter_unet_256.safetensors"
    },
+}
+
+#humanParsing
+HUMANPARSING_MODELS = {
+    "parsing_lip": {
+        "model_url": "https://huggingface.co/levihsu/OOTDiffusion/resolve/main/checkpoints/humanparsing/parsing_lip.onnx",
+    },
+}
+
+#mediapipe
+MEDIAPIPE_DIR = os.path.join(folder_paths.models_dir, "mediapipe")
+MEDIAPIPE_MODELS = {
+    "selfie_multiclass_256x256": {
+        "model_url": "https://huggingface.co/yolain/selfie_multiclass_256x256/resolve/main/selfie_multiclass_256x256.tflite"
+    }
 }
@@ -0,0 +1,2 @@
+#credit to city96 for this module
+#from https://github.com/city96/ComfyUI_ExtraModels/
@@ -0,0 +1,120 @@
+"""
+List of all DiT model types / settings
+"""
+sampling_settings = {
+	"beta_schedule" : "sqrt_linear",
+	"linear_start"  : 0.0001,
+	"linear_end"    : 0.02,
+	"timesteps"     : 1000,
+}
+
+dit_conf = {
+	"XL/2": { # DiT_XL_2
+		"unet_config": {
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"XL/4": { # DiT_XL_4
+		"unet_config": {
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    4,
+			"hidden_size" : 1152,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"XL/8": { # DiT_XL_8
+		"unet_config": {
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    8,
+			"hidden_size" : 1152,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"L/2": { # DiT_L_2
+		"unet_config": {
+			"depth"       :   24,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1024,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"L/4": { # DiT_L_4
+		"unet_config": {
+			"depth"       :   24,
+			"num_heads"   :   16,
+			"patch_size"  :    4,
+			"hidden_size" : 1024,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"L/8": { # DiT_L_8
+		"unet_config": {
+			"depth"       :   24,
+			"num_heads"   :   16,
+			"patch_size"  :    8,
+			"hidden_size" : 1024,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"B/2": { # DiT_B_2
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :   12,
+			"patch_size"  :    2,
+			"hidden_size" :  768,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"B/4": { # DiT_B_4
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :   12,
+			"patch_size"  :    4,
+			"hidden_size" :  768,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"B/8": { # DiT_B_8
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :   12,
+			"patch_size"  :    8,
+			"hidden_size" :  768,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"S/2": { # DiT_S_2
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :    6,
+			"patch_size"  :    2,
+			"hidden_size" :  384,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"S/4": { # DiT_S_4
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :    6,
+			"patch_size"  :    4,
+			"hidden_size" :  384,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"S/8": { # DiT_S_8
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :    6,
+			"patch_size"  :    8,
+			"hidden_size" :  384,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+}
@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.
@@ -0,0 +1,139 @@
+"""
+List of all PixArt model types / settings
+"""
+sampling_settings = {
+	"beta_schedule" : "sqrt_linear",
+	"linear_start"  : 0.0001,
+	"linear_end"    : 0.02,
+	"timesteps"     : 1000,
+}
+
+pixart_conf = {
+	"PixArtMS_XL_2": { # models/PixArtMS
+		"target": "PixArtMS",
+		"unet_config": {
+			"input_size"  : 1024//8,
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+			"pe_interpolation": 2,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"PixArtMS_Sigma_XL_2": {
+		"target": "PixArtMSSigma",
+		"unet_config": {
+			"input_size"  : 1024//8,
+			"token_num"   :  300,
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+			"micro_condition": False,
+			"pe_interpolation": 2,
+			"model_max_length": 300,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"PixArtMS_Sigma_XL_2_900M": {
+		"target": "PixArtMSSigma",
+		"unet_config": {
+			"input_size": 1024 // 8,
+			"token_num": 300,
+			"depth": 42,
+			"num_heads": 16,
+			"patch_size": 2,
+			"hidden_size": 1152,
+			"micro_condition": False,
+			"pe_interpolation": 2,
+			"model_max_length": 300,
+		},
+		"sampling_settings": sampling_settings,
+	},
+	"PixArtMS_Sigma_XL_2_2K": {
+		"target": "PixArtMSSigma",
+		"unet_config": {
+			"input_size"  : 2048//8,
+			"token_num"   :  300,
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+			"micro_condition": False,
+			"pe_interpolation": 4,
+			"model_max_length": 300,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"PixArt_XL_2": { # models/PixArt
+		"target": "PixArt",
+		"unet_config": {
+			"input_size"  :  512//8,
+			"token_num"   :  120,
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+			"pe_interpolation": 1,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+}
+
+pixart_conf.update({ # controlnet models
+	"ControlPixArtHalf": {
+		"target": "ControlPixArtHalf",
+		"unet_config": pixart_conf["PixArt_XL_2"]["unet_config"],
+		"sampling_settings": pixart_conf["PixArt_XL_2"]["sampling_settings"],
+	},
+	"ControlPixArtMSHalf": {
+		"target": "ControlPixArtMSHalf",
+		"unet_config": pixart_conf["PixArtMS_XL_2"]["unet_config"],
+		"sampling_settings": pixart_conf["PixArtMS_XL_2"]["sampling_settings"],
+	}
+})
+
+pixart_res = {
+	"PixArtMS_XL_2": { # models/PixArtMS 1024x1024
+		'0.25': [512, 2048], '0.26': [512, 1984], '0.27': [512, 1920], '0.28': [512, 1856],
+		'0.32': [576, 1792], '0.33': [576, 1728], '0.35': [576, 1664], '0.40': [640, 1600],
+		'0.42': [640, 1536], '0.48': [704, 1472], '0.50': [704, 1408], '0.52': [704, 1344],
+		'0.57': [768, 1344], '0.60': [768, 1280], '0.68': [832, 1216], '0.72': [832, 1152],
+		'0.78': [896, 1152], '0.82': [896, 1088], '0.88': [960, 1088], '0.94': [960, 1024],
+		'1.00': [1024,1024], '1.07': [1024, 960], '1.13': [1088, 960], '1.21': [1088, 896],
+		'1.29': [1152, 896], '1.38': [1152, 832], '1.46': [1216, 832], '1.67': [1280, 768],
+		'1.75': [1344, 768], '2.00': [1408, 704], '2.09': [1472, 704], '2.40': [1536, 640],
+		'2.50': [1600, 640], '2.89': [1664, 576], '3.00': [1728, 576], '3.11': [1792, 576],
+		'3.62': [1856, 512], '3.75': [1920, 512], '3.88': [1984, 512], '4.00': [2048, 512],
+	},
+	"PixArt_XL_2": { # models/PixArt 512x512
+		'0.25': [256,1024], '0.26': [256, 992], '0.27': [256, 960], '0.28': [256, 928],
+		'0.32': [288, 896], '0.33': [288, 864], '0.35': [288, 832], '0.40': [320, 800],
+		'0.42': [320, 768], '0.48': [352, 736], '0.50': [352, 704], '0.52': [352, 672],
+		'0.57': [384, 672], '0.60': [384, 640], '0.68': [416, 608], '0.72': [416, 576],
+		'0.78': [448, 576], '0.82': [448, 544], '0.88': [480, 544], '0.94': [480, 512],
+		'1.00': [512, 512], '1.07': [512, 480], '1.13': [544, 480], '1.21': [544, 448],
+		'1.29': [576, 448], '1.38': [576, 416], '1.46': [608, 416], '1.67': [640, 384],
+		'1.75': [672, 384], '2.00': [704, 352], '2.09': [736, 352], '2.40': [768, 320],
+		'2.50': [800, 320], '2.89': [832, 288], '3.00': [864, 288], '3.11': [896, 288],
+		'3.62': [928, 256], '3.75': [960, 256], '3.88': [992, 256], '4.00': [1024,256]
+	},
+	"PixArtMS_Sigma_XL_2_2K": {
+		'0.25': [1024, 4096], '0.26': [1024, 3968], '0.27': [1024, 3840], '0.28': [1024, 3712],
+		'0.32': [1152, 3584], '0.33': [1152, 3456], '0.35': [1152, 3328], '0.40': [1280, 3200],
+		'0.42': [1280, 3072], '0.48': [1408, 2944], '0.50': [1408, 2816], '0.52': [1408, 2688],
+		'0.57': [1536, 2688], '0.60': [1536, 2560], '0.68': [1664, 2432], '0.72': [1664, 2304],
+		'0.78': [1792, 2304], '0.82': [1792, 2176], '0.88': [1920, 2176], '0.94': [1920, 2048],
+		'1.00': [2048, 2048], '1.07': [2048, 1920], '1.13': [2176, 1920], '1.21': [2176, 1792],
+		'1.29': [2304, 1792], '1.38': [2304, 1664], '1.46': [2432, 1664], '1.67': [2560, 1536],
+		'1.75': [2688, 1536], '2.00': [2816, 1408], '2.09': [2944, 1408], '2.40': [3072, 1280],
+		'2.50': [3200, 1280], '2.89': [3328, 1152], '3.00': [3456, 1152], '3.11': [3584, 1152],
+		'3.62': [3712, 1024], '3.75': [3840, 1024], '3.88': [3968, 1024], '4.00': [4096, 1024]
+	}
+}
+# These should be the same
+pixart_res.update({
+	"PixArtMS_Sigma_XL_2": pixart_res["PixArtMS_XL_2"],
+	"PixArtMS_Sigma_XL_2_512": pixart_res["PixArt_XL_2"],
+})
@@ -0,0 +1,216 @@
+# For using the diffusers format weights
+#  Based on the original ComfyUI function +
+#  https://github.com/PixArt-alpha/PixArt-alpha/blob/master/tools/convert_pixart_alpha_to_diffusers.py
+import torch
+
+conversion_map_ms = [  # for multi_scale_train (MS)
+    # Resolution
+    ("csize_embedder.mlp.0.weight", "adaln_single.emb.resolution_embedder.linear_1.weight"),
+    ("csize_embedder.mlp.0.bias", "adaln_single.emb.resolution_embedder.linear_1.bias"),
+    ("csize_embedder.mlp.2.weight", "adaln_single.emb.resolution_embedder.linear_2.weight"),
+    ("csize_embedder.mlp.2.bias", "adaln_single.emb.resolution_embedder.linear_2.bias"),
+    # Aspect ratio
+    ("ar_embedder.mlp.0.weight", "adaln_single.emb.aspect_ratio_embedder.linear_1.weight"),
+    ("ar_embedder.mlp.0.bias", "adaln_single.emb.aspect_ratio_embedder.linear_1.bias"),
+    ("ar_embedder.mlp.2.weight", "adaln_single.emb.aspect_ratio_embedder.linear_2.weight"),
+    ("ar_embedder.mlp.2.bias", "adaln_single.emb.aspect_ratio_embedder.linear_2.bias"),
+]
+
+
+def get_depth(state_dict):
+    return sum(key.endswith('.attn1.to_k.bias') for key in state_dict.keys())
+
+
+def get_lora_depth(state_dict):
+    return sum(key.endswith('.attn1.to_k.lora_A.weight') for key in state_dict.keys())
+
+
+def get_conversion_map(state_dict):
+    conversion_map = [  # main SD conversion map (PixArt reference, HF Diffusers)
+        # Patch embeddings
+        ("x_embedder.proj.weight", "pos_embed.proj.weight"),
+        ("x_embedder.proj.bias", "pos_embed.proj.bias"),
+        # Caption projection
+        ("y_embedder.y_embedding", "caption_projection.y_embedding"),
+        ("y_embedder.y_proj.fc1.weight", "caption_projection.linear_1.weight"),
+        ("y_embedder.y_proj.fc1.bias", "caption_projection.linear_1.bias"),
+        ("y_embedder.y_proj.fc2.weight", "caption_projection.linear_2.weight"),
+        ("y_embedder.y_proj.fc2.bias", "caption_projection.linear_2.bias"),
+        # AdaLN-single LN
+        ("t_embedder.mlp.0.weight", "adaln_single.emb.timestep_embedder.linear_1.weight"),
+        ("t_embedder.mlp.0.bias", "adaln_single.emb.timestep_embedder.linear_1.bias"),
+        ("t_embedder.mlp.2.weight", "adaln_single.emb.timestep_embedder.linear_2.weight"),
+        ("t_embedder.mlp.2.bias", "adaln_single.emb.timestep_embedder.linear_2.bias"),
+        # Shared norm
+        ("t_block.1.weight", "adaln_single.linear.weight"),
+        ("t_block.1.bias", "adaln_single.linear.bias"),
+        # Final block
+        ("final_layer.linear.weight", "proj_out.weight"),
+        ("final_layer.linear.bias", "proj_out.bias"),
+        ("final_layer.scale_shift_table", "scale_shift_table"),
+    ]
+
+    # Add actual transformer blocks
+    for depth in range(get_depth(state_dict)):
+        # Transformer blocks
+        conversion_map += [
+            (f"blocks.{depth}.scale_shift_table", f"transformer_blocks.{depth}.scale_shift_table"),
+            # Projection
+            (f"blocks.{depth}.attn.proj.weight", f"transformer_blocks.{depth}.attn1.to_out.0.weight"),
+            (f"blocks.{depth}.attn.proj.bias", f"transformer_blocks.{depth}.attn1.to_out.0.bias"),
+            # Feed-forward
+            (f"blocks.{depth}.mlp.fc1.weight", f"transformer_blocks.{depth}.ff.net.0.proj.weight"),
+            (f"blocks.{depth}.mlp.fc1.bias", f"transformer_blocks.{depth}.ff.net.0.proj.bias"),
+            (f"blocks.{depth}.mlp.fc2.weight", f"transformer_blocks.{depth}.ff.net.2.weight"),
+            (f"blocks.{depth}.mlp.fc2.bias", f"transformer_blocks.{depth}.ff.net.2.bias"),
+            # Cross-attention (proj)
+            (f"blocks.{depth}.cross_attn.proj.weight", f"transformer_blocks.{depth}.attn2.to_out.0.weight"),
+            (f"blocks.{depth}.cross_attn.proj.bias", f"transformer_blocks.{depth}.attn2.to_out.0.bias"),
+        ]
+    return conversion_map
+
+
+def find_prefix(state_dict, target_key):
+    prefix = ""
+    for k in state_dict.keys():
+        if k.endswith(target_key):
+            prefix = k.split(target_key)[0]
+            break
+    return prefix
+
+
+def convert_state_dict(state_dict):
+    if "adaln_single.emb.resolution_embedder.linear_1.weight" in state_dict.keys():
+        cmap = get_conversion_map(state_dict) + conversion_map_ms
+    else:
+        cmap = get_conversion_map(state_dict)
+
+    missing = [k for k, v in cmap if v not in state_dict]
+    new_state_dict = {k: state_dict[v] for k, v in cmap if k not in missing}
+    matched = list(v for k, v in cmap if v in state_dict.keys())
+
+    for depth in range(get_depth(state_dict)):
+        for wb in ["weight", "bias"]:
+            # Self Attention
+            key = lambda a: f"transformer_blocks.{depth}.attn1.to_{a}.{wb}"
+            new_state_dict[f"blocks.{depth}.attn.qkv.{wb}"] = torch.cat((
+                state_dict[key('q')], state_dict[key('k')], state_dict[key('v')]
+            ), dim=0)
+            matched += [key('q'), key('k'), key('v')]
+
+            # Cross-attention (linear)
+            key = lambda a: f"transformer_blocks.{depth}.attn2.to_{a}.{wb}"
+            new_state_dict[f"blocks.{depth}.cross_attn.q_linear.{wb}"] = state_dict[key('q')]
+            new_state_dict[f"blocks.{depth}.cross_attn.kv_linear.{wb}"] = torch.cat((
+                state_dict[key('k')], state_dict[key('v')]
+            ), dim=0)
+            matched += [key('q'), key('k'), key('v')]
+
+    if len(matched) < len(state_dict):
+        print(f"PixArt: UNET conversion has leftover keys! ({len(matched)} vs {len(state_dict)})")
+        print(list(set(state_dict.keys()) - set(matched)))
+
+    if len(missing) > 0:
+        print(f"PixArt: UNET conversion has missing keys!")
+        print(missing)
+
+    return new_state_dict
+
+
+# Same as above but for LoRA weights:
+def convert_lora_state_dict(state_dict, peft=True):
+    # koyha
+    rep_ak = lambda x: x.replace(".weight", ".lora_down.weight")
+    rep_bk = lambda x: x.replace(".weight", ".lora_up.weight")
+    rep_pk = lambda x: x.replace(".weight", ".alpha")
+    if peft:  # peft
+        rep_ap = lambda x: x.replace(".weight", ".lora_A.weight")
+        rep_bp = lambda x: x.replace(".weight", ".lora_B.weight")
+        rep_pp = lambda x: x.replace(".weight", ".alpha")
+
+        prefix = find_prefix(state_dict, "adaln_single.linear.lora_A.weight")
+        state_dict = {k[len(prefix):]: v for k, v in state_dict.items()}
+    else:  # OneTrainer
+        rep_ap = lambda x: x.replace(".", "_")[:-7] + ".lora_down.weight"
+        rep_bp = lambda x: x.replace(".", "_")[:-7] + ".lora_up.weight"
+        rep_pp = lambda x: x.replace(".", "_")[:-7] + ".alpha"
+
+        prefix = "lora_transformer_"
+        t5_marker = "lora_te_encoder"
+        t5_keys = []
+        for key in list(state_dict.keys()):
+            if key.startswith(prefix):
+                state_dict[key[len(prefix):]] = state_dict.pop(key)
+            elif t5_marker in key:
+                t5_keys.append(state_dict.pop(key))
+        if len(t5_keys) > 0:
+            print(f"Text Encoder not supported for PixArt LoRA, ignoring {len(t5_keys)} keys")
+
+    cmap = []
+    cmap_unet = get_conversion_map(state_dict) + conversion_map_ms  # todo: 512 model
+    for k, v in cmap_unet:
+        if v.endswith(".weight"):
+            cmap.append((rep_ak(k), rep_ap(v)))
+            cmap.append((rep_bk(k), rep_bp(v)))
+            if not peft:
+                cmap.append((rep_pk(k), rep_pp(v)))
+
+    missing = [k for k, v in cmap if v not in state_dict]
+    new_state_dict = {k: state_dict[v] for k, v in cmap if k not in missing}
+    matched = list(v for k, v in cmap if v in state_dict.keys())
+
+    lora_depth = get_lora_depth(state_dict)
+    for fp, fk in ((rep_ap, rep_ak), (rep_bp, rep_bk)):
+        for depth in range(lora_depth):
+            # Self Attention
+            key = lambda a: fp(f"transformer_blocks.{depth}.attn1.to_{a}.weight")
+            new_state_dict[fk(f"blocks.{depth}.attn.qkv.weight")] = torch.cat((
+                state_dict[key('q')], state_dict[key('k')], state_dict[key('v')]
+            ), dim=0)
+
+            matched += [key('q'), key('k'), key('v')]
+            if not peft:
+                akey = lambda a: rep_pp(f"transformer_blocks.{depth}.attn1.to_{a}.weight")
+                new_state_dict[rep_pk((f"blocks.{depth}.attn.qkv.weight"))] = state_dict[akey("q")]
+                matched += [akey('q'), akey('k'), akey('v')]
+
+            # Self Attention projection?
+            key = lambda a: fp(f"transformer_blocks.{depth}.attn1.to_{a}.weight")
+            new_state_dict[fk(f"blocks.{depth}.attn.proj.weight")] = state_dict[key('out.0')]
+            matched += [key('out.0')]
+
+            # Cross-attention (linear)
+            key = lambda a: fp(f"transformer_blocks.{depth}.attn2.to_{a}.weight")
+            new_state_dict[fk(f"blocks.{depth}.cross_attn.q_linear.weight")] = state_dict[key('q')]
+            new_state_dict[fk(f"blocks.{depth}.cross_attn.kv_linear.weight")] = torch.cat((
+                state_dict[key('k')], state_dict[key('v')]
+            ), dim=0)
+            matched += [key('q'), key('k'), key('v')]
+            if not peft:
+                akey = lambda a: rep_pp(f"transformer_blocks.{depth}.attn2.to_{a}.weight")
+                new_state_dict[rep_pk((f"blocks.{depth}.cross_attn.q_linear.weight"))] = state_dict[akey("q")]
+                new_state_dict[rep_pk((f"blocks.{depth}.cross_attn.kv_linear.weight"))] = state_dict[akey("k")]
+                matched += [akey('q'), akey('k'), akey('v')]
+
+            # Cross Attention projection?
+            key = lambda a: fp(f"transformer_blocks.{depth}.attn2.to_{a}.weight")
+            new_state_dict[fk(f"blocks.{depth}.cross_attn.proj.weight")] = state_dict[key('out.0')]
+            matched += [key('out.0')]
+
+            key = fp(f"transformer_blocks.{depth}.ff.net.0.proj.weight")
+            new_state_dict[fk(f"blocks.{depth}.mlp.fc1.weight")] = state_dict[key]
+            matched += [key]
+
+            key = fp(f"transformer_blocks.{depth}.ff.net.2.weight")
+            new_state_dict[fk(f"blocks.{depth}.mlp.fc2.weight")] = state_dict[key]
+            matched += [key]
+
+    if len(matched) < len(state_dict):
+        print(f"PixArt: LoRA conversion has leftover keys! ({len(matched)} vs {len(state_dict)})")
+        print(list(set(state_dict.keys()) - set(matched)))
+
+    if len(missing) > 0:
+        print(f"PixArt: LoRA conversion has missing keys! (probably)")
+        print(missing)
+
+    return new_state_dict
@@ -0,0 +1,328 @@
+import torch
+import math
+import comfy.supported_models_base
+import comfy.latent_formats
+import comfy.model_patcher
+import comfy.model_base
+import comfy.utils
+import comfy.conds
+from comfy import model_management
+from .diffusers_convert import convert_state_dict
+
+# checkpointbf
+class EXM_PixArt(comfy.supported_models_base.BASE):
+    unet_config = {}
+    unet_extra_config = {}
+    latent_format = comfy.latent_formats.SD15
+
+    def __init__(self, model_conf):
+        self.model_target = model_conf.get("target")
+        self.unet_config = model_conf.get("unet_config", {})
+        self.sampling_settings = model_conf.get("sampling_settings", {})
+        self.latent_format = self.latent_format()
+        # UNET is handled by extension
+        self.unet_config["disable_unet_model_creation"] = True
+
+    def model_type(self, state_dict, prefix=""):
+        return comfy.model_base.ModelType.EPS
+
+
+class EXM_PixArt_Model(comfy.model_base.BaseModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def extra_conds(self, **kwargs):
+        out = super().extra_conds(**kwargs)
+
+        img_hw = kwargs.get("img_hw", None)
+        if img_hw is not None:
+            out["img_hw"] = comfy.conds.CONDRegular(torch.tensor(img_hw))
+
+        aspect_ratio = kwargs.get("aspect_ratio", None)
+        if aspect_ratio is not None:
+            out["aspect_ratio"] = comfy.conds.CONDRegular(torch.tensor(aspect_ratio))
+
+        cn_hint = kwargs.get("cn_hint", None)
+        if cn_hint is not None:
+            out["cn_hint"] = comfy.conds.CONDRegular(cn_hint)
+
+        return out
+
+
+def load_pixart(model_path, model_conf=None):
+    state_dict = comfy.utils.load_torch_file(model_path)
+    state_dict = state_dict.get("model", state_dict)
+
+    # prefix
+    for prefix in ["model.diffusion_model.", ]:
+        if any(True for x in state_dict if x.startswith(prefix)):
+            state_dict = {k[len(prefix):]: v for k, v in state_dict.items()}
+
+    # diffusers
+    if "adaln_single.linear.weight" in state_dict:
+        state_dict = convert_state_dict(state_dict)  # Diffusers
+
+    # guess auto config
+    if model_conf is None:
+        model_conf = guess_pixart_config(state_dict)
+
+    parameters = comfy.utils.calculate_parameters(state_dict)
+    unet_dtype = model_management.unet_dtype(model_params=parameters)
+    load_device = comfy.model_management.get_torch_device()
+    offload_device = comfy.model_management.unet_offload_device()
+
+    # ignore fp8/etc and use directly for now
+    manual_cast_dtype = model_management.unet_manual_cast(unet_dtype, load_device)
+    if manual_cast_dtype:
+        print(f"PixArt: falling back to {manual_cast_dtype}")
+        unet_dtype = manual_cast_dtype
+
+    model_conf = EXM_PixArt(model_conf)  # convert to object
+    model = EXM_PixArt_Model(  # same as comfy.model_base.BaseModel
+        model_conf,
+        model_type=comfy.model_base.ModelType.EPS,
+        device=model_management.get_torch_device()
+    )
+
+    if model_conf.model_target == "PixArtMS":
+        from .models.PixArtMS import PixArtMS
+        model.diffusion_model = PixArtMS(**model_conf.unet_config)
+    elif model_conf.model_target == "PixArt":
+        from .models.PixArt import PixArt
+        model.diffusion_model = PixArt(**model_conf.unet_config)
+    elif model_conf.model_target == "PixArtMSSigma":
+        from .models.PixArtMS import PixArtMS
+        model.diffusion_model = PixArtMS(**model_conf.unet_config)
+        model.latent_format = comfy.latent_formats.SDXL()
+    elif model_conf.model_target == "ControlPixArtMSHalf":
+        from .models.PixArtMS import PixArtMS
+        from .models.pixart_controlnet import ControlPixArtMSHalf
+        model.diffusion_model = PixArtMS(**model_conf.unet_config)
+        model.diffusion_model = ControlPixArtMSHalf(model.diffusion_model)
+    elif model_conf.model_target == "ControlPixArtHalf":
+        from .models.PixArt import PixArt
+        from .models.pixart_controlnet import ControlPixArtHalf
+        model.diffusion_model = PixArt(**model_conf.unet_config)
+        model.diffusion_model = ControlPixArtHalf(model.diffusion_model)
+    else:
+        raise NotImplementedError(f"Unknown model target '{model_conf.model_target}'")
+
+    m, u = model.diffusion_model.load_state_dict(state_dict, strict=False)
+    if len(m) > 0: print("Missing UNET keys", m)
+    if len(u) > 0: print("Leftover UNET keys", u)
+    model.diffusion_model.dtype = unet_dtype
+    model.diffusion_model.eval()
+    model.diffusion_model.to(unet_dtype)
+
+    model_patcher = comfy.model_patcher.ModelPatcher(
+        model,
+        load_device=load_device,
+        offload_device=offload_device,
+    )
+    return model_patcher
+
+
+def guess_pixart_config(sd):
+    """
+    Guess config based on converted state dict.
+    """
+    # Shared settings based on DiT_XL_2 - could be enumerated
+    config = {
+        "num_heads": 16,  # get from attention
+        "patch_size": 2,  # final layer I guess?
+        "hidden_size": 1152,  # pos_embed.shape[2]
+    }
+    config["depth"] = sum([key.endswith(".attn.proj.weight") for key in sd.keys()]) or 28
+
+    try:
+        # this is not present in the diffusers version for sigma?
+        config["model_max_length"] = sd["y_embedder.y_embedding"].shape[0]
+    except KeyError:
+        # need better logic to guess this
+        config["model_max_length"] = 300
+
+    if "pos_embed" in sd:
+        config["input_size"] = int(math.sqrt(sd["pos_embed"].shape[1])) * config["patch_size"]
+        config["pe_interpolation"] = config["input_size"] // (512 // 8)  # dumb guess
+
+    target_arch = "PixArtMS"
+    if config["model_max_length"] == 300:
+        # Sigma
+        target_arch = "PixArtMSSigma"
+        config["micro_condition"] = False
+        if "input_size" not in config:
+            # The diffusers weights for 1K/2K are exactly the same...?
+            # replace patch embed logic with HyDiT?
+            print(f"PixArt: diffusers weights - 2K model will be broken, use manual loading!")
+            config["input_size"] = 1024 // 8
+    else:
+        # Alpha
+        if "csize_embedder.mlp.0.weight" in sd:
+            # MS (microconds)
+            target_arch = "PixArtMS"
+            config["micro_condition"] = True
+            if "input_size" not in config:
+                config["input_size"] = 1024 // 8
+                config["pe_interpolation"] = 2
+        else:
+            # PixArt
+            target_arch = "PixArt"
+            if "input_size" not in config:
+                config["input_size"] = 512 // 8
+                config["pe_interpolation"] = 1
+
+    print("PixArt guessed config:", target_arch, config)
+    return {
+        "target": target_arch,
+        "unet_config": config,
+        "sampling_settings": {
+            "beta_schedule": "sqrt_linear",
+            "linear_start": 0.0001,
+            "linear_end": 0.02,
+            "timesteps": 1000,
+        }
+    }
+
+# lora
+class EXM_PixArt_ModelPatcher(comfy.model_patcher.ModelPatcher):
+    def calculate_weight(self, patches, weight, key):
+        """
+        This is almost the same as the comfy function, but stripped down to just the LoRA patch code.
+        The problem with the original code is the q/k/v keys being combined into one for the attention.
+        In the diffusers code, they're treated as separate keys, but in the reference code they're recombined (q+kv|qkv).
+        This means, for example, that the [1152,1152] weights become [3456,1152] in the state dict.
+        The issue with this is that the LoRA weights are [128,1152],[1152,128] and become [384,1162],[3456,128] instead.
+
+        This is the best thing I could think of that would fix that, but it's very fragile.
+         - Check key shape to determine if it needs the fallback logic
+         - Cut the input into parts based on the shape (undoing the torch.cat)
+         - Do the matrix multiplication logic
+         - Recombine them to match the expected shape
+        """
+        for p in patches:
+            alpha = p[0]
+            v = p[1]
+            strength_model = p[2]
+            if strength_model != 1.0:
+                weight *= strength_model
+
+            if isinstance(v, list):
+                v = (self.calculate_weight(v[1:], v[0].clone(), key),)
+
+            if len(v) == 2:
+                patch_type = v[0]
+                v = v[1]
+
+            if patch_type == "lora":
+                mat1 = comfy.model_management.cast_to_device(v[0], weight.device, torch.float32)
+                mat2 = comfy.model_management.cast_to_device(v[1], weight.device, torch.float32)
+                if v[2] is not None:
+                    alpha *= v[2] / mat2.shape[0]
+                try:
+                    mat1 = mat1.flatten(start_dim=1)
+                    mat2 = mat2.flatten(start_dim=1)
+
+                    ch1 = mat1.shape[0] // mat2.shape[1]
+                    ch2 = mat2.shape[0] // mat1.shape[1]
+                    ### Fallback logic for shape mismatch ###
+                    if mat1.shape[0] != mat2.shape[1] and ch1 == ch2 and (mat1.shape[0] / mat2.shape[1]) % 1 == 0:
+                        mat1 = mat1.chunk(ch1, dim=0)
+                        mat2 = mat2.chunk(ch1, dim=0)
+                        weight += torch.cat(
+                            [alpha * torch.mm(mat1[x], mat2[x]) for x in range(ch1)],
+                            dim=0,
+                        ).reshape(weight.shape).type(weight.dtype)
+                    else:
+                        weight += (alpha * torch.mm(mat1, mat2)).reshape(weight.shape).type(weight.dtype)
+                except Exception as e:
+                    print("ERROR", key, e)
+        return weight
+
+    def clone(self):
+        n = EXM_PixArt_ModelPatcher(self.model, self.load_device, self.offload_device, self.size, self.current_device,
+                                    weight_inplace_update=self.weight_inplace_update)
+        n.patches = {}
+        for k in self.patches:
+            n.patches[k] = self.patches[k][:]
+
+        n.object_patches = self.object_patches.copy()
+        n.model_options = copy.deepcopy(self.model_options)
+        n.model_keys = self.model_keys
+        return n
+
+
+def replace_model_patcher(model):
+    n = EXM_PixArt_ModelPatcher(
+        model=model.model,
+        size=model.size,
+        load_device=model.load_device,
+        offload_device=model.offload_device,
+        current_device=model.current_device,
+        weight_inplace_update=model.weight_inplace_update,
+    )
+    n.patches = {}
+    for k in model.patches:
+        n.patches[k] = model.patches[k][:]
+
+    n.object_patches = model.object_patches.copy()
+    n.model_options = copy.deepcopy(model.model_options)
+    return n
+
+
+def find_peft_alpha(path):
+    def load_json(json_path):
+        with open(json_path) as f:
+            data = json.load(f)
+        alpha = data.get("lora_alpha")
+        alpha = alpha or data.get("alpha")
+        if not alpha:
+            print(" Found config but `lora_alpha` is missing!")
+        else:
+            print(f" Found config at {json_path} [alpha:{alpha}]")
+        return alpha
+
+    # For some weird reason peft doesn't include the alpha in the actual model
+    print("PixArt: Warning! This is a PEFT LoRA. Trying to find config...")
+    files = [
+        f"{os.path.splitext(path)[0]}.json",
+        f"{os.path.splitext(path)[0]}.config.json",
+        os.path.join(os.path.dirname(path), "adapter_config.json"),
+    ]
+    for file in files:
+        if os.path.isfile(file):
+            return load_json(file)
+
+    print(" Missing config/alpha! assuming alpha of 8. Consider converting it/adding a config json to it.")
+    return 8.0
+
+
+def load_pixart_lora(model, lora, lora_path, strength):
+    k_back = lambda x: x.replace(".lora_up.weight", "")
+    # need to convert the actual weights for this to work.
+    if any(True for x in lora.keys() if x.endswith("adaln_single.linear.lora_A.weight")):
+        lora = convert_lora_state_dict(lora, peft=True)
+        alpha = find_peft_alpha(lora_path)
+        lora.update({f"{k_back(x)}.alpha": torch.tensor(alpha) for x in lora.keys() if "lora_up" in x})
+    else:  # OneTrainer
+        lora = convert_lora_state_dict(lora, peft=False)
+
+    key_map = {k_back(x): f"diffusion_model.{k_back(x)}.weight" for x in lora.keys() if "lora_up" in x}  # fake
+
+    loaded = comfy.lora.load_lora(lora, key_map)
+    if model is not None:
+        # switch to custom model patcher when using LoRAs
+        if isinstance(model, EXM_PixArt_ModelPatcher):
+            new_modelpatcher = model.clone()
+        else:
+            new_modelpatcher = replace_model_patcher(model)
+        k = new_modelpatcher.add_patches(loaded, strength)
+    else:
+        k = ()
+        new_modelpatcher = None
+
+    k = set(k)
+    for x in loaded:
+        if (x not in k):
+            print("NOT LOADED", x)
+
+    return new_modelpatcher
@@ -0,0 +1,250 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# GLIDE: https://github.com/openai/glide-text2im
+# MAE: https://github.com/facebookresearch/mae/blob/main/models_mae.py
+# --------------------------------------------------------
+import math
+import torch
+import torch.nn as nn
+import os
+import numpy as np
+from timm.models.layers import DropPath
+from timm.models.vision_transformer import PatchEmbed, Mlp
+
+
+from .utils import auto_grad_checkpoint, to_2tuple
+from .PixArt_blocks import t2i_modulate, CaptionEmbedder, AttentionKVCompress, MultiHeadCrossAttention, T2IFinalLayer, TimestepEmbedder, LabelEmbedder, FinalLayer
+
+
+class PixArtBlock(nn.Module):
+    """
+    A PixArt block with adaptive layer norm (adaLN-single) conditioning.
+    """
+    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, drop_path=0, input_size=None, sampling=None, sr_ratio=1, qk_norm=False, **block_kwargs):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.attn = AttentionKVCompress(
+            hidden_size, num_heads=num_heads, qkv_bias=True, sampling=sampling, sr_ratio=sr_ratio,
+            qk_norm=qk_norm, **block_kwargs
+        )
+        self.cross_attn = MultiHeadCrossAttention(hidden_size, num_heads, **block_kwargs)
+        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        # to be compatible with lower version pytorch
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.mlp = Mlp(in_features=hidden_size, hidden_features=int(hidden_size * mlp_ratio), act_layer=approx_gelu, drop=0)
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.scale_shift_table = nn.Parameter(torch.randn(6, hidden_size) / hidden_size ** 0.5)
+        self.sampling = sampling
+        self.sr_ratio = sr_ratio
+
+    def forward(self, x, y, t, mask=None, **kwargs):
+        B, N, C = x.shape
+
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = (self.scale_shift_table[None] + t.reshape(B, 6, -1)).chunk(6, dim=1)
+        x = x + self.drop_path(gate_msa * self.attn(t2i_modulate(self.norm1(x), shift_msa, scale_msa)).reshape(B, N, C))
+        x = x + self.cross_attn(x, y, mask)
+        x = x + self.drop_path(gate_mlp * self.mlp(t2i_modulate(self.norm2(x), shift_mlp, scale_mlp)))
+
+        return x
+
+
+### Core PixArt Model ###
+class PixArt(nn.Module):
+    """
+    Diffusion model with a Transformer backbone.
+    """
+    def __init__(
+            self,
+            input_size=32,
+            patch_size=2,
+            in_channels=4,
+            hidden_size=1152,
+            depth=28,
+            num_heads=16,
+            mlp_ratio=4.0,
+            class_dropout_prob=0.1,
+            pred_sigma=True,
+            drop_path: float = 0.,
+            caption_channels=4096,
+            pe_interpolation=1.0,
+            pe_precision=None,
+            config=None,
+            model_max_length=120,
+            qk_norm=False,
+            kv_compress_config=None,
+            **kwargs,
+    ):
+        super().__init__()
+        self.pred_sigma = pred_sigma
+        self.in_channels = in_channels
+        self.out_channels = in_channels * 2 if pred_sigma else in_channels
+        self.patch_size = patch_size
+        self.num_heads = num_heads
+        self.pe_interpolation = pe_interpolation
+        self.pe_precision = pe_precision
+        self.depth = depth
+
+        self.x_embedder = PatchEmbed(input_size, patch_size, in_channels, hidden_size, bias=True)
+        self.t_embedder = TimestepEmbedder(hidden_size)
+        num_patches = self.x_embedder.num_patches
+        self.base_size = input_size // self.patch_size
+        # Will use fixed sin-cos embedding:
+        self.register_buffer("pos_embed", torch.zeros(1, num_patches, hidden_size))
+
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.t_block = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 6 * hidden_size, bias=True)
+        )
+        self.y_embedder = CaptionEmbedder(
+            in_channels=caption_channels, hidden_size=hidden_size, uncond_prob=class_dropout_prob,
+            act_layer=approx_gelu, token_num=model_max_length
+		)
+        drop_path = [x.item() for x in torch.linspace(0, drop_path, depth)]  # stochastic depth decay rule
+        self.kv_compress_config = kv_compress_config
+        if kv_compress_config is None:
+            self.kv_compress_config = {
+                'sampling': None,
+                'scale_factor': 1,
+                'kv_compress_layer': [],
+            }
+        self.blocks = nn.ModuleList([
+            PixArtBlock(
+                hidden_size, num_heads, mlp_ratio=mlp_ratio, drop_path=drop_path[i],
+                input_size=(input_size // patch_size, input_size // patch_size),
+                sampling=self.kv_compress_config['sampling'],
+                sr_ratio=int(
+                    self.kv_compress_config['scale_factor']
+                ) if i in self.kv_compress_config['kv_compress_layer'] else 1,
+                qk_norm=qk_norm,
+            )
+            for i in range(depth)
+        ])
+        self.final_layer = T2IFinalLayer(hidden_size, patch_size, self.out_channels)
+
+    def forward_raw(self, x, t, y, mask=None, data_info=None):
+        """
+        Original forward pass of PixArt.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N, 1, 120, C) tensor of class labels
+        """
+        x = x.to(self.dtype)
+        timestep = t.to(self.dtype)
+        y = y.to(self.dtype)
+        pos_embed = self.pos_embed.to(self.dtype)
+        self.h, self.w = x.shape[-2]//self.patch_size, x.shape[-1]//self.patch_size
+        x = self.x_embedder(x) + pos_embed  # (N, T, D), where T = H * W / patch_size ** 2
+        t = self.t_embedder(timestep.to(x.dtype))  # (N, D)
+        t0 = self.t_block(t)
+        y = self.y_embedder(y, self.training)  # (N, 1, L, D)
+        if mask is not None:
+            if mask.shape[0] != y.shape[0]:
+                mask = mask.repeat(y.shape[0] // mask.shape[0], 1)
+            mask = mask.squeeze(1).squeeze(1)
+            y = y.squeeze(1).masked_select(mask.unsqueeze(-1) != 0).view(1, -1, x.shape[-1])
+            y_lens = mask.sum(dim=1).tolist()
+        else:
+            y_lens = [y.shape[2]] * y.shape[0]
+            y = y.squeeze(1).view(1, -1, x.shape[-1])
+        for block in self.blocks:
+            x = auto_grad_checkpoint(block, x, y, t0, y_lens)  # (N, T, D) #support grad checkpoint
+        x = self.final_layer(x, t)  # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)  # (N, out_channels, H, W)
+        return x
+
+    def forward(self, x, timesteps, context, y=None, **kwargs):
+        """
+        Forward pass that adapts comfy input to original forward function
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        timesteps: (N,) tensor of diffusion timesteps
+        context: (N, 1, 120, C) conditioning
+        y: extra conditioning.
+        """
+        ## Still accepts the input w/o that dim but returns garbage
+        if len(context.shape) == 3:
+            context = context.unsqueeze(1)
+
+        ## run original forward pass
+        out = self.forward_raw(
+            x = x.to(self.dtype),
+            t = timesteps.to(self.dtype),
+            y = context.to(self.dtype),
+        )
+
+        ## only return EPS
+        out = out.to(torch.float)
+        eps, rest = out[:, :self.in_channels], out[:, self.in_channels:]
+        return eps
+
+    def unpatchify(self, x):
+        """
+        x: (N, T, patch_size**2 * C)
+        imgs: (N, H, W, C)
+        """
+        c = self.out_channels
+        p = self.x_embedder.patch_size[0]
+        h = w = int(x.shape[1] ** 0.5)
+        assert h * w == x.shape[1]
+
+        x = x.reshape(shape=(x.shape[0], h, w, p, p, c))
+        x = torch.einsum('nhwpqc->nchpwq', x)
+        imgs = x.reshape(shape=(x.shape[0], c, h * p, h * p))
+        return imgs
+
+
+def get_2d_sincos_pos_embed(embed_dim, grid_size, cls_token=False, extra_tokens=0, pe_interpolation=1.0, base_size=16):
+    """
+    grid_size: int of the grid height and width
+    return:
+    pos_embed: [grid_size*grid_size, embed_dim] or [1+grid_size*grid_size, embed_dim] (w/ or w/o cls_token)
+    """
+    if isinstance(grid_size, int):
+        grid_size = to_2tuple(grid_size)
+    grid_h = np.arange(grid_size[0], dtype=np.float32) / (grid_size[0]/base_size) / pe_interpolation
+    grid_w = np.arange(grid_size[1], dtype=np.float32) / (grid_size[1]/base_size) / pe_interpolation
+    grid = np.meshgrid(grid_w, grid_h)  # here w goes first
+    grid = np.stack(grid, axis=0)
+    grid = grid.reshape([2, 1, grid_size[1], grid_size[0]])
+
+    pos_embed = get_2d_sincos_pos_embed_from_grid(embed_dim, grid)
+    if cls_token and extra_tokens > 0:
+        pos_embed = np.concatenate([np.zeros([extra_tokens, embed_dim]), pos_embed], axis=0)
+    return pos_embed.astype(np.float32)
+
+
+def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
+    assert embed_dim % 2 == 0
+
+    # use half of dimensions to encode grid_h
+    emb_h = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[0])  # (H*W, D/2)
+    emb_w = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[1])  # (H*W, D/2)
+
+    emb = np.concatenate([emb_h, emb_w], axis=1)  # (H*W, D)
+    return emb
+
+
+def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
+    """
+    embed_dim: output dimension for each position
+    pos: a list of positions to be encoded: size (M,)
+    out: (M, D)
+    """
+    assert embed_dim % 2 == 0
+    omega = np.arange(embed_dim // 2, dtype=np.float64)
+    omega /= embed_dim / 2.
+    omega = 1. / 10000 ** omega  # (D/2,)
+
+    pos = pos.reshape(-1)  # (M,)
+    out = np.einsum('m,d->md', pos, omega)  # (M, D/2), outer product
+
+    emb_sin = np.sin(out)  # (M, D/2)
+    emb_cos = np.cos(out)  # (M, D/2)
+
+    emb = np.concatenate([emb_sin, emb_cos], axis=1)  # (M, D)
+    return emb
@@ -0,0 +1,273 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# GLIDE: https://github.com/openai/glide-text2im
+# MAE: https://github.com/facebookresearch/mae/blob/main/models_mae.py
+# --------------------------------------------------------
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from timm.models.layers import DropPath
+from timm.models.vision_transformer import Mlp
+
+from .utils import auto_grad_checkpoint, to_2tuple
+from .PixArt_blocks import t2i_modulate, CaptionEmbedder, AttentionKVCompress, MultiHeadCrossAttention, T2IFinalLayer, TimestepEmbedder, SizeEmbedder
+from .PixArt import PixArt, get_2d_sincos_pos_embed
+
+
+class PatchEmbed(nn.Module):
+    """
+    2D Image to Patch Embedding
+    """
+    def __init__(
+            self,
+            patch_size=16,
+            in_chans=3,
+            embed_dim=768,
+            norm_layer=None,
+            flatten=True,
+            bias=True,
+    ):
+        super().__init__()
+        patch_size = to_2tuple(patch_size)
+        self.patch_size = patch_size
+        self.flatten = flatten
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias)
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x):
+        x = self.proj(x)
+        if self.flatten:
+            x = x.flatten(2).transpose(1, 2)  # BCHW -> BNC
+        x = self.norm(x)
+        return x
+
+
+class PixArtMSBlock(nn.Module):
+    """
+    A PixArt block with adaptive layer norm zero (adaLN-Zero) conditioning.
+    """
+    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, drop_path=0., input_size=None,
+                 sampling=None, sr_ratio=1, qk_norm=False, **block_kwargs):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.attn = AttentionKVCompress(
+            hidden_size, num_heads=num_heads, qkv_bias=True, sampling=sampling, sr_ratio=sr_ratio,
+            qk_norm=qk_norm, **block_kwargs
+        )
+        self.cross_attn = MultiHeadCrossAttention(hidden_size, num_heads, **block_kwargs)
+        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        # to be compatible with lower version pytorch
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.mlp = Mlp(in_features=hidden_size, hidden_features=int(hidden_size * mlp_ratio), act_layer=approx_gelu, drop=0)
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.scale_shift_table = nn.Parameter(torch.randn(6, hidden_size) / hidden_size ** 0.5)
+
+    def forward(self, x, y, t, mask=None, HW=None, **kwargs):
+        B, N, C = x.shape
+
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = (self.scale_shift_table[None] + t.reshape(B, 6, -1)).chunk(6, dim=1)
+        x = x + self.drop_path(gate_msa * self.attn(t2i_modulate(self.norm1(x), shift_msa, scale_msa), HW=HW))
+        x = x + self.cross_attn(x, y, mask)
+        x = x + self.drop_path(gate_mlp * self.mlp(t2i_modulate(self.norm2(x), shift_mlp, scale_mlp)))
+
+        return x
+
+
+### Core PixArt Model ###
+class PixArtMS(PixArt):
+    """
+    Diffusion model with a Transformer backbone.
+    """
+    def __init__(
+            self,
+            input_size=32,
+            patch_size=2,
+            in_channels=4,
+            hidden_size=1152,
+            depth=28,
+            num_heads=16,
+            mlp_ratio=4.0,
+            class_dropout_prob=0.1,
+            learn_sigma=True,
+            pred_sigma=True,
+            drop_path: float = 0.,
+            caption_channels=4096,
+            pe_interpolation=None,
+            pe_precision=None,
+            config=None,
+            model_max_length=120,
+            micro_condition=True,
+            qk_norm=False,
+            kv_compress_config=None,
+            **kwargs,
+    ):
+        super().__init__(
+            input_size=input_size,
+            patch_size=patch_size,
+            in_channels=in_channels,
+            hidden_size=hidden_size,
+            depth=depth,
+            num_heads=num_heads,
+            mlp_ratio=mlp_ratio,
+            class_dropout_prob=class_dropout_prob,
+            learn_sigma=learn_sigma,
+            pred_sigma=pred_sigma,
+            drop_path=drop_path,
+            pe_interpolation=pe_interpolation,
+            config=config,
+            model_max_length=model_max_length,
+            qk_norm=qk_norm,
+            kv_compress_config=kv_compress_config,
+            **kwargs,
+        )
+        self.dtype = torch.get_default_dtype()
+        self.h = self.w = 0
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.t_block = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 6 * hidden_size, bias=True)
+        )
+        self.x_embedder = PatchEmbed(patch_size, in_channels, hidden_size, bias=True)
+        self.y_embedder = CaptionEmbedder(in_channels=caption_channels, hidden_size=hidden_size, uncond_prob=class_dropout_prob, act_layer=approx_gelu, token_num=model_max_length)
+        self.micro_conditioning = micro_condition
+        if self.micro_conditioning:
+            self.csize_embedder = SizeEmbedder(hidden_size//3)  # c_size embed
+            self.ar_embedder = SizeEmbedder(hidden_size//3)     # aspect ratio embed
+        drop_path = [x.item() for x in torch.linspace(0, drop_path, depth)]  # stochastic depth decay rule
+        if kv_compress_config is None:
+            kv_compress_config = {
+                'sampling': None,
+                'scale_factor': 1,
+                'kv_compress_layer': [],
+            }
+        self.blocks = nn.ModuleList([
+            PixArtMSBlock(
+                hidden_size, num_heads, mlp_ratio=mlp_ratio, drop_path=drop_path[i],
+                input_size=(input_size // patch_size, input_size // patch_size),
+                sampling=kv_compress_config['sampling'],
+                sr_ratio=int(kv_compress_config['scale_factor']) if i in kv_compress_config['kv_compress_layer'] else 1,
+                qk_norm=qk_norm,
+            )
+            for i in range(depth)
+        ])
+        self.final_layer = T2IFinalLayer(hidden_size, patch_size, self.out_channels)
+
+    def forward_raw(self, x, t, y, mask=None, data_info=None, **kwargs):
+        """
+        Original forward pass of PixArt.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N, 1, 120, C) tensor of class labels
+        """
+        bs = x.shape[0]
+        x = x.to(self.dtype)
+        timestep = t.to(self.dtype)
+        y = y.to(self.dtype)
+        
+        pe_interpolation = self.pe_interpolation
+        if pe_interpolation is None or self.pe_precision is not None:
+            # calculate pe_interpolation on-the-fly
+            pe_interpolation = round((x.shape[-1]+x.shape[-2])/2.0 / (512/8.0), self.pe_precision or 0)
+
+        self.h, self.w = x.shape[-2]//self.patch_size, x.shape[-1]//self.patch_size
+        pos_embed = torch.from_numpy(
+            get_2d_sincos_pos_embed(
+                self.pos_embed.shape[-1], (self.h, self.w), pe_interpolation=pe_interpolation,
+                base_size=self.base_size
+            )
+        ).unsqueeze(0).to(device=x.device, dtype=self.dtype)
+
+        x = self.x_embedder(x) + pos_embed  # (N, T, D), where T = H * W / patch_size ** 2
+        t = self.t_embedder(timestep)  # (N, D)
+
+        if self.micro_conditioning:
+            c_size, ar = data_info['img_hw'].to(self.dtype), data_info['aspect_ratio'].to(self.dtype)
+            csize = self.csize_embedder(c_size, bs)  # (N, D)
+            ar = self.ar_embedder(ar, bs)  # (N, D)
+            t = t + torch.cat([csize, ar], dim=1)
+
+        t0 = self.t_block(t)
+        y = self.y_embedder(y, self.training)  # (N, D)
+
+        if mask is not None:
+            if mask.shape[0] != y.shape[0]:
+                mask = mask.repeat(y.shape[0] // mask.shape[0], 1)
+            mask = mask.squeeze(1).squeeze(1)
+            y = y.squeeze(1).masked_select(mask.unsqueeze(-1) != 0).view(1, -1, x.shape[-1])
+            y_lens = mask.sum(dim=1).tolist()
+        else:
+            y_lens = [y.shape[2]] * y.shape[0]
+            y = y.squeeze(1).view(1, -1, x.shape[-1])
+        for block in self.blocks:
+            x = auto_grad_checkpoint(block, x, y, t0, y_lens, (self.h, self.w), **kwargs)  # (N, T, D) #support grad checkpoint
+
+        x = self.final_layer(x, t)  # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)  # (N, out_channels, H, W)
+        
+        return x
+
+    def forward(self, x, timesteps, context, img_hw=None, aspect_ratio=None, **kwargs):
+        """
+        Forward pass that adapts comfy input to original forward function
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        timesteps: (N,) tensor of diffusion timesteps
+        context: (N, 1, 120, C) conditioning
+        img_hw: height|width conditioning
+        aspect_ratio: aspect ratio conditioning
+        """
+        ## size/ar from cond with fallback based on the latent image shape.
+        bs = x.shape[0]
+        data_info = {}
+        if img_hw is None:
+            data_info["img_hw"] = torch.tensor(
+                [[x.shape[2]*8, x.shape[3]*8]],
+                dtype=self.dtype,
+                device=x.device
+            ).repeat(bs, 1)
+        else:
+            data_info["img_hw"] = img_hw.to(dtype=x.dtype, device=x.device)
+        if aspect_ratio is None or True:
+            data_info["aspect_ratio"] = torch.tensor(
+                [[x.shape[2]/x.shape[3]]],
+                dtype=self.dtype,
+                device=x.device
+            ).repeat(bs, 1)
+        else:
+            data_info["aspect_ratio"] = aspect_ratio.to(dtype=x.dtype, device=x.device)
+
+        ## Still accepts the input w/o that dim but returns garbage
+        if len(context.shape) == 3:
+            context = context.unsqueeze(1)
+
+        ## run original forward pass
+        out = self.forward_raw(
+            x = x.to(self.dtype),
+            t = timesteps.to(self.dtype),
+            y = context.to(self.dtype),
+            data_info=data_info,
+        )
+
+        ## only return EPS
+        out = out.to(torch.float)
+        eps, rest = out[:, :self.in_channels], out[:, self.in_channels:]
+        return eps
+
+    def unpatchify(self, x):
+        """
+        x: (N, T, patch_size**2 * C)
+        imgs: (N, H, W, C)
+        """
+        c = self.out_channels
+        p = self.x_embedder.patch_size[0]
+        assert self.h * self.w == x.shape[1]
+
+        x = x.reshape(shape=(x.shape[0], self.h, self.w, p, p, c))
+        x = torch.einsum('nhwpqc->nchpwq', x)
+        imgs = x.reshape(shape=(x.shape[0], c, self.h * p, self.w * p))
+        return imgs
@@ -0,0 +1,477 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# GLIDE: https://github.com/openai/glide-text2im
+# MAE: https://github.com/facebookresearch/mae/blob/main/models_mae.py
+# --------------------------------------------------------
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from timm.models.vision_transformer import Mlp, Attention as Attention_
+from einops import rearrange
+
+from comfy import model_management
+if model_management.xformers_enabled():
+    import xformers
+    import xformers.ops
+else:
+    print("""
+########################################
+ PixArt: Not using xformers!
+  Expect images to be non-deterministic!
+  Batch sizes > 1 are most likely broken
+########################################
+""")
+
+def modulate(x, shift, scale):
+    return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
+
+def t2i_modulate(x, shift, scale):
+    return x * (1 + scale) + shift
+
+class MultiHeadCrossAttention(nn.Module):
+    def __init__(self, d_model, num_heads, attn_drop=0., proj_drop=0., **block_kwargs):
+        super(MultiHeadCrossAttention, self).__init__()
+        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
+
+        self.d_model = d_model
+        self.num_heads = num_heads
+        self.head_dim = d_model // num_heads
+
+        self.q_linear = nn.Linear(d_model, d_model)
+        self.kv_linear = nn.Linear(d_model, d_model*2)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(d_model, d_model)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(self, x, cond, mask=None):
+        # query/value: img tokens; key: condition; mask: if padding tokens
+        B, N, C = x.shape
+
+        q = self.q_linear(x).view(1, -1, self.num_heads, self.head_dim)
+        kv = self.kv_linear(cond).view(1, -1, 2, self.num_heads, self.head_dim)
+        k, v = kv.unbind(2)
+
+        if model_management.xformers_enabled():
+            attn_bias = None
+            if mask is not None:
+                attn_bias = xformers.ops.fmha.BlockDiagonalMask.from_seqlens([N] * B, mask)
+            x = xformers.ops.memory_efficient_attention(
+                q, k, v,
+                p=self.attn_drop.p,
+                attn_bias=attn_bias
+            )
+        else:
+            q, k, v = map(lambda t: t.permute(0, 2, 1, 3),(q, k, v),)
+            attn_mask = None
+            if mask is not None and len(mask) > 1:
+
+                # Create equivalent of xformer diagonal block mask, still only correct for square masks
+                # But depth doesn't matter as tensors can expand in that dimension
+                attn_mask_template = torch.ones(
+                    [q.shape[2] // B, mask[0]],
+                    dtype=torch.bool,
+                    device=q.device
+                )
+                attn_mask = torch.block_diag(attn_mask_template)
+
+                # create a mask on the diagonal for each mask in the batch
+                for n in range(B - 1):
+                    attn_mask = torch.block_diag(attn_mask, attn_mask_template)
+
+            x = torch.nn.functional.scaled_dot_product_attention(
+                q, k, v,
+                attn_mask=attn_mask,
+                dropout_p=self.attn_drop.p
+            ).permute(0, 2, 1, 3).contiguous()
+        x = x.view(B, -1, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class AttentionKVCompress(Attention_):
+    """Multi-head Attention block with KV token compression and qk norm."""
+
+    def __init__(
+        self,
+        dim,
+        num_heads=8,
+        qkv_bias=True,
+        sampling='conv',
+        sr_ratio=1,
+        qk_norm=False,
+        **block_kwargs,
+    ):
+        """
+        Args:
+            dim (int): Number of input channels.
+            num_heads (int): Number of attention heads.
+            qkv_bias (bool:  If True, add a learnable bias to query, key, value.
+        """
+        super().__init__(dim, num_heads=num_heads, qkv_bias=qkv_bias, **block_kwargs)
+
+        self.sampling=sampling    # ['conv', 'ave', 'uniform', 'uniform_every']
+        self.sr_ratio = sr_ratio
+        if sr_ratio > 1 and sampling == 'conv':
+            # Avg Conv Init.
+            self.sr = nn.Conv2d(dim, dim, groups=dim, kernel_size=sr_ratio, stride=sr_ratio)
+            self.sr.weight.data.fill_(1/sr_ratio**2)
+            self.sr.bias.data.zero_()
+            self.norm = nn.LayerNorm(dim)
+        if qk_norm:
+            self.q_norm = nn.LayerNorm(dim)
+            self.k_norm = nn.LayerNorm(dim)
+        else:
+            self.q_norm = nn.Identity()
+            self.k_norm = nn.Identity()
+
+    def downsample_2d(self, tensor, H, W, scale_factor, sampling=None):
+        if sampling is None or scale_factor == 1:
+            return tensor
+        B, N, C = tensor.shape
+
+        if sampling == 'uniform_every':
+            return tensor[:, ::scale_factor], int(N // scale_factor)
+
+        tensor = tensor.reshape(B, H, W, C).permute(0, 3, 1, 2)
+        new_H, new_W = int(H / scale_factor), int(W / scale_factor)
+        new_N = new_H * new_W
+
+        if sampling == 'ave':
+            tensor = F.interpolate(
+                tensor, scale_factor=1 / scale_factor, mode='nearest'
+            ).permute(0, 2, 3, 1)
+        elif sampling == 'uniform':
+            tensor = tensor[:, :, ::scale_factor, ::scale_factor].permute(0, 2, 3, 1)
+        elif sampling == 'conv':
+            tensor = self.sr(tensor).reshape(B, C, -1).permute(0, 2, 1)
+            tensor = self.norm(tensor)
+        else:
+            raise ValueError
+
+        return tensor.reshape(B, new_N, C).contiguous(), new_N
+
+    def forward(self, x, mask=None, HW=None, block_id=None):
+        B, N, C = x.shape # 2 4096 1152
+        new_N = N
+        if HW is None:
+            H = W = int(N ** 0.5)
+        else:
+            H, W = HW
+        qkv = self.qkv(x).reshape(B, N, 3, C)
+
+        q, k, v = qkv.unbind(2)
+        dtype = q.dtype
+        q = self.q_norm(q)
+        k = self.k_norm(k)
+
+        # KV compression
+        if self.sr_ratio > 1:
+            k, new_N = self.downsample_2d(k, H, W, self.sr_ratio, sampling=self.sampling)
+            v, new_N = self.downsample_2d(v, H, W, self.sr_ratio, sampling=self.sampling)
+
+        q = q.reshape(B, N, self.num_heads, C // self.num_heads).to(dtype)
+        k = k.reshape(B, new_N, self.num_heads, C // self.num_heads).to(dtype)
+        v = v.reshape(B, new_N, self.num_heads, C // self.num_heads).to(dtype)
+
+        attn_bias = None
+        if mask is not None:
+            attn_bias = torch.zeros([B * self.num_heads, q.shape[1], k.shape[1]], dtype=q.dtype, device=q.device)
+            attn_bias.masked_fill_(mask.squeeze(1).repeat(self.num_heads, 1, 1) == 0, float('-inf'))
+        # Switch between torch / xformers attention
+        if model_management.xformers_enabled():
+            x = xformers.ops.memory_efficient_attention(
+                q, k, v,
+                p=self.attn_drop.p,
+                attn_bias=attn_bias
+            )
+        else:
+            q, k, v = map(lambda t: t.transpose(1, 2),(q, k, v),)
+            x = torch.nn.functional.scaled_dot_product_attention(
+                q, k, v,
+                dropout_p=self.attn_drop.p,
+                attn_mask=attn_bias
+            ).transpose(1, 2).contiguous()
+        x = x.view(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+#################################################################################
+#   AMP attention with fp32 softmax to fix loss NaN problem during training     #
+#################################################################################
+class Attention(Attention_):
+    def forward(self, x):
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv.unbind(0)  # make torchscript happy (cannot use tensor as tuple)
+        use_fp32_attention = getattr(self, 'fp32_attention', False)
+        if use_fp32_attention:
+            q, k = q.float(), k.float()
+        with torch.cuda.amp.autocast(enabled=not use_fp32_attention):
+            attn = (q @ k.transpose(-2, -1)) * self.scale
+            attn = attn.softmax(dim=-1)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class FinalLayer(nn.Module):
+    """
+    The final layer of PixArt.
+    """
+
+    def __init__(self, hidden_size, patch_size, out_channels):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, patch_size * patch_size * out_channels, bias=True)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 2 * hidden_size, bias=True)
+        )
+
+    def forward(self, x, c):
+        shift, scale = self.adaLN_modulation(c).chunk(2, dim=1)
+        x = modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+class T2IFinalLayer(nn.Module):
+    """
+    The final layer of PixArt.
+    """
+
+    def __init__(self, hidden_size, patch_size, out_channels):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, patch_size * patch_size * out_channels, bias=True)
+        self.scale_shift_table = nn.Parameter(torch.randn(2, hidden_size) / hidden_size ** 0.5)
+        self.out_channels = out_channels
+
+    def forward(self, x, t):
+        shift, scale = (self.scale_shift_table[None] + t[:, None]).chunk(2, dim=1)
+        x = t2i_modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+class MaskFinalLayer(nn.Module):
+    """
+    The final layer of PixArt.
+    """
+
+    def __init__(self, final_hidden_size, c_emb_size, patch_size, out_channels):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(final_hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(final_hidden_size, patch_size * patch_size * out_channels, bias=True)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(c_emb_size, 2 * final_hidden_size, bias=True)
+        )
+    def forward(self, x, t):
+        shift, scale = self.adaLN_modulation(t).chunk(2, dim=1)
+        x = modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+class DecoderLayer(nn.Module):
+    """
+    The final layer of PixArt.
+    """
+
+    def __init__(self, hidden_size, decoder_hidden_size):
+        super().__init__()
+        self.norm_decoder = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, decoder_hidden_size, bias=True)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 2 * hidden_size, bias=True)
+        )
+    def forward(self, x, t):
+        shift, scale = self.adaLN_modulation(t).chunk(2, dim=1)
+        x = modulate(self.norm_decoder(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+#################################################################################
+#               Embedding Layers for Timesteps and Class Labels                 #
+#################################################################################
+class TimestepEmbedder(nn.Module):
+    """
+    Embeds scalar timesteps into vector representations.
+    """
+
+    def __init__(self, hidden_size, frequency_embedding_size=256):
+        super().__init__()
+        self.mlp = nn.Sequential(
+            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size, bias=True),
+        )
+        self.frequency_embedding_size = frequency_embedding_size
+
+    @staticmethod
+    def timestep_embedding(t, dim, max_period=10000):
+        """
+        Create sinusoidal timestep embeddings.
+        :param t: a 1-D Tensor of N indices, one per batch element.
+                          These may be fractional.
+        :param dim: the dimension of the output.
+        :param max_period: controls the minimum frequency of the embeddings.
+        :return: an (N, D) Tensor of positional embeddings.
+        """
+        # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py
+        half = dim // 2
+        freqs = torch.exp(
+            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32, device=t.device) / half)
+        args = t[:, None].float() * freqs[None]
+        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        if dim % 2:
+            embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+        return embedding
+
+    def forward(self, t):
+        t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
+        t_emb = self.mlp(t_freq.to(t.dtype))
+        return t_emb
+
+
+class SizeEmbedder(TimestepEmbedder):
+    """
+    Embeds scalar timesteps into vector representations.
+    """
+
+    def __init__(self, hidden_size, frequency_embedding_size=256):
+        super().__init__(hidden_size=hidden_size, frequency_embedding_size=frequency_embedding_size)
+        self.mlp = nn.Sequential(
+            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size, bias=True),
+        )
+        self.frequency_embedding_size = frequency_embedding_size
+        self.outdim = hidden_size
+
+    def forward(self, s, bs):
+        if s.ndim == 1:
+            s = s[:, None]
+        assert s.ndim == 2
+        if s.shape[0] != bs:
+            s = s.repeat(bs//s.shape[0], 1)
+            assert s.shape[0] == bs
+        b, dims = s.shape[0], s.shape[1]
+        s = rearrange(s, "b d -> (b d)")
+        s_freq = self.timestep_embedding(s, self.frequency_embedding_size)
+        s_emb = self.mlp(s_freq.to(s.dtype))
+        s_emb = rearrange(s_emb, "(b d) d2 -> b (d d2)", b=b, d=dims, d2=self.outdim)
+        return s_emb
+
+
+class LabelEmbedder(nn.Module):
+    """
+    Embeds class labels into vector representations. Also handles label dropout for classifier-free guidance.
+    """
+
+    def __init__(self, num_classes, hidden_size, dropout_prob):
+        super().__init__()
+        use_cfg_embedding = dropout_prob > 0
+        self.embedding_table = nn.Embedding(num_classes + use_cfg_embedding, hidden_size)
+        self.num_classes = num_classes
+        self.dropout_prob = dropout_prob
+
+    def token_drop(self, labels, force_drop_ids=None):
+        """
+        Drops labels to enable classifier-free guidance.
+        """
+        if force_drop_ids is None:
+            drop_ids = torch.rand(labels.shape[0]).cuda() < self.dropout_prob
+        else:
+            drop_ids = force_drop_ids == 1
+        labels = torch.where(drop_ids, self.num_classes, labels)
+        return labels
+
+    def forward(self, labels, train, force_drop_ids=None):
+        use_dropout = self.dropout_prob > 0
+        if (train and use_dropout) or (force_drop_ids is not None):
+            labels = self.token_drop(labels, force_drop_ids)
+        embeddings = self.embedding_table(labels)
+        return embeddings
+
+
+class CaptionEmbedder(nn.Module):
+    """
+    Embeds class labels into vector representations. Also handles label dropout for classifier-free guidance.
+    """
+
+    def __init__(self, in_channels, hidden_size, uncond_prob, act_layer=nn.GELU(approximate='tanh'), token_num=120):
+        super().__init__()
+        self.y_proj = Mlp(in_features=in_channels, hidden_features=hidden_size, out_features=hidden_size, act_layer=act_layer, drop=0)
+        self.register_buffer("y_embedding", nn.Parameter(torch.randn(token_num, in_channels) / in_channels ** 0.5))
+        self.uncond_prob = uncond_prob
+
+    def token_drop(self, caption, force_drop_ids=None):
+        """
+        Drops labels to enable classifier-free guidance.
+        """
+        if force_drop_ids is None:
+            drop_ids = torch.rand(caption.shape[0]).cuda() < self.uncond_prob
+        else:
+            drop_ids = force_drop_ids == 1
+        caption = torch.where(drop_ids[:, None, None, None], self.y_embedding, caption)
+        return caption
+
+    def forward(self, caption, train, force_drop_ids=None):
+        if train:
+            assert caption.shape[2:] == self.y_embedding.shape
+        use_dropout = self.uncond_prob > 0
+        if (train and use_dropout) or (force_drop_ids is not None):
+            caption = self.token_drop(caption, force_drop_ids)
+        caption = self.y_proj(caption)
+        return caption
+
+
+class CaptionEmbedderDoubleBr(nn.Module):
+    """
+    Embeds class labels into vector representations. Also handles label dropout for classifier-free guidance.
+    """
+
+    def __init__(self, in_channels, hidden_size, uncond_prob, act_layer=nn.GELU(approximate='tanh'), token_num=120):
+        super().__init__()
+        self.proj = Mlp(in_features=in_channels, hidden_features=hidden_size, out_features=hidden_size, act_layer=act_layer, drop=0)
+        self.embedding = nn.Parameter(torch.randn(1, in_channels) / 10 ** 0.5)
+        self.y_embedding = nn.Parameter(torch.randn(token_num, in_channels) / 10 ** 0.5)
+        self.uncond_prob = uncond_prob
+
+    def token_drop(self, global_caption, caption, force_drop_ids=None):
+        """
+        Drops labels to enable classifier-free guidance.
+        """
+        if force_drop_ids is None:
+            drop_ids = torch.rand(global_caption.shape[0]).cuda() < self.uncond_prob
+        else:
+            drop_ids = force_drop_ids == 1
+        global_caption = torch.where(drop_ids[:, None], self.embedding, global_caption)
+        caption = torch.where(drop_ids[:, None, None, None], self.y_embedding, caption)
+        return global_caption, caption
+
+    def forward(self, caption, train, force_drop_ids=None):
+        assert caption.shape[2: ] == self.y_embedding.shape
+        global_caption = caption.mean(dim=2).squeeze()
+        use_dropout = self.uncond_prob > 0
+        if (train and use_dropout) or (force_drop_ids is not None):
+            global_caption, caption = self.token_drop(global_caption, caption, force_drop_ids)
+        y_embed = self.proj(global_caption)
+        return y_embed, caption
@@ -0,0 +1,312 @@
+import re
+import torch
+import torch.nn as nn
+
+from copy import deepcopy
+from torch import Tensor
+from torch.nn import Module, Linear, init
+from typing import Any, Mapping
+
+from .PixArt import PixArt, get_2d_sincos_pos_embed
+from .PixArtMS import PixArtMSBlock, PixArtMS
+from .utils import auto_grad_checkpoint
+
+# The implementation of ControlNet-Half architrecture
+# https://github.com/lllyasviel/ControlNet/discussions/188
+class ControlT2IDitBlockHalf(Module):
+    def __init__(self, base_block: PixArtMSBlock, block_index: 0) -> None:
+        super().__init__()
+        self.copied_block = deepcopy(base_block)
+        self.block_index = block_index
+
+        for p in self.copied_block.parameters():
+            p.requires_grad_(True)
+
+        self.copied_block.load_state_dict(base_block.state_dict())
+        self.copied_block.train()
+        
+        self.hidden_size = hidden_size = base_block.hidden_size
+        if self.block_index == 0:
+            self.before_proj = Linear(hidden_size, hidden_size)
+            init.zeros_(self.before_proj.weight)
+            init.zeros_(self.before_proj.bias)
+        self.after_proj = Linear(hidden_size, hidden_size) 
+        init.zeros_(self.after_proj.weight)
+        init.zeros_(self.after_proj.bias)
+
+    def forward(self, x, y, t, mask=None, c=None):
+        
+        if self.block_index == 0:
+            # the first block
+            c = self.before_proj(c)
+            c = self.copied_block(x + c, y, t, mask)
+            c_skip = self.after_proj(c)
+        else:
+            # load from previous c and produce the c for skip connection
+            c = self.copied_block(c, y, t, mask)
+            c_skip = self.after_proj(c)
+        
+        return c, c_skip
+        
+
+# The implementation of ControlPixArtHalf net
+class ControlPixArtHalf(Module):
+    # only support single res model
+    def __init__(self, base_model: PixArt, copy_blocks_num: int = 13) -> None:
+        super().__init__()
+        self.dtype = torch.get_default_dtype()
+        self.base_model = base_model.eval()
+        self.controlnet = []
+        self.copy_blocks_num = copy_blocks_num
+        self.total_blocks_num = len(base_model.blocks)
+        for p in self.base_model.parameters():
+            p.requires_grad_(False)
+
+        # Copy first copy_blocks_num block
+        for i in range(copy_blocks_num):
+            self.controlnet.append(ControlT2IDitBlockHalf(base_model.blocks[i], i))
+        self.controlnet = nn.ModuleList(self.controlnet)
+    
+    def __getattr__(self, name: str) -> Tensor or Module:
+        if name in ['forward', 'forward_with_dpmsolver', 'forward_with_cfg', 'forward_c', 'load_state_dict']:
+            return self.__dict__[name]
+        elif name in ['base_model', 'controlnet']:
+            return super().__getattr__(name)
+        else:
+            return getattr(self.base_model, name)
+
+    def forward_c(self, c):
+        self.h, self.w = c.shape[-2]//self.patch_size, c.shape[-1]//self.patch_size
+        pos_embed = torch.from_numpy(get_2d_sincos_pos_embed(self.pos_embed.shape[-1], (self.h, self.w), lewei_scale=self.lewei_scale, base_size=self.base_size)).unsqueeze(0).to(c.device).to(self.dtype)
+        return self.x_embedder(c) + pos_embed if c is not None else c
+
+    # def forward(self, x, t, c, **kwargs):
+    #     return self.base_model(x, t, c=self.forward_c(c), **kwargs)
+    def forward_raw(self, x, timestep, y, mask=None, data_info=None, c=None, **kwargs):
+        # modify the original PixArtMS forward function
+        if c is not None:
+            c = c.to(self.dtype)
+            c = self.forward_c(c)
+        """
+        Forward pass of PixArt.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N, 1, 120, C) tensor of class labels
+        """
+        x = x.to(self.dtype)
+        timestep = timestep.to(self.dtype)
+        y = y.to(self.dtype)
+        pos_embed = self.pos_embed.to(self.dtype)
+        self.h, self.w = x.shape[-2]//self.patch_size, x.shape[-1]//self.patch_size
+        x = self.x_embedder(x) + pos_embed  # (N, T, D), where T = H * W / patch_size ** 2
+        t = self.t_embedder(timestep.to(x.dtype))  # (N, D)
+        t0 = self.t_block(t)
+        y = self.y_embedder(y, self.training)  # (N, 1, L, D)
+        if mask is not None:
+            if mask.shape[0] != y.shape[0]:
+                mask = mask.repeat(y.shape[0] // mask.shape[0], 1)
+            mask = mask.squeeze(1).squeeze(1)
+            y = y.squeeze(1).masked_select(mask.unsqueeze(-1) != 0).view(1, -1, x.shape[-1])
+            y_lens = mask.sum(dim=1).tolist()
+        else:
+            y_lens = [y.shape[2]] * y.shape[0]
+            y = y.squeeze(1).view(1, -1, x.shape[-1])
+
+        # define the first layer
+        x = auto_grad_checkpoint(self.base_model.blocks[0], x, y, t0, y_lens, **kwargs)  # (N, T, D) #support grad checkpoint
+
+        if c is not None:
+            # update c
+            for index in range(1, self.copy_blocks_num + 1):
+                c, c_skip = auto_grad_checkpoint(self.controlnet[index - 1], x, y, t0, y_lens, c, **kwargs)
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x + c_skip, y, t0, y_lens, **kwargs)
+        
+            # update x
+            for index in range(self.copy_blocks_num + 1, self.total_blocks_num):
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x, y, t0, y_lens, **kwargs)
+        else:
+            for index in range(1, self.total_blocks_num):
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x, y, t0, y_lens, **kwargs)
+
+        x = self.final_layer(x, t)  # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)  # (N, out_channels, H, W)
+        return x
+
+    def forward(self, x, timesteps, context, cn_hint=None, **kwargs):
+        """
+        Forward pass that adapts comfy input to original forward function
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        timesteps: (N,) tensor of diffusion timesteps
+        context: (N, 1, 120, C) conditioning
+        cn_hint: controlnet hint
+        """
+        ## Still accepts the input w/o that dim but returns garbage
+        if len(context.shape) == 3:
+            context = context.unsqueeze(1)
+
+        ## run original forward pass
+        out = self.forward_raw(
+            x = x.to(self.dtype),
+            timestep = timesteps.to(self.dtype),
+            y = context.to(self.dtype),
+            c = cn_hint,
+        )
+
+        ## only return EPS
+        out = out.to(torch.float)
+        eps, rest = out[:, :self.in_channels], out[:, self.in_channels:]
+        return eps
+
+    def forward_with_dpmsolver(self, x, t, y, data_info, c, **kwargs):
+        model_out = self.forward_raw(x, t, y, data_info=data_info, c=c, **kwargs)
+        return model_out.chunk(2, dim=1)[0]
+
+    # def forward_with_dpmsolver(self, x, t, y, data_info, c, **kwargs):
+    #     return self.base_model.forward_with_dpmsolver(x, t, y, data_info=data_info, c=self.forward_c(c), **kwargs)
+
+    def forward_with_cfg(self, x, t, y, cfg_scale, data_info, c, **kwargs):
+        return self.base_model.forward_with_cfg(x, t, y, cfg_scale, data_info, c=self.forward_c(c), **kwargs)
+
+    def load_state_dict(self, state_dict: Mapping[str, Any], strict: bool = True):
+        if all((k.startswith('base_model') or k.startswith('controlnet')) for k in state_dict.keys()):
+            return super().load_state_dict(state_dict, strict)
+        else:
+            new_key = {}
+            for k in state_dict.keys():
+                new_key[k] = re.sub(r"(blocks\.\d+)(.*)", r"\1.base_block\2", k)
+            for k, v in new_key.items():
+                if k != v:
+                    print(f"replace {k} to {v}")
+                    state_dict[v] = state_dict.pop(k)
+
+            return self.base_model.load_state_dict(state_dict, strict)
+    
+    def unpatchify(self, x):
+        """
+        x: (N, T, patch_size**2 * C)
+        imgs: (N, H, W, C)
+        """
+        c = self.out_channels
+        p = self.x_embedder.patch_size[0]
+        assert self.h * self.w == x.shape[1]
+
+        x = x.reshape(shape=(x.shape[0], self.h, self.w, p, p, c))
+        x = torch.einsum('nhwpqc->nchpwq', x)
+        imgs = x.reshape(shape=(x.shape[0], c, self.h * p, self.w * p))
+        return imgs
+
+    # @property
+    # def dtype(self):
+        ## 返回模型参数的数据类型
+        # return next(self.parameters()).dtype
+
+
+# The implementation for PixArtMS_Half + 1024 resolution
+class ControlPixArtMSHalf(ControlPixArtHalf):
+    # support multi-scale res model (multi-scale model can also be applied to single reso training & inference)
+    def __init__(self, base_model: PixArtMS, copy_blocks_num: int = 13) -> None:
+        super().__init__(base_model=base_model, copy_blocks_num=copy_blocks_num)
+
+    def forward_raw(self, x, timestep, y, mask=None, data_info=None, c=None, **kwargs):
+        # modify the original PixArtMS forward function
+        """
+        Forward pass of PixArt.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N, 1, 120, C) tensor of class labels
+        """
+        if c is not None:
+            c = c.to(self.dtype)
+            c = self.forward_c(c)
+        bs = x.shape[0]
+        x = x.to(self.dtype)
+        timestep = timestep.to(self.dtype)
+        y = y.to(self.dtype)
+        c_size, ar = data_info['img_hw'].to(self.dtype), data_info['aspect_ratio'].to(self.dtype)
+        self.h, self.w = x.shape[-2]//self.patch_size, x.shape[-1]//self.patch_size
+
+        pos_embed = torch.from_numpy(get_2d_sincos_pos_embed(self.pos_embed.shape[-1], (self.h, self.w), lewei_scale=self.lewei_scale, base_size=self.base_size)).unsqueeze(0).to(x.device).to(self.dtype)
+        x = self.x_embedder(x) + pos_embed  # (N, T, D), where T = H * W / patch_size ** 2
+        t = self.t_embedder(timestep)  # (N, D)
+        csize = self.csize_embedder(c_size, bs)  # (N, D)
+        ar = self.ar_embedder(ar, bs)  # (N, D)
+        t = t + torch.cat([csize, ar], dim=1)
+        t0 = self.t_block(t)
+        y = self.y_embedder(y, self.training)  # (N, D)
+        if mask is not None:
+            if mask.shape[0] != y.shape[0]:
+                mask = mask.repeat(y.shape[0] // mask.shape[0], 1)
+            mask = mask.squeeze(1).squeeze(1)
+            y = y.squeeze(1).masked_select(mask.unsqueeze(-1) != 0).view(1, -1, x.shape[-1])
+            y_lens = mask.sum(dim=1).tolist()
+        else:
+            y_lens = [y.shape[2]] * y.shape[0]
+            y = y.squeeze(1).view(1, -1, x.shape[-1])
+
+        # define the first layer
+        x = auto_grad_checkpoint(self.base_model.blocks[0], x, y, t0, y_lens, **kwargs)  # (N, T, D) #support grad checkpoint
+
+        if c is not None:
+            # update c
+            for index in range(1, self.copy_blocks_num + 1):
+                c, c_skip = auto_grad_checkpoint(self.controlnet[index - 1], x, y, t0, y_lens, c, **kwargs)
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x + c_skip, y, t0, y_lens, **kwargs)
+        
+            # update x
+            for index in range(self.copy_blocks_num + 1, self.total_blocks_num):
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x, y, t0, y_lens, **kwargs)
+        else:
+            for index in range(1, self.total_blocks_num):
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x, y, t0, y_lens, **kwargs)
+
+        x = self.final_layer(x, t)  # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)  # (N, out_channels, H, W)
+        return x
+
+    def forward(self, x, timesteps, context, img_hw=None, aspect_ratio=None, cn_hint=None, **kwargs):
+        """
+        Forward pass that adapts comfy input to original forward function
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        timesteps: (N,) tensor of diffusion timesteps
+        context: (N, 1, 120, C) conditioning
+        img_hw: height|width conditioning
+        aspect_ratio: aspect ratio conditioning
+        cn_hint: controlnet hint
+        """
+        ## size/ar from cond with fallback based on the latent image shape.
+        bs = x.shape[0]
+        data_info = {}
+        if img_hw is None:
+            data_info["img_hw"] = torch.tensor(
+                [[x.shape[2]*8, x.shape[3]*8]],
+                dtype=self.dtype,
+                device=x.device
+            ).repeat(bs, 1)
+        else:
+            data_info["img_hw"] = img_hw.to(x.dtype)
+        if aspect_ratio is None or True:
+            data_info["aspect_ratio"] = torch.tensor(
+                [[x.shape[2]/x.shape[3]]],
+                dtype=self.dtype,
+                device=x.device
+            ).repeat(bs, 1)
+        else:
+            data_info["aspect_ratio"] = aspect_ratio.to(x.dtype)
+
+        ## Still accepts the input w/o that dim but returns garbage
+        if len(context.shape) == 3:
+            context = context.unsqueeze(1)
+
+        ## run original forward pass
+        out = self.forward_raw(
+            x = x.to(self.dtype),
+            timestep = timesteps.to(self.dtype),
+            y = context.to(self.dtype),
+            c = cn_hint,
+            data_info=data_info,
+        )
+
+        ## only return EPS
+        out = out.to(torch.float)
+        eps, rest = out[:, :self.in_channels], out[:, self.in_channels:]
+        return eps
@@ -0,0 +1,122 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint, checkpoint_sequential
+from collections.abc import Iterable
+from itertools import repeat
+
+def _ntuple(n):
+    def parse(x):
+        if isinstance(x, Iterable) and not isinstance(x, str):
+            return x
+        return tuple(repeat(x, n))
+    return parse
+
+to_1tuple = _ntuple(1)
+to_2tuple = _ntuple(2)
+
+def set_grad_checkpoint(model, use_fp32_attention=False, gc_step=1):
+    assert isinstance(model, nn.Module)
+
+    def set_attr(module):
+        module.grad_checkpointing = True
+        module.fp32_attention = use_fp32_attention
+        module.grad_checkpointing_step = gc_step
+    model.apply(set_attr)
+
+def auto_grad_checkpoint(module, *args, **kwargs):
+    if getattr(module, 'grad_checkpointing', False):
+        if isinstance(module, Iterable):
+            gc_step = module[0].grad_checkpointing_step
+            return checkpoint_sequential(module, gc_step, *args, **kwargs)
+        else:
+            return checkpoint(module, *args, **kwargs)
+    return module(*args, **kwargs)
+
+def checkpoint_sequential(functions, step, input, *args, **kwargs):
+
+    # Hack for keyword-only parameter in a python 2.7-compliant way
+    preserve = kwargs.pop('preserve_rng_state', True)
+    if kwargs:
+        raise ValueError("Unexpected keyword arguments: " + ",".join(arg for arg in kwargs))
+
+    def run_function(start, end, functions):
+        def forward(input):
+            for j in range(start, end + 1):
+                input = functions[j](input, *args)
+            return input
+        return forward
+
+    if isinstance(functions, torch.nn.Sequential):
+        functions = list(functions.children())
+
+    # the last chunk has to be non-volatile
+    end = -1
+    segment = len(functions) // step
+    for start in range(0, step * (segment - 1), step):
+        end = start + step - 1
+        input = checkpoint(run_function(start, end, functions), input, preserve_rng_state=preserve)
+    return run_function(end + 1, len(functions) - 1, functions)(input)
+
+def get_rel_pos(q_size, k_size, rel_pos):
+    """
+    Get relative positional embeddings according to the relative positions of
+        query and key sizes.
+    Args:
+        q_size (int): size of query q.
+        k_size (int): size of key k.
+        rel_pos (Tensor): relative position embeddings (L, C).
+
+    Returns:
+        Extracted positional embeddings according to relative positions.
+    """
+    max_rel_dist = int(2 * max(q_size, k_size) - 1)
+    # Interpolate rel pos if needed.
+    if rel_pos.shape[0] != max_rel_dist:
+        # Interpolate rel pos.
+        rel_pos_resized = F.interpolate(
+            rel_pos.reshape(1, rel_pos.shape[0], -1).permute(0, 2, 1),
+            size=max_rel_dist,
+            mode="linear",
+        )
+        rel_pos_resized = rel_pos_resized.reshape(-1, max_rel_dist).permute(1, 0)
+    else:
+        rel_pos_resized = rel_pos
+
+    # Scale the coords with short length if shapes for q and k are different.
+    q_coords = torch.arange(q_size)[:, None] * max(k_size / q_size, 1.0)
+    k_coords = torch.arange(k_size)[None, :] * max(q_size / k_size, 1.0)
+    relative_coords = (q_coords - k_coords) + (k_size - 1) * max(q_size / k_size, 1.0)
+
+    return rel_pos_resized[relative_coords.long()]
+
+def add_decomposed_rel_pos(attn, q, rel_pos_h, rel_pos_w, q_size, k_size):
+    """
+    Calculate decomposed Relative Positional Embeddings from :paper:`mvitv2`.
+    https://github.com/facebookresearch/mvit/blob/19786631e330df9f3622e5402b4a419a263a2c80/mvit/models/attention.py   # noqa B950
+    Args:
+        attn (Tensor): attention map.
+        q (Tensor): query q in the attention layer with shape (B, q_h * q_w, C).
+        rel_pos_h (Tensor): relative position embeddings (Lh, C) for height axis.
+        rel_pos_w (Tensor): relative position embeddings (Lw, C) for width axis.
+        q_size (Tuple): spatial sequence size of query q with (q_h, q_w).
+        k_size (Tuple): spatial sequence size of key k with (k_h, k_w).
+
+    Returns:
+        attn (Tensor): attention map with added relative positional embeddings.
+    """
+    q_h, q_w = q_size
+    k_h, k_w = k_size
+    Rh = get_rel_pos(q_h, k_h, rel_pos_h)
+    Rw = get_rel_pos(q_w, k_w, rel_pos_w)
+
+    B, _, dim = q.shape
+    r_q = q.reshape(B, q_h, q_w, dim)
+    rel_h = torch.einsum("bhwc,hkc->bhwk", r_q, Rh)
+    rel_w = torch.einsum("bhwc,wkc->bhwk", r_q, Rw)
+
+    attn = (
+        attn.view(B, q_h, q_w, k_h, k_w) + rel_h[:, :, :, :, None] + rel_w[:, :, :, None, :]
+    ).view(B, q_h * q_w, k_h * k_w)
+
+    return attn
@@ -0,0 +1,38 @@
+import torch
+from comfy import model_management
+
+def string_to_dtype(s="none", mode=None):
+	s = s.lower().strip()
+	if s in ["default", "as-is"]:
+		return None
+	elif s in ["auto", "auto (comfy)"]:
+		if mode == "vae":
+			return model_management.vae_device()
+		elif mode == "text_encoder":
+			return model_management.text_encoder_dtype()
+		elif mode == "unet":
+			return model_management.unet_dtype()
+		else:
+			raise NotImplementedError(f"Unknown dtype mode '{mode}'")
+	elif s in ["none", "auto (hf)", "auto (hf/bnb)"]:
+		return None
+	elif s in ["fp32", "float32", "float"]:
+		return torch.float32
+	elif s in ["bf16", "bfloat16"]:
+		return torch.bfloat16
+	elif s in ["fp16", "float16", "half"]:
+		return torch.float16
+	elif "fp8" in s or "float8" in s:
+		if "e5m2" in s:
+			return torch.float8_e5m2
+		elif "e4m3" in s:
+			return torch.float8_e4m3fn
+		else:
+			raise NotImplementedError(f"Unknown 8bit dtype '{s}'")
+	elif "bnb" in s:
+		assert s in ["bnb8bit", "bnb4bit"], f"Unknown bnb mode '{s}'"
+		return s
+	elif s is None:
+		return None
+	else:
+		raise NotImplementedError(f"Unknown dtype '{s}'")
@@ -1,3 +1,5 @@
+#credit to ExponentialML for this module
+#from https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter
 import os
 import torch
 import comfy
@@ -7,7 +7,10 @@ from comfy import model_base
 from comfy import utils
 from comfy import diffusers_convert

-from comfy import sd2_clip
+try:
+    import comfy.text_encoders.sd2_clip
+except ImportError:
+    from comfy import sd2_clip

 from comfy import supported_models_base
 from comfy import latent_formats
@@ -1,102 +0,0 @@
-import torch
-import comfy
-from comfy.model_patcher import ModelPatcher
-from comfy.model_management import cast_to_device
-
-from .log import log_node_warn, log_node_error, log_node_info
-
-# Inpaint
-class InpaintHead(torch.nn.Module):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.head = torch.nn.Parameter(torch.empty(size=(320, 5, 3, 3), device='cpu'))
-
-    def __call__(self, x):
-        x = torch.nn.functional.pad(x, (1, 1, 1, 1), "replicate")
-        return torch.nn.functional.conv2d(input=x, weight=self.head)
-
-class InpaintWorker:
-    def __init__(self, node_name):
-        self.node_name = node_name if node_name is not None else ""
-        self.original_calculate_weight = ModelPatcher.calculate_weight
-        self.injected_model_patcher_calculate_weight = False
-
-    def load_fooocus_patch(self, lora: dict, to_load: dict):
-        patch_dict = {}
-        loaded_keys = set()
-        for key in to_load.values():
-            if value := lora.get(key, None):
-                patch_dict[key] = ("fooocus", value)
-                loaded_keys.add(key)
-
-        not_loaded = sum(1 for x in lora if x not in loaded_keys)
-        log_node_info(self.node_name,
-            f"{len(loaded_keys)} Lora keys loaded, {not_loaded} remaining keys not found in model."
-        )
-        return patch_dict
-
-    def calculate_weight_patched(self: ModelPatcher, patches, weight, key):
-        remaining = []
-
-        for p in patches:
-            alpha, v, strength_model = p
-
-            is_fooocus_patch = isinstance(v, tuple) and len(v) == 2 and v[0] == "fooocus"
-            if not is_fooocus_patch:
-                remaining.append(p)
-                continue
-
-            if alpha != 0.0:
-                v = v[1]
-                w1 = cast_to_device(v[0], weight.device, torch.float32)
-                if w1.shape == weight.shape:
-                    w_min = cast_to_device(v[1], weight.device, torch.float32)
-                    w_max = cast_to_device(v[2], weight.device, torch.float32)
-                    w1 = (w1 / 255.0) * (w_max - w_min) + w_min
-                    weight += alpha * cast_to_device(w1, weight.device, weight.dtype)
-                else:
-                    pass
-                    # log_node_warn(self.node_name,
-                    #     f"Shape mismatch {key}, weight not merged ({w1.shape} != {weight.shape})"
-                    # )
-
-        if len(remaining) > 0:
-            return self.original_calculate_weight(self, remaining, weight, key)
-        return weight
-
-    def inject_patched_calculate_weight(self):
-        if not self.injected_model_patcher_calculate_weight:
-            log_node_info(self.node_name,"Injecting patched comfy.model_patcher.ModelPatcher.calculate_weight")
-            ModelPatcher.calculate_weight = self.calculate_weight_patched
-            self.injected_model_patcher_calculate_weight = True
-
-    def patch(self, model, latent, patch):
-        base_model = model.model
-        latent_pixels = base_model.process_latent_in(latent["samples"])
-        noise_mask = latent["noise_mask"].round()
-        latent_mask = torch.nn.functional.max_pool2d(noise_mask, (8, 8)).round().to(latent_pixels)
-
-        inpaint_head_model, inpaint_lora = patch
-        feed = torch.cat([latent_mask, latent_pixels], dim=1)
-        inpaint_head_model.to(device=feed.device, dtype=feed.dtype)
-        inpaint_head_feature = inpaint_head_model(feed)
-
-        def input_block_patch(h, transformer_options):
-            if transformer_options["block"][1] == 0:
-                h = h + inpaint_head_feature.to(h)
-            return h
-
-        lora_keys = comfy.lora.model_lora_keys_unet(model.model, {})
-        lora_keys.update({x: x for x in base_model.state_dict().keys()})
-        loaded_lora = self.load_fooocus_patch(inpaint_lora, lora_keys)
-
-        m = model.clone()
-        m.set_model_input_block_patch(input_block_patch)
-        patched = m.add_patches(loaded_lora, 1.0)
-
-        not_patched_count = sum(1 for x in loaded_lora if x not in patched)
-        if not_patched_count > 0:
-            log_node_error(self.node_name, f"Failed to patch {not_patched_count} keys")
-
-        self.inject_patched_calculate_weight()
-        return (m,)
@@ -0,0 +1,117 @@
+#credit to Acly for this module
+#from https://github.com/Acly/comfyui-inpaint-nodes
+import torch
+import torch.nn.functional as F
+import comfy
+from comfy.model_base import BaseModel
+from comfy.model_patcher import ModelPatcher
+from comfy.model_management import cast_to_device
+
+from ..libs.log import log_node_warn, log_node_error, log_node_info
+
+class InpaintHead(torch.nn.Module):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.head = torch.nn.Parameter(torch.empty(size=(320, 5, 3, 3), device="cpu"))
+
+    def __call__(self, x):
+        x = F.pad(x, (1, 1, 1, 1), "replicate")
+        return F.conv2d(x, weight=self.head)
+
+
+class applyFooocusPatch:
+    def calculate_weight_patched(self, patches, weight, key, intermediate_type=torch.float32):
+        remaining = []
+
+        for p in patches:
+            alpha = p[0]
+            v = p[1]
+
+            is_fooocus_patch = isinstance(v, tuple) and len(v) == 2 and v[0] == "fooocus"
+            if not is_fooocus_patch:
+                remaining.append(p)
+                continue
+
+            if alpha != 0.0:
+                v = v[1]
+                w1 = cast_to_device(v[0], weight.device, torch.float32)
+                if w1.shape == weight.shape:
+                    w_min = cast_to_device(v[1], weight.device, torch.float32)
+                    w_max = cast_to_device(v[2], weight.device, torch.float32)
+                    w1 = (w1 / 255.0) * (w_max - w_min) + w_min
+                    weight += alpha * cast_to_device(w1, weight.device, weight.dtype)
+                else:
+                    pass
+                    # log_node_warn(self.node_name,
+                    #     f"Shape mismatch {key}, weight not merged ({w1.shape} != {weight.shape})"
+                    # )
+
+            if len(remaining) > 0:
+                return self.original_calculate_weight(remaining, weight, key, intermediate_type)
+        return weight
+
+    def __enter__(self):
+        try:
+            print("[comfyui-easy-use] Injecting patched comfy.lora.calculate_weight.calculate_weight")
+            self.original_calculate_weight = comfy.lora.calculate_weight
+            comfy.lora.calculate_weight = self.calculate_weight_patched
+        except AttributeError:
+            print("[comfyui-easy-use] Injecting patched comfy.model_patcher.ModelPatcher.calculate_weight")
+            self.original_calculate_weight = ModelPatcher.calculate_weight
+            ModelPatcher.calculate_weight = self.calculate_weight_patched
+    def __exit__(self, type, value, traceback):
+        try:
+            comfy.lora.calculate_weight = self.original_calculate_weight
+        except AttributeError:
+            ModelPatcher.calculate_weight = self.original_calculate_weight
+
+
+class InpaintWorker:
+    def __init__(self, node_name):
+        self.node_name = node_name if node_name is not None else ""
+
+    def load_fooocus_patch(self, lora: dict, to_load: dict):
+        patch_dict = {}
+        loaded_keys = set()
+        for key in to_load.values():
+            if value := lora.get(key, None):
+                patch_dict[key] = ("fooocus", value)
+                loaded_keys.add(key)
+
+        not_loaded = sum(1 for x in lora if x not in loaded_keys)
+        if not_loaded > 0:
+            log_node_info(self.node_name,
+                f"{len(loaded_keys)} Lora keys loaded, {not_loaded} remaining keys not found in model."
+            )
+        return patch_dict
+
+
+    def patch(self, model, latent, patch):
+        with applyFooocusPatch():
+            base_model: BaseModel = model.model
+            latent_pixels = base_model.process_latent_in(latent["samples"])
+            noise_mask = latent["noise_mask"].round()
+            latent_mask = F.max_pool2d(noise_mask, (8, 8)).round().to(latent_pixels)
+
+            inpaint_head_model, inpaint_lora = patch
+            feed = torch.cat([latent_mask, latent_pixels], dim=1)
+            inpaint_head_model.to(device=feed.device, dtype=feed.dtype)
+            inpaint_head_feature = inpaint_head_model(feed)
+
+            def input_block_patch(h, transformer_options):
+                if transformer_options["block"][1] == 0:
+                    h = h + inpaint_head_feature.to(h)
+                return h
+
+            lora_keys = comfy.lora.model_lora_keys_unet(model.model, {})
+            lora_keys.update({x: x for x in base_model.state_dict().keys()})
+            loaded_lora = self.load_fooocus_patch(inpaint_lora, lora_keys)
+
+            m = model.clone()
+            m.set_model_input_block_patch(input_block_patch)
+            patched = m.add_patches(loaded_lora, 1.0)
+
+            not_patched_count = sum(1 for x in loaded_lora if x not in patched)
+            if not_patched_count > 0:
+                log_node_error(self.node_name, f"Failed to patch {not_patched_count} keys")
+            return (m,)
@@ -0,0 +1,156 @@
+import torch
+import numpy as np
+import cv2
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader
+from .simple_extractor_dataset import SimpleFolderDataset
+from .transforms import transform_logits
+from tqdm import tqdm
+from PIL import Image
+
+def get_palette(num_cls):
+    """ Returns the color map for visualizing the segmentation mask.
+    Args:
+        num_cls: Number of classes
+    Returns:
+        The color map
+    """
+    n = num_cls
+    palette = [0] * (n * 3)
+    for j in range(0, n):
+        lab = j
+        palette[j * 3 + 0] = 0
+        palette[j * 3 + 1] = 0
+        palette[j * 3 + 2] = 0
+        i = 0
+        while lab:
+            palette[j * 3 + 0] |= (((lab >> 0) & 1) << (7 - i))
+            palette[j * 3 + 1] |= (((lab >> 1) & 1) << (7 - i))
+            palette[j * 3 + 2] |= (((lab >> 2) & 1) << (7 - i))
+            i += 1
+            lab >>= 3
+    return palette
+
+
+def delete_irregular(logits_result):
+    parsing_result = np.argmax(logits_result, axis=2)
+    upper_cloth = np.where(parsing_result == 4, 255, 0)
+    contours, hierarchy = cv2.findContours(upper_cloth.astype(np.uint8),
+                                           cv2.RETR_CCOMP, cv2.CHAIN_APPROX_TC89_L1)
+    area = []
+    for i in range(len(contours)):
+        a = cv2.contourArea(contours[i], True)
+        area.append(abs(a))
+    if len(area) != 0:
+        top = area.index(max(area))
+        M = cv2.moments(contours[top])
+        cY = int(M["m01"] / M["m00"])
+
+    dresses = np.where(parsing_result == 7, 255, 0)
+    contours_dress, hierarchy_dress = cv2.findContours(dresses.astype(np.uint8),
+                                                       cv2.RETR_CCOMP, cv2.CHAIN_APPROX_TC89_L1)
+    area_dress = []
+    for j in range(len(contours_dress)):
+        a_d = cv2.contourArea(contours_dress[j], True)
+        area_dress.append(abs(a_d))
+    if len(area_dress) != 0:
+        top_dress = area_dress.index(max(area_dress))
+        M_dress = cv2.moments(contours_dress[top_dress])
+        cY_dress = int(M_dress["m01"] / M_dress["m00"])
+    wear_type = "dresses"
+    if len(area) != 0:
+        if len(area_dress) != 0 and cY_dress > cY:
+            irregular_list = np.array([4, 5, 6])
+            logits_result[:, :, irregular_list] = -1
+        else:
+            irregular_list = np.array([5, 6, 7, 8, 9, 10, 12, 13])
+            logits_result[:cY, :, irregular_list] = -1
+            wear_type = "cloth_pant"
+        parsing_result = np.argmax(logits_result, axis=2)
+    # pad border
+    parsing_result = np.pad(parsing_result, pad_width=1, mode='constant', constant_values=0)
+    return parsing_result, wear_type
+
+
+
+def hole_fill(img):
+    img_copy = img.copy()
+    mask = np.zeros((img.shape[0] + 2, img.shape[1] + 2), dtype=np.uint8)
+    cv2.floodFill(img, mask, (0, 0), 255)
+    img_inverse = cv2.bitwise_not(img)
+    dst = cv2.bitwise_or(img_copy, img_inverse)
+    return dst
+
+def refine_mask(mask):
+    contours, hierarchy = cv2.findContours(mask.astype(np.uint8),
+                                           cv2.RETR_CCOMP, cv2.CHAIN_APPROX_TC89_L1)
+    area = []
+    for j in range(len(contours)):
+        a_d = cv2.contourArea(contours[j], True)
+        area.append(abs(a_d))
+    refine_mask = np.zeros_like(mask).astype(np.uint8)
+    if len(area) != 0:
+        i = area.index(max(area))
+        cv2.drawContours(refine_mask, contours, i, color=255, thickness=-1)
+        # keep large area in skin case
+        for j in range(len(area)):
+          if j != i and area[i] > 2000:
+             cv2.drawContours(refine_mask, contours, j, color=255, thickness=-1)
+    return refine_mask
+
+def refine_hole(parsing_result_filled, parsing_result, arm_mask):
+    filled_hole = cv2.bitwise_and(np.where(parsing_result_filled == 4, 255, 0),
+                                  np.where(parsing_result != 4, 255, 0)) - arm_mask * 255
+    contours, hierarchy = cv2.findContours(filled_hole, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_TC89_L1)
+    refine_hole_mask = np.zeros_like(parsing_result).astype(np.uint8)
+    for i in range(len(contours)):
+        a = cv2.contourArea(contours[i], True)
+        # keep hole > 2000 pixels
+        if abs(a) > 2000:
+            cv2.drawContours(refine_hole_mask, contours, i, color=255, thickness=-1)
+    return refine_hole_mask + arm_mask
+
+def onnx_inference(lip_session, input_dir, mask_components=[0]):
+
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.406, 0.456, 0.485], std=[0.225, 0.224, 0.229])
+    ])
+    input_size = [473, 473]
+
+    dataset_lip = SimpleFolderDataset(root=input_dir, input_size=input_size, transform=transform)
+    dataloader_lip = DataLoader(dataset_lip)
+    palette = get_palette(20)
+    with torch.no_grad():
+        for _, batch in enumerate(tqdm(dataloader_lip)):
+            image, meta = batch
+            c = meta['center'].numpy()[0]
+            s = meta['scale'].numpy()[0]
+            w = meta['width'].numpy()[0]
+            h = meta['height'].numpy()[0]
+
+            output = lip_session.run(None, {"input.1": image.numpy().astype(np.float32)})
+            upsample = torch.nn.Upsample(size=input_size, mode='bilinear', align_corners=True)
+            upsample_output = upsample(torch.from_numpy(output[1][0]).unsqueeze(0))
+            upsample_output = upsample_output.squeeze()
+            upsample_output = upsample_output.permute(1, 2, 0)  # CHW -> HWC
+            logits_result_lip = transform_logits(upsample_output.data.cpu().numpy(), c, s, w, h,
+                                                 input_size=input_size)
+            parsing_result = np.argmax(logits_result_lip, axis=2)
+
+        output_img = Image.fromarray(np.asarray(parsing_result, dtype=np.uint8))
+        output_img.putpalette(palette)
+
+    mask = np.isin(output_img, mask_components).astype(np.uint8)
+    mask_image = Image.fromarray(mask * 255)
+    mask_image = mask_image.convert("RGB")
+    mask_image = torch.from_numpy(np.array(mask_image).astype(np.float32) / 255.0).unsqueeze(0)
+
+    output_img = output_img.convert('RGB')
+    output_img = torch.from_numpy(np.array(output_img).astype(np.float32) / 255.0).unsqueeze(0)
+
+    return output_img, mask_image
+
+
+
+
@@ -0,0 +1,23 @@
+from .parsing_api import onnx_inference
+from ..libs.utils import install_package
+
+class HumanParsing:
+    def __init__(self, model_path):
+        self.model_path = model_path
+        self.session = None
+
+    def __call__(self, input_image, mask_components):
+        if self.session is None:
+            install_package('onnxruntime')
+            import onnxruntime as ort
+
+            session_options = ort.SessionOptions()
+            session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+            session_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+            # session_options.add_session_config_entry('gpu_id', str(gpu_id))
+            self.session = ort.InferenceSession(self.model_path, sess_options=session_options,
+                                                providers=['CPUExecutionProvider'])
+
+        parsed_image, mask = onnx_inference(self.session, input_image, mask_components)
+        return parsed_image, mask
+
@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+
+"""
+@Author  :   Peike Li
+@Contact :   peike.li@yahoo.com
+@File    :   dataset.py
+@Time    :   8/30/19 9:12 PM
+@Desc    :   Dataset Definition
+@License :   This source code is licensed under the license found in the
+             LICENSE file in the root directory of this source tree.
+"""
+
+import os
+
+import cv2
+import numpy as np
+from PIL import Image
+from torch.utils import data
+from .transforms import get_affine_transform
+
+
+class SimpleFolderDataset(data.Dataset):
+    def __init__(self, root, input_size=[512, 512], transform=None):
+        self.root = root
+        self.input_size = input_size
+        self.transform = transform
+        self.aspect_ratio = input_size[1] * 1.0 / input_size[0]
+        self.input_size = np.asarray(input_size)
+        self.is_pil_image = False
+        if isinstance(root, Image.Image):
+            self.file_list = [root]
+            self.is_pil_image = True
+        elif os.path.isfile(root):
+            self.file_list = [os.path.basename(root)]
+            self.root = os.path.dirname(root)
+        else:
+            self.file_list = os.listdir(self.root)
+
+    def __len__(self):
+        return len(self.file_list)
+
+    def _box2cs(self, box):
+        x, y, w, h = box[:4]
+        return self._xywh2cs(x, y, w, h)
+
+    def _xywh2cs(self, x, y, w, h):
+        center = np.zeros((2), dtype=np.float32)
+        center[0] = x + w * 0.5
+        center[1] = y + h * 0.5
+        if w > self.aspect_ratio * h:
+            h = w * 1.0 / self.aspect_ratio
+        elif w < self.aspect_ratio * h:
+            w = h * self.aspect_ratio
+        scale = np.array([w, h], dtype=np.float32)
+        return center, scale
+
+    def __getitem__(self, index):
+        if self.is_pil_image:
+            img = np.asarray(self.file_list[index])[:, :, [2, 1, 0]]
+        else:
+            img_name = self.file_list[index]
+            img_path = os.path.join(self.root, img_name)
+            img = cv2.imread(img_path, cv2.IMREAD_COLOR)
+        h, w, _ = img.shape
+
+        # Get person center and scale
+        person_center, s = self._box2cs([0, 0, w - 1, h - 1])
+        r = 0
+        trans = get_affine_transform(person_center, s, r, self.input_size)
+        input = cv2.warpAffine(
+            img,
+            trans,
+            (int(self.input_size[1]), int(self.input_size[0])),
+            flags=cv2.INTER_LINEAR,
+            borderMode=cv2.BORDER_CONSTANT,
+            borderValue=(0, 0, 0))
+
+        input = self.transform(input)
+        meta = {
+            'center': person_center,
+            'height': h,
+            'width': w,
+            'scale': s,
+            'rotation': r
+        }
+
+        return input, meta
@@ -0,0 +1,167 @@
+# ------------------------------------------------------------------------------
+# Copyright (c) Microsoft
+# Licensed under the MIT License.
+# Written by Bin Xiao (Bin.Xiao@microsoft.com)
+# ------------------------------------------------------------------------------
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import cv2
+import torch
+
+class BRG2Tensor_transform(object):
+    def __call__(self, pic):
+        img = torch.from_numpy(pic.transpose((2, 0, 1)))
+        if isinstance(img, torch.ByteTensor):
+            return img.float()
+        else:
+            return img
+
+class BGR2RGB_transform(object):
+    def __call__(self, tensor):
+        return tensor[[2,1,0],:,:]
+
+def flip_back(output_flipped, matched_parts):
+    '''
+    ouput_flipped: numpy.ndarray(batch_size, num_joints, height, width)
+    '''
+    assert output_flipped.ndim == 4,\
+        'output_flipped should be [batch_size, num_joints, height, width]'
+
+    output_flipped = output_flipped[:, :, :, ::-1]
+
+    for pair in matched_parts:
+        tmp = output_flipped[:, pair[0], :, :].copy()
+        output_flipped[:, pair[0], :, :] = output_flipped[:, pair[1], :, :]
+        output_flipped[:, pair[1], :, :] = tmp
+
+    return output_flipped
+
+
+def fliplr_joints(joints, joints_vis, width, matched_parts):
+    """
+    flip coords
+    """
+    # Flip horizontal
+    joints[:, 0] = width - joints[:, 0] - 1
+
+    # Change left-right parts
+    for pair in matched_parts:
+        joints[pair[0], :], joints[pair[1], :] = \
+            joints[pair[1], :], joints[pair[0], :].copy()
+        joints_vis[pair[0], :], joints_vis[pair[1], :] = \
+            joints_vis[pair[1], :], joints_vis[pair[0], :].copy()
+
+    return joints*joints_vis, joints_vis
+
+
+def transform_preds(coords, center, scale, input_size):
+    target_coords = np.zeros(coords.shape)
+    trans = get_affine_transform(center, scale, 0, input_size, inv=1)
+    for p in range(coords.shape[0]):
+        target_coords[p, 0:2] = affine_transform(coords[p, 0:2], trans)
+    return target_coords
+
+def transform_parsing(pred, center, scale, width, height, input_size):
+
+    trans = get_affine_transform(center, scale, 0, input_size, inv=1)
+    target_pred = cv2.warpAffine(
+            pred,
+            trans,
+            (int(width), int(height)), #(int(width), int(height)),
+            flags=cv2.INTER_NEAREST,
+            borderMode=cv2.BORDER_CONSTANT,
+            borderValue=(0))
+
+    return target_pred
+
+def transform_logits(logits, center, scale, width, height, input_size):
+
+    trans = get_affine_transform(center, scale, 0, input_size, inv=1)
+    channel = logits.shape[2]
+    target_logits = []
+    for i in range(channel):
+        target_logit = cv2.warpAffine(
+            logits[:,:,i],
+            trans,
+            (int(width), int(height)), #(int(width), int(height)),
+            flags=cv2.INTER_LINEAR,
+            borderMode=cv2.BORDER_CONSTANT,
+            borderValue=(0))
+        target_logits.append(target_logit)
+    target_logits = np.stack(target_logits,axis=2)
+
+    return target_logits
+
+
+def get_affine_transform(center,
+                         scale,
+                         rot,
+                         output_size,
+                         shift=np.array([0, 0], dtype=np.float32),
+                         inv=0):
+    if not isinstance(scale, np.ndarray) and not isinstance(scale, list):
+        print(scale)
+        scale = np.array([scale, scale])
+
+    scale_tmp = scale
+
+    src_w = scale_tmp[0]
+    dst_w = output_size[1]
+    dst_h = output_size[0]
+
+    rot_rad = np.pi * rot / 180
+    src_dir = get_dir([0, src_w * -0.5], rot_rad)
+    dst_dir = np.array([0, (dst_w-1) * -0.5], np.float32)
+
+    src = np.zeros((3, 2), dtype=np.float32)
+    dst = np.zeros((3, 2), dtype=np.float32)
+    src[0, :] = center + scale_tmp * shift
+    src[1, :] = center + src_dir + scale_tmp * shift
+    dst[0, :] = [(dst_w-1) * 0.5, (dst_h-1) * 0.5]
+    dst[1, :] = np.array([(dst_w-1) * 0.5, (dst_h-1) * 0.5]) + dst_dir
+
+    src[2:, :] = get_3rd_point(src[0, :], src[1, :])
+    dst[2:, :] = get_3rd_point(dst[0, :], dst[1, :])
+
+    if inv:
+        trans = cv2.getAffineTransform(np.float32(dst), np.float32(src))
+    else:
+        trans = cv2.getAffineTransform(np.float32(src), np.float32(dst))
+
+    return trans
+
+
+def affine_transform(pt, t):
+    new_pt = np.array([pt[0], pt[1], 1.]).T
+    new_pt = np.dot(t, new_pt)
+    return new_pt[:2]
+
+
+def get_3rd_point(a, b):
+    direct = a - b
+    return b + np.array([-direct[1], direct[0]], dtype=np.float32)
+
+
+def get_dir(src_point, rot_rad):
+    sn, cs = np.sin(rot_rad), np.cos(rot_rad)
+
+    src_result = [0, 0]
+    src_result[0] = src_point[0] * cs - src_point[1] * sn
+    src_result[1] = src_point[0] * sn + src_point[1] * cs
+
+    return src_result
+
+
+def crop(img, center, scale, output_size, rot=0):
+    trans = get_affine_transform(center, scale, rot, output_size)
+
+    dst_img = cv2.warpAffine(img,
+                             trans,
+                             (int(output_size[1]), int(output_size[0])),
+                             flags=cv2.INTER_LINEAR)
+
+    return dst_img
@@ -0,0 +1,186 @@
+#credit to huchenlei for this module
+#from https://github.com/huchenlei/ComfyUI-IC-Light-Native
+import torch
+import numpy as np
+from typing import Tuple, TypedDict, Callable
+
+import comfy.model_management
+from comfy.sd import load_unet
+from comfy.ldm.models.autoencoder import AutoencoderKL
+from comfy.model_base import BaseModel
+from comfy.model_patcher import ModelPatcher
+from PIL import Image
+from nodes import VAEEncode
+from ..libs.image import np2tensor, pil2tensor
+
+class UnetParams(TypedDict):
+    input: torch.Tensor
+    timestep: torch.Tensor
+    c: dict
+    cond_or_uncond: torch.Tensor
+
+class VAEEncodeArgMax(VAEEncode):
+    def encode(self, vae, pixels):
+        assert isinstance(
+            vae.first_stage_model, AutoencoderKL
+        ), "ArgMax only supported for AutoencoderKL"
+        original_sample_mode = vae.first_stage_model.regularization.sample
+        vae.first_stage_model.regularization.sample = False
+        ret = super().encode(vae, pixels)
+        vae.first_stage_model.regularization.sample = original_sample_mode
+        return ret
+
+class ICLight:
+
+    @staticmethod
+    def apply_c_concat(params: UnetParams, concat_conds) -> UnetParams:
+        """Apply c_concat on unet call."""
+        sample = params["input"]
+        params["c"]["c_concat"] = torch.cat(
+            (
+                    [concat_conds.to(sample.device)]
+                    * (sample.shape[0] // concat_conds.shape[0])
+            ),
+            dim=0,
+        )
+        return params
+
+    @staticmethod
+    def create_custom_conv(
+        original_conv: torch.nn.Module,
+        dtype: torch.dtype,
+        device=torch.device,
+    ) -> torch.nn.Module:
+        with torch.no_grad():
+            new_conv_in = torch.nn.Conv2d(
+                8,
+                original_conv.out_channels,
+                original_conv.kernel_size,
+                original_conv.stride,
+                original_conv.padding,
+            )
+            new_conv_in.weight.zero_()
+            new_conv_in.weight[:, :4, :, :].copy_(original_conv.weight)
+            new_conv_in.bias = original_conv.bias
+            return new_conv_in.to(dtype=dtype, device=device)
+
+    def generate_lighting_image(self, original_image, direction):
+        _, image_height, image_width, _ = original_image.shape
+        match direction:
+            case 'Left Light':
+                gradient = np.linspace(255, 0, image_width)
+                image = np.tile(gradient, (image_height, 1))
+                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+                return np2tensor(input_bg)
+            case 'Right Light':
+                gradient = np.linspace(0, 255, image_width)
+                image = np.tile(gradient, (image_height, 1))
+                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+                return np2tensor(input_bg)
+            case 'Top Light':
+                gradient = np.linspace(255, 0, image_height)[:, None]
+                image = np.tile(gradient, (1, image_width))
+                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+                return np2tensor(input_bg)
+            case 'Bottom Light':
+                gradient = np.linspace(0, 255, image_height)[:, None]
+                image = np.tile(gradient, (1, image_width))
+                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+                return np2tensor(input_bg)
+            case 'Circle Light':
+                x = np.linspace(-1, 1, image_width)
+                y = np.linspace(-1, 1, image_height)
+                x, y = np.meshgrid(x, y)
+                r = np.sqrt(x ** 2 + y ** 2)
+                r = r / r.max()
+                color1 = np.array([0, 0, 0])[np.newaxis, np.newaxis, :]
+                color2 = np.array([255, 255, 255])[np.newaxis, np.newaxis, :]
+                gradient = (color1 * r[..., np.newaxis] + color2 * (1 - r)[..., np.newaxis]).astype(np.uint8)
+                image = pil2tensor(Image.fromarray(gradient))
+                return image
+            case _:
+                image = pil2tensor(Image.new('RGB', (1, 1), (0, 0, 0)))
+                return image
+
+    def generate_source_image(self, original_image, source):
+        batch_size, image_height, image_width, _ = original_image.shape
+        match source:
+            case 'Use Flipped Background Image':
+                if batch_size < 2:
+                    raise ValueError('Must be at least 2 image to use flipped background image.')
+                original_image = [img.unsqueeze(0) for img in original_image]
+                image = torch.flip(original_image[1], [2])
+                return image
+            case 'Ambient':
+                input_bg = np.zeros(shape=(image_height, image_width, 3), dtype=np.uint8) + 64
+                return np2tensor(input_bg)
+            case 'Left Light':
+                gradient = np.linspace(224, 32, image_width)
+                image = np.tile(gradient, (image_height, 1))
+                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+                return np2tensor(input_bg)
+            case 'Right Light':
+                gradient = np.linspace(32, 224, image_width)
+                image = np.tile(gradient, (image_height, 1))
+                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+                return np2tensor(input_bg)
+            case 'Top Light':
+                gradient = np.linspace(224, 32, image_height)[:, None]
+                image = np.tile(gradient, (1, image_width))
+                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+                return np2tensor(input_bg)
+            case 'Bottom Light':
+                gradient = np.linspace(32, 224, image_height)[:, None]
+                image = np.tile(gradient, (1, image_width))
+                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+                return np2tensor(input_bg)
+            case _:
+                image = pil2tensor(Image.new('RGB', (1, 1), (0, 0, 0)))
+                return image
+
+
+    def apply(self, ic_model_path, model, c_concat: dict, ic_model=None) -> Tuple[ModelPatcher]:
+        device = comfy.model_management.get_torch_device()
+        dtype = comfy.model_management.unet_dtype()
+        work_model = model.clone()
+
+        # Apply scale factor.
+        base_model: BaseModel = work_model.model
+        scale_factor = base_model.model_config.latent_format.scale_factor
+
+        # [B, 4, H, W]
+        concat_conds: torch.Tensor = c_concat["samples"] * scale_factor
+        # [1, 4 * B, H, W]
+        concat_conds = torch.cat([c[None, ...] for c in concat_conds], dim=1)
+
+        def unet_dummy_apply(unet_apply: Callable, params: UnetParams):
+            """A dummy unet apply wrapper serving as the endpoint of wrapper
+            chain."""
+            return unet_apply(x=params["input"], t=params["timestep"], **params["c"])
+
+        existing_wrapper = work_model.model_options.get(
+            "model_function_wrapper", unet_dummy_apply
+        )
+
+        def wrapper_func(unet_apply: Callable, params: UnetParams):
+            return existing_wrapper(unet_apply, params=self.apply_c_concat(params, concat_conds))
+
+        work_model.set_model_unet_function_wrapper(wrapper_func)
+        if not ic_model:
+            ic_model = load_unet(ic_model_path)
+        ic_model_state_dict = ic_model.model.diffusion_model.state_dict()
+
+        work_model.add_patches(
+            patches={
+                ("diffusion_model." + key): (
+                    'diff',
+                    [
+                        value.to(dtype=dtype, device=device),
+                        {"pad_weight": key == 'input_blocks.0.0.weight'}
+                    ]
+                )
+                for key, value in ic_model_state_dict.items()
+            }
+        )
+
+        return (work_model, ic_model)
@@ -0,0 +1,42 @@
+{
+  "_name_or_path": "THUDM/chatglm3-6b-base",
+  "model_type": "chatglm",
+  "architectures": [
+    "ChatGLMModel"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_chatglm.ChatGLMConfig",
+    "AutoModel": "modeling_chatglm.ChatGLMForConditionalGeneration",
+    "AutoModelForCausalLM": "modeling_chatglm.ChatGLMForConditionalGeneration",
+    "AutoModelForSeq2SeqLM": "modeling_chatglm.ChatGLMForConditionalGeneration",
+    "AutoModelForSequenceClassification": "modeling_chatglm.ChatGLMForSequenceClassification"
+  },
+  "add_bias_linear": false,
+  "add_qkv_bias": true,
+  "apply_query_key_layer_scaling": true,
+  "apply_residual_connection_post_layernorm": false,
+  "attention_dropout": 0.0,
+  "attention_softmax_in_fp32": true,
+  "bias_dropout_fusion": true,
+  "ffn_hidden_size": 13696,
+  "fp32_residual_connection": false,
+  "hidden_dropout": 0.0,
+  "hidden_size": 4096,
+  "kv_channels": 128,
+  "layernorm_epsilon": 1e-05,
+  "multi_query_attention": true,
+  "multi_query_group_num": 2,
+  "num_attention_heads": 32,
+  "num_layers": 28,
+  "original_rope": true,
+  "padded_vocab_size": 65024,
+  "post_layer_norm": true,
+  "rmsnorm": true,
+  "seq_length": 32768,
+  "use_cache": true,
+  "torch_dtype": "float16",
+  "transformers_version": "4.30.2",
+  "tie_word_embeddings": false,
+  "eos_token_id": 2,
+  "pad_token_id": 0
+}
@@ -0,0 +1,60 @@
+from transformers import PretrainedConfig
+
+class ChatGLMConfig(PretrainedConfig):
+    model_type = "chatglm"
+    def __init__(
+        self,
+        num_layers=28,
+        padded_vocab_size=65024,
+        hidden_size=4096,
+        ffn_hidden_size=13696,
+        kv_channels=128,
+        num_attention_heads=32,
+        seq_length=2048,
+        hidden_dropout=0.0,
+        classifier_dropout=None,
+        attention_dropout=0.0,
+        layernorm_epsilon=1e-5,
+        rmsnorm=True,
+        apply_residual_connection_post_layernorm=False,
+        post_layer_norm=True,
+        add_bias_linear=False,
+        add_qkv_bias=False,
+        bias_dropout_fusion=True,
+        multi_query_attention=False,
+        multi_query_group_num=1,
+        apply_query_key_layer_scaling=True,
+        attention_softmax_in_fp32=True,
+        fp32_residual_connection=False,
+        quantization_bit=0,
+        pre_seq_len=None,
+        prefix_projection=False,
+        **kwargs
+    ):
+        self.num_layers = num_layers
+        self.vocab_size = padded_vocab_size
+        self.padded_vocab_size = padded_vocab_size
+        self.hidden_size = hidden_size
+        self.ffn_hidden_size = ffn_hidden_size
+        self.kv_channels = kv_channels
+        self.num_attention_heads = num_attention_heads
+        self.seq_length = seq_length
+        self.hidden_dropout = hidden_dropout
+        self.classifier_dropout = classifier_dropout
+        self.attention_dropout = attention_dropout
+        self.layernorm_epsilon = layernorm_epsilon
+        self.rmsnorm = rmsnorm
+        self.apply_residual_connection_post_layernorm = apply_residual_connection_post_layernorm
+        self.post_layer_norm = post_layer_norm
+        self.add_bias_linear = add_bias_linear
+        self.add_qkv_bias = add_qkv_bias
+        self.bias_dropout_fusion = bias_dropout_fusion
+        self.multi_query_attention = multi_query_attention
+        self.multi_query_group_num = multi_query_group_num
+        self.apply_query_key_layer_scaling = apply_query_key_layer_scaling
+        self.attention_softmax_in_fp32 = attention_softmax_in_fp32
+        self.fp32_residual_connection = fp32_residual_connection
+        self.quantization_bit = quantization_bit
+        self.pre_seq_len = pre_seq_len
+        self.prefix_projection = prefix_projection
+        super().__init__(**kwargs)
@@ -0,0 +1,299 @@
+import json
+import os
+import re
+from typing import List, Optional, Union, Dict
+from sentencepiece import SentencePieceProcessor
+from transformers import PreTrainedTokenizer
+from transformers.utils import logging, PaddingStrategy
+from transformers.tokenization_utils_base import EncodedInput, BatchEncoding
+
+class SPTokenizer:
+    def __init__(self, model_path: str):
+        # reload tokenizer
+        assert os.path.isfile(model_path), model_path
+        self.sp_model = SentencePieceProcessor(model_file=model_path)
+
+        # BOS / EOS token IDs
+        self.n_words: int = self.sp_model.vocab_size()
+        self.bos_id: int = self.sp_model.bos_id()
+        self.eos_id: int = self.sp_model.eos_id()
+        self.pad_id: int = self.sp_model.unk_id()
+        assert self.sp_model.vocab_size() == self.sp_model.get_piece_size()
+
+        role_special_tokens = ["<|system|>", "<|user|>", "<|assistant|>", "<|observation|>"]
+        special_tokens = ["[MASK]", "[gMASK]", "[sMASK]", "sop", "eop"] + role_special_tokens
+        self.special_tokens = {}
+        self.index_special_tokens = {}
+        for token in special_tokens:
+            self.special_tokens[token] = self.n_words
+            self.index_special_tokens[self.n_words] = token
+            self.n_words += 1
+        self.role_special_token_expression = "|".join([re.escape(token) for token in role_special_tokens])
+
+    def tokenize(self, s: str, encode_special_tokens=False):
+        if encode_special_tokens:
+            last_index = 0
+            t = []
+            for match in re.finditer(self.role_special_token_expression, s):
+                if last_index < match.start():
+                    t.extend(self.sp_model.EncodeAsPieces(s[last_index:match.start()]))
+                t.append(s[match.start():match.end()])
+                last_index = match.end()
+            if last_index < len(s):
+                t.extend(self.sp_model.EncodeAsPieces(s[last_index:]))
+            return t
+        else:
+            return self.sp_model.EncodeAsPieces(s)
+
+    def encode(self, s: str, bos: bool = False, eos: bool = False) -> List[int]:
+        assert type(s) is str
+        t = self.sp_model.encode(s)
+        if bos:
+            t = [self.bos_id] + t
+        if eos:
+            t = t + [self.eos_id]
+        return t
+
+    def decode(self, t: List[int]) -> str:
+        text, buffer = "", []
+        for token in t:
+            if token in self.index_special_tokens:
+                if buffer:
+                    text += self.sp_model.decode(buffer)
+                    buffer = []
+                text += self.index_special_tokens[token]
+            else:
+                buffer.append(token)
+        if buffer:
+            text += self.sp_model.decode(buffer)
+        return text
+
+    def decode_tokens(self, tokens: List[str]) -> str:
+        text = self.sp_model.DecodePieces(tokens)
+        return text
+
+    def convert_token_to_id(self, token):
+        """ Converts a token (str) in an id using the vocab. """
+        if token in self.special_tokens:
+            return self.special_tokens[token]
+        return self.sp_model.PieceToId(token)
+
+    def convert_id_to_token(self, index):
+        """Converts an index (integer) in a token (str) using the vocab."""
+        if index in self.index_special_tokens:
+            return self.index_special_tokens[index]
+        if index in [self.eos_id, self.bos_id, self.pad_id] or index < 0:
+            return ""
+        return self.sp_model.IdToPiece(index)
+
+
+class ChatGLMTokenizer(PreTrainedTokenizer):
+    vocab_files_names = {"vocab_file": "tokenizer.model"}
+
+    model_input_names = ["input_ids", "attention_mask", "position_ids"]
+
+    def __init__(self, vocab_file, padding_side="left", clean_up_tokenization_spaces=False, encode_special_tokens=False,
+                 **kwargs):
+        self.name = "GLMTokenizer"
+
+        self.vocab_file = vocab_file
+        self.tokenizer = SPTokenizer(vocab_file)
+        self.special_tokens = {
+            "<bos>": self.tokenizer.bos_id,
+            "<eos>": self.tokenizer.eos_id,
+            "<pad>": self.tokenizer.pad_id
+        }
+        self.encode_special_tokens = encode_special_tokens
+        super().__init__(padding_side=padding_side, clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+                         encode_special_tokens=encode_special_tokens,
+                         **kwargs)
+
+    def get_command(self, token):
+        if token in self.special_tokens:
+            return self.special_tokens[token]
+        assert token in self.tokenizer.special_tokens, f"{token} is not a special token for {self.name}"
+        return self.tokenizer.special_tokens[token]
+
+    @property
+    def unk_token(self) -> str:
+        return "<unk>"
+
+    @property
+    def pad_token(self) -> str:
+        return "<unk>"
+
+    @property
+    def pad_token_id(self):
+        return self.get_command("<pad>")
+
+    @property
+    def eos_token(self) -> str:
+        return "</s>"
+
+    @property
+    def eos_token_id(self):
+        return self.get_command("<eos>")
+
+    @property
+    def vocab_size(self):
+        return self.tokenizer.n_words
+
+    def get_vocab(self):
+        """ Returns vocab as a dict """
+        vocab = {self._convert_id_to_token(i): i for i in range(self.vocab_size)}
+        vocab.update(self.added_tokens_encoder)
+        return vocab
+
+    def _tokenize(self, text, **kwargs):
+        return self.tokenizer.tokenize(text, encode_special_tokens=self.encode_special_tokens)
+
+    def _convert_token_to_id(self, token):
+        """ Converts a token (str) in an id using the vocab. """
+        return self.tokenizer.convert_token_to_id(token)
+
+    def _convert_id_to_token(self, index):
+        """Converts an index (integer) in a token (str) using the vocab."""
+        return self.tokenizer.convert_id_to_token(index)
+
+    def convert_tokens_to_string(self, tokens: List[str]) -> str:
+        return self.tokenizer.decode_tokens(tokens)
+
+    def save_vocabulary(self, save_directory, filename_prefix=None):
+        """
+        Save the vocabulary and special tokens file to a directory.
+
+        Args:
+            save_directory (`str`):
+                The directory in which to save the vocabulary.
+            filename_prefix (`str`, *optional*):
+                An optional prefix to add to the named of the saved files.
+
+        Returns:
+            `Tuple(str)`: Paths to the files saved.
+        """
+        if os.path.isdir(save_directory):
+            vocab_file = os.path.join(
+                save_directory, self.vocab_files_names["vocab_file"]
+            )
+        else:
+            vocab_file = save_directory
+
+        with open(self.vocab_file, 'rb') as fin:
+            proto_str = fin.read()
+
+        with open(vocab_file, "wb") as writer:
+            writer.write(proto_str)
+
+        return (vocab_file,)
+
+    def get_prefix_tokens(self):
+        prefix_tokens = [self.get_command("[gMASK]"), self.get_command("sop")]
+        return prefix_tokens
+
+    def build_single_message(self, role, metadata, message):
+        assert role in ["system", "user", "assistant", "observation"], role
+        role_tokens = [self.get_command(f"<|{role}|>")] + self.tokenizer.encode(f"{metadata}\n")
+        message_tokens = self.tokenizer.encode(message)
+        tokens = role_tokens + message_tokens
+        return tokens
+
+    def build_chat_input(self, query, history=None, role="user"):
+        if history is None:
+            history = []
+        input_ids = []
+        for item in history:
+            content = item["content"]
+            if item["role"] == "system" and "tools" in item:
+                content = content + "\n" + json.dumps(item["tools"], indent=4, ensure_ascii=False)
+            input_ids.extend(self.build_single_message(item["role"], item.get("metadata", ""), content))
+        input_ids.extend(self.build_single_message(role, "", query))
+        input_ids.extend([self.get_command("<|assistant|>")])
+        return self.batch_encode_plus([input_ids], return_tensors="pt", is_split_into_words=True)
+
+    def build_inputs_with_special_tokens(
+            self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
+    ) -> List[int]:
+        """
+        Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
+        adding special tokens. A BERT sequence has the following format:
+
+        - single sequence: `[CLS] X [SEP]`
+        - pair of sequences: `[CLS] A [SEP] B [SEP]`
+
+        Args:
+            token_ids_0 (`List[int]`):
+                List of IDs to which the special tokens will be added.
+            token_ids_1 (`List[int]`, *optional*):
+                Optional second list of IDs for sequence pairs.
+
+        Returns:
+            `List[int]`: List of [input IDs](../glossary#input-ids) with the appropriate special tokens.
+        """
+        prefix_tokens = self.get_prefix_tokens()
+        token_ids_0 = prefix_tokens + token_ids_0
+        if token_ids_1 is not None:
+            token_ids_0 = token_ids_0 + token_ids_1 + [self.get_command("<eos>")]
+        return token_ids_0
+
+    def _pad(
+            self,
+            encoded_inputs: Union[Dict[str, EncodedInput], BatchEncoding],
+            max_length: Optional[int] = None,
+            padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,
+            pad_to_multiple_of: Optional[int] = None,
+            return_attention_mask: Optional[bool] = None,
+    ) -> dict:
+        """
+        Pad encoded inputs (on left/right and up to predefined length or max length in the batch)
+
+        Args:
+            encoded_inputs:
+                Dictionary of tokenized inputs (`List[int]`) or batch of tokenized inputs (`List[List[int]]`).
+            max_length: maximum length of the returned list and optionally padding length (see below).
+                Will truncate by taking into account the special tokens.
+            padding_strategy: PaddingStrategy to use for padding.
+
+                - PaddingStrategy.LONGEST Pad to the longest sequence in the batch
+                - PaddingStrategy.MAX_LENGTH: Pad to the max length (default)
+                - PaddingStrategy.DO_NOT_PAD: Do not pad
+                The tokenizer padding sides are defined in self.padding_side:
+
+                    - 'left': pads on the left of the sequences
+                    - 'right': pads on the right of the sequences
+            pad_to_multiple_of: (optional) Integer if set will pad the sequence to a multiple of the provided value.
+                This is especially useful to enable the use of Tensor Core on NVIDIA hardware with compute capability
+                `>= 7.5` (Volta).
+            return_attention_mask:
+                (optional) Set to False to avoid returning attention mask (default: set to model specifics)
+        """
+        # Load from model defaults
+        assert self.padding_side == "left"
+
+        required_input = encoded_inputs[self.model_input_names[0]]
+        seq_length = len(required_input)
+
+        if padding_strategy == PaddingStrategy.LONGEST:
+            max_length = len(required_input)
+
+        if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
+            max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of
+
+        needs_to_be_padded = padding_strategy != PaddingStrategy.DO_NOT_PAD and len(required_input) != max_length
+
+        # Initialize attention mask if not present.
+        if "attention_mask" not in encoded_inputs:
+            encoded_inputs["attention_mask"] = [1] * seq_length
+
+        if "position_ids" not in encoded_inputs:
+            encoded_inputs["position_ids"] = list(range(seq_length))
+
+        if needs_to_be_padded:
+            difference = max_length - len(required_input)
+
+            if "attention_mask" in encoded_inputs:
+                encoded_inputs["attention_mask"] = [0] * difference + encoded_inputs["attention_mask"]
+            if "position_ids" in encoded_inputs:
+                encoded_inputs["position_ids"] = [0] * difference + encoded_inputs["position_ids"]
+            encoded_inputs[self.model_input_names[0]] = [self.pad_token_id] * difference + required_input
+
+        return encoded_inputs
@@ -0,0 +1,12 @@
+{
+  "name_or_path": "THUDM/chatglm3-6b-base",
+  "remove_space": false,
+  "do_lower_case": false,
+  "tokenizer_class": "ChatGLMTokenizer",
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_chatglm.ChatGLMTokenizer",
+      null
+      ]
+  }
+}
@@ -0,0 +1,18 @@
+{
+  "attention_dropout": 0.0,
+  "dropout": 0.0,
+  "hidden_act": "quick_gelu",
+  "hidden_size": 1024,
+  "image_size": 336,
+  "initializer_factor": 1.0,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-05,
+  "model_type": "clip_vision_model",
+  "num_attention_heads": 16,
+  "num_channels": 3,
+  "num_hidden_layers": 24,
+  "patch_size": 14,
+  "projection_dim": 768,
+  "torch_dtype": "float32"
+}
@@ -0,0 +1,303 @@
+import json
+import os
+import torch
+import subprocess
+import sys
+import comfy.supported_models
+import comfy.model_patcher
+import comfy.model_management
+import comfy.model_detection as model_detection
+import comfy.model_base as model_base
+from comfy.model_base import sdxl_pooled, CLIPEmbeddingNoiseAugmentation, Timestep, ModelType
+from comfy.ldm.modules.diffusionmodules.openaimodel import UNetModel
+from comfy.clip_vision import ClipVisionModel, Output
+from comfy.utils import load_torch_file
+from .chatglm.modeling_chatglm import ChatGLMModel, ChatGLMConfig
+from .chatglm.tokenization_chatglm import ChatGLMTokenizer
+
+class KolorsUNetModel(UNetModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.encoder_hid_proj = torch.nn.Linear(4096, 2048, bias=True)
+
+    def forward(self, *args, **kwargs):
+        with torch.cuda.amp.autocast(enabled=True):
+            if "context" in kwargs:
+                kwargs["context"] = self.encoder_hid_proj(kwargs["context"])
+            result = super().forward(*args, **kwargs)
+            return result
+
+class KolorsSDXL(model_base.SDXL):
+    def __init__(self, model_config, model_type=ModelType.EPS, device=None):
+        model_base.BaseModel.__init__(self, model_config, model_type, device=device, unet_model=KolorsUNetModel)
+        self.embedder = Timestep(256)
+        self.noise_augmentor = CLIPEmbeddingNoiseAugmentation(**{"noise_schedule_config": {"timesteps": 1000, "beta_schedule": "squaredcos_cap_v2"}, "timestep_dim": 1280})
+
+    def encode_adm(self, **kwargs):
+        clip_pooled = sdxl_pooled(kwargs, self.noise_augmentor)
+        width = kwargs.get("width", 768)
+        height = kwargs.get("height", 768)
+        crop_w = kwargs.get("crop_w", 0)
+        crop_h = kwargs.get("crop_h", 0)
+        target_width = kwargs.get("target_width", width)
+        target_height = kwargs.get("target_height", height)
+
+        out = []
+        out.append(self.embedder(torch.Tensor([height])))
+        out.append(self.embedder(torch.Tensor([width])))
+        out.append(self.embedder(torch.Tensor([crop_h])))
+        out.append(self.embedder(torch.Tensor([crop_w])))
+        out.append(self.embedder(torch.Tensor([target_height])))
+        out.append(self.embedder(torch.Tensor([target_width])))
+        flat = torch.flatten(torch.cat(out)).unsqueeze(
+            dim=0).repeat(clip_pooled.shape[0], 1)
+        return torch.cat((clip_pooled.to(flat.device), flat), dim=1)
+
+class Kolors(comfy.supported_models.SDXL):
+    unet_config = {
+        "model_channels": 320,
+        "use_linear_in_transformer": True,
+        "transformer_depth": [0, 0, 2, 2, 10, 10],
+        "context_dim": 2048,
+        "adm_in_channels": 5632,
+        "use_temporal_attention": False,
+    }
+
+    def get_model(self, state_dict, prefix="", device=None):
+        out = KolorsSDXL(self, model_type=self.model_type(state_dict, prefix), device=device, )
+        out.__class__ = model_base.SDXL
+        if self.inpaint_model():
+            out.set_inpaint()
+        return out
+
+def kolors_unet_config_from_diffusers_unet(state_dict, dtype=None):
+    match = {}
+    transformer_depth = []
+
+    attn_res = 1
+    count_blocks = model_detection.count_blocks
+    down_blocks = count_blocks(state_dict, "down_blocks.{}")
+    for i in range(down_blocks):
+        attn_blocks = count_blocks(
+            state_dict, "down_blocks.{}.attentions.".format(i) + '{}')
+        res_blocks = count_blocks(
+            state_dict, "down_blocks.{}.resnets.".format(i) + '{}')
+        for ab in range(attn_blocks):
+            transformer_count = count_blocks(
+                state_dict, "down_blocks.{}.attentions.{}.transformer_blocks.".format(i, ab) + '{}')
+            transformer_depth.append(transformer_count)
+            if transformer_count > 0:
+                match["context_dim"] = state_dict["down_blocks.{}.attentions.{}.transformer_blocks.0.attn2.to_k.weight".format(
+                    i, ab)].shape[1]
+
+        attn_res *= 2
+        if attn_blocks == 0:
+            for i in range(res_blocks):
+                transformer_depth.append(0)
+
+    match["transformer_depth"] = transformer_depth
+
+    match["model_channels"] = state_dict["conv_in.weight"].shape[0]
+    match["in_channels"] = state_dict["conv_in.weight"].shape[1]
+    match["adm_in_channels"] = None
+    if "class_embedding.linear_1.weight" in state_dict:
+        match["adm_in_channels"] = state_dict["class_embedding.linear_1.weight"].shape[1]
+    elif "add_embedding.linear_1.weight" in state_dict:
+        match["adm_in_channels"] = state_dict["add_embedding.linear_1.weight"].shape[1]
+
+    Kolors = {'use_checkpoint': False, 'image_size': 32, 'out_channels': 4, 'use_spatial_transformer': True, 'legacy': False,
+              'num_classes': 'sequential', 'adm_in_channels': 5632, 'dtype': dtype, 'in_channels': 4, 'model_channels': 320,
+              'num_res_blocks': [2, 2, 2], 'transformer_depth': [0, 0, 2, 2, 10, 10], 'channel_mult': [1, 2, 4], 'transformer_depth_middle': 10,
+              'use_linear_in_transformer': True, 'context_dim': 2048, 'num_head_channels': 64, 'transformer_depth_output': [0, 0, 0, 2, 2, 2, 10, 10, 10],
+              'use_temporal_attention': False, 'use_temporal_resblock': False}
+
+    Kolors_inpaint = {'use_checkpoint': False, 'image_size': 32, 'out_channels': 4, 'use_spatial_transformer': True,
+                      'legacy': False,
+                      'num_classes': 'sequential', 'adm_in_channels': 5632, 'dtype': dtype, 'in_channels': 9,
+                      'model_channels': 320,
+                      'num_res_blocks': [2, 2, 2], 'transformer_depth': [0, 0, 2, 2, 10, 10], 'channel_mult': [1, 2, 4],
+                      'transformer_depth_middle': 10,
+                      'use_linear_in_transformer': True, 'context_dim': 2048, 'num_head_channels': 64,
+                      'transformer_depth_output': [0, 0, 0, 2, 2, 2, 10, 10, 10],
+                      'use_temporal_attention': False, 'use_temporal_resblock': False}
+
+    Kolors_ip2p = {'use_checkpoint': False, 'image_size': 32, 'out_channels': 4, 'use_spatial_transformer': True,
+                   'legacy': False,
+                   'num_classes': 'sequential', 'adm_in_channels': 5632, 'dtype': dtype, 'in_channels': 8,
+                   'model_channels': 320,
+                   'num_res_blocks': [2, 2, 2], 'transformer_depth': [0, 0, 2, 2, 10, 10], 'channel_mult': [1, 2, 4],
+                   'transformer_depth_middle': 10,
+                   'use_linear_in_transformer': True, 'context_dim': 2048, 'num_head_channels': 64,
+                   'transformer_depth_output': [0, 0, 0, 2, 2, 2, 10, 10, 10],
+                   'use_temporal_attention': False, 'use_temporal_resblock': False}
+
+    SDXL = {'use_checkpoint': False, 'image_size': 32, 'out_channels': 4, 'use_spatial_transformer': True,
+            'legacy': False,
+            'num_classes': 'sequential', 'adm_in_channels': 2816, 'dtype': dtype, 'in_channels': 4,
+            'model_channels': 320,
+            'num_res_blocks': [2, 2, 2], 'transformer_depth': [0, 0, 2, 2, 10, 10], 'channel_mult': [1, 2, 4],
+            'transformer_depth_middle': 10,
+            'use_linear_in_transformer': True, 'context_dim': 2048, 'num_head_channels': 64,
+            'transformer_depth_output': [0, 0, 0, 2, 2, 2, 10, 10, 10],
+            'use_temporal_attention': False, 'use_temporal_resblock': False}
+
+    SDXL_mid_cnet = {'use_checkpoint': False, 'image_size': 32, 'out_channels': 4, 'use_spatial_transformer': True,
+                     'legacy': False,
+                     'num_classes': 'sequential', 'adm_in_channels': 2816, 'dtype': dtype, 'in_channels': 4,
+                     'model_channels': 320,
+                     'num_res_blocks': [2, 2, 2], 'transformer_depth': [0, 0, 0, 0, 1, 1], 'channel_mult': [1, 2, 4],
+                     'transformer_depth_middle': 1,
+                     'use_linear_in_transformer': True, 'context_dim': 2048, 'num_head_channels': 64,
+                     'transformer_depth_output': [0, 0, 0, 0, 0, 0, 1, 1, 1],
+                     'use_temporal_attention': False, 'use_temporal_resblock': False}
+
+    SDXL_small_cnet = {'use_checkpoint': False, 'image_size': 32, 'out_channels': 4, 'use_spatial_transformer': True,
+                       'legacy': False,
+                       'num_classes': 'sequential', 'adm_in_channels': 2816, 'dtype': dtype, 'in_channels': 4,
+                       'model_channels': 320,
+                       'num_res_blocks': [2, 2, 2], 'transformer_depth': [0, 0, 0, 0, 0, 0], 'channel_mult': [1, 2, 4],
+                       'transformer_depth_middle': 0,
+                       'use_linear_in_transformer': True, 'num_head_channels': 64, 'context_dim': 1,
+                       'transformer_depth_output': [0, 0, 0, 0, 0, 0, 0, 0, 0],
+                       'use_temporal_attention': False, 'use_temporal_resblock': False}
+
+    supported_models = [Kolors, Kolors_inpaint,
+                        Kolors_ip2p, SDXL, SDXL_mid_cnet, SDXL_small_cnet]
+
+
+    for unet_config in supported_models:
+        matches = True
+        for k in match:
+            if match[k] != unet_config[k]:
+                # print("key {} does not match".format(k), match[k], "||", unet_config[k])
+                matches = False
+                break
+        if matches:
+            return model_detection.convert_config(unet_config)
+    return None
+
+# chatglm3 model
+class chatGLM3Model(torch.nn.Module):
+    def __init__(self, textmodel_json_config=None, device='cpu', offload_device='cpu', model_path=None):
+        super().__init__()
+        if model_path is None:
+            raise ValueError("model_path is required")
+        self.device = device
+        if textmodel_json_config is None:
+            textmodel_json_config = os.path.join(
+                os.path.dirname(os.path.realpath(__file__)),
+                "chatglm",
+                "config_chatglm.json"
+            )
+        with open(textmodel_json_config, 'r') as file:
+            config = json.load(file)
+        textmodel_json_config = ChatGLMConfig(**config)
+        is_accelerate_available = False
+        try:
+            from accelerate import init_empty_weights
+            from accelerate.utils import set_module_tensor_to_device
+            is_accelerate_available = True
+        except:
+            pass
+
+        from contextlib import nullcontext
+        with (init_empty_weights() if is_accelerate_available else nullcontext()):
+            with torch.no_grad():
+                print('torch version:', torch.__version__)
+                self.text_encoder = ChatGLMModel(textmodel_json_config).eval()
+                if '4bit' in model_path:
+                    try:
+                        import cpm_kernels
+                    except ImportError:
+                        print("Installing cpm_kernels...")
+                        subprocess.run([sys.executable, "-m", "pip", "install", "cpm_kernels"], check=True)
+                        pass
+                    self.text_encoder.quantize(4)
+                elif '8bit' in model_path:
+                    self.text_encoder.quantize(8)
+
+        sd = load_torch_file(model_path)
+        if is_accelerate_available:
+            for key in sd:
+                set_module_tensor_to_device(self.text_encoder, key, device=offload_device, value=sd[key])
+        else:
+            print("WARNING: Accelerate not available, use load_state_dict load model")
+            self.text_encoder.load_state_dict()
+
+def load_chatglm3(model_path=None):
+    if model_path is None:
+        return
+
+    load_device = comfy.model_management.text_encoder_device()
+    offload_device = comfy.model_management.text_encoder_offload_device()
+
+    glm3model = chatGLM3Model(
+        device=load_device,
+        offload_device=offload_device,
+        model_path=model_path
+    )
+    tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'chatglm', "tokenizer")
+    tokenizer = ChatGLMTokenizer.from_pretrained(tokenizer_path)
+    text_encoder = glm3model.text_encoder
+    return {"text_encoder":text_encoder, "tokenizer":tokenizer}
+
+
+# clipvision model
+def load_clipvision_vitl_336(path):
+    sd = load_torch_file(path)
+    if "vision_model.encoder.layers.22.layer_norm1.weight" in sd:
+        json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_config_vitl_336.json")
+    else:
+        raise Exception("Unsupported clip vision model")
+    clip = ClipVisionModel(json_config)
+    m, u = clip.load_sd(sd)
+    if len(m) > 0:
+        print("missing clip vision: {}".format(m))
+    u = set(u)
+    keys = list(sd.keys())
+    for k in keys:
+        if k not in u:
+            t = sd.pop(k)
+            del t
+    return clip
+
+class applyKolorsUnet:
+    def __enter__(self):
+        import comfy.ldm.modules.diffusionmodules.openaimodel
+        import comfy.utils
+        import comfy.clip_vision
+
+        self.original_UNET_MAP_BASIC = comfy.utils.UNET_MAP_BASIC.copy()
+        comfy.utils.UNET_MAP_BASIC.add(("encoder_hid_proj.weight", "encoder_hid_proj.weight"),)
+        comfy.utils.UNET_MAP_BASIC.add(("encoder_hid_proj.bias", "encoder_hid_proj.bias"),)
+
+        self.original_unet_config_from_diffusers_unet = model_detection.unet_config_from_diffusers_unet
+        model_detection.unet_config_from_diffusers_unet = kolors_unet_config_from_diffusers_unet
+
+        import comfy.supported_models
+        self.original_supported_models = comfy.supported_models.models
+        comfy.supported_models.models = [Kolors]
+
+        self.original_load_clipvision_from_sd = comfy.clip_vision.load_clipvision_from_sd
+        comfy.clip_vision.load_clipvision_from_sd = load_clipvision_vitl_336
+
+    def __exit__(self, type, value, traceback):
+        import comfy.ldm.modules.diffusionmodules.openaimodel
+        import comfy.utils
+        import comfy.supported_models
+        import comfy.clip_vision
+
+        comfy.utils.UNET_MAP_BASIC = self.original_UNET_MAP_BASIC
+
+        model_detection.unet_config_from_diffusers_unet = self.original_unet_config_from_diffusers_unet
+        comfy.supported_models.models = self.original_supported_models
+
+        comfy.clip_vision.load_clipvision_from_sd = self.original_load_clipvision_from_sd
+
+
+def is_kolors_model(model):
+    unet_config = model.model.model_config.unet_config
+    if unet_config and "adm_in_channels" in unet_config and unet_config["adm_in_channels"] == 5632:
+        return True
+    else:
+        return False
@@ -0,0 +1,66 @@
+import torch
+from torch.nn import Linear
+from types import MethodType
+import comfy.model_management
+import comfy.samplers
+from comfy.cldm.cldm import ControlNet
+from comfy.controlnet import ControlLora
+
+def patch_controlnet(model, control_net):
+    import comfy.controlnet
+    if isinstance(control_net, ControlLora):
+        del_keys = []
+        for k in control_net.control_weights:
+            if k.startswith("label_emb.0.0."):
+                del_keys.append(k)
+
+        for k in del_keys:
+            control_net.control_weights.pop(k)
+
+        super_pre_run = ControlLora.pre_run
+        super_copy = ControlLora.copy
+
+        super_forward = ControlNet.forward
+
+        def KolorsControlNet_forward(self, x, hint, timesteps, context, **kwargs):
+            with torch.cuda.amp.autocast(enabled=True):
+                context = model.model.diffusion_model.encoder_hid_proj(context)
+                return super_forward(self, x, hint, timesteps, context, **kwargs)
+
+        def KolorsControlLora_pre_run(self, *args, **kwargs):
+            result = super_pre_run(self, *args, **kwargs)
+
+            if hasattr(self, "control_model"):
+                self.control_model.forward = MethodType(
+                    KolorsControlNet_forward, self.control_model)
+            return result
+
+        control_net.pre_run = MethodType(
+            KolorsControlLora_pre_run, control_net)
+
+        def KolorsControlLora_copy(self, *args, **kwargs):
+            c = super_copy(self, *args, **kwargs)
+            c.pre_run = MethodType(
+                KolorsControlLora_pre_run, c)
+            return c
+
+        control_net.copy = MethodType(KolorsControlLora_copy, control_net)
+
+    elif isinstance(control_net, comfy.controlnet.ControlNet):
+        model_label_emb = model.model.diffusion_model.label_emb
+        control_net.control_model.label_emb = model_label_emb
+        control_net.control_model_wrapped.model.label_emb = model_label_emb
+        super_forward = ControlNet.forward
+
+        def KolorsControlNet_forward(self, x, hint, timesteps, context, **kwargs):
+            with torch.cuda.amp.autocast(enabled=True):
+                context = model.model.diffusion_model.encoder_hid_proj(context)
+                return super_forward(self, x, hint, timesteps, context, **kwargs)
+
+        control_net.control_model.forward = MethodType(
+            KolorsControlNet_forward, control_net.control_model)
+
+    else:
+        raise NotImplementedError(f"Type {control_net} not supported for KolorsControlNetPatch")
+
+    return control_net
@@ -0,0 +1,105 @@
+import re
+import random
+import gc
+import comfy.model_management as mm
+from nodes import ConditioningConcat, ConditioningZeroOut, ConditioningSetTimestepRange, ConditioningCombine
+
+def chatglm3_text_encode(chatglm3_model, prompt, clean_gpu=False):
+    device = mm.get_torch_device()
+    offload_device = mm.unet_offload_device()
+    if clean_gpu:
+        mm.unload_all_models()
+        mm.soft_empty_cache()
+    # Function to randomly select an option from the brackets
+
+    def choose_random_option(match):
+        options = match.group(1).split('|')
+        return random.choice(options)
+
+    prompt = re.sub(r'\{([^{}]*)\}', choose_random_option, prompt)
+
+    if "|" in prompt:
+        prompt = prompt.split("|")
+
+    if prompt is not None and isinstance(prompt, str):
+        batch_size = 1
+    elif prompt is not None and isinstance(prompt, list):
+        batch_size = len(prompt)
+
+    # Define tokenizers and text encoders
+    tokenizer = chatglm3_model['tokenizer']
+    text_encoder = chatglm3_model['text_encoder']
+    text_encoder.to(device)
+    text_inputs = tokenizer(
+        prompt,
+        padding="max_length",
+        max_length=256,
+        truncation=True,
+        return_tensors="pt",
+    ).to(device)
+
+    output = text_encoder(
+        input_ids=text_inputs['input_ids'],
+        attention_mask=text_inputs['attention_mask'],
+        position_ids=text_inputs['position_ids'],
+        output_hidden_states=True)
+
+    # [batch_size, 77, 4096]
+    prompt_embeds = output.hidden_states[-2].permute(1, 0, 2).clone()
+    text_proj = output.hidden_states[-1][-1, :, :].clone()  # [batch_size, 4096]
+    bs_embed, seq_len, _ = prompt_embeds.shape
+    prompt_embeds = prompt_embeds.repeat(1, 1, 1)
+    prompt_embeds = prompt_embeds.view(bs_embed, seq_len, -1)
+
+    bs_embed = text_proj.shape[0]
+    text_proj = text_proj.repeat(1, 1).view(bs_embed, -1)
+    text_encoder.to(offload_device)
+    if clean_gpu:
+        mm.soft_empty_cache()
+        gc.collect()
+    return [[prompt_embeds, {"pooled_output": text_proj},]]
+
+def chatglm3_adv_text_encode(chatglm3_model, text, clean_gpu=False):
+    time_start = 0
+    time_end = 1
+    match = re.search(r'TIMESTEP.*$', text)
+    if match:
+        timestep = match.group()
+        timestep = timestep.split(' ')
+        timestep = timestep[0]
+        text = text.replace(timestep, '')
+        value = timestep.split(':')
+        if len(value) >= 3:
+            time_start = float(value[1])
+            time_end = float(value[2])
+        elif len(value) == 2:
+            time_start = float(value[1])
+            time_end = 1
+        elif len(value) == 1:
+            time_start = 0.1
+            time_end = 1
+
+
+    pass3 = [x.strip() for x in text.split("BREAK")]
+    pass3 = [x for x in pass3 if x != '']
+
+    if len(pass3) == 0:
+        pass3 = ['']
+
+    conditioning = None
+
+    for text in pass3:
+        cond = chatglm3_text_encode(chatglm3_model, text, clean_gpu)
+        if conditioning is not None:
+            conditioning = ConditioningConcat().concat(conditioning, cond)[0]
+        else:
+            conditioning = cond
+
+    # setTimeStepRange
+    if time_start > 0 or time_end < 1:
+        conditioning_2, = ConditioningSetTimestepRange().set_range(conditioning, 0, time_start)
+        conditioning_1, = ConditioningZeroOut().zero_out(conditioning)
+        conditioning_1, = ConditioningSetTimestepRange().set_range(conditioning_1, time_start, time_end)
+        conditioning, = ConditioningCombine().combine(conditioning_1, conditioning_2)
+
+    return conditioning
@@ -0,0 +1,213 @@
+#credit to huchenlei for this module
+#from https://github.com/huchenlei/ComfyUI-layerdiffuse
+import torch
+import comfy.model_management
+import comfy.lora
+import copy
+from typing import Optional
+from enum import Enum
+from comfy.utils import load_torch_file
+from comfy.conds import CONDRegular
+from comfy_extras.nodes_compositing import JoinImageWithAlpha
+from .model import ModelPatcher, TransparentVAEDecoder, calculate_weight_adjust_channel
+from .attension_sharing import AttentionSharingPatcher
+from ..config import LAYER_DIFFUSION, LAYER_DIFFUSION_DIR, LAYER_DIFFUSION_VAE
+from ..libs.utils import to_lora_patch_dict, get_local_filepath, get_sd_version
+
+load_layer_model_state_dict = load_torch_file
+class LayerMethod(Enum):
+    FG_ONLY_ATTN = "Attention Injection"
+    FG_ONLY_CONV = "Conv Injection"
+    FG_TO_BLEND = "Foreground"
+    FG_BLEND_TO_BG = "Foreground to Background"
+    BG_TO_BLEND = "Background"
+    BG_BLEND_TO_FG = "Background to Foreground"
+    EVERYTHING = "Everything"
+
+class LayerDiffuse:
+
+    def __init__(self) -> None:
+        self.vae_transparent_decoder = None
+        self.frames = 1
+
+    def get_layer_diffusion_method(self, method, has_blend_latent):
+        method = LayerMethod(method)
+        if method == LayerMethod.BG_TO_BLEND and has_blend_latent:
+            method = LayerMethod.BG_BLEND_TO_FG
+        elif method == LayerMethod.FG_TO_BLEND and has_blend_latent:
+            method = LayerMethod.FG_BLEND_TO_BG
+        return method
+
+    def apply_layer_c_concat(self, cond, uncond, c_concat):
+        def write_c_concat(cond):
+            new_cond = []
+            for t in cond:
+                n = [t[0], t[1].copy()]
+                if "model_conds" not in n[1]:
+                    n[1]["model_conds"] = {}
+                n[1]["model_conds"]["c_concat"] = CONDRegular(c_concat)
+                new_cond.append(n)
+            return new_cond
+
+        return (write_c_concat(cond), write_c_concat(uncond))
+
+    def apply_layer_diffusion(self, model: ModelPatcher, method, weight, samples, blend_samples, positive, negative, image=None, additional_cond=(None, None, None)):
+        control_img: Optional[torch.TensorType] = None
+        sd_version = get_sd_version(model)
+        model_url = LAYER_DIFFUSION[method.value][sd_version]["model_url"]
+
+        if image is not None:
+            image = image.movedim(-1, 1)
+
+        try:
+            if hasattr(comfy.lora, "calculate_weight"):
+                comfy.lora.calculate_weight = calculate_weight_adjust_channel(comfy.lora.calculate_weight)
+            else:
+                ModelPatcher.calculate_weight = calculate_weight_adjust_channel(ModelPatcher.calculate_weight)
+        except:
+            pass
+
+        if method in [LayerMethod.FG_ONLY_CONV, LayerMethod.FG_ONLY_ATTN] and sd_version == 'sd1':
+            self.frames = 1
+        elif method in [LayerMethod.BG_TO_BLEND, LayerMethod.FG_TO_BLEND, LayerMethod.BG_BLEND_TO_FG, LayerMethod.FG_BLEND_TO_BG] and sd_version == 'sd1':
+            self.frames = 2
+            batch_size, _, height, width = samples['samples'].shape
+            if batch_size % 2 != 0:
+                raise Exception(f"The batch size should be a multiple of 2. 批次大小需为2的倍数")
+            control_img = image
+        elif method == LayerMethod.EVERYTHING and sd_version == 'sd1':
+            batch_size, _, height, width = samples['samples'].shape
+            self.frames = 3
+            if batch_size % 3 != 0:
+                raise Exception(f"The batch size should be a multiple of 3. 批次大小需为3的倍数")
+        if model_url is None:
+            raise Exception(f"{method.value} is not supported for {sd_version} model")
+
+        model_path = get_local_filepath(model_url, LAYER_DIFFUSION_DIR)
+        layer_lora_state_dict = load_layer_model_state_dict(model_path)
+        work_model = model.clone()
+        if sd_version == 'sd1':
+            patcher = AttentionSharingPatcher(
+                work_model, self.frames, use_control=control_img is not None
+            )
+            patcher.load_state_dict(layer_lora_state_dict, strict=True)
+            if control_img is not None:
+                patcher.set_control(control_img)
+        else:
+            layer_lora_patch_dict = to_lora_patch_dict(layer_lora_state_dict)
+            work_model.add_patches(layer_lora_patch_dict, weight)
+
+        # cond_contact
+        if method in [LayerMethod.FG_ONLY_ATTN, LayerMethod.FG_ONLY_CONV]:
+            samp_model = work_model
+        elif sd_version == 'sdxl':
+            if method in [LayerMethod.BG_TO_BLEND, LayerMethod.FG_TO_BLEND]:
+                c_concat = model.model.latent_format.process_in(samples["samples"])
+            else:
+                c_concat = model.model.latent_format.process_in(torch.cat([samples["samples"], blend_samples["samples"]], dim=1))
+            samp_model, positive, negative = (work_model,) + self.apply_layer_c_concat(positive, negative, c_concat)
+        elif sd_version == 'sd1':
+            if method in [LayerMethod.BG_TO_BLEND, LayerMethod.BG_BLEND_TO_FG]:
+                additional_cond = (additional_cond[0], None)
+            elif method in [LayerMethod.FG_TO_BLEND, LayerMethod.FG_BLEND_TO_BG]:
+                additional_cond = (additional_cond[1], None)
+
+            work_model.model_options.setdefault("transformer_options", {})
+            work_model.model_options["transformer_options"]["cond_overwrite"] = [
+                cond[0][0] if cond is not None else None
+                for cond in additional_cond
+            ]
+            samp_model = work_model
+
+        return samp_model, positive, negative
+
+    def join_image_with_alpha(self, image, alpha):
+        out = image.movedim(-1, 1)
+        if out.shape[1] == 3:  # RGB
+            out = torch.cat([out, torch.ones_like(out[:, :1, :, :])], dim=1)
+        for i in range(out.shape[0]):
+            out[i, 3, :, :] = alpha
+        return out.movedim(1, -1)
+
+    def image_to_alpha(self, image, latent):
+        pixel = image.movedim(-1, 1)  # [B, H, W, C] => [B, C, H, W]
+        decoded = []
+        sub_batch_size = 16
+        for start_idx in range(0, latent.shape[0], sub_batch_size):
+            decoded.append(
+                self.vae_transparent_decoder.decode_pixel(
+                    pixel[start_idx: start_idx + sub_batch_size],
+                    latent[start_idx: start_idx + sub_batch_size],
+                )
+            )
+        pixel_with_alpha = torch.cat(decoded, dim=0)
+        # [B, C, H, W] => [B, H, W, C]
+        pixel_with_alpha = pixel_with_alpha.movedim(1, -1)
+        image = pixel_with_alpha[..., 1:]
+        alpha = pixel_with_alpha[..., 0]
+
+        alpha = 1.0 - alpha
+        new_images, = JoinImageWithAlpha().join_image_with_alpha(image, alpha)
+        return new_images, alpha
+
+    def make_3d_mask(self, mask):
+        if len(mask.shape) == 4:
+            return mask.squeeze(0)
+
+        elif len(mask.shape) == 2:
+            return mask.unsqueeze(0)
+
+        return mask
+
+    def masks_to_list(self, masks):
+        if masks is None:
+            empty_mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
+            return ([empty_mask],)
+
+        res = []
+
+        for mask in masks:
+            res.append(mask)
+
+        return [self.make_3d_mask(x) for x in res]
+
+    def layer_diffusion_decode(self, layer_diffusion_method, latent, blend_samples, samp_images, model):
+        alpha = []
+        if layer_diffusion_method is not None:
+            sd_version = get_sd_version(model)
+            if sd_version not in ['sdxl', 'sd1']:
+                raise Exception(f"Only SDXL and SD1.5 model supported for Layer Diffusion")
+            method = self.get_layer_diffusion_method(layer_diffusion_method, blend_samples is not None)
+            sd15_allow = True if sd_version == 'sd1' and method in [LayerMethod.FG_ONLY_ATTN, LayerMethod.EVERYTHING, LayerMethod.BG_TO_BLEND, LayerMethod.BG_BLEND_TO_FG] else False
+            sdxl_allow = True if sd_version == 'sdxl' and method in [LayerMethod.FG_ONLY_CONV, LayerMethod.FG_ONLY_ATTN, LayerMethod.BG_BLEND_TO_FG] else False
+            if sdxl_allow or sd15_allow:
+                if self.vae_transparent_decoder is None:
+                    model_url = LAYER_DIFFUSION_VAE['decode'][sd_version]["model_url"]
+                    if model_url is None:
+                        raise Exception(f"{method.value} is not supported for {sd_version} model")
+                    decoder_file = get_local_filepath(model_url, LAYER_DIFFUSION_DIR)
+                    self.vae_transparent_decoder = TransparentVAEDecoder(
+                        load_torch_file(decoder_file),
+                        device=comfy.model_management.get_torch_device(),
+                        dtype=(torch.float16 if comfy.model_management.should_use_fp16() else torch.float32),
+                    )
+                if method in [LayerMethod.EVERYTHING, LayerMethod.BG_BLEND_TO_FG, LayerMethod.BG_TO_BLEND]:
+                    new_images = []
+                    sliced_samples = copy.copy({"samples": latent})
+                    for index in range(len(samp_images)):
+                        if index % self.frames == 0:
+                            img = samp_images[index::self.frames]
+                            alpha_images, _alpha = self.image_to_alpha(img, sliced_samples["samples"][index::self.frames])
+                            alpha.append(self.make_3d_mask(_alpha[0]))
+                            new_images.append(alpha_images[0])
+                        else:
+                            new_images.append(samp_images[index])
+                else:
+                    new_images, alpha = self.image_to_alpha(samp_images, latent)
+            else:
+                new_images = samp_images
+        else:
+            new_images = samp_images
+
+
+        return (new_images, samp_images, alpha)
@@ -7,7 +7,6 @@ import einops
 from comfy import model_management, utils
 from comfy.ldm.modules.attention import optimized_attention

-
 module_mapping_sd15 = {
    0: "input_blocks.1.1.transformer_blocks.0.attn1",
    1: "input_blocks.1.1.transformer_blocks.0.attn2",
@@ -1,204 +0,0 @@
-import torch
-import comfy.model_management
-import copy
-from typing import Optional
-from enum import Enum
-from comfy.utils import load_torch_file
-from comfy.conds import CONDRegular
-from comfy_extras.nodes_compositing import JoinImageWithAlpha
-from .model import ModelPatcher, TransparentVAEDecoder, calculate_weight_adjust_channel
-from .attension_sharing import AttentionSharingPatcher
-from ..config import LAYER_DIFFUSION, LAYER_DIFFUSION_DIR, LAYER_DIFFUSION_VAE
-from ..libs.utils import to_lora_patch_dict, get_local_filepath, get_sd_version
-
-load_layer_model_state_dict = load_torch_file
-class LayerMethod(Enum):
-    FG_ONLY_ATTN = "Attention Injection"
-    FG_ONLY_CONV = "Conv Injection"
-    FG_TO_BLEND = "Foreground"
-    FG_BLEND_TO_BG = "Foreground to Background"
-    BG_TO_BLEND = "Background"
-    BG_BLEND_TO_FG = "Background to Foreground"
-    EVERYTHING = "Everything"
-
-class LayerDiffuse:
-
-    def __init__(self) -> None:
-        self.vae_transparent_decoder = None
-        self.frames = 1
-
-    def get_layer_diffusion_method(self, method, has_blend_latent):
-        method = LayerMethod(method)
-        if method == LayerMethod.BG_TO_BLEND and has_blend_latent:
-            method = LayerMethod.BG_BLEND_TO_FG
-        elif method == LayerMethod.FG_TO_BLEND and has_blend_latent:
-            method = LayerMethod.FG_BLEND_TO_BG
-        return method
-
-    def apply_layer_c_concat(self, cond, uncond, c_concat):
-        def write_c_concat(cond):
-            new_cond = []
-            for t in cond:
-                n = [t[0], t[1].copy()]
-                if "model_conds" not in n[1]:
-                    n[1]["model_conds"] = {}
-                n[1]["model_conds"]["c_concat"] = CONDRegular(c_concat)
-                new_cond.append(n)
-            return new_cond
-
-        return (write_c_concat(cond), write_c_concat(uncond))
-
-    def apply_layer_diffusion(self, model: ModelPatcher, method, weight, samples, blend_samples, positive, negative, image=None, additional_cond=(None, None, None)):
-        control_img: Optional[torch.TensorType] = None
-        sd_version = get_sd_version(model)
-        model_url = LAYER_DIFFUSION[method.value][sd_version]["model_url"]
-
-        try:
-            ModelPatcher.calculate_weight = calculate_weight_adjust_channel(ModelPatcher.calculate_weight)
-        except:
-            pass
-
-        if method in [LayerMethod.FG_ONLY_CONV, LayerMethod.FG_ONLY_ATTN] and sd_version == 'sd15':
-            self.frames = 1
-        elif method in [LayerMethod.BG_TO_BLEND, LayerMethod.FG_TO_BLEND, LayerMethod.BG_BLEND_TO_FG, LayerMethod.FG_BLEND_TO_BG] and sd_version == 'sd15':
-            self.frames = 2
-            batch_size, _, height, width = samples['samples'].shape
-            if batch_size % 2 != 0:
-                raise Exception(f"The batch size should be a multiple of 2. 批次大小需为2的倍数")
-            control_img = image
-        elif method == LayerMethod.EVERYTHING and sd_version == 'sd15':
-            batch_size, _, height, width = samples['samples'].shape
-            self.frames = 3
-            if batch_size % 3 != 0:
-                raise Exception(f"The batch size should be a multiple of 3. 批次大小需为3的倍数")
-        if model_url is None:
-            raise Exception(f"{method.value} is not supported for {sd_version} model")
-
-        model_path = get_local_filepath(model_url, LAYER_DIFFUSION_DIR)
-        layer_lora_state_dict = load_layer_model_state_dict(model_path)
-        work_model = model.clone()
-        if sd_version == 'sd15':
-            patcher = AttentionSharingPatcher(
-                work_model, self.frames, use_control=control_img is not None
-            )
-            patcher.load_state_dict(layer_lora_state_dict, strict=True)
-            if control_img is not None:
-                patcher.set_control(control_img)
-        else:
-            layer_lora_patch_dict = to_lora_patch_dict(layer_lora_state_dict)
-            work_model.add_patches(layer_lora_patch_dict, weight)
-
-        # cond_contact
-        if method in [LayerMethod.FG_ONLY_ATTN, LayerMethod.FG_ONLY_CONV]:
-            samp_model = work_model
-        elif sd_version == 'sdxl':
-            if method in [LayerMethod.BG_TO_BLEND, LayerMethod.FG_TO_BLEND]:
-                c_concat = model.model.latent_format.process_in(samples["samples"])
-            else:
-                c_concat = model.model.latent_format.process_in(torch.cat([samples["samples"], blend_samples["samples"]], dim=1))
-            samp_model, positive, negative = (work_model,) + self.apply_layer_c_concat(positive, negative, c_concat)
-        elif sd_version == 'sd15':
-            if method in [LayerMethod.BG_TO_BLEND, LayerMethod.BG_BLEND_TO_FG]:
-                additional_cond = (additional_cond[0], None)
-            elif method in [LayerMethod.FG_TO_BLEND, LayerMethod.FG_BLEND_TO_BG]:
-                additional_cond = (additional_cond[1], None)
-
-            work_model.model_options.setdefault("transformer_options", {})
-            work_model.model_options["transformer_options"]["cond_overwrite"] = [
-                cond[0][0] if cond is not None else None
-                for cond in additional_cond
-            ]
-            samp_model = work_model
-
-        return samp_model, positive, negative
-
-    def join_image_with_alpha(self, image, alpha):
-        out = image.movedim(-1, 1)
-        if out.shape[1] == 3:  # RGB
-            out = torch.cat([out, torch.ones_like(out[:, :1, :, :])], dim=1)
-        for i in range(out.shape[0]):
-            out[i, 3, :, :] = alpha
-        return out.movedim(1, -1)
-
-    def image_to_alpha(self, image, latent):
-        pixel = image.movedim(-1, 1)  # [B, H, W, C] => [B, C, H, W]
-        decoded = []
-        sub_batch_size = 16
-        for start_idx in range(0, latent.shape[0], sub_batch_size):
-            decoded.append(
-                self.vae_transparent_decoder.decode_pixel(
-                    pixel[start_idx: start_idx + sub_batch_size],
-                    latent[start_idx: start_idx + sub_batch_size],
-                )
-            )
-        pixel_with_alpha = torch.cat(decoded, dim=0)
-        # [B, C, H, W] => [B, H, W, C]
-        pixel_with_alpha = pixel_with_alpha.movedim(1, -1)
-        image = pixel_with_alpha[..., 1:]
-        alpha = pixel_with_alpha[..., 0]
-
-        alpha = 1.0 - alpha
-        new_images, = JoinImageWithAlpha().join_image_with_alpha(image, alpha)
-        return new_images, alpha
-
-    def make_3d_mask(self, mask):
-        if len(mask.shape) == 4:
-            return mask.squeeze(0)
-
-        elif len(mask.shape) == 2:
-            return mask.unsqueeze(0)
-
-        return mask
-
-    def masks_to_list(self, masks):
-        if masks is None:
-            empty_mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
-            return ([empty_mask],)
-
-        res = []
-
-        for mask in masks:
-            res.append(mask)
-
-        return [self.make_3d_mask(x) for x in res]
-
-    def layer_diffusion_decode(self, layer_diffusion_method, latent, blend_samples, samp_images, model):
-        alpha = []
-        if layer_diffusion_method is not None:
-            sd_version = get_sd_version(model)
-            if sd_version not in ['sdxl', 'sd15']:
-                raise Exception(f"Only SDXL and SD1.5 model supported for Layer Diffusion")
-            method = self.get_layer_diffusion_method(layer_diffusion_method, blend_samples is not None)
-            sd15_allow = True if sd_version == 'sd15' and method in [LayerMethod.FG_ONLY_ATTN, LayerMethod.EVERYTHING, LayerMethod.BG_TO_BLEND, LayerMethod.BG_BLEND_TO_FG] else False
-            sdxl_allow = True if sd_version == 'sdxl' and method in [LayerMethod.FG_ONLY_CONV, LayerMethod.FG_ONLY_ATTN, LayerMethod.BG_BLEND_TO_FG] else False
-            if sdxl_allow or sd15_allow:
-                if self.vae_transparent_decoder is None:
-                    model_url = LAYER_DIFFUSION_VAE['decode'][sd_version]["model_url"]
-                    if model_url is None:
-                        raise Exception(f"{method.value} is not supported for {sd_version} model")
-                    decoder_file = get_local_filepath(model_url, LAYER_DIFFUSION_DIR)
-                    self.vae_transparent_decoder = TransparentVAEDecoder(
-                        load_torch_file(decoder_file),
-                        device=comfy.model_management.get_torch_device(),
-                        dtype=(torch.float16 if comfy.model_management.should_use_fp16() else torch.float32),
-                    )
-                if method in [LayerMethod.EVERYTHING, LayerMethod.BG_BLEND_TO_FG, LayerMethod.BG_TO_BLEND]:
-                    new_images = []
-                    sliced_samples = copy.copy({"samples": latent})
-                    for index in range(len(samp_images)):
-                        if index % self.frames == 0:
-                            img = samp_images[index::self.frames]
-                            alpha_images, _alpha = self.image_to_alpha(img, sliced_samples["samples"][index::self.frames])
-                            alpha.append(self.make_3d_mask(_alpha[0]))
-                            new_images.append(alpha_images[0])
-                        else:
-                            new_images.append(samp_images[index])
-                else:
-                    new_images, alpha = self.image_to_alpha(samp_images, latent)
-            else:
-                new_images = samp_images
-        else:
-            new_images = samp_images
-
-
-        return (new_images, samp_images, alpha)
@@ -7,18 +7,17 @@ import comfy.model_management
 from comfy.model_patcher import ModelPatcher
 from tqdm import tqdm
 from typing import Optional, Tuple
-
+from ..libs.utils import install_package
+from packaging import version

 try:
+    install_package("diffusers", "0.27.2", True, "0.25.0")
+
    from diffusers.configuration_utils import ConfigMixin, register_to_config
    from diffusers.models.modeling_utils import ModelMixin
    from diffusers import __version__
    if __version__:
-        try:
-            diffusers_version = float(__version__.replace('.', '').replace('dev','.'))
-        except ValueError:
-            diffusers_version = 270
-        if diffusers_version < 270:
+        if version.parse(__version__) < version.parse("0.26.0"):
            from diffusers.models.unet_2d_blocks import UNetMidBlock2D, get_down_block, get_up_block
        else:
            from diffusers.models.unets.unet_2d_blocks import UNetMidBlock2D, get_down_block, get_up_block
@@ -325,9 +324,9 @@ try:
        """Patches ComfyUI's LoRA weight application to accept multi-channel inputs."""
        @functools.wraps(func)
        def calculate_weight(
-                self: ModelPatcher, patches, weight: torch.Tensor, key: str
+            patches, weight: torch.Tensor, key: str, intermediate_type=torch.float32
        ) -> torch.Tensor:
-            weight = func(self, patches, weight, key)
+            weight = func(patches, weight, key, intermediate_type)

            for p in patches:
                alpha = p[0]
@@ -1,12 +1,16 @@
 import torch
 import numpy as np
+import re
 import itertools

 from comfy import model_management
 from comfy.sdxl_clip import SDXLClipModel, SDXLRefinerClipModel, SDXLClipG
-from nodes import NODE_CLASS_MAPPINGS, ConditioningConcat, CLIPTextEncode
+try:
+    from comfy.text_encoders.sd3_clip import SD3ClipModel, T5XXLModel
+except ImportError:
+    from comfy.sd3_clip import SD3ClipModel, T5XXLModel

-from .libs.utils import compare_revision
+from nodes import NODE_CLASS_MAPPINGS, ConditioningConcat, ConditioningZeroOut, ConditioningSetTimestepRange, ConditioningCombine

 def _grouper(n, iterable):
    it = iter(iterable)
@@ -237,17 +241,20 @@ def encode_token_weights_g(model, token_weight_pairs):


 def encode_token_weights_l(model, token_weight_pairs):
-    l_out, _ = model.clip_l.encode_token_weights(token_weight_pairs)
-    return l_out, None
+    l_out, pooled = model.clip_l.encode_token_weights(token_weight_pairs)
+    return l_out, pooled
+
+def encode_token_weights_t5(model, token_weight_pairs):
+    return model.t5xxl.encode_token_weights(token_weight_pairs)


 def encode_token_weights(model, token_weight_pairs, encode_func):
    if model.layer_idx is not None:
        # 2016 [c2cb8e88] 及以上版本去除了sdxl clip的clip_layer方法
-        if compare_revision(2016):
-            model.cond_stage_model.set_clip_options({'layer': model.layer_idx})
-        else:
-            model.cond_stage_model.clip_layer(model.layer_idx)
+        # if compare_revision(2016):
+        model.cond_stage_model.set_clip_options({'layer': model.layer_idx})
+        # else:
+        # model.cond_stage_model.clip_layer(model.layer_idx)

    model_management.load_model_gpu(model.patcher)
    return encode_func(model.cond_stage_model, token_weight_pairs)
@@ -260,6 +267,14 @@ def prepareXL(embs_l, embs_g, pooled, clip_balance):
    else:
        return embs_g, pooled

+def prepareSD3(out, pooled, clip_balance):
+    lg_w = 1 - max(0, clip_balance - .5) * 2
+    t5_w = 1 - max(0, .5 - clip_balance) * 2
+    if out.shape[0] > 1:
+        return torch.cat([out[0] * lg_w, out[1] * t5_w], dim=-1), pooled
+    else:
+        return out, pooled
+
 def advanced_encode(clip, text, token_normalization, weight_interpretation, w_max=1.0, clip_balance=.5,
                    apply_to_pooled=True, width=1024, height=1024, crop_w=0, crop_h=0, target_width=1024, target_height=1024, a1111_prompt_style=False, steps=1):

@@ -272,6 +287,25 @@ def advanced_encode(clip, text, token_normalization, weight_interpretation, w_ma
        else:
            raise Exception(f"[smzNodes Not Found] you need to install 'ComfyUI-smzNodes'")

+    time_start = 0
+    time_end = 1
+    match = re.search(r'TIMESTEP.*$', text)
+    if match:
+        timestep = match.group()
+        timestep = timestep.split(' ')
+        timestep = timestep[0]
+        text = text.replace(timestep, '')
+        value = timestep.split(':')
+        if len(value) >= 3:
+            time_start = float(value[1])
+            time_end = float(value[2])
+        elif len(value) == 2:
+            time_start = float(value[1])
+            time_end = 1
+        elif len(value) == 1:
+            time_start = 0.1
+            time_end = 1
+
    pass3 = [x.strip() for x in text.split("BREAK")]
    pass3 = [x for x in pass3 if x != '']

@@ -285,7 +319,62 @@ def advanced_encode(clip, text, token_normalization, weight_interpretation, w_ma

    for text in pass3:
        tokenized = clip.tokenize(text, return_word_ids=True)
-        if isinstance(clip.cond_stage_model, (SDXLClipModel, SDXLRefinerClipModel, SDXLClipG)):
+        if SD3ClipModel and isinstance(clip.cond_stage_model, SD3ClipModel):
+            lg_out = None
+            pooled = None
+            out = None
+
+            if len(tokenized['l']) > 0 or len(tokenized['g']) > 0:
+                if 'l' in tokenized:
+                    lg_out, l_pooled = advanced_encode_from_tokens(tokenized['l'],
+                                                                           token_normalization,
+                                                                           weight_interpretation,
+                                                                           lambda x: encode_token_weights(clip, x, encode_token_weights_l),
+                                                                           w_max=w_max, return_pooled=True,)
+                else:
+                    l_pooled = torch.zeros((1, 768), device=model_management.intermediate_device())
+
+                if 'g' in tokenized:
+                    g_out, g_pooled = advanced_encode_from_tokens(tokenized['g'],
+                               token_normalization,
+                               weight_interpretation,
+                               lambda x: encode_token_weights(clip, x, encode_token_weights_g),
+                               w_max=w_max, return_pooled=True)
+                    if lg_out is not None:
+                        lg_out = torch.cat([lg_out, g_out], dim=-1)
+                    else:
+                        lg_out = torch.nn.functional.pad(g_out, (768, 0))
+                else:
+                    g_out = None
+                    g_pooled = torch.zeros((1, 1280), device=model_management.intermediate_device())
+
+                if lg_out is not None:
+                    lg_out = torch.nn.functional.pad(lg_out, (0, 4096 - lg_out.shape[-1]))
+                    out = lg_out
+                pooled = torch.cat((l_pooled, g_pooled), dim=-1)
+
+            # t5xxl
+            if 't5xxl' in tokenized and clip.cond_stage_model.t5xxl is not None:
+                t5_out, t5_pooled = advanced_encode_from_tokens(tokenized['t5xxl'],
+                               token_normalization,
+                               weight_interpretation,
+                               lambda x: encode_token_weights(clip, x, encode_token_weights_t5),
+                               w_max=w_max, return_pooled=True)
+                if lg_out is not None:
+                    out = torch.cat([lg_out, t5_out], dim=-2)
+                else:
+                    out = t5_out
+
+            if out is None:
+                out = torch.zeros((1, 77, 4096), device=model_management.intermediate_device())
+
+            if pooled is None:
+                pooled = torch.zeros((1, 768 + 1280), device=model_management.intermediate_device())
+
+            embeddings_final, pooled = prepareSD3(out, pooled, clip_balance)
+            cond = [[embeddings_final, {"pooled_output": pooled}]]
+
+        elif isinstance(clip.cond_stage_model, (SDXLClipModel, SDXLRefinerClipModel, SDXLClipG)):
            embs_l = None
            embs_g = None
            pooled = None
@@ -316,8 +405,8 @@ def advanced_encode(clip, text, token_normalization, weight_interpretation, w_ma
            embeddings_final, pooled = advanced_encode_from_tokens(tokenized['l'],
                                                                   token_normalization,
                                                                   weight_interpretation,
-                                                                   lambda x: (clip.encode_from_tokens({'l': x}), None),
-                                                                   w_max=w_max)
+                                                                   lambda x: encode_token_weights(clip, x, encode_token_weights_l),
+                                                                   w_max=w_max,return_pooled=True,)
            cond = [[embeddings_final, {"pooled_output": pooled}]]

        if conditioning is not None:
@@ -325,6 +414,13 @@ def advanced_encode(clip, text, token_normalization, weight_interpretation, w_ma
        else:
            conditioning = cond

+    # setTimeStepRange
+    if time_start > 0 or time_end < 1:
+        conditioning_2, = ConditioningSetTimestepRange().set_range(conditioning, 0, time_start)
+        conditioning_1, = ConditioningZeroOut().zero_out(conditioning)
+        conditioning_1, = ConditioningSetTimestepRange().set_range(conditioning_1, time_start, time_end)
+        conditioning, = ConditioningCombine().combine(conditioning_1, conditioning_2)
+
    return conditioning


@@ -0,0 +1,115 @@
+import torch
+from PIL import Image
+from torch import Tensor
+from torch.nn import functional as F
+
+from torchvision.transforms import ToTensor, ToPILImage
+
+def adain_color_fix(target: Image, source: Image):
+    # Convert images to tensors
+    to_tensor = ToTensor()
+    target_tensor = to_tensor(target).unsqueeze(0)
+    source_tensor = to_tensor(source).unsqueeze(0)
+
+    # Apply adaptive instance normalization
+    result_tensor = adaptive_instance_normalization(target_tensor, source_tensor)
+
+    # Convert tensor back to image
+    to_image = ToPILImage()
+    result_image = to_image(result_tensor.squeeze(0).clamp_(0.0, 1.0))
+
+    return result_image
+
+def wavelet_color_fix(target: Image, source: Image):
+    source = source.resize(target.size, resample=Image.Resampling.LANCZOS)
+
+    # Convert images to tensors
+    to_tensor = ToTensor()
+    target_tensor = to_tensor(target).unsqueeze(0)
+    source_tensor = to_tensor(source).unsqueeze(0)
+
+    # Apply wavelet reconstruction
+    result_tensor = wavelet_reconstruction(target_tensor, source_tensor)
+
+    # Convert tensor back to image
+    to_image = ToPILImage()
+    result_image = to_image(result_tensor.squeeze(0).clamp_(0.0, 1.0))
+
+    return result_image
+
+def calc_mean_std(feat: Tensor, eps=1e-5):
+    """Calculate mean and std for adaptive_instance_normalization.
+    Args:
+        feat (Tensor): 4D tensor.
+        eps (float): A small value added to the variance to avoid
+            divide-by-zero. Default: 1e-5.
+    """
+    size = feat.size()
+    assert len(size) == 4, 'The input feature should be 4D tensor.'
+    b, c = size[:2]
+    feat_var = feat.view(b, c, -1).var(dim=2) + eps
+    feat_std = feat_var.sqrt().view(b, c, 1, 1)
+    feat_mean = feat.view(b, c, -1).mean(dim=2).view(b, c, 1, 1)
+    return feat_mean, feat_std
+
+def adaptive_instance_normalization(content_feat:Tensor, style_feat:Tensor):
+    """Adaptive instance normalization.
+    Adjust the reference features to have the similar color and illuminations
+    as those in the degradate features.
+    Args:
+        content_feat (Tensor): The reference feature.
+        style_feat (Tensor): The degradate features.
+    """
+    size = content_feat.size()
+    style_mean, style_std = calc_mean_std(style_feat)
+    content_mean, content_std = calc_mean_std(content_feat)
+    normalized_feat = (content_feat - content_mean.expand(size)) / content_std.expand(size)
+    return normalized_feat * style_std.expand(size) + style_mean.expand(size)
+
+def wavelet_blur(image: Tensor, radius: int):
+    """
+    Apply wavelet blur to the input tensor.
+    """
+    # input shape: (1, 3, H, W)
+    # convolution kernel
+    kernel_vals = [
+        [0.0625, 0.125, 0.0625],
+        [0.125, 0.25, 0.125],
+        [0.0625, 0.125, 0.0625],
+    ]
+    kernel = torch.tensor(kernel_vals, dtype=image.dtype, device=image.device)
+    # add channel dimensions to the kernel to make it a 4D tensor
+    kernel = kernel[None, None]
+    # repeat the kernel across all input channels
+    kernel = kernel.repeat(3, 1, 1, 1)
+    image = F.pad(image, (radius, radius, radius, radius), mode='replicate')
+    # apply convolution
+    output = F.conv2d(image, kernel, groups=3, dilation=radius)
+    return output
+
+def wavelet_decomposition(image: Tensor, levels=5):
+    """
+    Apply wavelet decomposition to the input tensor.
+    This function only returns the low frequency & the high frequency.
+    """
+    high_freq = torch.zeros_like(image)
+    for i in range(levels):
+        radius = 2 ** i
+        low_freq = wavelet_blur(image, radius)
+        high_freq += (image - low_freq)
+        image = low_freq
+
+    return high_freq, low_freq
+
+def wavelet_reconstruction(content_feat:Tensor, style_feat:Tensor):
+    """
+    Apply wavelet decomposition, so that the content will have the same color as the style.
+    """
+    # calculate the wavelet decomposition of the content feature
+    content_high_freq, content_low_freq = wavelet_decomposition(content_feat)
+    del content_low_freq
+    # calculate the wavelet decomposition of the style feature
+    style_high_freq, style_low_freq = wavelet_decomposition(style_feat)
+    del style_high_freq
+    # reconstruct the content feature with the style's high frequency
+    return content_high_freq + style_low_freq
@@ -1,14 +1,26 @@
 from .utils import find_wildcards_seed, find_nearest_steps, is_linked_styles_selector
-from ..log import log_node_warn
-from ..adv_encode import advanced_encode
-from ..wildcards import process_with_loras
+from .log import log_node_warn
+from .translate import zh_to_en, has_chinese
+from .wildcards import process_with_loras
+from .adv_encode import advanced_encode

-from nodes import ConditioningConcat, ConditioningCombine, ConditioningAverage, ConditioningSetTimestepRange
+from nodes import ConditioningConcat, ConditioningCombine, ConditioningAverage, ConditioningSetTimestepRange, CLIPTextEncode

-def prompt_to_cond(type, model, clip, clip_skip, lora_stack, text, prompt_token_normalization, prompt_weight_interpretation, a1111_prompt_style ,my_unique_id, prompt, easyCache, can_load_lora=True, steps=None):
+def prompt_to_cond(type, model, clip, clip_skip, lora_stack, text, prompt_token_normalization, prompt_weight_interpretation, a1111_prompt_style ,my_unique_id, prompt, easyCache, can_load_lora=True, steps=None, model_type=None):
    styles_selector = is_linked_styles_selector(prompt, my_unique_id, type)
    title = "正面提示词" if type == 'positive' else "负面提示词"
-    log_node_warn("正在处理" + title + "...")
+    log_node_warn("正在进行" + title + "...")
+
+    if model_type in ['hydit', 'flux']:
+        if model_type == 'flux':
+            text = zh_to_en([text])[0] if has_chinese(text) else text
+        embeddings_final, = CLIPTextEncode().encode(clip, text)
+        return (embeddings_final, "", model, clip)
+
+    # Translate cn to en
+    if has_chinese(text):
+        text = zh_to_en([text])[0]
+
    positive_seed = find_wildcards_seed(my_unique_id, text, prompt)
    model, clip, text, cond_decode, show_prompt, pipe_lora_stack = process_with_loras(
        text, model, clip, type, positive_seed, can_load_lora, lora_stack, easyCache)
@@ -18,7 +30,7 @@ def prompt_to_cond(type, model, clip, clip_skip, lora_stack, text, prompt_token_
    if clip_skip != 0:
        clipped.clip_layer(clip_skip)

-    log_node_warn("正在处理" + title + "编码...")
+    log_node_warn("正在进行" + title + "编码...")
    steps = steps if steps is not None else find_nearest_steps(my_unique_id, prompt)
    return (advanced_encode(clipped, text, prompt_token_normalization,
                            prompt_weight_interpretation, w_max=1.0,
@@ -3,30 +3,36 @@ import comfy.controlnet
 import comfy.model_management
 from nodes import NODE_CLASS_MAPPINGS

+union_controlnet_types = {"auto": -1, "openpose": 0, "depth": 1, "hed/pidi/scribble/ted": 2, "canny/lineart/anime_lineart/mlsd": 3, "normal": 4, "segment": 5, "tile": 6, "repaint": 7}
+
 class easyControlnet:
    def __init__(self):
        pass

-    def load_controlnet(self, control_net_name, control_net, scale_soft_weights):
-        if control_net is None:
-            if scale_soft_weights < 1:
-                if "ScaledSoftControlNetWeights" in NODE_CLASS_MAPPINGS:
-                    soft_weight_cls = NODE_CLASS_MAPPINGS['ScaledSoftControlNetWeights']
-                    (weights, timestep_keyframe) = soft_weight_cls().load_weights(scale_soft_weights, False)
-                    cn_adv_cls = NODE_CLASS_MAPPINGS['ControlNetLoaderAdvanced']
-                    control_net, = cn_adv_cls().load_controlnet(control_net_name, timestep_keyframe)
-                else:
-                    raise Exception(f"[Advanced-ControlNet Not Found] you need to install 'COMFYUI-Advanced-ControlNet'")
-            else:
-                controlnet_path = folder_paths.get_full_path("controlnet", control_net_name)
-                control_net = comfy.controlnet.load_controlnet(controlnet_path)
-        return control_net
-
-    def apply(self, control_net_name, image, positive, negative, strength, start_percent=0, end_percent=1, control_net=None, scale_soft_weights=1, mask=None):
+    def apply(self, control_net_name, image, positive, negative, strength, start_percent=0, end_percent=1, control_net=None, scale_soft_weights=1, mask=None, union_type=None, easyCache=None, use_cache=True, model=None, vae=None):
        if strength == 0:
            return (positive, negative)

-        control_net = self.load_controlnet(control_net_name, control_net, scale_soft_weights)
+        # kolors controlnet patch
+        from ..kolors.loader import is_kolors_model, applyKolorsUnet
+        if is_kolors_model(model):
+            from ..kolors.model_patch import patch_controlnet
+            if control_net is None:
+                with applyKolorsUnet():
+                    control_net = easyCache.load_controlnet(control_net_name, scale_soft_weights, use_cache)
+                control_net = patch_controlnet(model, control_net)
+        else:
+            if control_net is None:
+                control_net = easyCache.load_controlnet(control_net_name, scale_soft_weights, use_cache)
+
+        # union controlnet
+        if union_type is not None:
+            control_net = control_net.copy()
+            type_number = union_controlnet_types[union_type]
+            if type_number >= 0:
+                control_net.set_extra_arg("control_type", [type_number])
+            else:
+                control_net.set_extra_arg("control_type", [])

        if mask is not None:
            mask = mask.to(self.device)
@@ -63,7 +69,7 @@ class easyControlnet:
                    if prev_cnet in cnets:
                        c_net = cnets[prev_cnet]
                    else:
-                        c_net = control_net.copy().set_cond_hint(control_hint, strength, (start_percent, end_percent))
+                        c_net = control_net.copy().set_cond_hint(control_hint, strength, (start_percent, end_percent), vae)
                        c_net.set_previous_controlnet(prev_cnet)
                        cnets[prev_cnet] = c_net

@@ -1,7 +1,14 @@
+import os
+import base64
 import torch
 import numpy as np
 from enum import Enum
 from PIL import Image
+from io import BytesIO
+from typing import List, Union
+
+import folder_paths
+from .utils import install_package

 # PIL to Tensor
 def pil2tensor(image):
@@ -9,6 +16,28 @@ def pil2tensor(image):
 # Tensor to PIL
 def tensor2pil(image):
    return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+# np to Tensor
+def np2tensor(img_np: Union[np.ndarray, List[np.ndarray]]) -> torch.Tensor:
+  if isinstance(img_np, list):
+    return torch.cat([np2tensor(img) for img in img_np], dim=0)
+  return torch.from_numpy(img_np.astype(np.float32) / 255.0).unsqueeze(0)
+# Tensor to np
+def tensor2np(tensor: torch.Tensor) -> List[np.ndarray]:
+  if len(tensor.shape) == 3:  # Single image
+    return np.clip(255.0 * tensor.cpu().numpy(), 0, 255).astype(np.uint8)
+  else:  # Batch of images
+    return [np.clip(255.0 * t.cpu().numpy(), 0, 255).astype(np.uint8) for t in tensor]
+
+def pil2byte(pil_image, format='PNG'):
+  byte_arr = BytesIO()
+  pil_image.save(byte_arr, format=format)
+  byte_arr.seek(0)
+  return byte_arr
+
+def image2base64(image_base64):
+    image_bytes = base64.b64decode(image_base64)
+    image_data = Image.open(BytesIO(image_bytes))
+    return image_data

 # Get new bounds
 def get_new_bounds(width, height, left, right, top, bottom):
@@ -19,6 +48,64 @@ def get_new_bounds(width, height, left, right, top, bottom):
  bottom = height - bottom
  return (left, right, top, bottom)

+def RGB2RGBA(image: Image, mask: Image) -> Image:
+  (R, G, B) = image.convert('RGB').split()
+  return Image.merge('RGBA', (R, G, B, mask.convert('L')))
+
+def image2mask(image: Image) -> torch.Tensor:
+  _image = image.convert('RGBA')
+  alpha = _image.split()[0]
+  bg = Image.new("L", _image.size)
+  _image = Image.merge('RGBA', (bg, bg, bg, alpha))
+  ret_mask = torch.tensor([pil2tensor(_image)[0, :, :, 3].tolist()])
+  return ret_mask
+
+def mask2image(mask: torch.Tensor) -> Image:
+  masks = tensor2np(mask)
+  for m in masks:
+    _mask = Image.fromarray(m).convert("L")
+    _image = Image.new("RGBA", _mask.size, color='white')
+    _image = Image.composite(
+      _image, Image.new("RGBA", _mask.size, color='black'), _mask)
+  return _image
+
+# 图像融合
+class blendImage:
+  def g(self, x):
+    return torch.where(x <= 0.25, ((16 * x - 12) * x + 4) * x, torch.sqrt(x))
+
+  def blend_mode(self, img1, img2, mode):
+    if mode == "normal":
+      return img2
+    elif mode == "multiply":
+      return img1 * img2
+    elif mode == "screen":
+      return 1 - (1 - img1) * (1 - img2)
+    elif mode == "overlay":
+      return torch.where(img1 <= 0.5, 2 * img1 * img2, 1 - 2 * (1 - img1) * (1 - img2))
+    elif mode == "soft_light":
+      return torch.where(img2 <= 0.5, img1 - (1 - 2 * img2) * img1 * (1 - img1),
+                         img1 + (2 * img2 - 1) * (self.g(img1) - img1))
+    elif mode == "difference":
+      return img1 - img2
+    else:
+      raise ValueError(f"Unsupported blend mode: {mode}")
+
+  def blend_images(self, image1: torch.Tensor, image2: torch.Tensor, blend_factor: float, blend_mode: str = 'normal'):
+    image2 = image2.to(image1.device)
+    if image1.shape != image2.shape:
+      image2 = image2.permute(0, 3, 1, 2)
+      image2 = comfy.utils.common_upscale(image2, image1.shape[2], image1.shape[1], upscale_method='bicubic',
+                                          crop='center')
+      image2 = image2.permute(0, 2, 3, 1)
+
+    blended_image = self.blend_mode(image1, image2, blend_mode)
+    blended_image = image1 * (1 - blend_factor) + blended_image * blend_factor
+    blended_image = torch.clamp(blended_image, 0, 1)
+    return blended_image
+
+
+

 class ResizeMode(Enum):
  RESIZE = "Just Resize"
@@ -33,3 +120,75 @@ class ResizeMode(Enum):
      return 2
    assert False, "NOTREACHED"

+
+
+# CLIP反推
+import comfy.utils
+from torchvision import transforms
+Config, Interrogator = None, None
+class CI_Inference:
+  ci_model = None
+  cache_path: str
+
+  def __init__(self):
+    self.ci_model = None
+    self.low_vram = False
+    self.cache_path = os.path.join(folder_paths.models_dir, "clip_interrogator")
+
+  def _load_model(self, model_name, low_vram=False):
+    if not (self.ci_model and model_name == self.ci_model.config.clip_model_name and self.low_vram == low_vram):
+      self.low_vram = low_vram
+      print(f"Load model: {model_name}")
+
+      config = Config(
+        device="cuda" if torch.cuda.is_available() else "cpu",
+        download_cache=True,
+        clip_model_name=model_name,
+        clip_model_path=self.cache_path,
+        cache_path=self.cache_path,
+        caption_model_name='blip-large'
+      )
+
+      if low_vram:
+        config.apply_low_vram_defaults()
+
+      self.ci_model = Interrogator(config)
+
+  def _interrogate(self, image, mode, caption=None):
+    if mode == 'best':
+      prompt = self.ci_model.interrogate(image, caption=caption)
+    elif mode == 'classic':
+      prompt = self.ci_model.interrogate_classic(image, caption=caption)
+    elif mode == 'fast':
+      prompt = self.ci_model.interrogate_fast(image, caption=caption)
+    elif mode == 'negative':
+      prompt = self.ci_model.interrogate_negative(image)
+    else:
+      raise Exception(f"Unknown mode {mode}")
+    return prompt
+
+  def image_to_prompt(self, image, mode, model_name='ViT-L-14/openai', low_vram=False):
+    try:
+      from clip_interrogator import Config, Interrogator
+      global Config, Interrogator
+    except:
+      install_package("clip_interrogator", "0.6.0")
+      from clip_interrogator import Config, Interrogator
+
+    pbar = comfy.utils.ProgressBar(len(image))
+
+    self._load_model(model_name, low_vram)
+    prompt = []
+    for i in range(len(image)):
+      im = image[i]
+
+      im = tensor2pil(im)
+      im = im.convert('RGB')
+
+      _prompt = self._interrogate(im, mode)
+      pbar.update(1)
+      prompt.append(_prompt)
+
+    return prompt
+
+ci = CI_Inference()
@@ -1,16 +1,23 @@
-import time, os, psutil
+import re, time, os, psutil
+import folder_paths
 import comfy.utils
 import comfy.sd
-import folder_paths
+import comfy.controlnet
+
+from comfy.model_patcher import ModelPatcher
 from nodes import NODE_CLASS_MAPPINGS
 from collections import defaultdict
-from ..log import log_node_info, log_node_error
+from .log import log_node_info, log_node_error
+from ..dit.pixArt.loader import load_pixart

-stable_diffusion_loaders = ["easy a1111Loader", "easy comfyLoader", "easy zero123Loader", "easy svdLoader"]
+stable_diffusion_loaders = ["easy fullLoader", "easy a1111Loader", "easy comfyLoader", "easy hunyuanDiTLoader","easy zero123Loader", "easy svdLoader"]
 stable_cascade_loaders = ["easy cascadeLoader"]
+dit_loaders = ['easy pixArtLoader']
+controlnet_loaders = ["easy controlnetLoader", "easy controlnetLoaderADV"]
+instant_loaders = ["easy instantIDApply", "easy instantIDApplyADV"]
 cascade_vae_node = ["easy preSamplingCascade", "easy fullCascadeKSampler"]
 model_merge_node = ["easy XYInputs: ModelMergeBlocks"]
-lora_widget = ["easy a1111Loader", "easy comfyLoader"]
+lora_widget = ["easy fullLoader", "easy a1111Loader", "easy comfyLoader"]

 class easyLoader:
    def __init__(self):
@@ -22,6 +29,9 @@ class easyLoader:
            "bvae": defaultdict(tuple),
            "vae": defaultdict(object),
            "lora": defaultdict(dict),  # {lora_name: {UID: (model_lora, clip_lora)}}
+            "controlnet": defaultdict(dict),
+            "t5": defaultdict(tuple),
+            "chatglm3": defaultdict(tuple),
        }
        self.memory_threshold = self.determine_memory_threshold(0.7)
        self.lora_name_cache = []
@@ -50,9 +60,17 @@ class easyLoader:
        for key in keys - desired_names:
            del self.loaded_objects[object_type][key]

-    def get_input_value(self, entry, key):
+    def get_input_value(self, entry, key, prompt=None):
        val = entry["inputs"][key]
-        return val if isinstance(val, str) else val[0]
+        if isinstance(val, str):
+            return val
+        elif isinstance(val, list):
+            if prompt is not None and val[0]:
+                return prompt[val[0]]['inputs'][key]
+            else:
+                return val[0]
+        else:
+            return str(val)

    def process_pipe_loader(self, entry, desired_ckpt_names, desired_vae_names, desired_lora_names, desired_lora_settings, num_loras=3, suffix=""):
        for idx in range(1, num_loras + 1):
@@ -71,10 +89,12 @@ class easyLoader:
        desired_vae_names = set()
        desired_lora_names = set()
        desired_lora_settings = set()
+        desired_controlnet_names = set()
+        desired_t5_names = set()
+        desired_glm3_names = set()

        for entry in prompt.values():
            class_type = entry["class_type"]
-
            if class_type in lora_widget:
                lora_name = self.get_input_value(entry, "lora_name")
                desired_lora_names.add(lora_name)
@@ -82,9 +102,25 @@ class easyLoader:
                desired_lora_settings.add(setting)

            if class_type in stable_diffusion_loaders:
-                desired_ckpt_names.add(self.get_input_value(entry, "ckpt_name"))
+                desired_ckpt_names.add(self.get_input_value(entry, "ckpt_name", prompt))
                desired_vae_names.add(self.get_input_value(entry, "vae_name"))

+            elif class_type in ['easy kolorsLoader']:
+                desired_unet_names.add(self.get_input_value(entry, "unet_name"))
+                desired_vae_names.add(self.get_input_value(entry, "vae_name"))
+                desired_glm3_names.add(self.get_input_value(entry, "chatglm3_name"))
+
+            elif class_type in dit_loaders:
+                t5_name = self.get_input_value(entry, "mt5_name") if "mt5_name" in entry["inputs"] else  None
+                clip_name = self.get_input_value(entry, "clip_name") if "clip_name" in entry["inputs"] else None
+                model_name = self.get_input_value(entry, "model_name")
+                ckpt_name = self.get_input_value(entry, "ckpt_name", prompt)
+                if t5_name:
+                    desired_t5_names.add(t5_name)
+                if clip_name:
+                    desired_clip_names.add(clip_name)
+                desired_ckpt_names.add(ckpt_name+'_'+model_name)
+
            elif class_type in stable_cascade_loaders:
                desired_unet_names.add(self.get_input_value(entry, "stage_c"))
                desired_unet_names.add(self.get_input_value(entry, "stage_b"))
@@ -99,6 +135,16 @@ class easyLoader:
                if decode_vae_name and decode_vae_name != 'None':
                    desired_vae_names.add(decode_vae_name)

+            elif class_type in controlnet_loaders:
+                control_net_name = self.get_input_value(entry, "control_net_name", prompt)
+                scale_soft_weights = self.get_input_value(entry, "scale_soft_weights")
+                desired_controlnet_names.add(f'{control_net_name};{scale_soft_weights}')
+
+            elif class_type in instant_loaders:
+                control_net_name = self.get_input_value(entry, "control_net_name", prompt)
+                scale_soft_weights = self.get_input_value(entry, "cn_soft_weights")
+                desired_controlnet_names.add(f'{control_net_name};{scale_soft_weights}')
+
            elif class_type in model_merge_node:
                desired_ckpt_names.add(self.get_input_value(entry, "ckpt_name_1"))
                desired_ckpt_names.add(self.get_input_value(entry, "ckpt_name_2"))
@@ -106,7 +152,7 @@ class easyLoader:
                if vae_use != 'Use Model 1' and vae_use != 'Use Model 2':
                    desired_vae_names.add(vae_use)

-        object_types = ["ckpt", "unet", "clip", "bvae", "vae", "lora"]
+        object_types = ["ckpt", "unet", "clip", "bvae", "vae", "lora", "controlnet", "t5"]
        for object_type in object_types:
            if object_type == 'unet':
                desired_names = desired_unet_names
@@ -117,6 +163,12 @@ class easyLoader:
                    desired_names = desired_ckpt_names
            elif object_type == "vae":
                desired_names = desired_vae_names
+            elif object_type == "controlnet":
+                desired_names = desired_controlnet_names
+            elif object_type == "t5":
+                desired_names = desired_t5_names
+            elif object_type == "chatglm3":
+                desired_names = desired_glm3_names
            else:
                desired_names = desired_lora_names
            self.clear_unused_objects(desired_names, object_type)
@@ -155,7 +207,7 @@ class easyLoader:
        current_memory = self.get_memory_usage()
        if current_memory < self.memory_threshold:
            return
-        eviction_order = ["vae", "lora", "bvae", "clip", "ckpt"]
+        eviction_order = ["vae", "lora", "bvae", "clip", "ckpt", "controlnet", "unet", "t5", "chatglm3"]
        for obj_type in eviction_order:
            if current_memory < self.memory_threshold:
                break
@@ -186,7 +238,11 @@ class easyLoader:
            config_path = folder_paths.get_full_path("configs", config_name)
            loaded_ckpt = comfy.sd.load_checkpoint(config_path, ckpt_path, output_vae=True, output_clip=output_clip, embedding_directory=folder_paths.get_folder_paths("embeddings"))
        else:
-            loaded_ckpt = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=output_clip, output_clipvision=output_clipvision, embedding_directory=folder_paths.get_folder_paths("embeddings"))
+            model_options = {}
+            if re.search("nf4", ckpt_name):
+                from ..bitsandbytes_NF4 import OPS
+                model_options = {"custom_operations": OPS}
+            loaded_ckpt = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=output_clip, output_clipvision=output_clipvision, embedding_directory=folder_paths.get_folder_paths("embeddings"), model_options=model_options)

        self.add_to_cache("ckpt", cache_name, loaded_ckpt[0])
        self.add_to_cache("bvae", cache_name, loaded_ckpt[2])
@@ -216,6 +272,7 @@ class easyLoader:

    def load_unet(self, unet_name):
        if unet_name in self.loaded_objects["unet"]:
+            log_node_info("Load UNet", f"{unet_name} cached")
            return self.loaded_objects["unet"][unet_name][0]

        unet_path = folder_paths.get_full_path("unet", unet_name)
@@ -225,11 +282,40 @@ class easyLoader:

        return model

-    def load_clip(self, clip_name, type='stable_diffusion'):
+    def load_controlnet(self, control_net_name, scale_soft_weights=1, use_cache=True):
+        unique_id = f'{control_net_name};{str(scale_soft_weights)}'
+        if use_cache and unique_id in self.loaded_objects["controlnet"]:
+            return self.loaded_objects["controlnet"][unique_id][0]
+        if scale_soft_weights < 1:
+            if "ScaledSoftControlNetWeights" in NODE_CLASS_MAPPINGS:
+                soft_weight_cls = NODE_CLASS_MAPPINGS['ScaledSoftControlNetWeights']
+                (weights, timestep_keyframe) = soft_weight_cls().load_weights(scale_soft_weights, False)
+                cn_adv_cls = NODE_CLASS_MAPPINGS['ControlNetLoaderAdvanced']
+                control_net, = cn_adv_cls().load_controlnet(control_net_name, timestep_keyframe)
+            else:
+                raise Exception(f"[Advanced-ControlNet Not Found] you need to install 'COMFYUI-Advanced-ControlNet'")
+        else:
+            controlnet_path = folder_paths.get_full_path("controlnet", control_net_name)
+            control_net = comfy.controlnet.load_controlnet(controlnet_path)
+        if use_cache:
+            self.add_to_cache("controlnet", unique_id, control_net)
+            self.eviction_based_on_memory()
+
+        return control_net
+    def load_clip(self, clip_name, type='stable_diffusion', load_clip=None):
+        if clip_name in self.loaded_objects["clip"]:
+            return self.loaded_objects["clip"][clip_name][0]
+
        if type == 'stable_diffusion':
            clip_type = comfy.sd.CLIPType.STABLE_DIFFUSION
-        else:
+        elif type == 'stable_cascade':
            clip_type = comfy.sd.CLIPType.STABLE_CASCADE
+        elif type == 'sd3':
+            clip_type = comfy.sd.CLIPType.SD3
+        elif type == 'flux':
+            clip_type = comfy.sd.CLIPType.FLUX
+        elif type == 'stable_audio':
+            clip_type = comfy.sd.CLIPType.STABLE_AUDIO
        clip_path = folder_paths.get_full_path("clip", clip_name)
        load_clip = comfy.sd.load_clip(ckpt_paths=[clip_path], embedding_directory=folder_paths.get_folder_paths("embeddings"), clip_type=clip_type)
        self.add_to_cache("clip", clip_name, load_clip)
@@ -237,7 +323,7 @@ class easyLoader:

        return load_clip

-    def load_lora(self, lora, model=None, clip=None):
+    def load_lora(self, lora, model=None, clip=None, type=None):
        lora_name = lora["lora_name"]
        model = model if model is not None else lora["model"]
        clip = clip if clip is not None else lora["clip"]
@@ -248,11 +334,12 @@ class easyLoader:
        lbw_b = lora["lbw_b"] if "lbw_b" in lora else None

        model_hash = str(model)[44:-1]
-        clip_hash = str(clip)[25:-1]
+        clip_hash = str(clip)[25:-1] if clip else ''

        unique_id = f'{model_hash};{clip_hash};{lora_name};{model_strength};{clip_strength}'

-        if unique_id in self.loaded_objects["lora"] and unique_id in self.loaded_objects["lora"][lora_name]:
+        if unique_id in self.loaded_objects["lora"]:
+            log_node_info("Load LORA",f"{lora_name} cached")
            return self.loaded_objects["lora"][unique_id][0]

        orig_lora_name = lora_name
@@ -302,7 +389,12 @@ class easyLoader:
                    model.model.load_state_dict(mapping_norm, strict=False)
                    return (model, clip)

-                model, clip = comfy.sd.load_lora_for_models(model, clip, _lora, model_strength, clip_strength)
+                # PixArt
+                if type is not None and type == 'PixArt':
+                    from ..dit.pixArt.loader import load_pixart_lora
+                    model = load_pixart_lora(model, _lora, lora_path, model_strength)
+                else:
+                    model, clip = comfy.sd.load_lora_for_models(model, clip, _lora, model_strength, clip_strength)

            self.add_to_cache("lora", unique_id, (model, clip))
            self.eviction_based_on_memory()
@@ -330,4 +422,188 @@ class easyLoader:
                    self.lora_name_cache.append(x)
                    return x

-            return None
+            return None
+
+    def load_main(self, ckpt_name, config_name, vae_name, lora_name, lora_model_strength, lora_clip_strength, optional_lora_stack, model_override, clip_override, vae_override, prompt, nf4=False):
+        model: ModelPatcher | None = None
+        clip: comfy.sd.CLIP | None = None
+        vae: comfy.sd.VAE | None = None
+        clip_vision = None
+        lora_stack = []
+
+        can_load_lora = True
+        # 判断是否存在 模型或Lora叠加xyplot, 若存在优先缓存第一个模型
+        xy_model_id = next((x for x in prompt if str(prompt[x]["class_type"]) in ["easy XYInputs: ModelMergeBlocks",
+                                                                                  "easy XYInputs: Checkpoint"]), None)
+        xy_lora_id = next((x for x in prompt if str(prompt[x]["class_type"]) == "easy XYInputs: Lora"), None)
+        if xy_lora_id is not None:
+            can_load_lora = False
+        if xy_model_id is not None:
+            node = prompt[xy_model_id]
+            if "ckpt_name_1" in node["inputs"]:
+                ckpt_name_1 = node["inputs"]["ckpt_name_1"]
+                model, clip, vae, clip_vision = self.load_checkpoint(ckpt_name_1)
+                can_load_lora = False
+        # Load models
+        elif model_override is not None and clip_override is not None and vae_override is not None:
+            model = model_override
+            clip = clip_override
+            vae = vae_override
+        elif model_override is not None:
+            raise Exception(f"[ERROR] clip or vae is missing")
+        elif vae_override is not None:
+            raise Exception(f"[ERROR] model or clip is missing")
+        elif clip_override is not None:
+            raise Exception(f"[ERROR] model or vae is missing")
+        else:
+            model, clip, vae, clip_vision = self.load_checkpoint(ckpt_name, config_name)
+
+        if optional_lora_stack is not None and can_load_lora:
+            for lora in optional_lora_stack:
+                lora = {"lora_name": lora[0], "model": model, "clip": clip, "model_strength": lora[1],
+                        "clip_strength": lora[2]}
+                model, clip = self.load_lora(lora)
+                lora['model'] = model
+                lora['clip'] = clip
+                lora_stack.append(lora)
+
+        if lora_name != "None" and can_load_lora:
+            lora = {"lora_name": lora_name, "model": model, "clip": clip, "model_strength": lora_model_strength,
+                    "clip_strength": lora_clip_strength}
+            model, clip = self.load_lora(lora)
+            lora_stack.append(lora)
+
+        # Check for custom VAE
+        if vae_name not in ["Baked VAE", "Baked-VAE"]:
+            vae = self.load_vae(vae_name)
+        # CLIP skip
+        if not clip:
+            raise Exception("No CLIP found")
+
+        return model, clip, vae, clip_vision, lora_stack
+
+    # Kolors
+    def load_kolors_unet(self, unet_name):
+        if unet_name in self.loaded_objects["unet"]:
+            log_node_info("Load Kolors UNet", f"{unet_name} cached")
+            return self.loaded_objects["unet"][unet_name][0]
+        else:
+            from ..kolors.loader import applyKolorsUnet
+            with applyKolorsUnet():
+                unet_path = folder_paths.get_full_path("unet", unet_name)
+                sd = comfy.utils.load_torch_file(unet_path)
+                model = comfy.sd.load_unet_state_dict(sd)
+                if model is None:
+                    raise RuntimeError("ERROR: Could not detect model type of: {}".format(unet_path))
+
+                self.add_to_cache("unet", unet_name, model)
+                self.eviction_based_on_memory()
+
+                return model
+
+    def load_chatglm3(self, chatglm3_name):
+        from ..kolors.loader import load_chatglm3
+        if chatglm3_name in self.loaded_objects["chatglm3"]:
+            log_node_info("Load ChatGLM3", f"{chatglm3_name} cached")
+            return self.loaded_objects["chatglm3"][chatglm3_name][0]
+
+        chatglm_model = load_chatglm3(model_path=folder_paths.get_full_path("llm", chatglm3_name))
+        self.add_to_cache("chatglm3", chatglm3_name, chatglm_model)
+        self.eviction_based_on_memory()
+
+        return chatglm_model
+
+
+    # DiT
+    def load_dit_ckpt(self, ckpt_name, model_name, **kwargs):
+        if (ckpt_name+'_'+model_name) in self.loaded_objects["ckpt"]:
+            return self.loaded_objects["ckpt"][ckpt_name+'_'+model_name][0]
+        model = None
+        ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name)
+        model_type = kwargs['model_type'] if "model_type" in kwargs else 'PixArt'
+        if model_type == 'PixArt':
+            pixart_conf = kwargs['pixart_conf']
+            model_conf = pixart_conf[model_name]
+            model = load_pixart(ckpt_path, model_conf)
+        if model:
+            self.add_to_cache("ckpt", ckpt_name + '_' + model_name, model)
+            self.eviction_based_on_memory()
+        return model
+
+
+    def load_dit_clip(self, clip_name, **kwargs):
+        if clip_name in self.loaded_objects["clip"]:
+            return self.loaded_objects["clip"][clip_name][0]
+
+        clip_path = folder_paths.get_full_path("clip", clip_name)
+        sd = comfy.utils.load_torch_file(clip_path)
+
+        prefix = "bert."
+        state_dict = {}
+        for key in sd:
+            nkey = key
+            if key.startswith(prefix):
+                nkey = key[len(prefix):]
+            state_dict[nkey] = sd[key]
+
+        m, e = model.load_sd(state_dict)
+        if len(m) > 0 or len(e) > 0:
+            print(f"{clip_name}: clip missing {len(m)} keys ({len(e)} extra)")
+
+        self.add_to_cache("clip", clip_name, model)
+        self.eviction_based_on_memory()
+
+        return model
+
+    def load_dit_t5(self, t5_name, **kwargs):
+        if t5_name in self.loaded_objects["t5"]:
+            return self.loaded_objects["t5"][t5_name][0]
+
+        model_type = kwargs['model_type'] if "model_type" in kwargs else 'HyDiT'
+        if model_type == 'HyDiT':
+            del kwargs['model_type']
+            model = EXM_HyDiT_Tenc_Temp(model_class="mT5", **kwargs)
+        t5_path = folder_paths.get_full_path("t5", t5_name)
+        sd = comfy.utils.load_torch_file(t5_path)
+        m, e = model.load_sd(sd)
+        if len(m) > 0 or len(e) > 0:
+            print(f"{t5_name}: mT5 missing {len(m)} keys ({len(e)} extra)")
+
+        self.add_to_cache("t5", t5_name, model)
+        self.eviction_based_on_memory()
+
+        return model
+
+    def load_t5_from_sd3_clip(self, sd3_clip, padding):
+        try:
+            from comfy.text_encoders.sd3_clip import SD3Tokenizer, SD3ClipModel
+        except:
+            from comfy.sd3_clip import SD3Tokenizer, SD3ClipModel
+        import copy
+
+        clip = sd3_clip.clone()
+        assert clip.cond_stage_model.t5xxl is not None, "CLIP must have T5 loaded!"
+
+        # remove transformer
+        transformer = clip.cond_stage_model.t5xxl.transformer
+        clip.cond_stage_model.t5xxl.transformer = None
+
+        # clone object
+        tmp = SD3ClipModel(clip_l=False, clip_g=False, t5=False)
+        tmp.t5xxl = copy.deepcopy(clip.cond_stage_model.t5xxl)
+        # put transformer back
+        clip.cond_stage_model.t5xxl.transformer = transformer
+        tmp.t5xxl.transformer = transformer
+
+        # override special tokens
+        tmp.t5xxl.special_tokens = copy.deepcopy(clip.cond_stage_model.t5xxl.special_tokens)
+        tmp.t5xxl.special_tokens.pop("end")  # make sure empty tokens match
+
+        # tokenizer
+        tok = SD3Tokenizer()
+        tok.t5xxl.min_length = padding
+
+        clip.cond_stage_model = tmp
+        clip.tokenizer = tok
+
+        return clip
@@ -1,10 +1,13 @@
 import comfy
+import comfy.model_management
+import comfy.samplers
 import torch
 import numpy as np
 import latent_preview
 from nodes import MAX_RESOLUTION
 from PIL import Image
 from typing import Dict, List, Optional, Tuple, Union, Any
+from ..brushnet.model_patch import add_model_patch

 class easySampler:
    def __init__(self):
@@ -12,6 +15,7 @@ class easySampler:
            "results": [],
            "pipe_line": [],
        }
+        self.device = comfy.model_management.intermediate_device()

    @staticmethod
    def tensor2pil(image: torch.Tensor) -> Image.Image:
@@ -47,9 +51,31 @@ class easySampler:
            parts.append('None')
        return parts

+    def emptyLatent(self, resolution, empty_latent_width, empty_latent_height, batch_size=1, compression=0, sd3=False):
+        if resolution not in ["自定义 x 自定义", 'width x height (custom)']:
+            try:
+                width, height = map(int, resolution.split(' x '))
+                empty_latent_width = width
+                empty_latent_height = height
+            except ValueError:
+                raise ValueError("Invalid base_resolution format.")
+        if sd3:
+            latent = torch.ones([batch_size, 16, empty_latent_height // 8, empty_latent_width // 8], device=self.device) * 0.0609
+            samples = {"samples": latent}
+        elif compression == 0:
+            latent = torch.zeros([batch_size, 4, empty_latent_height // 8, empty_latent_width // 8], device=self.device)
+            samples = {"samples": latent}
+        else:
+            latent_c = torch.zeros(
+                [batch_size, 16, empty_latent_height // compression, empty_latent_width // compression])
+            latent_b = torch.zeros([batch_size, 4, empty_latent_height // 4, empty_latent_width // 4])
+
+            samples = ({"samples": latent_c}, {"samples": latent_b})
+        return samples
+
    def common_ksampler(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent, denoise=1.0,
                        disable_noise=False, start_step=None, last_step=None, force_full_denoise=False,
-                        preview_latent=True, disable_pbar=False, custom=None):
+                        preview_latent=True, disable_pbar=False):
        device = comfy.model_management.get_torch_device()
        latent_image = latent["samples"]

@@ -74,30 +100,25 @@ class easySampler:
                preview_bytes = previewer.decode_latent_to_preview_image(preview_format, x0)
            pbar.update_absolute(step + 1, total_steps, preview_bytes)

-        if custom is not None:
-            guider = custom['guider'] if 'guider' in custom else None
-            sampler = custom['sampler'] if 'sampler' in custom else None
-            sigmas = custom['sigmas'] if 'sigmas' in custom else None
-            noise = custom['noise'] if 'noise' in custom else None
-            samples = guider.sample(noise.generate_noise(latent), latent_image, sampler, sigmas,
-                                    denoise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar,
-                                    seed=noise.seed)
-            samples = samples.to(comfy.model_management.intermediate_device())
+        if disable_noise:
+            noise = torch.zeros(latent_image.size(), dtype=latent_image.dtype, layout=latent_image.layout,
+                                device="cpu")
        else:
-            if disable_noise:
-                noise = torch.zeros(latent_image.size(), dtype=latent_image.dtype, layout=latent_image.layout,
-                                    device="cpu")
-            else:
-                batch_inds = latent["batch_index"] if "batch_index" in latent else None
-                noise = comfy.sample.prepare_noise(latent_image, seed, batch_inds)
-
-            samples = comfy.sample.sample(model, noise, steps, cfg, sampler_name, scheduler, positive, negative,
-                                          latent_image,
-                                          denoise=denoise, disable_noise=disable_noise, start_step=start_step,
-                                          last_step=last_step,
-                                          force_full_denoise=force_full_denoise, noise_mask=noise_mask, callback=callback,
-                                          disable_pbar=disable_pbar, seed=seed)
+            batch_inds = latent["batch_index"] if "batch_index" in latent else None
+            noise = comfy.sample.prepare_noise(latent_image, seed, batch_inds)

+        #######################################################################################
+        # add model patch
+        # brushnet
+        add_model_patch(model)
+        #######################################################################################
+        samples = comfy.sample.sample(model, noise, steps, cfg, sampler_name, scheduler, positive, negative,
+                                      latent_image,
+                                      denoise=denoise, disable_noise=disable_noise, start_step=start_step,
+                                      last_step=last_step,
+                                      force_full_denoise=force_full_denoise, noise_mask=noise_mask,
+                                      callback=callback,
+                                      disable_pbar=disable_pbar, seed=seed)
        out = latent.copy()
        out["samples"] = samples
        return out
@@ -135,14 +156,42 @@ class easySampler:
                preview_bytes = previewer.decode_latent_to_preview_image(preview_format, x0)
            pbar.update_absolute(step + 1, total_steps, preview_bytes)

-        samples = comfy.sample.sample_custom(model, noise, cfg, _sampler, sigmas, positive, negative, latent_image,
-                                             noise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar,
-                                             seed=seed)
+        samples = comfy.samplers.sample(model, noise, positive, negative, cfg, device, _sampler, sigmas, latent_image=latent_image, model_options=model.model_options,
+               denoise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar, seed=seed)

        out = latent.copy()
        out["samples"] = samples
        return out

+    def custom_advanced_ksampler(self, noise, guider, sampler, sigmas, latent_image):
+        latent = latent_image
+        latent_image = latent["samples"]
+        latent = latent.copy()
+        latent_image = comfy.sample.fix_empty_latent_channels(guider.model_patcher, latent_image)
+        latent["samples"] = latent_image
+
+        noise_mask = None
+        if "noise_mask" in latent:
+            noise_mask = latent["noise_mask"]
+
+        x0_output = {}
+        callback = latent_preview.prepare_callback(guider.model_patcher, sigmas.shape[-1] - 1, x0_output)
+
+        disable_pbar = not comfy.utils.PROGRESS_BAR_ENABLED
+        samples = guider.sample(noise.generate_noise(latent), latent_image, sampler, sigmas, denoise_mask=noise_mask,
+                                callback=callback, disable_pbar=disable_pbar, seed=noise.seed)
+        samples = samples.to(comfy.model_management.intermediate_device())
+
+        out = latent.copy()
+        out["samples"] = samples
+        if "x0" in x0_output:
+            out_denoised = latent.copy()
+            out_denoised["samples"] = guider.model_patcher.model.process_latent_out(x0_output["x0"].cpu())
+        else:
+            out_denoised = out
+
+        return (out, out_denoised)
+
    def get_value_by_id(self, key: str, my_unique_id: Any) -> Optional[Any]:
        """Retrieve value by its associated ID."""
        try:
@@ -220,4 +269,641 @@ class easySampler:
            sdxl_pipe.get("clip"),
            sdxl_pipe.get("images"),
            sdxl_pipe.get("seed")
-        )
+        )
+
+def loglinear_interp(t_steps, num_steps):
+    """
+    Performs log-linear interpolation of a given array of decreasing numbers.
+    """
+    xs = np.linspace(0, 1, len(t_steps))
+    ys = np.log(t_steps[::-1])
+
+    new_xs = np.linspace(0, 1, num_steps)
+    new_ys = np.interp(new_xs, xs, ys)
+
+    interped_ys = np.exp(new_ys)[::-1].copy()
+    return interped_ys
+
+class alignYourStepsScheduler:
+
+    NOISE_LEVELS = {
+        "SD1": [14.6146412293, 6.4745760956, 3.8636745985, 2.6946151520, 1.8841921177, 1.3943805092, 0.9642583904,
+                0.6523686016, 0.3977456272, 0.1515232662, 0.0291671582],
+        "SDXL": [14.6146412293, 6.3184485287, 3.7681790315, 2.1811480769, 1.3405244945, 0.8620721141, 0.5550693289,
+                 0.3798540708, 0.2332364134, 0.1114188177, 0.0291671582],
+        "SVD": [700.00, 54.5, 15.886, 7.977, 4.248, 1.789, 0.981, 0.403, 0.173, 0.034, 0.002]}
+
+    def get_sigmas(self, model_type, steps, denoise):
+
+        total_steps = steps
+        if denoise < 1.0:
+            if denoise <= 0.0:
+                return (torch.FloatTensor([]),)
+            total_steps = round(steps * denoise)
+
+        sigmas = self.NOISE_LEVELS[model_type][:]
+        if (steps + 1) != len(sigmas):
+            sigmas = loglinear_interp(sigmas, steps + 1)
+
+        sigmas = sigmas[-(total_steps + 1):]
+        sigmas[-1] = 0
+        return (torch.FloatTensor(sigmas),)
+
+
+class gitsScheduler:
+
+    NOISE_LEVELS = {
+        0.80: [
+            [14.61464119, 7.49001646, 0.02916753],
+            [14.61464119, 11.54541874, 6.77309084, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 3.07277966, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 2.05039096, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.85520077, 2.05039096, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.85520077, 3.07277966, 1.56271636, 0.02916753],
+            [14.61464119, 12.96784878, 11.54541874, 8.75849152, 7.49001646, 5.85520077, 3.07277966, 1.56271636,
+             0.02916753],
+            [14.61464119, 13.76078796, 12.2308979, 10.90732002, 8.75849152, 7.49001646, 5.85520077, 3.07277966,
+             1.56271636, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 10.90732002, 8.75849152, 7.49001646, 5.85520077,
+             3.07277966, 1.56271636, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646,
+             5.85520077, 3.07277966, 1.56271636, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646,
+             6.14220476, 4.86714602, 3.07277966, 1.56271636, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.31284904, 9.24142551, 8.30717278,
+             7.49001646, 6.14220476, 4.86714602, 3.07277966, 1.56271636, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.24142551,
+             8.30717278, 7.49001646, 6.14220476, 4.86714602, 3.07277966, 1.56271636, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.24142551,
+             8.75849152, 8.30717278, 7.49001646, 6.14220476, 4.86714602, 3.07277966, 1.56271636, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.24142551,
+             8.75849152, 8.30717278, 7.49001646, 6.14220476, 4.86714602, 3.1956799, 1.98035145, 0.86115354, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.75859547,
+             9.24142551, 8.75849152, 8.30717278, 7.49001646, 6.14220476, 4.86714602, 3.1956799, 1.98035145, 0.86115354,
+             0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.75859547,
+             9.24142551, 8.75849152, 8.30717278, 7.49001646, 6.77309084, 5.85520077, 4.65472794, 3.07277966, 1.84880662,
+             0.83188516, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.75859547,
+             9.24142551, 8.75849152, 8.30717278, 7.88507891, 7.49001646, 6.77309084, 5.85520077, 4.65472794, 3.07277966,
+             1.84880662, 0.83188516, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.75859547,
+             9.24142551, 8.75849152, 8.30717278, 7.88507891, 7.49001646, 6.77309084, 5.85520077, 4.86714602, 3.75677586,
+             2.84484982, 1.78698075, 0.803307, 0.02916753],
+        ],
+        0.85: [
+            [14.61464119, 7.49001646, 0.02916753],
+            [14.61464119, 7.49001646, 1.84880662, 0.02916753],
+            [14.61464119, 11.54541874, 6.77309084, 1.56271636, 0.02916753],
+            [14.61464119, 11.54541874, 7.11996698, 3.07277966, 1.24153244, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.09240818, 2.84484982, 0.95350921, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.09240818, 2.84484982, 0.95350921, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.58536053, 3.1956799, 1.84880662, 0.803307, 0.02916753],
+            [14.61464119, 12.96784878, 11.54541874, 8.75849152, 7.49001646, 5.58536053, 3.1956799, 1.84880662, 0.803307,
+             0.02916753],
+            [14.61464119, 12.96784878, 11.54541874, 8.75849152, 7.49001646, 6.14220476, 4.65472794, 3.07277966,
+             1.84880662, 0.803307, 0.02916753],
+            [14.61464119, 13.76078796, 12.2308979, 10.90732002, 8.75849152, 7.49001646, 6.14220476, 4.65472794,
+             3.07277966, 1.84880662, 0.803307, 0.02916753],
+            [14.61464119, 13.76078796, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646, 6.14220476,
+             4.65472794, 3.07277966, 1.84880662, 0.803307, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646,
+             6.14220476, 4.65472794, 3.07277966, 1.84880662, 0.803307, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.31284904, 9.24142551, 8.30717278,
+             7.49001646, 6.14220476, 4.65472794, 3.07277966, 1.84880662, 0.803307, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.31284904, 9.24142551, 8.30717278,
+             7.49001646, 6.14220476, 4.86714602, 3.60512662, 2.6383388, 1.56271636, 0.72133851, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.31284904, 9.24142551, 8.30717278,
+             7.49001646, 6.77309084, 5.85520077, 4.65472794, 3.46139455, 2.45070267, 1.56271636, 0.72133851,
+             0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.31284904, 9.24142551, 8.75849152,
+             8.30717278, 7.49001646, 6.77309084, 5.85520077, 4.65472794, 3.46139455, 2.45070267, 1.56271636, 0.72133851,
+             0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.24142551,
+             8.75849152, 8.30717278, 7.49001646, 6.77309084, 5.85520077, 4.65472794, 3.46139455, 2.45070267, 1.56271636,
+             0.72133851, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.75859547,
+             9.24142551, 8.75849152, 8.30717278, 7.49001646, 6.77309084, 5.85520077, 4.65472794, 3.46139455, 2.45070267,
+             1.56271636, 0.72133851, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.90732002, 10.31284904, 9.75859547,
+             9.24142551, 8.75849152, 8.30717278, 7.88507891, 7.49001646, 6.77309084, 5.85520077, 4.65472794, 3.46139455,
+             2.45070267, 1.56271636, 0.72133851, 0.02916753],
+        ],
+        0.90: [
+            [14.61464119, 6.77309084, 0.02916753],
+            [14.61464119, 7.49001646, 1.56271636, 0.02916753],
+            [14.61464119, 7.49001646, 3.07277966, 0.95350921, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.54230714, 0.89115214, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 4.86714602, 2.54230714, 0.89115214, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.09240818, 3.07277966, 1.61558151, 0.69515091, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.11996698, 4.86714602, 3.07277966, 1.61558151, 0.69515091,
+             0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.85520077, 4.45427561, 2.95596409, 1.61558151,
+             0.69515091, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.19988537, 1.24153244,
+             0.57119018, 0.02916753],
+            [14.61464119, 12.96784878, 10.90732002, 8.75849152, 7.49001646, 5.85520077, 4.45427561, 3.1956799,
+             2.19988537, 1.24153244, 0.57119018, 0.02916753],
+            [14.61464119, 12.96784878, 11.54541874, 9.24142551, 8.30717278, 7.49001646, 5.85520077, 4.45427561,
+             3.1956799, 2.19988537, 1.24153244, 0.57119018, 0.02916753],
+            [14.61464119, 12.96784878, 11.54541874, 9.24142551, 8.30717278, 7.49001646, 6.14220476, 4.86714602,
+             3.75677586, 2.84484982, 1.84880662, 1.08895338, 0.52423614, 0.02916753],
+            [14.61464119, 13.76078796, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646, 6.14220476,
+             4.86714602, 3.75677586, 2.84484982, 1.84880662, 1.08895338, 0.52423614, 0.02916753],
+            [14.61464119, 13.76078796, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646, 6.44769001,
+             5.58536053, 4.45427561, 3.32507086, 2.45070267, 1.61558151, 0.95350921, 0.45573691, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646,
+             6.44769001, 5.58536053, 4.45427561, 3.32507086, 2.45070267, 1.61558151, 0.95350921, 0.45573691,
+             0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646,
+             6.77309084, 5.85520077, 4.86714602, 3.91689563, 3.07277966, 2.27973175, 1.56271636, 0.95350921, 0.45573691,
+             0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.31284904, 9.24142551, 8.30717278,
+             7.49001646, 6.77309084, 5.85520077, 4.86714602, 3.91689563, 3.07277966, 2.27973175, 1.56271636, 0.95350921,
+             0.45573691, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.31284904, 9.24142551, 8.75849152,
+             8.30717278, 7.49001646, 6.77309084, 5.85520077, 4.86714602, 3.91689563, 3.07277966, 2.27973175, 1.56271636,
+             0.95350921, 0.45573691, 0.02916753],
+            [14.61464119, 13.76078796, 12.96784878, 12.2308979, 11.54541874, 10.31284904, 9.24142551, 8.75849152,
+             8.30717278, 7.49001646, 6.77309084, 5.85520077, 5.09240818, 4.45427561, 3.60512662, 2.95596409, 2.19988537,
+             1.51179266, 0.89115214, 0.43325692, 0.02916753],
+        ],
+        0.95: [
+            [14.61464119, 6.77309084, 0.02916753],
+            [14.61464119, 6.77309084, 1.56271636, 0.02916753],
+            [14.61464119, 7.49001646, 2.84484982, 0.89115214, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.36326075, 0.803307, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.95596409, 1.56271636, 0.64427125, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 4.86714602, 2.95596409, 1.56271636, 0.64427125, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 4.86714602, 3.07277966, 1.91321158, 1.08895338, 0.50118381,
+             0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.45427561, 3.07277966, 1.91321158, 1.08895338,
+             0.50118381, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.85520077, 4.45427561, 3.07277966, 1.91321158,
+             1.08895338, 0.50118381, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.19988537, 1.41535246,
+             0.803307, 0.38853383, 0.02916753],
+            [14.61464119, 12.2308979, 8.75849152, 7.49001646, 5.85520077, 4.65472794, 3.46139455, 2.6383388, 1.84880662,
+             1.24153244, 0.72133851, 0.34370604, 0.02916753],
+            [14.61464119, 12.96784878, 10.90732002, 8.75849152, 7.49001646, 5.85520077, 4.65472794, 3.46139455,
+             2.6383388, 1.84880662, 1.24153244, 0.72133851, 0.34370604, 0.02916753],
+            [14.61464119, 12.96784878, 10.90732002, 8.75849152, 7.49001646, 6.14220476, 4.86714602, 3.75677586,
+             2.95596409, 2.19988537, 1.56271636, 1.05362725, 0.64427125, 0.32104823, 0.02916753],
+            [14.61464119, 12.96784878, 10.90732002, 8.75849152, 7.49001646, 6.44769001, 5.58536053, 4.65472794,
+             3.60512662, 2.95596409, 2.19988537, 1.56271636, 1.05362725, 0.64427125, 0.32104823, 0.02916753],
+            [14.61464119, 12.96784878, 11.54541874, 9.24142551, 8.30717278, 7.49001646, 6.44769001, 5.58536053,
+             4.65472794, 3.60512662, 2.95596409, 2.19988537, 1.56271636, 1.05362725, 0.64427125, 0.32104823,
+             0.02916753],
+            [14.61464119, 12.96784878, 11.54541874, 9.24142551, 8.30717278, 7.49001646, 6.44769001, 5.58536053,
+             4.65472794, 3.75677586, 3.07277966, 2.45070267, 1.78698075, 1.24153244, 0.83188516, 0.50118381, 0.22545385,
+             0.02916753],
+            [14.61464119, 12.96784878, 11.54541874, 9.24142551, 8.30717278, 7.49001646, 6.77309084, 5.85520077,
+             5.09240818, 4.45427561, 3.60512662, 2.95596409, 2.36326075, 1.72759056, 1.24153244, 0.83188516, 0.50118381,
+             0.22545385, 0.02916753],
+            [14.61464119, 13.76078796, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646, 6.77309084,
+             5.85520077, 5.09240818, 4.45427561, 3.60512662, 2.95596409, 2.36326075, 1.72759056, 1.24153244, 0.83188516,
+             0.50118381, 0.22545385, 0.02916753],
+            [14.61464119, 13.76078796, 12.2308979, 10.90732002, 9.24142551, 8.30717278, 7.49001646, 6.77309084,
+             5.85520077, 5.09240818, 4.45427561, 3.75677586, 3.07277966, 2.45070267, 1.91321158, 1.46270394, 1.05362725,
+             0.72133851, 0.43325692, 0.19894916, 0.02916753],
+        ],
+        1.00: [
+            [14.61464119, 1.56271636, 0.02916753],
+            [14.61464119, 6.77309084, 0.95350921, 0.02916753],
+            [14.61464119, 6.77309084, 2.36326075, 0.803307, 0.02916753],
+            [14.61464119, 7.11996698, 3.07277966, 1.56271636, 0.59516323, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.84484982, 1.41535246, 0.57119018, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.84484982, 1.61558151, 0.86115354, 0.38853383, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 4.86714602, 2.84484982, 1.61558151, 0.86115354, 0.38853383,
+             0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 4.86714602, 3.07277966, 1.98035145, 1.24153244, 0.72133851,
+             0.34370604, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.45427561, 3.07277966, 1.98035145, 1.24153244,
+             0.72133851, 0.34370604, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.27973175, 1.51179266,
+             0.95350921, 0.54755926, 0.25053367, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.36326075, 1.61558151,
+             1.08895338, 0.72133851, 0.41087446, 0.17026083, 0.02916753],
+            [14.61464119, 11.54541874, 8.75849152, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.36326075,
+             1.61558151, 1.08895338, 0.72133851, 0.41087446, 0.17026083, 0.02916753],
+            [14.61464119, 11.54541874, 8.75849152, 7.49001646, 5.85520077, 4.65472794, 3.60512662, 2.84484982,
+             2.12350607, 1.56271636, 1.08895338, 0.72133851, 0.41087446, 0.17026083, 0.02916753],
+            [14.61464119, 11.54541874, 8.75849152, 7.49001646, 5.85520077, 4.65472794, 3.60512662, 2.84484982,
+             2.19988537, 1.61558151, 1.162866, 0.803307, 0.50118381, 0.27464288, 0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 8.75849152, 7.49001646, 5.85520077, 4.65472794, 3.75677586, 3.07277966,
+             2.45070267, 1.84880662, 1.36964464, 1.01931262, 0.72133851, 0.45573691, 0.25053367, 0.09824532,
+             0.02916753],
+            [14.61464119, 11.54541874, 8.75849152, 7.49001646, 6.14220476, 5.09240818, 4.26497746, 3.46139455,
+             2.84484982, 2.19988537, 1.67050016, 1.24153244, 0.92192322, 0.64427125, 0.43325692, 0.25053367, 0.09824532,
+             0.02916753],
+            [14.61464119, 11.54541874, 8.75849152, 7.49001646, 6.14220476, 5.09240818, 4.26497746, 3.60512662,
+             2.95596409, 2.45070267, 1.91321158, 1.51179266, 1.12534678, 0.83188516, 0.59516323, 0.38853383, 0.22545385,
+             0.09824532, 0.02916753],
+            [14.61464119, 12.2308979, 9.24142551, 8.30717278, 7.49001646, 6.14220476, 5.09240818, 4.26497746,
+             3.60512662, 2.95596409, 2.45070267, 1.91321158, 1.51179266, 1.12534678, 0.83188516, 0.59516323, 0.38853383,
+             0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 12.2308979, 9.24142551, 8.30717278, 7.49001646, 6.77309084, 5.85520077, 5.09240818,
+             4.26497746, 3.60512662, 2.95596409, 2.45070267, 1.91321158, 1.51179266, 1.12534678, 0.83188516, 0.59516323,
+             0.38853383, 0.22545385, 0.09824532, 0.02916753],
+        ],
+        1.05: [
+            [14.61464119, 0.95350921, 0.02916753],
+            [14.61464119, 6.77309084, 0.89115214, 0.02916753],
+            [14.61464119, 6.77309084, 2.05039096, 0.72133851, 0.02916753],
+            [14.61464119, 6.77309084, 2.84484982, 1.28281462, 0.52423614, 0.02916753],
+            [14.61464119, 6.77309084, 3.07277966, 1.61558151, 0.803307, 0.34370604, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.84484982, 1.56271636, 0.803307, 0.34370604, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.84484982, 1.61558151, 0.95350921, 0.52423614, 0.22545385,
+             0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.07277966, 1.98035145, 1.24153244, 0.74807048, 0.41087446,
+             0.17026083, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.1956799, 2.27973175, 1.51179266, 0.95350921, 0.59516323, 0.34370604,
+             0.13792117, 0.02916753],
+            [14.61464119, 7.49001646, 5.09240818, 3.46139455, 2.45070267, 1.61558151, 1.08895338, 0.72133851,
+             0.45573691, 0.25053367, 0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.09240818, 3.46139455, 2.45070267, 1.61558151, 1.08895338,
+             0.72133851, 0.45573691, 0.25053367, 0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.36326075, 1.61558151,
+             1.08895338, 0.72133851, 0.45573691, 0.25053367, 0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.45070267, 1.72759056,
+             1.24153244, 0.86115354, 0.59516323, 0.38853383, 0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.65472794, 3.60512662, 2.84484982, 2.19988537,
+             1.61558151, 1.162866, 0.83188516, 0.59516323, 0.38853383, 0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.65472794, 3.60512662, 2.84484982, 2.19988537,
+             1.67050016, 1.28281462, 0.95350921, 0.72133851, 0.52423614, 0.34370604, 0.19894916, 0.09824532,
+             0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.65472794, 3.60512662, 2.95596409, 2.36326075,
+             1.84880662, 1.41535246, 1.08895338, 0.83188516, 0.61951244, 0.45573691, 0.32104823, 0.19894916, 0.09824532,
+             0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.65472794, 3.60512662, 2.95596409, 2.45070267,
+             1.91321158, 1.51179266, 1.20157266, 0.95350921, 0.74807048, 0.57119018, 0.43325692, 0.29807833, 0.19894916,
+             0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 8.30717278, 7.11996698, 5.85520077, 4.65472794, 3.60512662, 2.95596409,
+             2.45070267, 1.91321158, 1.51179266, 1.20157266, 0.95350921, 0.74807048, 0.57119018, 0.43325692, 0.29807833,
+             0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 8.30717278, 7.11996698, 5.85520077, 4.65472794, 3.60512662, 2.95596409,
+             2.45070267, 1.98035145, 1.61558151, 1.32549286, 1.08895338, 0.86115354, 0.69515091, 0.54755926, 0.41087446,
+             0.29807833, 0.19894916, 0.09824532, 0.02916753],
+        ],
+        1.10: [
+            [14.61464119, 0.89115214, 0.02916753],
+            [14.61464119, 2.36326075, 0.72133851, 0.02916753],
+            [14.61464119, 5.85520077, 1.61558151, 0.57119018, 0.02916753],
+            [14.61464119, 6.77309084, 2.45070267, 1.08895338, 0.45573691, 0.02916753],
+            [14.61464119, 6.77309084, 2.95596409, 1.56271636, 0.803307, 0.34370604, 0.02916753],
+            [14.61464119, 6.77309084, 3.07277966, 1.61558151, 0.89115214, 0.4783645, 0.19894916, 0.02916753],
+            [14.61464119, 6.77309084, 3.07277966, 1.84880662, 1.08895338, 0.64427125, 0.34370604, 0.13792117,
+             0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.84484982, 1.61558151, 0.95350921, 0.54755926, 0.27464288,
+             0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.95596409, 1.91321158, 1.24153244, 0.803307, 0.4783645, 0.25053367,
+             0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.07277966, 2.05039096, 1.41535246, 0.95350921, 0.64427125,
+             0.41087446, 0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.1956799, 2.27973175, 1.61558151, 1.12534678, 0.803307, 0.54755926,
+             0.36617002, 0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.32507086, 2.45070267, 1.72759056, 1.24153244, 0.89115214,
+             0.64427125, 0.45573691, 0.32104823, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 5.09240818, 3.60512662, 2.84484982, 2.05039096, 1.51179266, 1.08895338, 0.803307,
+             0.59516323, 0.43325692, 0.29807833, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 5.09240818, 3.60512662, 2.84484982, 2.12350607, 1.61558151, 1.24153244,
+             0.95350921, 0.72133851, 0.54755926, 0.41087446, 0.29807833, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.45070267, 1.84880662, 1.41535246, 1.08895338,
+             0.83188516, 0.64427125, 0.50118381, 0.36617002, 0.25053367, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 5.85520077, 4.45427561, 3.1956799, 2.45070267, 1.91321158, 1.51179266, 1.20157266,
+             0.95350921, 0.74807048, 0.59516323, 0.45573691, 0.34370604, 0.25053367, 0.17026083, 0.09824532,
+             0.02916753],
+            [14.61464119, 7.49001646, 5.85520077, 4.45427561, 3.46139455, 2.84484982, 2.19988537, 1.72759056,
+             1.36964464, 1.08895338, 0.86115354, 0.69515091, 0.54755926, 0.43325692, 0.34370604, 0.25053367, 0.17026083,
+             0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.45427561, 3.46139455, 2.84484982, 2.19988537,
+             1.72759056, 1.36964464, 1.08895338, 0.86115354, 0.69515091, 0.54755926, 0.43325692, 0.34370604, 0.25053367,
+             0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 11.54541874, 7.49001646, 5.85520077, 4.45427561, 3.46139455, 2.84484982, 2.19988537,
+             1.72759056, 1.36964464, 1.08895338, 0.89115214, 0.72133851, 0.59516323, 0.4783645, 0.38853383, 0.29807833,
+             0.22545385, 0.17026083, 0.09824532, 0.02916753],
+        ],
+        1.15: [
+            [14.61464119, 0.83188516, 0.02916753],
+            [14.61464119, 1.84880662, 0.59516323, 0.02916753],
+            [14.61464119, 5.85520077, 1.56271636, 0.52423614, 0.02916753],
+            [14.61464119, 5.85520077, 1.91321158, 0.83188516, 0.34370604, 0.02916753],
+            [14.61464119, 5.85520077, 2.45070267, 1.24153244, 0.59516323, 0.25053367, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.51179266, 0.803307, 0.41087446, 0.17026083, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.56271636, 0.89115214, 0.50118381, 0.25053367, 0.09824532,
+             0.02916753],
+            [14.61464119, 6.77309084, 3.07277966, 1.84880662, 1.12534678, 0.72133851, 0.43325692, 0.22545385,
+             0.09824532, 0.02916753],
+            [14.61464119, 6.77309084, 3.07277966, 1.91321158, 1.24153244, 0.803307, 0.52423614, 0.34370604, 0.19894916,
+             0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 2.95596409, 1.91321158, 1.24153244, 0.803307, 0.52423614, 0.34370604,
+             0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.07277966, 2.05039096, 1.36964464, 0.95350921, 0.69515091, 0.4783645,
+             0.32104823, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.07277966, 2.12350607, 1.51179266, 1.08895338, 0.803307, 0.59516323,
+             0.43325692, 0.29807833, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.07277966, 2.12350607, 1.51179266, 1.08895338, 0.803307, 0.59516323,
+             0.45573691, 0.34370604, 0.25053367, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.07277966, 2.19988537, 1.61558151, 1.24153244, 0.95350921,
+             0.74807048, 0.59516323, 0.45573691, 0.34370604, 0.25053367, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.1956799, 2.45070267, 1.78698075, 1.32549286, 1.01931262, 0.803307,
+             0.64427125, 0.50118381, 0.38853383, 0.29807833, 0.22545385, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.1956799, 2.45070267, 1.78698075, 1.32549286, 1.01931262, 0.803307,
+             0.64427125, 0.52423614, 0.41087446, 0.32104823, 0.25053367, 0.19894916, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.1956799, 2.45070267, 1.84880662, 1.41535246, 1.12534678, 0.89115214,
+             0.72133851, 0.59516323, 0.4783645, 0.38853383, 0.32104823, 0.25053367, 0.19894916, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.1956799, 2.45070267, 1.84880662, 1.41535246, 1.12534678, 0.89115214,
+             0.72133851, 0.59516323, 0.50118381, 0.41087446, 0.34370604, 0.27464288, 0.22545385, 0.17026083, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.86714602, 3.1956799, 2.45070267, 1.84880662, 1.41535246, 1.12534678, 0.89115214,
+             0.72133851, 0.59516323, 0.50118381, 0.41087446, 0.34370604, 0.29807833, 0.25053367, 0.19894916, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+        ],
+        1.20: [
+            [14.61464119, 0.803307, 0.02916753],
+            [14.61464119, 1.56271636, 0.52423614, 0.02916753],
+            [14.61464119, 2.36326075, 0.92192322, 0.36617002, 0.02916753],
+            [14.61464119, 2.84484982, 1.24153244, 0.59516323, 0.25053367, 0.02916753],
+            [14.61464119, 5.85520077, 2.05039096, 0.95350921, 0.45573691, 0.17026083, 0.02916753],
+            [14.61464119, 5.85520077, 2.45070267, 1.24153244, 0.64427125, 0.29807833, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.45070267, 1.36964464, 0.803307, 0.45573691, 0.25053367, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.61558151, 0.95350921, 0.59516323, 0.36617002, 0.19894916,
+             0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.67050016, 1.08895338, 0.74807048, 0.50118381, 0.32104823,
+             0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.95596409, 1.84880662, 1.24153244, 0.83188516, 0.59516323, 0.41087446,
+             0.27464288, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 3.07277966, 1.98035145, 1.36964464, 0.95350921, 0.69515091, 0.50118381,
+             0.36617002, 0.25053367, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 6.77309084, 3.46139455, 2.36326075, 1.56271636, 1.08895338, 0.803307, 0.59516323, 0.45573691,
+             0.34370604, 0.25053367, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 6.77309084, 3.46139455, 2.45070267, 1.61558151, 1.162866, 0.86115354, 0.64427125, 0.50118381,
+             0.38853383, 0.29807833, 0.22545385, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.65472794, 3.07277966, 2.12350607, 1.51179266, 1.08895338, 0.83188516,
+             0.64427125, 0.50118381, 0.38853383, 0.29807833, 0.22545385, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.65472794, 3.07277966, 2.12350607, 1.51179266, 1.08895338, 0.83188516,
+             0.64427125, 0.50118381, 0.41087446, 0.32104823, 0.25053367, 0.19894916, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 7.49001646, 4.65472794, 3.07277966, 2.12350607, 1.51179266, 1.08895338, 0.83188516,
+             0.64427125, 0.50118381, 0.41087446, 0.34370604, 0.27464288, 0.22545385, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 7.49001646, 4.65472794, 3.07277966, 2.19988537, 1.61558151, 1.20157266, 0.92192322,
+             0.72133851, 0.57119018, 0.45573691, 0.36617002, 0.29807833, 0.25053367, 0.19894916, 0.17026083, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.65472794, 3.07277966, 2.19988537, 1.61558151, 1.24153244, 0.95350921,
+             0.74807048, 0.59516323, 0.4783645, 0.38853383, 0.32104823, 0.27464288, 0.22545385, 0.19894916, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 7.49001646, 4.65472794, 3.07277966, 2.19988537, 1.61558151, 1.24153244, 0.95350921,
+             0.74807048, 0.59516323, 0.50118381, 0.41087446, 0.34370604, 0.29807833, 0.25053367, 0.22545385, 0.19894916,
+             0.17026083, 0.13792117, 0.09824532, 0.02916753],
+        ],
+        1.25: [
+            [14.61464119, 0.72133851, 0.02916753],
+            [14.61464119, 1.56271636, 0.50118381, 0.02916753],
+            [14.61464119, 2.05039096, 0.803307, 0.32104823, 0.02916753],
+            [14.61464119, 2.36326075, 0.95350921, 0.43325692, 0.17026083, 0.02916753],
+            [14.61464119, 2.84484982, 1.24153244, 0.59516323, 0.27464288, 0.09824532, 0.02916753],
+            [14.61464119, 3.07277966, 1.51179266, 0.803307, 0.43325692, 0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.36326075, 1.24153244, 0.72133851, 0.41087446, 0.22545385, 0.09824532,
+             0.02916753],
+            [14.61464119, 5.85520077, 2.45070267, 1.36964464, 0.83188516, 0.52423614, 0.34370604, 0.19894916,
+             0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.61558151, 0.98595673, 0.64427125, 0.43325692, 0.27464288,
+             0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.67050016, 1.08895338, 0.74807048, 0.52423614, 0.36617002,
+             0.25053367, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.72759056, 1.162866, 0.803307, 0.59516323, 0.45573691, 0.34370604,
+             0.25053367, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.95596409, 1.84880662, 1.24153244, 0.86115354, 0.64427125, 0.4783645, 0.36617002,
+             0.27464288, 0.19894916, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.95596409, 1.84880662, 1.28281462, 0.92192322, 0.69515091, 0.52423614,
+             0.41087446, 0.32104823, 0.25053367, 0.19894916, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.95596409, 1.91321158, 1.32549286, 0.95350921, 0.72133851, 0.54755926,
+             0.43325692, 0.34370604, 0.27464288, 0.22545385, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.95596409, 1.91321158, 1.32549286, 0.95350921, 0.72133851, 0.57119018,
+             0.45573691, 0.36617002, 0.29807833, 0.25053367, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 5.85520077, 2.95596409, 1.91321158, 1.32549286, 0.95350921, 0.74807048, 0.59516323, 0.4783645,
+             0.38853383, 0.32104823, 0.27464288, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 5.85520077, 3.07277966, 2.05039096, 1.41535246, 1.05362725, 0.803307, 0.61951244, 0.50118381,
+             0.41087446, 0.34370604, 0.29807833, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 5.85520077, 3.07277966, 2.05039096, 1.41535246, 1.05362725, 0.803307, 0.64427125, 0.52423614,
+             0.43325692, 0.36617002, 0.32104823, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 3.07277966, 2.05039096, 1.46270394, 1.08895338, 0.83188516, 0.66947293,
+             0.54755926, 0.45573691, 0.38853383, 0.34370604, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916,
+             0.17026083, 0.13792117, 0.09824532, 0.02916753],
+        ],
+        1.30: [
+            [14.61464119, 0.72133851, 0.02916753],
+            [14.61464119, 1.24153244, 0.43325692, 0.02916753],
+            [14.61464119, 1.56271636, 0.59516323, 0.22545385, 0.02916753],
+            [14.61464119, 1.84880662, 0.803307, 0.36617002, 0.13792117, 0.02916753],
+            [14.61464119, 2.36326075, 1.01931262, 0.52423614, 0.25053367, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.36964464, 0.74807048, 0.41087446, 0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 3.07277966, 1.56271636, 0.89115214, 0.54755926, 0.34370604, 0.19894916, 0.09824532,
+             0.02916753],
+            [14.61464119, 3.07277966, 1.61558151, 0.95350921, 0.61951244, 0.41087446, 0.27464288, 0.17026083,
+             0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.45070267, 1.36964464, 0.83188516, 0.54755926, 0.36617002, 0.25053367,
+             0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.45070267, 1.41535246, 0.92192322, 0.64427125, 0.45573691, 0.34370604,
+             0.25053367, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.6383388, 1.56271636, 1.01931262, 0.72133851, 0.50118381, 0.36617002, 0.27464288,
+             0.19894916, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.61558151, 1.05362725, 0.74807048, 0.54755926, 0.41087446,
+             0.32104823, 0.25053367, 0.19894916, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.61558151, 1.08895338, 0.77538133, 0.57119018, 0.43325692,
+             0.34370604, 0.27464288, 0.22545385, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.61558151, 1.08895338, 0.803307, 0.59516323, 0.45573691, 0.36617002,
+             0.29807833, 0.25053367, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.61558151, 1.08895338, 0.803307, 0.59516323, 0.4783645, 0.38853383,
+             0.32104823, 0.27464288, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.72759056, 1.162866, 0.83188516, 0.64427125, 0.50118381, 0.41087446,
+             0.34370604, 0.29807833, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.72759056, 1.162866, 0.83188516, 0.64427125, 0.52423614, 0.43325692,
+             0.36617002, 0.32104823, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.78698075, 1.24153244, 0.92192322, 0.72133851, 0.57119018,
+             0.45573691, 0.38853383, 0.34370604, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.84484982, 1.78698075, 1.24153244, 0.92192322, 0.72133851, 0.57119018, 0.4783645,
+             0.41087446, 0.36617002, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+        ],
+        1.35: [
+            [14.61464119, 0.69515091, 0.02916753],
+            [14.61464119, 0.95350921, 0.34370604, 0.02916753],
+            [14.61464119, 1.56271636, 0.57119018, 0.19894916, 0.02916753],
+            [14.61464119, 1.61558151, 0.69515091, 0.29807833, 0.09824532, 0.02916753],
+            [14.61464119, 1.84880662, 0.83188516, 0.43325692, 0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.162866, 0.64427125, 0.36617002, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.36964464, 0.803307, 0.50118381, 0.32104823, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.41535246, 0.83188516, 0.54755926, 0.36617002, 0.25053367, 0.17026083,
+             0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.56271636, 0.95350921, 0.64427125, 0.45573691, 0.32104823, 0.22545385,
+             0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.56271636, 0.95350921, 0.64427125, 0.45573691, 0.34370604, 0.25053367,
+             0.19894916, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 3.07277966, 1.61558151, 1.01931262, 0.72133851, 0.52423614, 0.38853383, 0.29807833,
+             0.22545385, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 3.07277966, 1.61558151, 1.01931262, 0.72133851, 0.52423614, 0.41087446, 0.32104823,
+             0.25053367, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 3.07277966, 1.61558151, 1.05362725, 0.74807048, 0.54755926, 0.43325692, 0.34370604,
+             0.27464288, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 3.07277966, 1.72759056, 1.12534678, 0.803307, 0.59516323, 0.45573691, 0.36617002, 0.29807833,
+             0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 3.07277966, 1.72759056, 1.12534678, 0.803307, 0.59516323, 0.4783645, 0.38853383, 0.32104823,
+             0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.45070267, 1.51179266, 1.01931262, 0.74807048, 0.57119018, 0.45573691,
+             0.36617002, 0.32104823, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 5.85520077, 2.6383388, 1.61558151, 1.08895338, 0.803307, 0.61951244, 0.50118381, 0.41087446,
+             0.34370604, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 5.85520077, 2.6383388, 1.61558151, 1.08895338, 0.803307, 0.64427125, 0.52423614, 0.43325692,
+             0.36617002, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 5.85520077, 2.6383388, 1.61558151, 1.08895338, 0.803307, 0.64427125, 0.52423614, 0.45573691,
+             0.38853383, 0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+        ],
+        1.40: [
+            [14.61464119, 0.59516323, 0.02916753],
+            [14.61464119, 0.95350921, 0.34370604, 0.02916753],
+            [14.61464119, 1.08895338, 0.43325692, 0.13792117, 0.02916753],
+            [14.61464119, 1.56271636, 0.64427125, 0.27464288, 0.09824532, 0.02916753],
+            [14.61464119, 1.61558151, 0.803307, 0.43325692, 0.22545385, 0.09824532, 0.02916753],
+            [14.61464119, 2.05039096, 0.95350921, 0.54755926, 0.34370604, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.24153244, 0.72133851, 0.43325692, 0.27464288, 0.17026083, 0.09824532,
+             0.02916753],
+            [14.61464119, 2.45070267, 1.24153244, 0.74807048, 0.50118381, 0.34370604, 0.25053367, 0.17026083,
+             0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.28281462, 0.803307, 0.52423614, 0.36617002, 0.27464288, 0.19894916, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.28281462, 0.803307, 0.54755926, 0.38853383, 0.29807833, 0.22545385, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.41535246, 0.86115354, 0.59516323, 0.43325692, 0.32104823, 0.25053367,
+             0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.51179266, 0.95350921, 0.64427125, 0.45573691, 0.34370604, 0.27464288,
+             0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.51179266, 0.95350921, 0.64427125, 0.4783645, 0.36617002, 0.29807833, 0.25053367,
+             0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.56271636, 0.98595673, 0.69515091, 0.52423614, 0.41087446, 0.34370604,
+             0.29807833, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.56271636, 1.01931262, 0.72133851, 0.54755926, 0.43325692, 0.36617002,
+             0.32104823, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 2.84484982, 1.61558151, 1.05362725, 0.74807048, 0.57119018, 0.45573691, 0.38853383,
+             0.34370604, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 2.84484982, 1.61558151, 1.08895338, 0.803307, 0.61951244, 0.50118381, 0.41087446, 0.36617002,
+             0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 2.84484982, 1.61558151, 1.08895338, 0.803307, 0.61951244, 0.50118381, 0.43325692, 0.38853383,
+             0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.61558151, 1.08895338, 0.803307, 0.64427125, 0.52423614, 0.45573691, 0.41087446,
+             0.36617002, 0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+        ],
+        1.45: [
+            [14.61464119, 0.59516323, 0.02916753],
+            [14.61464119, 0.803307, 0.25053367, 0.02916753],
+            [14.61464119, 0.95350921, 0.34370604, 0.09824532, 0.02916753],
+            [14.61464119, 1.24153244, 0.54755926, 0.25053367, 0.09824532, 0.02916753],
+            [14.61464119, 1.56271636, 0.72133851, 0.36617002, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 1.61558151, 0.803307, 0.45573691, 0.27464288, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 1.91321158, 0.95350921, 0.57119018, 0.36617002, 0.25053367, 0.17026083, 0.09824532,
+             0.02916753],
+            [14.61464119, 2.19988537, 1.08895338, 0.64427125, 0.41087446, 0.27464288, 0.19894916, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.24153244, 0.74807048, 0.50118381, 0.34370604, 0.25053367, 0.19894916,
+             0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.24153244, 0.74807048, 0.50118381, 0.36617002, 0.27464288, 0.22545385,
+             0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.28281462, 0.803307, 0.54755926, 0.41087446, 0.32104823, 0.25053367, 0.19894916,
+             0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.28281462, 0.803307, 0.57119018, 0.43325692, 0.34370604, 0.27464288, 0.22545385,
+             0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.28281462, 0.83188516, 0.59516323, 0.45573691, 0.36617002, 0.29807833,
+             0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.28281462, 0.83188516, 0.59516323, 0.45573691, 0.36617002, 0.32104823,
+             0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.51179266, 0.95350921, 0.69515091, 0.52423614, 0.41087446, 0.34370604,
+             0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 2.84484982, 1.51179266, 0.95350921, 0.69515091, 0.52423614, 0.43325692, 0.36617002,
+             0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 2.84484982, 1.56271636, 0.98595673, 0.72133851, 0.54755926, 0.45573691, 0.38853383,
+             0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.56271636, 1.01931262, 0.74807048, 0.57119018, 0.4783645, 0.41087446, 0.36617002,
+             0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 2.84484982, 1.56271636, 1.01931262, 0.74807048, 0.59516323, 0.50118381, 0.43325692,
+             0.38853383, 0.36617002, 0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916,
+             0.17026083, 0.13792117, 0.09824532, 0.02916753],
+        ],
+        1.50: [
+            [14.61464119, 0.54755926, 0.02916753],
+            [14.61464119, 0.803307, 0.25053367, 0.02916753],
+            [14.61464119, 0.86115354, 0.32104823, 0.09824532, 0.02916753],
+            [14.61464119, 1.24153244, 0.54755926, 0.25053367, 0.09824532, 0.02916753],
+            [14.61464119, 1.56271636, 0.72133851, 0.36617002, 0.19894916, 0.09824532, 0.02916753],
+            [14.61464119, 1.61558151, 0.803307, 0.45573691, 0.27464288, 0.17026083, 0.09824532, 0.02916753],
+            [14.61464119, 1.61558151, 0.83188516, 0.52423614, 0.34370604, 0.25053367, 0.17026083, 0.09824532,
+             0.02916753],
+            [14.61464119, 1.84880662, 0.95350921, 0.59516323, 0.38853383, 0.27464288, 0.19894916, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 1.84880662, 0.95350921, 0.59516323, 0.41087446, 0.29807833, 0.22545385, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 1.84880662, 0.95350921, 0.61951244, 0.43325692, 0.32104823, 0.25053367, 0.19894916,
+             0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.19988537, 1.12534678, 0.72133851, 0.50118381, 0.36617002, 0.27464288, 0.22545385,
+             0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.19988537, 1.12534678, 0.72133851, 0.50118381, 0.36617002, 0.29807833, 0.25053367,
+             0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.36326075, 1.24153244, 0.803307, 0.57119018, 0.43325692, 0.34370604, 0.29807833, 0.25053367,
+             0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.36326075, 1.24153244, 0.803307, 0.57119018, 0.43325692, 0.34370604, 0.29807833, 0.27464288,
+             0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.36326075, 1.24153244, 0.803307, 0.59516323, 0.45573691, 0.36617002, 0.32104823, 0.29807833,
+             0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.36326075, 1.24153244, 0.803307, 0.59516323, 0.45573691, 0.38853383, 0.34370604, 0.32104823,
+             0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117, 0.09824532,
+             0.02916753],
+            [14.61464119, 2.45070267, 1.32549286, 0.86115354, 0.64427125, 0.50118381, 0.41087446, 0.36617002,
+             0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083, 0.13792117,
+             0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.36964464, 0.92192322, 0.69515091, 0.54755926, 0.45573691, 0.41087446,
+             0.36617002, 0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+            [14.61464119, 2.45070267, 1.41535246, 0.95350921, 0.72133851, 0.57119018, 0.4783645, 0.43325692, 0.38853383,
+             0.36617002, 0.34370604, 0.32104823, 0.29807833, 0.27464288, 0.25053367, 0.22545385, 0.19894916, 0.17026083,
+             0.13792117, 0.09824532, 0.02916753],
+        ],
+    }
+
+    def get_sigmas(self, coeff, steps, denoise):
+        total_steps = steps
+        if denoise < 1.0:
+            if denoise <= 0.0:
+                return (torch.FloatTensor([]),)
+            total_steps = round(steps * denoise)
+
+        if steps <= 20:
+            sigmas = self.NOISE_LEVELS[round(coeff, 2)][steps-2][:]
+        else:
+            sigmas = self.NOISE_LEVELS[round(coeff, 2)][-1][:]
+            sigmas = loglinear_interp(sigmas, steps + 1)
+
+        sigmas = sigmas[-(total_steps + 1):]
+        sigmas[-1] = 0
+        return (torch.FloatTensor(sigmas), )
@@ -0,0 +1,201 @@
+import json
+import os
+import yaml
+import requests
+import pathlib
+from aiohttp import web
+from server import PromptServer
+from .image import tensor2pil, pil2tensor, image2base64, pil2byte
+from .log import log_node_error
+
+
+root_path = pathlib.Path(__file__).parent.parent.parent
+config_path = os.path.join(root_path,'config.yaml')
+default_key = [{'name':'Default', 'key':''}]
+
+class StabilityAPI:
+    def __init__(self):
+        self.api_url = "https://api.stability.ai"
+        self.api_keys = None
+        self.api_current = 0
+        self.user_info = {}
+        self.getAPIKeys()
+
+    def getErrors(self, code):
+        errors = {
+            400: "Bad Request",
+            403: "ApiKey Forbidden",
+            413: "Your request was larger than 10MiB.",
+            429: "You have made more than 150 requests in 10 seconds.",
+            500: "Internal Server Error",
+        }
+        return errors.get(code, "Unknown Error")
+
+    def getAPIKeys(self):
+        if os.path.isfile(config_path):
+            with open(config_path, 'r') as f:
+                data = yaml.load(f, Loader=yaml.FullLoader)
+                if not data:
+                    data = {'STABILITY_API_KEY': default_key, 'STABILITY_API_DEFAULT':0}
+                    with open(config_path, 'w') as f:
+                        yaml.dump(data, f)
+                if 'STABILITY_API_KEY' not in data:
+                    data['STABILITY_API_KEY'] = default_key
+                    data['STABILITY_API_DEFAULT'] = 0
+                    with open(config_path, 'w') as f:
+                        yaml.dump(data, f)
+                api_keys = data['STABILITY_API_KEY']
+                self.api_current = data['STABILITY_API_DEFAULT']
+                self.api_keys = api_keys
+                return api_keys
+        else:
+            # create a yaml file
+            with open(config_path, 'w') as f:
+                data = {'STABILITY_API_KEY': default_key, 'STABILITY_API_DEFAULT':0}
+                yaml.dump(data, f)
+                return data['STABILITY_API_KEY']
+        pass
+
+    def setAPIKeys(self, api_keys):
+        if len(api_keys) > 0:
+            self.api_keys = api_keys
+            # load and save the yaml file
+            with open(config_path, 'r') as f:
+                data = yaml.load(f, Loader=yaml.FullLoader)
+                data['STABILITY_API_KEY'] = api_keys
+                with open(config_path, 'w') as f:
+                    yaml.dump(data, f)
+        return True
+
+    def setAPIDefault(self, current):
+        if current is not None:
+            self.api_current = current
+            # load and save the yaml file
+            with open(config_path, 'r') as f:
+                data = yaml.load(f, Loader=yaml.FullLoader)
+                data['STABILITY_API_DEFAULT'] = current
+                with open(config_path, 'w') as f:
+                    yaml.dump(data, f)
+        return True
+
+    def generate_sd3_image(self, prompt, negative_prompt, aspect_ratio,  model, seed, mode='text-to-image', image=None, strength=1, output_format='png', node_name='easy stableDiffusion3API'):
+        url = f"{self.api_url}/v2beta/stable-image/generate/sd3"
+        api_key = self.api_keys[self.api_current]['key']
+        files = None
+        data = {
+            "prompt": prompt,
+            "mode": mode,
+            "model": model,
+            "seed": seed,
+            "output_format": output_format,
+        }
+        if model == 'sd3':
+            data['negative_prompt'] = negative_prompt
+
+        if mode == 'text-to-image':
+            files = {"none": ''}
+            data['aspect_ratio'] = aspect_ratio
+        elif mode == 'image-to-image':
+            pil_image = tensor2pil(image)
+            image_byte = pil2byte(pil_image)
+            files = {"image": ("output.png", image_byte, 'image/png')}
+            data['strength'] = strength
+
+        response = requests.post(url,
+            headers={"authorization": f"{api_key}", "accept": "application/json"},
+            files=files,
+            data=data,
+        )
+        if response.status_code == 200:
+            PromptServer.instance.send_sync('stable-diffusion-api-generate-succeed',{"model":model})
+            json_data = response.json()
+            image_base64 = json_data['image']
+            image_data = image2base64(image_base64)
+            output_t = pil2tensor(image_data)
+            return output_t
+        else:
+            if 'application/json' in response.headers['Content-Type']:
+                error_info = response.json()
+                log_node_error(node_name,  error_info.get('name', 'No name provided'))
+                log_node_error(node_name, error_info.get('errors', ['No details provided']))
+            error_status_text = self.getErrors(response.status_code)
+            PromptServer.instance.send_sync('easyuse-toast',{"type": "error", "content": error_status_text})
+            raise Exception(f"Failed to generate image: {error_status_text}")
+
+    # get user account
+    async def getUserAccount(self, cache=True):
+        url = f"{self.api_url}/v1/user/account"
+        api_key = self.api_keys[self.api_current]['key']
+        name = self.api_keys[self.api_current]['name']
+        if cache and name in self.user_info:
+            return self.user_info[name]
+        else:
+            response = requests.get(url, headers={"Authorization": f"Bearer {api_key}"})
+            if response.status_code == 200:
+                user_info = response.json()
+                self.user_info[name] = user_info
+                return user_info
+            else:
+                PromptServer.instance.send_sync('easyuse-toast',{'type': 'error', 'content': self.getErrors(response.status_code)})
+                return None
+
+    # get user balance
+    async def getUserBalance(self):
+        url = f"{self.api_url}/v1/user/balance"
+        api_key = self.api_keys[self.api_current]['key']
+        response = requests.get(url, headers={
+            "Authorization": f"Bearer {api_key}"
+        })
+        if response.status_code == 200:
+            return response.json()
+        else:
+            PromptServer.instance.send_sync('easyuse-toast', {'type': 'error', 'content': self.getErrors(response.status_code)})
+            return None
+
+stableAPI = StabilityAPI()
+
+
+@PromptServer.instance.routes.get("/easyuse/stability/api_keys")
+async def get_stability_api_keys(request):
+    stableAPI.getAPIKeys()
+    return web.json_response({"keys": stableAPI.api_keys, "current": stableAPI.api_current})
+
+@PromptServer.instance.routes.post("/easyuse/stability/set_api_keys")
+async def set_stability_api_keys(request):
+    post = await request.post()
+    api_keys = post.get("api_keys")
+    current = post.get('current')
+    if api_keys is not None:
+        api_keys = json.loads(api_keys)
+        stableAPI.setAPIKeys(api_keys)
+        if current is not None:
+            print(current)
+            stableAPI.setAPIDefault(int(current))
+            account = await stableAPI.getUserAccount()
+            balance = await stableAPI.getUserBalance()
+            return web.json_response({'account': account, 'balance': balance})
+        else:
+            return web.json_response({'status': 'ok'})
+    else:
+        return web.Response(status=400)
+
+@PromptServer.instance.routes.post("/easyuse/stability/set_apikey_default")
+async def set_stability_api_default(request):
+    post = await request.post()
+    current = post.get("current")
+    if current is not None and current < len(stableAPI.api_keys):
+        stableAPI.api_current = current
+        return web.json_response({'status': 'ok'})
+    else:
+        return web.Response(status=400)
+
+@PromptServer.instance.routes.get("/easyuse/stability/user_info")
+async def get_account_info(request):
+    account = await stableAPI.getUserAccount()
+    balance = await stableAPI.getUserBalance()
+    return web.json_response({'account': account, 'balance': balance})
+
+@PromptServer.instance.routes.get("/easyuse/stability/balance")
+async def get_balance_info(request):
+    balance = await stableAPI.getUserBalance()
+    return web.json_response({'balance': balance})
@@ -0,0 +1,148 @@
+import torch
+import torch.nn as nn
+from comfy.model_patcher import ModelPatcher
+from typing import Union
+
+T = torch.Tensor
+
+
+def exists(val):
+    return val is not None
+
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d
+
+
+class StyleAlignedArgs:
+    def __init__(self, share_attn: str) -> None:
+        self.adain_keys = "k" in share_attn
+        self.adain_values = "v" in share_attn
+        self.adain_queries = "q" in share_attn
+
+    share_attention: bool = True
+    adain_queries: bool = True
+    adain_keys: bool = True
+    adain_values: bool = True
+
+
+def expand_first(
+    feat: T,
+    scale=1.0,
+) -> T:
+    """
+    Expand the first element so it has the same shape as the rest of the batch.
+    """
+    b = feat.shape[0]
+    feat_style = torch.stack((feat[0], feat[b // 2])).unsqueeze(1)
+    if scale == 1:
+        feat_style = feat_style.expand(2, b // 2, *feat.shape[1:])
+    else:
+        feat_style = feat_style.repeat(1, b // 2, 1, 1, 1)
+        feat_style = torch.cat([feat_style[:, :1], scale * feat_style[:, 1:]], dim=1)
+    return feat_style.reshape(*feat.shape)
+
+
+def concat_first(feat: T, dim=2, scale=1.0) -> T:
+    """
+    concat the the feature and the style feature expanded above
+    """
+    feat_style = expand_first(feat, scale=scale)
+    return torch.cat((feat, feat_style), dim=dim)
+
+
+def calc_mean_std(feat, eps: float = 1e-5) -> "tuple[T, T]":
+    feat_std = (feat.var(dim=-2, keepdims=True) + eps).sqrt()
+    feat_mean = feat.mean(dim=-2, keepdims=True)
+    return feat_mean, feat_std
+
+def adain(feat: T) -> T:
+    feat_mean, feat_std = calc_mean_std(feat)
+    feat_style_mean = expand_first(feat_mean)
+    feat_style_std = expand_first(feat_std)
+    feat = (feat - feat_mean) / feat_std
+    feat = feat * feat_style_std + feat_style_mean
+    return feat
+
+class SharedAttentionProcessor:
+    def __init__(self, args: StyleAlignedArgs, scale: float):
+        self.args = args
+        self.scale = scale
+
+    def __call__(self, q, k, v, extra_options):
+        if self.args.adain_queries:
+            q = adain(q)
+        if self.args.adain_keys:
+            k = adain(k)
+        if self.args.adain_values:
+            v = adain(v)
+        if self.args.share_attention:
+            k = concat_first(k, -2, scale=self.scale)
+            v = concat_first(v, -2)
+
+        return q, k, v
+
+
+def get_norm_layers(
+    layer: nn.Module,
+    norm_layers_: "dict[str, list[Union[nn.GroupNorm, nn.LayerNorm]]]",
+    share_layer_norm: bool,
+    share_group_norm: bool,
+):
+    if isinstance(layer, nn.LayerNorm) and share_layer_norm:
+        norm_layers_["layer"].append(layer)
+    if isinstance(layer, nn.GroupNorm) and share_group_norm:
+        norm_layers_["group"].append(layer)
+    else:
+        for child_layer in layer.children():
+            get_norm_layers(
+                child_layer, norm_layers_, share_layer_norm, share_group_norm
+            )
+
+
+def register_norm_forward(
+    norm_layer: Union[nn.GroupNorm, nn.LayerNorm],
+) -> Union[nn.GroupNorm, nn.LayerNorm]:
+    if not hasattr(norm_layer, "orig_forward"):
+        setattr(norm_layer, "orig_forward", norm_layer.forward)
+    orig_forward = norm_layer.orig_forward
+
+    def forward_(hidden_states: T) -> T:
+        n = hidden_states.shape[-2]
+        hidden_states = concat_first(hidden_states, dim=-2)
+        hidden_states = orig_forward(hidden_states)  # type: ignore
+        return hidden_states[..., :n, :]
+
+    norm_layer.forward = forward_  # type: ignore
+    return norm_layer
+
+
+def register_shared_norm(
+    model: ModelPatcher,
+    share_group_norm: bool = True,
+    share_layer_norm: bool = True,
+):
+    norm_layers = {"group": [], "layer": []}
+    get_norm_layers(model.model, norm_layers, share_layer_norm, share_group_norm)
+    print(
+        f"Patching {len(norm_layers['group'])} group norms, {len(norm_layers['layer'])} layer norms."
+    )
+    return [register_norm_forward(layer) for layer in norm_layers["group"]] + [
+        register_norm_forward(layer) for layer in norm_layers["layer"]
+    ]
+
+
+SHARE_NORM_OPTIONS = ["both", "group", "layer", "disabled"]
+SHARE_ATTN_OPTIONS = ["q+k", "q+k+v", "disabled"]
+
+
+def styleAlignBatch(model, share_norm, share_attn, scale=1.0):
+    m = model.clone()
+    share_group_norm = share_norm in ["group", "both"]
+    share_layer_norm = share_norm in ["layer", "both"]
+    register_shared_norm(model, share_group_norm, share_layer_norm)
+    args = StyleAlignedArgs(share_attn)
+    m.set_model_attn1_patch(SharedAttentionProcessor(args, scale))
+    return m
@@ -0,0 +1,247 @@
+#credit to shadowcz007 for this module
+#from https://github.com/shadowcz007/comfyui-mixlab-nodes/blob/main/nodes/TextGenerateNode.py
+import re
+import os
+import folder_paths
+
+import comfy.utils
+import torch
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+
+from .utils import install_package
+try:
+    from lark import Lark, Transformer, v_args
+except:
+    print('install lark-parser...')
+    install_package('lark-parser')
+    from lark import Lark, Transformer, v_args
+
+model_path = os.path.join(folder_paths.models_dir, 'prompt_generator')
+zh_en_model_path = os.path.join(model_path, 'opus-mt-zh-en')
+zh_en_model, zh_en_tokenizer = None, None
+
+def correct_prompt_syntax(prompt=""):
+    # print("input prompt",prompt)
+    corrected_elements = []
+    # 处理成统一的英文标点
+    prompt = prompt.replace('（', '(').replace('）', ')').replace('，', ',').replace(';', ',').replace('。', '.').replace('：',':').replace('\\',',')
+    # 删除多余的空格
+    prompt = re.sub(r'\s+', ' ', prompt).strip()
+    prompt = prompt.replace("< ","<").replace(" >",">").replace("( ","(").replace(" )",")").replace("[ ","[").replace(' ]',']')
+
+    # 分词
+    prompt_elements = prompt.split(',')
+
+    def balance_brackets(element, open_bracket, close_bracket):
+        open_brackets_count = element.count(open_bracket)
+        close_brackets_count = element.count(close_bracket)
+        return element + close_bracket * (open_brackets_count - close_brackets_count)
+
+    for element in prompt_elements:
+        element = element.strip()
+
+        # 处理空元素
+        if not element:
+            continue
+
+        # 检查并处理圆括号、方括号、尖括号
+        if element[0] in '([':
+            corrected_element = balance_brackets(element, '(', ')') if element[0] == '(' else balance_brackets(element, '[', ']')
+        elif element[0] == '<':
+            corrected_element = balance_brackets(element, '<', '>')
+        else:
+            # 删除开头的右括号或右方括号
+            corrected_element = element.lstrip(')]')
+
+        corrected_elements.append(corrected_element)
+
+    # 重组修正后的prompt
+    return  ','.join(corrected_elements)
+
+def detect_language(input_str):
+    # 统计中文和英文字符的数量
+    count_cn = count_en = 0
+    for char in input_str:
+        if '\u4e00' <= char <= '\u9fff':
+            count_cn += 1
+        elif char.isalpha():
+            count_en += 1
+
+    # 根据统计的字符数量判断主要语言
+    if count_cn > count_en:
+        return "cn"
+    elif count_en > count_cn:
+        return "en"
+    else:
+        return "unknow"
+
+def has_chinese(text):
+    has_cn = False
+    _text = text
+    _text = re.sub(r'<.*?>', '', _text)
+    _text = re.sub(r'__.*?__', '', _text)
+    _text = re.sub(r'embedding:.*?$', '', _text)
+    for char in _text:
+        if '\u4e00' <= char <= '\u9fff':
+            has_cn = True
+            break
+        elif char.isalpha():
+            continue
+    return has_cn
+
+def translate(text):
+    global zh_en_model_path, zh_en_model, zh_en_tokenizer
+
+    if not os.path.exists(zh_en_model_path):
+        zh_en_model_path = 'Helsinki-NLP/opus-mt-zh-en'
+
+    if zh_en_model is None:
+
+        zh_en_model = AutoModelForSeq2SeqLM.from_pretrained(zh_en_model_path).eval()
+        zh_en_tokenizer = AutoTokenizer.from_pretrained(zh_en_model_path, padding=True, truncation=True)
+
+    zh_en_model.to("cuda" if torch.cuda.is_available() else "cpu")
+    with torch.no_grad():
+        encoded = zh_en_tokenizer([text], return_tensors="pt")
+        encoded.to(zh_en_model.device)
+        sequences = zh_en_model.generate(**encoded)
+        return zh_en_tokenizer.batch_decode(sequences, skip_special_tokens=True)[0]
+
+@v_args(inline=True)  # Decorator to flatten the tree directly into the function arguments
+class ChinesePromptTranslate(Transformer):
+
+    def sentence(self, *args):
+        return ", ".join(args)
+
+    def phrase(self, *args):
+        return "".join(args)
+
+    def emphasis(self, *args):
+        # Reconstruct the emphasis with translated content
+        return "(" + "".join(args) + ")"
+
+    def weak_emphasis(self, *args):
+        print('weak_emphasis:', args)
+        return "[" + "".join(args) + "]"
+
+    def embedding(self, *args):
+        print('prompt embedding', args[0])
+        if len(args) == 1:
+            embedding_name = str(args[0])
+            return f"embedding:{embedding_name}"
+        elif len(args) > 1:
+            embedding_name, *numbers = args
+
+            if len(numbers) == 2:
+                return f"embedding:{embedding_name}:{numbers[0]}:{numbers[1]}"
+            elif len(numbers) == 1:
+                return f"embedding:{embedding_name}:{numbers[0]}"
+            else:
+                return f"embedding:{embedding_name}"
+
+    def lora(self, *args):
+        if len(args) == 1:
+            return f"<lora:{args[0]}>"
+        elif len(args) > 1:
+            # print('lora', args)
+            _, loar_name, *numbers = args
+            loar_name = str(loar_name).strip()
+            if len(numbers) == 2:
+                return f"<lora:{loar_name}:{numbers[0]}:{numbers[1]}>"
+            elif len(numbers) == 1:
+                return f"<lora:{loar_name}:{numbers[0]}>"
+            else:
+                return f"<lora:{loar_name}>"
+
+    def weight(self, word, number):
+        translated_word = translate(str(word)).rstrip('.')
+        return f"({translated_word}:{str(number).strip()})"
+
+    def schedule(self, *args):
+        print('prompt schedule', args)
+        data = [str(arg).strip() for arg in args]
+
+        return f"[{':'.join(data)}]"
+
+    def word(self, word):
+        # Translate each word using the dictionary
+        word = str(word)
+        match_cn = re.search(r'@.*?@', word)
+        if re.search(r'__.*?__', word):
+            return word.rstrip('.')
+        elif match_cn:
+            chinese = match_cn.group()
+            before = word.split('@', 1)
+            before = before[0] if len(before) > 0 else ''
+            before = translate(str(before)).rstrip('.') if before else ''
+            after = word.rsplit('@', 1)
+            after = after[len(after)-1] if len(after) > 1 else ''
+            after = translate(after).rstrip('.') if after else ''
+            return before + chinese.replace('@', '').rstrip('.') + after
+        elif detect_language(word) == "cn":
+            return translate(word).rstrip('.')
+        else:
+            return word.rstrip('.')
+
+
+#定义Prompt文法
+grammar = """
+start: sentence
+sentence: phrase ("," phrase)*
+phrase: emphasis | weight | word | lora | embedding | schedule 
+emphasis: "(" sentence ")" -> emphasis
+        | "[" sentence "]" -> weak_emphasis
+weight: "(" word ":" NUMBER ")"
+schedule: "[" word ":" word ":" NUMBER "]"
+lora: "<" WORD ":" WORD (":" NUMBER)? (":" NUMBER)? ">"
+embedding: "embedding" ":" WORD (":" NUMBER)? (":" NUMBER)?
+word: WORD
+
+NUMBER: /\s*-?\d+(\.\d+)?\s*/
+WORD: /[^,:\(\)\[\]<>]+/
+"""
+def zh_to_en(text):
+    global zh_en_model_path, zh_en_model, zh_en_tokenizer
+    # 进度条
+    pbar = comfy.utils.ProgressBar(len(text) + 1)
+    texts = [correct_prompt_syntax(t) for t in text]
+
+    install_package('sentencepiece', '0.2.0')
+
+    if not os.path.exists(zh_en_model_path):
+        zh_en_model_path = 'Helsinki-NLP/opus-mt-zh-en'
+
+    if zh_en_model is None:
+        zh_en_model = AutoModelForSeq2SeqLM.from_pretrained(zh_en_model_path).eval()
+        zh_en_tokenizer = AutoTokenizer.from_pretrained(zh_en_model_path, padding=True, truncation=True)
+
+    zh_en_model.to("cuda" if torch.cuda.is_available() else "cpu")
+
+    prompt_result = []
+
+    en_texts = []
+
+    for t in texts:
+        if t:
+            # translated_text =  translated_word = translate(zh_en_tokenizer,zh_en_model,str(t))
+            parser = Lark(grammar, start="start", parser="lalr", transformer=ChinesePromptTranslate())
+            # print('t',t)
+            result = parser.parse(t).children
+            # print('en_result',result)
+            # en_text=translate(zh_en_tokenizer,zh_en_model,text_without_syntax)
+            en_texts.append(result[0])
+
+    zh_en_model.to('cpu')
+    # print("test en_text", en_texts)
+    # en_text.to("cuda" if torch.cuda.is_available() else "cpu")
+
+    pbar.update(1)
+    for t in en_texts:
+        prompt_result.append(t)
+        pbar.update(1)
+
+    # print('prompt_result', prompt_result, )
+    if len(prompt_result) == 0:
+        prompt_result = [""]
+
+    return prompt_result
@@ -5,6 +5,19 @@ class AlwaysEqualProxy(str):
    def __ne__(self, _):
        return False

+class TautologyStr(str):
+    def __ne__(self, other):
+        return False
+
+class ByPassTypeTuple(tuple):
+    def __getitem__(self, index):
+        if index>0:
+            index=0
+        item = super().__getitem__(index)
+        if isinstance(item, str):
+            return TautologyStr(item)
+        return item
+
 comfy_ui_revision = None
 def get_comfyui_revision():
    try:
@@ -17,6 +30,53 @@ def get_comfyui_revision():
        comfy_ui_revision = "Unknown"
    return comfy_ui_revision

+
+import sys
+import importlib.util
+import importlib.metadata
+import comfy.model_management as mm
+import gc
+from packaging import version
+from server import PromptServer
+def is_package_installed(package):
+    try:
+        module = importlib.util.find_spec(package)
+        return module is not None
+    except ImportError as e:
+        print(e)
+        return False
+
+def install_package(package, v=None, compare=True, compare_version=None):
+    run_install = True
+    if is_package_installed(package):
+        try:
+            installed_version = importlib.metadata.version(package)
+            if v is not None:
+                if compare_version is None:
+                    compare_version = v
+                if not compare or version.parse(installed_version) >= version.parse(compare_version):
+                    run_install = False
+            else:
+                run_install = False
+        except:
+            run_install = False
+
+    if run_install:
+        import subprocess
+        package_command = package + '==' + v if v is not None else package
+        PromptServer.instance.send_sync("easyuse-toast", {'content': f"Installing {package_command}...", 'duration': 5000})
+        result = subprocess.run([sys.executable, '-s', '-m', 'pip', 'install', package_command], capture_output=True, text=True)
+        if result.returncode == 0:
+            PromptServer.instance.send_sync("easyuse-toast", {'content': f"{package} installed successfully", 'type': 'success', 'duration': 5000})
+            print(f"Package {package} installed successfully")
+            return True
+        else:
+            PromptServer.instance.send_sync("easyuse-toast", {'content': f"{package} installed failed", 'type': 'error', 'duration': 5000})
+            print(f"Package {package} installed failed")
+            return False
+    else:
+        return False
+
 def compare_revision(num):
    global comfy_ui_revision
    if not comfy_ui_revision:
@@ -36,16 +96,6 @@ def find_tags(string: str, sep="/") -> list[str]:
        return string.split(sep)[:-1]
    return []

-import folder_paths
-def add_folder_path_and_extensions(folder_name, full_folder_paths, extensions):
-    for full_folder_path in full_folder_paths:
-        folder_paths.add_model_folder_path(folder_name, full_folder_path)
-    if folder_name in folder_paths.folder_names_and_paths:
-        current_paths, current_extensions = folder_paths.folder_names_and_paths[folder_name]
-        updated_extensions = current_extensions | extensions
-        folder_paths.folder_names_and_paths[folder_name] = (current_paths, updated_extensions)
-    else:
-        folder_paths.folder_names_and_paths[folder_name] = (full_folder_paths, extensions)

 from comfy.model_base import BaseModel
 import comfy.supported_models
@@ -55,10 +105,22 @@ def get_sd_version(model):
    model_config: comfy.supported_models.supported_models_base.BASE = base.model_config
    if isinstance(model_config, comfy.supported_models.SDXL):
        return 'sdxl'
+    elif isinstance(model_config, comfy.supported_models.SDXLRefiner):
+        return 'sdxl_refiner'
    elif isinstance(
            model_config, (comfy.supported_models.SD15, comfy.supported_models.SD20)
    ):
-        return 'sd15'
+        return 'sd1'
+    elif isinstance(
+            model_config, (comfy.supported_models.SVD_img2vid)
+    ):
+        return 'svd'
+    elif isinstance(model_config, comfy.supported_models.SD3):
+        return 'sd3'
+    elif isinstance(model_config, comfy.supported_models.HunyuanDiT):
+        return 'hydit'
+    elif isinstance(model_config, comfy.supported_models.Flux):
+        return 'flux'
    else:
        return 'unknown'

@@ -158,7 +220,7 @@ def get_local_filepath(url, dirname, local_file_name=None):
                download_url_to_file(url, destination)
            except Exception as err:
                PromptServer.instance.send_sync("easyuse-toast",
-                                                {'content': f'无法从 {url} 下载模型'}, type='error')
+                                                {'content': f'无法从 {url} 下载模型', 'type':'error'})
                raise Exception(f'无法从 {url} 下载，错误信息：{str(err.args[0])}')
    return destination

@@ -186,7 +248,7 @@ def easySave(images, filename_prefix, output_type, prompt=None, extra_pnginfo=No
    from nodes import PreviewImage, SaveImage
    if output_type == "Hide":
        return list()
-    if output_type == "Preview":
+    if output_type in ["Preview", "Preview&Choose"]:
        filename_prefix = 'easyPreview'
        results = PreviewImage().save_images(images, filename_prefix, prompt, extra_pnginfo)
        return results['ui']['images']
@@ -207,4 +269,9 @@ def getMetadata(filepath):
        if header_size <= 0:
            raise BufferError("Invalid header")

-        return header
+        return header
+
+def cleanGPUUsedForce():
+    gc.collect()
+    mm.unload_all_models()
+    mm.soft_empty_cache()
@@ -2,11 +2,12 @@ import os, torch
 from pathlib import Path
 from PIL import Image, ImageDraw, ImageFont
 from .utils import easySave
-from ..config import RESOURCES_DIR
-from ..log import log_node_warn
-from ..adv_encode import advanced_encode
+from .adv_encode import advanced_encode
 from .controlnet import easyControlnet
-from ..layer_diffuse.func import LayerDiffuse
+from .log import log_node_warn
+from ..layer_diffuse import LayerDiffuse
+from ..config import RESOURCES_DIR
+
 class easyXYPlot():

    def __init__(self, xyPlotData, save_prefix, image_output, prompt, extra_pnginfo, my_unique_id, sampler, easyCache):
@@ -185,7 +186,6 @@ class easyXYPlot():

        # 高级用法
        if plot_image_vars["x_node_type"] == "advanced" or plot_image_vars["y_node_type"] == "advanced":
-
            if self.x_type == "Seeds++ Batch" or self.y_type == "Seeds++ Batch":
                seed = int(x_value) if self.x_type == "Seeds++ Batch" else int(y_value)
            if self.x_type == "Steps" or self.y_type == "Steps":
@@ -287,28 +287,12 @@ class easyXYPlot():
                if plot_image_vars['clip_skip'] != 0:
                    clip.clip_layer(plot_image_vars['clip_skip'])

-            # Lora
-            if self.x_type == "Lora" or self.y_type == "Lora":
-                model = model if model is not None else plot_image_vars["model"]
-                clip = clip if clip is not None else plot_image_vars["clip"]
-
-                xy_values = x_value if self.x_type == "Lora" else y_value
-                lora_name, lora_model_strength, lora_clip_strength = xy_values.split(",")
-                lora_stack = [{"lora_name": lora_name, "model": model, "clip" :clip, "model_strength": float(lora_model_strength), "clip_strength": float(lora_clip_strength)}]
-                if 'lora_stack' in plot_image_vars:
-                    lora_stack = lora_stack + plot_image_vars['lora_stack']
-
-                if lora_stack is not None and lora_stack != []:
-                    for lora in lora_stack:
-                        model, clip = self.easyCache.load_lora(lora)
-
            # CheckPoint
            if self.x_type == "Checkpoint" or self.y_type == "Checkpoint":
                xy_values = x_value if self.x_type == "Checkpoint" else y_value
                ckpt_name, clip_skip, vae_name = xy_values.split(",")
                ckpt_name = ckpt_name.replace('*', ',')
                vae_name = vae_name.replace('*', ',')
-                print(ckpt_name)
                model, clip, vae, clip_vision = self.easyCache.load_checkpoint(ckpt_name)
                if vae_name != 'None':
                    vae = self.easyCache.load_vae(vae_name)
@@ -348,6 +332,21 @@ class easyXYPlot():
                    if "negative_cond" in plot_image_vars:
                        negative = negative + plot_image_vars["negative_cond"]

+            # Lora
+            if self.x_type == "Lora" or self.y_type == "Lora":
+                model = model if model is not None else plot_image_vars["model"]
+                clip = clip if clip is not None else plot_image_vars["clip"]
+
+                xy_values = x_value if self.x_type == "Lora" else y_value
+                lora_name, lora_model_strength, lora_clip_strength = xy_values.split(",")
+                lora_stack = [{"lora_name": lora_name, "model": model, "clip" :clip, "model_strength": float(lora_model_strength), "clip_strength": float(lora_clip_strength)}]
+                if 'lora_stack' in plot_image_vars:
+                    lora_stack = lora_stack + plot_image_vars['lora_stack']
+
+                if lora_stack is not None and lora_stack != []:
+                    for lora in lora_stack:
+                        model, clip = self.easyCache.load_lora(lora)
+
            # 提示词
            if "Positive" in self.x_type or "Positive" in self.y_type:
                if self.x_type == 'Positive Prompt S/R' or self.y_type == 'Positive Prompt S/R':
@@ -395,7 +394,7 @@ class easyXYPlot():
            model, clip, vae, clip_vision = self.easyCache.load_checkpoint(plot_image_vars['ckpt_name'])

            if plot_image_vars['lora_name'] != "None":
-                lora = {"lora_name": plot_image_vars['lora_name'], "model": model, "clip": clip, "model_strength": plot_image_vars['model_strength'], "clip_strength": plot_image_vars['lora_clip_strength']}
+                lora = {"lora_name": plot_image_vars['lora_name'], "model": model, "clip": clip, "model_strength": plot_image_vars['lora_model_strength'], "clip_strength": plot_image_vars['lora_clip_strength']}
                model, clip = self.easyCache.load_lora(lora)

            # Check for custom VAE
@@ -446,7 +445,6 @@ class easyXYPlot():

        samples = empty_samples if layer_diffusion_method is not None and empty_samples is not None else samples
        # Sample
-
        samples = self.sampler.common_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, samples,
                                          denoise=denoise, disable_noise=disable_noise, preview_latent=preview_latent,
                                          start_step=start_step, last_step=last_step,
@@ -1,10 +1,17 @@
 from typing import Iterator, List, Tuple, Dict, Any, Union, Optional
 from _decimal import Context, getcontext
 from decimal import Decimal
-from .libs.utils import AlwaysEqualProxy
-import torch
+from .libs.utils import AlwaysEqualProxy, ByPassTypeTuple, cleanGPUUsedForce, compare_revision
+from .libs.cache import remove_cache
 import numpy as np
+import re
 import json
+import torch
+import comfy.utils
+
+DEFAULT_FLOW_NUM = 2
+MAX_FLOW_NUM = 10
+lazy_options = {"lazy": True} if compare_revision(2543) else {}

 def validate_list_args(args: Dict[str, List[Any]]) -> Tuple[bool, Optional[str], Optional[str]]:
    """
@@ -75,7 +82,7 @@ class Int:
    @classmethod
    def INPUT_TYPES(s):
        return {
-            "required": {"value": ("INT", {"default": 0})},
+            "required": {"value": ("INT", {"default": 0, "min": -999999, "max": 999999,})},
        }

    RETURN_TYPES = ("INT",)
@@ -144,7 +151,7 @@ class Float:
    @classmethod
    def INPUT_TYPES(s):
        return {
-            "required": {"value": ("FLOAT", {"default": 0, "step": 0.01})},
+            "required": {"value": ("FLOAT", {"default": 0, "step": 0.01, "min": -999999, "max": 999999,})},
        }

    RETURN_TYPES = ("FLOAT",)
@@ -278,7 +285,490 @@ class imageSwitch:
        else:
            return (image_b, )

-# ---------------------------------------------------------------运算 开始----------------------------------------------------------------------#
+class textSwitch:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "input": ("INT", {"default": 1, "min": 1, "max": 2}),
+            },
+            "optional": {
+                "text1": ("STRING", {"forceInput": True}),
+                "text2": ("STRING", {"forceInput": True}),
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("STRING",)
+    CATEGORY = "EasyUse/Logic/Switch"
+    FUNCTION = "switch"
+
+    def switch(self, input, text1=None, text2=None,):
+        if input == 1:
+            return (text1,)
+        else:
+            return (text2,)
+
+# ---------------------------------------------------------------Index Switch----------------------------------------------------------------------#
+
+class anythingIndexSwitch:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs =  {
+            "required": {
+                "index": ("INT", {"default": 0, "min": 0, "max": 9, "step": 1}),
+            },
+            "optional": {
+            }
+        }
+        for i in range(DEFAULT_FLOW_NUM):
+            inputs["optional"]["value%d" % i] = (AlwaysEqualProxy("*"),lazy_options)
+        return inputs
+
+    RETURN_TYPES = (AlwaysEqualProxy("*"),)
+    RETURN_NAMES = ("value",)
+    FUNCTION = "index_switch"
+
+    CATEGORY = "EasyUse/Logic/Index Switch"
+
+    def check_lazy_status(self, index, **kwargs):
+        key = "value%d" % index
+        if kwargs.get(key, None) is None:
+            return [key]
+
+    def index_switch(self, index, **kwargs):
+        key = "value%d" % index
+        return (kwargs[key],)
+
+class imageIndexSwitch:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs =  {
+            "required": {
+                "index": ("INT", {"default": 0, "min": 0, "max": 9, "step": 1}),
+            },
+            "optional": {
+            }
+        }
+        for i in range(DEFAULT_FLOW_NUM):
+            inputs["optional"]["image%d" % i] = ("IMAGE",lazy_options)
+        return inputs
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "index_switch"
+
+    CATEGORY = "EasyUse/Logic/Index Switch"
+
+    def check_lazy_status(self, index, **kwargs):
+        key = "image%d" % index
+        if kwargs.get(key, None) is None:
+            return [key]
+
+    def index_switch(self, index, **kwargs):
+        key = "image%d" % index
+        return (kwargs[key],)
+
+class textIndexSwitch:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs =  {
+            "required": {
+                "index": ("INT", {"default": 0, "min": 0, "max": 9, "step": 1}),
+            },
+            "optional": {
+            }
+        }
+        for i in range(DEFAULT_FLOW_NUM):
+            inputs["optional"]["text%d" % i] = ("STRING",{**lazy_options,"forceInput":True})
+        return inputs
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+    FUNCTION = "index_switch"
+
+    CATEGORY = "EasyUse/Logic/Index Switch"
+
+    def check_lazy_status(self, index, **kwargs):
+        key = "text%d" % index
+        if kwargs.get(key, None) is None:
+            return [key]
+
+    def index_switch(self, index, **kwargs):
+        key = "text%d" % index
+        return (kwargs[key],)
+
+class conditioningIndexSwitch:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs =  {
+            "required": {
+                "index": ("INT", {"default": 0, "min": 0, "max": 9, "step": 1}),
+            },
+            "optional": {
+            }
+        }
+        for i in range(DEFAULT_FLOW_NUM):
+            inputs["optional"]["cond%d" % i] = ("CONDITIONING",lazy_options)
+        return inputs
+
+    RETURN_TYPES = ("CONDITIONING",)
+    RETURN_NAMES = ("conditioning",)
+    FUNCTION = "index_switch"
+
+    CATEGORY = "EasyUse/Logic/Index Switch"
+
+    def check_lazy_status(self, index, **kwargs):
+        key = "cond%d" % index
+        if kwargs.get(key, None) is None:
+            return [key]
+
+    def index_switch(self, index, **kwargs):
+        key = "cond%d" % index
+        return (kwargs[key],)
+
+# ---------------------------------------------------------------Math----------------------------------------------------------------------#
+class mathIntOperation:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "a": ("INT", {"default": 0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 1}),
+                "b": ("INT", {"default": 0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 1}),
+                "operation": (["add", "subtract", "multiply", "divide", "modulo", "power"],),
+            },
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "int_math_operation"
+
+    CATEGORY = "EasyUse/Logic/Math"
+
+    def int_math_operation(self, a, b, operation):
+        if operation == "add":
+            return (a + b,)
+        elif operation == "subtract":
+            return (a - b,)
+        elif operation == "multiply":
+            return (a * b,)
+        elif operation == "divide":
+            return (a // b,)
+        elif operation == "modulo":
+            return (a % b,)
+        elif operation == "power":
+            return (a ** b,)
+
+class mathFloatOperation:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "a": ("FLOAT", {"default": 0, "min": -999999999999.0, "max": 999999999999.0, "step": 1}),
+                "b": ("FLOAT", {"default": 0, "min": -999999999999.0, "max": 999999999999.0, "step": 1}),
+                "operation": (["==", "!=", "<", ">", "<=", ">="],),
+            },
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    FUNCTION = "float_math_operation"
+
+    CATEGORY = "EasyUse/Logic/Math"
+
+    def float_math_operation(self, a, b, operation):
+        if operation == "==":
+            return (a == b,)
+        elif operation == "!=":
+            return (a != b,)
+        elif operation == "<":
+            return (a < b,)
+        elif operation == ">":
+            return (a > b,)
+        elif operation == "<=":
+            return (a <= b,)
+        elif operation == ">=":
+            return (a >= b,)
+
+class mathStringOperation:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "a": ("STRING", {"multiline": False}),
+                "b": ("STRING", {"multiline": False}),
+                "operation": (["a == b", "a != b", "a IN b", "a MATCH REGEX(b)", "a BEGINSWITH b", "a ENDSWITH b"],),
+                "case_sensitive": ("BOOLEAN", {"default": True}),
+            },
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    FUNCTION = "string_math_operation"
+
+    CATEGORY = "EasyUse/Logic/Math"
+
+    def string_math_operation(self, a, b, operation, case_sensitive):
+        if not case_sensitive:
+            a = a.lower()
+            b = b.lower()
+
+        if operation == "a == b":
+            return (a == b,)
+        elif operation == "a != b":
+            return (a != b,)
+        elif operation == "a IN b":
+            return (a in b,)
+        elif operation == "a MATCH REGEX(b)":
+            try:
+                return (re.match(b, a) is not None,)
+            except:
+                return (False,)
+        elif operation == "a BEGINSWITH b":
+            return (a.startswith(b),)
+        elif operation == "a ENDSWITH b":
+            return (a.endswith(b),)
+
+# ---------------------------------------------------------------Flow----------------------------------------------------------------------#
+try:
+    from comfy_execution.graph_utils import GraphBuilder, is_link
+except:
+    GraphBuilder = None
+
+class whileLoopStart:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs = {
+            "required": {
+                "condition": ("BOOLEAN", {"default": True}),
+            },
+            "optional": {
+            },
+        }
+        for i in range(MAX_FLOW_NUM):
+            inputs["optional"]["initial_value%d" % i] = ("*",)
+        return inputs
+
+    RETURN_TYPES = ByPassTypeTuple(tuple(["FLOW_CONTROL"] + ["*"] * MAX_FLOW_NUM))
+    RETURN_NAMES = ByPassTypeTuple(tuple(["flow"] + ["value%d" % i for i in range(MAX_FLOW_NUM)]))
+    FUNCTION = "while_loop_open"
+
+    CATEGORY = "EasyUse/Logic/While Loop"
+
+    def while_loop_open(self, condition, **kwargs):
+        values = []
+        for i in range(MAX_FLOW_NUM):
+            values.append(kwargs.get("initial_value%d" % i, None))
+        return tuple(["stub"] + values)
+
+class whileLoopEnd:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs = {
+            "required": {
+                "flow": ("FLOW_CONTROL", {"rawLink": True}),
+                "condition": ("BOOLEAN", {}),
+            },
+            "optional": {
+            },
+            "hidden": {
+                "dynprompt": "DYNPROMPT",
+                "unique_id": "UNIQUE_ID",
+            }
+        }
+        for i in range(MAX_FLOW_NUM):
+            inputs["optional"]["initial_value%d" % i] = (AlwaysEqualProxy('*'),)
+        return inputs
+
+    RETURN_TYPES = ByPassTypeTuple(tuple([AlwaysEqualProxy('*')] * MAX_FLOW_NUM))
+    RETURN_NAMES = ByPassTypeTuple(tuple(["value%d" % i for i in range(MAX_FLOW_NUM)]))
+    FUNCTION = "while_loop_close"
+
+    CATEGORY = "EasyUse/Logic/While Loop"
+
+    def explore_dependencies(self, node_id, dynprompt, upstream):
+        node_info = dynprompt.get_node(node_id)
+        if "inputs" not in node_info:
+            return
+        for k, v in node_info["inputs"].items():
+            if is_link(v):
+                parent_id = v[0]
+                if parent_id not in upstream:
+                    upstream[parent_id] = []
+                    self.explore_dependencies(parent_id, dynprompt, upstream)
+                upstream[parent_id].append(node_id)
+
+    def collect_contained(self, node_id, upstream, contained):
+        if node_id not in upstream:
+            return
+        for child_id in upstream[node_id]:
+            if child_id not in contained:
+                contained[child_id] = True
+                self.collect_contained(child_id, upstream, contained)
+
+
+    def while_loop_close(self, flow, condition, dynprompt=None, unique_id=None, **kwargs):
+        if not condition:
+            # We're done with the loop
+            values = []
+            for i in range(MAX_FLOW_NUM):
+                values.append(kwargs.get("initial_value%d" % i, None))
+            return tuple(values)
+
+        # We want to loop
+        this_node = dynprompt.get_node(unique_id)
+        upstream = {}
+        # Get the list of all nodes between the open and close nodes
+        self.explore_dependencies(unique_id, dynprompt, upstream)
+
+        contained = {}
+        open_node = flow[0]
+        self.collect_contained(open_node, upstream, contained)
+        contained[unique_id] = True
+        contained[open_node] = True
+
+        graph = GraphBuilder()
+        for node_id in contained:
+            original_node = dynprompt.get_node(node_id)
+            node = graph.node(original_node["class_type"], "Recurse" if node_id == unique_id else node_id)
+            node.set_override_display_id(node_id)
+        for node_id in contained:
+            original_node = dynprompt.get_node(node_id)
+            node = graph.lookup_node("Recurse" if node_id == unique_id else node_id)
+            for k, v in original_node["inputs"].items():
+                if is_link(v) and v[0] in contained:
+                    parent = graph.lookup_node(v[0])
+                    node.set_input(k, parent.out(v[1]))
+                else:
+                    node.set_input(k, v)
+
+        new_open = graph.lookup_node(open_node)
+        for i in range(MAX_FLOW_NUM):
+            key = "initial_value%d" % i
+            new_open.set_input(key, kwargs.get(key, None))
+        my_clone = graph.lookup_node("Recurse")
+        result = map(lambda x: my_clone.out(x), range(MAX_FLOW_NUM))
+        return {
+            "result": tuple(result),
+            "expand": graph.finalize(),
+        }
+
+class forLoopStart:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "total": ("INT", {"default": 1, "min": 1, "max": 100000, "step": 1}),
+            },
+            "optional": {
+                "initial_value%d" % i: (AlwaysEqualProxy("*"),) for i in range(1, MAX_FLOW_NUM)
+            },
+            "hidden": {
+                "initial_value0": (AlwaysEqualProxy("*"),),
+                "prompt": "PROMPT",
+                "extra_pnginfo": "EXTRA_PNGINFO",
+                "unique_id": "UNIQUE_ID"
+            }
+        }
+
+    RETURN_TYPES = ByPassTypeTuple(tuple(["FLOW_CONTROL", "INT"] + [AlwaysEqualProxy("*")] * (MAX_FLOW_NUM - 1)))
+    RETURN_NAMES = ByPassTypeTuple(tuple(["flow", "index"] + ["value%d" % i for i in range(1, MAX_FLOW_NUM)]))
+    FUNCTION = "for_loop_start"
+
+    CATEGORY = "EasyUse/Logic/For Loop"
+
+    def for_loop_start(self, total, prompt=None, extra_pnginfo=None, unique_id=None, **kwargs):
+        graph = GraphBuilder()
+        i = 0
+        unique_id = unique_id.split('.')[len(unique_id.split('.'))-1] if "." in unique_id else unique_id
+        node = next((x for x in extra_pnginfo['workflow']['nodes'] if x['id'] == int(unique_id)), None)
+        if node:
+            node['properties']['total'] = total
+        if "initial_value0" in kwargs:
+            i = kwargs["initial_value0"]
+        initial_values = {("initial_value%d" % num): kwargs.get("initial_value%d" % num, None) for num in range(1, MAX_FLOW_NUM)}
+        while_open = graph.node("easy whileLoopStart", condition=total, initial_value0=i, **initial_values)
+        outputs = [kwargs.get("initial_value%d" % num, None) for num in range(1, MAX_FLOW_NUM)]
+        return {
+            "result": tuple(["stub", i] + outputs),
+            "expand": graph.finalize(),
+        }
+
+class forLoopEnd:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "flow": ("FLOW_CONTROL", {"rawLink": True}),
+            },
+            "optional": {
+                "initial_value%d" % i: (AlwaysEqualProxy("*"), {"rawLink": True}) for i in range(1, MAX_FLOW_NUM)
+            },
+            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO", "my_unique_id": "UNIQUE_ID"},
+        }
+
+    RETURN_TYPES = ByPassTypeTuple(tuple([AlwaysEqualProxy("*")] * (MAX_FLOW_NUM - 1)))
+    RETURN_NAMES = ByPassTypeTuple(tuple(["value%d" % i for i in range(1, MAX_FLOW_NUM)]))
+    FUNCTION = "for_loop_end"
+
+    CATEGORY = "EasyUse/Logic/For Loop"
+
+    def for_loop_end(self, flow, prompt=None, extra_pnginfo=None, my_unique_id=None, **kwargs):
+        graph = GraphBuilder()
+        while_open = flow[0]
+        total = None
+        if extra_pnginfo:
+            node = next((x for x in extra_pnginfo['workflow']['nodes'] if x['id'] == int(while_open)), None)
+            if node:
+                if 'properties' in node and 'total' in node['properties']:
+                    total = node['properties']['total']
+                else:
+                    total = node['widgets_values'][0] if "widgets_values" in node else None
+        if total is None:
+            raise Exception("Unable to get parameters for the start of the loop")
+        sub = graph.node("easy mathInt", operation="add", a=[while_open, 1], b=1)
+        cond = graph.node("easy compare", a=sub.out(0), b=total, comparison='a < b')
+        input_values = {("initial_value%d" % i): kwargs.get("initial_value%d" % i, None) for i in
+                        range(1, MAX_FLOW_NUM)}
+        while_close = graph.node("easy whileLoopEnd",
+                                 flow=flow,
+                                 condition=cond.out(0),
+                                 initial_value0=sub.out(0),
+                                 **input_values)
+        return {
+            "result": tuple([while_close.out(i) for i in range(1, MAX_FLOW_NUM)]),
+            "expand": graph.finalize(),
+        }

 COMPARE_FUNCTIONS = {
    "a == b": lambda a, b: a == b,
@@ -293,46 +783,70 @@ COMPARE_FUNCTIONS = {
 class Compare:
    @classmethod
    def INPUT_TYPES(s):
-        s.compare_functions = list(COMPARE_FUNCTIONS.keys())
+        compare_functions = list(COMPARE_FUNCTIONS.keys())
        return {
            "required": {
                "a": (AlwaysEqualProxy("*"), {"default": 0}),
                "b": (AlwaysEqualProxy("*"), {"default": 0}),
-                "comparison": (s.compare_functions, {"default": "a == b"}),
+                "comparison": (compare_functions, {"default": "a == b"}),
            },
        }

    RETURN_TYPES = ("BOOLEAN",)
    RETURN_NAMES = ("boolean",)
    FUNCTION = "compare"
-    CATEGORY = "EasyUse/Logic/Math"
+    CATEGORY = "EasyUse/Logic"

    def compare(self, a, b, comparison):
        return (COMPARE_FUNCTIONS[comparison](a, b),)

 # 判断
-class If:
+class IfElse:
    @classmethod
    def INPUT_TYPES(s):
        return {
            "required": {
-                "any": (AlwaysEqualProxy("*"),),
-                "if": (AlwaysEqualProxy("*"),),
-                "else": (AlwaysEqualProxy("*"),),
+                "boolean": ("BOOLEAN",),
+                "on_true": (AlwaysEqualProxy("*"), lazy_options),
+                "on_false": (AlwaysEqualProxy("*"), lazy_options),
            },
        }

    RETURN_TYPES = (AlwaysEqualProxy("*"),)
-    RETURN_NAMES = ("?",)
+    RETURN_NAMES = ("*",)
    FUNCTION = "execute"
-    CATEGORY = "EasyUse/Logic/Math"
+    CATEGORY = "EasyUse/Logic"
+
+    def check_lazy_status(self, boolean, on_true=None, on_false=None):
+        if boolean and on_true is None:
+            return ["on_true"]
+        if not boolean and on_false is None:
+            return ["on_false"]

    def execute(self, *args, **kwargs):
-        return (kwargs['if'] if kwargs['any'] else kwargs['else'],)
-
+        return (kwargs['on_true'] if kwargs['boolean'] else kwargs['on_false'],)

 #是否为SDXL
 from comfy.sdxl_clip import SDXLClipModel, SDXLRefinerClipModel, SDXLClipG
+class isNone:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "any": (AlwaysEqualProxy("*"),)
+            },
+            "optional": {
+            }
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    RETURN_NAMES = ("boolean",)
+    FUNCTION = "execute"
+    CATEGORY = "EasyUse/Logic"
+
+    def execute(self, any):
+        return (True if any is None else False,)
+
 class isSDXL:
    @classmethod
    def INPUT_TYPES(s):
@@ -395,24 +909,66 @@ class xyAny:

        return (new_x, new_y)

+class batchAnything:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "any_1": (AlwaysEqualProxy("*"),{}),
+                "any_2": (AlwaysEqualProxy("*"),{})
+            }
+        }
+
+    RETURN_TYPES = (AlwaysEqualProxy("*"),)
+    RETURN_NAMES = ("batch",)
+
+    FUNCTION = "batch"
+    CATEGORY = "EasyUse/Logic"
+
+    def batch(self, any_1, any_2):
+        if isinstance(any_1, torch.Tensor) or isinstance(any_2, torch.Tensor):
+            if any_1 is None:
+                return (any_2,)
+            elif any_2 is None:
+                return (any_1,)
+            if any_1.shape[1:] != any_2.shape[1:]:
+                any_2 = comfy.utils.common_upscale(any_2.movedim(-1, 1), any_1.shape[2], any_1.shape[1], "bilinear", "center").movedim(1, -1)
+            return (torch.cat((any_1, any_2), 0),)
+        elif isinstance(any_1, (str, float, int)):
+            if any_2 is None:
+                return (any_1,)
+            elif isinstance(any_2, tuple):
+                return (any_2 + (any_1,),)
+            return ((any_1, any_2),)
+        elif isinstance(any_2, (str, float, int)):
+            if any_1 is None:
+                return (any_2,)
+            elif isinstance(any_1, tuple):
+                return (any_1 + (any_2,),)
+            return ((any_2, any_1),)
+        else:
+            if any_1 is None:
+                return (any_2,)
+            elif any_2 is None:
+                return (any_1,)
+            return (any_1 + any_2,)
+
 # 转换所有类型
-class ConvertAnything:
+class convertAnything:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": {
-            "anything": (AlwaysEqualProxy("*"),),
+            "*": (AlwaysEqualProxy("*"),),
            "output_type": (["string", "int", "float", "boolean"], {"default": "string"}),
        }}

-    RETURN_TYPES = (AlwaysEqualProxy("*"),),
-    RETURN_NAMES = ('*',)
+    RETURN_TYPES = ByPassTypeTuple((AlwaysEqualProxy("*"),))
    OUTPUT_NODE = True
    FUNCTION = "convert"
    CATEGORY = "EasyUse/Logic"

    def convert(self, *args, **kwargs):
-        print(kwargs)
-        anything = kwargs['anything']
+        anything = kwargs['*']
        output_type = kwargs['output_type']
        params = None
        if output_type == 'string':
@@ -454,7 +1010,11 @@ class showAnything:
                    values.append(str(val))
                    pass

-        if unique_id and extra_pnginfo and "workflow" in extra_pnginfo[0]:
+        if not extra_pnginfo:
+            print("Error: extra_pnginfo is empty")
+        elif (not isinstance(extra_pnginfo[0], dict) or "workflow" not in extra_pnginfo[0]):
+            print("Error: extra_pnginfo[0] is not a dict or missing 'workflow' key")
+        else:
            workflow = extra_pnginfo[0]["workflow"]
            node = next((x for x in workflow["nodes"] if str(x["id"]) == unique_id[0]), None)
            if node:
@@ -492,6 +1052,24 @@ class showTensorShape:

        return {"ui": {"text": shapes}}

+class outputToList:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "tuple": (AlwaysEqualProxy("*"), {}),
+            }, "optional": {},
+        }
+
+    RETURN_TYPES = (AlwaysEqualProxy("*"),)
+    RETURN_NAMES = ("list",)
+    OUTPUT_IS_LIST = (True,)
+    FUNCTION = "output_to_List"
+    CATEGORY = "EasyUse/Logic"
+
+    def output_to_List(self, tuple):
+        return (tuple,)
+
 # cleanGpuUsed
 class cleanGPUUsed:
    @classmethod
@@ -507,12 +1085,10 @@ class cleanGPUUsed:
    CATEGORY = "EasyUse/Logic"

    def empty_cache(self, anything, unique_id=None, extra_pnginfo=None):
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-
+        cleanGPUUsedForce()
+        remove_cache('*')
        return ()

-from .libs.cache import remove_cache
 class clearCacheKey:
    @classmethod
    def INPUT_TYPES(s):
@@ -552,6 +1128,84 @@ class clearCacheAll:
        remove_cache('*')
        return ()

+# Deprecated
+class If:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "any": (AlwaysEqualProxy("*"),),
+                "if": (AlwaysEqualProxy("*"),),
+                "else": (AlwaysEqualProxy("*"),),
+            },
+        }
+
+    RETURN_TYPES = (AlwaysEqualProxy("*"),)
+    RETURN_NAMES = ("?",)
+    FUNCTION = "execute"
+    CATEGORY = "EasyUse/🚫 Deprecated"
+    DEPRECATED = True
+
+    def execute(self, *args, **kwargs):
+        return (kwargs['if'] if kwargs['any'] else kwargs['else'],)
+
+class poseEditor:
+  @classmethod
+  def INPUT_TYPES(s):
+    return {"required": {
+        "image": ("STRING", {"default":""})
+    }}
+
+  FUNCTION = "output_pose"
+  CATEGORY = "EasyUse/🚫 Deprecated"
+  DEPRECATED = True
+  RETURN_TYPES = ()
+  RETURN_NAMES = ()
+  def output_pose(self, image):
+      return ()
+
+class imageToMask:
+  @classmethod
+  def INPUT_TYPES(s):
+    return {"required": {
+        "image": ("IMAGE",),
+        "channel": (['red', 'green', 'blue'],),
+       }
+    }
+
+  RETURN_TYPES = ("MASK",)
+  FUNCTION = "convert"
+  CATEGORY = "EasyUse/🚫 Deprecated"
+  DEPRECATED = True
+
+  def convert_to_single_channel(self, image, channel='red'):
+    from PIL import Image
+    # Convert to RGB mode to access individual channels
+    image = image.convert('RGB')
+
+    # Extract the desired channel and convert to greyscale
+    if channel == 'red':
+      channel_img = image.split()[0].convert('L')
+    elif channel == 'green':
+      channel_img = image.split()[1].convert('L')
+    elif channel == 'blue':
+      channel_img = image.split()[2].convert('L')
+    else:
+      raise ValueError(
+        "Invalid channel option. Please choose 'red', 'green', or 'blue'.")
+
+    # Convert the greyscale channel back to RGB mode
+    channel_img = Image.merge(
+      'RGB', (channel_img, channel_img, channel_img))
+
+    return channel_img
+
+  def convert(self, image, channel='red'):
+    from .libs.image import pil2tensor, tensor2pil
+    image = self.convert_to_single_channel(tensor2pil(image), channel)
+    image = pil2tensor(image)
+    return (image.squeeze().mean(2),)
+
 NODE_CLASS_MAPPINGS = {
  "easy string": String,
  "easy int": Int,
@@ -559,17 +1213,35 @@ NODE_CLASS_MAPPINGS = {
  "easy float": Float,
  "easy rangeFloat": RangeFloat,
  "easy boolean": Boolean,
+  "easy mathString": mathStringOperation,
+  "easy mathInt": mathIntOperation,
+  "easy mathFloat": mathFloatOperation,
  "easy compare": Compare,
  "easy imageSwitch": imageSwitch,
-  "easy if": If,
+  "easy textSwitch": textSwitch,
+  "easy anythingIndexSwitch": anythingIndexSwitch,
+  "easy imageIndexSwitch": imageIndexSwitch,
+  "easy textIndexSwitch": textIndexSwitch,
+  "easy conditioningIndexSwitch": conditioningIndexSwitch,
+  "easy whileLoopStart": whileLoopStart,
+  "easy whileLoopEnd": whileLoopEnd,
+  "easy forLoopStart": forLoopStart,
+  "easy forLoopEnd": forLoopEnd,
+  "easy ifElse": IfElse,
+  "easy isNone": isNone,
  "easy isSDXL": isSDXL,
+  "easy outputToList": outputToList,
  "easy xyAny": xyAny,
-  "easy convertAnything": ConvertAnything,
+  "easy batchAnything": batchAnything,
+  "easy convertAnything": convertAnything,
  "easy showAnything": showAnything,
  "easy showTensorShape": showTensorShape,
  "easy clearCacheKey": clearCacheKey,
  "easy clearCacheAll": clearCacheAll,
  "easy cleanGpuUsed": cleanGPUUsed,
+  "easy if": If,
+  "easy poseEditor": poseEditor,
+  "easy imageToMask": imageToMask
 }
 NODE_DISPLAY_NAME_MAPPINGS = {
  "easy string": "String",
@@ -579,14 +1251,32 @@ NODE_DISPLAY_NAME_MAPPINGS = {
  "easy rangeFloat": "Range(Float)",
  "easy boolean": "Boolean",
  "easy compare": "Compare",
+  "easy mathString": "Math String",
+  "easy mathInt": "Math Int",
+  "easy mathFloat": "Math Float",
  "easy imageSwitch": "Image Switch",
-  "easy if": "If",
+  "easy textSwitch": "Text Switch",
+  "easy anythingIndexSwitch": "Any Index Switch",
+  "easy imageIndexSwitch": "Image Index Switch",
+  "easy textIndexSwitch": "Text Index Switch",
+  "easy conditioningIndexSwitch": "Conditioning Index Switch",
+  "easy whileLoopStart": "While Loop Start",
+  "easy whileLoopEnd": "While Loop End",
+  "easy forLoopStart": "For Loop Start",
+  "easy forLoopEnd": "For Loop End",
+  "easy ifElse": "If else",
+  "easy isNone": "Is None",
  "easy isSDXL": "Is SDXL",
+  "easy outputToList": "Output to List",
  "easy xyAny": "XYAny",
+  "easy batchAnything": "Batch Any",
  "easy convertAnything": "Convert Any",
  "easy showAnything": "Show Any",
  "easy showTensorShape": "Show Tensor Shape",
  "easy clearCacheKey": "Clear Cache Key",
  "easy clearCacheAll": "Clear Cache All",
-  "easy cleanGpuUsed": "Clean GPU Used"
+  "easy cleanGpuUsed": "Clean GPU Used",
+  "easy if": "If (🚫Deprecated)",
+  "easy poseEditor": "PoseEditor (🚫Deprecated)",
+  "easy imageToMask": "ImageToMask (🚫Deprecated)"
 }
@@ -2,9 +2,6 @@ import random
 import server
 from enum import Enum

-
-seed_nodes = ["easy wildcards","easy preSampling","easy preSamplingAdvanced","easy preSamplingSdTurbo","easy preSamplingDynamicCFG","easy preSamplingLayerDiffusion","easy preSamplingCascade","easy fullCascadeKSampler","easy fullkSampler","easy seed","easy latentNoisy", "easy preSamplingNoiseIn"]
-
 class SGmode(Enum):
    FIX = 1
    INCR = 2
@@ -123,41 +120,6 @@ def prompt_seed_update(json_data):
        # control after generated
        if mode is not None and not mode:
            control_seed(node[1], action, seed_is_global)
-    # else:
-    #     prompts = json_data['prompt'].items()
-    #     for k, v in prompts:
-    #         if 'class_type' not in v:
-    #             continue
-    #         cls = v['class_type']
-    #         if cls in seed_nodes:
-    #             extra_data = next((x for x in workflow["nodes"] if str(x["id"]) == k), None)
-    #             if extra_data is not None:
-    #                 inputs = extra_data.get('inputs')
-    #                 widgets_value = extra_data.get('widgets_values')
-    #                 widgets_length = len(widgets_value)
-    #                 if "disable" in widgets_value:
-    #                     break
-    #                 if inputs is not None and inputs != []:
-    #                     seed_num_input = next((x for x in inputs if x['name'] == 'seed_num' and x['type'] == 'INT'), None)
-    #                     if seed_num_input is not None:
-    #                         action = 'fixed'
-    #                     else:
-    #                         action = widgets_value[widgets_length - 1]
-    #                 else:
-    #                     control_index = widgets_length - 2 if cls == 'easy seed' else widgets_length - 1
-    #                     action = widgets_value[control_index]
-    #
-    #                 # print(action)
-    #                 node = k, v
-    #                 value = control_seed(node[1], action, False)
-    #
-    #                 if k not in seed_widget_map:
-    #                     continue
-    #
-    #                 if 'seed_num' in v['inputs']:
-    #                     if isinstance(v['inputs']['seed_num'], int):
-    #                         v['inputs']['seed_num'] = value
-

    return value is not None

@@ -0,0 +1,602 @@
+import os
+import comfy
+import folder_paths
+from .config import RESOURCES_DIR
+def load_preset(filename):
+    path = os.path.join(RESOURCES_DIR, filename)
+    path = os.path.abspath(path)
+    preset_list = []
+
+    if os.path.exists(path):
+        with open(path, 'r') as file:
+            for line in file:
+                preset_list.append(line.strip())
+
+        return preset_list
+    else:
+        return []
+def generate_floats(batch_count, first_float, last_float):
+    if batch_count > 1:
+        interval = (last_float - first_float) / (batch_count - 1)
+        values = [str(round(first_float + i * interval, 3)) for i in range(batch_count)]
+    else:
+        values = [str(first_float)] if batch_count == 1 else []
+    return "; ".join(values)
+
+def generate_ints(batch_count, first_int, last_int):
+    if batch_count > 1:
+        interval = (last_int - first_int) / (batch_count - 1)
+        values = [str(int(first_int + i * interval)) for i in range(batch_count)]
+    else:
+        values = [str(first_int)] if batch_count == 1 else []
+    # values = list(set(values))  # Remove duplicates
+    # values.sort()  # Sort in ascending order
+    return "; ".join(values)
+
+# Seed++ Batch
+class XYplot_SeedsBatch:
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "batch_count": ("INT", {"default": 3, "min": 1, "max": 50}), },
+        }
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, batch_count):
+
+        axis = "advanced: Seeds++ Batch"
+        xy_values = {"axis": axis, "values": batch_count}
+        return (xy_values,)
+
+# Step Values
+class XYplot_Steps:
+    parameters = ["steps", "start_at_step", "end_at_step",]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "target_parameter": (cls.parameters,),
+                "batch_count": ("INT", {"default": 3, "min": 0, "max": 50}),
+                "first_step": ("INT", {"default": 10, "min": 1, "max": 10000}),
+                "last_step": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                "first_start_step": ("INT", {"default": 0, "min": 0, "max": 10000}),
+                "last_start_step": ("INT", {"default": 10, "min": 0, "max": 10000}),
+                "first_end_step": ("INT", {"default": 10, "min": 0, "max": 10000}),
+                "last_end_step": ("INT", {"default": 20, "min": 0, "max": 10000}),
+            }
+        }
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, target_parameter, batch_count, first_step, last_step, first_start_step, last_start_step,
+                 first_end_step, last_end_step,):
+
+        axis, xy_first, xy_last = None, None, None
+
+        if target_parameter == "steps":
+            axis = "advanced: Steps"
+            xy_first = first_step
+            xy_last = last_step
+        elif target_parameter == "start_at_step":
+            axis = "advanced: StartStep"
+            xy_first = first_start_step
+            xy_last = last_start_step
+        elif target_parameter == "end_at_step":
+            axis = "advanced: EndStep"
+            xy_first = first_end_step
+            xy_last = last_end_step
+
+        values = generate_ints(batch_count, xy_first, xy_last)
+        return ({"axis": axis, "values": values},) if values is not None else (None,)
+
+class XYplot_CFG:
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "batch_count": ("INT", {"default": 3, "min": 0, "max": 50}),
+                "first_cfg": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 100.0}),
+                "last_cfg": ("FLOAT", {"default": 9.0, "min": 0.0, "max": 100.0}),
+            }
+        }
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, batch_count, first_cfg, last_cfg):
+        axis = "advanced: CFG Scale"
+        values = generate_floats(batch_count, first_cfg, last_cfg)
+        return ({"axis": axis, "values": values},) if values else (None,)
+
+# Step Values
+class XYplot_Sampler_Scheduler:
+    parameters = ["sampler", "scheduler", "sampler & scheduler"]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        samplers = ["None"] + comfy.samplers.KSampler.SAMPLERS
+        schedulers = ["None"] + comfy.samplers.KSampler.SCHEDULERS
+        inputs = {
+            "required": {
+                "target_parameter": (cls.parameters,),
+                "input_count": ("INT", {"default": 1, "min": 1, "max": 30, "step": 1})
+            }
+        }
+        for i in range(1, 30 + 1):
+            inputs["required"][f"sampler_{i}"] = (samplers,)
+            inputs["required"][f"scheduler_{i}"] = (schedulers,)
+
+        return inputs
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, target_parameter, input_count, **kwargs):
+        axis, values, = None, None,
+        if target_parameter == "scheduler":
+            axis = "advanced: Scheduler"
+            schedulers = [kwargs.get(f"scheduler_{i}") for i in range(1, input_count + 1)]
+            values = [scheduler for scheduler in schedulers if scheduler != "None"]
+        elif target_parameter == "sampler":
+            axis = "advanced: Sampler"
+            samplers = [kwargs.get(f"sampler_{i}") for i in range(1, input_count + 1)]
+            values = [sampler for sampler in samplers if sampler != "None"]
+        else:
+            axis = "advanced: Sampler&Scheduler"
+            samplers = [kwargs.get(f"sampler_{i}") for i in range(1, input_count + 1)]
+            schedulers = [kwargs.get(f"scheduler_{i}") for i in range(1, input_count + 1)]
+            values = []
+            for sampler, scheduler in zip(samplers, schedulers):
+                sampler = sampler if sampler else 'None'
+                scheduler = scheduler if scheduler else 'None'
+                values.append(sampler +','+ scheduler)
+        values = "; ".join(values)
+        return ({"axis": axis, "values": values},) if values else (None,)
+
+class XYplot_Denoise:
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "batch_count": ("INT", {"default": 3, "min": 0, "max": 50}),
+                "first_denoise": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.1}),
+                "last_denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.1}),
+            }
+        }
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, batch_count, first_denoise, last_denoise):
+        axis = "advanced: Denoise"
+        values = generate_floats(batch_count, first_denoise, last_denoise)
+        return ({"axis": axis, "values": values},) if values else (None,)
+
+# PromptSR
+class XYplot_PromptSR:
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs = {
+            "required": {
+                "target_prompt": (["positive", "negative"],),
+                "search_txt": ("STRING", {"default": "", "multiline": False}),
+                "replace_all_text": ("BOOLEAN", {"default": False}),
+                "replace_count": ("INT", {"default": 3, "min": 1, "max": 30 - 1}),
+            }
+        }
+
+        # Dynamically add replace_X inputs
+        for i in range(1, 30):
+            replace_key = f"replace_{i}"
+            inputs["required"][replace_key] = ("STRING", {"default": "", "multiline": False, "placeholder": replace_key})
+
+        return inputs
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, target_prompt, search_txt, replace_all_text, replace_count, **kwargs):
+        axis = None
+
+        if target_prompt == "positive":
+            axis = "advanced: Positive Prompt S/R"
+        elif target_prompt == "negative":
+            axis = "advanced: Negative Prompt S/R"
+
+        # Create base entry
+        values = [(search_txt, None, replace_all_text)]
+
+        if replace_count > 0:
+            # Append additional entries based on replace_count
+            values.extend([(search_txt, kwargs.get(f"replace_{i+1}"), replace_all_text) for i in range(replace_count)])
+        return ({"axis": axis, "values": values},) if values is not None else (None,)
+
+# XYPlot Pos Condition
+class XYplot_Positive_Cond:
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs = {
+            "optional": {
+                "positive_1": ("CONDITIONING",),
+                "positive_2": ("CONDITIONING",),
+                "positive_3": ("CONDITIONING",),
+                "positive_4": ("CONDITIONING",),
+            }
+        }
+
+        return inputs
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, positive_1=None, positive_2=None, positive_3=None, positive_4=None):
+        axis = "advanced: Pos Condition"
+        values = []
+        cond = []
+        # Create base entry
+        if positive_1 is not None:
+            values.append("0")
+            cond.append(positive_1)
+        if positive_2 is not None:
+            values.append("1")
+            cond.append(positive_2)
+        if positive_3 is not None:
+            values.append("2")
+            cond.append(positive_3)
+        if positive_4 is not None:
+            values.append("3")
+            cond.append(positive_4)
+
+        return ({"axis": axis, "values": values, "cond": cond},) if values is not None else (None,)
+
+# XYPlot Neg Condition
+class XYplot_Negative_Cond:
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        inputs = {
+            "optional": {
+                "negative_1": ("CONDITIONING",),
+                "negative_2": ("CONDITIONING",),
+                "negative_3": ("CONDITIONING",),
+                "negative_4": ("CONDITIONING",),
+            }
+        }
+
+        return inputs
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, negative_1=None, negative_2=None, negative_3=None, negative_4=None):
+        axis = "advanced: Neg Condition"
+        values = []
+        cond = []
+        # Create base entry
+        if negative_1 is not None:
+            values.append(0)
+            cond.append(negative_1)
+        if negative_2 is not None:
+            values.append(1)
+            cond.append(negative_2)
+        if negative_3 is not None:
+            values.append(2)
+            cond.append(negative_3)
+        if negative_4 is not None:
+            values.append(3)
+            cond.append(negative_4)
+
+        return ({"axis": axis, "values": values, "cond": cond},) if values is not None else (None,)
+
+# XYPlot Pos Condition List
+class XYplot_Positive_Cond_List:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "positive": ("CONDITIONING",),
+            }
+        }
+
+    INPUT_IS_LIST = True
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, positive):
+        axis = "advanced: Pos Condition"
+        values = []
+        cond = []
+        for index, c in enumerate(positive):
+            values.append(str(index))
+            cond.append(c)
+
+        return ({"axis": axis, "values": values, "cond": cond},) if values is not None else (None,)
+
+# XYPlot Neg Condition List
+class XYplot_Negative_Cond_List:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "negative": ("CONDITIONING",),
+            }
+        }
+
+    INPUT_IS_LIST = True
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, negative):
+        axis = "advanced: Neg Condition"
+        values = []
+        cond = []
+        for index, c in enumerate(negative):
+            values.append(index)
+            cond.append(c)
+
+        return ({"axis": axis, "values": values, "cond": cond},) if values is not None else (None,)
+
+# XY Plot: ControlNet
+class XYplot_Control_Net:
+    parameters = ["strength", "start_percent", "end_percent"]
+    @classmethod
+    def INPUT_TYPES(cls):
+        def get_file_list(filenames):
+            return [file for file in filenames if file != "put_models_here.txt" and "lllite" not in file]
+
+        return {
+            "required": {
+                "control_net_name": (get_file_list(folder_paths.get_filename_list("controlnet")),),
+                "image": ("IMAGE",),
+                "target_parameter": (cls.parameters,),
+                "batch_count": ("INT", {"default": 3, "min": 1, "max": 30}),
+                "first_strength": ("FLOAT", {"default": 0.0, "min": 0.00, "max": 10.0, "step": 0.01}),
+                "last_strength": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 10.0, "step": 0.01}),
+                "first_start_percent": ("FLOAT", {"default": 0.0, "min": 0.00, "max": 1.0, "step": 0.01}),
+                "last_start_percent": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 1.0, "step": 0.01}),
+                "first_end_percent": ("FLOAT", {"default": 0.0, "min": 0.00, "max": 1.0, "step": 0.01}),
+                "last_end_percent": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 1.0, "step": 0.01}),
+                "strength": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 10.0, "step": 0.01}),
+                "start_percent": ("FLOAT", {"default": 0.0, "min": 0.00, "max": 1.0, "step": 0.01}),
+                "end_percent": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, control_net_name, image, target_parameter, batch_count, first_strength, last_strength, first_start_percent,
+                 last_start_percent, first_end_percent, last_end_percent, strength, start_percent, end_percent):
+
+        axis, = None,
+
+        values = []
+
+        if target_parameter == "strength":
+            axis = "advanced: ControlNetStrength"
+
+            values.append([(control_net_name, image, first_strength, start_percent, end_percent)])
+            strength_increment = (last_strength - first_strength) / (batch_count - 1) if batch_count > 1 else 0
+            for i in range(1, batch_count - 1):
+                values.append([(control_net_name, image, first_strength + i * strength_increment, start_percent,
+                                end_percent)])
+            if batch_count > 1:
+                values.append([(control_net_name, image, last_strength, start_percent, end_percent)])
+
+        elif target_parameter == "start_percent":
+            axis = "advanced: ControlNetStart%"
+
+            percent_increment = (last_start_percent - first_start_percent) / (batch_count - 1) if batch_count > 1 else 0
+            values.append([(control_net_name, image, strength, first_start_percent, end_percent)])
+            for i in range(1, batch_count - 1):
+                values.append([(control_net_name, image, strength, first_start_percent + i * percent_increment,
+                                  end_percent)])
+
+            # Always add the last start_percent if batch_count is more than 1.
+            if batch_count > 1:
+                values.append((control_net_name, image, strength, last_start_percent, end_percent))
+
+        elif target_parameter == "end_percent":
+            axis = "advanced: ControlNetEnd%"
+
+            percent_increment = (last_end_percent - first_end_percent) / (batch_count - 1) if batch_count > 1 else 0
+            values.append([(control_net_name, image, image, strength, start_percent, first_end_percent)])
+            for i in range(1, batch_count - 1):
+                values.append([(control_net_name, image, strength, start_percent,
+                                  first_end_percent + i * percent_increment)])
+
+            if batch_count > 1:
+                values.append([(control_net_name, image, strength, start_percent, last_end_percent)])
+
+
+        return ({"axis": axis, "values": values},)
+
+
+#Checkpoints
+class XYplot_Checkpoint:
+
+    modes = ["Ckpt Names", "Ckpt Names+ClipSkip", "Ckpt Names+ClipSkip+VAE"]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+
+        checkpoints = ["None"] + folder_paths.get_filename_list("checkpoints")
+        vaes = ["Baked VAE"] + folder_paths.get_filename_list("vae")
+
+        inputs = {
+            "required": {
+                "input_mode": (cls.modes,),
+                "ckpt_count": ("INT", {"default": 3, "min": 0, "max": 10, "step": 1}),
+            }
+        }
+
+        for i in range(1, 10 + 1):
+            inputs["required"][f"ckpt_name_{i}"] = (checkpoints,)
+            inputs["required"][f"clip_skip_{i}"] = ("INT", {"default": -1, "min": -24, "max": -1, "step": 1})
+            inputs["required"][f"vae_name_{i}"] = (vaes,)
+
+        inputs["optional"] = {
+            "optional_lora_stack": ("LORA_STACK",)
+        }
+        return inputs
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, input_mode, ckpt_count, **kwargs):
+
+        axis = "advanced: Checkpoint"
+
+        checkpoints = [kwargs.get(f"ckpt_name_{i}") for i in range(1, ckpt_count + 1)]
+        clip_skips = [kwargs.get(f"clip_skip_{i}") for i in range(1, ckpt_count + 1)]
+        vaes = [kwargs.get(f"vae_name_{i}") for i in range(1, ckpt_count + 1)]
+
+        # Set None for Clip Skip and/or VAE if not correct modes
+        for i in range(ckpt_count):
+            if "ClipSkip" not in input_mode:
+                clip_skips[i] = 'None'
+            if "VAE" not in input_mode:
+                vaes[i] = 'None'
+
+        # Extend each sub-array with lora_stack if it's not None
+        values = [checkpoint.replace(',', '*')+','+str(clip_skip)+','+vae.replace(',', '*') for checkpoint, clip_skip, vae in zip(checkpoints, clip_skips, vaes) if
+                        checkpoint != "None"]
+
+        optional_lora_stack = kwargs.get("optional_lora_stack") if "optional_lora_stack" in kwargs else []
+
+        xy_values = {"axis": axis, "values": values, "lora_stack": optional_lora_stack}
+        return (xy_values,)
+
+#Loras
+class XYplot_Lora:
+
+    modes = ["Lora Names", "Lora Names+Weights"]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        loras = ["None"] + folder_paths.get_filename_list("loras")
+
+        inputs = {
+            "required": {
+                "input_mode": (cls.modes,),
+                "lora_count": ("INT", {"default": 3, "min": 0, "max": 10, "step": 1}),
+                "model_strength": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                "clip_strength": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+            }
+        }
+
+        for i in range(1, 10 + 1):
+            inputs["required"][f"lora_name_{i}"] = (loras,)
+            inputs["required"][f"model_str_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01})
+            inputs["required"][f"clip_str_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01})
+
+        inputs["optional"] = {
+            "optional_lora_stack": ("LORA_STACK",)
+        }
+        return inputs
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, input_mode, lora_count, model_strength, clip_strength, **kwargs):
+
+        axis = "advanced: Lora"
+        # Extract values from kwargs
+        loras = [kwargs.get(f"lora_name_{i}") for i in range(1, lora_count + 1)]
+        model_strs = [kwargs.get(f"model_str_{i}", model_strength) for i in range(1, lora_count + 1)]
+        clip_strs = [kwargs.get(f"clip_str_{i}", clip_strength) for i in range(1, lora_count + 1)]
+
+        # Use model_strength and clip_strength for the loras where values are not provided
+        if "Weights" not in input_mode:
+            for i in range(lora_count):
+                model_strs[i] = model_strength
+                clip_strs[i] = clip_strength
+
+        # Extend each sub-array with lora_stack if it's not None
+        values = [lora.replace(',', '*')+','+str(model_str)+','+str(clip_str) for lora, model_str, clip_str
+                    in zip(loras, model_strs, clip_strs) if lora != "None"]
+
+        optional_lora_stack = kwargs.get("optional_lora_stack") if "optional_lora_stack" in kwargs else []
+
+        xy_values = {"axis": axis, "values": values, "lora_stack": optional_lora_stack}
+        return (xy_values,)
+
+# 模型叠加
+class XYplot_ModelMergeBlocks:
+
+    @classmethod
+    def INPUT_TYPES(s):
+        checkpoints = folder_paths.get_filename_list("checkpoints")
+        vae = ["Use Model 1", "Use Model 2"] + folder_paths.get_filename_list("vae")
+
+        preset = ["Preset"]  # 20
+        preset += load_preset("mmb-preset.txt")
+        preset += load_preset("mmb-preset.custom.txt")
+
+        default_vectors = "1,0,0; \n0,1,0; \n0,0,1; \n1,1,0; \n1,0,1; \n0,1,1; "
+        return {
+            "required": {
+                "ckpt_name_1": (checkpoints,),
+                "ckpt_name_2": (checkpoints,),
+                "vae_use": (vae, {"default": "Use Model 1"}),
+                "preset": (preset, {"default": "preset"}),
+                "values": ("STRING", {"default": default_vectors, "multiline": True, "placeholder": 'Support 2 methods:\n\n1.input, middle, out in same line and insert values seperated by "; "\n\n2.model merge block number seperated by ", " in same line and insert values seperated by "; "'}),
+            },
+            "hidden": {"my_unique_id": "UNIQUE_ID"}
+        }
+
+    RETURN_TYPES = ("X_Y",)
+    RETURN_NAMES = ("X or Y",)
+    FUNCTION = "xy_value"
+
+    CATEGORY = "EasyUse/XY Inputs"
+
+    def xy_value(self, ckpt_name_1, ckpt_name_2, vae_use, preset, values, my_unique_id=None):
+
+        axis = "advanced: ModelMergeBlocks"
+        if ckpt_name_1 is None:
+            raise Exception("ckpt_name_1 is not found")
+        if ckpt_name_2 is None:
+            raise Exception("ckpt_name_2 is not found")
+
+        models = (ckpt_name_1, ckpt_name_2)
+
+        xy_values = {"axis":axis, "values":values, "models":models, "vae_use": vae_use}
+        return (xy_values,)
@@ -0,0 +1,15 @@
+[project]
+name = "comfyui-easy-use"
+description = "To enhance the usability of ComfyUI, optimizations and integrations have been implemented for several commonly used nodes."
+version = "1.2.2"
+license = { file = "LICENSE" }
+dependencies = ["diffusers>=0.25.0", "accelerate>=0.25.0", "clip_interrogator>=0.6.0", "sentencepiece", "lark-parser", "onnxruntime", "spandrel", "opencv-python"]
+
+[project.urls]
+Repository = "https://github.com/yolain/ComfyUI-Easy-Use"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "yolain"
+DisplayName = "ComfyUI-Easy-Use"
+Icon = ""
@@ -0,0 +1,4 @@
+numpy>=1.19.0
+huggingface_hub>=0.23.3
+transformers>=4.38.2
+protobuf>=4.25.3
@@ -1,2 +1,8 @@
 diffusers>=0.25.0
-aiohttp
+accelerate>=0.25.0
+clip_interrogator>=0.6.0
+lark-parser
+onnxruntime
+opencv-python
+sentencepiece
+spandrel
@@ -1,13 +0,0 @@
-#easyuse_groups_map{
-  flex-direction: column;
-  align-items: end;
-  display:flex;position: absolute;
-  top: 50px; left: 10px; width: 180px;
-  border-radius:12px;
-  min-height:100px;
-  max-height:400px;
-  color: var(--descrip-text);
-  background-color: var(--comfy-menu-bg);
-  padding: 10px 4px;
-  border: 1px solid var(--border-color);z-index: 999999999;padding-top: 0;
-}
@@ -1,48 +0,0 @@
-import {getLocale} from './utils.js'
-const locale = getLocale()
-
-const zhCN = {
-    // ExtraMenu
-    "💎 View Checkpoint Info...": "💎 查看 Checkpoint 信息...",
-    "💎 View Lora Info...": "💎 查看 Lora 信息...",
-    "🔃 Reload Node": "🔃 刷新节点",
-    // ModelInfo
-    "Updated At:": "最近更新：",
-    "Created At:": "首次发布：",
-    "✏️ Edit": "✏️ 编辑",
-    "💾 Save": "💾 保存",
-    "No notes": "当前还没有备注内容",
-    "Saving Notes...": "正在保存备注...",
-    "Type your notes here":"在这里输入备注内容",
-    "Notes": "备注",
-    "Type": "类型",
-    "Trained Words": "训练词",
-    "BaseModel": "基础算法",
-    "Details": "详情",
-    "Download": "下载量",
-    "Source": "来源",
-    "Saving Preview...": "正在保存预览图...",
-    "Saving Succeed":"保存成功",
-    "Saving Failed":"保存失败",
-    "No COMBO link": "沒有找到COMBO连接",
-    "Reboot ComfyUI":"重启ComfyUI",
-    "Are you sure you'd like to reboot the server?": "是否要重启ComfyUI？",
-    // GroupMap
-    "Groups Map (EasyUse)": "管理组 (EasyUse)",
-    "Reboot ComfyUI (EasyUse)": "重启服务 (EasyUse)",
-    "Always": "启用中",
-    "Bypass": "已忽略",
-    "Never": "已停用",
-    "Auto Sorting": "自动排序",
-    "Toggle `Show/Hide` can set mode of group, LongPress can set group nodes to never": "点击`启用中/已忽略`可设置组模式, 长按可停用该组节点",
-    // Quick
-    "Enable ALT+1~9 to paste nodes from nodes template (ComfyUI-Easy-Use)": "启用ALT1~9从节点模板粘贴到工作流 (ComfyUI-Easy-Use)",
-    "Enable process bar in queue button (ComfyUI-Easy-Use)": "启用提示词队列进度显示条 (ComfyUI-Easy-Use）",
-    "Enable ContextMenu Auto Nest Subdirectories (ComfyUI-Easy-Use)": "启用上下文菜单自动嵌套子目录 (ComfyUI-Easy-Use)",
-    "Too many thumbnails, have closed the display": "模型缩略图太多啦，为您关闭了显示"
-}
-
-export const $t = (key) => {
-    const cn = zhCN[key]
-    return locale === 'zh-CN' && cn ? cn : key
-}
@@ -1,298 +0,0 @@
-import { api } from "/scripts/api.js";
-import { app } from "/scripts/app.js";
-import {deepEqual, addCss, isLocalNetwork} from "../common/utils.js";
-import {$t} from '../common/i18n.js';
-import {toast} from "../common/toast.js";
-
-addCss('css/index.css')
-
-api.addEventListener("easyuse-toast",event=>{
-    const content = event.detail.content
-    const type = event.detail.type
-    const duration = event.detail.duration
-    if(!type){
-        toast.info(content, duration)
-    }
-    else{
-      toast.showToast({
-        id: `toast-${type}`,
-        content: `${toast[type+"_icon"]} ${content}`,
-        duration: duration || 3000,
-      })
-    }
-})
-app.registerExtension({
-    name: "comfy.easyUse",
-    init() {
-        // Canvas Menu
-        const getCanvasMenuOptions = LGraphCanvas.prototype.getCanvasMenuOptions;
-        LGraphCanvas.prototype.getCanvasMenuOptions = function () {
-            const options = getCanvasMenuOptions.apply(this, arguments);
-            let draggerEl = null
-            let isGroupMapcanMove = true
-            let old_groups = []
-            let emptyImg = new Image()
-            emptyImg.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=";
-
-            options.push(null,
-                // Groups Map
-                {
-                    content: '📜 '+ $t('Groups Map (EasyUse)'),
-                    callback: async() => {
-                        let groups = app.canvas.graph._groups
-                        let nodes = app.canvas.graph._nodes
-                        let old_nodes = groups.length
-                        let div =
-                            document.querySelector('#easyuse_groups_map') ||
-                            document.createElement('div')
-                        div.id = 'easyuse_groups_map'
-                        div.innerHTML = ''
-                        let btn = document.createElement('div')
-                        btn.style = `display: flex;
-                            width: calc(100% - 8px);
-                            justify-content: space-between;
-                            align-items: center;
-                            padding: 0 6px;
-                            height: 44px;`
-                        let hideBtn = document.createElement('button')
-                        let textB = document.createElement('p')
-                        btn.appendChild(textB)
-                        btn.appendChild(hideBtn)
-                        textB.style.fontSize = '11px'
-                        textB.innerHTML =  `<b>${$t('Groups Map (EasyUse)')}</b>`
-                        hideBtn.style = `float: right;color: var(--input-text);border-radius:6px;font-size:9px;
-                            background-color: var(--comfy-input-bg); border: 1px solid var(--border-color);cursor: pointer;padding: 5px;aspect-ratio: 1 / 1;`
-                        hideBtn.addEventListener('click', () => {
-                            div.style.display = 'none'
-                        })
-                        hideBtn.innerText = '❌'
-                        div.appendChild(btn)
-
-                        div.addEventListener('mousedown', function (e) {
-                            var startX = e.clientX
-                            var startY = e.clientY
-                            var offsetX = div.offsetLeft
-                            var offsetY = div.offsetTop
-
-                            function moveBox (e) {
-                              var newX = e.clientX
-                              var newY = e.clientY
-                              var deltaX = newX - startX
-                              var deltaY = newY - startY
-                              div.style.left = offsetX + deltaX + 'px'
-                              div.style.top = offsetY + deltaY + 'px'
-                            }
-
-                            function stopMoving () {
-                              document.removeEventListener('mousemove', moveBox)
-                              document.removeEventListener('mouseup', stopMoving)
-                            }
-
-                            if(isGroupMapcanMove){
-                                document.addEventListener('mousemove', moveBox)
-                                document.addEventListener('mouseup', stopMoving)
-                            }
-                        })
-
-                        function updateGroups(groups, groupsDiv, autoSortDiv){
-                            if(groups.length>0){
-                                autoSortDiv.style.display = 'block'
-                            }else autoSortDiv.style.display = 'none'
-                            for (let index in groups) {
-                                const group = groups[index]
-                                const title = group.title
-                                const show_text = $t('Always')
-                                const hide_text = $t('Bypass')
-                                const mute_text = $t('Never')
-                                let group_item = document.createElement('div')
-                                let group_item_style = `justify-content: space-between;display:flex;background-color: var(--comfy-input-bg);border-radius: 5px;border:1px solid var(--border-color);margin-top:5px;`
-                                group_item.addEventListener("mouseover",event=>{
-                                    event.preventDefault()
-                                    group_item.style = group_item_style + "filter:brightness(1.2);"
-                                })
-                                group_item.addEventListener("mouseleave",event=>{
-                                    event.preventDefault()
-                                    group_item.style = group_item_style + "filter:brightness(1);"
-                                })
-                                group_item.addEventListener("dragstart",e=>{
-                                    draggerEl = e.currentTarget;
-                                    e.currentTarget.style.opacity = "0.6";
-									e.currentTarget.style.border = "1px dashed yellow";
-									e.dataTransfer.effectAllowed = 'move';
-									e.dataTransfer.setDragImage(emptyImg, 0, 0);
-                                })
-                                group_item.addEventListener("dragend",e=>{
-                                    e.target.style.opacity = "1";
-                                    e.currentTarget.style.border = "1px dashed transparent";
-                                    e.currentTarget.removeAttribute("draggable");
-									document.querySelectorAll('.easyuse-group-item').forEach((el,i) => {
-										var prev_i = el.dataset.id;
-										if (el == draggerEl && prev_i != i ) {
-											groups.splice(i, 0, groups.splice(prev_i, 1)[0]);
-										}
-										el.dataset.id = i;
-									});
-                                     isGroupMapcanMove = true
-                                })
-                                group_item.addEventListener("dragover",e=>{
-                                    e.preventDefault();
-									if (e.currentTarget == draggerEl) return;
-									let rect = e.currentTarget.getBoundingClientRect();
-									if (e.clientY > rect.top + rect.height / 2) {
-										e.currentTarget.parentNode.insertBefore(draggerEl, e.currentTarget.nextSibling);
-									} else {
-										e.currentTarget.parentNode.insertBefore(draggerEl, e.currentTarget);
-									}
-                                    isGroupMapcanMove = true
-                                })
-
-
-                                group_item.setAttribute('data-id',index)
-                                group_item.className = 'easyuse-group-item'
-                                group_item.style = group_item_style
-                                // 标题
-                                let text_group_title = document.createElement('div')
-                                text_group_title.style = `flex:1;font-size:12px;color:var(--input-text);padding:4px;white-space: nowrap;overflow: hidden;text-overflow: ellipsis;cursor:pointer`
-                                text_group_title.innerHTML = `${title}`
-                                text_group_title.addEventListener('mousedown',e=>{
-                                    isGroupMapcanMove = false
-                                    e.currentTarget.parentNode.draggable = 'true';
-                                })
-                                text_group_title.addEventListener('mouseleave',e=>{
-                                    setTimeout(_=>{
-                                        isGroupMapcanMove = true
-                                    },150)
-                                })
-                                group_item.append(text_group_title)
-                                // 按钮组
-                                let buttons = document.createElement('div')
-                                group.recomputeInsideNodes();
-                                const nodesInGroup = group._nodes;
-                                let isGroupShow = nodesInGroup && nodesInGroup.length>0 && nodesInGroup[0].mode == 0
-                                let isGroupMute = nodesInGroup && nodesInGroup.length>0 && nodesInGroup[0].mode == 2
-                                let go_btn = document.createElement('button')
-                                go_btn.style = "margin-right:6px;cursor:pointer;font-size:10px;padding:2px 4px;color:var(--input-text);background-color: var(--comfy-input-bg);border: 1px solid var(--border-color);border-radius:4px;"
-                                go_btn.innerText = "Go"
-                                go_btn.addEventListener('click', () => {
-                                    app.canvas.ds.offset[0] =  -group.pos[0] - group.size[0] * 0.5 + (app.canvas.canvas.width * 0.5) / app.canvas.ds.scale;
-                                    app.canvas.ds.offset[1] = -group.pos[1] - group.size[1] * 0.5 + (app.canvas.canvas.height * 0.5) / app.canvas.ds.scale;
-                                    app.canvas.setDirty(true, true);
-                                    app.canvas.setZoom(1)
-                                })
-                                buttons.append(go_btn)
-                                let see_btn = document.createElement('button')
-                                let defaultStyle = `cursor:pointer;font-size:10px;;padding:2px;border: 1px solid var(--border-color);border-radius:4px;width:36px;`
-                                see_btn.style = isGroupMute ? `background-color:var(--error-text);color:var(--input-text);` + defaultStyle : (isGroupShow ? `background-color:#006691;color:var(--input-text);` + defaultStyle : `background-color: var(--comfy-input-bg);color:var(--descrip-text);` + defaultStyle)
-                                see_btn.innerText = isGroupMute ? mute_text : (isGroupShow ? show_text : hide_text)
-                                let pressTimer
-                                let firstTime =0, lastTime =0
-                                let isHolding = false
-                                see_btn.addEventListener('click', () => {
-                                    if(isHolding){
-                                        isHolding = false
-                                        return
-                                    }
-                                    for (const node of nodesInGroup) {
-                                        node.mode = isGroupShow ? 4 : 0;
-                                        node.graph.change();
-                                    }
-                                    isGroupShow = nodesInGroup[0].mode == 0 ? true : false
-                                    isGroupMute = nodesInGroup[0].mode == 2 ? true : false
-                                    see_btn.style = isGroupMute ? `background-color:var(--error-text);color:var(--input-text);` + defaultStyle : (isGroupShow ? `background-color:#006691;color:var(--input-text);` + defaultStyle : `background-color: var(--comfy-input-bg);color:var(--descrip-text);` + defaultStyle)
-                                    see_btn.innerText = isGroupMute ? mute_text : (isGroupShow ? show_text : hide_text)
-                                })
-                                see_btn.addEventListener('mousedown', () => {
-                                    firstTime = new Date().getTime();
-                                    clearTimeout(pressTimer);
-                                    pressTimer = setTimeout(_=>{
-                                        for (const node of nodesInGroup) {
-                                            node.mode = isGroupMute ? 0 : 2;
-                                            node.graph.change();
-                                        }
-                                        isGroupShow = nodesInGroup[0].mode == 0 ? true : false
-                                        isGroupMute = nodesInGroup[0].mode == 2 ? true : false
-                                        see_btn.style = isGroupMute ? `background-color:var(--error-text);color:var(--input-text);` + defaultStyle : (isGroupShow ? `background-color:#006691;color:var(--input-text);` + defaultStyle : `background-color: var(--comfy-input-bg);color:var(--descrip-text);` + defaultStyle)
-                                        see_btn.innerText = isGroupMute ? mute_text : (isGroupShow ? show_text : hide_text)
-                                    },500)
-                                })
-                                see_btn.addEventListener('mouseup', () => {
-                                    lastTime = new Date().getTime();
-                                    if(lastTime - firstTime > 500) isHolding = true
-                                    clearTimeout(pressTimer);
-                                })
-                                buttons.append(see_btn)
-                                group_item.append(buttons)
-
-                                groupsDiv.append(group_item)
-                            }
-
-                        }
-
-                        let groupsDiv =  document.createElement('div')
-                        groupsDiv.id = 'easyuse-groups-items'
-                        groupsDiv.style = `overflow-y: auto;max-height: 400px;height:100%;width: 100%;`
-
-                        let autoSortDiv = document.createElement('button')
-                        autoSortDiv.style = `cursor:pointer;font-size:10px;padding:2px 4px;color:var(--input-text);background-color: var(--comfy-input-bg);border: 1px solid var(--border-color);border-radius:4px;`
-                        autoSortDiv.innerText =  $t('Auto Sorting')
-                        autoSortDiv.addEventListener('click',e=>{
-                            e.preventDefault()
-                            groupsDiv.innerHTML = ``
-                            let new_groups = groups.sort((a,b)=> a['pos'][0] - b['pos'][0]).sort((a,b)=> a['pos'][1] - b['pos'][1])
-                            updateGroups(new_groups, groupsDiv, autoSortDiv)
-                        })
-
-                        updateGroups(groups, groupsDiv, autoSortDiv)
-
-                        div.appendChild(groupsDiv)
-
-                        let remarkDiv =  document.createElement('p')
-                        remarkDiv.style = `text-align:center; font-size:10px; padding:0 10px;color:var(--descrip-text)`
-                        remarkDiv.innerText =  $t('Toggle `Show/Hide` can set mode of group, LongPress can set group nodes to never')
-                        div.appendChild(groupsDiv)
-                        div.appendChild(remarkDiv)
-                        div.appendChild(autoSortDiv)
-
-                        let graphDiv = document.getElementById("graph-canvas")
-                        graphDiv.addEventListener('mouseover', async () => {
-                          groupsDiv.innerHTML = ``
-                          let new_groups = app.canvas.graph._groups
-                          updateGroups(new_groups, groupsDiv, autoSortDiv)
-                          old_nodes = nodes
-                        })
-
-                        if (!document.querySelector('#easyuse_groups_map')){
-                            document.body.appendChild(div)
-                        }else{
-                            div.style.display = 'flex'
-                        }
-
-                    }
-                }
-            );
-            // Only show the reboot option if the server is running on a local network 仅在本地或局域网环境可重启服务
-            if(isLocalNetwork(window.location.host)){
-                options.push(null,{
-                    content: '🔴 '+ $t('Reboot ComfyUI (EasyUse)'),
-                    callback: _ =>{
-                        if (confirm($t("Are you sure you'd like to reboot the server?"))){
-                            try {
-                                api.fetchApi("/easyuse/reboot");
-                            } catch (exception) {}
-                        }
-                    }
-                })
-            }
-            return options;
-        };
-    },
-    beforeRegisterNodeDef(nodeType, nodeData, app) {
-        if (nodeData.name.startsWith("easy")) {
-            const origOnConfigure = nodeType.prototype.onConfigure;
-            nodeType.prototype.onConfigure = function () {
-                const r = origOnConfigure ? origOnConfigure.apply(this, arguments) : undefined;
-                return r;
-            };
-        }
-    },
-});
@@ -1,26 +0,0 @@
-import { app } from "/scripts/app.js";
-
-export class FlowState {
-    constructor(){}
-    static idle() {
-        return (!app.runningNodeId);
-    }
-    static paused() {
-        return true;
-    }
-    static paused_here(node_id) {
-        return (FlowState.paused() && FlowState.here(node_id))
-    }
-    static running() {
-        return (!FlowState.idle());
-    }
-    static here(node_id) {
-        return (app.runningNodeId==node_id);
-    }
-    static state() {
-        if (FlowState.paused()) return "Paused";
-        if (FlowState.running()) return "Running";
-        return "Idle";
-    }
-    static cancelling = false;
-}
@@ -0,0 +1,93 @@
+.easyuse-account{
+
+}
+.easyuse-account-user{
+    font-size: 10px;
+    color:var(--descrip-text);
+    text-align: center;
+}
+.easyuse-account-user-info{
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding-bottom:10px;
+    cursor: pointer;
+}
+.easyuse-account-user-info .user{
+    display: flex;
+    align-items: center;
+}
+.easyuse-account-user-info .edit{
+    padding:5px 10px;
+    background: var(--comfy-menu-bg);
+    border-radius:4px;
+}
+.easyuse-account-user-info:hover{
+    filter:brightness(110%);
+}
+.easyuse-account-user-info h5{
+    margin:0;
+    font-size: 10px;
+    text-align: left;
+}
+.easyuse-account-user-info h6{
+    margin:0;
+    font-size: 8px;
+    text-align: left;
+    font-weight: 300;
+}
+.easyuse-account-user-info .remark{
+    margin-top: 4px;
+}
+.easyuse-account-user-info .avatar{
+    width: 36px;
+    height: 36px;
+    background: var(--comfy-input-bg);
+    border-radius: 50%;
+    margin-right: 5px;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    font-size: 16px;
+    overflow: hidden;
+}
+.easyuse-account-user-info .avatar img{
+    width: 100%;
+    height: 100%;
+}
+.easyuse-account-dialog{
+    width: 600px;
+}
+.easyuse-account-dialog-main a, .easyuse-account-dialog-main a:visited{
+    font-weight: 400;
+    color: var(--theme-color-light);
+}
+.easyuse-account-dialog-item{
+    display: flex;
+    justify-content: flex-start;
+    align-items: center;
+    padding: 10px 0;
+    border-bottom: 1px solid var(--border-color);
+}
+.easyuse-account-dialog-item input{
+    padding:5px;
+    margin-right:5px;
+}
+.easyuse-account-dialog-item input.key{
+    flex:1;
+}
+.easyuse-account-dialog-item button{
+    cursor: pointer;
+    margin-left:5px!important;
+    padding:5px!important;
+    font-size: 16px!important;
+}
+.easyuse-account-dialog-item button:hover{
+    filter:brightness(120%);
+}
+.easyuse-account-dialog-item button.choose {
+    background: var(--theme-color);
+}
+.easyuse-account-dialog-item button.delete{
+    background: var(--error-color);
+}
@@ -0,0 +1,35 @@
+.easyuse-chooser-dialog{
+    max-width: 600px;
+}
+.easyuse-chooser-dialog-title{
+    font-size: 18px;
+    font-weight: 700;
+    text-align: center;
+    color:var(--input-text);
+    margin:0;
+}
+.easyuse-chooser-dialog-images{
+    margin-top:10px;
+    display: flex;
+    flex-wrap: wrap;
+    width: 100%;
+    box-sizing: border-box;
+}
+.easyuse-chooser-dialog-images img{
+    width: 50%;
+    height: auto;
+    cursor: pointer;
+    box-sizing: border-box;
+    filter:brightness(80%);
+}
+.easyuse-chooser-dialog-images img:hover{
+    filter:brightness(100%);
+}
+.easyuse-chooser-dialog-images img.selected{
+    border: 4px solid var(--success-color);
+}
+
+.easyuse-chooser-hidden{
+    display: none;
+    height:0;
+}
@@ -26,15 +26,14 @@ textarea{
    backdrop-filter: blur(8px) brightness(120%);
 }
 .comfy-menu{
-    top:38%;
    border-radius:16px;
    box-shadow:0 0 1px var(--descrip-text);
    backdrop-filter: blur(8px) brightness(120%);
 }
 .comfy-menu button,.comfy-modal button {
-    font-size: 16px;
-    padding:6px 0;
-    margin-bottom:8px;
+    font-size: 14px;
+    padding:4px 0;
+    margin-bottom:4px;
 }
 .comfy-menu button.comfy-settings-btn{
    font-size: 12px;
@@ -43,7 +42,7 @@ textarea{
    margin-bottom: 4px;
 }
 .comfy-menu-btns button,.comfy-list-actions button{
-    font-size: 12px;
+    font-size: 10px;
 }
 .comfy-menu > button,
 .comfy-menu-btns button,
@@ -51,6 +50,10 @@ textarea{
 .comfy-modal button {
    border-width:1px;
 }
+.comfy-modal-content{
+    width: 100%;
+}
+

 dialog{
    border:1px solid var(--border-color);
@@ -71,6 +74,9 @@ dialog{
 hr{
   border:1px solid var(--border-color);
 }
+#comfy-dev-save-api-button{
+    justify-content: center;
+}
 #shareButton{
    background:linear-gradient(to left,var(--theme-color),var(--theme-color-light))!important;
    color:white!important;
@@ -78,10 +84,12 @@ hr{
 #queue-button{
    position:relative;
    overflow:hidden;
+    min-height:30px;
    z-index:1;
 }

 #queue-button:after{
+    clear: both;
    content:attr(data-attr);
    background:green;
    color:#FFF;
@@ -112,4 +120,11 @@ hr{
 }
 ::-webkit-scrollbar-thumb:hover {
    background-color: transparent;
+}
+
+[data-theme="dark"] .workspace_manager .chakra-card{
+    background-color:var(--comfy-menu-bg)!important;
+}
+.workspace_manager .chakra-card{
+    width: 400px;
 }
@@ -0,0 +1,34 @@
+#easyuse_groups_map{
+  flex-direction: column;
+  align-items: end;
+  display:flex;position: absolute;
+  top: 50px; left: 10px; width: 180px;
+  border-radius:12px;
+  min-height:100px;
+  max-height:400px;
+  color: var(--descrip-text);
+  background-color: var(--comfy-menu-bg);
+  padding: 10px 4px;
+  border: 1px solid var(--border-color);
+  z-index: 399;
+  padding-top: 0;
+}
+#easyuse_groups_map .icon{
+  width: 12px;
+  height:12px;
+}
+#easyuse_groups_map .closeBtn{
+  float: right;
+  color: var(--input-text);
+  border-radius:30px;
+  background-color: var(--comfy-input-bg);
+  border: 1px solid var(--border-color);
+  cursor: pointer;
+  aspect-ratio: 1 / 1;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+#easyuse_groups_map .closeBtn:hover{
+  filter:brightness(120%);
+}
@@ -4,4 +4,8 @@
@import "groupmap.css";
@import "contextmenu.css";
@import "modelinfo.css";
-@import "toast.css";
+@import "toast.css";
+@import "account.css";
+@import "chooser.css";
+@import "toolbar.css";
+@import "sliderControl.css";
@@ -1,3 +1,6 @@
+.easyuse-prompt-styles{
+    overflow: auto;
+}
 .easyuse-prompt-styles .tools{
    display:flex;
    justify-content:space-between;
@@ -41,9 +44,13 @@
    min-height: 150px;
    height: calc(100% - 40px);
    overflow: auto;
-    // display: flex;
-    // flex-wrap: wrap;
+    /*display: flex;*/
+    /*flex-wrap: wrap;*/
 }
+.easyuse-prompt-styles-list.no-top{
+    height: auto;
+}
+
 .easyuse-prompt-styles-tag{
    display: inline-block;
    vertical-align: middle;
@@ -0,0 +1,66 @@
+.easyuse-slider{
+    width:100%;
+    height:100%;
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+    position: relative;
+}
+.easyuse-slider-item{
+    height: inherit;
+    min-width: 25px;
+    justify-content: center;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+}
+.easyuse-slider-item.positive .easyuse-slider-item-label{
+    color: var(--success-color);
+}
+.easyuse-slider-item.negative .easyuse-slider-item-label{
+    color: var(--error-color);
+}
+.easyuse-slider-item-input{
+    height:15px;
+    font-size: 10px;
+    color: var(--input-text);
+}
+.easyuse-slider-item-label{
+    height:15px;
+    border: none;
+    color: var(--descrip-text);
+    font-size: 8px;
+}
+.easyuse-slider-item-scroll {
+    width: 5px;
+    height: calc(100% - 30px);
+    background: var(--comfy-input-bg);
+    border-radius: 10px;
+    position: relative;
+}
+.easyuse-slider-item-bar{
+    width: 10px;
+    height: 10px;
+    background: linear-gradient(to bottom, var(--input-text), var(--descrip-text));
+    border-radius:100%;
+    box-shadow: 0 2px 10px var(--bg-color);
+    position: absolute;
+    top: 0;
+    left:-2.5px;
+    cursor: pointer;
+    z-index:1;
+}
+.easyuse-slider-item-area{
+    width: 100%;
+    border-radius:20px;
+    position: absolute;
+    bottom: 0;
+    background: var(--input-text);
+    z-index:0;
+}
+.easyuse-slider-item.positive .easyuse-slider-item-area{
+    background: var(--success-color);
+}
+.easyuse-slider-item.negative .easyuse-slider-item-area{
+    background: var(--error-color);
+}
--- a/Show More
+++ b/Show More