Compare commits
657
Commits
@@ -0,0 +1,24 @@
|
||||
name: 报告问题 / Bug report
|
||||
description: 哪里坏了、报错了，或者和你想的不一样 / Something broke or did not do what you expected
|
||||
title: "[Bug] "
|
||||
labels: ["bug"]
|
||||
body:
|
||||
- type: textarea
|
||||
id: what
|
||||
attributes:
|
||||
label: 遇到了什么问题？ / What went wrong?
|
||||
description: 一两句话就行，中文英文都可以。 / A sentence or two is enough, in any language.
|
||||
placeholder: 比如：在模型页点扫描，进度停在 30% 就不动了。 / e.g. The scan on the Models page stops at 30%.
|
||||
validations:
|
||||
required: true
|
||||
- type: textarea
|
||||
id: more
|
||||
attributes:
|
||||
label: 截图或报错（可选） / Screenshots or errors (optional)
|
||||
description: 截图可以直接拖进来。 / Drop screenshots here.
|
||||
- type: textarea
|
||||
id: environment
|
||||
attributes:
|
||||
label: 环境信息（可选） / Environment (optional)
|
||||
description: 在插件里点 设置 → 帮助与反馈 → 复制诊断信息，粘贴到这里。 / In the plugin, Settings → Help and feedback → Copy diagnostics, then paste here.
|
||||
render: text
|
||||
@@ -0,0 +1,2 @@
|
||||
# A blank issue stays possible: the plugin's feedback window opens one with what was written.
|
||||
blank_issues_enabled: true
|
||||
@@ -0,0 +1,13 @@
|
||||
name: 提建议 / Suggestion
|
||||
description: 想要的功能、哪里不顺手、希望往什么方向发展 / A feature you want, something awkward, where the plugin should go
|
||||
title: "[Idea] "
|
||||
labels: ["enhancement"]
|
||||
body:
|
||||
- type: textarea
|
||||
id: idea
|
||||
attributes:
|
||||
label: 你希望有什么？ / What would you like?
|
||||
description: 随便写，一两句话就行，中文英文都可以。 / Anything goes; a sentence or two is enough, in any language.
|
||||
placeholder: 比如：希望素材库能按标签筛选。 / e.g. Filter the material library by tag.
|
||||
validations:
|
||||
required: true
|
||||
+15
-6
@@ -1,5 +1,6 @@
|
||||
# Local configuration and credentials
|
||||
config.json
|
||||
allow_remote_changes
|
||||
.env
|
||||
.env.*
|
||||
!.env.example
|
||||
@@ -56,22 +57,30 @@ api/notebooks/
|
||||
# AI Dev Scripts & Temporary text dumps
|
||||
scripts/
|
||||
doctor_code.txt
|
||||
# Only the Markdown of these doc folders is tracked: screenshots, logs and raw test
|
||||
# data stay local (put them under .agents/).
|
||||
docs/*
|
||||
!docs/architecture/
|
||||
docs/architecture/*
|
||||
!docs/architecture/*.md
|
||||
!docs/decisions/
|
||||
docs/decisions/*
|
||||
!docs/decisions/*.md
|
||||
!docs/audits/
|
||||
!docs/audits/*.md
|
||||
!docs/guides/
|
||||
docs/guides/*
|
||||
!docs/guides/*.md
|
||||
# The README's pictures (small WebP from the isolated demo ComfyUI).
|
||||
!docs/images/
|
||||
docs/images/*
|
||||
!docs/images/*.webp
|
||||
AI_SYSTEM_TEMPLATE.md
|
||||
|
||||
# AI Agents Directory
|
||||
.agents/
|
||||
|
||||
# Test files
|
||||
test_*.js
|
||||
test*.mjs
|
||||
tests/
|
||||
# Scratch test files at the top level (the plugin's tests live in tests/, see docs/guides/testing.md)
|
||||
/test_*.js
|
||||
/test*.mjs
|
||||
|
||||
# Local diagnostic/test artifacts
|
||||
grep_doctor.txt
|
||||
|
||||
@@ -3,11 +3,33 @@
|
||||
适用于本插件的所有修改，包括 Gemini、Codex 和人工维护。目标是让 UX 持续改善，同时让代码职责、状态来源和验证方式保持清楚。
|
||||
用户明确的当前要求优先；确需偏离本规范时，采用最小例外，在交付说明中写明原因、影响和验证。常规实现选择自行处理，不因本规范增加无必要的确认步骤。
|
||||
|
||||
## 0. 每次提交的硬性要求
|
||||
|
||||
以下几条每次提交都要做到，没有“这次改动小”的例外；其余各节是怎么做好的指引。
|
||||
|
||||
1. **结构和文档同步。** 按下表更新文档，与代码放在同一次提交里。新增、删除、改名、拆分源码文件一律算改了模块职责：职责清单同时是文件目录，每个源码文件都要有一行。
|
||||
2. **跑结构检查。** `node tools/check_structure.mjs`，失败不提交。它检查每个源码文件都登记在架构文档里、每个前端模块都能从入口引用到、每个前端文件都能按浏览器的方式解析（`node --check` 对 .js 文件会漏掉浏览器报错的写法）、CSS 里没有按 `style` 属性匹配的 `:has()`（会让拖动画布掉帧，见 [lessons.md](docs/architecture/lessons.md)），并执行规模阈值（第 2 节）：新文件不能一开始就超线，已超线的文件比上次提交只能变短或持平。
|
||||
3. **不留旧实现。** 被取代的模块、样式、文案 key、文档说明同一次提交删掉（第 6 节）。
|
||||
4. **按风险验证**（第 7 节），只提交本任务的文件，没有明确同意不推送。收尾时工作区干净，或在交付说明里列出每个有意留下的未提交文件。
|
||||
5. **测试产物不进仓库。** 测试代码放 `tests/`；截图、录屏、日志、原始测试数据、审计附件放在 `.agents/`（已忽略，只留本机），不用 `git add -f` 绕过忽略规则。提交的文件里不写本机路径、用户名或 `file:///` 链接，文档之间用相对链接。
|
||||
6. **交付说明**写清：改了什么和为什么、验证结果和没验证到的地方、遗留问题、提交号；用了规范例外就写原因和影响。
|
||||
|
||||
| 改了…… | 更新 |
|
||||
| --- | --- |
|
||||
| 新增 / 删除 / 改名 / 拆分源码文件，模块职责 | `ARCHITECTURE.md` 职责清单，或最窄的 `docs/architecture/` 专题 |
|
||||
| 数据流、接口、持久化格式、安全边界、跨系统规则 | 对应的 `docs/architecture/` 专题；系统图或阅读地图变了才改 `ARCHITECTURE.md` 入口 |
|
||||
| 用户能感觉到的行为 | `CHANGELOG.md`；使用方法变了同步 `README.md` 或 `docs/guides/` |
|
||||
| 长期有效的产品或架构取舍 | `docs/decisions/` |
|
||||
| 反复出现的坑、严重故障 | `docs/architecture/lessons.md` |
|
||||
| 开发规范本身 | 只改本文件 |
|
||||
|
||||
普通修复、样式微调不写进架构文档；没有变化的边界不写“本次未改变”。
|
||||
|
||||
## 1. 修改前先定位责任
|
||||
|
||||
1. 查看 `git status` 和相关差异，保留已有工作；不覆盖、回退或提交他人的无关修改。
|
||||
2. 阅读 [ARCHITECTURE.md](ARCHITECTURE.md)，再按阅读地图打开与任务有关的专题，避免每次加载全部文档。
|
||||
3. 搜索目标函数的调用方、相关状态、CSS 选择器及已有辅助函数，再确定修改位置。
|
||||
3. 搜索目标函数的调用方、相关状态、CSS 选择器及已有辅助函数，再确定修改位置。界面上的按钮或文字，先用 `node tools/ui_map.mjs find <屏幕上的字>` 查它在哪个文件、样式在哪、调哪个接口、后端哪个函数；每块界面的用途和统一叫法见 [ui-flows.md](docs/architecture/ui-flows.md)。改了界面文字或流程，顺手更新那里（结构检查会指出对不上的地方）。
|
||||
4. 简短说明本次行为变化和负责它的模块。一个修复优先落在能解释问题的最小责任范围内。
|
||||
|
||||
UX 请求默认允许调整布局、交互和文案，不代表允许改变文件存储位置、接口协议、工作流语义、模型识别依据或用户数据。
|
||||
@@ -37,7 +59,12 @@ UX 请求默认允许调整布局、交互和文案，不代表允许改变文
|
||||
- 通用文件不能成为杂物箱。不要为了省一个文件，把新领域逻辑塞进 `utils`、素材详情渲染器或浏览器主对象。
|
||||
- 不引入没有当前调用方的管理器、适配层、配置项、事件总线或依赖。一次性的简单逻辑可以留在其责任模块内。
|
||||
|
||||
**规模审查阈值：** 普通逻辑文件超过约 600 行，或单函数超过约 100 行时，新增功能前必须检查能否提取独立职责。继续扩展时，在交付说明中解释为什么仍属于同一职责。已有超大模块的小修复不要求顺手重写全文件；语言目录、数据表和样式表不按这个行数阈值拆分。不能通过空壳包装、压缩代码或碎片化文件绕过审查。
|
||||
**规模阈值（只减不增）：** 普通逻辑文件以 600 行为线，单函数以约 100 行为线。
|
||||
- 新文件不超过 600 行；写不下说明有两种以上职责，先拆。
|
||||
- 已经超过 600 行的老文件，每次改动后只能变短或持平，不能变长。要在里面加功能，先把一块独立职责搬出去，腾出行数再加。
|
||||
- 不为了达标专门大拆；改到哪个文件，就顺手从它身上拆走一块，让超线文件随日常修改逐步变少。
|
||||
- 语言目录、数据表和样式表不按这个行数计算。不能通过空壳包装、压缩代码、删注释或碎片化文件绕过。
|
||||
- `tools/check_structure.mjs` 按上次提交比对，新文件超线或老文件变长都会失败。
|
||||
|
||||
## 3. 状态、关闭与异步
|
||||
|
||||
@@ -72,9 +99,36 @@ UX 请求默认允许调整布局、交互和文案，不代表允许改变文
|
||||
- 路径与文件名在后端使用现有边界校验；不能只检查 `..`。前端校验不能替代后端校验。
|
||||
- 修改模型、封面、附属文件或导入包前先完整校验和暂存。失败时保留旧数据，避免先删除旧文件再尝试保存新文件。
|
||||
- 修改多文件发布流程要覆盖中途失败和冲突。单个 JSON 的原子写入不能冒充整组文件的事务。
|
||||
- 大目录遍历、哈希和大量磁盘 I/O 使用已有工作线程/进程路径，不阻塞 aiohttp 事件循环。
|
||||
- UI 适配不能偷偷迁移用户数据、修改全局配置或改变现有路由与存储格式。确需改协议时同步调用方、兼容策略和测试。
|
||||
|
||||
### 安全底线
|
||||
|
||||
ComfyUI-Manager 收录审核检查的就是这几类口子（2026-10 审 Anomalous_TTS 时逐条指出过）。没有“先这样、以后再补”的例外：
|
||||
|
||||
1. **不执行下载来的或用户文件里的代码。** 数据不用 `pickle`、`eval`、`exec`、动态导入读；配置文件当数据解析。模型文件只读 safetensors / GGUF 的文件头，`.ckpt` / `.pt` / `.pth` / `.bin` 不打开，界面提醒它们可能带代码。
|
||||
2. **下载要能核对。** 只从允许的 https 站点下载，先写 `.part`，核对 SHA-256 后才改名放入；没有可核对的指纹时在界面上说明。下载的东西只当数据用。
|
||||
3. **接口不接受任意本机路径。** 只收“类型 + 根目录序号 + 相对路径”，在后端用 `resolve_within` 校验；需要指向本机某个文件时，由服务端自己找到它，只给页面一个令牌。模型文件本身可以是链接（云服务器上模型文件夹里全是指向平台模型盘的链接）：文件夹部分照样用 `resolve_within`，文件用 `model_file_within` / `model_reference_within` 按名字取，不跟着链接走出去，封面、信息和改动都在链接旁边。
|
||||
4. **会写入、移动、删除文件或替用户联网的接口只接受本机请求**（请求来自本机，没有经过代理，Host 也是本机）。用 `--listen` 开放到局域网时，别的设备只能查看。由 `api/local_guard.py` 的中间件统一把关：`/anomalous/` 下 GET 以外的请求默认只接受本机，确实只读的 POST 列进 `OPEN_POSTS`，不只是读的 GET（备份文件、联网、本机文件夹）列进 `LOCAL_GETS`；新接口要想清楚属于哪一类，不要为了方便放进 `OPEN_POSTS`。唯一的例外是云服务器用户在服务器上的插件文件夹里放了 `allow_remote_changes` 文件（启动时读一次，网页建不了也删不掉）：这时 `local_guard.may_change` 也放行别的设备；接口里要自己判断时用 `may_change`，只有“浏览器就在这台电脑上”才成立的事（比如在本机的下载文件夹里找原文件）才用 `is_local`。MCP 始终只接受本机。
|
||||
5. **用户的文件删除一律进回收站，没有回收站就拒绝；从不覆盖**（同名另存为“名字 (2)”或拒绝）。插件自己产生的临时文件（`.part`、暂存区）可以直接删。
|
||||
6. **只读的接口也按第 3 条来。** “只是读”不是例外；能按名字、编号取的，就不收路径，由服务端在自己登记的范围里找到文件。
|
||||
7. **读用户文件要有上限。** 限制读取的大小和条数；读不了或超大的文件跳过并在结果里说明，不让一个坏文件拖垮整个请求。读到的内容进页面只当纯文本（本节第二条）。
|
||||
|
||||
### 资源占用
|
||||
|
||||
ComfyUI 的内存、显存和 CPU 是留给出图的。插件闲着的时候应该几乎不占资源：
|
||||
|
||||
1. **用户动了才做事。** 不在后台轮询、定时扫描或预加载；确需定时的（扫描进度、跟随选中的节点）只在对应界面打开期间进行，关掉就停。
|
||||
2. **耗时的活放后台。** 大目录遍历、哈希和大量磁盘 I/O 使用已有工作线程/进程路径，不阻塞 aiohttp 事件循环。
|
||||
3. **数据跟着界面走。** 界面打开时才读，关掉就释放；跨次使用的缓存要小、有上限，写清楚何时失效。长列表只渲染看得到的或前几十条。
|
||||
4. **图片用缩略图。** 网格和列表用缓存的缩略图，原图只在看大图或拖到画布时读取；浏览器里不常驻大量原图。
|
||||
|
||||
### 功能原则
|
||||
|
||||
几个功能对用户的承诺。改这些功能时不能破坏；确需例外，先问维护者：
|
||||
|
||||
1. **模型检查（模型医生）从不自己改工作流。** 检查只读；只有用户按了“换上”或“下载”才动节点，而且只换成同一个文件（SHA-256 指纹一致）。只是同名、没法核对的候选，标明“按文件名”由用户决定。下载的来源（C 站按指纹、工作流带的链接、ComfyUI-Manager 模型清单）在界面上写明。完整的判断规则（三档可信度、基础组件只认指纹、下载来源与核对）见 `docs/guides/model-check-rules.md`，改模型检查前先读、改了规则同时改它。
|
||||
2. **搭配只记住，从不修改参数数值。** 存的时候是什么，放回画布就是什么：强度、CLIP 层数、提示词等一律原样，不用节点默认值顶替，也不替用户“调”。想要别的数值，在画布上调好再存一个新搭配。放上画布只新放一组节点，从不改画布上已有的节点。（理由见 `docs/decisions/README.md` AD-021；模型检查的见 AD-005、AD-006、AD-020。）
|
||||
|
||||
## 6. 清理旧实现
|
||||
|
||||
- 替换一条路径时搜索它的导入、导出、调用、字段、事件和选择器；确认无用后一起移除。
|
||||
@@ -90,11 +144,10 @@ UX 请求默认允许调整布局、交互和文案，不代表允许改变文
|
||||
| 修改范围 | 至少验证 |
|
||||
| --- | --- |
|
||||
| 导入、导出、模块拆分 | JS 语法、模块链接，以及受影响按钮的真实执行路径 |
|
||||
| 工坊状态与生命周期 | `node --experimental-vm-modules tests/prompt_ui_lifecycle.mjs` |
|
||||
| 词卡读取、分页 | `node tests/prompt_material_source.mjs` |
|
||||
| 翻译桥接 | `node tests/translation_service_contracts.mjs`，异步节点写入另跑工坊生命周期测试 |
|
||||
| 素材应用、笔记隔离 | `node --experimental-vm-modules tests/material_workspace_flow.mjs` |
|
||||
| 素材提示词协议、配方筛选、拖拽清理 | `node --experimental-vm-modules tests/studio_contracts.mjs` |
|
||||
| 提示词工坊、词块 | `node tests/prompt_tags.mjs`、`node tests/prompt_boxes.mjs` |
|
||||
| 素材提示词、节点参数 | `node tests/material_prompt_cross_node.mjs`、`node tests/node_material_actions.mjs`、`node tests/node_parameter_sets.mjs` |
|
||||
| 搭配、往画布插节点、撤销 | `node tests/combo_slots.mjs`、`node tests/graph_splice.mjs`、`node tests/canvas_undo.mjs` |
|
||||
| 提交前全部跑一遍 | `node tools/run_tests.mjs`（说明见 `docs/guides/testing.md`） |
|
||||
| CSS、布局、交互 | 实际浏览器验证受影响状态；涉及宿主行为时验证 ComfyUI |
|
||||
| 文件修改、导入、存储 | 对应 Python 测试，至少覆盖成功、冲突和中途失败保留旧数据 |
|
||||
| 仅文档 | 检查链接、命令、实际代码一致性和 Git 差异 |
|
||||
@@ -103,15 +156,13 @@ UX 请求默认允许调整布局、交互和文案，不代表允许改变文
|
||||
- 修复故障时，优先补充能复现原故障的行为测试。不能只通过源码字符串“存在某段代码”来证明修复。
|
||||
- UX 明确替换旧交互时，更新测试到新的用户流程，并保留原本要保护的行为；不要仅删除失败断言或重新塞回废弃功能。
|
||||
- 新增应随仓库交付的回归测试要检查 `.gitignore`，确认确实进入版本控制。
|
||||
- 历史本地 Python 测试可能不在 Git 中。使用合适环境运行相关测试，例如 `python -m unittest discover -s tests -p 'test_*.py'`，核对实际发现的数量；零项测试不算通过。
|
||||
- Python 测试要在 ComfyUI 的 Python 环境里跑（`node tools/run_tests.mjs` 会自己找），核对实际发现的数量；零项测试不算通过。
|
||||
- 无法运行真实宿主、网络服务或完整测试时，准确说明缺口；不要将模拟画布、语法检查或已有通过数量称为本轮宿主验证。
|
||||
|
||||
## 8. 文档与交付
|
||||
|
||||
- 架构文档只记录职责、数据流、契约和关键约束。颜色、像素值及审美描述以 CSS 为准，不每次 UX 更新都往架构入口追加长篇设计说明。
|
||||
- 改动架构时更新最窄的相关专题。修改规范时以本文件为唯一正文，`GEMINI.md` 只保留阅读入口，避免两套要求漂移。
|
||||
- 该更新哪份文档见第 0 节的表。规范以本文件为唯一正文，避免几份要求各自漂移。
|
||||
- 完成前审查差异、死代码、临时文件和空白错误；保留现有文件编码及换行风格。
|
||||
- 验证后按仓库约定形成一个连贯的本地提交，只包含本任务文件；没有明确授权不推送 GitHub。
|
||||
- 交付说明包含：改了什么与原因、验证结果与限制、剩余问题、本地提交。仅在触发规模阈值或规则例外时额外解释取舍。
|
||||
|
||||
**交付自查：** 新职责放对位置了吗？是否只有一个状态来源？每条关闭路径会释放资源吗？迟到请求会写错对象吗？旧代码和旧 CSS 清掉了吗？新文案已本地化吗？用户文件失败时还在吗？测试验证了实际行为吗？
|
||||
**交付自查：** 新职责放对位置了吗？是否只有一个状态来源？每条关闭路径会释放资源吗？迟到请求会写错对象吗？旧代码和旧 CSS 清掉了吗？新文案已本地化吗？用户文件失败时还在吗？新接口会动文件或联网吗，只接受本机请求了吗？接口收了路径吗，读用户文件有上限吗？插件闲着时还占着 CPU、内存或显存吗？测试验证了实际行为吗？
|
||||
|
||||
+989
-100
File diff suppressed because it is too large
Load Diff
+983
-197
File diff suppressed because it is too large
Load Diff
@@ -1,11 +0,0 @@
|
||||
# Gemini 工作入口
|
||||
|
||||
在本插件中修改任何文件前，先阅读并遵守根目录的 [AGENTS.md](AGENTS.md)。它是本仓库开发与维护规范的唯一正文，适用于 UX 调整、修复和重构。
|
||||
|
||||
随后阅读 [ARCHITECTURE.md](ARCHITECTURE.md)，按其中的阅读地图加载与当前任务有关的专题。
|
||||
|
||||
不要只凭当前任务描述直接追加实现。先确认现有责任模块、状态来源、关闭清理和样式规则；完成后按规范验证并报告结果。
|
||||
|
||||
如果当前工具没有加载本文件，任务发起者应明确要求 Gemini 阅读 `GEMINI.md` 和 `AGENTS.md`。文件的存在不代表工具已实际读取，更不代表检查已自动执行。
|
||||
|
||||
前端设计任务另读 [前端设计与协作方案](docs/plans/frontend-design-brief.md)；具体功能计划按该文链接进入，不使用历史视觉建议作为当前任务单。
|
||||
@@ -2,20 +2,25 @@
|
||||
|
||||
# 🚀 Anomalous Model Browser
|
||||
|
||||
**A Comprehensive Creative Workspace & Model Manager for ComfyUI**
|
||||
*零依赖 C 站元数据抓取 · 智能模型医生 · 可视化节点助手 · 工作流配方与参数笔记*
|
||||
**A model browser and creative workspace for ComfyUI**
|
||||
*模型库 · 出图图库 · 工作流 · 搭配 · 提示词 · 角色配音 · 模型检查 · 操作记录*
|
||||
|
||||
<br/>
|
||||
|
||||
[](https://github.com/ltdrdata/ComfyUI-Manager)
|
||||
[](LICENSE)
|
||||
[](CHANGELOG.md)
|
||||
[](https://www.bilibili.com/video/BV1a1bv68EuA/)
|
||||
[](https://youtu.be/hAvsj7uiaCw)
|
||||
[](CHANGELOG.md)
|
||||
[](https://www.bilibili.com/video/BV1boHx61Enc/)
|
||||
[](https://www.bilibili.com/video/BV1bkpZ6uEZQ/)
|
||||
[](https://www.reddit.com/r/comfyui/s/n38ihf3DLf)
|
||||
|
||||
<br/>
|
||||
|
||||
[**English**](#-english) | [**中文说明**](#-中文)
|
||||
[**English**](#english) | [**中文说明**](#中文)
|
||||
|
||||
<br/>
|
||||
|
||||
<img src="docs/images/en-models.webp" width="900" alt="Models with their Civitai covers, base model and real names">
|
||||
|
||||
</div>
|
||||
|
||||
@@ -23,90 +28,101 @@
|
||||
|
||||
<h2 id="english">🇬🇧 English</h2>
|
||||
|
||||
> **Anomalous Model Browser** is a comprehensive creative workspace and model management suite for ComfyUI. It integrates hash-based metadata indexing, workflow healing (Model Doctor), canvas visual model swapping (Node Assistant), a unified Material Library with polymorphic canvas drag-and-drop, and immutable Workflow Recipes.
|
||||
> **Anomalous Model Browser** takes care of the chores around ComfyUI in one window: browse your models with their Civitai covers and trigger words, look back through your outputs, keep workflows you have tuned, keep model combos and prompts, repair workflows whose models are missing, and, with the companion node pack [Anomalous_TTS](https://github.com/DemonGatanjieu/Anomalous_TTS), give your characters a voice. An activity log shows everything the plugin changed.
|
||||
|
||||
### 🎬 Video Walkthrough & Demos
|
||||
* 📺 **YouTube**: [Watch Quick Walkthrough on YouTube](https://youtu.be/hAvsj7uiaCw)
|
||||
* 📺 **Bilibili**: [Watch Video Demo on Bilibili (在哔哩哔哩观看)](https://www.bilibili.com/video/BV1a1bv68EuA/)
|
||||
### 🎬 Videos and discussion
|
||||
* 📺 **Bilibili** (Chinese): [Video demo](https://www.bilibili.com/video/BV1boHx61Enc/) · [Character voices demo](https://www.bilibili.com/video/BV1bkpZ6uEZQ/)
|
||||
* 💬 **Reddit**: [The post on r/comfyui](https://www.reddit.com/r/comfyui/s/n38ihf3DLf)
|
||||
|
||||
### 🌟 Core Capabilities
|
||||
### 💡 What it helps with
|
||||
|
||||
| 🚀 Primary View | 💡 Description |
|
||||
| :--- | :--- |
|
||||
| **Model Browser (📦 Models)** | Browse models categorized by folder (checkpoints, unet, loras). Displays Civitai metadata, triggers, architectures, and high-res covers. Supports visual swapping, renaming, and notes. |
|
||||
| **History Gallery (🖼️ Gallery)** | Native viewer for the ComfyUI `output` directory. Features multi-dimensional search (prompt, model, seed, hash) with removable filter blocks, mouse-wheel zoom, and drag-to-canvas workflow reconstruction. |
|
||||
| **Workflow Recipes (🪡 Workflows)** | Save full workflows or partial subgraphs. Displays live model readiness status (e.g. all models ready). Open recipes in a new canvas or drag cards directly onto the canvas to load. |
|
||||
| **Toolbox & Bottom Dock (🧰)** | Lower-left navigation bar featuring the Toolbox as the first icon. Directly hosts 4 frequent tools (Scan, Doctor, Assistant, Material Library) plus Settings. Clicking the Toolbox opens a panel containing 5 secondary utilities (Workflow Transfer, Prompt Studio, Prompt Translator, Model Source Hub, Prompt Notes). |
|
||||
| **Workflow Repair (Model Doctor 🩺)** | Automatically detects broken nodes in external workflows and reconnects them to local models by comparing SHA-256 hashes and file sizes. |
|
||||
| **Node Assistant & Presets (🤖)** | Canvas-linked sidebar. Select any node on the canvas to inspect covers/triggers, visually swap models, or apply recipe parameters transactionally. |
|
||||
| **Material Library & Polymorphic Drag (✨)** | Save curated bundles from output PNGs (workflow, provenance, node parameters). Drop onto canvas to open workflow, drop prompts to auto-create native CLIP nodes, or drop onto existing nodes to inject parameters. |
|
||||
**1. "Which LoRA was that again?"** A file called `download (3).safetensors` tells you nothing. Press **Scan** once: every model is looked up on Civitai by its file hash and gets its real name, cover, trigger words and base model. From then on you pick models by their covers.
|
||||
|
||||
### 📦 Quick Installation
|
||||
<p align="center"><img src="docs/images/en-scan.webp" width="520" alt="Scan results: each file matched on Civitai"></p>
|
||||
|
||||
1. Open your terminal in the ComfyUI `custom_nodes` directory:
|
||||
**2. Someone else's workflow opens with red nodes.** Model Check says which models are missing. When the workflow carries model fingerprints (the plugin writes them into the workflows and images of everyone who has it, unless they turn it off), the ones you already have under another name or in another folder go back in with one press, and the rest can be downloaded from Civitai, Hugging Face or ComfyUI-Manager's model list, each download checked against its fingerprint (a Manager entry that only shares the file name is marked so, for you to decide). A workflow without fingerprints can only be matched by file name: a file of the same name elsewhere on your computer is offered for you to confirm.
|
||||
|
||||
<p align="center"><img src="docs/images/en-model-check.webp" width="760" alt="Model Check puts back three missing models with one press"></p>
|
||||
|
||||
**3. "How did I make this picture?"** Search your outputs by prompt words, model or LoRA, then drag the picture onto the canvas: its workflow comes back.
|
||||
|
||||
<p align="center"><img src="docs/images/en-gallery.webp" width="760" alt="Gallery search, then drag an image onto the canvas"></p>
|
||||
|
||||
**4. The same model, LoRAs and prompt, again and again.** Pick those nodes on the canvas, right-click → **AMB** → **Save as combo**, and they are kept as a card beside the canvas. Next time press **Put on canvas** (or drag the card) and the wired group comes back where you click; nothing already on the canvas changes. Models and prompts in a combo can be changed later.
|
||||
|
||||
<p align="center"><img src="docs/images/en-combo.webp" width="760" alt="Picked nodes saved as a combo, then put back on the canvas as wired nodes"></p>
|
||||
|
||||
**5. Long prompts are hard to edit.** Select a prompt node and Prompt Studio shows its text as tags: click to weight, drag to reorder, type to add (Chinese and other languages become English).
|
||||
|
||||
<p align="center"><img src="docs/images/en-prompt-studio.webp" width="760" alt="Prompt Studio editing a prompt node as tags"></p>
|
||||
|
||||
**6. Characters that talk.** With the companion node pack [Anomalous_TTS](https://github.com/DemonGatanjieu/Anomalous_TTS): GPT-SoVITS characters with a reference clip per emotion, and a script page to voice them.
|
||||
|
||||
<p align="center"><img src="docs/images/en-voices.webp" width="760" alt="Character voices page"></p>
|
||||
|
||||
**Changed your mind?** Everything the plugin changes is listed in **Activity**, with **Undo** and **Find on canvas**.
|
||||
|
||||
<p align="center"><img src="docs/images/en-activity.webp" width="620" alt="Activity log with an undo button"></p>
|
||||
|
||||
**Light on your computer**: the plugin itself loads no models, so it takes no graphics memory from image generation; the browser shows small thumbnails instead of full images, and its pictures are released a minute and a half after you close it. The voice models of Anomalous_TTS give their graphics memory back whenever ComfyUI needs it for image generation, and all of it on **Unload models**.
|
||||
|
||||
### 📦 Install
|
||||
|
||||
1. In **ComfyUI Manager**, search `Anomalous Model Browser`, install it and restart ComfyUI. Or clone it into `custom_nodes`:
|
||||
```bash
|
||||
cd custom_nodes
|
||||
git clone https://github.com/DemonGatanjieu/Anomalous_Model_Browser.git
|
||||
```
|
||||
2. Restart ComfyUI. *(Alternatively, install via **ComfyUI Manager** by searching for `Anomalous Model Browser`)*
|
||||
3. **Updating**: click the **!** button in the browser header; the current version is shown at the top, and **Check for updates / switch version** opens the version panel. From there you can update to the newest published release, roll back to an earlier one, or return to the latest version, then restart ComfyUI. The plugin never checks for updates on its own.
|
||||
2. Press **Shift + B** to open it. On **Home**, **Scan model folders** fills in covers and trigger words, and **Tour the interface** points at each part of the window.
|
||||
3. Optional: for character voices, also install [Anomalous_TTS](https://github.com/DemonGatanjieu/Anomalous_TTS) (search `Anomalous TTS` in ComfyUI Manager).
|
||||
|
||||
Open the browser via **Ctrl + Shift + M**, the floating canvas orb (**📦**), or **Extensions → Anomalous Model Browser** in ComfyUI's menu. **ComfyUI Settings → Anomalous Model Browser → Interface** lets you customize the shortcut, configure the UI language, and select an entry mode (floating button, action-bar button, or Extensions menu only).
|
||||
|
||||
<br/>
|
||||
Scanning needs to reach Civitai. Without it, scan offline: base models are read from the files, and a later online scan fills in the rest (see **Network and backups** below).
|
||||
|
||||
<details>
|
||||
<summary><b>📖 Click to Expand: Step-by-Step Operating Guide</b></summary>
|
||||
<summary><b>📖 Every page and tool, in detail</b></summary>
|
||||
|
||||
<br/>
|
||||
Every page has an icon on the rail at the left of the window.
|
||||
|
||||
#### 1. Top Navigation Views (三大顶栏视图)
|
||||
The header provides 3 primary workspaces:
|
||||
* **Models (📦)**: Main model catalog. The left panel shows folder trees (`checkpoints`, `unet`, `loras`), while the center grid displays model cards with previews, trigger tags, and metadata.
|
||||
* **Gallery (🖼️)**: Historical output browser. The top search bar filters outputs by prompt, model name, seed, filename, or model hash; each search keyword forms an independent block with a `×` button for instant removal. Dragging an image onto the canvas reconstructs its embedded workflow.
|
||||
* **Workflows (🪡)**: Workflow Recipe studio. Filter by `[All]`, `[Full Workflows]`, or `[Subgraphs]`. Click `Save Current Workflow` to save the active canvas, or drag any recipe card directly onto the canvas to load it.
|
||||
| Page | What you do there |
|
||||
| :--- | :--- |
|
||||
| **🏠 Home** | Pick what you want to do: a card per task, first steps (scan your model folders, a guided tour of the interface) and your latest activity. |
|
||||
| **🕘 Activity** | Everything the plugin changed, by day: on the canvas (which node settings changed from what to what, nodes added or removed, workflows opened) and in files (models, covers, workflows, materials, notes, images, audio). **Find on canvas** jumps to the node; a canvas change can be undone with **Undo** until something changes it again, the rest is recorded only. Your own edits are not listed. |
|
||||
| **📦 Models** | Your models with covers, trigger words and base model. Chips at the top switch between types (Checkpoint, LoRA, VAE…) and list a whole type, subfolders included; the folder list narrows it to one folder. **+** adds a loader node to the canvas; edit a model's name, notes and cover, or scan just that model. |
|
||||
| **🖼️ Gallery** | Your ComfyUI `output` folder. Search by prompt, model, LoRA, seed, file name or model hash; open an image to see the parameters it was made with, or drag it onto the canvas to get its workflow back. **☆** keeps a good one as a whole workflow, a combo (model, LoRAs, prompt) or just its prompts. |
|
||||
| **🪡 Workflows** | Saved workflows: save a whole workflow or a part of one together with its models, cover, notes and parameters. Each card shows whether the models are on this computer; drag it onto the canvas to load it. Versions can be compared and restored. A card's export button makes a **recipe package** (.zip) to give to someone; dropped into their ⇅, it becomes a workflow card. |
|
||||
| **🧩 Combos** | A main model, a few LoRAs and a prompt you like, kept together. **Put on canvas** (or dragging the card onto the canvas) lays them out as a wired group of nodes; nothing already on the canvas changes. |
|
||||
| **✍️ Prompts** | Prompt Studio, a page of the browser; **Beside the canvas** moves it next to the canvas to see both. Select a prompt node and its prompt boxes appear as tags, edited in place: click a tag to make it stronger or weaker, double-click to edit, drag to reorder, type to add (Chinese, Japanese and other languages are translated to English), and show each tag's meaning in Chinese, Japanese, Korean and other languages. Click a card (a few common ones, plus your saved prompts) to add it, or drag it straight onto a prompt box on the canvas (outlined green for positive, red for negative) or onto empty canvas for a new prompt node. With no prompt node selected you write a draft. |
|
||||
| **🎙️ Voices / 🎧 Audio** | With [Anomalous_TTS](https://github.com/DemonGatanjieu/Anomalous_TTS) installed: import GPT-SoVITS characters, pick a reference clip per emotion, fix pronunciations, write a script under Voice-over on the same page and generate it right there; generated audio is listed in the audio gallery. Without it, the page explains how to install it and nothing else depends on it. |
|
||||
|
||||
#### 2. Bottom Navigation & Toolbox Catalog (🧰 第一个图标：实用工具箱)
|
||||
* **Dock Layout**: The lower-left navigation bar hosts 6 permanent buttons in a fixed layout:
|
||||
1. **Toolbox (🧰)**: First anchor on the left. Opens the Toolbox panel for secondary tools.
|
||||
2. **Scan Wizard (🔄)**: Direct shortcut to launch model library scanning.
|
||||
3. **Model Doctor (🩺)**: Direct shortcut to diagnose and repair missing workflow nodes.
|
||||
4. **Node Assistant (🤖)**: Direct shortcut to inspect canvas node models and inject parameter presets.
|
||||
5. **Material Library (✨)**: Direct shortcut to manage curated bundles and drag assets to the canvas.
|
||||
6. **Settings (⚙️)**: Fixed anchor on the far right for global preferences.
|
||||
* **Toolbox Catalog**: Clicking the first icon (**🧰 实用工具箱**) opens a dedicated popup panel containing 5 secondary utilities:
|
||||
1. **Workflow Transfer Center (⇄ 导入导出)**: Lossless AMB format workflow share code import and export. Allows importing workflows from text codes or exporting the current canvas with embedded hashes.
|
||||
2. **Prompt Studio (🎛️ 提示词工坊)**: Modular prompt mixer deck. Extract prompt cards from history or materials, reorder segments, and assemble positive/negative prompts.
|
||||
3. **Prompt Translator (🌐 翻译助手)**: Built-in bilingual prompt translation between Chinese and English without leaving the interface.
|
||||
4. **Model Source Hub (🔗 模型来源)**: Dual-scope (workflow and library) download URL inspector. Navigates to Civitai, HuggingFace, Liblib, or ModelScope, and generates non-intrusive canvas Note nodes.
|
||||
5. **Prompt Notes (📑 提示词笔记)**: Lightweight notebook for drafting, editing, and managing reusable prompt snippets saved locally in the user directory (`workflows/anomalous_notebooks`).
|
||||
Tools on the rail:
|
||||
|
||||
#### 3. Scan Wizard (🔄 扫描向导)
|
||||
* **Location**: Direct shortcut on the bottom dock (2nd icon).
|
||||
* **Operation**: Scan configured model directories to compute file hashes, download Civitai covers, tags, and architectures, and build the local offline database.
|
||||
* **Scan** reads your model folders and fetches covers, trigger words and base models from Civitai (by file hash, no extra Python packages).
|
||||
* **Model Check** (formerly Model Doctor) checks each workflow you open: when models are missing, a bar over the canvas says so and puts back, with one press, the ones you have under another name or folder, recognised by the fingerprints (hash and file size) the plugin records in workflows and images (**Settings → Record model fingerprints in workflows**, on by default); without them, a file of the same name is offered for you to confirm. Its page lists the rest with what you can do.
|
||||
* **Current node** (formerly Node Assistant) shows the model of the node you select, lets you swap it from the covers or insert a LoRA, and lists every set of values saved for that kind of node with exactly what applying it would change; saved values can be deleted there.
|
||||
* **Each tool on its page**: share and import on Workflows (⇅: a short share code of the canvas workflow, in Chinese characters or letters; paste a code, or drop a workflow file, an image or a backup .zip), Model Sources (where each model can be downloaded) on Models and in Model Check, translation on the prompt boxes in Current node.
|
||||
* **Settings** (at the bottom): language, font size, thumbnails, video covers, which model folders to show, and feedback. Home and Settings have **Report a problem**, which opens a GitHub issue with your versions and GPU already filled in.
|
||||
|
||||
#### 4. Model Doctor (🩺 模型医生)
|
||||
* **Location**: Direct shortcut on the bottom dock (3rd icon).
|
||||
* **Operation**: When loading an external workflow with missing red nodes, Model Doctor inspects embedded provenance hashes and file sizes to reconnect local matches automatically. The "View Hash" button opens a side-by-side SHA256 comparison modal.
|
||||
**AI apps (MCP)**: Claude, Cursor, Cherry Studio and other apps that support MCP can use your library through `http://127.0.0.1:8188/anomalous/mcp`: answer questions about your models, outputs and saved prompts, and change the open workflow for you (prompts, models, LoRAs, combos, missing models), each change one Ctrl+Z step. Local only; setup in [docs/guides/mcp.md](docs/guides/mcp.md).
|
||||
|
||||
#### 5. Node Assistant & Parameter Presets (🤖 节点助手)
|
||||
* **Location**: Direct shortcut on the bottom dock (4th icon).
|
||||
* **Actions**: Select a model node on the canvas to view high-res previews and trigger words, or swap models visually. Switch to **Parameter Presets** to inject recipe-saved node values (e.g., KSampler steps, CFG, denoise) into matching canvas nodes with safe seed preservation.
|
||||
</details>
|
||||
|
||||
#### 6. Material Library & Polymorphic Canvas Drag (✨ 素材库与多态拖拽)
|
||||
* **Location**: Direct shortcut on the bottom dock (5th icon).
|
||||
* **Capture**: In Gallery or Workflows, open an image's parameter inspector to save its image, workflow, and node blocks as a curated material bundle (`workflows/anomalous_materials`).
|
||||
* **Polymorphic Canvas Drag**:
|
||||
- Dragging a workflow material to an empty canvas area opens the full workflow.
|
||||
- Dragging a prompt-only material to an empty canvas auto-creates native `CLIPTextEncode` nodes with distinct negative (`#532323`) and positive (`#235327`) styling.
|
||||
- Dragging materials onto existing canvas nodes injects matching parameter values directly.
|
||||
<details>
|
||||
<summary><b>⚙️ Opening, shortcuts and updating</b></summary>
|
||||
|
||||
#### 7. Global Settings (⚙️ 设置)
|
||||
* **Location**: Direct shortcut on the far right of the lower-left navigation bar (6th icon).
|
||||
* **Options**: Interface language, font scale, thumbnail rendering, video cover hover behavior, and model folder blacklist.
|
||||
Open the browser with **Shift + B** (again to close), the floating button on the canvas, or **Extensions → Anomalous Model Browser** in ComfyUI's menu. **ComfyUI Settings → Anomalous Model Browser → Interface** changes the shortcut, the language and how the browser is opened (floating button, a button next to Run, or the Extensions menu only).
|
||||
|
||||
> [!WARNING]
|
||||
> **Beta Data Protection:** Workflow Recipes, Material Library, and Parameter Presets are currently in active preview. Please back up `workflows/anomalous_recipes`, `workflows/anomalous_materials`, and `workflows/anomalous_parameters` inside your ComfyUI user directory before updating.
|
||||
**Updating**: click the **!** button at the top right of the browser; it shows the current version, and **Check for updates / switch version** opens the version panel. Update to the newest release, go back to an earlier one or return to the latest, then restart ComfyUI. The plugin never checks for updates on its own.
|
||||
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>🌐 Network and backups</b></summary>
|
||||
|
||||
**On a cloud server (AutoDL, RunPod…):** fully supported on overseas servers; on servers in mainland China only in part (Civitai is mostly out of reach there: lookups are unreliable, covers rarely download). Not fully tested yet (one AutoDL server so far). The guide has a section for AI assistants to walk you through it. Opened from another computer, the plugin is view only by default. Open ComfyUI through an SSH tunnel, or see [docs/guides/cloud-server.md](docs/guides/cloud-server.md).
|
||||
|
||||
**Network:** Scan looks models up on Civitai and prompt translation uses Google Translate, so both need to reach those sites (from mainland China usually through a proxy; when civitai.com cannot be reached the plugin tries Civitai's other address, civitai.red, which some networks reach, a cloud server in mainland China among them: names and trigger words come, covers usually not). Without them, pick **Offline** on the scan page (an online scan does the same by itself when it cannot connect): base models are read from the files, without covers or trigger words, and a later online scan fills in the rest. Downloading missing models needs the network too; for Hugging Face, **Settings → Model downloads** can use the hf-mirror.com mirror (Civitai has none). Browsing models, outputs, workflows and combos needs no network.
|
||||
|
||||
**Keep a copy of your own data:** **Settings → Backup → Export** packs workflows, combos, saved prompts and node values, parameter presets, and the names, notes and covers you gave your models into one .zip; keep it on a cloud drive or a USB stick, and **Import** puts it back, also on another computer. (They live in `workflows/anomalous_recipes`, `workflows/anomalous_notebooks`, `workflows/anomalous_materials` and `workflows/anomalous_parameters` in your ComfyUI user folder.)
|
||||
|
||||
</details>
|
||||
|
||||
@@ -114,97 +130,124 @@ The header provides 3 primary workspaces:
|
||||
|
||||
<h2 id="中文">🇨🇳 中文说明</h2>
|
||||
|
||||
> **Anomalous Model Browser** 是为 ComfyUI 设计的综合创作工作台与模型管理套件。系统集成了基于文件哈希的元数据提取、工作流缺失模型自愈（模型医生）、画布节点可视化换模与 LoRA 插入（节点助手）、支持多态画布拖拽的统一素材库，以及工作流配方体系。
|
||||
> **Anomalous Model Browser** 在一个窗口里帮你打理 ComfyUI 周边的杂事：
|
||||
> - 带 C 站封面和触发词浏览模型；
|
||||
> - 翻看以前的出图；
|
||||
> - 保存调好的工作流，存下常用的模型搭配和提示词；
|
||||
> - 别人的工作流缺模型时自动找回；
|
||||
> - 配合配套节点包 [Anomalous_TTS](https://github.com/DemonGatanjieu/Anomalous_TTS) 给角色配音。
|
||||
>
|
||||
> 插件改动过什么，都能在“操作记录”里查到。
|
||||
|
||||
### 🎬 视频演示与教程
|
||||
* 📺 **哔哩哔哩 (Bilibili)**：[在 B 站观看快速上手与使用演示](https://www.bilibili.com/video/BV1a1bv68EuA/)
|
||||
* 📺 **YouTube**：[在 YouTube 观看视频演示](https://youtu.be/hAvsj7uiaCw)
|
||||
### 🎬 视频与讨论
|
||||
* 📺 **哔哩哔哩 (Bilibili)**：[功能演示](https://www.bilibili.com/video/BV1boHx61Enc/) · [角色配音演示](https://www.bilibili.com/video/BV1bkpZ6uEZQ/)
|
||||
* 💬 **Reddit**：[r/comfyui 上的介绍帖](https://www.reddit.com/r/comfyui/s/n38ihf3DLf)
|
||||
|
||||
### 🌟 核心特性速览
|
||||
### 💡 它能帮你解决什么
|
||||
|
||||
| 🚀 核心视图与工具 | 💡 详细说明 |
|
||||
| :--- | :--- |
|
||||
| **模型浏览 (📦 模型)** | 本地模型管理网格。左侧树状目录分类（checkpoints、unet、loras），卡片展示 C 站元数据、触发词、基础架构与高清封面，支持看图换模与自定义备注。 |
|
||||
| **出图图库 (🖼️ 图库)** | 原生读取本地 `output` 文件夹，支持滚轮缩放与安全删除；顶部搜索栏支持按提示词、模型名、LoRA、seed、文件名或模型哈希多维检索，生成可点击独立移除的搜索标签块；拖拽图片原地还原工作流。 |
|
||||
| **工作流配方 (🪡 工作流)** | 工作流配方工坊。支持保存完整工作流或局部子图，实时显示模型就绪状态（如“全部模型就绪”）；支持一键在新画布打开或直接拖拽卡片到画布空白处载入。 |
|
||||
| **实用工具箱与底栏 (🧰)** | 侧边栏左下角第一个图标为工具箱，底栏直达 4 大常用工具（扫描向导、模型医生、节点助手、素材库）与全局设置；点击工具箱弹出浮窗面板，提供 5 大扩展工具（导入导出、提示词工坊、翻译助手、模型来源、提示词笔记）。 |
|
||||
| **节点智能修复 (模型医生 🩺)** | 导入他人工作流发生节点爆红时，自动比对本地模型 SHA256 哈希与字节大小，一键替换为有效路径，支持哈希透视比对。 |
|
||||
| **节点助手与参数预设 (🤖)** | 画布选中节点即可可视化选图换模型、向兼容链路插入 LoRA，或一键应用工作流配方中沉淀的节点参数（自动跳过易变种子）。 |
|
||||
| **统一素材库与多态拖拽 (✨)** | 原生 PNG 资产一键打包保存（完整工作流、模型血缘与节点参数）；多态拖拽：拖至空白画布还原工作流或生成原生红绿提示词节点，拖至已有节点智能注入参数。 |
|
||||
**1. 模型太多，认不出谁是谁。** 文件叫 `下载 (3).safetensors`，根本看不出是什么。点一次 **扫描**，每个模型都按文件哈希去 C 站认一遍，显示出它真正的名字、封面、触发词和底模。以后看封面挑模型就行。
|
||||
|
||||
### 📦 快速安装
|
||||
<p align="center"><img src="docs/images/scan.webp" width="520" alt="扫描结果：每个文件都在 C 站认出来了"></p>
|
||||
|
||||
1. 在 ComfyUI 的 `custom_nodes` 目录下打开终端执行：
|
||||
**2. 打开别人的工作流，一片红框。** 模型检查会告诉你缺哪些模型。如果工作流里带着模型指纹（装了本插件的人出图、保存工作流时会自动记下，除非他在设置里关掉），你电脑里其实有、只是改了名或换了文件夹的，点一下就换上；真没有的可以从 C 站、Hugging Face 或 ComfyUI-Manager 的模型清单下载，下载完按指纹核对过才用（Manager 清单里只是同名、没法核对的，会标出来让你决定）。没有指纹的工作流只能按文件名找：别处有同名文件，会列出来让你确认。
|
||||
|
||||
<p align="center"><img src="docs/images/model-check.webp" width="760" alt="模型检查一键换上 3 个缺失的模型"></p>
|
||||
|
||||
**3. 这张图当时是怎么出的？** 在图库里按提示词、模型或 LoRA 搜，再把图拖到画布上，当时的工作流就回来了。
|
||||
|
||||
<p align="center"><img src="docs/images/gallery.webp" width="760" alt="图库搜索后把图拖到画布"></p>
|
||||
|
||||
**4. 每次都要重新配一遍模型、LoRA 和提示词。** 在画布上选中这几个节点，右键 → **AMB** → **存为搭配**，它们就成了画布旁的一张卡片。下次点 **放到画布**（或者直接拖卡片），点哪里，那组连好线的节点就出现在哪里，画布上原有的东西不动。搭配里的模型和提示词以后还能换。
|
||||
|
||||
<p align="center"><img src="docs/images/combo.webp" width="760" alt="选中的节点存为搭配，再放回画布变成连好线的节点"></p>
|
||||
|
||||
**5. 提示词太长，改起来麻烦。** 选中提示词节点，提示词工坊把它拆成词块：点一下调权重，拖动换位置，输入就加（中文会自动译成英文，比如输入“蓝宝石”加进去的是 sapphire）。
|
||||
|
||||
<p align="center"><img src="docs/images/prompt-studio.webp" width="760" alt="提示词工坊按词块编辑提示词节点"></p>
|
||||
|
||||
**6. 想让角色开口说话。** 配合配套节点包 [Anomalous_TTS](https://github.com/DemonGatanjieu/Anomalous_TTS)：导入 GPT-SoVITS 角色，每种情绪一段参考音频，在配音页写台词直接生成。
|
||||
|
||||
<p align="center"><img src="docs/images/voices.webp" width="760" alt="角色语音页面"></p>
|
||||
|
||||
**改错了也不怕。** 插件做的每一处改动都列在“操作记录”里，带 **撤销** 和 **在画布上找到**。
|
||||
|
||||
<p align="center"><img src="docs/images/activity.webp" width="560" alt="操作记录和撤销按钮"></p>
|
||||
|
||||
**不占你的资源**：
|
||||
- 插件本身不加载任何模型，不和生图抢显存。
|
||||
- 浏览时显示的是小缩略图，不加载原图；关闭窗口一分半后，图片也会释放掉。
|
||||
- Anomalous_TTS 的语音模型在 ComfyUI 生图需要显存时会自动让出，点 **卸载模型** 时全部释放。
|
||||
|
||||
### 📦 安装
|
||||
|
||||
1. 在 **ComfyUI Manager** 里搜索 `Anomalous Model Browser`，安装后重启 ComfyUI。也可以在 `custom_nodes` 目录下手动安装：
|
||||
```bash
|
||||
cd custom_nodes
|
||||
git clone https://github.com/DemonGatanjieu/Anomalous_Model_Browser.git
|
||||
```
|
||||
2. 重启 ComfyUI 即可使用。（*也可以直接在 **ComfyUI Manager** 搜索 `Anomalous Model Browser` 点击安装*）
|
||||
3. **更新插件**：点击顶栏的 **!** 按钮，顶部会显示当前版本，点 **检查更新 / 切换版本** 进入版本面板。可以一键更新到最新发布版本、回退到以前的版本，或回到最新版，之后重启 ComfyUI 即可。插件不会自己联网检查更新。
|
||||
2. 按 **Shift + B** 打开。在 **主页** 点 **扫描模型文件夹** 补全封面和触发词；点 **界面导览** 会逐一指给你看窗口的各个部分。
|
||||
3. 想用角色配音的话，再装 [Anomalous_TTS](https://github.com/DemonGatanjieu/Anomalous_TTS)（在 ComfyUI Manager 搜索 `Anomalous TTS`）。不装也不影响其他功能。
|
||||
|
||||
可以按 **Ctrl + Shift + M**、点击画布上的悬浮 **📦**，或从 ComfyUI 顶部菜单 **扩展 → Anomalous Model Browser** 打开。**ComfyUI 设置 → Anomalous Model Browser → 界面** 会显示当前快捷键，并可直接打开 ComfyUI 原生录入窗口修改，因此冲突与保留按键检查仍然只有一套。该页面还可以让插件语言跟随 ComfyUI 或单独固定为中文/English，并严格三选一显示悬浮入口、运行按钮旁的原生顶部入口或仅使用扩展菜单。只有选择悬浮入口时才显示大小和样式选项。顶部栏重绘不会擅自改变所选模式，扩展菜单命令则始终保留，便于恢复设置。
|
||||
|
||||
<br/>
|
||||
扫描要连 C 站。连不上也能用：选离线扫描，只从模型文件推断底模，以后能连上时再扫一次会自动补上（见下面的“网络和备份”）。
|
||||
|
||||
<details>
|
||||
<summary><b>📖 点击展开：标准操作指南（图文步骤）</b></summary>
|
||||
<summary><b>📖 每个页面和工具的详细说明</b></summary>
|
||||
|
||||
<br/>
|
||||
窗口左侧的图标栏，每个页面一个图标。
|
||||
|
||||
#### 1. 顶部主工作区导航 (三大顶栏视图)
|
||||
插件顶部居中提供 3 个核心工作区入口：
|
||||
* **模型 (📦)**：主模型浏览器。左侧为模型文件夹分类树（`checkpoints`、`unet`、`loras` 等），中间展示模型卡片网格、封面图预览与触发词。
|
||||
* **图库 (🖼️)**：出图历史浏览器。原生读取本地 `output` 目录。顶部搜索栏支持输入提示词、模型名、LoRA、seed、文件名或模型哈希，回车即可生成独立的搜索标签块，点击标签块上的 `×` 可快速移除该过滤项；直接将图片拖拽至 ComfyUI 画布可原地恢复内嵌工作流。
|
||||
* **工作流 (🪡)**：工作流配方工坊。提供 `[全部]`、`[完整工作流]`、`[局部子图]` 子过滤器与标签筛选；点击右上角 `保存当前工作流` 即可将当前画布打包为配方；直接按住配方卡片拖拽到 ComfyUI 画布空白处释放即可立即载入。
|
||||
| 页面 | 在这里做什么 |
|
||||
| :--- | :--- |
|
||||
| **🏠 主页** | 想做什么就点哪张卡片。还有上手第一步（扫描模型文件夹、界面导览）和最近的操作记录。 |
|
||||
| **🕘 记录** | 按天列出插件做过的每一处改动。<br>画布上：哪个节点的设置从什么改成了什么、加了或删了哪些节点、打开了哪个工作流。<br>文件上：模型、封面、工作流、素材、笔记、图片、音频。<br>**在画布上找到** 可以直接跳到那个节点；画布上的改动在没被再改过之前可以点 **撤销**，其余只记录。你自己在画布上的修改不会记进来。 |
|
||||
| **📦 模型** | 模型带封面、触发词和底模信息。<br>顶部标签切换类型（Checkpoint、LoRA、VAE…），连同子文件夹一起列出；左侧文件夹列表可以只看某个文件夹。<br>**+** 一键在画布上创建加载节点；也可以改名、写备注、换封面，或只扫描这一个模型。 |
|
||||
| **🖼️ 图库** | 读取 ComfyUI 的 `output` 文件夹。<br>可以按提示词、模型、LoRA、seed、文件名或模型哈希搜索。<br>点开图片能看到生成参数；拖到画布上可以还原当时的工作流。<br>觉得好就点 **☆**：存成整个工作流、搭配（模型 + LoRA + 提示词），或者只存提示词。 |
|
||||
| **🪡 工作流** | 存下的工作流：把完整工作流或其中一段，连同模型、封面、备注和参数一起存下来。<br>卡片会显示这台电脑上模型是否齐全；拖到画布上即可载入。<br>可以比较、恢复历史版本。<br>卡片上的导出按钮能打成**配方包**（压缩包）发给别人，对方拖进 ⇅ 就多一张工作流卡片。 |
|
||||
| **🧩 搭配** | 把常用的主模型、几个 LoRA 和一段提示词存成一个搭配。<br>按 **放到画布**（或把卡片拖到画布上），就放出一组连好线的节点；画布上原有的东西不动。 |
|
||||
| **✍️ 提示词** | 提示词工坊，浏览器里的一个页面；点“停到画布旁”可以移到画布旁边，边看画布边改。选中一个提示词节点，它的提示词框就以词块的样子出现在工坊里，直接改：点一下调权重，双击改字，拖动换位置，输入就加（中文、日文等会自动译成英文），还能在每个词下面显示它的中文、日文、韩文等语言的意思。<br>点词卡（几张常用的，加上你存的）加进去，或者直接拖到画布的提示词框里（正面绿框、负面红框），拖到空白处就新建一个提示词节点。没选中提示词节点时写的是草稿。 |
|
||||
| **🎙️ 角色语音 / 🎧 音频库** | 装了 [Anomalous_TTS](https://github.com/DemonGatanjieu/Anomalous_TTS) 后可用：<br>导入 GPT-SoVITS 角色，给每种情绪选参考音频，修正读音；切到“配音”写台词并直接生成。<br>生成的音频都在音频库里。没装时，页面会说明怎么安装，其他功能不受影响。 |
|
||||
|
||||
#### 2. 底部导航与实用工具箱 (🧰 第一个图标：实用工具箱)
|
||||
* **布局结构**：侧边栏左下角常驻 6 个固定图标按钮：
|
||||
1. **实用工具箱 (🧰)**：左侧首个图标，点击展开工具箱浮窗面板。
|
||||
2. **扫描向导 (🔄)**：直达本地模型扫描与哈希/元数据建立。
|
||||
3. **模型医生 (🩺)**：直达工作流爆红诊断与缺失模型自动自愈。
|
||||
4. **节点助手 (🤖)**：直达画布选中节点模型信息查看、可视化换模与参数预设注入。
|
||||
5. **素材库 (✨)**：直达素材资产管理与多态画布拖拽。
|
||||
6. **全局设置 (⚙️)**：最右侧齿轮图标，直达全局偏好设置。
|
||||
* **实用工具箱浮窗**：点击首个图标（**🧰 实用工具箱**）打开工具箱窗口，集中收纳了未在底栏常驻的 5 大扩展工具：
|
||||
1. **导入导出 (⇄)**：无损 AMB 格式工作流分享码导入与导出，支持从文本分享码原地解析还原画布，或将当前画布打包生成带校验哈希的分享码。
|
||||
2. **提示词工坊 (🎛️)**：模块化提示词积木组装台，支持从出图历史或素材中抽取词卡并分块混音、正负词排序与组合。
|
||||
3. **翻译助手 (🌐)**：内置中英双向提示词互译工具，无需离开 ComfyUI 即可完成提示词中英翻译。
|
||||
4. **模型来源 (🔗)**：检视当前工作流或模型库中模型的在线下载来源（Civitai、HuggingFace、Liblib、ModelScope），支持一键在画布生成包含模型来源信息的 Note 说明节点。
|
||||
5. **提示词笔记 (📑)**：保存在 ComfyUI 用户目录（`workflows/anomalous_notebooks`）下的轻量提示词草稿本，用于随时记录、整理与复用常用提示词片段。
|
||||
图标栏上的工具：
|
||||
|
||||
#### 3. 扫描向导 (🔄 扫描向导)
|
||||
* **入口位置**：底部快捷栏第 2 个图标。
|
||||
* **操作步骤**：首次使用或添加新模型后打开，选择扫描范围（全部路径、仅缺失元数据或自定义目录）并执行，系统将自动建立本地模型库并拉取 C 站封面、标签与架构信息。
|
||||
* **扫描**：读取模型文件夹，按文件哈希从 C 站获取封面、触发词和底模。不需要额外安装 Python 包。
|
||||
* **模型检查**（原“模型医生”）：打开工作流时自动检查，缺模型就在画布上方提示；本地改过名、换过文件夹的同一个文件一键换上，靠的是插件记在工作流和图片里的模型指纹（哈希和文件大小；**设置 → 在工作流里记下模型指纹**，默认打开）；没有指纹时，同名文件会列出来让你确认。其余的在检查页里自己挑或去 Civitai 找。
|
||||
* **当前节点**（原“节点助手”）：选中画布上的节点，查看它用的模型。可以看图换模型、插入 LoRA；存过的同类节点参数列在一起，每条写明会改哪几项，一键套用；存下的参数也在这里删除。
|
||||
* **工具回到各自的页面**：分享与导入在“工作流”页（⇅：把画布上的工作流变成一段短短的分享码，有汉字码和字母码；也能粘贴分享码，或拖入工作流文件、图片、备份压缩包），模型来源（每个模型去哪下载）在“模型”页和模型检查里，翻译在“当前节点”的提示词框上。
|
||||
* **设置**（最下面）：语言、字号、缩略图、视频封面、显示哪些模型文件夹，以及提交反馈。主页和设置里的 **报告问题** 会打开一个已经填好版本和显卡信息的 GitHub 页面。
|
||||
|
||||
#### 4. 拯救爆红 (🩺 模型医生)
|
||||
* **入口位置**：底部快捷栏第 3 个图标。
|
||||
* **操作步骤**：载入他人工作流或图片出现红框缺失报错时，点击模型医生即可自动比对本地模型哈希与字节大小，一键批量映射为本地正确路径。卡片上的“查看哈希”可展开内嵌指纹与磁盘文件的 SHA256 逐项比对面板。
|
||||
**接入 AI 软件（MCP）**：Claude、Cursor、Cherry Studio 等支持 MCP 的 AI 软件，可以通过 `http://127.0.0.1:8188/anomalous/mcp` 查你的模型、出图和存下的提示词，回答相关问题；也能帮你改当前工作流（提示词、模型、LoRA、搭配、缺失的模型），每次改动都能用 Ctrl+Z 撤销。只限本机。设置方法见 [docs/guides/mcp.md](docs/guides/mcp.md)。
|
||||
|
||||
#### 5. 选中交互与预设 (🤖 节点助手)
|
||||
* **入口位置**：底部快捷栏第 4 个图标。
|
||||
* **动作功能**：在画布选中模型节点后，可在“动作”页查看高清预览图与触发词，支持看图一键替换模型或在兼容链路前后插入 LoRA。
|
||||
* **参数预设**：切换至“参数预设”页，可读取工作流配方中同类型节点的保存参数并一键注入画布（自动保留种子等易变数值）。
|
||||
</details>
|
||||
|
||||
#### 6. 统一素材库与多态画布拖拽 (✨ 素材库与多态拖拽)
|
||||
* **入口位置**：底部快捷栏第 5 个图标。
|
||||
* **保存素材**：在出图图库或配方详情中打开任意生成 PNG 的参数面板，可一键将图片、完整工作流、模型依赖与可复用节点参数打包收藏。
|
||||
* **多态画布拖拽**：
|
||||
- 将工作流素材直接拖拽至空白画布，即可原地恢复并打开完整工作流。
|
||||
- 将纯提示词素材拖拽至空白画布，会自动创建带有正负区分色（深红 `#532323` 为负向 / 墨绿 `#235327` 为正向）的原生 `CLIPTextEncode` 节点。
|
||||
- 将素材拖拽至画布已有节点上时，会自动通过语义探针将匹配参数注入目标节点中。
|
||||
* **本地存储**：素材存储于 ComfyUI 用户目录下的 `workflows/anomalous_materials`，支持原子写入。
|
||||
<details>
|
||||
<summary><b>⚙️ 打开方式、快捷键和更新</b></summary>
|
||||
|
||||
#### 7. 全局设置面板 (⚙️ 设置)
|
||||
* **入口位置**：侧边栏左下角最右侧第 6 个图标（**齿轮图标 ⚙️**）。
|
||||
* **个性调节**：支持中英文界面切换、字体大小缩放、视频封面悬停/常开播放、缩略图优化与目录黑名单管理。
|
||||
打开方式有三种：按 **Shift + B**（再按一次关闭）、点击画布上的悬浮按钮，或者从 ComfyUI 菜单 **扩展 → Anomalous Model Browser** 打开。在 **ComfyUI 设置 → Anomalous Model Browser → 界面** 里，可以修改快捷键、插件语言和打开方式（悬浮按钮、运行按钮旁的按钮，或只用扩展菜单）。
|
||||
|
||||
> [!WARNING]
|
||||
> **测试功能数据安全提醒：** 工作流配方、素材库与参数预设目前属于活跃测试阶段，更新插件前建议备份 ComfyUI 用户目录下的 `workflows/anomalous_recipes`、`workflows/anomalous_materials` 与 `workflows/anomalous_parameters` 文件夹。
|
||||
**更新插件**：
|
||||
- 点窗口右上角的 **!**，可以看到当前版本；
|
||||
- 点 **检查更新 / 切换版本** 打开版本面板，可以更新到最新版、回退到以前的版本，或回到最新版；
|
||||
- 换完版本后重启 ComfyUI。插件不会自己联网检查更新。
|
||||
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>🌐 网络和备份</b></summary>
|
||||
|
||||
**在云服务器上（AutoDL 等）：** 海外的云服务器完整支持；国内的云服务器只能部分支持（多半连不上 Civitai，查模型不稳定，封面基本下不来）。目前还没有完整测过（只实测过一台 AutoDL 服务器），用的时候请留意。说明里有一节写给 AI 看的步骤，把链接丢给 AI 就能让它带你做。从别的电脑打开时插件默认只能浏览。用 SSH 隧道打开就能照常用，或者见 [docs/guides/cloud-server.md](docs/guides/cloud-server.md)。
|
||||
|
||||
**关于网络：** 扫描模型要连 Civitai（C 站）查封面和触发词，提示词翻译默认用谷歌翻译，这两样在国内一般要开网络代理才能用。不开代理也行：扫描页选 **离线**（联网扫描连不上时也会自动改成这样），只从模型文件推断底模，没有封面和触发词，以后能连上时再扫一次会自动补上。下载缺失的模型也要联网：Hugging Face 的模型可以在 **设置 → 模型下载** 里打开“Hugging Face 用国内镜像”，不用代理；C 站的没有镜像。（civitai.com 连不上时插件会自动试 Civitai 的另一个地址 civitai.red，有的网络能连上，比如国内的云服务器，这时能认出模型名字和触发词，封面多半还是下不来。）浏览模型、图库、工作流和搭配都不用联网。
|
||||
|
||||
**备份自己的数据：** **设置 → 备份 → 导出**，把工作流、搭配、存下的提示词和节点参数、参数预设，以及你给模型改的名字、备注和封面打成一个压缩包，放到云端硬盘或 U 盘里；换电脑或重装后用 **导入** 恢复。（它们存在 ComfyUI 用户目录下的 `workflows/anomalous_recipes`、`workflows/anomalous_notebooks`、`workflows/anomalous_materials` 与 `workflows/anomalous_parameters`。）
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
### 🧪 Tests (测试)
|
||||
|
||||
The plugin's tests are in `tests/`; run them all with `node tools/run_tests.mjs` from the plugin folder. See [docs/guides/testing.md](docs/guides/testing.md).
|
||||
插件的测试在 `tests/` 里，在插件文件夹运行 `node tools/run_tests.mjs` 一次跑完。改代码或提 PR 之前跑一遍，说明见 [docs/guides/testing.md](docs/guides/testing.md)。
|
||||
|
||||
### 📝 License & Branding (开源与品牌声明)
|
||||
|
||||
* **Code License (代码授权)**: The source code is released under the [MIT License](LICENSE). 本项目源代码基于 MIT 许可证开源，可自由使用、修改与分发。
|
||||
|
||||
+5
-1
@@ -1,11 +1,15 @@
|
||||
import os
|
||||
from .api import setup_routes
|
||||
from .api.usage_ledger import note_prompt
|
||||
from server import PromptServer
|
||||
|
||||
WEB_DIRECTORY = "./web"
|
||||
|
||||
# 注册 API 路由
|
||||
setup_routes(PromptServer.instance.app)
|
||||
if hasattr(PromptServer, "instance") and PromptServer.instance is not None:
|
||||
setup_routes(PromptServer.instance.app)
|
||||
# Each queued run's nodes and models, for the Tidy tab's "Not used lately" (api/usage_ledger.py).
|
||||
PromptServer.instance.add_on_prompt_handler(note_prompt)
|
||||
|
||||
NODE_CLASS_MAPPINGS = {}
|
||||
NODE_DISPLAY_NAME_MAPPINGS = {}
|
||||
|
||||
+153
-100
@@ -1,100 +1,153 @@
|
||||
from . import (
|
||||
folder_types, gallery_routes, materials, media_routes, model_catalog,
|
||||
model_media, model_metadata, model_resolution, recipe_packages, recipes,
|
||||
translation_routes, version_manager,
|
||||
)
|
||||
from .scanner import *
|
||||
from .config import *
|
||||
from .notebooks import *
|
||||
from .parameters import *
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
@web.middleware
|
||||
async def no_cache_extension_middleware(request, handler):
|
||||
response = await handler(request)
|
||||
if request.path.startswith('/extensions/Anomalous_Model_Browser'):
|
||||
response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate, max-age=0'
|
||||
response.headers['Pragma'] = 'no-cache'
|
||||
response.headers['Expires'] = '0'
|
||||
return response
|
||||
|
||||
def setup_routes(app):
|
||||
if hasattr(app, 'middlewares') and no_cache_extension_middleware not in app.middlewares:
|
||||
app.middlewares.append(no_cache_extension_middleware)
|
||||
app.router.add_get('/anomalous/folders', model_catalog.api_get_folders)
|
||||
app.router.add_get('/anomalous/all_folder_types', folder_types.api_get_all_folder_types)
|
||||
app.router.add_get('/anomalous/models', model_catalog.api_get_models)
|
||||
app.router.add_get('/anomalous/all_scan_models', model_catalog.api_get_all_scan_models)
|
||||
app.router.add_get('/anomalous/batch_select', model_catalog.api_batch_select)
|
||||
app.router.add_get('/anomalous/image', media_routes.api_serve_image)
|
||||
app.router.add_post('/anomalous/scan', api_scan_folder)
|
||||
app.router.add_get('/anomalous/scan_status', api_scan_status)
|
||||
app.router.add_get('/anomalous/find_model', model_catalog.api_find_model)
|
||||
app.router.add_get('/anomalous/config', api_get_config)
|
||||
app.router.add_post('/anomalous/save_config', api_save_config)
|
||||
app.router.add_post('/anomalous/delete_model', model_metadata.api_delete_model)
|
||||
app.router.add_post('/anomalous/clean_civitai_info', api_clean_civitai_info)
|
||||
app.router.add_get('/anomalous/compatible_models', model_catalog.api_compatible_models)
|
||||
app.router.add_get('/anomalous/notebooks', api_get_notebooks)
|
||||
app.router.add_post('/anomalous/save_notebook', api_save_notebook)
|
||||
app.router.add_post('/anomalous/delete_notebook', api_delete_notebook)
|
||||
|
||||
# Parameter Routes
|
||||
app.router.add_get('/anomalous/parameters', api_get_parameters)
|
||||
app.router.add_get('/anomalous/parameters/by_node_type', api_get_parameters_by_type)
|
||||
app.router.add_post('/anomalous/save_parameter', api_save_parameter)
|
||||
app.router.add_post('/anomalous/rename_parameter', api_rename_parameter)
|
||||
app.router.add_post('/anomalous/delete_parameter', api_delete_parameter)
|
||||
app.router.add_get('/anomalous/parameter_gallery', api_get_parameter_gallery)
|
||||
|
||||
# Recipe Routes
|
||||
app.router.add_get('/anomalous/recipes', recipes.api_get_recipes)
|
||||
app.router.add_get('/anomalous/recipe_full', recipes.api_get_recipe_full)
|
||||
app.router.add_get('/anomalous/recipe_asset', recipes.api_get_recipe_asset)
|
||||
app.router.add_get('/anomalous/recipe_gallery', recipes.api_get_recipe_gallery)
|
||||
app.router.add_get('/anomalous/recipe_parameter_gallery', recipes.api_get_recipe_parameter_gallery)
|
||||
app.router.add_get('/anomalous/recipe_gallery_compare', recipes.api_get_recipe_gallery_compare)
|
||||
app.router.add_post('/anomalous/save_recipe', recipes.api_save_recipe)
|
||||
app.router.add_post('/anomalous/update_recipe', recipes.api_update_recipe)
|
||||
app.router.add_post('/anomalous/set_recipe_gallery_cover', recipes.api_set_recipe_gallery_cover)
|
||||
app.router.add_post('/anomalous/delete_recipe', recipes.api_delete_recipe)
|
||||
app.router.add_get('/anomalous/recipe_history', recipes.api_get_recipe_history)
|
||||
app.router.add_get('/anomalous/recipe_version', recipes.api_get_recipe_version)
|
||||
app.router.add_post('/anomalous/restore_recipe_version', recipes.api_restore_recipe_version)
|
||||
app.router.add_post('/anomalous/refresh_recipe_identity', recipes.api_refresh_recipe_identity)
|
||||
app.router.add_post('/anomalous/export_recipe_package', recipe_packages.api_export_recipe_package)
|
||||
app.router.add_post('/anomalous/import_recipe_package_inspect', recipe_packages.api_import_recipe_package_inspect)
|
||||
app.router.add_post('/anomalous/import_recipe_package_commit', recipe_packages.api_import_recipe_package_commit)
|
||||
|
||||
# Curated Material Library Routes
|
||||
app.router.add_get('/anomalous/materials', materials.api_get_materials)
|
||||
app.router.add_get('/anomalous/material_full', materials.api_get_material_full)
|
||||
app.router.add_get('/anomalous/material_asset', materials.api_get_material_asset)
|
||||
app.router.add_get('/anomalous/materials/by_node_type', materials.api_get_materials_by_node_type)
|
||||
app.router.add_post('/anomalous/inspect_image_material', materials.api_inspect_image_material)
|
||||
app.router.add_post('/anomalous/save_image_material', materials.api_save_image_material)
|
||||
app.router.add_post('/anomalous/save_parameter_material', materials.api_save_parameter_material)
|
||||
app.router.add_post('/anomalous/save_prompt_note_material', materials.api_save_prompt_note_material)
|
||||
app.router.add_post('/anomalous/save_prompt_plan', materials.api_save_prompt_plan)
|
||||
app.router.add_post('/anomalous/delete_material', materials.api_delete_material)
|
||||
app.router.add_post('/anomalous/update_material', materials.api_update_material)
|
||||
|
||||
app.router.add_post('/anomalous/translate', translation_routes.api_translate)
|
||||
app.router.add_get('/anomalous/base_models', model_catalog.api_base_models)
|
||||
app.router.add_get('/anomalous/gallery_images', gallery_routes.api_get_gallery_images)
|
||||
app.router.add_post('/anomalous/delete_gallery_image', gallery_routes.api_delete_gallery_image)
|
||||
app.router.add_get('/anomalous/resolve_hash', model_resolution.api_resolve_hash)
|
||||
app.router.add_post('/anomalous/resolve_hash_batch', model_resolution.api_resolve_hash_batch)
|
||||
app.router.add_get('/anomalous/all_hashes', model_resolution.api_get_all_hashes)
|
||||
app.router.add_post('/anomalous/scan_all', api_scan_all)
|
||||
app.router.add_get('/anomalous/global_scan_status', api_global_scan_status)
|
||||
app.router.add_get('/anomalous/scan_missing_models_status', api_scan_missing_models_status)
|
||||
app.router.add_post('/anomalous/clear_cache', media_routes.api_clear_cache)
|
||||
app.router.add_post('/anomalous/update_metadata', model_metadata.api_update_metadata)
|
||||
app.router.add_post('/anomalous/set_custom_cover', model_media.api_set_custom_cover)
|
||||
app.router.add_post('/anomalous/upload_custom_cover', model_media.api_upload_custom_cover)
|
||||
app.router.add_get('/anomalous/model_images', media_routes.api_get_model_images)
|
||||
app.router.add_post('/anomalous/resolve_paths_to_previews', model_catalog.api_resolve_paths_to_previews)
|
||||
app.router.add_post('/anomalous/scan_missing_models', api_scan_missing_models)
|
||||
version_manager.register_routes(app)
|
||||
from . import (
|
||||
activity_log, audio_catalog, folder_types, gallery_routes, materials, media_routes, model_catalog,
|
||||
model_folder, model_media, model_metadata, model_resolution, model_type_listing, kept_images, quick_index, node_material, recipe_packages, recipes, scan_choice, scan_report, scan_summary,
|
||||
local_guard, lora_info, mcp_server, model_download, model_import, model_placement, translation_routes, version_manager, tts_version, backup,
|
||||
network_check, model_heads, model_usage, usage_ledger, sidecar_layout, ai_tasks_routes,
|
||||
)
|
||||
from .scanner import *
|
||||
from .config import *
|
||||
from .notebooks import *
|
||||
from .parameters import *
|
||||
|
||||
import os
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
# ComfyUI serves the web folder under the plugin folder's own name, whatever it is called.
|
||||
EXTENSION_STATIC_PREFIX = f'/extensions/{os.path.basename(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))}/'
|
||||
|
||||
|
||||
@web.middleware
|
||||
async def no_cache_extension_middleware(request, handler):
|
||||
"""Make browsers revalidate this plugin's JS/CSS so a normal refresh picks up updates.
|
||||
|
||||
`no-cache` still allows 304 responses via ETag/Last-Modified. This replaces
|
||||
per-import `?v=` query strings, which load a second module instance whenever
|
||||
two files import the same module with different URLs.
|
||||
"""
|
||||
response = await handler(request)
|
||||
if request.path.startswith(EXTENSION_STATIC_PREFIX):
|
||||
response.headers['Cache-Control'] = 'no-cache'
|
||||
return response
|
||||
|
||||
def setup_routes(app):
|
||||
model_heads.keep_on_disk()
|
||||
if hasattr(app, 'middlewares') and no_cache_extension_middleware not in app.middlewares:
|
||||
app.middlewares.append(no_cache_extension_middleware)
|
||||
# Other devices on the network may look; only this computer may change things (local_guard.py).
|
||||
if hasattr(app, 'middlewares') and local_guard.local_only_middleware not in app.middlewares:
|
||||
app.middlewares.append(local_guard.local_only_middleware)
|
||||
app.router.add_get('/anomalous/access', local_guard.api_access)
|
||||
try:
|
||||
folder_types.upgrade_folder_defaults()
|
||||
except Exception as error:
|
||||
print(f"[Anomalous Browser] Could not update the shown model folders: {error}")
|
||||
app.router.add_get('/anomalous/folders', model_catalog.api_get_folders)
|
||||
app.router.add_get('/anomalous/all_folder_types', folder_types.api_get_all_folder_types)
|
||||
app.router.add_get('/anomalous/models', model_catalog.api_get_models)
|
||||
app.router.add_get('/anomalous/type_models', model_type_listing.api_get_type_models)
|
||||
app.router.add_get('/anomalous/all_scan_models', model_catalog.api_get_all_scan_models)
|
||||
app.router.add_get('/anomalous/image', media_routes.api_serve_image)
|
||||
app.router.add_get('/anomalous/card_cache', media_routes.api_card_cache)
|
||||
app.router.add_post('/anomalous/card_cache/clear', media_routes.api_clear_card_cache)
|
||||
app.router.add_post('/anomalous/scan', api_scan_folder)
|
||||
app.router.add_get('/anomalous/scan_status', api_scan_status)
|
||||
app.router.add_get('/anomalous/find_model', model_catalog.api_find_model)
|
||||
app.router.add_get('/anomalous/config', api_get_config)
|
||||
app.router.add_post('/anomalous/save_config', api_save_config)
|
||||
app.router.add_post('/anomalous/delete_model', model_metadata.api_delete_model)
|
||||
app.router.add_post('/anomalous/open_model_folder', model_folder.api_open_model_folder)
|
||||
app.router.add_get('/anomalous/compatible_models', model_catalog.api_compatible_models)
|
||||
app.router.add_get('/anomalous/notebooks', api_get_notebooks)
|
||||
app.router.add_post('/anomalous/save_notebook', api_save_notebook)
|
||||
app.router.add_post('/anomalous/delete_notebook', api_delete_notebook)
|
||||
|
||||
# Parameter Routes
|
||||
app.router.add_get('/anomalous/parameters', api_get_parameters)
|
||||
app.router.add_get('/anomalous/parameters/by_node_type', api_get_parameters_by_type)
|
||||
app.router.add_get('/anomalous/parameters/signatures', api_get_parameter_set_signatures)
|
||||
app.router.add_post('/anomalous/save_parameter', api_save_parameter)
|
||||
app.router.add_post('/anomalous/rename_parameter', api_rename_parameter)
|
||||
app.router.add_post('/anomalous/delete_parameter', api_delete_parameter)
|
||||
app.router.add_get('/anomalous/parameter_gallery', api_get_parameter_gallery)
|
||||
app.router.add_get('/anomalous/parameter_pictures', api_get_parameter_pictures)
|
||||
|
||||
# Recipe Routes
|
||||
app.router.add_get('/anomalous/recipes', recipes.api_get_recipes)
|
||||
app.router.add_get('/anomalous/recipe_full', recipes.api_get_recipe_full)
|
||||
app.router.add_get('/anomalous/recipe_asset', recipes.api_get_recipe_asset)
|
||||
app.router.add_get('/anomalous/recipe_gallery', recipes.api_get_recipe_gallery)
|
||||
app.router.add_get('/anomalous/recipe_parameter_gallery', recipes.api_get_recipe_parameter_gallery)
|
||||
app.router.add_get('/anomalous/recipe_gallery_compare', recipes.api_get_recipe_gallery_compare)
|
||||
app.router.add_post('/anomalous/save_recipe', recipes.api_save_recipe)
|
||||
app.router.add_post('/anomalous/update_recipe', recipes.api_update_recipe)
|
||||
app.router.add_post('/anomalous/recipe_focus', recipes.api_set_recipe_focus)
|
||||
app.router.add_post('/anomalous/set_recipe_gallery_cover', recipes.api_set_recipe_gallery_cover)
|
||||
app.router.add_post('/anomalous/delete_recipe', recipes.api_delete_recipe)
|
||||
app.router.add_get('/anomalous/recipe_history', recipes.api_get_recipe_history)
|
||||
app.router.add_get('/anomalous/recipe_version', recipes.api_get_recipe_version)
|
||||
app.router.add_post('/anomalous/restore_recipe_version', recipes.api_restore_recipe_version)
|
||||
app.router.add_post('/anomalous/refresh_recipe_identity', recipes.api_refresh_recipe_identity)
|
||||
app.router.add_post('/anomalous/export_recipe_package', recipe_packages.api_export_recipe_package)
|
||||
app.router.add_post('/anomalous/import_recipe_package_inspect', recipe_packages.api_import_recipe_package_inspect)
|
||||
app.router.add_post('/anomalous/import_recipe_package_commit', recipe_packages.api_import_recipe_package_commit)
|
||||
|
||||
# Curated Material Library Routes
|
||||
app.router.add_get('/anomalous/materials', materials.api_get_materials)
|
||||
app.router.add_get('/anomalous/material_full', materials.api_get_material_full)
|
||||
app.router.add_get('/anomalous/material_asset', materials.api_get_material_asset)
|
||||
app.router.add_get('/anomalous/materials/by_node_type', materials.api_get_materials_by_node_type)
|
||||
app.router.add_post('/anomalous/inspect_image_material', materials.api_inspect_image_material)
|
||||
app.router.add_post('/anomalous/save_image_material', materials.api_save_image_material)
|
||||
app.router.add_post('/anomalous/save_prompt_plan', materials.api_save_prompt_plan)
|
||||
app.router.add_post('/anomalous/save_node_material', node_material.api_save_node_material)
|
||||
app.router.add_post('/anomalous/delete_material', materials.api_delete_material)
|
||||
app.router.add_post('/anomalous/update_material', materials.api_update_material)
|
||||
app.router.add_post('/anomalous/mark_material_moved', materials.api_mark_material_moved)
|
||||
|
||||
app.router.add_post('/anomalous/translate', translation_routes.api_translate)
|
||||
app.router.add_get('/anomalous/base_models', model_catalog.api_base_models)
|
||||
app.router.add_get('/anomalous/gallery_images', gallery_routes.api_get_gallery_images)
|
||||
app.router.add_post('/anomalous/delete_gallery_image', gallery_routes.api_delete_gallery_image)
|
||||
app.router.add_get('/anomalous/output_thumbnail', gallery_routes.api_output_thumbnail)
|
||||
app.router.add_get('/anomalous/kept_images', kept_images.api_kept_images)
|
||||
app.router.add_get('/anomalous/quick_index', quick_index.api_quick_index)
|
||||
app.router.add_get('/anomalous/resolve_hash', model_resolution.api_resolve_hash)
|
||||
app.router.add_post('/anomalous/resolve_hash_batch', model_resolution.api_resolve_hash_batch)
|
||||
app.router.add_get('/anomalous/all_hashes', model_resolution.api_get_all_hashes)
|
||||
app.router.add_post('/anomalous/scan_all', api_scan_all)
|
||||
app.router.add_get('/anomalous/global_scan_status', api_global_scan_status)
|
||||
app.router.add_post('/anomalous/clear_cache', media_routes.api_clear_cache)
|
||||
app.router.add_post('/anomalous/update_metadata', model_metadata.api_update_metadata)
|
||||
app.router.add_post('/anomalous/set_custom_cover', model_media.api_set_custom_cover)
|
||||
app.router.add_post('/anomalous/upload_custom_cover', model_media.api_upload_custom_cover)
|
||||
app.router.add_get('/anomalous/model_covers', model_media.api_model_covers)
|
||||
app.router.add_get('/anomalous/model_images', media_routes.api_get_model_images)
|
||||
app.router.add_post('/anomalous/resolve_paths_to_previews', model_catalog.api_resolve_paths_to_previews)
|
||||
app.router.add_get('/anomalous/scan_summary', scan_summary.api_scan_summary)
|
||||
app.router.add_get('/anomalous/scan_matched', scan_summary.api_scan_matched)
|
||||
app.router.add_get('/anomalous/scan_pickable', scan_summary.api_scan_pickable)
|
||||
app.router.add_get('/anomalous/last_scan', scan_report.api_last_scan)
|
||||
app.router.add_get('/anomalous/scan_model', scan_report.api_scan_model)
|
||||
app.router.add_post('/anomalous/scan_choice', scan_choice.api_set_scan_choice)
|
||||
app.router.add_get('/anomalous/lora_info', lora_info.api_lora_info)
|
||||
|
||||
# Audio & Voice Studio Routes
|
||||
app.router.add_get('/anomalous/audio_stream', audio_catalog.api_serve_audio)
|
||||
app.router.add_get('/anomalous/audio_gallery', audio_catalog.api_get_audio_gallery)
|
||||
app.router.add_post('/anomalous/delete_audio_gallery', audio_catalog.api_delete_audio_gallery)
|
||||
app.router.add_get('/anomalous/audio_previews', audio_catalog.api_get_audio_previews)
|
||||
app.router.add_post('/anomalous/save_audio_preview', audio_catalog.api_save_audio_preview)
|
||||
version_manager.register_routes(app)
|
||||
tts_version.register_routes(app)
|
||||
activity_log.register_routes(app)
|
||||
mcp_server.register_routes(app)
|
||||
ai_tasks_routes.register_routes(app)
|
||||
model_download.register_routes(app)
|
||||
network_check.register_routes(app)
|
||||
model_usage.register_routes(app)
|
||||
usage_ledger.register_routes(app)
|
||||
sidecar_layout.register_routes(app)
|
||||
model_import.register_routes(app)
|
||||
model_placement.register_routes(app)
|
||||
backup.register_routes(app)
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
"""What each thing an AI app can do through Anomalous's MCP endpoint is, in one place.
|
||||
|
||||
Every tool (mcp_tools.py reads, mcp_actions.py acts, mcp_task_tools.py the AI's own) has an
|
||||
entry here: its kind (the AI workbench's colour, words and counts; None = not a step of its
|
||||
own), the stage of the work it belongs to (the flow over a task: models, combo, prompt,
|
||||
canvas, run, pictures, voice, library) and its gate (what it touches or costs, for the user's
|
||||
rules on what needs their OK: canvas, gpu, download, network, files; None = nothing to guard).
|
||||
tests/test_ai_tasks.py keeps this catalog and the tools in step.
|
||||
|
||||
The user's own changes in Anomalous (activity log actions) get stages too, so the ones made
|
||||
while an AI works sit in the same flow as its steps (ai_tasks.note_activity).
|
||||
"""
|
||||
|
||||
from collections import namedtuple
|
||||
|
||||
Entry = namedtuple("Entry", "kind stage gate")
|
||||
|
||||
STAGES = ("model", "combo", "prompt", "canvas", "run", "picture", "voice", "library")
|
||||
GATES = ("canvas", "gpu", "download", "network", "files")
|
||||
|
||||
# Arguments with which a call also changes the canvas: it then asks as the stricter of its own gate and "canvas".
|
||||
ALSO_CANVAS = {"run_workflow": ("workflow", "prompt", "negative", "seed", "width", "height", "image", "image_node", "values")}
|
||||
|
||||
TOOLS = {
|
||||
# reading
|
||||
"library_overview": Entry("look", "library", None),
|
||||
"search_models": Entry("look", "model", None),
|
||||
"get_model": Entry("look", "model", None),
|
||||
"scan_report": Entry("look", "library", None),
|
||||
"search_images": Entry("look", "picture", None),
|
||||
"get_image_info": Entry("look", "picture", None),
|
||||
"zoom_image": Entry("look", "picture", None),
|
||||
"list_combos": Entry("look", "combo", None),
|
||||
"list_workflows": Entry("look", "canvas", None),
|
||||
"list_saved_prompts": Entry("look", "prompt", None),
|
||||
"search_audio": Entry("look", "voice", None),
|
||||
"recent_activity": Entry("look", "library", None),
|
||||
"describe_canvas": Entry("look", "canvas", None),
|
||||
"get_situation": Entry("look", None, None), # the task, the canvas in brief and the next step (mcp_situation.py)
|
||||
"check_workflow_models": Entry("look", "model", None),
|
||||
"download_status": Entry("look", "model", None),
|
||||
"list_voices": Entry("look", "voice", None),
|
||||
# acting
|
||||
"set_prompt": Entry("canvas", "prompt", "canvas"),
|
||||
"set_model": Entry("canvas", "model", "canvas"),
|
||||
"add_lora": Entry("canvas", "model", "canvas"),
|
||||
"place_combo": Entry("canvas", "combo", "canvas"),
|
||||
"fix_workflow_models": Entry("canvas", "model", "canvas"),
|
||||
"find_nodes": Entry("look", "canvas", None),
|
||||
"add_node": Entry("canvas", "canvas", "canvas"),
|
||||
"add_nodes": Entry("canvas", "canvas", "canvas"),
|
||||
"connect_nodes": Entry("canvas", "canvas", "canvas"),
|
||||
"set_values": Entry("canvas", "canvas", "canvas"),
|
||||
"remove_nodes": Entry("canvas", "canvas", "canvas"),
|
||||
"new_workflow": Entry("canvas", "canvas", "canvas"),
|
||||
"open_workflow": Entry("canvas", "canvas", "canvas"),
|
||||
"run_workflow": Entry("run", "run", "gpu"),
|
||||
"download_missing_models": Entry("download", "model", "download"),
|
||||
"download_model": Entry("download", "model", "download"),
|
||||
"move_model": Entry("act", "model", "files"),
|
||||
"scan_models": Entry("scan", "library", "network"),
|
||||
"speak": Entry("speech", "voice", "gpu"),
|
||||
"open_in_anomalous": Entry("show", "model", None),
|
||||
# the AI's own: notes and panels are steps; the rest only steer the task
|
||||
"report": Entry("note", None, None),
|
||||
"log_decision": Entry("decision", None, None),
|
||||
"log_outside": Entry("outside", None, None), # what it did with other tools (ai_outside.py, which also notes what changed)
|
||||
"show_panel": Entry("panel", None, None),
|
||||
"ask_user": Entry("panel", None, None),
|
||||
"propose_repaint_area": Entry("panel", "picture", None),
|
||||
"show_run_map": Entry("panel", None, None),
|
||||
"begin_task": Entry(None, None, None),
|
||||
"track_run": Entry(None, "run", None), # attaches an existing submission; creates its own run step
|
||||
"update_panel": Entry(None, None, None),
|
||||
"get_answers": Entry(None, None, None),
|
||||
"run_status": Entry("look", "run", None),
|
||||
"stop_run": Entry(None, "run", None), # ends a run step of its own; the step says who stopped it
|
||||
"get_toolbox": Entry(None, None, None),
|
||||
# Anomalous's card in the conversation (mcp_apps.py): its own calls, not the AI's steps
|
||||
"app_task_view": Entry(None, None, None),
|
||||
"app_answer": Entry(None, None, None),
|
||||
}
|
||||
|
||||
# Activity log actions (activity_log.py ROUTE_ACTIONS, and "canvas") the user makes in Anomalous
|
||||
# that belong in the task an AI is working on, with their stage. Downloads, imports, moves, scans
|
||||
# and backups are left out: an AI's own calls can cause those too.
|
||||
USER_ACTIONS = {
|
||||
"canvas": "canvas",
|
||||
"model_edit": "library", "model_cover": "library", "model_delete": "library",
|
||||
"recipe_save": "canvas", "recipe_edit": "canvas", "recipe_delete": "canvas", "recipe_restore": "canvas",
|
||||
"material_save": "prompt", "material_edit": "prompt", "material_delete": "prompt",
|
||||
"preset_save": "run", "preset_rename": "run", "preset_delete": "run",
|
||||
"image_delete": "picture", "audio_delete": "voice", "audio_save": "voice", "voice_settings": "voice",
|
||||
"note_save": "library", "note_delete": "library",
|
||||
}
|
||||
|
||||
|
||||
def entry(tool, read_only=True):
|
||||
"""The catalog entry of `tool`; one not listed is a read, or an act when it is not read-only."""
|
||||
found = TOOLS.get(tool)
|
||||
if found:
|
||||
return found
|
||||
return Entry("look" if read_only else "act", None, None)
|
||||
|
||||
|
||||
def is_step(tool):
|
||||
"""Whether a call of `tool` is a step of its own in a task."""
|
||||
return entry(tool).kind is not None
|
||||
@@ -0,0 +1,304 @@
|
||||
"""Activity log: what Anomalous changed, newest first, kept in the ComfyUI user folder.
|
||||
|
||||
Two sources feed it. The middleware records this plugin's own write requests
|
||||
(and Anomalous_TTS's) after they succeed: files such as models, covers, recipes,
|
||||
materials, notes, presets, images and audio. The browser posts the canvas changes
|
||||
it made (`POST /anomalous/activity`). Only the newest MAX_ENTRIES are kept and long
|
||||
values are shortened, so the file stays small. Recording never fails a request:
|
||||
the log is a convenience, not part of the action.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
MAX_ENTRIES = 500
|
||||
MAX_LOG_BYTES = 2 * 1024 * 1024 # long canvas entries could otherwise outgrow the JSON writer's limit
|
||||
MAX_VALUE_CHARS = 400
|
||||
MAX_CHANGE_CHARS = 2000 # a before/after value: room for a whole prompt, so its receipt can compare tags
|
||||
DIFF_CONTEXT_CHARS = 60 # kept before the first difference of a long before/after pair
|
||||
MAX_CHANGES = 60
|
||||
|
||||
# Write routes worth a line in the log → the action id the browser has words for. Scans are
|
||||
# recorded when they end, with what they found (api/scan_report.py), not here.
|
||||
ROUTE_ACTIONS = {
|
||||
'/anomalous/delete_model': 'model_delete',
|
||||
'/anomalous/update_metadata': 'model_edit',
|
||||
'/anomalous/set_custom_cover': 'model_cover',
|
||||
'/anomalous/upload_custom_cover': 'model_cover',
|
||||
'/anomalous/save_recipe': 'recipe_save',
|
||||
'/anomalous/update_recipe': 'recipe_edit',
|
||||
'/anomalous/delete_recipe': 'recipe_delete',
|
||||
'/anomalous/restore_recipe_version': 'recipe_restore',
|
||||
'/anomalous/set_recipe_gallery_cover': 'recipe_cover',
|
||||
'/anomalous/import_recipe_package_commit': 'recipe_import',
|
||||
'/anomalous/save_image_material': 'material_save',
|
||||
'/anomalous/save_prompt_plan': 'material_save',
|
||||
'/anomalous/update_material': 'material_edit',
|
||||
'/anomalous/delete_material': 'material_delete',
|
||||
'/anomalous/save_notebook': 'note_save',
|
||||
'/anomalous/delete_notebook': 'note_delete',
|
||||
'/anomalous/save_parameter': 'preset_save',
|
||||
'/anomalous/rename_parameter': 'preset_rename',
|
||||
'/anomalous/delete_parameter': 'preset_delete',
|
||||
'/anomalous/delete_gallery_image': 'image_delete',
|
||||
'/anomalous/delete_audio_gallery': 'audio_delete',
|
||||
'/anomalous/save_audio_preview': 'audio_save',
|
||||
'/anomalous/clear_cache': 'cache_clear',
|
||||
'/anomalous_tts/import/commit': 'voice_import',
|
||||
'/anomalous_tts/settings': 'voice_settings',
|
||||
}
|
||||
# Request fields that name what was changed, in order of preference.
|
||||
TARGET_FIELDS = ('name', 'character', 'filename', 'target_filename', 'recipe_filename',
|
||||
'notebook_filename', 'new_name', 'path', 'file', 'target')
|
||||
|
||||
# What a handler attaches to its request for the log: request[ACTIVITY_DETAIL] = {fields, files}.
|
||||
# web.RequestKey is newer than the aiohttp some ComfyUI installs have; a plain key works there.
|
||||
ACTIVITY_DETAIL = web.RequestKey("activity_detail", dict) if hasattr(web, "RequestKey") else "activity_detail"
|
||||
|
||||
_lock = threading.RLock()
|
||||
_entries = None
|
||||
_listeners = [] # called with each new entry once it is saved (ai_tasks.note_activity)
|
||||
|
||||
|
||||
def log_path():
|
||||
user_dir = folder_paths.get_user_directory() if hasattr(folder_paths, 'get_user_directory') else None
|
||||
if not user_dir:
|
||||
user_dir = os.path.join(folder_paths.base_path, 'user')
|
||||
directory = os.path.join(user_dir, 'anomalous')
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
return os.path.join(directory, 'activity_log.json')
|
||||
|
||||
|
||||
def _load():
|
||||
global _entries
|
||||
if _entries is None:
|
||||
try:
|
||||
with open(log_path(), encoding='utf-8') as source:
|
||||
data = json.load(source)
|
||||
_entries = [entry for entry in data if isinstance(entry, dict)] if isinstance(data, list) else []
|
||||
except (OSError, ValueError):
|
||||
_entries = []
|
||||
return _entries
|
||||
|
||||
|
||||
def _encoded_size(entries):
|
||||
return len(json.dumps(entries, ensure_ascii=False, separators=(',', ':')).encode('utf-8'))
|
||||
|
||||
|
||||
def _trim(entries):
|
||||
"""Drop the oldest entries until the list fits MAX_ENTRIES and MAX_LOG_BYTES."""
|
||||
del entries[MAX_ENTRIES:]
|
||||
while len(entries) > 1 and _encoded_size(entries) > MAX_LOG_BYTES:
|
||||
del entries[max(1, len(entries) * 9 // 10):]
|
||||
|
||||
|
||||
def _text(value):
|
||||
return value if isinstance(value, str) else json.dumps(value, ensure_ascii=False)
|
||||
|
||||
|
||||
def _short(value, limit=MAX_VALUE_CHARS):
|
||||
text = _text(value)
|
||||
return text if len(text) <= limit else text[:limit] + '…'
|
||||
|
||||
|
||||
def _short_values(item, keys):
|
||||
"""`keys` of `item` shortened. A long before/after pair is cut around its first difference
|
||||
instead of at the start, so a change late in a long prompt still shows."""
|
||||
out = {key: _short(item[key], MAX_CHANGE_CHARS if key in ('before', 'after') else MAX_VALUE_CHARS)
|
||||
for key in keys if key in item and item[key] is not None}
|
||||
if 'before' not in out or 'after' not in out:
|
||||
return out
|
||||
old, new = _text(item['before']), _text(item['after'])
|
||||
if len(old) <= MAX_CHANGE_CHARS and len(new) <= MAX_CHANGE_CHARS:
|
||||
return out
|
||||
same = 0
|
||||
while same < min(len(old), len(new)) and old[same] == new[same]:
|
||||
same += 1
|
||||
start = max(0, same - DIFF_CONTEXT_CHARS)
|
||||
|
||||
def cut(text):
|
||||
return ('…' if start else '') + text[start:start + MAX_CHANGE_CHARS] + ('…' if start + MAX_CHANGE_CHARS < len(text) else '')
|
||||
out['before'], out['after'] = cut(old), cut(new)
|
||||
return out
|
||||
|
||||
|
||||
def add_entry(source, action, target='', detail=None):
|
||||
"""Append one entry (newest first) and save. Returns the entry."""
|
||||
entry = {
|
||||
'id': uuid.uuid4().hex[:12],
|
||||
'time': time.time(),
|
||||
'source': source,
|
||||
'action': action,
|
||||
'target': _short(target or ''),
|
||||
}
|
||||
if detail:
|
||||
entry['detail'] = detail
|
||||
with _lock:
|
||||
entries = _load()
|
||||
entries.insert(0, entry)
|
||||
_trim(entries)
|
||||
atomic_write_json(log_path(), entries)
|
||||
for listener in _listeners:
|
||||
try:
|
||||
listener(entry)
|
||||
except Exception: # noqa: BLE001 - a listener must never fail the action recorded
|
||||
logging.getLogger(__name__).warning('Anomalous activity log: a listener failed', exc_info=True)
|
||||
return entry
|
||||
|
||||
|
||||
def add_listener(listener):
|
||||
if listener not in _listeners:
|
||||
_listeners.append(listener)
|
||||
|
||||
|
||||
def tag(entry_id, task_id):
|
||||
"""Names the AI task an entry belongs to (made by the AI, or by the user while it worked)."""
|
||||
with _lock:
|
||||
entries = _load()
|
||||
found = next((entry for entry in entries if entry.get('id') == entry_id), None)
|
||||
if found and found.get('task') != task_id:
|
||||
found['task'] = task_id
|
||||
atomic_write_json(log_path(), entries)
|
||||
|
||||
|
||||
def list_entries(limit=100, source=None):
|
||||
with _lock:
|
||||
entries = _load()
|
||||
picked = [entry for entry in entries if not source or entry.get('source') == source]
|
||||
return picked[:limit]
|
||||
|
||||
|
||||
def clear():
|
||||
global _entries
|
||||
with _lock:
|
||||
_entries = []
|
||||
atomic_write_json(log_path(), [])
|
||||
|
||||
|
||||
def _target_of(body):
|
||||
if not isinstance(body, dict):
|
||||
return ''
|
||||
for field in TARGET_FIELDS:
|
||||
value = body.get(field)
|
||||
if isinstance(value, str) and value.strip():
|
||||
return os.path.basename(value.strip().rstrip('/\\')) or value.strip()
|
||||
return ''
|
||||
|
||||
|
||||
def _failed(response):
|
||||
"""True when a response reports failure, including the 200 + {"status": "error"} style."""
|
||||
if response.status >= 300:
|
||||
return True
|
||||
if getattr(response, 'content_type', '') != 'application/json' or not getattr(response, 'body', None):
|
||||
return False
|
||||
try:
|
||||
data = json.loads(response.body)
|
||||
except (TypeError, ValueError):
|
||||
return False
|
||||
return isinstance(data, dict) and (data.get('success') is False or data.get('ok') is False
|
||||
or data.get('status') in ('error', 'failed'))
|
||||
|
||||
|
||||
async def _request_body(request):
|
||||
"""The body the handler already read (aiohttp caches it); {} when it was not JSON or a form."""
|
||||
try:
|
||||
if request.content_type == 'application/json':
|
||||
return await request.json()
|
||||
if request.content_type in ('multipart/form-data', 'application/x-www-form-urlencoded'):
|
||||
return dict(await request.post())
|
||||
except (ValueError, UnicodeDecodeError, RuntimeError):
|
||||
pass
|
||||
return {}
|
||||
|
||||
|
||||
def _clean_detail(detail):
|
||||
"""What a handler attached for the log (request[ACTIVITY_DETAIL]): the fields it changed
|
||||
({field, before, after}) and the files it moved, values shortened."""
|
||||
if not isinstance(detail, dict):
|
||||
return None
|
||||
cleaned = {}
|
||||
if isinstance(detail.get('fields'), list):
|
||||
cleaned['fields'] = [_short_values(item, ('field', 'before', 'after'))
|
||||
for item in detail['fields'][:MAX_CHANGES] if isinstance(item, dict)]
|
||||
if isinstance(detail.get('files'), list):
|
||||
cleaned['files'] = [_short(name) for name in detail['files'][:MAX_CHANGES]]
|
||||
return {key: value for key, value in cleaned.items() if value} or None
|
||||
|
||||
|
||||
@web.middleware
|
||||
async def activity_middleware(request, handler):
|
||||
response = await handler(request)
|
||||
action = ROUTE_ACTIONS.get(request.path) if request.method == 'POST' else None
|
||||
if action and not _failed(response):
|
||||
try:
|
||||
target = _target_of(await _request_body(request))
|
||||
detail = _clean_detail(request.get(ACTIVITY_DETAIL))
|
||||
await asyncio.get_running_loop().run_in_executor(None, add_entry, 'file', action, target, detail)
|
||||
except Exception: # noqa: BLE001 - the log must never fail the action it records
|
||||
logging.getLogger(__name__).warning('Anomalous activity log: could not record %s', request.path, exc_info=True)
|
||||
return response
|
||||
|
||||
|
||||
def _clean_changes(changes):
|
||||
cleaned = []
|
||||
for change in changes[:MAX_CHANGES]:
|
||||
if not isinstance(change, dict):
|
||||
continue
|
||||
item = _short_values(change, ('kind', 'node', 'type', 'widget', 'before', 'after'))
|
||||
if item.get('kind') in ('changed', 'wired', 'added', 'removed', 'opened'):
|
||||
cleaned.append(item)
|
||||
return cleaned
|
||||
|
||||
|
||||
async def api_get_activity(request):
|
||||
try:
|
||||
limit = max(1, min(MAX_ENTRIES, int(request.query.get('limit', '100'))))
|
||||
except ValueError:
|
||||
limit = 100
|
||||
source = request.query.get('source') or None
|
||||
entries = await asyncio.get_running_loop().run_in_executor(None, list_entries, limit, source)
|
||||
return web.json_response({'entries': entries})
|
||||
|
||||
|
||||
async def api_post_activity(request):
|
||||
"""Canvas changes from the browser: {changes: [...], total, workflow, via?}; via "mcp" marks
|
||||
changes an AI app made through the MCP endpoint."""
|
||||
try:
|
||||
body = await request.json()
|
||||
except ValueError:
|
||||
return web.json_response({'error': 'Invalid JSON body'}, status=400)
|
||||
if not isinstance(body, dict) or not isinstance(body.get('changes'), list):
|
||||
return web.json_response({'error': 'changes must be a list'}, status=400)
|
||||
changes = _clean_changes(body['changes'])
|
||||
if not changes:
|
||||
return web.json_response({'error': 'No recognizable changes'}, status=400)
|
||||
total = body.get('total') if isinstance(body.get('total'), int) else len(changes)
|
||||
detail = {'changes': changes, 'total': max(total, len(changes))}
|
||||
if body.get('via') == 'mcp':
|
||||
detail['via'] = 'mcp'
|
||||
entry = await asyncio.get_running_loop().run_in_executor(
|
||||
None, add_entry, 'canvas', 'canvas', body.get('workflow') if isinstance(body.get('workflow'), str) else '', detail)
|
||||
return web.json_response({'entry': entry})
|
||||
|
||||
|
||||
async def api_clear_activity(request):
|
||||
await asyncio.get_running_loop().run_in_executor(None, clear)
|
||||
return web.json_response({'ok': True})
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
if hasattr(app, 'middlewares') and activity_middleware not in app.middlewares:
|
||||
app.middlewares.append(activity_middleware)
|
||||
app.router.add_get('/anomalous/activity', api_get_activity)
|
||||
app.router.add_post('/anomalous/activity', api_post_activity)
|
||||
app.router.add_post('/anomalous/activity/clear', api_clear_activity)
|
||||
@@ -0,0 +1,109 @@
|
||||
"""How long an AI waits for the user to answer its question (ask_user, a question on a panel).
|
||||
|
||||
One tool call waits at most ai_panels.MAX_WAIT (55 s, under the minute AI apps give a call), so
|
||||
the answer to a question still open says whether to wait on with get_answers: until the time the
|
||||
user set in the Gates window (ai_gates.answer_wait, from when it asked), and while the user is
|
||||
typing an answer (the page posts POST /anomalous/ai_tasks/{id}/typing as they type) until a while
|
||||
after their last key. Then the AI ends its turn and the user brings it back with a line to paste
|
||||
(web/modules/ai_call_lines.js); or, when the user set so (ai_gates.no_answer "recommended"), each
|
||||
open choice the AI marked a recommended option for takes it, marked as such for the user and the
|
||||
AI (recommended_on_timeout), and the AI goes on; not once the user began writing (typed since the
|
||||
question came): they stepped away mid-answer, and it waits for them. Typing is kept in memory only.
|
||||
"""
|
||||
|
||||
import time
|
||||
|
||||
from . import ai_gates, ai_panels, ai_tasks
|
||||
|
||||
AFTER_TYPING = 60 # the user typed this recently: their answer is on its way
|
||||
TOOK = ("The user did not answer in time and set that your recommended option goes then: Anomalous took it for "
|
||||
"them (recommended_on_timeout). Go on with it; a question without a recommended option stays open for the user.")
|
||||
STOP = "You waited as long as the user set: end your turn now. They answer in Anomalous and tell you in your chat to go on."
|
||||
WROTE = ("The user began writing an answer, then stepped away: end your turn now. Nothing is chosen for them; they "
|
||||
"finish it in Anomalous and tell you in your chat to go on.")
|
||||
_typed = {} # task id -> time of the user's last key
|
||||
|
||||
|
||||
def take_recommended(task_id, step):
|
||||
"""Answers each open choice of panel step `step` that has a recommended option with it. Returns how many."""
|
||||
taken = 0
|
||||
for block in step["panel"].get("blocks") or []:
|
||||
picked = [option["id"] for option in block.get("options") or [] if option.get("recommended")]
|
||||
if block.get("type") != "choices" or not picked or block.get("id") in (step.get("answers") or {}):
|
||||
continue
|
||||
try:
|
||||
ai_panels.answer(task_id, step["id"], block["id"], choice=picked if block.get("multiple") else picked[:1],
|
||||
extra={"recommended_on_timeout": True})
|
||||
taken += 1
|
||||
except ai_panels.PanelError:
|
||||
pass
|
||||
return taken
|
||||
|
||||
|
||||
def typing(task_id, now=None):
|
||||
"""The user is typing in task `task_id` (an answer or a message). False for no such task."""
|
||||
with ai_tasks._lock:
|
||||
if not ai_tasks.get_task(task_id):
|
||||
return False
|
||||
_typed[task_id] = time.time() if now is None else now
|
||||
return True
|
||||
|
||||
|
||||
def wait_on(panel_id, now=None, allow_recommended=True):
|
||||
"""For a question of panel `panel_id` still open: {keep_waiting, seconds_left?, typing?, note}, or {}."""
|
||||
with ai_tasks._lock:
|
||||
task, step = ai_panels._find(panel_id)
|
||||
return _wait_on(task, step, now, allow_recommended)
|
||||
|
||||
|
||||
def _wait_on(task, step, now, allow_recommended):
|
||||
"""Check typing and commit a timeout choice under the same lock as user answers."""
|
||||
if not step:
|
||||
return {}
|
||||
now = time.time() if now is None else now
|
||||
typed = _typed.get(task["id"], 0)
|
||||
left = max(step["at"] + ai_gates.answer_wait(), typed + AFTER_TYPING) - now
|
||||
if left <= 0:
|
||||
wrote = typed >= step["at"] # a half-written answer is theirs: no option is taken over it
|
||||
if allow_recommended and not wrote and ai_gates.no_answer() == "recommended" and take_recommended(task["id"], step):
|
||||
return {"keep_waiting": False, "took_recommended": True, "note": TOOK}
|
||||
return {"keep_waiting": False, "note": WROTE if wrote else STOP}
|
||||
typing_now = now - typed < AFTER_TYPING
|
||||
return {"keep_waiting": True, "seconds_left": round(left), **({"typing": True} if typing_now else {}),
|
||||
"note": ("The user is typing their answer" if typing_now else "The user has not answered yet")
|
||||
+ ": call get_answers(panel, wait_seconds=55) now, and again while keep_waiting is true. Do not "
|
||||
"end your turn or ask the same in your own chat."}
|
||||
|
||||
|
||||
def for_answer(answer, panel_id=None, now=None):
|
||||
"""get_answers' `answer`, with how to wait on when nothing came back but questions still open:
|
||||
for panel `panel_id`, or without one for the newest open question while the user's time runs."""
|
||||
waiting = answer.get("still_waiting") or []
|
||||
if not waiting or answer.get("answers") or answer.get("messages"):
|
||||
return answer
|
||||
if panel_id is None:
|
||||
found = [wait_on(panel, now) for panel in dict.fromkeys(item["panel"] for item in waiting)]
|
||||
live = [item for item in found if item.get("keep_waiting")]
|
||||
status = max(live, key=lambda item: item["seconds_left"]) if live else next((item for item in found if item), {})
|
||||
took = any(item.get("took_recommended") for item in found)
|
||||
return {**answer, **status, **({"took_recommended": True} if took else {})}
|
||||
return {**answer, **wait_on(panel_id, now)}
|
||||
|
||||
|
||||
def collect(client, panel_id=None, wait_seconds=0, task_id=None):
|
||||
"""Wait unlocked, then deliver a timeout choice or a racing user answer in this same call."""
|
||||
answer = ai_panels.get_answers(client, panel_id, wait_seconds, task_id=task_id)
|
||||
if answer.get("answers") or answer.get("messages") or not answer.get("still_waiting"):
|
||||
return answer
|
||||
with ai_tasks._lock:
|
||||
# Input may have arrived after the long wait released its lock. Read it before choosing.
|
||||
answer = ai_panels.get_answers(client, panel_id, 0, task_id=task_id)
|
||||
if answer.get("answers") or answer.get("messages") or not answer.get("still_waiting"):
|
||||
return answer
|
||||
status = for_answer(answer, panel_id)
|
||||
fresh = ai_panels.get_answers(client, panel_id, 0, task_id=task_id)
|
||||
if fresh.get("answers") or fresh.get("messages"):
|
||||
if any(item.get("recommended_on_timeout") for item in fresh.get("answers", [])):
|
||||
fresh["note"] = TOOK
|
||||
return fresh
|
||||
return {**status, **fresh} if fresh.get("still_waiting") else fresh
|
||||
@@ -0,0 +1,41 @@
|
||||
"""Who is calling Anomalous's MCP endpoint (mcp_server.py), for the AI workbench's record
|
||||
(ai_tasks.py): a short name for the AI app, the session it runs when it keeps several, and a task
|
||||
it names. Each comes from the request's headers or metadata and is cleaned to a short plain word."""
|
||||
|
||||
import re
|
||||
|
||||
|
||||
_CLIENT_NAMES = (
|
||||
("claude-code", "Claude Code"), ("claude", "Claude"), ("cursor", "Cursor"), ("cherry", "Cherry Studio"),
|
||||
("windsurf", "Windsurf"), ("codex", "Codex"), ("gemini", "Gemini"), ("vscode", "VS Code"), ("cline", "Cline"),
|
||||
)
|
||||
|
||||
|
||||
def client_of(headers, params):
|
||||
"""A short name for the AI app making a call: the client info it sends, else its User-Agent."""
|
||||
meta = params.get("_meta") if isinstance(params.get("_meta"), dict) else {}
|
||||
info = meta.get("io.modelcontextprotocol/clientInfo")
|
||||
raw = info.get("name") if isinstance(info, dict) and isinstance(info.get("name"), str) else ""
|
||||
if not raw:
|
||||
raw = (headers.get("User-Agent") or "").split(" ")[0].split("/")[0]
|
||||
lowered = raw.lower()
|
||||
for key, name in _CLIENT_NAMES:
|
||||
if key in lowered:
|
||||
return name
|
||||
clean = re.sub(r"[^\w .-]", "", raw).strip()[:40]
|
||||
return clean or "AI"
|
||||
|
||||
|
||||
def session_of(headers, params):
|
||||
"""An optional session key when one app runs multiple MCP sessions at once."""
|
||||
meta = params.get("_meta") if isinstance(params.get("_meta"), dict) else {}
|
||||
raw = headers.get("Mcp-Session-Id") or headers.get("X-Anomalous-Session") or meta.get("sessionId") or meta.get("conversationId") or ""
|
||||
return re.sub(r"[^\w .:-]", "", str(raw)).strip()[:64] if isinstance(raw, str) else ""
|
||||
|
||||
|
||||
def task_of(headers, params, arguments=None):
|
||||
"""An explicit task id from headers, request metadata or tool arguments."""
|
||||
meta = params.get("_meta") if isinstance(params.get("_meta"), dict) else {}
|
||||
arg_task = arguments.get("task") if isinstance(arguments, dict) else None
|
||||
raw = arg_task or headers.get("X-Anomalous-Task") or meta.get("anomalous/task") or meta.get("task") or ""
|
||||
return re.sub(r"[^\w-]", "", str(raw)).strip()[:64] if isinstance(raw, str) else ""
|
||||
@@ -0,0 +1,101 @@
|
||||
"""A task's key decisions, kept in Anomalous to look back on ("决策"). Talk may happen anywhere,
|
||||
in the AI's own chat too; what was settled is kept here: the AI records it (log_decision: what,
|
||||
why, what was left out, who decided, the steps it is about), and what the user decided in
|
||||
Anomalous itself is read from the task's own steps (a panel answer, a gate's allow or no, the
|
||||
materials handed over, the canvas mode, a stop). decisions() lists both, oldest first; gap() says
|
||||
how much the AI did since its last recorded decision, for a quiet reminder."""
|
||||
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from . import ai_tasks
|
||||
|
||||
BY = ("user", "ai", "together")
|
||||
MAX_TEXT = 600
|
||||
MAX_REJECTED = 6
|
||||
MAX_RELATED = 8
|
||||
QUESTIONS = ("choices", "input", "picks")
|
||||
|
||||
|
||||
def log(client, title, decision, reason="", rejected=None, by="user", related=None, now=None, session="", task_id=None):
|
||||
"""A decision the AI records. `related`: ids of this task's steps it is about. Returns the step."""
|
||||
title, decision = str(title or "").strip(), str(decision or "").strip()
|
||||
if not title or not decision:
|
||||
raise ValueError("title (what was decided about) and decision (what was decided) are needed")
|
||||
if by not in BY:
|
||||
raise ValueError(f"by is one of {', '.join(BY)}")
|
||||
rejected = [ai_tasks._short(str(item).strip(), 200) for item in (rejected or []) if str(item).strip()][:MAX_REJECTED]
|
||||
now = time.time() if now is None else now
|
||||
record = {"title": ai_tasks._short(title, 200), "decision": ai_tasks._short(decision, MAX_TEXT),
|
||||
"reason": ai_tasks._short(str(reason or "").strip(), MAX_TEXT), "rejected": rejected, "by": by, "related": []}
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "log_decision", "kind": "decision", "ok": True,
|
||||
"state": "done", "summary": "log_decision", "text": record["decision"], "decision": record, "results": []}
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks.current_task(client, now, session=session, task_id=task_id)
|
||||
known = {item["id"] for item in task["steps"]}
|
||||
record["related"] = [str(item) for item in (related or []) if str(item) in known][:MAX_RELATED]
|
||||
ai_tasks._add_step(task, step)
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task["id"])
|
||||
return step
|
||||
|
||||
|
||||
def decisions(task):
|
||||
"""Every decision of `task`, oldest first: {type: logged | answer | gate | toolbox | canvas | stop, step, at, …}."""
|
||||
out = []
|
||||
for step in (task or {}).get("steps") or []:
|
||||
tool = step.get("tool")
|
||||
if step.get("kind") == "decision":
|
||||
out.append({"type": "logged", "step": step["id"], "at": step["at"], **step["decision"]})
|
||||
elif step.get("kind") == "panel":
|
||||
blocks = {block.get("id"): block for block in step["panel"].get("blocks") or []}
|
||||
for block_id, given in (step.get("answers") or {}).items():
|
||||
block = blocks.get(block_id) or {}
|
||||
out.append({"type": "answer", "step": step["id"], "at": given.get("at", step["at"]),
|
||||
"question": block.get("question") or step["panel"].get("title") or "",
|
||||
"answer": "、".join(given.get("labels") or []) if given.get("labels") and given.get("choice") != ["other"] else given.get("text", ""),
|
||||
"skipped": bool(given.get("skipped")), "timed_out": bool(given.get("recommended_on_timeout"))})
|
||||
elif (step.get("gate") or {}).get("at"):
|
||||
asked = step["gate"]
|
||||
out.append({"type": "gate", "step": step["id"], "at": asked["at"], "tool": tool,
|
||||
"allowed": asked.get("decision") == "allow", "text": asked.get("text", "")})
|
||||
elif tool == "user_toolbox":
|
||||
box = step.get("toolbox") or {}
|
||||
count = sum(len(value) for value in box.values() if isinstance(value, list))
|
||||
out.append({"type": "toolbox", "step": step["id"], "at": step["at"], "mode": box.get("mode", "prefer"), "count": count})
|
||||
elif tool == "user_canvas":
|
||||
out.append({"type": "canvas", "step": step["id"], "at": step["at"], "mode": step.get("canvas")})
|
||||
elif tool == "user_stop":
|
||||
out.append({"type": "stop", "step": step["id"], "at": step["at"]})
|
||||
return sorted(out, key=lambda item: item["at"])
|
||||
|
||||
|
||||
def gap(task):
|
||||
"""Runs and canvas changes of the AI since its last recorded decision ({runs, canvas}), or None when there are none."""
|
||||
runs = canvas = 0
|
||||
for step in reversed((task or {}).get("steps") or []):
|
||||
if step.get("kind") == "decision":
|
||||
break
|
||||
runs += step.get("kind") == "run"
|
||||
canvas += step.get("kind") == "canvas"
|
||||
return {"runs": runs, "canvas": canvas} if runs or canvas else None
|
||||
|
||||
|
||||
def lines(task, limit=12):
|
||||
"""The latest decisions in a line each, for an AI picking the task up again."""
|
||||
words = []
|
||||
for item in decisions(task)[-limit:]:
|
||||
if item["type"] == "logged":
|
||||
words.append(f"{item['title']}: {item['decision']}" + (f" (because {item['reason']})" if item["reason"] else ""))
|
||||
elif item["type"] == "answer":
|
||||
words.append(f"Nobody answered \"{item['question']}\" in time; your recommended option was taken: {item['answer']}" if item["timed_out"] else
|
||||
f"The user answered \"{item['question']}\": " + ("left it to you" if item["skipped"] else item["answer"]))
|
||||
elif item["type"] == "gate":
|
||||
words.append(f"The user {'allowed' if item['allowed'] else 'refused'} {item['tool']}" + (f": {item['text']}" if item["text"] else ""))
|
||||
elif item["type"] == "toolbox":
|
||||
words.append(f"The user handed over {item['count']} materials ({item['mode']})")
|
||||
elif item["type"] == "canvas":
|
||||
words.append("The user set the canvas mode to " + ("the task's own tab" if item["mode"] == "new" else "their open canvas"))
|
||||
else:
|
||||
words.append("The user stopped a run")
|
||||
return words
|
||||
+223
@@ -0,0 +1,223 @@
|
||||
"""Gates: what the user lets AI apps do through Anomalous's MCP endpoint without asking first.
|
||||
|
||||
Each acting tool has a gate in action_catalog.py (canvas, gpu, download, network, files) and each gate
|
||||
a policy the user sets on the AI workbench: "auto" (go ahead), "ask" (wait for the user's OK)
|
||||
or "never". mcp_server.py asks check() before running a tool. With "ask" the tool's step waits
|
||||
in state "asking", showing what it would do, for up to WAIT_SECONDS: the user's Allow lets the
|
||||
call go on, No answers the AI with the user's reason. When the user has not answered by then,
|
||||
the AI is told to wait (get_answers) and call the same tool again; the user's later answer
|
||||
reaches it as a message (ai_panels._collect), and an allowed call made again with the same
|
||||
arguments goes ahead without asking twice. Policies are kept in the ComfyUI user folder
|
||||
(anomalous/ai_gates.json); changing one is a write (local_guard.py keeps it to this computer).
|
||||
The same window sets (anomalous/ai_tools.json) how an AI waits for a run (run_wait): "call", it ends its turn and the user tells it when the run is done (the AI
|
||||
workbench gives them a line to paste), or "wait", it waits with run_status; how long in all an
|
||||
AI waits for the user's answer to its question (answer_wait, ai_answer_wait.py), and what happens
|
||||
when that time runs out (no_answer): "stop", the AI ends its turn and waits for the user, or
|
||||
"recommended", a choice the AI marked a recommended option for takes it (never a gate's question).
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
|
||||
from . import action_catalog, ai_tasks
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
POLICIES = ("auto", "ask", "never")
|
||||
RUN_WAITS = ("call", "wait")
|
||||
ANSWER_WAITS = (60, 180, 600) # seconds; the first call waits 30-55 s, get_answers the rest
|
||||
NO_ANSWERS = ("stop", "recommended")
|
||||
DEFAULTS = {"canvas": "auto", "gpu": "auto", "download": "ask", "network": "auto", "files": "ask"}
|
||||
WAIT_SECONDS = 50 # below the minute many AI apps give a tool call
|
||||
ALLOWED_SECONDS = 30 * 60 # an Allow the AI did not wait for holds this long for the same call
|
||||
MAX_ARGS = 8
|
||||
|
||||
_decided = threading.Condition(ai_tasks._lock)
|
||||
|
||||
|
||||
def _path():
|
||||
return os.path.join(os.path.dirname(ai_tasks.tasks_dir()), "ai_gates.json")
|
||||
|
||||
|
||||
def policies():
|
||||
try:
|
||||
with open(_path(), encoding="utf-8") as source:
|
||||
stored = json.load(source)
|
||||
except (OSError, ValueError):
|
||||
stored = {}
|
||||
stored = stored if isinstance(stored, dict) else {}
|
||||
return {gate: stored.get(gate) if stored.get(gate) in POLICIES else default for gate, default in DEFAULTS.items()}
|
||||
|
||||
|
||||
def set_policy(gate, policy):
|
||||
if gate not in DEFAULTS or policy not in POLICIES:
|
||||
raise ValueError("Unknown gate or policy")
|
||||
with _decided:
|
||||
current = policies()
|
||||
current[gate] = policy
|
||||
atomic_write_json(_path(), current)
|
||||
return current
|
||||
|
||||
|
||||
def _tools_path():
|
||||
return os.path.join(os.path.dirname(ai_tasks.tasks_dir()), "ai_tools.json")
|
||||
|
||||
|
||||
def _tool_settings():
|
||||
try:
|
||||
with open(_tools_path(), encoding="utf-8") as source:
|
||||
stored = json.load(source)
|
||||
except (OSError, ValueError):
|
||||
stored = {}
|
||||
return stored if isinstance(stored, dict) else {}
|
||||
|
||||
|
||||
def _set_tool_setting(key, value):
|
||||
with _decided:
|
||||
atomic_write_json(_tools_path(), {**_tool_settings(), key: value})
|
||||
return value
|
||||
|
||||
|
||||
def run_wait():
|
||||
"""How an AI waits for its run: "call" (the user tells it when it is done) or "wait" (run_status)."""
|
||||
chosen = _tool_settings().get("runs")
|
||||
return chosen if chosen in RUN_WAITS else "call"
|
||||
|
||||
|
||||
def set_run_wait(mode):
|
||||
if mode not in RUN_WAITS:
|
||||
raise ValueError("runs is call or wait")
|
||||
return _set_tool_setting("runs", mode)
|
||||
|
||||
|
||||
def answer_wait():
|
||||
"""How long in all an AI waits for the user's answer, in seconds (one of ANSWER_WAITS)."""
|
||||
chosen = _tool_settings().get("answer_wait")
|
||||
return chosen if chosen in ANSWER_WAITS else 180
|
||||
|
||||
|
||||
def set_answer_wait(seconds):
|
||||
if seconds not in ANSWER_WAITS or isinstance(seconds, bool):
|
||||
raise ValueError("answer_wait is 60, 180 or 600")
|
||||
return _set_tool_setting("answer_wait", seconds)
|
||||
|
||||
|
||||
def no_answer():
|
||||
"""When the user's time runs out unanswered: "stop" (the AI waits for them) or "recommended"."""
|
||||
chosen = _tool_settings().get("no_answer")
|
||||
return chosen if chosen in NO_ANSWERS else "stop"
|
||||
|
||||
|
||||
def set_no_answer(mode):
|
||||
if mode not in NO_ANSWERS:
|
||||
raise ValueError("no_answer is stop or recommended")
|
||||
return _set_tool_setting("no_answer", mode)
|
||||
|
||||
|
||||
def describe(tool, arguments):
|
||||
"""What a call would do, as [{label, value}] for the card the user answers."""
|
||||
out = []
|
||||
for key, value in list((arguments or {}).items())[:MAX_ARGS]:
|
||||
if key == "task":
|
||||
continue
|
||||
if key == "model_id": # its name, and the folder it is in
|
||||
value = " · ".join(filter(None, (ai_tasks._model_result(value).get("name") or value, str(value).split(":")[0])))
|
||||
out.append({"label": key, "value": ai_tasks._short(value, 400)})
|
||||
return out
|
||||
|
||||
|
||||
def _signature(tool, arguments):
|
||||
return json.dumps([tool, {k: v for k, v in (arguments or {}).items() if k != "task"}], sort_keys=True, ensure_ascii=False)
|
||||
|
||||
|
||||
def _blocked(text):
|
||||
return {"content": [{"type": "text", "text": text}], "isError": True}
|
||||
|
||||
|
||||
def _step(step_ref):
|
||||
task = ai_tasks._load().get(step_ref[0]) if step_ref else None
|
||||
step = next((item for item in (task or {}).get("steps", []) if item.get("id") == step_ref[1]), None) if task else None
|
||||
return task, step
|
||||
|
||||
|
||||
def check(tool, arguments, step_ref, now=None):
|
||||
"""None when the call may go ahead; else the result to give the AI instead of running it."""
|
||||
gate = action_catalog.entry(tool).gate
|
||||
if gate and set(arguments or {}) & set(action_catalog.ALSO_CANVAS.get(tool, ())):
|
||||
strict = {"auto": 0, "ask": 1, "never": 2}
|
||||
gate = max((gate, "canvas"), key=lambda name: strict.get(policies().get(name, "auto"), 0))
|
||||
policy = policies().get(gate, "auto") if gate else "auto"
|
||||
if policy == "auto":
|
||||
return None
|
||||
if policy == "never":
|
||||
return _blocked(f"The user does not let AI apps do this ({gate}) through Anomalous; tell them what you "
|
||||
"wanted to do instead, or ask them to change it in the AI workbench (Gates).")
|
||||
now = time.time() if now is None else now
|
||||
signature = _signature(tool, arguments)
|
||||
with _decided:
|
||||
task, step = _step(step_ref)
|
||||
if not step:
|
||||
return _blocked("Approval could not be recorded; nothing was done. Retry after reopening the AI workbench.")
|
||||
# An Allow given after the AI stopped waiting: the same call again goes ahead.
|
||||
for earlier in task["steps"]:
|
||||
asked = earlier.get("gate") or {}
|
||||
if (asked.get("timed_out") and asked.get("signature") == signature
|
||||
and asked.get("decision") == "allow" and not asked.get("used")
|
||||
and now - asked.get("at", 0) < ALLOWED_SECONDS):
|
||||
asked["used"] = True
|
||||
earlier["state"] = "done"
|
||||
step["gate"] = {"gate": gate, "signature": signature, "decision": "allow", "used": True, "earlier": earlier["id"]}
|
||||
ai_tasks._save(task)
|
||||
return None
|
||||
step["state"] = "asking"
|
||||
step["gate"] = {"gate": gate, "signature": signature, "lines": describe(tool, arguments), "asked": now}
|
||||
ai_tasks._save(task)
|
||||
task_id = task["id"]
|
||||
ai_tasks._notify(task_id, {"gate": gate, "asks": True})
|
||||
with _decided:
|
||||
_decided.wait_for(lambda: "decision" in step["gate"], WAIT_SECONDS)
|
||||
asked = step["gate"]
|
||||
if asked.get("decision") == "allow":
|
||||
asked["used"] = True
|
||||
step["state"] = "running"
|
||||
ai_tasks._save(task)
|
||||
return None
|
||||
if asked.get("decision") == "deny":
|
||||
return _blocked("你没有允许 / The user said no to this in Anomalous." + (f" They said: {asked['text']}" if asked.get("text") else ""))
|
||||
asked["timed_out"] = True
|
||||
ai_tasks._save(task)
|
||||
return {"content": [{"type": "text", "text": "Waiting for the user's OK in Anomalous's AI workbench: nothing was done yet. "
|
||||
"Call get_answers (wait_seconds up to 55) to hear their answer; once they allow "
|
||||
"it, call this tool again with the same arguments."}],
|
||||
"structuredContent": {"waiting_for_user": True, "gate": gate}, "isError": False}
|
||||
|
||||
|
||||
def decide(task_id, step_id, decision, text="", remember=False, now=None):
|
||||
"""The user's answer to a step that asks: "allow" or "deny" (with words for the AI)."""
|
||||
if decision not in ("allow", "deny"):
|
||||
raise ValueError("decision is allow or deny")
|
||||
with _decided:
|
||||
task, step = _step((task_id, step_id))
|
||||
asked = (step or {}).get("gate")
|
||||
if not asked or step.get("state") != "asking":
|
||||
raise ValueError("Nothing waits for an answer there")
|
||||
asked.update(decision=decision, at=time.time() if now is None else now)
|
||||
if text:
|
||||
asked["text"] = ai_tasks._short(str(text).strip(), 1000)
|
||||
if asked.get("timed_out"):
|
||||
# The AI stopped waiting: it hears of the answer as a message, and an Allow waits for its call.
|
||||
asked["delivered"] = False
|
||||
step["state"] = "allowed" if decision == "allow" else "error"
|
||||
else:
|
||||
step["state"] = "running" if decision == "allow" else "error"
|
||||
if decision == "deny":
|
||||
step.update(ok=False, error="你没有允许 / You said no")
|
||||
ai_tasks._save(task)
|
||||
_decided.notify_all()
|
||||
if remember and decision == "allow":
|
||||
set_policy(asked["gate"], "auto")
|
||||
ai_tasks._notify(task_id)
|
||||
from . import ai_panels
|
||||
ai_panels.wake()
|
||||
return step
|
||||
+210
@@ -0,0 +1,210 @@
|
||||
"""Marks the user draws on a picture to tell the AI where to change it (the AI workbench's marker,
|
||||
web/modules/ui_ai_marker.js): boxes, circles, arrows and free lines, each with a note. The page
|
||||
sends the picture with the marks drawn on it (a PNG) and the marks themselves; this keeps the
|
||||
PNG in the ComfyUI user folder (anomalous/ai_marks/<task>/<step>.png, never the output folder, so
|
||||
the gallery stays the user's pictures) and adds a "user_marks" step to the task. The AI gets it
|
||||
like a message (ai_panels._collect, kind "marks": the notes with where each mark is, in
|
||||
fractions of the picture) and, attached to the same answer, the marked picture as a thumbnail
|
||||
(image_items), so an AI that can see pictures sees the marks. Only an output picture can be
|
||||
marked; the PNG is checked (signature, size, dimensions) before it is kept.
|
||||
The user also says how to change the picture (MODES), and the AI reads that choice first, as the
|
||||
user's: leave it to the AI, change only the marked areas, or make the whole picture anew. For
|
||||
"only the marked areas" the page sends a mask (the marker's "repaint" brush, and the boxes,
|
||||
circles and lines; white where to repaint), and the picture is also written to ComfyUI's input
|
||||
folder as anomalous_inpaint_<step>.png with that area as its alpha, so LoadImage gives the
|
||||
picture and the area as its MASK for an inpaint workflow; the AI gets the file name with the marks.
|
||||
"""
|
||||
|
||||
import base64
|
||||
import io
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
import uuid
|
||||
|
||||
import folder_paths
|
||||
|
||||
from . import ai_tasks
|
||||
from .mcp_tools import _image_content
|
||||
|
||||
MAX_PNG_BYTES = 8 * 1024 * 1024
|
||||
MAX_EDGE = 4096
|
||||
MAX_MARKS = 20
|
||||
MAX_NOTE = 300
|
||||
SHAPES = ("box", "circle", "arrow", "pen")
|
||||
MODES = {
|
||||
"auto": "How to change it is up to you: say in report which way you took (repaint only the marked areas, "
|
||||
"or make the picture anew) and why. To repaint only the marked areas, propose_repaint_area(marks=this "
|
||||
"id) agrees on the area with the user and makes the picture to repaint.",
|
||||
"local": "The user chose: change ONLY the marked areas and keep everything else exactly as it is. Repaint "
|
||||
"them from inpaint_image (inpaint_note says how); do not make the whole picture anew. If the area "
|
||||
"looks off, propose_repaint_area(marks=this id) agrees on a better one first.",
|
||||
"whole": "The user chose: make the whole picture anew with these changes (its own model and prompt, "
|
||||
"changed as the notes say; a new seed or img2img). Do not repaint only a part of it.",
|
||||
}
|
||||
FILE_NAME = re.compile(r"[0-9a-f]{10}\.png")
|
||||
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
|
||||
|
||||
|
||||
class MarksError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def path_of(task_id, name):
|
||||
"""The kept PNG `name` of task `task_id`, or None (only names this module makes)."""
|
||||
if not FILE_NAME.fullmatch(str(name)):
|
||||
return None
|
||||
path = os.path.join(ai_tasks.marks_dir(task_id), name)
|
||||
return path if os.path.isfile(path) else None
|
||||
|
||||
|
||||
def _png(data_url):
|
||||
text = str(data_url or "")
|
||||
if not text.startswith("data:image/png;base64,"):
|
||||
raise MarksError("Expected the marked picture as a PNG data URL")
|
||||
try:
|
||||
data = base64.b64decode(text.split(",", 1)[1], validate=True)
|
||||
except (ValueError, IndexError):
|
||||
raise MarksError("The marked picture is not valid base64")
|
||||
if len(data) > MAX_PNG_BYTES or not data.startswith(PNG_SIGNATURE):
|
||||
raise MarksError("The marked picture is not a PNG of a usable size")
|
||||
from PIL import Image
|
||||
|
||||
try:
|
||||
with Image.open(io.BytesIO(data)) as image:
|
||||
if image.format != "PNG" or max(image.size) > MAX_EDGE:
|
||||
raise MarksError("The marked picture is too large")
|
||||
image.verify()
|
||||
except MarksError:
|
||||
raise
|
||||
except Exception: # noqa: BLE001 - whatever PIL says, it is not a picture to keep
|
||||
raise MarksError("The marked picture cannot be read")
|
||||
return data
|
||||
|
||||
|
||||
def _fraction(value):
|
||||
try:
|
||||
return min(1.0, max(0.0, round(float(value), 4)))
|
||||
except (TypeError, ValueError):
|
||||
raise MarksError("Mark positions are fractions of the picture")
|
||||
|
||||
|
||||
def _clean(marks, masked=False):
|
||||
if not isinstance(marks, list) or (not marks and not masked) or len(marks) > MAX_MARKS:
|
||||
raise MarksError(f"Between 1 and {MAX_MARKS} marks")
|
||||
out = []
|
||||
for mark in marks:
|
||||
if not isinstance(mark, dict) or mark.get("shape") not in SHAPES:
|
||||
raise MarksError(f"Each mark is one of {', '.join(SHAPES)}")
|
||||
x, y, w, h = (_fraction(mark.get(key, 0)) for key in ("x", "y", "w", "h"))
|
||||
out.append({"shape": mark["shape"], "x": x, "y": y, "w": min(w, 1 - x), "h": min(h, 1 - y),
|
||||
"note": ai_tasks._short(str(mark.get("note") or "").strip(), MAX_NOTE)})
|
||||
return out
|
||||
|
||||
|
||||
def _words(marks, text, mode="auto"):
|
||||
"""The message the AI reads: how to change the picture, the user's words, then each mark with where it is."""
|
||||
lines = [MODES[mode]] + ([text] if text else [])
|
||||
for number, mark in enumerate(marks, 1):
|
||||
where = (f"x {round(mark['x'] * 100)}–{round((mark['x'] + mark['w']) * 100)}%, "
|
||||
f"y {round(mark['y'] * 100)}–{round((mark['y'] + mark['h']) * 100)}% of the picture")
|
||||
lines.append(f"Mark {number} ({mark['shape']}, {where}): {mark['note'] or '(no note)'}")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def picture_path(picture):
|
||||
"""Where an output picture {subfolder, filename} (as _output_media gives it) is on disk."""
|
||||
return os.path.join(folder_paths.get_output_directory(), picture["subfolder"], picture["filename"])
|
||||
|
||||
|
||||
def write_inpaint(picture, area_of, name_id):
|
||||
"""The picture with its repaint area as alpha in ComfyUI's input folder (a new file, never one
|
||||
that is there), so LoadImage gives the area as MASK: its name. `area_of(size)` makes the area
|
||||
(an "L" image of that size, white where to repaint, soft edges kept)."""
|
||||
from PIL import Image, ImageOps
|
||||
|
||||
try:
|
||||
with Image.open(picture_path(picture)) as original:
|
||||
area = area_of(original.size)
|
||||
if not area.getbbox():
|
||||
raise MarksError("The repaint area is empty")
|
||||
out = original.convert("RGB")
|
||||
out.putalpha(ImageOps.invert(area)) # ComfyUI's LoadImage: MASK = 1 - alpha
|
||||
except MarksError:
|
||||
raise
|
||||
except Exception: # noqa: BLE001 - a picture PIL cannot read cannot be repainted either
|
||||
raise MarksError("The picture cannot be read for repainting")
|
||||
name = f"anomalous_inpaint_{name_id}.png"
|
||||
with open(os.path.join(folder_paths.get_input_directory(), name), "xb") as target: # never replaces a file
|
||||
out.save(target, "PNG")
|
||||
return name
|
||||
|
||||
|
||||
def _inpaint_file(picture, mask, step_id):
|
||||
"""write_inpaint with the area the user drew (`mask`, PNG bytes, white where to repaint)."""
|
||||
from PIL import Image
|
||||
|
||||
def drawn_area(size):
|
||||
with Image.open(io.BytesIO(mask)) as drawn:
|
||||
return drawn.convert("L").resize(size, Image.NEAREST).point(lambda value: 255 if value > 127 else 0)
|
||||
|
||||
return write_inpaint(picture, drawn_area, step_id)
|
||||
|
||||
|
||||
def save(task_id, image, png, marks, text="", now=None, mask=None, mode=None):
|
||||
"""Keeps the marked picture and adds the user's marks to the task, with how to change it (a
|
||||
key of MODES; without one, "local" when there is a mask, as the page sent before there was a
|
||||
choice). For "local", `mask` (a PNG data URL) also makes the picture ready to repaint
|
||||
(_inpaint_file); the other ways keep no mask. Returns the step."""
|
||||
mode = mode or ("local" if mask else "auto")
|
||||
if mode not in MODES:
|
||||
raise MarksError(f"How to change it is one of {', '.join(MODES)}")
|
||||
if mode != "local":
|
||||
mask = None
|
||||
elif not mask:
|
||||
raise MarksError("Changing only the marked areas needs a box, circle, line or painted area")
|
||||
try:
|
||||
picture = ai_tasks._output_media(image)
|
||||
except (ValueError, OSError):
|
||||
picture = None
|
||||
if not picture:
|
||||
raise MarksError("Only a picture in the output folder can be marked")
|
||||
data = _png(png)
|
||||
mask = _png(mask) if mask else None
|
||||
marks = _clean(marks, masked=mask is not None)
|
||||
text = ai_tasks._short(str(text or "").strip(), 2000)
|
||||
step_id = uuid.uuid4().hex[:10]
|
||||
now = time.time() if now is None else now
|
||||
if not ai_tasks.get_task(task_id):
|
||||
raise MarksError("No such task")
|
||||
inpaint = _inpaint_file(picture, mask, step_id) if mask else None # outside the lock: a picture takes a moment
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
if not task:
|
||||
raise MarksError("No such task")
|
||||
os.makedirs(ai_tasks.marks_dir(task_id), exist_ok=True)
|
||||
with open(os.path.join(ai_tasks.marks_dir(task_id), f"{step_id}.png"), "xb") as target: # a new name: never replaces
|
||||
target.write(data)
|
||||
step = {"id": step_id, "at": now, "ms": 0, "tool": "user_marks", "kind": "user", "ok": True, "state": "done",
|
||||
"summary": "user_marks", "text": _words(marks, text, mode), "note": text, "image": picture, "marks": marks, "mode": mode,
|
||||
"marked": f"{step_id}.png", "delivered": False, "results": [], **({"inpaint": inpaint} if inpaint else {})}
|
||||
task["steps"].append(step)
|
||||
del task["steps"][:-ai_tasks.MAX_STEPS]
|
||||
task["updated"] = max(task.get("updated", 0), now)
|
||||
task["ended"] = None # like a message (ai_panels.leave_message): the task goes on
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
return step
|
||||
|
||||
|
||||
def image_items(messages):
|
||||
"""MCP image items of the marked pictures among `messages` and of the pictures the user handed
|
||||
over (ai_pictures.py), their thumbnails, taking their private "_marked" / "_pictures" paths off
|
||||
the messages."""
|
||||
items = []
|
||||
for message in messages:
|
||||
for path in [message.pop("_marked", None), *message.pop("_pictures", [])]:
|
||||
item = _image_content(path) if path else None
|
||||
if item:
|
||||
items.append(item)
|
||||
return items
|
||||
@@ -0,0 +1,88 @@
|
||||
"""What the user points at in a message to the AI ("@" in the AI workbench's message box,
|
||||
web/modules/ui_ai_mention.js): models, combos, workflows, prompts, node types, custom node packs
|
||||
and output pictures, by the names the AI's tools use. Checked when the message is left (clean)
|
||||
and given to the AI with it (message_of): each thing as get_toolbox gives a pick (lookup), the
|
||||
pictures attached with what made them, as ai_pictures.py hands them over, so the AI needs no
|
||||
guessing which "that LoRA" is."""
|
||||
|
||||
from . import ai_pictures
|
||||
from .mcp_tools import ToolError, _resolve_image
|
||||
|
||||
KINDS = ("models", "combos", "workflows", "prompts", "nodes", "packs", "pictures")
|
||||
MAX_REFS = 12
|
||||
MAX_NAME = 300
|
||||
|
||||
|
||||
class RefsError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def clean(refs):
|
||||
"""[{kind, id, label}] from the page: known kinds, text names, each thing once, at most MAX_REFS."""
|
||||
if refs in (None, []):
|
||||
return []
|
||||
if not isinstance(refs, list) or len(refs) > MAX_REFS:
|
||||
raise RefsError(f"refs: a list of up to {MAX_REFS} things")
|
||||
out = []
|
||||
for ref in refs:
|
||||
if not isinstance(ref, dict) or ref.get("kind") not in KINDS:
|
||||
raise RefsError(f"refs: each is {{kind, id}} with kind one of {', '.join(KINDS)}")
|
||||
name = ref.get("id")
|
||||
if not isinstance(name, str) or not name.strip() or len(name) > MAX_NAME:
|
||||
raise RefsError(f"refs: an id is text of up to {MAX_NAME} characters")
|
||||
label = str(ref.get("label") or name).strip()[:MAX_NAME]
|
||||
item = {"kind": ref["kind"], "id": name.strip(), "label": label}
|
||||
if not any(have["kind"] == item["kind"] and have["id"] == item["id"] for have in out):
|
||||
out.append(item)
|
||||
return out
|
||||
|
||||
|
||||
def lookup(kind, name):
|
||||
"""A combo, workflow, prompt or model as the AI's tools give it, or None when it is gone."""
|
||||
from . import mcp_tools
|
||||
|
||||
if kind in ("combos", "workflows"):
|
||||
lister = mcp_tools.list_combos if kind == "combos" else mcp_tools.list_workflows
|
||||
return next(iter(lister(name, 1, exact_name=True)[kind]), None)
|
||||
if kind == "prompts":
|
||||
from .ai_toolbox_catalog import everything
|
||||
|
||||
return next((entry for entry in everything()["prompts"] if entry["id"] == name), None)
|
||||
if kind == "models":
|
||||
try:
|
||||
found = mcp_tools.get_model(name)
|
||||
except ToolError:
|
||||
return None
|
||||
return found[0] if isinstance(found, tuple) else found # without its cover picture
|
||||
return None
|
||||
|
||||
|
||||
def message_of(step):
|
||||
"""The refs of a message step for the AI ("refs", each in full or marked missing) and the
|
||||
pictures' files in "_pictures" for ai_marks.image_items to attach."""
|
||||
items, files = [], []
|
||||
for ref in step.get("refs") or []:
|
||||
item = {"kind": ref["kind"], "id": ref["id"], "said_as": f"@{ref['label']}"}
|
||||
if ref["kind"] == "pictures":
|
||||
try:
|
||||
rel, path = _resolve_image(ref["id"])[:2]
|
||||
except ToolError:
|
||||
item["missing"] = True
|
||||
else:
|
||||
item.update(image=rel, made_with=ai_pictures.brief(path))
|
||||
files.append(path)
|
||||
elif ref["kind"] == "nodes":
|
||||
item["note"] = "a node type: find_nodes(types=[id]) gives it in full, add_node adds it"
|
||||
elif ref["kind"] == "packs":
|
||||
item["note"] = "a custom node pack (folder): its node types are those find_nodes lists with this source"
|
||||
else:
|
||||
found = lookup(ref["kind"], ref["id"])
|
||||
if found is None:
|
||||
item["missing"] = True
|
||||
else:
|
||||
item["details"] = found
|
||||
items.append(item)
|
||||
out = {"refs": items, "refs_note": "What the user's @ names in their text point at, and the pictures they attached, exactly."}
|
||||
if files:
|
||||
out["_pictures"] = files
|
||||
return out
|
||||
@@ -0,0 +1,197 @@
|
||||
"""What happened outside Anomalous while an AI works on a task, as steps of kind "outside" in the
|
||||
AI workbench. Anomalous sees only the calls made to it: an AI app may also run commands and
|
||||
scripts of its own, and one that edits pictures that way loses their workflow and the user's
|
||||
earlier result. Two ways to see it:
|
||||
|
||||
check() looks, when the AI calls Anomalous (never in the background), at what changed since its
|
||||
previous call: pictures in ComfyUI's output folder no ComfyUI run saved, and pictures in the
|
||||
output or input folder rewritten in place (changed a while after they were made). Only the top of
|
||||
each folder, by the files' own times (made, changed), at most MAX_ENTRIES entries. While ComfyUI
|
||||
runs a prompt, new pictures wait until it ends (its history names them then). What it finds is
|
||||
a step and goes to the AI with its next answer (tell), which says it may well be the user's own
|
||||
doing. Without a creation time (Linux), output pictures are "new or changed" and the input
|
||||
folder is not looked at (an upload looks the same).
|
||||
|
||||
log() is the AI's own word: what it ran or changed outside Anomalous, why, and which files.
|
||||
"""
|
||||
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from collections import OrderedDict
|
||||
|
||||
import folder_paths
|
||||
|
||||
from . import ai_tasks
|
||||
from .mcp_tools import tool_text
|
||||
|
||||
PICTURES = {".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp", ".tif", ".tiff", ".mp4", ".webm", ".mov"}
|
||||
MAX_ENTRIES = 20000 # of a folder's top looked at in one check
|
||||
MAX_FOUND = 12 # files named in one step
|
||||
REWRITE_SECONDS = 60 # changed this long after it was made: rewritten, not just written
|
||||
HISTORY_ITEMS = 300 # ComfyUI's latest runs whose saved pictures are no news
|
||||
MAX_WATCHED = 16 # tasks whose last check is kept
|
||||
MAX_TEXT, MAX_FILES, MAX_FILE = 300, 20, 200
|
||||
|
||||
_lock = threading.Lock()
|
||||
_watched = OrderedDict() # task id -> {"since": time of the last full check, "told": {(folder, name, changed)}}
|
||||
|
||||
|
||||
def _queue():
|
||||
from server import PromptServer
|
||||
return PromptServer.instance.prompt_queue
|
||||
|
||||
|
||||
def _busy():
|
||||
"""Whether ComfyUI runs a prompt now (its pictures are in no history yet)."""
|
||||
try:
|
||||
running, _pending = _queue().get_current_queue_volatile()
|
||||
except Exception: # noqa: BLE001 - no server (tests) or an older queue: nothing runs that we know of
|
||||
return False
|
||||
return bool(running)
|
||||
|
||||
|
||||
def _saved_by_runs():
|
||||
"""Names of the pictures ComfyUI's latest runs saved at the top of the output folder."""
|
||||
try:
|
||||
history = _queue().get_history(max_items=HISTORY_ITEMS, map_function=lambda record: record.get("outputs") or {})
|
||||
except Exception: # noqa: BLE001 - no server (tests)
|
||||
return set()
|
||||
names = set()
|
||||
for outputs in history.values():
|
||||
for output in outputs.values() if isinstance(outputs, dict) else ():
|
||||
for items in output.values() if isinstance(output, dict) else ():
|
||||
for item in items if isinstance(items, list) else ():
|
||||
if isinstance(item, dict) and item.get("type") == "output" and not item.get("subfolder") and item.get("filename"):
|
||||
names.add(item["filename"])
|
||||
return names
|
||||
|
||||
|
||||
def _times(entry):
|
||||
"""(made, changed) of a folder entry; made is None where the system keeps no creation time."""
|
||||
stat = entry.stat()
|
||||
return getattr(stat, "st_birthtime", None), stat.st_mtime
|
||||
|
||||
|
||||
def _changes(folder, root, since):
|
||||
"""[(name, change, when)] of the pictures at the top of `root` changed after `since`:
|
||||
"rewritten", "new" or (no creation time) "changed"."""
|
||||
found = []
|
||||
try:
|
||||
with os.scandir(root) as entries:
|
||||
for at, entry in enumerate(entries):
|
||||
if at >= MAX_ENTRIES:
|
||||
break
|
||||
if os.path.splitext(entry.name)[1].lower() not in PICTURES or not entry.is_file(follow_symlinks=False):
|
||||
continue
|
||||
made, changed = _times(entry)
|
||||
if changed <= since and (made is None or made <= since):
|
||||
continue
|
||||
if made is None:
|
||||
found.append((entry.name, "changed", changed))
|
||||
elif changed - made > REWRITE_SECONDS:
|
||||
found.append((entry.name, "rewritten", changed))
|
||||
elif made > since:
|
||||
found.append((entry.name, "new", changed))
|
||||
except OSError:
|
||||
return []
|
||||
return [item for item in found if folder == "output" or item[1] == "rewritten"]
|
||||
|
||||
|
||||
def check(task_id, now=None):
|
||||
"""What changed outside Anomalous since the last check of `task_id`, as a step of the task
|
||||
(also returned), or None. The first check of a task only starts the watch."""
|
||||
if not task_id:
|
||||
return None
|
||||
now = time.time() if now is None else now
|
||||
with _lock:
|
||||
watch = _watched.get(task_id)
|
||||
if watch is None:
|
||||
_watched[task_id] = {"since": now, "told": set()}
|
||||
while len(_watched) > MAX_WATCHED:
|
||||
_watched.popitem(last=False)
|
||||
return None
|
||||
_watched.move_to_end(task_id)
|
||||
busy = _busy()
|
||||
saved = set() if busy else _saved_by_runs()
|
||||
files = []
|
||||
for folder, root in (("output", folder_paths.get_output_directory()), ("input", folder_paths.get_input_directory())):
|
||||
for name, change, when in _changes(folder, root, watch["since"]):
|
||||
if busy and change != "rewritten":
|
||||
continue # maybe the running prompt's: judged once it ends
|
||||
if change != "rewritten" and name in saved:
|
||||
continue
|
||||
if (folder, name, when) not in watch["told"]:
|
||||
watch["told"].add((folder, name, when))
|
||||
files.append({"folder": folder, "name": name, "change": change})
|
||||
if not busy:
|
||||
# A file's change time can be a second or two after the clock read (Windows): kept as told
|
||||
# until it is older than the next check's start.
|
||||
watch.update(since=now, told={key for key in watch["told"] if key[2] > now})
|
||||
if not files:
|
||||
return None
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "outside_files", "kind": "outside", "ok": True,
|
||||
"state": "done", "summary": "outside_files", "files": files[:MAX_FOUND], "more": max(0, len(files) - MAX_FOUND),
|
||||
"results": []}
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
if not task:
|
||||
return None
|
||||
ai_tasks._add_step(task, step)
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
return step
|
||||
|
||||
|
||||
def tell(result, step):
|
||||
"""Puts what check() found into the AI's tool result."""
|
||||
if not step or not isinstance(result, dict):
|
||||
return result
|
||||
files = [f"{item['folder']}/{item['name']} ({item['change']})" for item in step["files"]]
|
||||
note = ("Anomalous saw pictures change outside its tools since your previous call; it shows them to the user. "
|
||||
"It may be the user's own doing. If it was yours: never edit, crop, paint or overwrite pictures with code "
|
||||
"of your own (that loses their workflow and the user's earlier result); change a picture by running a "
|
||||
"ComfyUI workflow, look at one with zoom_image, and say what you ran outside Anomalous with log_outside.")
|
||||
if result.get("isError"):
|
||||
result["content"] = list(result.get("content") or []) + [{"type": "text", "text": f"{note} Files: {', '.join(files)}"}]
|
||||
return result
|
||||
data = result.get("structuredContent")
|
||||
data = dict(data) if isinstance(data, dict) else {}
|
||||
data["outside_changes"], data["outside_note"] = files, note
|
||||
result["structuredContent"] = data
|
||||
content = list(result.get("content") or [])
|
||||
text = {"type": "text", "text": tool_text(data)}
|
||||
if content and isinstance(content[0], dict) and content[0].get("type") == "text":
|
||||
content[0] = text
|
||||
else:
|
||||
content.insert(0, text)
|
||||
result["content"] = content
|
||||
return result
|
||||
|
||||
|
||||
def _line(value, limit, what):
|
||||
value = str(value or "").strip()
|
||||
if len(value) > limit:
|
||||
raise ValueError(f"{what} is longer than {limit} characters.")
|
||||
return value
|
||||
|
||||
|
||||
def log(client, what, why="", files=None, now=None, session="", task_id=None):
|
||||
"""The AI's word on what it did outside Anomalous, as a step of its task. Returns the step."""
|
||||
what = _line(what, MAX_TEXT, "what")
|
||||
if not what:
|
||||
raise ValueError("what is empty: the command, script or change you made outside Anomalous.")
|
||||
if files is not None and not isinstance(files, list):
|
||||
raise ValueError("files is a list of the files you read, wrote or changed.")
|
||||
named = [_line(item, MAX_FILE, "a file") for item in (files or [])[:MAX_FILES] if str(item or "").strip()]
|
||||
now = time.time() if now is None else now
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "log_outside", "kind": "outside", "ok": True,
|
||||
"state": "done", "summary": f"log_outside: {what[:80]}", "what": what, "why": _line(why, MAX_TEXT, "why"),
|
||||
"files": named, "results": []}
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks.current_task(client, now, session=session, task_id=task_id)
|
||||
ai_tasks._add_step(task, step)
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task["id"])
|
||||
return step
|
||||
@@ -0,0 +1,598 @@
|
||||
"""Panels the AI draws in its task (show_panel), from Anomalous's own blocks, and the answers
|
||||
the user gives on them.
|
||||
|
||||
A panel is a step of the AI's current task (ai_tasks.py) holding a title and a list of blocks:
|
||||
heading, text, images (from ComfyUI's output folder, with marks: circles or boxes and a label
|
||||
at places given as fractions of the picture), slider (two pictures over each other, a line to
|
||||
drag between them), picks (pictures with a reason and "take this one"), models (the user's, by
|
||||
model_id), diagram (boxes and arrows, laid out by the page; a box can name a canvas node),
|
||||
table, list, params, choices (buttons; one or several picks) and input (a line of text),
|
||||
progress, divider; and area (the user's repaint area beside the AI's, ai_repaint.py). Nothing the AI sends is run or rendered as markup, and no drawing of its own
|
||||
(SVG) is taken: every block is checked here to be one of these shapes, with plain strings and
|
||||
numbers of bounded size, pictures only from the output folder and models only from the user's
|
||||
folders. The page draws them (ui_ai_panel.js).
|
||||
|
||||
The user's answers come back through POST /anomalous/ai_tasks/{task}/answer and wait in the
|
||||
step until the AI asks for them (get_answers, which may wait a while for one) or makes its next
|
||||
successful MCP tool call (attach_pending). The user can also write to the AI in a task
|
||||
(POST /anomalous/ai_tasks/{task}/message): the message is a step of its own and reaches the AI
|
||||
the same way.
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
|
||||
import folder_paths
|
||||
|
||||
from . import ai_marks, ai_tasks
|
||||
from .mcp_tools import tool_text
|
||||
|
||||
MAX_BLOCKS = 30
|
||||
MAX_ITEMS = 12
|
||||
MAX_ROWS = 30
|
||||
MAX_COLUMNS = 8
|
||||
MAX_WAIT = 55
|
||||
TONES = ("normal", "muted", "tip", "warning")
|
||||
LAYOUTS = ("row", "grid", "compare")
|
||||
INTERACTIVE = ("choices", "input", "picks")
|
||||
INPAINT_NOTE = (
|
||||
"inpaint_image is the picture with the area to repaint: LoadImage(image=inpaint_image) gives the picture and, as MASK, that area. "
|
||||
"inpaint_image is already in ComfyUI's input folder, ready: do not check it with a command; "
|
||||
"get_image_info(image=inpaint_image, folder='input', include_image=true) shows it and the area, zoom_image a part "
|
||||
"of it larger. Repaint with a workflow; do not paint the picture with code of your own. "
|
||||
"Use the picture's own model and prompt (get_image_info on image) and build it with add_node and its wiring "
|
||||
"(in the picture's workflow, LoadImage -> VAEEncode(pixels, vae) -> SetLatentNoiseMask(samples, mask) in place "
|
||||
"of the empty latent), e.g. new_workflow: CheckpointLoaderSimple, "
|
||||
"LoadImage, CLIPTextEncode x2, VAEEncode(pixels, vae) -> SetLatentNoiseMask(samples, mask) -> KSampler "
|
||||
"(denoise 0.5-0.8 keeps the look; 1.0 with VAEEncodeForInpaint(grow_mask_by 8) replaces it) -> VAEDecode -> "
|
||||
"SaveImage; GrowMask softens the edge. Say in report what you set and why, ask_user the strength if unsure, "
|
||||
"and show the old and new picture with a slider panel."
|
||||
)
|
||||
COLORS = ("red", "green", "blue", "yellow", "purple")
|
||||
MAX_MARKS = 8
|
||||
MAX_NODES = 24
|
||||
MAX_EDGES = 40
|
||||
|
||||
_answered = threading.Condition(ai_tasks._lock)
|
||||
|
||||
|
||||
class PanelError(ValueError):
|
||||
"""What is wrong with a panel, for the AI to fix."""
|
||||
|
||||
|
||||
def _text(value, limit, where, required=False):
|
||||
if value is None and not required:
|
||||
return ""
|
||||
if not isinstance(value, (str, int, float)) or isinstance(value, bool):
|
||||
raise PanelError(f"{where} must be text")
|
||||
text = str(value).strip()
|
||||
if required and not text:
|
||||
raise PanelError(f"{where} is empty")
|
||||
return text[:limit]
|
||||
|
||||
|
||||
def _list(value, limit, where):
|
||||
if value is None:
|
||||
return []
|
||||
if not isinstance(value, list):
|
||||
raise PanelError(f"{where} must be a list")
|
||||
if len(value) > limit:
|
||||
raise PanelError(f"{where} has more than {limit} items")
|
||||
return value
|
||||
|
||||
|
||||
def _fraction(value, where):
|
||||
if not isinstance(value, (int, float)) or isinstance(value, bool) or not 0 <= value <= 1:
|
||||
raise PanelError(f"{where} must be a number from 0 to 1 (a fraction of the picture)")
|
||||
return round(float(value), 4)
|
||||
|
||||
|
||||
def _marks(value, where):
|
||||
marks = []
|
||||
for i, mark in enumerate(_list(value, MAX_MARKS, where)):
|
||||
here = f"{where}[{i}]"
|
||||
if not isinstance(mark, dict):
|
||||
raise PanelError(f"{here} must be {{x, y, w, h | r, label, color}}")
|
||||
out = {"x": _fraction(mark.get("x"), f"{here}.x"), "y": _fraction(mark.get("y"), f"{here}.y"),
|
||||
"label": _text(mark.get("label"), 60, f"{here}.label"),
|
||||
"color": mark.get("color") if mark.get("color") in COLORS else "red"}
|
||||
if mark.get("w") is not None or mark.get("h") is not None:
|
||||
out.update(w=_fraction(mark.get("w"), f"{here}.w"), h=_fraction(mark.get("h"), f"{here}.h"))
|
||||
else:
|
||||
out["r"] = _fraction(mark.get("r", 0.06), f"{here}.r")
|
||||
marks.append(out)
|
||||
return marks
|
||||
|
||||
|
||||
def _image(item, where):
|
||||
image = item.get("image") if isinstance(item, dict) else item
|
||||
found = ai_tasks._output_media(str(image or ""))
|
||||
if not found:
|
||||
raise PanelError(f"{where}: {image!r} is not a picture in ComfyUI's output folder (subfolder/name.png, as search_images gives it)")
|
||||
out = {**found, "caption": _text(item.get("caption") if isinstance(item, dict) else "", 120, f"{where}.caption")}
|
||||
if isinstance(item, dict) and item.get("marks"):
|
||||
out["marks"] = _marks(item["marks"], f"{where}.marks")
|
||||
return out
|
||||
|
||||
|
||||
def _diagram(block, where):
|
||||
nodes, ids = [], set()
|
||||
for i, node in enumerate(_list(block.get("nodes"), MAX_NODES, f"{where}.nodes")):
|
||||
here = f"{where}.nodes[{i}]"
|
||||
if not isinstance(node, dict):
|
||||
raise PanelError(f"{here} must be {{id, label, detail, node_id}}")
|
||||
node_id = _text(node.get("id") or f"n{i + 1}", 40, f"{here}.id")
|
||||
if node_id in ids:
|
||||
raise PanelError(f"{here}.id {node_id!r} twice")
|
||||
ids.add(node_id)
|
||||
out = {"id": node_id, "label": _text(node.get("label"), 40, f"{here}.label", True),
|
||||
"detail": _text(node.get("detail"), 80, f"{here}.detail"),
|
||||
"color": node.get("color") if node.get("color") in COLORS else ""}
|
||||
if node.get("node_id") not in (None, ""):
|
||||
out["node_id"] = _text(node.get("node_id"), 20, f"{here}.node_id")
|
||||
nodes.append(out)
|
||||
if not nodes:
|
||||
raise PanelError(f"{where}.nodes is empty")
|
||||
edges = []
|
||||
for i, edge in enumerate(_list(block.get("edges"), MAX_EDGES, f"{where}.edges")):
|
||||
here = f"{where}.edges[{i}]"
|
||||
if not isinstance(edge, dict) or edge.get("from") not in ids or edge.get("to") not in ids:
|
||||
raise PanelError(f"{here} must be {{from, to, label}} naming two node ids")
|
||||
edges.append({"from": edge["from"], "to": edge["to"], "label": _text(edge.get("label"), 30, f"{here}.label")})
|
||||
return {"nodes": nodes, "edges": edges, "direction": "down" if block.get("direction") == "down" else "right"}
|
||||
|
||||
|
||||
def _model(item, where):
|
||||
from .mcp_tools import ToolError, _resolve_model
|
||||
from .model_media import _preview_url_for_model
|
||||
|
||||
model_id = item.get("model_id") if isinstance(item, dict) else item
|
||||
try:
|
||||
folder_type, path_idx, base_dir, file_path = _resolve_model(model_id)
|
||||
except ToolError as error:
|
||||
raise PanelError(f"{where}: {error}")
|
||||
try:
|
||||
cover = _preview_url_for_model(folder_type, path_idx, base_dir, file_path) or ""
|
||||
except Exception: # noqa: BLE001 - a card without its cover is still a card
|
||||
cover = ""
|
||||
return {"model_id": str(model_id), "folder": folder_type, "path_idx": path_idx,
|
||||
"rel": os.path.relpath(file_path, base_dir).replace(os.sep, "/"), "name": os.path.basename(file_path),
|
||||
"cover": cover, "note": _text(item.get("note") if isinstance(item, dict) else "", 160, f"{where}.note")}
|
||||
|
||||
|
||||
def clean_block(block, at, taken):
|
||||
"""One block as the page may draw it, or PanelError."""
|
||||
where = f"blocks[{at}]"
|
||||
if not isinstance(block, dict) or not isinstance(block.get("type"), str):
|
||||
raise PanelError(f"{where} must be an object with a type")
|
||||
kind = block["type"]
|
||||
out = {"type": kind}
|
||||
if kind == "heading":
|
||||
out["text"] = _text(block.get("text"), 120, f"{where}.text", True)
|
||||
elif kind == "text":
|
||||
out["text"] = _text(block.get("text"), 4000, f"{where}.text", True)
|
||||
out["tone"] = block.get("tone") if block.get("tone") in TONES else "normal"
|
||||
elif kind == "images":
|
||||
items = _list(block.get("items"), MAX_ITEMS, f"{where}.items")
|
||||
if not items:
|
||||
raise PanelError(f"{where}.items is empty")
|
||||
out["items"] = [_image(item, f"{where}.items[{i}]") for i, item in enumerate(items)]
|
||||
out["layout"] = block.get("layout") if block.get("layout") in LAYOUTS else "row"
|
||||
elif kind == "slider":
|
||||
out.update(before=_image(block.get("before"), f"{where}.before"), after=_image(block.get("after"), f"{where}.after"),
|
||||
before_label=_text(block.get("before_label"), 40, f"{where}.before_label"),
|
||||
after_label=_text(block.get("after_label"), 40, f"{where}.after_label"))
|
||||
elif kind == "picks":
|
||||
items, ids = [], set()
|
||||
raw = _list(block.get("items"), MAX_ITEMS, f"{where}.items")
|
||||
if len(raw) < 2:
|
||||
raise PanelError(f"{where}.items needs 2 to {MAX_ITEMS} pictures")
|
||||
for i, item in enumerate(raw):
|
||||
here = f"{where}.items[{i}]"
|
||||
if not isinstance(item, dict):
|
||||
raise PanelError(f"{here} must be {{id, image, label, reason, recommended}}")
|
||||
item_id = _text(item.get("id") or f"p{i + 1}", 40, f"{here}.id")
|
||||
if item_id in ids:
|
||||
raise PanelError(f"{here}.id {item_id!r} twice")
|
||||
ids.add(item_id)
|
||||
picture = _image(item, here)
|
||||
items.append({**picture, "id": item_id, "label": _text(item.get("label"), 60, f"{here}.label"),
|
||||
"reason": _text(item.get("reason"), 200, f"{here}.reason"), "recommended": item.get("recommended") is True})
|
||||
out.update(question=_text(block.get("question"), 200, f"{where}.question"), items=items,
|
||||
multiple=block.get("multiple") is True)
|
||||
elif kind == "run_map": # a run's real shape (ai_run_map.py), drawn by the page from the step; only show_run_map makes it
|
||||
out["step"] = _text(block.get("step"), 20, f"{where}.step", True)
|
||||
elif kind == "area": # the user's repaint area and the AI's, pictures in the task's marks folder; only ai_repaint makes it
|
||||
if not all(ai_marks.FILE_NAME.fullmatch(str(block.get(side))) for side in ("yours", "ai")):
|
||||
raise PanelError(f"{where}: an area block shows pictures Anomalous made")
|
||||
out.update({side: block[side] for side in ("yours", "ai")}, grow=int(block.get("grow") or 0), feather=int(block.get("feather") or 0))
|
||||
elif kind == "diagram":
|
||||
out.update(_diagram(block, where))
|
||||
elif kind == "models":
|
||||
items = _list(block.get("items"), MAX_ITEMS, f"{where}.items")
|
||||
if not items:
|
||||
raise PanelError(f"{where}.items is empty")
|
||||
out["items"] = [_model(item, f"{where}.items[{i}]") for i, item in enumerate(items)]
|
||||
elif kind == "table":
|
||||
columns = [_text(c, 60, f"{where}.columns") for c in _list(block.get("columns"), MAX_COLUMNS, f"{where}.columns")]
|
||||
rows = []
|
||||
for r, row in enumerate(_list(block.get("rows"), MAX_ROWS, f"{where}.rows")):
|
||||
cells = _list(row, MAX_COLUMNS, f"{where}.rows[{r}]")
|
||||
rows.append([_text(cell, 200, f"{where}.rows[{r}]") for cell in cells])
|
||||
if not rows:
|
||||
raise PanelError(f"{where}.rows is empty")
|
||||
out.update(columns=columns, rows=rows)
|
||||
elif kind == "list":
|
||||
items = [_text(item, 300, f"{where}.items") for item in _list(block.get("items"), MAX_ROWS, f"{where}.items")]
|
||||
if not items:
|
||||
raise PanelError(f"{where}.items is empty")
|
||||
out.update(items=items, ordered=block.get("ordered") is True)
|
||||
elif kind == "params":
|
||||
items = []
|
||||
for i, item in enumerate(_list(block.get("items"), MAX_ROWS, f"{where}.items")):
|
||||
if not isinstance(item, dict):
|
||||
raise PanelError(f"{where}.items[{i}] must be {{label, value}}")
|
||||
items.append({"label": _text(item.get("label"), 60, f"{where}.items[{i}].label", True),
|
||||
"value": _text(item.get("value"), 300, f"{where}.items[{i}].value")})
|
||||
if not items:
|
||||
raise PanelError(f"{where}.items is empty")
|
||||
out["items"] = items
|
||||
elif kind == "choices":
|
||||
options, ids = [], set()
|
||||
raw = _list(block.get("options"), 8, f"{where}.options")
|
||||
if len(raw) < 2:
|
||||
raise PanelError(f"{where}.options needs 2 to 8 options")
|
||||
for i, option in enumerate(raw):
|
||||
if not isinstance(option, dict):
|
||||
option = {"label": option}
|
||||
label = _text(option.get("label"), 80, f"{where}.options[{i}].label", True)
|
||||
option_id = _text(option.get("id") or f"o{i + 1}", 40, f"{where}.options[{i}].id")
|
||||
if option_id in ids:
|
||||
raise PanelError(f"{where}.options: id {option_id!r} twice")
|
||||
ids.add(option_id)
|
||||
options.append({"id": option_id, "label": label, "detail": _text(option.get("detail"), 200, f"{where}.options[{i}].detail"),
|
||||
**({"recommended": True} if option.get("recommended") is True else {}),
|
||||
**({"label_key": option["label_key"]} if re.fullmatch(r"ai[A-Z]\w{1,40}", str(option.get("label_key"))) else {})})
|
||||
# other: a line for an answer none of the options is
|
||||
out.update(question=_text(block.get("question"), 200, f"{where}.question"), options=options,
|
||||
multiple=block.get("multiple") is True, other=block.get("other") is True)
|
||||
elif kind == "input":
|
||||
out.update(question=_text(block.get("question"), 200, f"{where}.question", True),
|
||||
placeholder=_text(block.get("placeholder"), 80, f"{where}.placeholder"))
|
||||
elif kind == "progress":
|
||||
value, top = block.get("value"), block.get("max", 100)
|
||||
if not all(isinstance(n, (int, float)) and not isinstance(n, bool) for n in (value, top)) or top <= 0:
|
||||
raise PanelError(f"{where}: value and max must be numbers, max above 0")
|
||||
out.update(label=_text(block.get("label"), 120, f"{where}.label"), value=max(0, min(value, top)), max=top)
|
||||
elif kind == "divider":
|
||||
pass
|
||||
else:
|
||||
raise PanelError(f"{where}.type {kind!r} is not one of heading, text, images, slider, picks, models, diagram, "
|
||||
"table, list, params, choices, input, progress, divider")
|
||||
if kind in INTERACTIVE or block.get("id") is not None:
|
||||
block_id = _text(block.get("id") or f"q{at + 1}", 40, f"{where}.id")
|
||||
if block_id in taken:
|
||||
raise PanelError(f"{where}.id {block_id!r} twice")
|
||||
taken.add(block_id)
|
||||
out["id"] = block_id
|
||||
return out
|
||||
|
||||
|
||||
def clean_blocks(blocks):
|
||||
blocks = _list(blocks, MAX_BLOCKS, "blocks")
|
||||
if not blocks:
|
||||
raise PanelError("blocks is empty")
|
||||
taken = set()
|
||||
return [clean_block(block, at, taken) for at, block in enumerate(blocks)]
|
||||
|
||||
|
||||
def _block_ids(blocks):
|
||||
"""Stable handles for deliberate edits; old records get them only when updated."""
|
||||
taken = {block["id"] for block in blocks if block.get("id")}
|
||||
out = []
|
||||
for block in blocks:
|
||||
block = dict(block)
|
||||
if not block.get("id"):
|
||||
block_id = uuid.uuid4().hex[:10]
|
||||
while block_id in taken:
|
||||
block_id = uuid.uuid4().hex[:10]
|
||||
block["id"] = block_id
|
||||
taken.add(block_id)
|
||||
out.append(block)
|
||||
return out
|
||||
|
||||
|
||||
def _merge_blocks(existing, incoming):
|
||||
"""Keep the order already seen, append new output, edit only identified blocks in place."""
|
||||
merged = list(existing)
|
||||
by_id = {block["id"]: at for at, block in enumerate(existing) if block.get("id")}
|
||||
used = set()
|
||||
for raw, block in zip(incoming, clean_blocks(incoming)):
|
||||
if block["type"] in INTERACTIVE and not raw.get("id"):
|
||||
# Positional q1/q2 defaults cannot identify a question in a partial append.
|
||||
block.pop("id")
|
||||
at = by_id.get(block.get("id"))
|
||||
if at is None and not block.get("id"):
|
||||
# A client may send its entire previous layout again. That cannot reorder it.
|
||||
at = next((i for i, old in enumerate(existing) if i not in used
|
||||
and {key: value for key, value in old.items() if key != "id"} == block), None)
|
||||
if at is None and block["type"] == "progress":
|
||||
matches = [i for i, old in enumerate(existing) if old["type"] == "progress"
|
||||
and old.get("label") == block.get("label")]
|
||||
if len(matches) == 1:
|
||||
at = matches[0]
|
||||
if at is None:
|
||||
merged.append(block)
|
||||
else:
|
||||
if existing[at]["type"] != block["type"]:
|
||||
raise PanelError("An existing block id must keep its type; use a new id for new output.")
|
||||
merged[at] = {**block, **({"id": existing[at]["id"]} if existing[at].get("id") else {})}
|
||||
used.add(at)
|
||||
if len(merged) > MAX_BLOCKS:
|
||||
raise PanelError(f"The panel would exceed {MAX_BLOCKS} blocks; use show_panel for the next stage of work.")
|
||||
return _block_ids(merged)
|
||||
|
||||
|
||||
def _find(panel_id):
|
||||
"""(task, step) holding panel `panel_id`, or (None, None). Call under the lock."""
|
||||
for task in ai_tasks._load().values():
|
||||
for step in task.get("steps") or []:
|
||||
if step.get("kind") == "panel" and step.get("panel", {}).get("id") == panel_id:
|
||||
return task, step
|
||||
return None, None
|
||||
|
||||
|
||||
def show(client, title, blocks, now=None, session="", task_id=None, tool="show_panel", extra=None):
|
||||
title = _text(title, 120, "title", True)
|
||||
panel = {"id": uuid.uuid4().hex[:10], "title": title, "blocks": _block_ids(clean_blocks(blocks)), "closed": False}
|
||||
now = time.time() if now is None else now
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": tool, "kind": "panel", "ok": True,
|
||||
"summary": f"{tool}: {title}", "panel": panel, "answers": {}, "results": [], **(extra or {})}
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks.current_task(client, now, session=session, task_id=task_id, follow_up=True)
|
||||
ai_tasks._add_step(task, step)
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task["id"], {"panel": title, "asks": any(b["type"] in INTERACTIVE for b in panel["blocks"])})
|
||||
return panel
|
||||
|
||||
|
||||
def update(panel_id, title=None, blocks=None, closed=None):
|
||||
with ai_tasks._lock:
|
||||
task, step = _find(str(panel_id))
|
||||
if not step:
|
||||
raise PanelError(f"No panel {panel_id!r}; show_panel returns its id.")
|
||||
# Validate the whole update before replacing the saved panel.
|
||||
panel = dict(step["panel"])
|
||||
if title is not None:
|
||||
panel["title"] = _text(title, 120, "title", True)
|
||||
if blocks is not None:
|
||||
panel["blocks"] = _merge_blocks(panel["blocks"], blocks)
|
||||
panel["changed"] = time.time() # when its numbers were written: the page greys a progress bar the task went past
|
||||
if closed is not None:
|
||||
panel["closed"] = bool(closed)
|
||||
step["panel"] = panel
|
||||
task["updated"] = max(task.get("updated", 0), time.time())
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task["id"])
|
||||
return panel
|
||||
|
||||
|
||||
def answer(task_id, step_id, block_id, choice=None, text=None, now=None, skip=False, extra=None):
|
||||
"""The user's answer to one block of a panel (from the page), or `skip` it, with `extra` for the AI
|
||||
(ai_repaint.prepare). Returns the step's answers."""
|
||||
with _answered:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
step = next((item for item in (task or {}).get("steps") or [] if item.get("id") == step_id), None)
|
||||
if not step or step.get("kind") != "panel":
|
||||
raise PanelError("No such panel")
|
||||
if step["panel"].get("closed"):
|
||||
raise PanelError("The AI closed this panel")
|
||||
block = next((b for b in step["panel"]["blocks"] if b.get("id") == block_id), None)
|
||||
if not block or block["type"] not in INTERACTIVE:
|
||||
raise PanelError("No such question")
|
||||
if block_id in step.setdefault("answers", {}):
|
||||
raise PanelError("Already answered")
|
||||
entry = {"at": time.time() if now is None else now, "delivered": False, **(extra or {})}
|
||||
if skip:
|
||||
entry["skipped"] = True
|
||||
elif block["type"] == "choices" and block.get("other") and not choice and isinstance(text, str) and text.strip():
|
||||
entry.update(choice=["other"], labels=["other"], text=_text(text, 2000, "text", True))
|
||||
elif block["type"] in ("choices", "picks"):
|
||||
picked = choice if isinstance(choice, list) else [choice]
|
||||
options = block["options"] if block["type"] == "choices" else block["items"]
|
||||
known = {option["id"]: option.get("label") or option["id"] for option in options}
|
||||
picked = [str(item) for item in picked if str(item) in known]
|
||||
if not picked or (len(picked) > 1 and not block.get("multiple")):
|
||||
raise PanelError("Pick one of the options")
|
||||
entry.update(choice=picked, labels=[known[item] for item in picked])
|
||||
else:
|
||||
value = _text(text, 2000, "text", True)
|
||||
entry["text"] = value
|
||||
step["answers"][block_id] = entry
|
||||
task["updated"] = max(task.get("updated", 0), entry["at"])
|
||||
ai_tasks._save(task)
|
||||
_answered.notify_all()
|
||||
answers = dict(step["answers"])
|
||||
ai_tasks._notify(task_id)
|
||||
return answers
|
||||
|
||||
|
||||
MAX_MESSAGE = 2000
|
||||
|
||||
|
||||
def leave_message(task_id, text, refs=None, now=None):
|
||||
"""A message from the user to the AI working on task `task_id`, with what its "@" point at and
|
||||
the pictures attached (ai_message_refs.py); words may be left out when something is attached.
|
||||
Returns the step."""
|
||||
from . import ai_message_refs
|
||||
|
||||
try:
|
||||
refs = ai_message_refs.clean(refs)
|
||||
except ai_message_refs.RefsError as error:
|
||||
raise PanelError(str(error))
|
||||
text = _text(text, MAX_MESSAGE, "text", not refs)
|
||||
now = time.time() if now is None else now
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "user_message", "kind": "user", "ok": True,
|
||||
"summary": "user_message", "text": text, "delivered": False, "results": [], **({"refs": refs} if refs else {})}
|
||||
with _answered:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
if not task:
|
||||
raise PanelError("No such task")
|
||||
task["steps"].append(step)
|
||||
del task["steps"][:-ai_tasks.MAX_STEPS]
|
||||
task["updated"] = max(task.get("updated", 0), now)
|
||||
task["ended"] = None # writing to the AI goes on with the task: its next call comes back here
|
||||
ai_tasks._save(task)
|
||||
_answered.notify_all()
|
||||
ai_tasks._notify(task_id)
|
||||
return step
|
||||
|
||||
|
||||
def _collect(client, panel_id, task_id=None):
|
||||
"""Answers and messages not given to the AI yet (its own tasks, task `task_id`, or panel
|
||||
`panel_id` and the messages of that panel's task), marked as given. Under the lock."""
|
||||
out, waiting, messages, changed = [], [], [], set()
|
||||
tasks = ai_tasks._load()
|
||||
panel_task = _find(panel_id)[0] if panel_id is not None else None
|
||||
named_task = tasks.get(task_id) if task_id else None
|
||||
for task in tasks.values():
|
||||
if panel_id is not None:
|
||||
if task is not panel_task:
|
||||
continue
|
||||
elif task_id is not None:
|
||||
if task is not named_task:
|
||||
continue
|
||||
elif task.get("client") != client:
|
||||
continue
|
||||
for step in task.get("steps") or []:
|
||||
if step.get("kind") == "user" and not step.get("delivered") and (panel_id is None or task is panel_task):
|
||||
step.update(delivered=True, delivered_at=time.time())
|
||||
changed.add(task["id"])
|
||||
message = {"id": step["id"], "task": task["id"], "text": step["text"], "at": step["at"]}
|
||||
if step.get("tool") == "user_activity":
|
||||
message["kind"] = "change" # something the user changed in Anomalous, not words to the AI
|
||||
elif step.get("tool") == "user_pictures":
|
||||
from . import ai_pictures
|
||||
message.update(ai_pictures.message_of(step)) # the pictures themselves go with it
|
||||
elif step.get("refs"):
|
||||
from . import ai_message_refs
|
||||
message.update(ai_message_refs.message_of(step)) # what its "@" point at, pictures attached
|
||||
elif step.get("tool") == "user_stop":
|
||||
message["kind"] = "stop" # the user stopped the AI's run (ai_run_control.py)
|
||||
elif step.get("tool") == "user_toolbox":
|
||||
message["kind"] = "toolbox" # what the user picked for the AI to work with (ai_toolbox.py)
|
||||
elif step.get("tool") == "user_marks":
|
||||
# Marks on a picture: the picture's path for the AI, and the marked one attached (ai_marks.image_items).
|
||||
message.update(kind="marks", image="/".join(part for part in (step["image"].get("subfolder"), step["image"]["filename"]) if part),
|
||||
mode=step.get("mode") or ("local" if step.get("inpaint") else "auto"),
|
||||
_marked=ai_marks.path_of(task["id"], step.get("marked")))
|
||||
if step.get("inpaint"):
|
||||
message.update(inpaint_image=step["inpaint"], inpaint_note=INPAINT_NOTE)
|
||||
messages.append(message)
|
||||
continue
|
||||
asked = step.get("gate") or {}
|
||||
if asked.get("timed_out") and asked.get("decision") and not asked.get("delivered") and panel_id is None:
|
||||
asked["delivered"] = True
|
||||
changed.add(task["id"])
|
||||
messages.append({"id": step["id"], "task": task["id"], "kind": "gate", "at": asked.get("at"),
|
||||
"text": (f"The user allowed {step['tool']}: call it again with the same arguments now."
|
||||
if asked["decision"] == "allow" else
|
||||
f"The user said no to {step['tool']}." + (f" They said: {asked['text']}" if asked.get("text") else ""))})
|
||||
continue
|
||||
panel = step.get("panel")
|
||||
if step.get("kind") != "panel" or (panel_id is not None and panel["id"] != panel_id):
|
||||
continue
|
||||
for block in panel["blocks"]:
|
||||
if block["type"] not in INTERACTIVE:
|
||||
continue
|
||||
given = step.get("answers", {}).get(block["id"])
|
||||
if not given:
|
||||
if not panel.get("closed"):
|
||||
waiting.append({"panel": panel["id"], "question": block["id"]})
|
||||
continue
|
||||
if given.get("delivered"):
|
||||
continue
|
||||
given.update(delivered=True, delivered_at=time.time())
|
||||
changed.add(task["id"])
|
||||
item = {"panel": panel["id"], "question": block["id"], "asked": block.get("question", "")}
|
||||
item.update({key: given[key] for key in ("choice", "labels", "text", "skipped", "inpaint_image", "note", "recommended_on_timeout") if key in given})
|
||||
out.append(item)
|
||||
for tid in changed:
|
||||
ai_tasks._save(tasks[tid])
|
||||
return out, waiting, messages, changed
|
||||
|
||||
|
||||
def wake():
|
||||
"""Anything waiting in get_answers looks again (the user added something to a task)."""
|
||||
with _answered:
|
||||
_answered.notify_all()
|
||||
|
||||
|
||||
def get_answers(client, panel_id=None, wait_seconds=0, task_id=None):
|
||||
"""The user's new answers and messages; with `wait_seconds`, waits up to that long (MAX_WAIT)
|
||||
for one: for a panel's question still open, or (no panel named) for anything the user sends."""
|
||||
deadline = time.monotonic() + max(0, min(float(wait_seconds or 0), MAX_WAIT))
|
||||
panel_id = str(panel_id) if panel_id else None
|
||||
notified = set()
|
||||
try:
|
||||
with _answered:
|
||||
if panel_id is not None and _find(panel_id)[1] is None:
|
||||
raise PanelError(f"No panel {panel_id!r}; show_panel returns its id.")
|
||||
while True:
|
||||
answers, waiting, messages, changed = _collect(client, panel_id, task_id=task_id)
|
||||
notified.update(changed)
|
||||
left = deadline - time.monotonic()
|
||||
if answers or messages or left <= 0 or (panel_id is not None and not waiting):
|
||||
answer = {"answers": answers, "still_waiting": waiting}
|
||||
if messages:
|
||||
answer["messages"] = messages
|
||||
return answer
|
||||
_answered.wait(left)
|
||||
finally:
|
||||
for tid in notified:
|
||||
ai_tasks._notify(tid)
|
||||
|
||||
|
||||
def attach_pending(result, client, task_id=None):
|
||||
"""Attaches unread user messages and panel answers to a successful tool result so an AI
|
||||
that does not call get_answers still receives them once."""
|
||||
if not isinstance(result, dict) or result.get("isError"):
|
||||
return result
|
||||
with _answered:
|
||||
answers, waiting, messages, changed = _collect(client, None, task_id=task_id)
|
||||
for tid in changed:
|
||||
ai_tasks._notify(tid)
|
||||
if not answers and not messages:
|
||||
return result
|
||||
data = result.get("structuredContent")
|
||||
data = dict(data) if isinstance(data, dict) else {}
|
||||
if messages:
|
||||
data["user_messages"] = messages
|
||||
if answers:
|
||||
data["user_answers"] = answers
|
||||
if waiting:
|
||||
data["still_waiting"] = waiting
|
||||
data["user_notice"] = (
|
||||
"The user sent new input in the AI workbench. Read user_messages / user_answers and follow them; you may "
|
||||
"reply in your chat or in Anomalous (report(reply_to=<its id>)), but once you and the user settle what to do, "
|
||||
"record it with log_decision so the decision stays in Anomalous; "
|
||||
"kind=change messages are changes the user made themselves while you worked: keep them, do not undo them; "
|
||||
"kind=marks messages are places the user marked on a picture to change (the marked picture is attached): "
|
||||
"say what you see and how you would fix it (show_panel can show the picture with your own marks), "
|
||||
"ask_user which fix to do, and log_decision the fix chosen (related: the marks' id); "
|
||||
"kind=toolbox messages are the nodes, combos, workflows, prompts and models the user picked for you to use; "
|
||||
"kind=stop: the user stopped your run, so do not run it again until they say what to change; "
|
||||
"kind=pictures: pictures the user handed you (attached), with made_with read from each picture's own workflow."
|
||||
)
|
||||
pictures = ai_marks.image_items(messages)
|
||||
result["structuredContent"] = data
|
||||
content = list(result.get("content") or [])
|
||||
if content and isinstance(content[0], dict) and content[0].get("type") == "text":
|
||||
content[0] = {"type": "text", "text": tool_text(data)}
|
||||
else:
|
||||
content.insert(0, {"type": "text", "text": tool_text(data)})
|
||||
result["content"] = content + pictures
|
||||
return result
|
||||
@@ -0,0 +1,158 @@
|
||||
"""Pictures the user hands the AI working on a task (the gallery card's menu, the image inspector's
|
||||
✦): a user step with the pictures (shown on the timeline like the AI's own), which the AI gets as
|
||||
a message (kind "pictures", ai_panels._collect) with each picture attached as a 512 px copy and
|
||||
what made it in a few words (brief(): models, LoRAs, prompts, size, sampler; read from the
|
||||
picture's own workflow by ai_run_map.py), so nothing needs describing. Pictures handed one after
|
||||
another before the AI looked join one step. mark_gone() tells the page which of a task's
|
||||
pictures were deleted since. save_upload() keeps a picture the user dropped or pasted into a
|
||||
message in the output folder's ai_inbox, so the gallery has it and the message carries it like
|
||||
any other: read as a picture first, size-capped, never over a file.
|
||||
"""
|
||||
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from PIL import Image
|
||||
|
||||
from . import ai_run_map, ai_tasks
|
||||
from .image_search import read_png_text
|
||||
from .mcp_tools import ToolError, _resolve_image
|
||||
|
||||
MAX_PICTURES = 8
|
||||
INBOX = "ai_inbox" # under the output folder
|
||||
MAX_UPLOAD = 25 * 1024 * 1024
|
||||
UPLOAD_TYPES = {"PNG": ".png", "JPEG": ".jpg", "WEBP": ".webp", "GIF": ".gif"}
|
||||
|
||||
|
||||
class PicturesError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def brief(path):
|
||||
"""What made the picture at `path`, from its own workflow: {models, loras, positive, negative, size, sampler} or {}."""
|
||||
try:
|
||||
prompt = json.loads((read_png_text(path) if path.lower().endswith(".png") else {}).get("prompt") or "null")
|
||||
shape = ai_run_map.map_of(prompt) if isinstance(prompt, dict) else None
|
||||
except (OSError, ValueError):
|
||||
shape = None
|
||||
if not shape:
|
||||
return {}
|
||||
out = {}
|
||||
for box in shape["boxes"]:
|
||||
facts = box["facts"]
|
||||
if box["role"] == "model" and facts.get("file"):
|
||||
out.setdefault("models", []).append(facts["file"])
|
||||
elif box["role"] == "lora" and facts.get("file"):
|
||||
out.setdefault("loras", []).append(f"{facts['file']} ({facts.get('strength', '?')})")
|
||||
elif box["role"] == "prompt" and facts.get("text"):
|
||||
out.setdefault("negative" if facts.get("polarity") == "negative" else "positive", facts["text"])
|
||||
elif box["role"] == "sampler":
|
||||
out["sampler"] = {key: facts[key] for key in ("steps", "cfg", "sampler_name", "scheduler", "denoise") if key in facts}
|
||||
if facts.get("width") and "size" not in out:
|
||||
out["size"] = f"{facts['width']}x{facts['height']}"
|
||||
return out
|
||||
|
||||
|
||||
def mark_gone(task):
|
||||
"""Marks each output picture `task` shows (results, panels, marks) that is no longer in the output
|
||||
folder, deleted or moved: "gone": true, so the page says so instead of a broken picture."""
|
||||
root = ai_tasks.folder_paths.get_output_directory()
|
||||
|
||||
def walk(value):
|
||||
if isinstance(value, dict):
|
||||
if value.get("folder") == "output" and value.get("filename") and \
|
||||
not os.path.isfile(os.path.join(root, value.get("subfolder") or "", value["filename"])):
|
||||
value["gone"] = True
|
||||
for item in value.values():
|
||||
walk(item)
|
||||
elif isinstance(value, list):
|
||||
for item in value:
|
||||
walk(item)
|
||||
|
||||
walk((task or {}).get("steps"))
|
||||
return task
|
||||
|
||||
|
||||
def save_upload(data, name="", now=None):
|
||||
"""Keeps picture bytes `data` (the file's own name `name`, for its stem) in output/ai_inbox.
|
||||
Returns its "ai_inbox/name.ext"."""
|
||||
if not data or len(data) > MAX_UPLOAD:
|
||||
raise PicturesError(f"A picture up to {MAX_UPLOAD // (1024 * 1024)} MB")
|
||||
try:
|
||||
with Image.open(io.BytesIO(data)) as image:
|
||||
kind = image.format
|
||||
image.verify()
|
||||
except (OSError, ValueError, SyntaxError, Image.DecompressionBombError):
|
||||
raise PicturesError("Not a picture Anomalous can read (PNG, JPEG, WebP or GIF)")
|
||||
if kind not in UPLOAD_TYPES:
|
||||
raise PicturesError("Not a picture Anomalous can read (PNG, JPEG, WebP or GIF)")
|
||||
stem = re.sub(r"[^\w\- ]+", "", os.path.splitext(os.path.basename(str(name or "")))[0]).strip()[:60] or "pasted"
|
||||
folder = os.path.join(ai_tasks.folder_paths.get_output_directory(), INBOX)
|
||||
os.makedirs(folder, exist_ok=True)
|
||||
stamp = time.strftime("%Y%m%d-%H%M%S", time.localtime(time.time() if now is None else now))
|
||||
for count in range(1, 100):
|
||||
filename = f"{stem}_{stamp}{'' if count == 1 else f' ({count})'}{UPLOAD_TYPES[kind]}"
|
||||
try:
|
||||
with open(os.path.join(folder, filename), "xb") as out: # never over a file
|
||||
out.write(data)
|
||||
except FileExistsError:
|
||||
continue
|
||||
return f"{INBOX}/{filename}"
|
||||
raise PicturesError("No free name for the picture")
|
||||
|
||||
|
||||
def hand(task_id, images, text="", now=None):
|
||||
"""Hands output pictures `images` ("subfolder/name.png") to task `task_id`'s AI. Returns the step."""
|
||||
if not isinstance(images, list) or not 1 <= len(images) <= MAX_PICTURES:
|
||||
raise PicturesError(f"Hand 1 to {MAX_PICTURES} pictures")
|
||||
pictures = []
|
||||
for image in images:
|
||||
try:
|
||||
rel = _resolve_image(image)[0]
|
||||
except ToolError as error:
|
||||
raise PicturesError(str(error))
|
||||
subfolder, _, filename = rel.rpartition("/")
|
||||
picture = {"type": "image", "folder": "output", "filename": filename, "subfolder": subfolder}
|
||||
if picture not in pictures:
|
||||
pictures.append(picture)
|
||||
now = time.time() if now is None else now
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
if not task or task.get("ended"):
|
||||
raise PicturesError("No such open task")
|
||||
last = task["steps"][-1] if task["steps"] else None
|
||||
if last and last.get("tool") == "user_pictures" and not last.get("delivered") and not text:
|
||||
step = last # the AI has not looked yet: one step with all of them
|
||||
step["results"] = (step["results"] + [item for item in pictures if item not in step["results"]])[:MAX_PICTURES]
|
||||
step["at"] = now
|
||||
else:
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "user_pictures", "kind": "user", "ok": True,
|
||||
"state": "done", "summary": "user_pictures", "delivered": False, "results": pictures,
|
||||
"text": ai_tasks._short(str(text or "").strip(), 1000)}
|
||||
task["steps"].append(step)
|
||||
del task["steps"][:-ai_tasks.MAX_STEPS]
|
||||
task["updated"] = max(task.get("updated", 0), now)
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
return step
|
||||
|
||||
|
||||
def message_of(step):
|
||||
"""The AI's message for a pictures step: the pictures' paths and what made each; their files go
|
||||
in "_pictures" for ai_marks.image_items to attach."""
|
||||
paths, briefs, files = [], [], []
|
||||
for item in step.get("results") or []:
|
||||
rel = "/".join(part for part in (item.get("subfolder"), item["filename"]) if part)
|
||||
try:
|
||||
path = _resolve_image(rel)[1]
|
||||
except ToolError:
|
||||
continue # deleted since: the rest still go
|
||||
paths.append(rel)
|
||||
briefs.append({"image": rel, **brief(path)})
|
||||
files.append(path)
|
||||
words = step.get("text") or "The user handed you these pictures in Anomalous."
|
||||
return {"kind": "pictures", "text": words, "images": paths, "made_with": briefs, "_pictures": files}
|
||||
@@ -0,0 +1,184 @@
|
||||
"""Where to repaint a picture the user marked, as the AI proposes it and the user agrees on the AI
|
||||
workbench (the propose_repaint_area tool, mcp_task_tools.py).
|
||||
|
||||
The user's marks (ai_marks.py) are rough, and the AI sees the marked picture: it may move, reshape,
|
||||
grow and soften the area: `areas` (boxes or ellipses as fractions of the picture, x/y the top left
|
||||
as in the marks), `grow` (pixels added around each) and `feather` (pixels of soft edge). Anomalous
|
||||
draws the user's area and the AI's over the picture into the task's marks folder and puts both side
|
||||
by side on a panel (block "area") with three answers: the AI's, the user's own, or marking it
|
||||
again; a line of their own says what to change. When the user picks an area, the picture goes
|
||||
into ComfyUI's input folder with that area as its alpha (ai_marks.write_inpaint), so LoadImage
|
||||
gives the picture and the area as its MASK; the answer the AI reads carries the file's name and a
|
||||
short note of the usual repaint nodes. How to build the repaint on the canvas stays the AI's.
|
||||
"""
|
||||
|
||||
import os
|
||||
import uuid
|
||||
|
||||
import folder_paths
|
||||
|
||||
from . import ai_marks, ai_panels, ai_tasks
|
||||
|
||||
SHAPES = ("box", "ellipse")
|
||||
MAX_AREAS = 8
|
||||
MAX_GROW = 256
|
||||
MAX_FEATHER = 128
|
||||
PREVIEW_EDGE = 1024
|
||||
TINT = (255, 64, 64)
|
||||
CHOICES = ( # id, label for the AI, the page's words
|
||||
("ai", "Use the AI's area", "aiRepaintUseAi"),
|
||||
("mine", "Use the user's own marks", "aiRepaintUseMine"),
|
||||
("again", "Mark it again", "aiRepaintAgain"),
|
||||
)
|
||||
AGAIN_NOTE = "The user marks the picture again: wait for their new marks with get_answers, then propose again."
|
||||
WORDS_NOTE = "The user said what to change about the area: propose_repaint_area again with it."
|
||||
|
||||
|
||||
class RepaintError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def _number(value, low, high, what):
|
||||
if isinstance(value, bool) or not isinstance(value, (int, float)) or not low <= value <= high:
|
||||
raise RepaintError(f"{what} is a number from {low} to {high}")
|
||||
return value
|
||||
|
||||
|
||||
def _areas(areas):
|
||||
if not isinstance(areas, list) or not 0 < len(areas) <= MAX_AREAS:
|
||||
raise RepaintError(f"areas lists 1 to {MAX_AREAS} areas")
|
||||
out = []
|
||||
for at, area in enumerate(areas):
|
||||
where = f"areas[{at}]"
|
||||
if not isinstance(area, dict) or area.get("shape", "box") not in SHAPES:
|
||||
raise RepaintError(f"{where} is {{shape: box | ellipse, x, y, w, h}}")
|
||||
x, y = (_number(area.get(key), 0, 1, f"{where}.{key}") for key in ("x", "y"))
|
||||
w, h = (_number(area.get(key), 0.005, 1, f"{where}.{key}") for key in ("w", "h"))
|
||||
out.append({"shape": area.get("shape", "box"), "x": round(x, 4), "y": round(y, 4),
|
||||
"w": round(min(w, 1 - x), 4), "h": round(min(h, 1 - y), 4)})
|
||||
return out
|
||||
|
||||
|
||||
def _from_marks(marks):
|
||||
"""The user's marks as areas: a circle an ellipse in its box, a line or an arrow the box around it."""
|
||||
return [{"shape": "ellipse" if mark["shape"] == "circle" else "box", **{key: mark[key] for key in ("x", "y", "w", "h")}}
|
||||
for mark in marks if mark["w"] > 0 and mark["h"] > 0]
|
||||
|
||||
|
||||
def area_image(size, areas, grow=0, feather=0):
|
||||
"""An "L" image of `size`, white over `areas` grown by `grow` pixels, `feather` pixels soft at the edge."""
|
||||
from PIL import Image, ImageDraw, ImageFilter
|
||||
|
||||
width, height = size
|
||||
area = Image.new("L", size, 0)
|
||||
draw = ImageDraw.Draw(area)
|
||||
for shape in areas:
|
||||
box = [shape["x"] * width - grow, shape["y"] * height - grow,
|
||||
(shape["x"] + shape["w"]) * width + grow, (shape["y"] + shape["h"]) * height + grow]
|
||||
(draw.ellipse if shape["shape"] == "ellipse" else draw.rectangle)(box, fill=255)
|
||||
return area.filter(ImageFilter.GaussianBlur(feather / 2)) if feather else area
|
||||
|
||||
|
||||
def _user_area(marks_step):
|
||||
"""How to make the user's own area: what they painted when they asked for only the marked areas, else their marks."""
|
||||
painted = marks_step.get("inpaint")
|
||||
if painted:
|
||||
def from_painted(size):
|
||||
from PIL import Image, ImageOps
|
||||
|
||||
with Image.open(os.path.join(folder_paths.get_input_directory(), painted)) as kept:
|
||||
return ImageOps.invert(kept.getchannel("A")).resize(size)
|
||||
return from_painted
|
||||
areas = _from_marks(marks_step.get("marks") or [])
|
||||
if not areas:
|
||||
raise RepaintError("These marks hold no area to repaint")
|
||||
return lambda size: area_image(size, areas)
|
||||
|
||||
|
||||
def _preview(task_id, picture, area_of):
|
||||
"""The picture, made small, with the area tinted, kept in the task's marks folder: its name."""
|
||||
from PIL import Image
|
||||
|
||||
try:
|
||||
with Image.open(ai_marks.picture_path(picture)) as original:
|
||||
base = original.convert("RGB")
|
||||
except OSError:
|
||||
raise RepaintError("The marked picture cannot be read")
|
||||
base.thumbnail((PREVIEW_EDGE, PREVIEW_EDGE))
|
||||
area = area_of(base.size).point(lambda value: value * 55 // 100)
|
||||
shown = Image.composite(Image.new("RGB", base.size, TINT), base, area)
|
||||
name = f"{uuid.uuid4().hex[:10]}.png"
|
||||
os.makedirs(ai_tasks.marks_dir(task_id), exist_ok=True)
|
||||
with open(os.path.join(ai_tasks.marks_dir(task_id), name), "xb") as target:
|
||||
shown.save(target, "PNG")
|
||||
return name
|
||||
|
||||
|
||||
def propose(client, title, marks_id, areas=None, grow=12, feather=8, note="", session=""):
|
||||
"""Shows the user their area and the AI's for marks `marks_id`; returns the panel to wait on."""
|
||||
with ai_tasks._lock:
|
||||
found = next(((task, step) for task in ai_tasks._load().values() for step in task.get("steps") or []
|
||||
if step.get("id") == marks_id and step.get("tool") == "user_marks"), None)
|
||||
if not found:
|
||||
raise RepaintError("marks is the id of the user's marks (user_messages[].id, kind marks)")
|
||||
task, marks_step = found
|
||||
grow = int(_number(grow, 0, MAX_GROW, "grow"))
|
||||
feather = int(_number(feather, 0, MAX_FEATHER, "feather"))
|
||||
shapes = _areas(areas) if areas else _from_marks(marks_step.get("marks") or [])
|
||||
if not shapes:
|
||||
raise RepaintError("These marks hold no area: give areas")
|
||||
picture = marks_step["image"]
|
||||
with_edges = {"grow": grow, "feather": feather}
|
||||
try:
|
||||
from PIL import Image
|
||||
|
||||
with Image.open(ai_marks.picture_path(picture)) as original:
|
||||
scale = min(1, PREVIEW_EDGE / max(original.size)) # grow and feather are pixels of the whole picture
|
||||
except OSError:
|
||||
raise RepaintError("The marked picture cannot be read")
|
||||
yours = _preview(task["id"], picture, _user_area(marks_step))
|
||||
ai = _preview(task["id"], picture, lambda size: area_image(size, shapes, grow * scale, feather * scale))
|
||||
blocks = [{"type": "area", "yours": yours, "ai": ai, **with_edges}]
|
||||
if note:
|
||||
blocks.append({"type": "text", "text": note})
|
||||
blocks.append({"type": "choices", "id": "answer", "other": True,
|
||||
"options": [{"id": key, "label": label, "label_key": words, **({"recommended": True} if key == "ai" else {})}
|
||||
for key, label, words in CHOICES]})
|
||||
try:
|
||||
return ai_panels.show(client, title, blocks, session=session, task_id=task["id"], tool="propose_repaint_area",
|
||||
extra={"repaint": {"marks": marks_id, "areas": shapes, **with_edges}})
|
||||
except ai_panels.PanelError as error:
|
||||
raise RepaintError(str(error))
|
||||
|
||||
|
||||
def prepare(task_id, step_id, choice, text, skip=False):
|
||||
"""What the user's answer to a repaint panel brings the AI, made before it is recorded: the repaint
|
||||
picture for an area picked (inpaint_image and its note; "your call" takes the AI's), else what to
|
||||
do now; {} for other panels."""
|
||||
step = next((item for item in (ai_tasks.get_task(task_id) or {}).get("steps") or [] if item.get("id") == step_id), None)
|
||||
asked = (step or {}).get("repaint")
|
||||
if not asked:
|
||||
return {}
|
||||
picked = "ai" if skip else (choice[0] if isinstance(choice, list) and choice else choice)
|
||||
if picked not in ("ai", "mine"):
|
||||
return {"note": WORDS_NOTE if str(text or "").strip() and not picked else AGAIN_NOTE}
|
||||
marks_step = next((item for task in ai_tasks._load().values() for item in task.get("steps") or []
|
||||
if item.get("id") == asked["marks"]), None)
|
||||
if not marks_step:
|
||||
raise RepaintError("The marks are gone")
|
||||
area_of = (_user_area(marks_step) if picked == "mine"
|
||||
else lambda size: area_image(size, asked["areas"], asked["grow"], asked["feather"]))
|
||||
try:
|
||||
name = ai_marks.write_inpaint(marks_step["image"], area_of, uuid.uuid4().hex[:10])
|
||||
except ai_marks.MarksError as error:
|
||||
raise RepaintError(str(error))
|
||||
return {"inpaint_image": name, "note": ai_panels.INPAINT_NOTE}
|
||||
|
||||
|
||||
def discard(prepared):
|
||||
"""The repaint picture `prepare` made, when the answer was refused after all (the plugin's own file)."""
|
||||
if prepared.get("inpaint_image"):
|
||||
try:
|
||||
os.remove(os.path.join(folder_paths.get_input_directory(), prepared["inpaint_image"]))
|
||||
except OSError:
|
||||
pass
|
||||
@@ -0,0 +1,55 @@
|
||||
"""Stopping a run an AI started (the workbench's stop button, the AI's stop_run): its prompts still
|
||||
waiting leave ComfyUI's queue and the one running is interrupted, only while it is still that one
|
||||
(ComfyUI's own cancel; never anyone else's prompt). The run's watcher (ai_task_runs.py) then ends
|
||||
the step as "cancelled" with who stopped it; when the user did, the AI is told with its next answer."""
|
||||
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from . import ai_task_runs, ai_tasks
|
||||
|
||||
|
||||
class RunControlError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def _interrupt(queue, prompt_id):
|
||||
"""Interrupts `prompt_id` if it is the prompt running now; True when it was."""
|
||||
if hasattr(queue, "interrupt_if_running"):
|
||||
return bool(queue.interrupt_if_running(prompt_id))
|
||||
running, _ = queue.get_current_queue() # an older ComfyUI: check, then the global interrupt
|
||||
if not any(item[1] == prompt_id for item in running):
|
||||
return False
|
||||
import nodes
|
||||
nodes.interrupt_processing()
|
||||
return True
|
||||
|
||||
|
||||
def stop(step_id, by="user", task_id=None, now=None):
|
||||
"""Stops run step `step_id` (in task `task_id` when given). Returns {"task", "removed", "interrupted"}."""
|
||||
now = time.time() if now is None else now
|
||||
with ai_tasks._lock:
|
||||
tasks = ai_tasks._load()
|
||||
task = next((item for item in tasks.values() if (not task_id or item["id"] == task_id)
|
||||
and any(step["id"] == step_id for step in item.get("steps") or [])), None)
|
||||
step = next((item for item in (task or {}).get("steps", []) if item["id"] == step_id), None)
|
||||
if not step or step.get("tool") != "run_workflow":
|
||||
raise RunControlError("No such run in this task")
|
||||
if step.get("state") != "running" or not step.get("prompt_ids"):
|
||||
raise RunControlError("This run is not going any more")
|
||||
prompts = list(step["prompt_ids"])
|
||||
step["stop"] = by
|
||||
if by == "user":
|
||||
task["steps"].append({
|
||||
"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "user_stop", "kind": "user", "ok": True,
|
||||
"state": "done", "summary": "user_stop", "stopped": step_id, "delivered": False, "results": [],
|
||||
"text": "The user stopped your run in Anomalous. Do not start it again unless they ask; ask_user what to change.",
|
||||
})
|
||||
del task["steps"][:-ai_tasks.MAX_STEPS]
|
||||
task["updated"] = max(task.get("updated", 0), now)
|
||||
ai_tasks._save(task)
|
||||
queue = ai_task_runs._queue()
|
||||
removed = sum(1 for prompt_id in prompts if queue.delete_queue_item(lambda item, pid=prompt_id: item[1] == pid))
|
||||
interrupted = sum(1 for prompt_id in prompts if _interrupt(queue, prompt_id))
|
||||
ai_tasks._notify(task["id"])
|
||||
return {"task": task["id"], "removed": removed, "interrupted": interrupted}
|
||||
@@ -0,0 +1,180 @@
|
||||
"""The shape of a workflow run in a few boxes, so the user sees what the AI really ran: read from
|
||||
the prompt ComfyUI queued (ai_task_runs.py keeps it on the run's step as "map"), never from
|
||||
what the AI says. Plumbing (reroutes, primitives, notes) is left out and wired through; each
|
||||
box has a role (model, lora, prompt, size, sampler, image, upscale, decode, save, other) and a
|
||||
few facts the page words in the user's language (ui_ai_run_map.js); the links carry ComfyUI's
|
||||
types. changes() says what differs from the run before it: a setting, a node added or gone.
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
from .model_constants import MODEL_EXTENSIONS
|
||||
|
||||
MAX_BOXES = 24 # what a stage diagram holds (ai_panels.MAX_NODES)
|
||||
MAX_EDGES = 40
|
||||
MAX_CHANGES = 10
|
||||
HIDDEN = {"Reroute", "Note", "MarkdownNote", "PrimitiveNode", "PrimitiveInt", "PrimitiveFloat", "PrimitiveString",
|
||||
"PrimitiveStringMultiline", "PrimitiveBoolean"}
|
||||
SEEDS = {"seed", "noise_seed"}
|
||||
SAMPLER_FACTS = ("steps", "cfg", "sampler_name", "scheduler", "denoise")
|
||||
TEXT_CHARS = 80
|
||||
VALUE_CHARS = 60
|
||||
|
||||
|
||||
def _linked(value):
|
||||
return isinstance(value, list) and len(value) == 2 and isinstance(value[0], (str, int))
|
||||
|
||||
|
||||
def _literal(value):
|
||||
return isinstance(value, (str, int, float, bool)) and not isinstance(value, list)
|
||||
|
||||
|
||||
def _file_name(value):
|
||||
return os.path.splitext(os.path.basename(str(value).replace("\\", "/")))[0]
|
||||
|
||||
|
||||
def _output_type(class_type, index):
|
||||
"""ComfyUI's type of output `index` of `class_type` ("MODEL", "LATENT"...), or ""."""
|
||||
try:
|
||||
import nodes
|
||||
types = getattr(nodes.NODE_CLASS_MAPPINGS.get(class_type), "RETURN_TYPES", None) or ()
|
||||
return str(types[int(index)]) if int(index) < len(types) else ""
|
||||
except Exception: # noqa: BLE001 - no ComfyUI (tests) or an odd node: the link stays unnamed
|
||||
return ""
|
||||
|
||||
|
||||
def _role(class_type, inputs):
|
||||
name = class_type.lower()
|
||||
if "lora_name" in inputs:
|
||||
return "lora"
|
||||
if _linked(inputs.get("latent_image")) or "sampler" in name and not name.endswith("select"):
|
||||
return "sampler"
|
||||
if name == "loadimage" or name.startswith("loadimage"):
|
||||
return "image"
|
||||
if "upscale" in name:
|
||||
return "upscale"
|
||||
if "loader" in name:
|
||||
return "model"
|
||||
if isinstance(inputs.get("text"), str) or "textencode" in name:
|
||||
return "prompt"
|
||||
if name.startswith("empty") and "latent" in name:
|
||||
return "size"
|
||||
if name.startswith("vaedecode"):
|
||||
return "decode"
|
||||
if name.startswith(("save", "preview")):
|
||||
return "save"
|
||||
return "other"
|
||||
|
||||
|
||||
def _facts(role, inputs):
|
||||
literal = {key: value for key, value in inputs.items() if _literal(value)}
|
||||
facts = {}
|
||||
model = next((value for value in literal.values() if isinstance(value, str) and value.lower().endswith(MODEL_EXTENSIONS)), None)
|
||||
if model:
|
||||
facts["file"] = _file_name(model)[:VALUE_CHARS]
|
||||
if role == "lora":
|
||||
for key in ("strength_model", "strength"):
|
||||
if isinstance(literal.get(key), (int, float)):
|
||||
facts["strength"] = round(float(literal[key]), 3)
|
||||
break
|
||||
elif role == "prompt":
|
||||
text = next((value for key, value in literal.items() if isinstance(value, str) and key.startswith("text")), "")
|
||||
facts["text"] = " ".join(text.split())[:TEXT_CHARS]
|
||||
elif role == "sampler":
|
||||
facts.update({key: literal[key] for key in SAMPLER_FACTS if key in literal})
|
||||
elif role == "image":
|
||||
facts["file"] = str(literal.get("image") or "")[:VALUE_CHARS]
|
||||
elif role == "save":
|
||||
facts["prefix"] = str(literal.get("filename_prefix") or "")[:VALUE_CHARS]
|
||||
if all(isinstance(literal.get(key), (int, float)) and literal[key] > 0 for key in ("width", "height")):
|
||||
facts.update(width=int(literal["width"]), height=int(literal["height"]))
|
||||
if isinstance(literal.get("batch_size"), int) and literal["batch_size"] > 1:
|
||||
facts["batch"] = literal["batch_size"]
|
||||
if role == "other" and not facts:
|
||||
facts["values"] = [[key, str(value)[:VALUE_CHARS]] for key, value in literal.items()
|
||||
if key not in SEEDS and str(value).strip()][:2]
|
||||
return facts
|
||||
|
||||
|
||||
def map_of(prompt):
|
||||
"""{"boxes": [{id, type, title, role, facts}], "links": [{from, to, type}], "params": {...}} of API prompt `prompt`."""
|
||||
nodes = {str(key): node for key, node in (prompt or {}).items() if isinstance(node, dict) and node.get("class_type")}
|
||||
shown = [key for key in nodes if nodes[key]["class_type"] not in HIDDEN]
|
||||
if len(shown) > MAX_BOXES: # keep what makes the picture; drop the helpers first
|
||||
rank = {"other": 2, "save": 1}
|
||||
shown = sorted(shown, key=lambda key: rank.get(_role(nodes[key]["class_type"], nodes[key].get("inputs") or {}), 0))[:MAX_BOXES]
|
||||
keep = set(shown)
|
||||
|
||||
def source(link, seen=()):
|
||||
"""The shown node (and the output's type) a link comes from, wired through hidden nodes."""
|
||||
key, index = str(link[0]), link[1]
|
||||
if key in keep:
|
||||
return key, _output_type(nodes[key]["class_type"], index)
|
||||
node = nodes.get(key)
|
||||
if not node or key in seen:
|
||||
return None, ""
|
||||
upstream = next((value for value in (node.get("inputs") or {}).values() if _linked(value)), None)
|
||||
return source(upstream, (*seen, key)) if upstream else (None, "")
|
||||
|
||||
boxes, links, params = [], [], {}
|
||||
for key in sorted(shown, key=lambda item: (len(item), item)):
|
||||
node = nodes[key]
|
||||
inputs = node.get("inputs") or {}
|
||||
role = _role(node["class_type"], inputs)
|
||||
boxes.append({"id": key, "type": node["class_type"][:80], "role": role, "facts": _facts(role, inputs),
|
||||
"title": str((node.get("_meta") or {}).get("title") or node["class_type"])[:80]})
|
||||
for name, value in inputs.items():
|
||||
if _linked(value):
|
||||
found, kind = source(value)
|
||||
if found and found != key and len(links) < MAX_EDGES:
|
||||
links.append({"from": found, "to": key, "type": kind or name.upper(), "input": name})
|
||||
elif _literal(value) and name not in SEEDS:
|
||||
params[f"{key}.{name}"] = str(value)[:300]
|
||||
_polarity(boxes, links)
|
||||
return {"boxes": boxes, "links": links, "params": params}
|
||||
|
||||
|
||||
def _polarity(boxes, links):
|
||||
"""Marks prompt boxes positive or negative by the sampler input they reach."""
|
||||
by_id = {box["id"]: box for box in boxes}
|
||||
feeds = {}
|
||||
for link in links:
|
||||
feeds.setdefault(link["from"], []).append(link)
|
||||
for box in boxes:
|
||||
if box["role"] != "prompt":
|
||||
continue
|
||||
todo, seen = [box["id"]], set()
|
||||
while todo and "polarity" not in box["facts"]:
|
||||
here = todo.pop()
|
||||
seen.add(here)
|
||||
for link in feeds.get(here, []):
|
||||
if link["input"] in ("positive", "negative") and by_id[link["to"]]["role"] == "sampler":
|
||||
box["facts"]["polarity"] = link["input"]
|
||||
break
|
||||
if link["to"] not in seen:
|
||||
todo.append(link["to"])
|
||||
|
||||
|
||||
def changes(before, after):
|
||||
"""What differs in map `after` from map `before`: [{node, title, key, from, to}] or a node added / gone."""
|
||||
if not before or not after:
|
||||
return []
|
||||
titles = {box["id"]: box["title"] for box in before.get("boxes", [])}
|
||||
titles.update({box["id"]: box["title"] for box in after.get("boxes", [])})
|
||||
old_ids = {box["id"]: box["type"] for box in before.get("boxes", [])}
|
||||
new_ids = {box["id"]: box["type"] for box in after.get("boxes", [])}
|
||||
out = []
|
||||
for key, kind in new_ids.items():
|
||||
if old_ids.get(key) != kind:
|
||||
out.append({"node": key, "title": titles[key], "change": "added"})
|
||||
for key, kind in old_ids.items():
|
||||
if new_ids.get(key) != kind:
|
||||
out.append({"node": key, "title": titles[key], "change": "removed"})
|
||||
gone = {item["node"] for item in out}
|
||||
old, new = before.get("params", {}), after.get("params", {})
|
||||
for name in sorted(set(old) | set(new), key=lambda item: (len(item.split(".")[0]), item)):
|
||||
node, key = name.split(".", 1)
|
||||
if node not in gone and old.get(name) != new.get(name):
|
||||
out.append({"node": node, "title": titles.get(node, node), "key": key,
|
||||
"from": (old.get(name) or "")[:VALUE_CHARS], "to": (new.get(name) or "")[:VALUE_CHARS]})
|
||||
return out[:MAX_CHANGES]
|
||||
@@ -0,0 +1,72 @@
|
||||
"""Attach explicitly identified external ComfyUI submissions to an AI task; never guess ownership."""
|
||||
import json
|
||||
import math
|
||||
import time
|
||||
|
||||
from . import ai_task_runs, ai_tasks
|
||||
from .mcp_tools import ToolError
|
||||
|
||||
|
||||
def checked_wait(value):
|
||||
"""wait_seconds as seconds from 0 to 55: one call waits no longer, so a longer wait is cut to that."""
|
||||
if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
|
||||
raise ToolError("wait_seconds is a number of seconds, up to 55.")
|
||||
return min(max(value, 0), 55)
|
||||
|
||||
|
||||
def track_run(ctx, prompt_ids, task=None, wait_seconds=15):
|
||||
wait_seconds = checked_wait(wait_seconds)
|
||||
if (not isinstance(prompt_ids, list) or not 1 <= len(prompt_ids) <= 8
|
||||
or any(not isinstance(pid, str) or not pid or len(pid) > 128 for pid in prompt_ids)
|
||||
or len(set(prompt_ids)) != len(prompt_ids)):
|
||||
raise ToolError("Give 1–8 unique prompt_ids returned by your own ComfyUI /prompt submissions.")
|
||||
client, session = ctx.get("client") or "AI", ctx.get("session") or ""
|
||||
task_id = task or ctx.get("task") or ai_tasks.active_task_id(client, session)
|
||||
with ai_tasks._lock:
|
||||
target = ai_tasks._load().get(task_id)
|
||||
if not target or target.get("ended"):
|
||||
raise ToolError("Begin or resume an open task before attaching a run; pass its task ID.")
|
||||
existing = None
|
||||
for candidate in ai_tasks._load().values():
|
||||
for step in candidate.get("steps", []):
|
||||
ids = step.get("prompt_ids") or []
|
||||
if set(ids).intersection(prompt_ids):
|
||||
if candidate["id"] != task_id or ids != prompt_ids:
|
||||
raise ToolError("A prompt ID is already attached to another run. Do not reassign it.")
|
||||
existing = step
|
||||
if existing is None:
|
||||
try:
|
||||
queue = ai_task_runs._queue()
|
||||
running, pending = queue.get_current_queue()
|
||||
known = {item[1] for item in [*running, *pending]}
|
||||
missing = [pid for pid in prompt_ids if pid not in known and not queue.get_history(prompt_id=pid).get(pid)]
|
||||
except Exception as error:
|
||||
raise ToolError("Cannot read ComfyUI's queue/history; nothing was attached.") from error
|
||||
if missing:
|
||||
raise ToolError("Unknown prompt IDs: " + ", ".join(missing) + ". Use this server's submission receipts.")
|
||||
receipt = {"prompt_ids": prompt_ids, "queued": len(prompt_ids)}
|
||||
result = {"structuredContent": receipt, "content": []}
|
||||
step = ai_tasks.record(client, "run_workflow", {}, result, time.time(), session=session, task_id=task_id)
|
||||
if not step:
|
||||
raise ToolError("Could not record the run; nothing was queued by this tool.")
|
||||
step.update(prompt_ids=list(prompt_ids), source="external")
|
||||
ai_tasks._save(target)
|
||||
ai_task_runs.watch(step["id"], receipt)
|
||||
existing = step
|
||||
answer = ai_task_runs.status(client, session, task_id, wait_seconds, step_id=existing["id"])
|
||||
return {"task": task_id, "attached": True, **answer}
|
||||
|
||||
|
||||
def wait_for_receipt(result, client, session, task_id, wait_seconds=15, step_id=None):
|
||||
"""Return authoritative execution state alongside submission receipts, with a bounded wait."""
|
||||
answer = ai_task_runs.status(client, session, task_id, wait_seconds, step_id=step_id)
|
||||
data = {**result.get("structuredContent", {}), **answer, "task": task_id}
|
||||
result["structuredContent"] = data
|
||||
content = list(result.get("content") or [])
|
||||
text = {"type": "text", "text": json.dumps(data, ensure_ascii=False)}
|
||||
if content and content[0].get("type") == "text":
|
||||
content[0] = text
|
||||
else:
|
||||
content.insert(0, text)
|
||||
result["content"] = content
|
||||
return result
|
||||
@@ -0,0 +1,221 @@
|
||||
"""What a run an AI started shows beyond the node and its steps (ai_task_runs.py adds it to the
|
||||
run's progress, for the AI and the workbench): ComfyUI's console since the run began (the
|
||||
progress bar of the node running with its own note, "Model Initializing", the models it loads:
|
||||
what the user sees in the console window), the time per step and the time left, the graphics
|
||||
card's memory, and once per run estimate(): the size each sampler works at, read from the queued
|
||||
prompt (never changed), with warnings for a run that will be very slow or will not fit, such as a
|
||||
picture upscaled by a model and then sampled again at full size."""
|
||||
|
||||
import math
|
||||
import re
|
||||
import time
|
||||
from datetime import datetime
|
||||
|
||||
ANSI = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")
|
||||
# tqdm's bar: " 12%|## | 6/50 [00:03<00:22, 1.95it/s, a note]"
|
||||
BAR = re.compile(r"(\d+)/(\d+)\s*\[([^<\]]*)<([^,\]]*),\s*([^,\]]*)(?:,\s*([^\]]*))?\]")
|
||||
CONSOLE_LINES = 5
|
||||
LINE_CHARS = 200
|
||||
# Megapixels a sampler can work at comfortably on a 12 GB card; scaled by the card's memory.
|
||||
COMFORT_MP_12GB = 4.2
|
||||
LATENT_INPUTS = ("latent_image", "samples", "latent", "pixels", "image", "images")
|
||||
NOT_PICTURES = {"model", "clip", "vae", "upscale_model", "positive", "negative", "conditioning", "control_net",
|
||||
"mask", "sampler", "sigmas", "guider", "noise", "clip_vision", "style_model"}
|
||||
|
||||
|
||||
def _logs():
|
||||
try:
|
||||
from app import logger
|
||||
except ImportError:
|
||||
return []
|
||||
return list(logger.get_logs() or [])
|
||||
|
||||
|
||||
def console_since(started, entries=None, limit=CONSOLE_LINES):
|
||||
"""The console's last `limit` lines written since `started` (a time.time()), as shown: colours
|
||||
gone, a progress bar redrawn in place kept at its latest."""
|
||||
written = []
|
||||
for entry in _logs() if entries is None else entries:
|
||||
try:
|
||||
at = datetime.fromisoformat(entry["t"]).timestamp()
|
||||
except (KeyError, TypeError, ValueError):
|
||||
continue
|
||||
if at >= started - 1:
|
||||
written.append(str(entry.get("m") or ""))
|
||||
lines = []
|
||||
for raw in "".join(written).split("\n"):
|
||||
parts = [part for part in raw.split("\r") if part.strip()]
|
||||
line = ANSI.sub("", parts[-1]).strip() if parts else ""
|
||||
if line:
|
||||
lines.append(line[:LINE_CHARS])
|
||||
return lines[-limit:]
|
||||
|
||||
|
||||
def _seconds(text):
|
||||
"""tqdm's "01:23" / "1:02:03" in seconds, or None ("?")."""
|
||||
try:
|
||||
parts = [int(part) for part in text.strip().split(":")]
|
||||
except ValueError:
|
||||
return None
|
||||
return sum(part * 60 ** index for index, part in enumerate(reversed(parts))) if 1 < len(parts) <= 3 else None
|
||||
|
||||
|
||||
def bar_of(lines):
|
||||
"""The progress bar on the console's last line: steps, seconds left and per step, its note; or None."""
|
||||
match = BAR.search(lines[-1]) if lines else None
|
||||
if not match:
|
||||
return None
|
||||
out = {"value": int(match[1]), "max": int(match[2])}
|
||||
left = _seconds(match[4])
|
||||
if left is not None and out["value"]:
|
||||
out["left"] = left
|
||||
rate = match[5].strip()
|
||||
number = re.match(r"([\d.]+)\s*(s/it|it/s)", rate)
|
||||
if number and float(number[1]) > 0:
|
||||
out["rate"] = round(float(number[1]) if number[2] == "s/it" else 1 / float(number[1]), 2)
|
||||
if match[6] and match[6].strip():
|
||||
out["note"] = match[6].strip()[:80]
|
||||
return out
|
||||
|
||||
|
||||
class Pace:
|
||||
"""Seconds per step and seconds left of the node running, from the steps seen over time
|
||||
(for nodes whose bar is not on the console)."""
|
||||
|
||||
def __init__(self):
|
||||
self.key, self.first = None, None
|
||||
|
||||
def update(self, key, value, most, now=None):
|
||||
now = time.monotonic() if now is None else now
|
||||
if key != self.key or self.first is None or value < self.first[1]:
|
||||
self.key, self.first = key, (now, value)
|
||||
return None
|
||||
done = value - self.first[1]
|
||||
if done <= 0:
|
||||
return None
|
||||
rate = (now - self.first[0]) / done
|
||||
return {"rate": round(rate, 2), "left": max(0, round(rate * (most - value)))}
|
||||
|
||||
|
||||
def vram():
|
||||
"""The graphics card's free and total memory in MB, or None (no card, or no ComfyUI)."""
|
||||
try:
|
||||
import comfy.model_management as management
|
||||
device = management.get_torch_device()
|
||||
if getattr(device, "type", "") in ("cpu", "mps"):
|
||||
return None
|
||||
total, free = management.get_total_memory(device), management.get_free_memory(device)
|
||||
except Exception: # noqa: BLE001 - memory is a hint; the run goes on without it
|
||||
return None
|
||||
return {"free_mb": int(free // 2 ** 26) * 64, "total_mb": int(total // 2 ** 20)}
|
||||
|
||||
|
||||
def _image_size(name):
|
||||
"""(width, height) of picture `name` in ComfyUI's input folder, or None."""
|
||||
try:
|
||||
import folder_paths
|
||||
from PIL import Image
|
||||
with Image.open(folder_paths.get_annotated_filepath(str(name))) as picture:
|
||||
return picture.size
|
||||
except Exception: # noqa: BLE001 - an unreadable picture only leaves the size unknown
|
||||
return None
|
||||
|
||||
|
||||
def _number(value):
|
||||
return value if isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value) else None
|
||||
|
||||
|
||||
def _linked(value):
|
||||
return isinstance(value, list) and len(value) == 2 and isinstance(value[0], (str, int))
|
||||
|
||||
|
||||
def _model_factor(prompt, link):
|
||||
"""How many times an upscale model enlarges, from its file name ("4x-UltraSharp", "x2plus"); 4 if unsaid."""
|
||||
name = str(((prompt.get(str(link[0])) or {}).get("inputs") or {}).get("model_name") or "") if _linked(link) else ""
|
||||
match = re.search(r"(?<![0-9])([1-8])x|x([1-8])(?![0-9])", name, re.I)
|
||||
return int(match[1] or match[2]) if match else 4
|
||||
|
||||
|
||||
def estimate(prompt, vram_total_mb=None, image_size=_image_size):
|
||||
"""The size each sampler of API prompt `prompt` works at, and warnings: {"samplers", "warnings"}."""
|
||||
sizes = {}
|
||||
|
||||
def size(node_id, seen):
|
||||
node_id = str(node_id)
|
||||
if node_id in sizes:
|
||||
return sizes[node_id]
|
||||
node = prompt.get(node_id)
|
||||
if not isinstance(node, dict) or node_id in seen:
|
||||
return None
|
||||
seen.add(node_id)
|
||||
kind, inputs = str(node.get("class_type") or ""), node.get("inputs") or {}
|
||||
names = sorted((name for name, value in inputs.items() if _linked(value) and name not in NOT_PICTURES),
|
||||
key=lambda name: LATENT_INPUTS.index(name) if name in LATENT_INPUTS else len(LATENT_INPUTS))
|
||||
upstream = next((found for found in (size(inputs[name][0], seen) for name in names) if found), None)
|
||||
width, height = _number(inputs.get("width")), _number(inputs.get("height"))
|
||||
scale = _number(inputs.get("scale_by"))
|
||||
out = upstream
|
||||
if kind == "LoadImage":
|
||||
dims = image_size(inputs.get("image"))
|
||||
out = {"width": dims[0], "height": dims[1], "batch": 1, "upscaled": False} if dims else None
|
||||
elif width and height and width > 0 and height > 0:
|
||||
batch = _number(inputs.get("batch_size")) or (upstream or {}).get("batch", 1)
|
||||
out = {"width": width, "height": height, "batch": int(batch), "upscaled": (upstream or {}).get("upscaled", False)}
|
||||
elif upstream and (width or height): # one side given: the other keeps the picture's shape
|
||||
ratio = (width or 0) / upstream["width"] if width else height / upstream["height"]
|
||||
out = {**upstream, "width": upstream["width"] * ratio, "height": upstream["height"] * ratio}
|
||||
elif upstream and scale:
|
||||
out = {**upstream, "width": upstream["width"] * scale, "height": upstream["height"] * scale}
|
||||
elif upstream and kind == "ImageScaleToTotalPixels" and _number(inputs.get("megapixels")):
|
||||
ratio = math.sqrt(inputs["megapixels"] * 1024 * 1024 / (upstream["width"] * upstream["height"]))
|
||||
out = {**upstream, "width": upstream["width"] * ratio, "height": upstream["height"] * ratio}
|
||||
elif upstream and kind == "ImageUpscaleWithModel":
|
||||
factor = _model_factor(prompt, inputs.get("upscale_model"))
|
||||
out = {**upstream, "width": upstream["width"] * factor, "height": upstream["height"] * factor, "upscaled": True}
|
||||
sizes[node_id] = out
|
||||
return out
|
||||
|
||||
def steps_of(inputs):
|
||||
if _number(inputs.get("steps")):
|
||||
return int(inputs["steps"])
|
||||
source = prompt.get(str(inputs["sigmas"][0])) if _linked(inputs.get("sigmas")) else None
|
||||
return int(source["inputs"]["steps"]) if source and _number((source.get("inputs") or {}).get("steps")) else None
|
||||
|
||||
comfort = COMFORT_MP_12GB * max(0.5, min(3.0, (vram_total_mb or 12288) / 12288))
|
||||
samplers, warnings = [], []
|
||||
for node_id, node in sorted(prompt.items(), key=lambda item: str(item[0])):
|
||||
if not isinstance(node, dict):
|
||||
continue
|
||||
inputs = node.get("inputs") or {}
|
||||
title = str((node.get("_meta") or {}).get("title") or node.get("class_type") or node_id)[:80]
|
||||
if _linked(inputs.get("latent_image")):
|
||||
found = size(inputs["latent_image"][0], set())
|
||||
if not found:
|
||||
continue
|
||||
entry = {"node": str(node_id), "title": title, "width": round(found["width"]), "height": round(found["height"]),
|
||||
"batch": found["batch"], "steps": steps_of(inputs), "upscaled": found["upscaled"]}
|
||||
samplers.append(entry)
|
||||
megapixels = entry["width"] * entry["height"] * entry["batch"] / 1048576
|
||||
if megapixels > comfort:
|
||||
warnings.append({"kind": "upscale_resample" if found["upscaled"] else "big_sample",
|
||||
**entry, "megapixels": round(megapixels, 1)})
|
||||
elif node.get("class_type") == "VAEDecode" and _linked(inputs.get("samples")):
|
||||
found = size(inputs["samples"][0], set())
|
||||
if found and found["width"] * found["height"] * found["batch"] / 1048576 > comfort * 2:
|
||||
warnings.append({"kind": "big_decode", "node": str(node_id), "title": title,
|
||||
"width": round(found["width"]), "height": round(found["height"])})
|
||||
return {"samplers": samplers[:12], "warnings": warnings[:6], "comfort_mp": round(comfort, 1)}
|
||||
|
||||
|
||||
def warning_words(warning):
|
||||
"""One sentence for the AI on a warning of estimate()."""
|
||||
where = f"{warning['title']} (node {warning['node']}) works at {warning['width']}x{warning['height']}"
|
||||
if warning["kind"] == "upscale_resample":
|
||||
return (f"{where}{' for ' + str(warning['steps']) + ' steps' if warning.get('steps') else ''} after an upscale "
|
||||
"model enlarged the picture: very slow and may not fit in memory. If the user only wants it bigger, the "
|
||||
"upscale model alone (ImageUpscaleWithModel -> SaveImage, no sampler after it) is enough; else sample "
|
||||
"smaller (scale down before VAEEncode), use fewer steps or a lower denoise, or a tiled sampler.")
|
||||
if warning["kind"] == "big_sample":
|
||||
return (f"{where}: {warning['megapixels']} megapixels, more than this card is comfortable with; expect it to be "
|
||||
"very slow or run out of memory. Consider a smaller size and upscaling afterwards.")
|
||||
return f"{where} when decoded: VAEDecodeTiled saves memory there."
|
||||
@@ -0,0 +1,129 @@
|
||||
"""Each task's own canvas tab, kept by Anomalous rather than left to the AI: with "new" (the
|
||||
default, set in the Gates window; each task can change it) the page copies the workflow open
|
||||
now into a new tab named after the task before the AI's first change, and brings that tab back
|
||||
before each later change, read or run (web/modules/mcp_task_tab.js); new_workflow and
|
||||
open_workflow make the tab they open the task's. The user's own tab is never changed. With
|
||||
"current" the AI works on whatever tab is open, as before.
|
||||
|
||||
mcp_server.py marks each tool call with its task (begin_call); mcp_bridge.ask_page adds the
|
||||
task's canvas to the page actions that touch the canvas (spec) and keeps the tab the page
|
||||
reports (remember); tell() tells the AI once when a tab was made for it.
|
||||
"""
|
||||
|
||||
import contextvars
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from . import ai_tasks
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
MODES = ("new", "current")
|
||||
DEFAULT = "new"
|
||||
# Page actions (web/modules/mcp_bridge.js) that work on the canvas, so on the task's tab.
|
||||
TAB_ACTIONS = {"describe_canvas", "set_prompt", "set_model", "add_lora", "place_combo", "check_models", "fix_models",
|
||||
"run_workflow", "download_missing", "add_node", "add_nodes", "connect_nodes", "set_values", "remove_nodes", "new_workflow", "open_workflow",
|
||||
"fill_slots"}
|
||||
_call = contextvars.ContextVar("anomalous_task_canvas", default=None)
|
||||
|
||||
|
||||
def _path():
|
||||
return os.path.join(os.path.dirname(ai_tasks.tasks_dir()), "ai_canvas.json")
|
||||
|
||||
|
||||
def default_mode():
|
||||
try:
|
||||
with open(_path(), encoding="utf-8") as source:
|
||||
mode = json.load(source).get("mode")
|
||||
except (OSError, ValueError, AttributeError):
|
||||
mode = None
|
||||
return mode if mode in MODES else DEFAULT
|
||||
|
||||
|
||||
def set_default(mode):
|
||||
if mode not in MODES:
|
||||
raise ValueError("canvas_tab is new or current")
|
||||
atomic_write_json(_path(), {"mode": mode})
|
||||
return mode
|
||||
|
||||
|
||||
def mode_of(task):
|
||||
mode = ((task or {}).get("canvas") or {}).get("mode")
|
||||
return mode if mode in MODES else default_mode()
|
||||
|
||||
|
||||
def set_mode(task_id, mode):
|
||||
"""The user's choice for one task. Returns the task's canvas record."""
|
||||
if mode not in MODES:
|
||||
raise ValueError("canvas is new or current")
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
if not task:
|
||||
raise ValueError("No such task")
|
||||
if (task.get("canvas") or {}).get("mode", default_mode()) != mode:
|
||||
# The user's choice: the AI hears of it, and it is one of the task's decisions (ai_decisions.py).
|
||||
now = time.time()
|
||||
ai_tasks._add_step(task, {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "user_canvas", "kind": "user", "ok": True,
|
||||
"state": "done", "summary": "user_canvas", "canvas": mode, "delivered": False, "results": [],
|
||||
"text": "The user chose that you work " + ("in a tab of the task's own." if mode == "new" else "on the canvas they have open.")})
|
||||
task["canvas"] = {**(task.get("canvas") or {}), "mode": mode}
|
||||
ai_tasks._save(task)
|
||||
canvas = dict(task["canvas"])
|
||||
ai_tasks._notify(task_id)
|
||||
return canvas
|
||||
|
||||
|
||||
def begin_call(task_id):
|
||||
"""Marks the tool call running now as task `task_id`'s; the holder says later what the page opened."""
|
||||
holder = {"task": task_id, "opened": None}
|
||||
_call.set(holder)
|
||||
return holder
|
||||
|
||||
|
||||
def spec(action):
|
||||
"""What the page needs for page action `action` of the call running now: {mode, tab, title}, or None."""
|
||||
holder = _call.get()
|
||||
if not holder or not holder.get("task") or action not in TAB_ACTIONS:
|
||||
return None
|
||||
task = ai_tasks.get_task(holder["task"])
|
||||
if not task:
|
||||
return None
|
||||
return {"mode": mode_of(task), "tab": (task.get("canvas") or {}).get("tab"), "title": (task.get("title") or "")[:60]}
|
||||
|
||||
|
||||
def remember(tab):
|
||||
"""Keeps the tab the page made or opened for the call's task ({path, name, made?})."""
|
||||
holder = _call.get()
|
||||
if not holder or not holder.get("task") or not isinstance(tab, dict) or not isinstance(tab.get("path"), str):
|
||||
return
|
||||
kept = {"path": tab["path"][:300], "name": str(tab.get("name") or "")[:120], "at": time.time()}
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(holder["task"])
|
||||
if not task:
|
||||
return
|
||||
task["canvas"] = {**(task.get("canvas") or {}), "tab": kept}
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(holder["task"])
|
||||
holder["opened"] = {**kept, "made": bool(tab.get("made"))}
|
||||
|
||||
|
||||
def tell(result, holder):
|
||||
"""Says in the tool's answer that Anomalous made the task a tab of its own (once, when it did)."""
|
||||
opened = (holder or {}).get("opened")
|
||||
if not opened or not opened["made"] or not isinstance(result, dict) or result.get("isError"):
|
||||
return result
|
||||
data = dict(result.get("structuredContent") or {})
|
||||
data["canvas_tab"] = {"name": opened["name"], "note": (
|
||||
f"Anomalous copied the user's open workflow to a new tab \"{opened['name']}\" for this task (the user's "
|
||||
"setting): your canvas changes, reads and runs go there; the user's own tab stays as it was. Do not switch "
|
||||
"tabs yourself.")}
|
||||
result["structuredContent"] = data
|
||||
content = list(result.get("content") or [])
|
||||
text = {"type": "text", "text": json.dumps(data, ensure_ascii=False)}
|
||||
if content and isinstance(content[0], dict) and content[0].get("type") == "text":
|
||||
content[0] = text
|
||||
else:
|
||||
content.insert(0, text)
|
||||
result["content"] = content
|
||||
return result
|
||||
@@ -0,0 +1,62 @@
|
||||
"""The user's own changes in Anomalous while an AI works on a task: each activity log entry the
|
||||
user makes (activity_log.py tells note_activity of every new entry) becomes a step of the task
|
||||
the AI called within USER_STEP_SECONDS, and the entry names that task back. The AI is told of it
|
||||
with its next call (ai_panels.attach_pending, a message of kind "change"), so it keeps the user's
|
||||
change instead of working over it. The AI's own canvas changes (via mcp) are its steps already;
|
||||
which actions count, and their stage, is action_catalog.USER_ACTIONS."""
|
||||
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from . import action_catalog, activity_log, ai_tasks
|
||||
|
||||
USER_STEP_SECONDS = 10 * 60
|
||||
|
||||
|
||||
def _live_task(now):
|
||||
"""The task an AI is working on now (it called within USER_STEP_SECONDS), or None."""
|
||||
live = [task for task in ai_tasks._load().values() if not task.get("ended") and not task.get("waiting")
|
||||
and now - task.get("updated", 0) < USER_STEP_SECONDS]
|
||||
return max(live, key=lambda task: task.get("updated", 0)) if live else None
|
||||
|
||||
|
||||
def _change_text(entry):
|
||||
"""What the user changed, in words for the AI."""
|
||||
if entry.get("action") == "image_delete" and entry.get("target"):
|
||||
return (f"Deleted the picture {entry['target']} (to the Recycle Bin): it is gone from the output folder, "
|
||||
"so do not use, show or hand it in again; another picture is needed for what it was for.")
|
||||
if entry.get("source") != "canvas":
|
||||
words = str(entry.get("action", "")).replace("_", " ")
|
||||
return f"{words}: {entry['target']}" if entry.get("target") else words
|
||||
lines = []
|
||||
for change in (entry.get("detail") or {}).get("changes") or []:
|
||||
if change.get("kind") == "changed":
|
||||
lines.append(f"{change.get('node')} {change.get('widget')}: {change.get('before')} -> {change.get('after')}")
|
||||
elif change.get("kind") == "opened":
|
||||
lines.append(f"opened the workflow {change.get('node')}")
|
||||
else:
|
||||
lines.append(f"{change.get('kind')} {change.get('node')}")
|
||||
return "Changed on the canvas: " + "; ".join(lines[:8])
|
||||
|
||||
|
||||
def note_activity(entry):
|
||||
"""A new activity log entry: a step of the AI's task when the user made it while the AI worked."""
|
||||
stage = action_catalog.USER_ACTIONS.get(entry.get("action"))
|
||||
if stage is None or (entry.get("detail") or {}).get("via") == "mcp":
|
||||
return None
|
||||
at = entry.get("time") or time.time()
|
||||
with ai_tasks._lock:
|
||||
task = _live_task(at)
|
||||
if not task:
|
||||
return None
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": at, "ms": 0, "tool": "user_activity", "kind": "user", "stage": stage,
|
||||
"ok": True, "state": "done", "summary": entry.get("action", ""),
|
||||
"text": ai_tasks._short(_change_text(entry), ai_tasks.MAX_NOTE), "activity": entry["id"],
|
||||
"delivered": False, "results": []}
|
||||
# Appended without moving "updated": the user's own changes do not keep the AI's task open.
|
||||
task["steps"].append(step)
|
||||
del task["steps"][:-ai_tasks.MAX_STEPS]
|
||||
ai_tasks._save(task)
|
||||
activity_log.tag(entry["id"], task["id"])
|
||||
ai_tasks._notify(task["id"])
|
||||
return step
|
||||
@@ -0,0 +1,91 @@
|
||||
"""Select a task to resume from unread user input, without changing task state or ownership;
|
||||
whether a look belongs to the task just done; how many of a task's failures still stand.
|
||||
|
||||
Called under ai_tasks' lock when a caller has no recent open task. Explicit task selection
|
||||
and the user's task waiting for the next AI take precedence in ai_tasks.
|
||||
"""
|
||||
|
||||
import json
|
||||
|
||||
REPLIES = {"user_message", "user_marks", "user_pictures", "user_toolbox"}
|
||||
REPLY_FRESH = 2 * 3600
|
||||
AFTER_DONE = 5 * 60 # a look this soon after the AI said its task is done is part of that task, not a new one
|
||||
|
||||
|
||||
def _reply_at(task, now):
|
||||
"""Latest unread user input; a tool still running keeps its task from automatic takeover."""
|
||||
if any(step.get("state") == "running" for step in task["steps"]):
|
||||
return 0
|
||||
replies = []
|
||||
for step in task["steps"]:
|
||||
if step.get("kind") == "user" and step.get("tool") in REPLIES:
|
||||
replies.append(step)
|
||||
elif step.get("kind") == "panel":
|
||||
replies.extend((step.get("answers") or {}).values())
|
||||
return max((r.get("at", 0) for r in replies if not r.get("delivered") and not r.get("recommended_on_timeout")
|
||||
and 0 <= now - r.get("at", 0) < REPLY_FRESH), default=0)
|
||||
|
||||
|
||||
def latest_replied(tasks, client, now):
|
||||
"""The task of this app with the latest eligible reply, or None."""
|
||||
candidates = ((at, task) for task in tasks.values() if task.get("client") == client and (at := _reply_at(task, now)))
|
||||
_, task = max(candidates, key=lambda item: item[0], default=(0, None))
|
||||
return task
|
||||
|
||||
|
||||
def just_done(task, tasks, waiting, client, now, explicit=False):
|
||||
"""`task` (the app's last one) when it said it is done (report done) moments ago: a look the AI
|
||||
takes right after (checking its result) goes there, the task staying ended, and what it shows or
|
||||
asks the user about it (a before and after, "happy with it?") opens it again; no new task is made
|
||||
for either. Automatic selection yields to a waiting task or unread reply; an explicit
|
||||
task id keeps the same precedence as selecting an open task."""
|
||||
if not task or not task.get("ended") or not 0 <= now - task["ended"] < AFTER_DONE:
|
||||
return None
|
||||
if not any(step.get("tool") == "report" and step.get("at") == task["ended"] for step in task["steps"]):
|
||||
return None # it ended by a pause or another task, not by the AI saying it is done
|
||||
if not explicit and ((waiting and not waiting.get("ended")) or latest_replied(tasks, client, now)):
|
||||
return None
|
||||
return task
|
||||
|
||||
|
||||
RECOVERY_TARGETS = {
|
||||
"set_model": ("node_id",), "set_prompt": ("node_id", "role"), "set_values": ("node_id",),
|
||||
"connect_nodes": ("from_node_id", "to_node_id", "input"), "remove_nodes": ("node_ids",),
|
||||
"run_workflow": ("workflow",), "open_workflow": ("workflow",),
|
||||
"get_model": ("model_id",), "move_model": ("model_id",), "download_model": ("url",),
|
||||
"get_image_info": ("image",), "zoom_image": ("image",),
|
||||
}
|
||||
|
||||
|
||||
def recovery_target(tool, arguments):
|
||||
"""Keep target identity, not prompt text or changed values, to distinguish independent retries."""
|
||||
target = {key: arguments[key] for key in RECOVERY_TARGETS.get(tool, ()) if arguments.get(key) is not None}
|
||||
if tool == "set_prompt":
|
||||
target["role"] = arguments.get("role") or "positive"
|
||||
for key, value in target.items():
|
||||
if key.endswith("node_id"):
|
||||
target[key] = str(value)
|
||||
elif key == "node_ids" and isinstance(value, list):
|
||||
target[key] = sorted(map(str, value))
|
||||
if tool == "set_values" and isinstance(arguments.get("values"), dict):
|
||||
values = arguments["values"]
|
||||
if arguments.get("node_id") is None and values and all(isinstance(value, dict) for value in values.values()):
|
||||
target["settings"] = {str(node): sorted(settings) for node, settings in values.items()}
|
||||
else:
|
||||
target["settings"] = sorted(values)
|
||||
return json.dumps(target, sort_keys=True, ensure_ascii=False) if target else None
|
||||
|
||||
|
||||
def unresolved(steps):
|
||||
"""Only completed successful calls to the same recorded target resolve an earlier failure. A
|
||||
failure that named no target (its arguments missing or misnamed, as a light model's first try
|
||||
often is) is resolved by any later completed success of the same tool."""
|
||||
later_ok, later_tools, count = set(), set(), 0
|
||||
for step in reversed(steps):
|
||||
key = (step.get("tool"), step.get("recovery_target"))
|
||||
if step.get("ok") and step.get("state") in (None, "done"):
|
||||
later_ok.add(key)
|
||||
later_tools.add(key[0])
|
||||
elif not step.get("ok") and key not in later_ok and not (key[1] is None and key[0] in later_tools):
|
||||
count += 1
|
||||
return count
|
||||
@@ -0,0 +1,55 @@
|
||||
"""Which task a task goes on from ("接着"), so work split over tasks is found together: a task an
|
||||
AI begins as new while on another (ai_tasks.begin_task), or one the user starts while looking at
|
||||
another (ai_tasks.start_task), keeps that one as its "from". The user can link a task to another
|
||||
or take the link off (set_from); links() gives a task's own "from" and the tasks that go on from it,
|
||||
and an AI beginning a task that goes on from another hears what was decided there."""
|
||||
|
||||
from . import ai_decisions, ai_tasks
|
||||
|
||||
|
||||
class LinkError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def set_from(task_id, parent_id):
|
||||
"""Task `task_id` goes on from `parent_id` (None: from none). Refuses a loop. Returns the parent id."""
|
||||
with ai_tasks._lock:
|
||||
tasks = ai_tasks._load()
|
||||
task = tasks.get(task_id)
|
||||
if not task:
|
||||
raise LinkError("No such task")
|
||||
if parent_id is not None:
|
||||
if parent_id not in tasks or parent_id == task_id:
|
||||
raise LinkError("No such other task")
|
||||
seen, at = set(), parent_id
|
||||
while at and at not in seen: # going up from the parent must not come back here
|
||||
if at == task_id:
|
||||
raise LinkError("That task already goes on from this one")
|
||||
seen.add(at)
|
||||
at = (tasks.get(at) or {}).get("from")
|
||||
task["from"] = parent_id
|
||||
else:
|
||||
task.pop("from", None)
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
return parent_id
|
||||
|
||||
|
||||
def links(task_id):
|
||||
"""{from: {id, title} | None, next: [{id, title}]} of task `task_id`, the next oldest first."""
|
||||
with ai_tasks._lock:
|
||||
tasks = ai_tasks._load()
|
||||
task = tasks.get(task_id) or {}
|
||||
brief = lambda item: {"id": item["id"], "title": item.get("title") or ""} # noqa: E731
|
||||
parent = tasks.get(task.get("from"))
|
||||
later = sorted((item for item in tasks.values() if item.get("from") == task_id), key=lambda item: item.get("started", 0))
|
||||
return {"from": brief(parent) if parent else None, "next": [brief(item) for item in later]}
|
||||
|
||||
|
||||
def carried(task):
|
||||
"""For an AI beginning `task`: the task it goes on from and what was decided there, or None."""
|
||||
parent = ai_tasks.get_task(task.get("from")) if task.get("from") else None
|
||||
if not parent:
|
||||
return None
|
||||
return {"task": parent["id"], "title": parent.get("title") or "", "decisions": ai_decisions.lines(parent),
|
||||
"note": "This task goes on from that one; keep to what was decided there unless the user says otherwise."}
|
||||
@@ -0,0 +1,442 @@
|
||||
"""What a workflow run an AI started made: after run_workflow (mcp_server.py), the prompts
|
||||
ComfyUI queued for it are watched in its history until they end, and the pictures and videos
|
||||
they saved become the step's results (ai_tasks.py keeps the step). A thread per run, polling
|
||||
every RUN_POLL_SECONDS, for at most ai_tasks.RUN_WATCH_SECONDS; nothing runs when no AI ran
|
||||
anything. While it runs, where it stands (queued and how many are ahead, the node running and
|
||||
its steps, nodes done; read from ComfyUI's queue and its progress registry, never changed) is
|
||||
the step's "progress", sent to the page with each change, and status() answers the AI's
|
||||
run_status with it, waiting for the end when asked. tell() puts the same news in the AI's
|
||||
other answers: where the run stands while it goes, and once that it ended. The console's lines,
|
||||
the time left and the card's memory join the progress, and the size each sampler works at with
|
||||
its warnings is the step's "estimate" (ai_run_watch.py), the run's shape in boxes its "map" with
|
||||
what changed since the task's run before it (ai_run_map.py); a run the user or the AI stopped
|
||||
(ai_run_control.py) ends "cancelled"."""
|
||||
|
||||
import threading
|
||||
import time
|
||||
|
||||
from . import ai_gates, ai_run_map, ai_run_watch, ai_tasks
|
||||
from .mcp_tools import ToolError, _image_content, _resolve_image, retext, tool_text
|
||||
|
||||
RUN_POLL_SECONDS = 2.0
|
||||
MAX_STATUS_WAIT = 55
|
||||
MAX_PREVIEWS = 8 # the last PreviewImage pictures of a run the AI is told of
|
||||
MAX_SHOWN = 4 # thumbnails of a finished run's pictures that come with the answer first telling of its end
|
||||
|
||||
|
||||
def _queue():
|
||||
from server import PromptServer
|
||||
return PromptServer.instance.prompt_queue
|
||||
|
||||
|
||||
def outputs_of(record_, folder="output"):
|
||||
"""Saved pictures and videos in one history record; with `folder` "temp", what PreviewImage
|
||||
nodes showed (a pose skeleton, a mask): the AI's to look at, not the user's results."""
|
||||
out = []
|
||||
for output in (record_.get("outputs") or {}).values():
|
||||
for key in ("images", "gifs", "videos"):
|
||||
for item in output.get(key) or []:
|
||||
if isinstance(item, dict) and item.get("type") == folder and item.get("filename"):
|
||||
out.append({"type": "image", "filename": item["filename"], "subfolder": item.get("subfolder") or "",
|
||||
"folder": folder})
|
||||
return out
|
||||
|
||||
|
||||
def _registry():
|
||||
"""ComfyUI's per-node progress of the prompt running now, or None (an older ComfyUI has none)."""
|
||||
try:
|
||||
from comfy_execution import progress
|
||||
except ImportError:
|
||||
return None
|
||||
return progress.global_progress_registry
|
||||
|
||||
|
||||
def progress_of(prompts):
|
||||
"""Where the run of `prompts` stands: queued (how many are ahead), running (the node and its
|
||||
steps, nodes done of all), or None when ComfyUI cannot say."""
|
||||
try:
|
||||
running, pending = _queue().get_current_queue()
|
||||
except Exception: # noqa: BLE001 - no server (tests)
|
||||
return None
|
||||
running_ids = [item[1] for item in running]
|
||||
order = [item[1] for item in sorted(pending, key=lambda item: item[0])]
|
||||
current = next((pid for pid in prompts if pid in running_ids), None)
|
||||
if not current:
|
||||
waiting = [pid for pid in prompts if pid in order]
|
||||
if not waiting:
|
||||
return None
|
||||
return {"state": "queued", "ahead": order.index(waiting[0]) + len(running_ids)}
|
||||
out = {"state": "running", "prompt": prompts.index(current) + 1, "prompts": len(prompts)}
|
||||
registry = _registry()
|
||||
if registry is None or registry.prompt_id != current:
|
||||
return out
|
||||
nodes = dict(registry.nodes)
|
||||
out["nodes_done"] = sum(1 for node in nodes.values() if node["state"].value == "finished")
|
||||
out["nodes"] = len(registry.dynprompt.original_prompt)
|
||||
active = next(((node_id, node) for node_id, node in nodes.items() if node["state"].value == "running"), None)
|
||||
if active:
|
||||
try:
|
||||
info = registry.dynprompt.get_node(active[0]) or {}
|
||||
except Exception: # noqa: BLE001 - a node of the run that is gone already
|
||||
info = {}
|
||||
out["node"] = str((info.get("_meta") or {}).get("title") or info.get("class_type") or active[0])[:80]
|
||||
out["value"], out["max"] = int(active[1]["value"]), int(active[1]["max"])
|
||||
# Like ComfyUI's own tab title: the running node's steps; without steps, the nodes done.
|
||||
if out.get("max", 0) > 1:
|
||||
out["percent"] = max(0, min(100, round(100 * out["value"] / out["max"])))
|
||||
elif out["nodes"]:
|
||||
out["percent"] = max(0, min(100, round(100 * out["nodes_done"] / out["nodes"])))
|
||||
return out
|
||||
|
||||
|
||||
def _show_progress(task_id, step_id, progress):
|
||||
"""The run's progress on its step (kept in memory; the page hears of each change)."""
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
step = next((item for item in (task or {}).get("steps", []) if item["id"] == step_id), None)
|
||||
if step and step.get("stop"):
|
||||
progress = {**progress, "stopping": step["stop"]}
|
||||
if not step or step.get("progress") == progress or step.get("state") != "running":
|
||||
return
|
||||
step["progress"] = progress
|
||||
ai_tasks._notify(task_id, {"progress": {"step": step_id, **progress}})
|
||||
|
||||
|
||||
def _finish_run(task_id, step_id, prompts, history, queued=None):
|
||||
if not prompts:
|
||||
_stop_run(task_id, step_id, "没有找到已排队的运行 / No queued run was found; completion cannot be confirmed")
|
||||
return True
|
||||
images, previews, failed, done = [], [], False, 0
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
stopped = next((item.get("stop") for item in (task or {}).get("steps", []) if item["id"] == step_id), None)
|
||||
for prompt_id in prompts:
|
||||
record_ = history.get(prompt_id)
|
||||
if not record_:
|
||||
if stopped and queued is not None and prompt_id not in queued:
|
||||
done += 1 # taken out of the queue before it started: it never gets a history
|
||||
continue
|
||||
if stopped and (record_.get("status") or {}).get("status_str") == "error":
|
||||
done += 1 # the interrupt ends a prompt "error"; it was stopped, not broken
|
||||
continue
|
||||
status = record_.get("status") or {}
|
||||
if status.get("status_str") == "error":
|
||||
failed = True
|
||||
done += 1
|
||||
elif status.get("completed"):
|
||||
done += 1
|
||||
for image in outputs_of(record_):
|
||||
if image not in images: # a prompt ComfyUI answers from its cache repeats the same file
|
||||
images.append(image)
|
||||
previews += [image for image in outputs_of(record_, "temp") if image not in previews]
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
step = next((item for item in (task or {}).get("steps", []) if item["id"] == step_id), None)
|
||||
if not step:
|
||||
return True
|
||||
failed = failed or bool(step.get("submission_error"))
|
||||
stopped = step.get("stop")
|
||||
results = [item for item in step["results"] if item["type"] != "image"] + images[:ai_tasks.MAX_RESULTS]
|
||||
previews = previews[-MAX_PREVIEWS:]
|
||||
if (done < len(prompts) and results == step["results"] and step.get("prompts") == len(prompts)
|
||||
and previews == step.get("previews", []) and (not failed or step.get("ok") is False)):
|
||||
return False # nothing new to keep: no write
|
||||
step["results"] = results
|
||||
if previews:
|
||||
step["previews"] = previews
|
||||
step["state"] = "running" if done < len(prompts) else ("cancelled" if stopped else "error" if failed else "done")
|
||||
step["prompts"] = len(prompts)
|
||||
if failed:
|
||||
step["ok"] = False
|
||||
step["error"] = step.get("submission_error") or "ComfyUI 运行出错 / The run failed"
|
||||
if done >= len(prompts):
|
||||
step.pop("progress", None)
|
||||
step["ms"] = int((time.time() - step["at"]) * 1000)
|
||||
if step["state"] in ("done", "error") and not step.get("told") and ai_gates.run_wait() == "call":
|
||||
step["call_ai"] = True # the workbench offers the user a line to paste to the AI
|
||||
task["updated"] = max(task["updated"], time.time())
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
return done >= len(prompts)
|
||||
|
||||
|
||||
def _stop_run(task_id, step_id, reason):
|
||||
"""Monitoring ended without proof of completion; never pretend the run succeeded."""
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
step = next((item for item in (task or {}).get("steps", []) if item["id"] == step_id), None)
|
||||
if not step or step.get("state") != "running":
|
||||
return
|
||||
step.update(state="stopped", ok=False, error=reason, ms=max(0, int((time.time() - step["at"]) * 1000)))
|
||||
step.pop("progress", None)
|
||||
task["updated"] = max(task["updated"], time.time())
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
|
||||
|
||||
def watch(step_id, receipt):
|
||||
"""Follow only IDs returned by this submission, in batch order; never infer ownership from the queue."""
|
||||
with ai_tasks._lock:
|
||||
task_id = next((task["id"] for task in ai_tasks._load().values()
|
||||
if any(step["id"] == step_id for step in task.get("steps") or [])), None)
|
||||
if not task_id:
|
||||
return
|
||||
prompts = receipt.get("prompt_ids") or []
|
||||
if not prompts:
|
||||
_stop_run(task_id, step_id, "缺少运行 ID / Missing submission IDs; refresh ComfyUI before retrying")
|
||||
return
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
step = next((item for item in (task or {}).get("steps", []) if item["id"] == step_id), None)
|
||||
if not step:
|
||||
return # The user may remove the task while its submission is returning.
|
||||
step["prompt_ids"] = list(prompts)
|
||||
step_at = step["at"]
|
||||
for other in task.get("steps", []): # a new run: no line to paste for an older one any more
|
||||
if other is not step:
|
||||
other.pop("call_ai", None)
|
||||
if receipt.get("submission_error"):
|
||||
step.update(submission_error=receipt["submission_error"], error=receipt["submission_error"], ok=False)
|
||||
ai_tasks._save(task)
|
||||
|
||||
def follow():
|
||||
start = time.monotonic()
|
||||
pace, estimated = ai_run_watch.Pace(), False
|
||||
while time.monotonic() - start < ai_tasks.RUN_WATCH_SECONDS:
|
||||
try:
|
||||
history = {pid: _queue().get_history(prompt_id=pid).get(pid) for pid in prompts}
|
||||
except Exception: # noqa: BLE001 - stop the receipt, not the actual ComfyUI run
|
||||
_stop_run(task_id, step_id, "无法读取运行记录 / Run history could not be read; check ComfyUI's queue")
|
||||
return
|
||||
try:
|
||||
running, pending = _queue().get_current_queue()
|
||||
queued = {item[1]: item for item in [*running, *pending]}
|
||||
except Exception: # noqa: BLE001 - the queue only helps (estimate, a stopped run); history decides
|
||||
queued = None
|
||||
if not estimated: # from the queue, or from the history of a run that was quicker than this look
|
||||
item = next((queued[pid] for pid in prompts if pid in (queued or {})), None) or next(((history.get(pid) or {}).get("prompt") for pid in prompts if (history.get(pid) or {}).get("prompt")), None)
|
||||
estimated = _estimate(task_id, step_id, item)
|
||||
if _finish_run(task_id, step_id, prompts, {k: v for k, v in history.items() if v},
|
||||
None if queued is None else set(queued)):
|
||||
return
|
||||
try:
|
||||
progress = progress_of(prompts)
|
||||
if progress and progress["state"] == "running":
|
||||
_more_progress(progress, step_at, pace)
|
||||
except (AttributeError, KeyError, TypeError, ValueError):
|
||||
progress = None # progress is optional; keep watching the authoritative history
|
||||
if progress:
|
||||
_show_progress(task_id, step_id, progress)
|
||||
time.sleep(RUN_POLL_SECONDS)
|
||||
_stop_run(task_id, step_id, "运行跟踪已超时，未停止出图 / Monitoring timed out; the workflow was not cancelled. Check ComfyUI's queue")
|
||||
|
||||
threading.Thread(target=follow, name="anomalous-ai-run", daemon=True).start()
|
||||
|
||||
|
||||
def _estimate(task_id, step_id, item):
|
||||
"""The run's estimate (ai_run_watch.estimate) and map (ai_run_map) from its queued prompt `item`,
|
||||
kept on the step once, with what changed since the task's run before."""
|
||||
if not item or len(item) < 3 or not isinstance(item[2], dict):
|
||||
return False
|
||||
memory = ai_run_watch.vram()
|
||||
try:
|
||||
found = ai_run_watch.estimate(item[2], (memory or {}).get("total_mb"))
|
||||
shape = ai_run_map.map_of(item[2])
|
||||
except Exception: # noqa: BLE001 - an odd prompt leaves the run without an estimate, nothing more
|
||||
return True
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
steps = (task or {}).get("steps", [])
|
||||
at = next((index for index, entry in enumerate(steps) if entry["id"] == step_id), None)
|
||||
if at is None:
|
||||
return True
|
||||
before = next((entry["map"] for entry in reversed(steps[:at]) if entry.get("tool") == "run_workflow" and entry.get("map")), None)
|
||||
steps[at].update(estimate=found, map=shape, changes=ai_run_map.changes(before, shape))
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
return True
|
||||
|
||||
|
||||
def _more_progress(progress, started, pace):
|
||||
"""The console's last lines, its bar's time left (else the pace of the steps), the card's memory."""
|
||||
lines = ai_run_watch.console_since(started)
|
||||
if lines:
|
||||
progress["console"] = lines
|
||||
bar = ai_run_watch.bar_of(lines)
|
||||
if bar and bar.get("note"):
|
||||
progress["note"] = bar["note"]
|
||||
timing = None
|
||||
if bar and bar["max"] == progress.get("max"):
|
||||
timing = {key: bar[key] for key in ("left", "rate") if key in bar}
|
||||
if not timing and progress.get("max", 0) > 1:
|
||||
timing = pace.update((progress.get("prompt"), progress.get("node")), progress["value"], progress["max"])
|
||||
if timing:
|
||||
progress.update(timing)
|
||||
memory = ai_run_watch.vram()
|
||||
if memory:
|
||||
progress["vram"] = memory
|
||||
|
||||
|
||||
def summary(run):
|
||||
"""One sentence for the AI on where run step `run` stands."""
|
||||
state, progress = run.get("state"), run.get("progress") or {}
|
||||
warned = " ".join(ai_run_watch.warning_words(item) for item in (run.get("estimate") or {}).get("warnings", []))
|
||||
warning = (f" Warning: {warned} Tell the user (report) and ask_user whether to stop it (stop_run)." if warned and state == "running" else "")
|
||||
if state == "running" and progress.get("state") == "queued":
|
||||
return f"Your run is queued, {progress.get('ahead', 0)} ahead of it; it has not started. Do not run it again.{warning}"
|
||||
if state == "running":
|
||||
parts = []
|
||||
if progress.get("prompts", 0) > 1:
|
||||
parts.append(f"run {progress['prompt']} of {progress['prompts']}")
|
||||
if progress.get("node"):
|
||||
parts.append(f"{progress['node']} step {progress['value']}/{progress['max']}" if progress.get("max", 0) > 1
|
||||
else progress["node"])
|
||||
if "percent" in progress:
|
||||
parts.append(f"{progress['percent']}%")
|
||||
if progress.get("nodes"):
|
||||
parts.append(f"{progress['nodes_done']} of {progress['nodes']} nodes done")
|
||||
if progress.get("left") is not None:
|
||||
parts.append(f"about {progress['left']} s left in this node")
|
||||
parts.append(f"{round(time.time() - run['at'])} s so far")
|
||||
if progress.get("note"):
|
||||
parts.append(f"console says: {progress['note']}")
|
||||
return (f"Your run is still going ({', '.join(parts)}). It has not finished: {waiting_words()}; "
|
||||
"do not look in the output folder or guess." + warning)
|
||||
if state == "cancelled":
|
||||
return ("The user stopped your run in Anomalous; do not start it again unless they ask." if run.get("stop") == "user"
|
||||
else "Your run was stopped (stop_run).")
|
||||
if state == "done":
|
||||
pictures = [item["filename"] for item in run.get("results") or [] if item.get("type") == "image"]
|
||||
return f"Your run finished in {round(run.get('ms', 0) / 1000)} s with {len(pictures)} picture(s): {', '.join(pictures[:8])}."
|
||||
if state in ("asking", "allowed"):
|
||||
return "Your run waits for the user's OK in Anomalous; it has not started."
|
||||
return f"Your run did not finish: {run.get('error') or state}."
|
||||
|
||||
|
||||
def news(task_id):
|
||||
"""The run news for the AI working on task `task_id`: while its latest run goes, and once after it ends."""
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id) if task_id else None
|
||||
run = next((step for step in reversed((task or {}).get("steps", [])) if step.get("tool") == "run_workflow"), None)
|
||||
if not run or not run.get("prompt_ids") or run.get("told"):
|
||||
return None
|
||||
answer = {"state": run.get("state"), "summary": summary(run)}
|
||||
if run.get("state") == "running" and run.get("progress"):
|
||||
answer["progress"] = run["progress"]
|
||||
if run.get("state") not in ("running", "asking", "allowed"):
|
||||
run["told"], run["shown"] = True, False # show_pictures attaches them to this answer
|
||||
run.pop("call_ai", None)
|
||||
ai_tasks._save(task)
|
||||
return answer
|
||||
|
||||
|
||||
def waiting_words():
|
||||
"""How the AI is to wait for a run still going, as the user chose (ai_gates.run_wait)."""
|
||||
if ai_gates.run_wait() == "call":
|
||||
return ("the user tells you when it is done (Anomalous gives them a line to paste to you): say it is running "
|
||||
"and end your turn; do not wait with run_status")
|
||||
return "call run_status with wait_seconds to wait for it"
|
||||
|
||||
|
||||
def show_pictures(result, task_id):
|
||||
"""Attaches thumbnails of the latest run's pictures to the answer that first tells the AI it ended
|
||||
(status() or news() marked it), so it sees what came out without get_image_info; once per run."""
|
||||
if not isinstance(result, dict) or result.get("isError") or not task_id:
|
||||
return result
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
run = next((step for step in reversed((task or {}).get("steps", [])) if step.get("tool") == "run_workflow"), None)
|
||||
if not run or run.get("shown") is not False:
|
||||
return result
|
||||
run["shown"] = True
|
||||
ai_tasks._save(task)
|
||||
shown, items = [], []
|
||||
for item in run.get("results") or []:
|
||||
rel = "/".join(part for part in (item.get("subfolder"), item.get("filename")) if part)
|
||||
if item.get("type") != "image" or len(items) >= MAX_SHOWN:
|
||||
continue
|
||||
try:
|
||||
picture = _image_content(_resolve_image(rel)[1])
|
||||
except ToolError:
|
||||
picture = None
|
||||
if picture:
|
||||
shown.append(rel)
|
||||
items.append(picture)
|
||||
if not items:
|
||||
return result
|
||||
data = dict(result.get("structuredContent") or {})
|
||||
data["pictures_attached"] = shown
|
||||
retext(result, data)
|
||||
result["content"] = [*result["content"], *items]
|
||||
return result
|
||||
|
||||
|
||||
def tell(result, task_id):
|
||||
"""Puts the run news (news()) into a tool result, so the AI need not go and look."""
|
||||
run = news(task_id) if isinstance(result, dict) and not result.get("isError") else None
|
||||
if not run:
|
||||
return result
|
||||
data = result.get("structuredContent")
|
||||
data = dict(data) if isinstance(data, dict) else {}
|
||||
data["your_run"] = run
|
||||
retext(result, data)
|
||||
return result
|
||||
|
||||
|
||||
def status(client, session="", task_id=None, wait_seconds=0, step_id=None):
|
||||
"""The AI's run_status: its task's latest run, where it stands, and what it made; with
|
||||
`wait_seconds`, waits (up to MAX_STATUS_WAIT) until the run ends. No run yet is an answer, not
|
||||
an error (an AI asks before it runs, and the task would show a failed step)."""
|
||||
task_id = ai_tasks.active_task_id(client, session, task_id)
|
||||
deadline = time.monotonic() + max(0.0, min(float(wait_seconds or 0), MAX_STATUS_WAIT))
|
||||
while True:
|
||||
task = ai_tasks.get_task(task_id) if task_id else None
|
||||
run = next((step for step in reversed((task or {}).get("steps", []))
|
||||
if step.get("tool") == "run_workflow" and (not step_id or step["id"] == step_id)), None)
|
||||
if not run:
|
||||
return {"state": "none", "summary": "No run in this task yet.",
|
||||
"next": "run_workflow starts one (workflow: a saved one, with the prompt, seed or size to change)."}
|
||||
if run.get("state") not in ("running", "asking", "allowed") or time.monotonic() >= deadline:
|
||||
break
|
||||
time.sleep(1)
|
||||
answer = {"state": run.get("state"), "seconds": round(run.get("ms", 0) / 1000) if run.get("state") != "running"
|
||||
else round(time.time() - run["at"]), "summary": summary(run)}
|
||||
if run.get("state") not in ("running", "asking", "allowed") and not run.get("told"):
|
||||
with ai_tasks._lock: # told here: the next answers need not repeat it
|
||||
task = ai_tasks._load().get(task_id)
|
||||
step = next((item for item in (task or {}).get("steps", []) if item["id"] == run["id"]), None)
|
||||
if step is not None:
|
||||
step["told"], step["shown"] = True, False # show_pictures attaches them to this answer
|
||||
step.pop("call_ai", None)
|
||||
ai_tasks._save(task)
|
||||
if run.get("progress"):
|
||||
answer["progress"] = run["progress"]
|
||||
if (run.get("estimate") or {}).get("samplers"):
|
||||
answer["estimate"] = run["estimate"]
|
||||
if run.get("prompt_ids"):
|
||||
answer["prompt_ids"] = run["prompt_ids"]
|
||||
pictures = ["/".join(part for part in (item.get("subfolder"), item["filename"]) if part)
|
||||
for item in run.get("results") or [] if item.get("type") == "image"]
|
||||
if pictures:
|
||||
answer["pictures"] = pictures
|
||||
previews = ["/".join(part for part in (item.get("subfolder"), item["filename"]) if part) for item in run.get("previews") or []]
|
||||
if previews:
|
||||
answer["previews"] = previews
|
||||
answer["previews_note"] = ("What the run's PreviewImage nodes showed (pose skeletons, masks…), in ComfyUI's temp "
|
||||
"folder: zoom_image(image, folder='temp') or get_image_info(image, folder='temp', "
|
||||
"include_image=true) shows them; there is no need to run a preprocessor yourself.")
|
||||
if run.get("error"):
|
||||
answer["error"] = run["error"]
|
||||
# What to do now, in one line a small model can follow (get_situation and the canvas tools say theirs too).
|
||||
answer["next"] = {
|
||||
"running": (f"It is still running: {waiting_words()}. Do not guess it is done or run it again."
|
||||
if ai_gates.run_wait() == "call" else
|
||||
"run_status(wait_seconds=55): it is still running; do not guess it is done or run it again."),
|
||||
"allowed": "run_status(wait_seconds=55): it is about to run.",
|
||||
"done": ("The first answer telling you it ended has its pictures attached (pictures_attached): look at them, "
|
||||
"then report what came out with images= its pictures; show_panel only to compare or ask. "
|
||||
"zoom_image looks closer."),
|
||||
"asking": "get_answers(wait_seconds=55): the run waits for the user's OK in Anomalous.",
|
||||
"cancelled": "It was stopped and nothing more comes of it: ask_user what to change before running again.",
|
||||
}.get(run.get("state"), "get_situation shows what went wrong (a missing model: check_workflow_models); fix it, then run again.")
|
||||
return answer
|
||||
+592
@@ -0,0 +1,592 @@
|
||||
"""AI tasks: what AI apps did through Anomalous's MCP endpoint, kept for the AI workbench page.
|
||||
|
||||
Every tool call an AI app makes (mcp_server.py) becomes a step of a task: a task is one piece
|
||||
of work, named by the AI with begin_task, else the calls of one app that follow each other
|
||||
without a long pause. A step starts in state "running" when the call begins and is updated in
|
||||
place when it finishes: what was done (the tool, a short summary of its arguments), whether it
|
||||
worked, and what came out of it, so the page can show it live and lead there: the models it
|
||||
used, the combo it placed, the canvas change it made (by its activity log entry, for undo),
|
||||
the pictures a run made (ai_task_runs.py watches ComfyUI's history until the run ends), the
|
||||
audio it spoke. The AI can also leave a note (report), with pictures it made another way. What
|
||||
each tool is (kind, stage of the work, gate) is action_catalog.py's; the user's own changes
|
||||
made while an AI works join its task through ai_task_changes.py. A step a restart left
|
||||
"running" is marked stopped when the record is read again.
|
||||
|
||||
The user can start a task first (New task, POST /anomalous/ai_tasks): it waits for an AI, and
|
||||
the next app that calls takes it over, so the work it does next starts there instead of joining
|
||||
the app's last task. Likewise an app whose task ended or paused goes on in the task the user wrote
|
||||
to (a message, marks, pictures, materials) that it has not read yet, rather than starting one.
|
||||
|
||||
Tasks are files in the ComfyUI user folder (anomalous/ai_tasks/<id>.json), the newest
|
||||
MAX_TASKS kept. Recording never fails a tool call: the record is a convenience. The page
|
||||
learns of a change through the "anomalous.ai_task" event. Reading is open like the other
|
||||
pages; renaming and removing are writes (local_guard.py keeps them to this computer). The
|
||||
routes are in ai_tasks_routes.py.
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
|
||||
import folder_paths
|
||||
|
||||
from . import action_catalog, activity_log
|
||||
from .ai_task_handoff import just_done, latest_replied, recovery_target, unresolved
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
FORMAT = 1
|
||||
MAX_TASKS = 300
|
||||
MAX_STEPS = 400
|
||||
MAX_TASK_BYTES = 2 * 1024 * 1024
|
||||
IDLE_SECONDS = 20 * 60 # a longer pause between calls of one app starts a new task
|
||||
MAX_TEXT = 300
|
||||
MAX_NOTE = 2000
|
||||
MAX_TITLE = 80
|
||||
MAX_RESULTS = 40
|
||||
RUN_WATCH_SECONDS = 30 * 60
|
||||
MEDIA_EXTS = {".png", ".jpg", ".jpeg", ".webp", ".gif", ".mp4", ".webm"}
|
||||
|
||||
# What each tool is (its kind, stage and gate) is action_catalog.py's.
|
||||
OWN_STEPS = {"report", "log_decision", "log_outside", "show_panel", "ask_user", "show_run_map", "propose_repaint_area"} # make their step themselves (with its text or panel)
|
||||
|
||||
_lock = threading.RLock()
|
||||
_tasks = None # id -> task
|
||||
_current = {} # client/session key -> id of the task its calls go to
|
||||
_waiting = [None] # id of the task the user started that no AI has taken yet
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- storage
|
||||
|
||||
def tasks_dir():
|
||||
user_dir = folder_paths.get_user_directory() if hasattr(folder_paths, "get_user_directory") else None
|
||||
if not user_dir:
|
||||
user_dir = os.path.join(folder_paths.base_path, "user")
|
||||
directory = os.path.join(user_dir, "anomalous", "ai_tasks")
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
return directory
|
||||
|
||||
|
||||
def _path(task_id):
|
||||
return os.path.join(tasks_dir(), f"{task_id}.json")
|
||||
|
||||
|
||||
def marks_dir(task_id):
|
||||
"""Where the pictures the user marked for a task are kept (ai_marks.py); gone with the task."""
|
||||
return os.path.join(os.path.dirname(tasks_dir()), "ai_marks", re.sub(r"[^\w-]", "", task_id))
|
||||
|
||||
|
||||
def _forget(task_id):
|
||||
"""The task's own files: its record and its marked pictures (the plugin's, not the user's pictures)."""
|
||||
try:
|
||||
os.remove(_path(task_id))
|
||||
except OSError:
|
||||
pass
|
||||
shutil.rmtree(marks_dir(task_id), ignore_errors=True)
|
||||
|
||||
|
||||
def _load():
|
||||
global _tasks
|
||||
if _tasks is None:
|
||||
_tasks = {}
|
||||
for name in os.listdir(tasks_dir()):
|
||||
if not name.endswith(".json"):
|
||||
continue
|
||||
try:
|
||||
with open(os.path.join(tasks_dir(), name), encoding="utf-8") as source:
|
||||
task = json.load(source)
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
if isinstance(task, dict) and task.get("format") == FORMAT and isinstance(task.get("id"), str):
|
||||
_tasks[task["id"]] = task
|
||||
if _stop_running(task):
|
||||
_save(task)
|
||||
# A task the user started before ComfyUI restarted still waits for the next AI.
|
||||
waiting = [task for task in _tasks.values() if task.get("waiting") and not task.get("ended")]
|
||||
if waiting and _waiting[0] is None:
|
||||
_waiting[0] = max(waiting, key=lambda task: task.get("started", 0))["id"]
|
||||
return _tasks
|
||||
|
||||
|
||||
def _stop_running(task):
|
||||
"""Steps a call or a run left "running" when ComfyUI stopped: nothing watches them any more."""
|
||||
stopped = False
|
||||
for step in task.get("steps") or []:
|
||||
if step.get("state") == "asking" and step.get("gate") and not step["gate"].get("timed_out"):
|
||||
step["gate"]["timed_out"] = True # no old process is still waiting for this decision
|
||||
stopped = True
|
||||
if step.get("state") == "running":
|
||||
step.update(state="stopped", ok=False, error="ComfyUI 重启时这一步还没结束 / ComfyUI restarted before this step ended")
|
||||
stopped = True
|
||||
return stopped
|
||||
|
||||
|
||||
def _save(task):
|
||||
try:
|
||||
atomic_write_json(_path(task["id"]), task, MAX_TASK_BYTES)
|
||||
except (OSError, ValueError) as error:
|
||||
log.warning("Anomalous AI tasks: %s not saved: %s", task["id"], error)
|
||||
|
||||
|
||||
def _drop_oldest():
|
||||
tasks = _load()
|
||||
if len(tasks) <= MAX_TASKS:
|
||||
return
|
||||
for task in sorted(tasks.values(), key=lambda item: item.get("updated", 0))[: len(tasks) - MAX_TASKS]:
|
||||
tasks.pop(task["id"], None)
|
||||
_forget(task["id"]) # the pictures and files it made stay
|
||||
|
||||
|
||||
def _notify(task_id, extra=None):
|
||||
try:
|
||||
from server import PromptServer
|
||||
PromptServer.instance.send_sync("anomalous.ai_task", {"id": task_id, **(extra or {})})
|
||||
except Exception: # noqa: BLE001 - tests and early start have no server; the page polls on open
|
||||
pass
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- who is calling (named in ai_callers.py)
|
||||
|
||||
def _owner_key(client, session=""):
|
||||
return f"{client}::{session}" if session else client
|
||||
|
||||
|
||||
def _bind_owner(client, session, task_id):
|
||||
_current[_owner_key(client, session)] = task_id
|
||||
if not session or client not in _current:
|
||||
_current[client] = task_id
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- tasks and steps
|
||||
|
||||
def _short(value, limit=MAX_TEXT):
|
||||
text = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False)
|
||||
return text if len(text) <= limit else text[:limit] + "…"
|
||||
|
||||
|
||||
def _new_task(client, title="", now=None, session=""):
|
||||
now = time.time() if now is None else now
|
||||
task = {"format": FORMAT, "id": f"{int(now)}_{uuid.uuid4().hex[:8]}", "title": _short(title, MAX_TITLE),
|
||||
"title_from": "ai" if title else "auto", "client": client, "started": now, "updated": now,
|
||||
"ended": None, "steps": []}
|
||||
if session:
|
||||
task["session"] = session
|
||||
_load()[task["id"]] = task
|
||||
_bind_owner(client, session, task["id"])
|
||||
_drop_oldest()
|
||||
return task
|
||||
|
||||
|
||||
def _claim_explicit(tasks, task_id, client, session=""):
|
||||
if not task_id or task_id not in tasks or tasks[task_id].get("ended"):
|
||||
return None
|
||||
picked = tasks[task_id]
|
||||
if picked.get("waiting"):
|
||||
if _waiting[0] == task_id:
|
||||
_waiting[0] = None
|
||||
picked["waiting"] = False
|
||||
if not picked.get("client"):
|
||||
picked["client"] = client
|
||||
_bind_owner(client, session, task_id)
|
||||
return picked
|
||||
|
||||
|
||||
def _take_waiting(client, now, session=""):
|
||||
"""The task the user started, now this app's (its own open task ends), or None."""
|
||||
task = _load().get(_waiting[0])
|
||||
_waiting[0] = None
|
||||
if not task or task.get("ended"): # it waits until an AI takes it, as its page says, or the user starts another
|
||||
return None
|
||||
owner = _owner_key(client, session)
|
||||
previous = _load().get(_current.get(owner) or (None if session else _current.get(client)))
|
||||
if previous and previous is not task and not previous.get("ended"):
|
||||
previous["ended"] = previous.get("updated")
|
||||
_save(previous)
|
||||
task["client"] = client
|
||||
if session:
|
||||
task["session"] = session
|
||||
task["waiting"] = False
|
||||
_bind_owner(client, session, task["id"])
|
||||
return task
|
||||
|
||||
|
||||
ABOUT_TYPES = {"model": "model_id", "image": "image", "combo": "name", "workflow": "name"} # what a task the user starts can be about
|
||||
|
||||
|
||||
def _about(items):
|
||||
"""What the user handed to the AI with a task (a model, an output image, a combo), checked: plain strings only."""
|
||||
out = []
|
||||
for item in items if isinstance(items, list) else []:
|
||||
key = ABOUT_TYPES.get(item.get("type")) if isinstance(item, dict) else None
|
||||
if key and isinstance(item.get(key), str) and item[key].strip():
|
||||
out.append({"type": item["type"], key: _short(item[key].strip(), 300),
|
||||
**({"label": _short(item["label"], 120)} if isinstance(item.get("label"), str) else {})})
|
||||
return out[:5]
|
||||
|
||||
|
||||
def start_task(title="", now=None, about=None, from_task=None):
|
||||
"""A task the user starts; it waits for the next AI app that calls. `about`: what the user
|
||||
handed to the AI with it (from a model page, an image or a combo); `from_task`: the task it
|
||||
goes on from (ai_task_links.py). Returns the task."""
|
||||
now = time.time() if now is None else now
|
||||
with _lock:
|
||||
before = _load().get(_waiting[0])
|
||||
if before and not before.get("steps"): # started before and never taken: this one replaces it
|
||||
remove_task(before["id"])
|
||||
task = {"format": FORMAT, "id": f"{int(now)}_{uuid.uuid4().hex[:8]}", "title": _short(str(title or "").strip(), MAX_TITLE),
|
||||
"title_from": "user", "client": "", "started": now, "updated": now, "ended": None, "steps": [], "waiting": True}
|
||||
if not task["title"]:
|
||||
task["title_from"] = "auto"
|
||||
if _about(about):
|
||||
task["about"] = _about(about)
|
||||
if from_task in _load():
|
||||
task["from"] = from_task
|
||||
_load()[task["id"]] = task
|
||||
_waiting[0] = task["id"]
|
||||
_drop_oldest()
|
||||
_save(task)
|
||||
_notify(task["id"])
|
||||
return task
|
||||
|
||||
|
||||
def active_task_id(client, session="", task_id=None):
|
||||
"""The active task id for this caller without creating a new task."""
|
||||
with _lock:
|
||||
tasks = _load()
|
||||
if task_id and task_id in tasks:
|
||||
return task_id
|
||||
found = _current.get(_owner_key(client, session)) or (None if session else _current.get(client))
|
||||
return found if found in tasks else None
|
||||
|
||||
|
||||
def current_task(client, now=None, session="", task_id=None, follow_up=False, read_only=False):
|
||||
"""The task this app's calls go to now: an explicit task, one the user started for the next
|
||||
AI, else its open one, unless it paused too long. `follow_up`: a panel, question or note, which
|
||||
right after the AI said its task is done is about that task (ai_task_handoff.just_done).
|
||||
`read_only` keeps such a task ended while a follow-up reopens it; both honor an explicit id."""
|
||||
now = time.time() if now is None else now
|
||||
with _lock:
|
||||
tasks = _load()
|
||||
task = tasks.get(task_id or _current.get(_owner_key(client, session)))
|
||||
if (follow_up or read_only) and just_done(task, tasks, tasks.get(_waiting[0]), client, now, explicit=bool(task_id)):
|
||||
_bind_owner(client, session, task["id"])
|
||||
if follow_up:
|
||||
task["ended"] = None
|
||||
_save(task)
|
||||
return task
|
||||
picked = _claim_explicit(tasks, task_id, client, session)
|
||||
if picked:
|
||||
return picked
|
||||
waiting = _take_waiting(client, now, session=session)
|
||||
if waiting:
|
||||
return waiting
|
||||
task = tasks.get(_current.get(_owner_key(client, session)) or (None if session else _current.get(client)))
|
||||
if task and not task.get("ended") and now - task.get("updated", 0) < IDLE_SECONDS:
|
||||
_bind_owner(client, session, task["id"])
|
||||
return task
|
||||
if task and not task.get("ended"):
|
||||
task["ended"] = task.get("updated")
|
||||
_save(task)
|
||||
return _take_replied(tasks, client, now, session) or _new_task(client, now=now, session=session)
|
||||
|
||||
|
||||
def _take_replied(tasks, client, now, session="", previous=None):
|
||||
"""The newest task of this app the user wrote to lately, since its AI last read (an ended one
|
||||
opens again), now this app's instead of a new one (its own open task `previous` ends), or None."""
|
||||
replied = latest_replied(tasks, client, now)
|
||||
if replied is None:
|
||||
return None
|
||||
if previous and previous is not replied and not previous.get("ended"):
|
||||
previous["ended"] = previous.get("updated")
|
||||
_save(previous)
|
||||
replied["ended"] = None
|
||||
_bind_owner(client, session, replied["id"])
|
||||
_save(replied)
|
||||
return replied
|
||||
|
||||
|
||||
def begin_task(client, title, now=None, new_task=False, session="", task_id=None):
|
||||
"""Name or resume the active task; only an explicit new piece of work splits it."""
|
||||
now = time.time() if now is None else now
|
||||
with _lock:
|
||||
tasks = _load()
|
||||
previous = tasks.get(_current.get(_owner_key(client, session)) or (None if session else _current.get(client)))
|
||||
task = None if new_task else _claim_explicit(tasks, task_id, client, session)
|
||||
if task is None:
|
||||
task = _take_waiting(client, now, session=session)
|
||||
if task is None and not new_task and previous and not previous.get("ended") and now - previous.get("updated", 0) < IDLE_SECONDS:
|
||||
task = previous
|
||||
if task is None and not new_task:
|
||||
task = _take_replied(tasks, client, now, session, previous)
|
||||
if task is None:
|
||||
if previous and not previous.get("ended"):
|
||||
previous["ended"] = now
|
||||
_save(previous)
|
||||
task = _new_task(client, title, now, session=session)
|
||||
if new_task and previous:
|
||||
task["from"] = previous["id"] # begun from that one (ai_task_links.py)
|
||||
elif not task.get("title") or task.get("title_from") == "auto":
|
||||
task["title"] = _short(title, MAX_TITLE)
|
||||
task["title_from"] = "ai"
|
||||
_bind_owner(client, session, task["id"])
|
||||
task["updated"] = now
|
||||
_save(task)
|
||||
_notify(task["id"])
|
||||
return task
|
||||
|
||||
|
||||
def _add_step(task, step):
|
||||
task["steps"].append(step)
|
||||
del task["steps"][:-MAX_STEPS]
|
||||
task["updated"] = max(task.get("updated", 0), step["at"] + step.get("ms", 0) / 1000)
|
||||
if task.get("title_from") == "auto" and not task.get("title") and step["kind"] not in ("look", "note") and step["ok"]:
|
||||
task["title"] = step["summary"][:MAX_TITLE]
|
||||
|
||||
|
||||
def summary_of(tool, arguments):
|
||||
"""A few words on what a call asked for: its main argument."""
|
||||
for key in ("title", "query", "text", "name", "workflow", "character", "model_id", "url", "what", "names", "type", "types"):
|
||||
if arguments.get(key) not in (None, "", []):
|
||||
value = arguments[key]
|
||||
if key == "model_id": # "type:0:folder/file.safetensors": the file, and where it moves to
|
||||
value = str(value).split(":", 2)[-1].rsplit("/", 1)[-1] + (f" → {arguments['to_type']}" if arguments.get("to_type") else "")
|
||||
return _short(f"{tool}: {_short(value, 120)}", 160)
|
||||
return tool
|
||||
|
||||
|
||||
def _model_result(model_id):
|
||||
from .mcp_tools import _resolve_model
|
||||
try:
|
||||
folder_type, path_idx, base_dir, file_path = _resolve_model(model_id)
|
||||
except Exception: # noqa: BLE001 - a model that went away is still worth its id
|
||||
return {"type": "model", "model_id": str(model_id)}
|
||||
rel = os.path.relpath(file_path, base_dir).replace(os.sep, "/")
|
||||
return {"type": "model", "model_id": str(model_id), "folder": folder_type, "path_idx": path_idx, "rel": rel,
|
||||
"name": os.path.basename(file_path)}
|
||||
|
||||
|
||||
def results_of(tool, arguments, data):
|
||||
"""What came out of a call, for the page to show and lead to."""
|
||||
data = data if isinstance(data, dict) else {}
|
||||
out = []
|
||||
if tool in ("set_model", "add_lora", "open_in_anomalous") and arguments.get("model_id"):
|
||||
out.append(_model_result(arguments["model_id"]))
|
||||
if tool == "place_combo" and arguments.get("name"):
|
||||
out.append({"type": "combo", "name": _short(arguments["name"], 120)})
|
||||
if isinstance(data.get("_activity"), str):
|
||||
out.append({"type": "canvas", "activity": data["_activity"]})
|
||||
if tool == "speak":
|
||||
out.extend({"type": "audio", "file": _short(f, 200)} for f in data.get("files") or [] if isinstance(f, str))
|
||||
if tool == "scan_models" and data.get("started"):
|
||||
out.append({"type": "scan"})
|
||||
if tool == "download_model" and data.get("started"):
|
||||
out.append({**_download_result(data), "name": _short(str(data.get("model") or ""), 160)})
|
||||
if tool == "download_missing_models":
|
||||
out.extend(_download_result(item) for item in data.get("started") or [] if isinstance(item, dict))
|
||||
return out[:MAX_RESULTS]
|
||||
|
||||
|
||||
def _download_result(started):
|
||||
"""A download the AI started (mcp_actions' answer): the file it makes, and its size when the site said."""
|
||||
size = started.get("size")
|
||||
return {"type": "download", "file": _short(str(started.get("to") or "").rsplit("/", 1)[-1], 200),
|
||||
"size": size if isinstance(size, int) and size > 0 else None}
|
||||
|
||||
|
||||
def _count_of(data):
|
||||
"""How many things a read found: the length of its first list."""
|
||||
if isinstance(data, dict):
|
||||
for value in data.values():
|
||||
if isinstance(value, list):
|
||||
return len(value)
|
||||
return None
|
||||
|
||||
|
||||
def begin_step(client, tool, arguments, started=None, read_only=False, session="", task_id=None):
|
||||
"""Starts an in-flight step in state 'running' before a tool executes. Returns (task_id, step_id) or None."""
|
||||
if not action_catalog.is_step(tool) or tool in OWN_STEPS:
|
||||
return None
|
||||
try:
|
||||
started = time.time() if started is None else started
|
||||
args = arguments if isinstance(arguments, dict) else {}
|
||||
what = action_catalog.entry(tool, read_only)
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": started, "ms": 0, "tool": tool, "kind": what.kind, "stage": what.stage,
|
||||
"ok": True, "state": "running", "summary": summary_of(tool, args), "results": [],
|
||||
"recovery_target": recovery_target(tool, args)}
|
||||
with _lock:
|
||||
task = current_task(client, started, session=session, task_id=task_id, read_only=read_only)
|
||||
_add_step(task, step)
|
||||
_save(task)
|
||||
_notify(task["id"])
|
||||
return task["id"], step["id"]
|
||||
except Exception: # noqa: BLE001 - the record must never fail the AI's call
|
||||
log.warning("Anomalous AI tasks: begin_step of %s failed", tool, exc_info=True)
|
||||
return None
|
||||
|
||||
|
||||
def finish_step(client, tool, arguments, result, started, read_only=False, step_ref=None, session="", task_id=None):
|
||||
"""Completes an in-flight step (or creates one if step_ref is None) with its final outcome. Never raises."""
|
||||
if not action_catalog.is_step(tool) or tool in OWN_STEPS:
|
||||
return None
|
||||
try:
|
||||
args = arguments if isinstance(arguments, dict) else {}
|
||||
data = result.get("structuredContent") if isinstance(result, dict) else None
|
||||
failed = not isinstance(result, dict) or bool(result.get("isError"))
|
||||
error = _short(" ".join(item.get("text", "") for item in result.get("content") or [] if isinstance(item, dict))) if failed and isinstance(result, dict) else ""
|
||||
ms = max(0, int((time.time() - started) * 1000))
|
||||
what = action_catalog.entry(tool, read_only)
|
||||
kind = what.kind
|
||||
waiting = isinstance(data, dict) and data.get("waiting_for_user") # a gate the user has not answered (ai_gates.py)
|
||||
state = "error" if failed else "asking" if waiting else "running" if tool == "run_workflow" else "done"
|
||||
summary = summary_of(tool, args)
|
||||
results = [] if failed else results_of(tool, args, data)
|
||||
with _lock:
|
||||
task = _load().get(step_ref[0]) if isinstance(step_ref, tuple) and len(step_ref) == 2 else None
|
||||
step = next((item for item in (task or {}).get("steps", []) if item.get("id") == step_ref[1]), None) if task else None
|
||||
# A user can answer just after check() times out, before this call returns.
|
||||
gate = (step or {}).get("gate") or {}
|
||||
if waiting and gate.get("decision"):
|
||||
failed = gate["decision"] == "deny"
|
||||
state = "error" if failed else "done" if gate.get("used") else "allowed"
|
||||
error = (step.get("error") or "你没有允许 / You said no") if failed else ""
|
||||
if task is None:
|
||||
task = current_task(client, started, session=session, task_id=task_id, read_only=read_only)
|
||||
if step is None:
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": started, "ms": ms, "tool": tool, "kind": kind, "stage": what.stage,
|
||||
"ok": not failed, "state": state, "summary": summary, "results": results}
|
||||
_add_step(task, step)
|
||||
else:
|
||||
step.update(ms=ms, ok=not failed, state=state, summary=summary, results=results)
|
||||
step["recovery_target"] = recovery_target(tool, args)
|
||||
if error:
|
||||
step["error"] = error
|
||||
else:
|
||||
step.pop("error", None)
|
||||
if kind == "look" and not failed and tool.startswith(("search_", "list_")):
|
||||
step["count"] = _count_of(data)
|
||||
task["updated"] = max(task.get("updated", 0), step["at"] + ms / 1000)
|
||||
if task.get("title_from") == "auto" and not task.get("title") and kind not in ("look", "note") and step["ok"]:
|
||||
task["title"] = summary[:MAX_TITLE]
|
||||
_save(task)
|
||||
for result in results:
|
||||
if result["type"] == "canvas":
|
||||
activity_log.tag(result["activity"], task["id"]) # the activity page links back to the task
|
||||
_notify(task["id"])
|
||||
return step
|
||||
except Exception: # noqa: BLE001 - the record must never fail the AI's call
|
||||
log.warning("Anomalous AI tasks: step of %s not recorded", tool, exc_info=True)
|
||||
return None
|
||||
|
||||
|
||||
def record(client, tool, arguments, result, started, read_only=False, session="", task_id=None):
|
||||
"""One tool call as a step of the app's current task. Never raises."""
|
||||
return finish_step(client, tool, arguments, result, started, read_only, session=session, task_id=task_id)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- notes from the AI
|
||||
|
||||
def _output_media(path):
|
||||
"""An output-folder file the AI names ("subfolder/name.png"), as an image result, or None."""
|
||||
root = os.path.realpath(folder_paths.get_output_directory())
|
||||
full = os.path.realpath(os.path.join(root, str(path).replace("\\", "/").lstrip("/")))
|
||||
if os.path.commonpath((root, full)) != root or not os.path.isfile(full):
|
||||
return None
|
||||
if os.path.splitext(full)[1].lower() not in MEDIA_EXTS:
|
||||
return None
|
||||
rel = os.path.relpath(full, root).replace(os.sep, "/")
|
||||
subfolder, _, filename = rel.rpartition("/")
|
||||
return {"type": "image", "filename": filename, "subfolder": subfolder, "folder": "output"}
|
||||
|
||||
|
||||
def report(client, text, images=None, done=False, now=None, session="", task_id=None, reply_to=None):
|
||||
"""A note from the AI, with pictures it made (in ComfyUI's output folder); `reply_to`: the user's
|
||||
message or marks it answers (both steps then point at each other). Returns the step."""
|
||||
text = str(text or "").strip()
|
||||
if not text and not images:
|
||||
raise ValueError("text or images is needed")
|
||||
results, missing = [], []
|
||||
for path in (images or [])[:MAX_RESULTS]:
|
||||
item = _output_media(path)
|
||||
(results.append(item) if item else missing.append(str(path)))
|
||||
now = time.time() if now is None else now
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "report", "kind": "note", "ok": True,
|
||||
"state": "done", "summary": "report", "text": _short(text, MAX_NOTE), "results": results}
|
||||
with _lock:
|
||||
task = current_task(client, now, session=session, task_id=task_id, follow_up=True)
|
||||
asked = next((item for item in task["steps"] if reply_to and item["id"] == reply_to and item.get("kind") == "user"), None)
|
||||
if reply_to and not asked:
|
||||
raise ValueError("reply_to is the id of the user's message or marks (user_messages[].id) in this task")
|
||||
if asked:
|
||||
step["reply_to"], asked["replied"] = asked["id"], step["id"]
|
||||
_add_step(task, step)
|
||||
if done:
|
||||
task["ended"] = now
|
||||
_save(task)
|
||||
_notify(task["id"])
|
||||
return step, missing
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- the page's view
|
||||
|
||||
def task_summary(task, now=None):
|
||||
now = time.time() if now is None else now
|
||||
steps = task.get("steps") or []
|
||||
kinds = {}
|
||||
for step in steps:
|
||||
kinds[step["kind"]] = kinds.get(step["kind"], 0) + 1
|
||||
images = [item for step in steps for item in step.get("results") or [] if item.get("type") == "image"]
|
||||
asks = sum(1 for step in steps if step.get("kind") == "panel" and not step["panel"].get("closed")
|
||||
for block in step["panel"]["blocks"] if block.get("type") in ("choices", "input", "picks")
|
||||
and block.get("id") and block["id"] not in step.get("answers", {}))
|
||||
asks += sum(1 for step in steps if step.get("state") == "asking")
|
||||
return {
|
||||
"id": task["id"], "title": task.get("title") or "", "client": task.get("client") or ("" if task.get("waiting") else "AI"),
|
||||
"started": task.get("started"), "updated": task.get("updated"), "ended": task.get("ended"),
|
||||
"waiting": bool(task.get("waiting")) and not task.get("ended"),
|
||||
"live": any(step.get("state") == "running" and now - step.get("at", 0) < RUN_WATCH_SECONDS for step in steps),
|
||||
"steps": len(steps), "kinds": kinds, "errors": unresolved(steps),
|
||||
"images": len(images), "cover": images[-1] if images else None, "asks": asks, "from": task.get("from"),
|
||||
}
|
||||
|
||||
|
||||
def list_tasks(limit=100):
|
||||
with _lock:
|
||||
tasks = sorted(_load().values(), key=lambda task: task.get("updated", 0), reverse=True)
|
||||
return [task_summary(task) for task in tasks[:limit]]
|
||||
|
||||
|
||||
def get_task(task_id):
|
||||
with _lock:
|
||||
task = _load().get(task_id)
|
||||
return json.loads(json.dumps(task)) if task else None
|
||||
|
||||
|
||||
def rename_task(task_id, title):
|
||||
with _lock:
|
||||
task = _load().get(task_id)
|
||||
if not task:
|
||||
return None
|
||||
task["title"] = _short(str(title or "").strip(), MAX_TITLE)
|
||||
task["title_from"] = "user" if task["title"] else "auto"
|
||||
_save(task)
|
||||
return task
|
||||
|
||||
|
||||
def remove_task(task_id):
|
||||
with _lock:
|
||||
task = _load().pop(task_id, None)
|
||||
if not task:
|
||||
return False
|
||||
for client, current in list(_current.items()):
|
||||
if current == task_id:
|
||||
_current.pop(client, None)
|
||||
if _waiting[0] == task_id:
|
||||
_waiting[0] = None
|
||||
_forget(task_id)
|
||||
return True
|
||||
@@ -0,0 +1,291 @@
|
||||
"""The AI workbench's routes over ai_tasks.py (the record) and ai_panels.py (panels, answers,
|
||||
messages): the list and one task (reads, open like the other pages), and the writes the page
|
||||
makes - start a task, rename or remove one, answer a panel, write to the AI, answer a gate and
|
||||
set the gates' policies (ai_gates.py), stop a run (ai_run_control.py), hand the AI pictures
|
||||
(ai_pictures.py) - (local_guard.py keeps the writes to this computer)."""
|
||||
|
||||
import asyncio
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from . import activity_log, ai_decisions, ai_gates, ai_marks, ai_pictures, ai_run_control, ai_task_canvas, ai_task_changes, ai_task_links, ai_tasks, ai_toolbox
|
||||
|
||||
|
||||
async def api_list(request):
|
||||
try:
|
||||
limit = max(1, min(300, int(request.query.get("limit", 100))))
|
||||
except ValueError:
|
||||
limit = 100
|
||||
return web.json_response({"tasks": ai_tasks.list_tasks(limit)})
|
||||
|
||||
|
||||
async def api_start(request):
|
||||
"""POST /anomalous/ai_tasks: {title, about?, from?} - the user starts a task for the next AI app that
|
||||
calls; `about` names what it is about ([{type: model | image | combo, model_id | image | name}]),
|
||||
`from` the task it goes on from."""
|
||||
try:
|
||||
body = await request.json()
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
body = {}
|
||||
body = body if isinstance(body, dict) else {}
|
||||
title = body.get("title") if isinstance(body.get("title"), str) else ""
|
||||
parent = body.get("from") if isinstance(body.get("from"), str) else None
|
||||
return web.json_response({"task": ai_tasks.task_summary(ai_tasks.start_task(title, about=body.get("about"), from_task=parent))})
|
||||
|
||||
|
||||
async def api_get(request):
|
||||
task = ai_tasks.get_task(request.match_info["task_id"])
|
||||
if task:
|
||||
task["canvas_mode"] = ai_task_canvas.mode_of(task) # the task's own choice, else the user's default
|
||||
task["decisions"], task["decisions_gap"] = ai_decisions.decisions(task), ai_decisions.gap(task)
|
||||
task["links"] = ai_task_links.links(task["id"]) # the task it goes on from, those going on from it
|
||||
ai_pictures.mark_gone(task) # pictures deleted since: the page says so
|
||||
return web.json_response({"task": task}) if task else web.json_response({"error": "not_found"}, status=404)
|
||||
|
||||
|
||||
async def api_change(request):
|
||||
"""POST /anomalous/ai_tasks/{id}: {"title": "…"} renames it, {"remove": true} takes it off the list,
|
||||
{"canvas": "new" | "current"} sets whether the AI works in a tab of the task's own, {"from": id | null}
|
||||
links it to the task it goes on from (or takes the link off)."""
|
||||
task_id = request.match_info["task_id"]
|
||||
try:
|
||||
body = await request.json()
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
body = None
|
||||
if not isinstance(body, dict):
|
||||
return web.json_response({"error": "Expected {title} or {remove: true}"}, status=400)
|
||||
if body.get("remove") is True:
|
||||
return web.json_response({"removed": ai_tasks.remove_task(task_id)})
|
||||
if "canvas" in body:
|
||||
try:
|
||||
return web.json_response({"canvas": ai_task_canvas.set_mode(task_id, body["canvas"])})
|
||||
except ValueError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
if "from" in body:
|
||||
try:
|
||||
return web.json_response({"from": ai_task_links.set_from(task_id, body["from"] if isinstance(body["from"], str) else None)})
|
||||
except ai_task_links.LinkError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
if "title" in body:
|
||||
task = ai_tasks.rename_task(task_id, body["title"])
|
||||
return web.json_response({"task": ai_tasks.task_summary(task)}) if task else web.json_response({"error": "not_found"}, status=404)
|
||||
return web.json_response({"error": "Expected {title} or {remove: true}"}, status=400)
|
||||
|
||||
|
||||
async def api_answer(request):
|
||||
"""POST /anomalous/ai_tasks/{id}/answer: {step, block, choice: [ids] | text | skip: true} - the user's answer on a panel."""
|
||||
from . import ai_panels, ai_repaint
|
||||
|
||||
try:
|
||||
body = await request.json()
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
body = None
|
||||
if not isinstance(body, dict):
|
||||
return web.json_response({"error": "Expected {step, block, choice | text}"}, status=400)
|
||||
task_id, step_id, skip = request.match_info["task_id"], str(body.get("step")), body.get("skip") is True
|
||||
try:
|
||||
# A repaint area picked: its picture is made first (outside the lock), so the AI gets it with the answer.
|
||||
extra = await asyncio.to_thread(ai_repaint.prepare, task_id, step_id, body.get("choice"), body.get("text"), skip)
|
||||
except ai_repaint.RepaintError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
try:
|
||||
answers = ai_panels.answer(task_id, step_id, str(body.get("block")), body.get("choice"), body.get("text"), skip=skip, extra=extra)
|
||||
except ai_panels.PanelError as error:
|
||||
ai_repaint.discard(extra)
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
return web.json_response({"answers": answers})
|
||||
|
||||
|
||||
async def api_typing(request):
|
||||
"""POST /anomalous/ai_tasks/{id}/typing: the user is typing an answer or a message (ai_answer_wait.py)."""
|
||||
from . import ai_answer_wait
|
||||
|
||||
if not ai_answer_wait.typing(request.match_info["task_id"]):
|
||||
return web.json_response({"error": "not_found"}, status=404)
|
||||
return web.json_response({"ok": True})
|
||||
|
||||
|
||||
async def api_message(request):
|
||||
"""POST /anomalous/ai_tasks/{id}/message: {text, refs?} - the user writes to the AI on that task (refs: its "@")."""
|
||||
from . import ai_panels
|
||||
|
||||
try:
|
||||
body = await request.json()
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
body = None
|
||||
if not isinstance(body, dict):
|
||||
return web.json_response({"error": "Expected {text}"}, status=400)
|
||||
try:
|
||||
step = ai_panels.leave_message(request.match_info["task_id"], body.get("text"), body.get("refs"))
|
||||
except ai_panels.PanelError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
return web.json_response({"step": step})
|
||||
|
||||
|
||||
async def _body(request):
|
||||
try:
|
||||
body = await request.json()
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
return None
|
||||
return body if isinstance(body, dict) else None
|
||||
|
||||
|
||||
async def api_gate(request):
|
||||
"""POST /anomalous/ai_tasks/{id}/gate: {step, decision: allow | deny, text?, remember?}."""
|
||||
body = await _body(request)
|
||||
if body is None:
|
||||
return web.json_response({"error": "Expected {step, decision}"}, status=400)
|
||||
try:
|
||||
step = ai_gates.decide(request.match_info["task_id"], str(body.get("step")), body.get("decision"),
|
||||
body.get("text") or "", bool(body.get("remember")))
|
||||
except ValueError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
return web.json_response({"step": step})
|
||||
|
||||
|
||||
async def api_gates(request):
|
||||
"""GET /anomalous/ai_gates: {policies: {gate: policy}, canvas_tab, tools}; POST {gate, policy} changes one,
|
||||
POST {canvas_tab: new | current} whether new tasks work in a tab of their own (ai_task_canvas.py),
|
||||
POST {runs: call | wait}
|
||||
how the AI waits for a run (ai_gates.run_wait), POST {answer_wait: 60 | 180 | 600} for the user's answer,
|
||||
POST {no_answer: stop | recommended} what happens when that time runs out."""
|
||||
def settings():
|
||||
return {"policies": ai_gates.policies(), "canvas_tab": ai_task_canvas.default_mode(),
|
||||
"runs": ai_gates.run_wait(), "answer_wait": ai_gates.answer_wait(), "no_answer": ai_gates.no_answer()}
|
||||
|
||||
if request.method == "GET":
|
||||
return web.json_response(settings())
|
||||
body = await _body(request)
|
||||
try:
|
||||
if "canvas_tab" in (body or {}):
|
||||
ai_task_canvas.set_default(body["canvas_tab"])
|
||||
elif "runs" in (body or {}):
|
||||
ai_gates.set_run_wait(body["runs"])
|
||||
elif "answer_wait" in (body or {}):
|
||||
ai_gates.set_answer_wait(body["answer_wait"])
|
||||
elif "no_answer" in (body or {}):
|
||||
ai_gates.set_no_answer(body["no_answer"])
|
||||
else:
|
||||
ai_gates.set_policy((body or {}).get("gate"), (body or {}).get("policy"))
|
||||
except ValueError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
return web.json_response(settings())
|
||||
|
||||
|
||||
async def api_marks(request):
|
||||
"""POST /anomalous/ai_tasks/{id}/marks: {image, png, marks, text, mode, mask} - the user's marks on a picture for the AI."""
|
||||
from . import ai_panels
|
||||
|
||||
body = await _body(request)
|
||||
if body is None:
|
||||
return web.json_response({"error": "Expected {image, png, marks}"}, status=400)
|
||||
try:
|
||||
step = await asyncio.to_thread(ai_marks.save, request.match_info["task_id"], body.get("image"),
|
||||
body.get("png"), body.get("marks"), body.get("text"), None, body.get("mask"), body.get("mode"))
|
||||
except ai_marks.MarksError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
ai_panels.wake()
|
||||
return web.json_response({"step": step})
|
||||
|
||||
|
||||
async def api_marked(request):
|
||||
"""GET /anomalous/ai_tasks/{id}/marks/{name}: a marked picture the user sent."""
|
||||
path = ai_marks.path_of(request.match_info["task_id"], request.match_info["name"])
|
||||
if not path:
|
||||
return web.json_response({"error": "Not found"}, status=404)
|
||||
return web.FileResponse(path, headers={"Cache-Control": "private, max-age=86400"})
|
||||
|
||||
|
||||
async def api_toolbox_pick(request):
|
||||
"""POST /anomalous/ai_tasks/{id}/toolbox: {mode, nodes, combos, workflows, prompts, models} - what the user hands the AI."""
|
||||
from . import ai_panels
|
||||
|
||||
body = await _body(request)
|
||||
try:
|
||||
step = ai_toolbox.pick(request.match_info["task_id"], body if body is not None else None, (body or {}).get("mode", "prefer"))
|
||||
except ai_toolbox.ToolboxError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
ai_panels.wake()
|
||||
return web.json_response({"step": step})
|
||||
|
||||
|
||||
async def api_pictures(request):
|
||||
"""POST /anomalous/ai_tasks/{id}/pictures: {images: ["subfolder/name.png"], text?} - the user hands the AI pictures."""
|
||||
from . import ai_panels, ai_pictures
|
||||
|
||||
body = await _body(request)
|
||||
try:
|
||||
step = await asyncio.to_thread(ai_pictures.hand, request.match_info["task_id"], (body or {}).get("images"), (body or {}).get("text") or "")
|
||||
except ai_pictures.PicturesError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
ai_panels.wake()
|
||||
return web.json_response({"step": step})
|
||||
|
||||
|
||||
async def api_upload(request):
|
||||
"""POST /anomalous/ai_pictures/upload?name= with a picture's bytes - one the user dropped or pasted
|
||||
into a message, kept in the output folder (ai_pictures.save_upload): {image, filename, subfolder}."""
|
||||
from . import ai_pictures
|
||||
|
||||
data = await request.read()
|
||||
try:
|
||||
image = await asyncio.to_thread(ai_pictures.save_upload, data, request.query.get("name", ""))
|
||||
except ai_pictures.PicturesError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
except OSError as error:
|
||||
return web.json_response({"error": f"Could not keep the picture: {error}"}, status=500)
|
||||
subfolder, _, filename = image.rpartition("/")
|
||||
return web.json_response({"image": image, "filename": filename, "subfolder": subfolder})
|
||||
|
||||
|
||||
async def api_stop(request):
|
||||
"""POST /anomalous/ai_tasks/{id}/runs/{step}/stop - the user stops a run the AI started."""
|
||||
from . import ai_panels
|
||||
|
||||
try:
|
||||
answer = await asyncio.to_thread(ai_run_control.stop, request.match_info["step_id"], "user", request.match_info["task_id"])
|
||||
except ai_run_control.RunControlError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
ai_panels.wake()
|
||||
return web.json_response(answer)
|
||||
|
||||
|
||||
async def api_toolbox(request):
|
||||
"""GET /anomalous/ai_toolbox?kind=all: what the picker lists; GET/POST /anomalous/ai_toolbox/favorites."""
|
||||
if request.path.endswith("/favorites"):
|
||||
if request.method == "GET":
|
||||
return web.json_response({"favorites": ai_toolbox.favorites()})
|
||||
body = await _body(request)
|
||||
try:
|
||||
return web.json_response({"favorites": ai_toolbox.set_favorites(body if body is not None else None)})
|
||||
except ai_toolbox.ToolboxError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
try:
|
||||
return web.json_response(await asyncio.to_thread(ai_toolbox.catalog, request.query.get("kind", "")))
|
||||
except ai_toolbox.ToolboxError as error:
|
||||
return web.json_response({"error": str(error)}, status=400)
|
||||
except Exception as error: # noqa: BLE001 - ComfyUI's node list or a store unreadable: say so to the page
|
||||
return web.json_response({"error": str(error)}, status=502)
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
activity_log.add_listener(ai_task_changes.note_activity) # the user's changes while an AI works
|
||||
app.router.add_get("/anomalous/ai_tasks", api_list)
|
||||
app.router.add_post("/anomalous/ai_tasks", api_start)
|
||||
app.router.add_get("/anomalous/ai_tasks/{task_id}", api_get)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}", api_change)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}/answer", api_answer)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}/message", api_message)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}/typing", api_typing)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}/gate", api_gate)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}/marks", api_marks)
|
||||
app.router.add_get("/anomalous/ai_tasks/{task_id}/marks/{name}", api_marked)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}/toolbox", api_toolbox_pick)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}/runs/{step_id}/stop", api_stop)
|
||||
app.router.add_post("/anomalous/ai_tasks/{task_id}/pictures", api_pictures)
|
||||
app.router.add_post("/anomalous/ai_pictures/upload", api_upload)
|
||||
app.router.add_get("/anomalous/ai_toolbox", api_toolbox)
|
||||
app.router.add_get("/anomalous/ai_toolbox/favorites", api_toolbox)
|
||||
app.router.add_post("/anomalous/ai_toolbox/favorites", api_toolbox)
|
||||
app.router.add_get("/anomalous/ai_gates", api_gates)
|
||||
app.router.add_post("/anomalous/ai_gates", api_gates)
|
||||
@@ -0,0 +1,155 @@
|
||||
"""What the user hands the AI to work with ("给 AI 的素材", web/modules/ui_ai_toolbox.js): node
|
||||
types, whole custom node packs (by folder: every node type in it), combos, workflows, saved
|
||||
prompts and models picked for a task, and how strictly: prefer
|
||||
(the AI is told to use them first) or only (add_node and new_workflow refuse other node types,
|
||||
except ComfyUI's own built-in ones and the helpers that live only in the page). Favourites
|
||||
(user/anomalous/ai_toolbox.json) are what a task has until the user picks for it. A pick is a
|
||||
"user_toolbox" step the AI receives like a message (kind toolbox, ai_panels.py); begin_task
|
||||
names the task's picks and get_toolbox gives them in full. The catalogue the picker shows uses
|
||||
the same names the AI's tools use: node types from ComfyUI's /object_info (mcp_canvas_edit.py),
|
||||
the rest from ai_toolbox_catalog.py."""
|
||||
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from . import ai_tasks
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
KINDS = ("nodes", "packs", "combos", "workflows", "prompts", "models")
|
||||
MODES = ("prefer", "only")
|
||||
MAX_ITEMS = 60
|
||||
MAX_NAME = 300
|
||||
_lock = threading.Lock()
|
||||
|
||||
|
||||
class ToolboxError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def _path():
|
||||
return os.path.join(os.path.dirname(ai_tasks.tasks_dir()), "ai_toolbox.json")
|
||||
|
||||
|
||||
def clean(picks):
|
||||
"""{kind: [names]} for KINDS: strings only, each kind once per name, at most MAX_ITEMS."""
|
||||
if not isinstance(picks, dict):
|
||||
raise ToolboxError("Expected {nodes, packs, combos, workflows, prompts, models}")
|
||||
out = {}
|
||||
for kind in KINDS:
|
||||
items = picks.get(kind) or []
|
||||
if not isinstance(items, list) or len(items) > MAX_ITEMS:
|
||||
raise ToolboxError(f"{kind}: a list of up to {MAX_ITEMS} names")
|
||||
names = []
|
||||
for item in items:
|
||||
if not isinstance(item, str) or not item.strip() or len(item) > MAX_NAME:
|
||||
raise ToolboxError(f"{kind}: names are text of up to {MAX_NAME} characters")
|
||||
if item.strip() not in names:
|
||||
names.append(item.strip())
|
||||
out[kind] = names
|
||||
return out
|
||||
|
||||
|
||||
def count(box):
|
||||
return sum(len((box or {}).get(kind) or []) for kind in KINDS)
|
||||
|
||||
|
||||
def favorites():
|
||||
try:
|
||||
with open(_path(), encoding="utf-8") as source:
|
||||
return clean(json.load(source))
|
||||
except (OSError, ValueError):
|
||||
return clean({})
|
||||
|
||||
|
||||
def set_favorites(picks):
|
||||
picks = clean(picks)
|
||||
with _lock:
|
||||
atomic_write_json(_path(), picks)
|
||||
return picks
|
||||
|
||||
|
||||
def effective(task):
|
||||
"""The task's picks ({mode, kinds…, "from": task|favorites}), or None when it has none."""
|
||||
box = (task or {}).get("toolbox")
|
||||
if box:
|
||||
return {**box, "from": "task"}
|
||||
liked = favorites()
|
||||
return {"mode": "prefer", **liked, "from": "favorites"} if count(liked) else None
|
||||
|
||||
|
||||
def words(box):
|
||||
"""The picks in a sentence or two for the AI."""
|
||||
parts = []
|
||||
labels = {"nodes": "node types", "packs": "custom node packs (every node type in these folders; get_toolbox lists them)",
|
||||
"combos": "combos (place_combo)", "workflows": "workflows (open_workflow opens one in a new tab)",
|
||||
"prompts": "prompts (combo:<name> / workflow:<name> are the prompts inside that combo or workflow)",
|
||||
"models": "models (model_id for set_model / add_lora / get_model)"}
|
||||
for kind in KINDS:
|
||||
if box.get(kind):
|
||||
parts.append(f"{labels[kind]}: {', '.join(box[kind])}")
|
||||
how = ("Use ONLY these node types (and those of the picked packs) when you add nodes; ComfyUI's own built-in nodes stay allowed. "
|
||||
if box.get("mode") == "only" else "Use these first. ")
|
||||
return f"The user picked these for you to work with. {how}{'; '.join(parts)}. get_toolbox gives them in full."
|
||||
|
||||
|
||||
def pick(task_id, picks, mode="prefer", now=None):
|
||||
"""The user's picks for task `task_id`: kept on the task and given to the AI as a step. Returns the step."""
|
||||
if mode not in MODES:
|
||||
raise ToolboxError("mode is prefer or only")
|
||||
picks = clean(picks)
|
||||
now = time.time() if now is None else now
|
||||
box = {"mode": mode, **picks}
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
if not task:
|
||||
raise ToolboxError("No such task")
|
||||
task["toolbox"] = box
|
||||
step = {"id": uuid.uuid4().hex[:10], "at": now, "ms": 0, "tool": "user_toolbox", "kind": "user", "ok": True,
|
||||
"state": "done", "summary": "user_toolbox", "toolbox": box,
|
||||
"text": words(box) if count(box) else "The user took back the things they picked for you; use what fits.",
|
||||
"delivered": False, "results": []}
|
||||
task["steps"].append(step)
|
||||
del task["steps"][:-ai_tasks.MAX_STEPS]
|
||||
task["updated"] = max(task.get("updated", 0), now)
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
return step
|
||||
|
||||
|
||||
def builtin(info):
|
||||
"""Whether a node type (its /object_info entry) is ComfyUI's own and free: not a custom node, not a paid API node."""
|
||||
module = str((info or {}).get("python_module") or "")
|
||||
return module == "nodes" or module.startswith("comfy_extras")
|
||||
|
||||
|
||||
def chosen(box, name, info):
|
||||
"""Whether node type `name` (its /object_info entry) is among picks `box`: itself, or its pack."""
|
||||
return bool(box) and (name in (box.get("nodes") or []) or source_of(info) in (box.get("packs") or []))
|
||||
|
||||
|
||||
def refused(task_id, types, info):
|
||||
"""The node types among `types` the task's "only" picks do not allow (page-only helpers, unknown to /object_info, pass)."""
|
||||
box = effective(ai_tasks.get_task(task_id)) if task_id else None
|
||||
if not box or box.get("mode") != "only":
|
||||
return []
|
||||
return sorted({name for name in types if name in info and not chosen(box, name, info[name]) and not builtin(info[name])})
|
||||
|
||||
|
||||
def source_of(info):
|
||||
"""Where a node type comes from: its custom node folder, "builtin", or "api" (paid API nodes)."""
|
||||
module = str((info or {}).get("python_module") or "")
|
||||
if module.startswith("custom_nodes."):
|
||||
return module.split(".")[1]
|
||||
return "api" if module.startswith("comfy_api_nodes") else "builtin"
|
||||
|
||||
|
||||
def catalog(kind):
|
||||
"""What the picker lists besides node types (ai_toolbox_catalog.py); the page has those itself."""
|
||||
from .ai_toolbox_catalog import everything
|
||||
|
||||
if kind != "all":
|
||||
raise ToolboxError("kind is all; node types come from the page")
|
||||
return everything()
|
||||
@@ -0,0 +1,86 @@
|
||||
"""Everything the materials picker (web/modules/ui_ai_toolbox.js) lists besides node types, in
|
||||
one answer (GET /anomalous/ai_toolbox?kind=all): combos with their cover and prompt, saved
|
||||
workflows with their cover, tags and prompts, prompts (the saved ones, and the ones inside
|
||||
combos and workflows, ids "combo:<name>" and "workflow:<name>"), and models with their cover,
|
||||
by the names and ids the AI's tools use. Read in one go and kept a few seconds, so the picker
|
||||
opens at once; node types come from the page's own node definitions. prompt_entries() also
|
||||
gives get_toolbox the text of picked prompts."""
|
||||
|
||||
import threading
|
||||
import time
|
||||
|
||||
from . import mcp_tools
|
||||
from .model_catalog import _collect_all_scan_models
|
||||
from .notebooks import _list_notebooks
|
||||
from .quick_index import compact_models
|
||||
from .recipe_store import _list_recipes, get_recipes_dir
|
||||
|
||||
CACHE_SECONDS = 15
|
||||
MAX_TEXT = 1500
|
||||
MAX_THUMBNAIL = 60_000 # an inline thumbnail larger than this is left out; the cover asset or the default stands in
|
||||
_cache = {"at": 0.0, "data": None}
|
||||
_lock = threading.Lock()
|
||||
|
||||
|
||||
def _join(texts, limit=MAX_TEXT):
|
||||
text = "\n".join(str(item).strip() for item in texts or [] if str(item or "").strip())
|
||||
return text if len(text) <= limit else text[:limit] + "…"
|
||||
|
||||
|
||||
def _combos():
|
||||
out = []
|
||||
for note in _list_notebooks():
|
||||
data = note.get("data") or {}
|
||||
combo, loras = mcp_tools.combo_view(note)
|
||||
out.append({"name": combo["name"], "model": combo["main_model"], "loras": loras[:12], "base": combo.get("base_model") or "",
|
||||
"prompt": combo["prompt"], "structure": data.get("kind") == "nodes",
|
||||
"cover": (data.get("mainModel") or {}).get("preview_url") or "" if isinstance(data.get("mainModel"), dict) else "",
|
||||
"image": data.get("source_image") if isinstance(data.get("source_image"), dict) else None})
|
||||
return out
|
||||
|
||||
|
||||
def _workflows():
|
||||
out = []
|
||||
for recipe in _list_recipes(get_recipes_dir()):
|
||||
data = recipe.get("data") or {}
|
||||
params = data.get("params") if isinstance(data.get("params"), dict) else {}
|
||||
thumbnail = data.get("thumbnail") if isinstance(data.get("thumbnail"), str) and len(data["thumbnail"]) <= MAX_THUMBNAIL else None
|
||||
out.append({"name": data.get("name") or recipe["filename"], "filename": recipe["filename"], "tags": (data.get("tags") or [])[:8],
|
||||
"notes": str(data.get("notes") or "")[:300], "partial": data.get("workflow_scope") == "partial",
|
||||
"nodes": len(params.get("nodes") or []), "base": params.get("baseModel") or "",
|
||||
"prompt": _join(params.get("promptPositive")), "negative": _join(params.get("promptNegative"), 600),
|
||||
"cover_asset": (data.get("presentation") or {}).get("cover_asset_id"), "thumbnail": thumbnail,
|
||||
"image": data.get("source_image") if isinstance(data.get("source_image"), dict) else None,
|
||||
"saved": data.get("timestamp") or 0})
|
||||
return out
|
||||
|
||||
|
||||
def _models():
|
||||
out = []
|
||||
for model in compact_models(_collect_all_scan_models(1, 0).get("models") or []):
|
||||
place = f"{model['subfolder']}/{model['filename']}" if model["subfolder"] else model["filename"]
|
||||
out.append({"id": f"{model['type']}:{model['path_idx']}:{place}", "name": model["name"] or model["civitai_name"] or model["filename"],
|
||||
"file": model["filename"], "type": model["type"], "base": model["base"], "words": model["words"],
|
||||
"cover": model["preview_url"], "folder": model["subfolder"]})
|
||||
return out
|
||||
|
||||
|
||||
def prompt_entries(combos, workflows):
|
||||
"""The prompts the picker lists: saved ones (id = name), then those of combos and workflows."""
|
||||
entries = [{"id": prompt["name"], "name": prompt["name"], "source": "saved", "tags": prompt["tags"],
|
||||
"positive": prompt["positive"], "negative": prompt["negative"]} for prompt in mcp_tools.saved_prompts()]
|
||||
entries += [{"id": f"combo:{combo['name']}", "name": combo["name"], "source": "combo", "tags": [],
|
||||
"positive": combo["prompt"], "negative": ""} for combo in combos if combo["prompt"]]
|
||||
entries += [{"id": f"workflow:{flow['name']}", "name": flow["name"], "source": "workflow", "tags": flow["tags"],
|
||||
"positive": flow["prompt"], "negative": flow["negative"]} for flow in workflows if flow["prompt"] or flow["negative"]]
|
||||
return entries
|
||||
|
||||
|
||||
def everything(fresh=False):
|
||||
"""{combos, workflows, prompts, models}, read at most every CACHE_SECONDS."""
|
||||
with _lock:
|
||||
if fresh or _cache["data"] is None or time.monotonic() - _cache["at"] > CACHE_SECONDS:
|
||||
combos, workflows = _combos(), _workflows()
|
||||
_cache.update(at=time.monotonic(), data={"combos": combos, "workflows": workflows,
|
||||
"prompts": prompt_entries(combos, workflows), "models": _models()})
|
||||
return _cache["data"]
|
||||
@@ -0,0 +1,256 @@
|
||||
"""Generated audio: the audio gallery, Preview Audio results, and streaming them."""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import shutil
|
||||
import time
|
||||
from urllib.parse import quote
|
||||
|
||||
import folder_paths
|
||||
from aiohttp import web
|
||||
|
||||
from .audio_metadata import generation_info
|
||||
from .path_utils import resolve_within
|
||||
from .trash import move_to_trash, trash_failure
|
||||
|
||||
AUDIO_EXTENSIONS = {'.wav', '.mp3', '.flac', '.ogg', '.opus', '.m4a'}
|
||||
AUDIO_CONTENT_TYPES = {
|
||||
'.wav': 'audio/wav',
|
||||
'.mp3': 'audio/mpeg',
|
||||
'.flac': 'audio/flac',
|
||||
'.ogg': 'audio/ogg',
|
||||
'.opus': 'audio/ogg',
|
||||
'.m4a': 'audio/mp4',
|
||||
}
|
||||
AUDIO_ROOTS = {
|
||||
"output": lambda: folder_paths.get_output_directory(),
|
||||
"temp": lambda: folder_paths.get_temp_directory(),
|
||||
}
|
||||
PREVIEW_LIMIT = 30
|
||||
SAVED_PREVIEW_SUBFOLDER = "audio"
|
||||
# Revalidate instead of forbidding caches: overwritten files get a new ?v=mtime URL.
|
||||
AUDIO_CACHE_HEADERS = {"Cache-Control": "no-cache"}
|
||||
|
||||
|
||||
def _audio_url(rel_path, dir_type, version):
|
||||
return f"/anomalous/audio_stream?path={quote(rel_path, safe='/')}&type={dir_type}&v={int(version)}"
|
||||
|
||||
|
||||
async def api_serve_audio(request):
|
||||
"""GET /anomalous/audio_stream?path=...&type=output|temp - Stream an audio file."""
|
||||
rel_path = request.query.get("path", "").strip("/\\")
|
||||
dir_type = request.query.get("type", "output")
|
||||
if not rel_path:
|
||||
return web.Response(status=400, text="Missing audio path")
|
||||
if dir_type not in AUDIO_ROOTS:
|
||||
return web.Response(status=400, text="Unknown audio folder")
|
||||
|
||||
base_dir = AUDIO_ROOTS[dir_type]()
|
||||
try:
|
||||
resolved_path = resolve_within(base_dir, rel_path)
|
||||
except ValueError:
|
||||
return web.Response(status=403, text="Forbidden path")
|
||||
|
||||
ext = os.path.splitext(resolved_path)[1].lower()
|
||||
if ext not in AUDIO_EXTENSIONS:
|
||||
return web.Response(status=415, text="Not an audio file")
|
||||
if not os.path.isfile(resolved_path):
|
||||
return web.Response(status=404, text="Audio file not found")
|
||||
|
||||
return web.FileResponse(resolved_path, headers={"Content-Type": AUDIO_CONTENT_TYPES[ext], **AUDIO_CACHE_HEADERS})
|
||||
|
||||
|
||||
def _collect_audio_files(root_dir, dir_type):
|
||||
"""Scan a folder tree for audio files, newest first."""
|
||||
audios = []
|
||||
if not os.path.isdir(root_dir):
|
||||
return audios
|
||||
|
||||
for root, _, files in os.walk(root_dir):
|
||||
for name in files:
|
||||
if os.path.splitext(name)[1].lower() not in AUDIO_EXTENSIONS:
|
||||
continue
|
||||
try:
|
||||
stat = os.stat(os.path.join(root, name))
|
||||
except OSError:
|
||||
continue
|
||||
subfolder = os.path.relpath(root, root_dir)
|
||||
clean_sub = "" if subfolder == "." else subfolder.replace(os.sep, '/')
|
||||
rel_path = "/".join(part for part in (clean_sub, name) if part)
|
||||
audios.append({
|
||||
"filename": name,
|
||||
"subfolder": clean_sub,
|
||||
"size_bytes": stat.st_size,
|
||||
"mtime": stat.st_mtime,
|
||||
"audio_url": _audio_url(rel_path, dir_type, stat.st_mtime),
|
||||
})
|
||||
audios.sort(key=lambda a: a["mtime"], reverse=True)
|
||||
return audios
|
||||
|
||||
|
||||
_info_cache = {}
|
||||
|
||||
|
||||
def _cached_generation_info(path, mtime, size):
|
||||
"""Generation info keyed by (mtime, size) so unchanged files are parsed once."""
|
||||
cached = _info_cache.get(path)
|
||||
if cached and cached[0] == (mtime, size):
|
||||
return cached[1]
|
||||
info = generation_info(path)
|
||||
if len(_info_cache) > 5000:
|
||||
_info_cache.clear()
|
||||
_info_cache[path] = ((mtime, size), info)
|
||||
return info
|
||||
|
||||
|
||||
def _attach_generation_info(root_dir, items):
|
||||
for item in items:
|
||||
path = os.path.join(root_dir, item["subfolder"], item["filename"])
|
||||
item["generation"] = _cached_generation_info(path, item["mtime"], item["size_bytes"])
|
||||
return items
|
||||
|
||||
|
||||
def _search_text(item):
|
||||
speech = (item.get("generation") or {}).get("speech") or ""
|
||||
return f"{item['subfolder']}/{item['filename']}\n{speech}".lower()
|
||||
|
||||
|
||||
def _gallery_page(output_dir, page, limit, query):
|
||||
all_audios = _collect_audio_files(output_dir, "output")
|
||||
if query:
|
||||
# Searching reads every file's comments once; the cache keeps later searches cheap.
|
||||
_attach_generation_info(output_dir, all_audios)
|
||||
all_audios = [item for item in all_audios if query in _search_text(item)]
|
||||
total = len(all_audios)
|
||||
start = (page - 1) * limit
|
||||
items = all_audios[start:start + limit]
|
||||
if not query:
|
||||
_attach_generation_info(output_dir, items)
|
||||
return items, total, start + limit < total
|
||||
|
||||
|
||||
def _positive_int(value, default, maximum=None):
|
||||
try:
|
||||
number = int(value)
|
||||
except (TypeError, ValueError):
|
||||
return default
|
||||
number = max(1, number)
|
||||
return min(maximum, number) if maximum else number
|
||||
|
||||
|
||||
async def api_get_audio_gallery(request):
|
||||
"""GET /anomalous/audio_gallery?page=1&limit=50&q=text - Generated audio in output, with the speech that produced it."""
|
||||
page = _positive_int(request.query.get("page"), 1)
|
||||
limit = _positive_int(request.query.get("limit"), 40, 100)
|
||||
query = request.query.get("q", "").strip().lower()
|
||||
|
||||
items, total, has_more = await asyncio.to_thread(_gallery_page, folder_paths.get_output_directory(), page, limit, query)
|
||||
return web.json_response({
|
||||
"success": True,
|
||||
"audios": items,
|
||||
"total": total,
|
||||
"page": page,
|
||||
"has_more": has_more,
|
||||
})
|
||||
|
||||
|
||||
def _list_previews(temp_dir):
|
||||
items = _collect_audio_files(temp_dir, "temp")[:PREVIEW_LIMIT]
|
||||
return _attach_generation_info(temp_dir, items)
|
||||
|
||||
|
||||
async def api_get_audio_previews(request):
|
||||
"""GET /anomalous/audio_previews - Unsaved preview audio in ComfyUI's temp folder (cleared on restart)."""
|
||||
items = await asyncio.to_thread(_list_previews, folder_paths.get_temp_directory())
|
||||
return web.json_response({"success": True, "audios": items})
|
||||
|
||||
|
||||
def _save_preview(temp_dir, output_dir, subfolder, filename):
|
||||
source = resolve_within(temp_dir, subfolder, filename)
|
||||
ext = os.path.splitext(filename)[1].lower()
|
||||
if ext not in AUDIO_EXTENSIONS:
|
||||
raise ValueError("Only audio files can be saved")
|
||||
if not os.path.isfile(source):
|
||||
raise FileNotFoundError(filename)
|
||||
|
||||
dest_dir = resolve_within(output_dir, SAVED_PREVIEW_SUBFOLDER)
|
||||
os.makedirs(dest_dir, exist_ok=True)
|
||||
stamp = time.strftime("%Y%m%d-%H%M%S", time.localtime(os.path.getmtime(source)))
|
||||
for counter in range(1, 1000):
|
||||
name = f"Preview_{stamp}_{counter:02}{ext}"
|
||||
target = os.path.join(dest_dir, name)
|
||||
try:
|
||||
# O_EXCL: never overwrite an existing file in the library.
|
||||
fd = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0))
|
||||
except FileExistsError:
|
||||
continue
|
||||
try:
|
||||
with os.fdopen(fd, "wb") as out, open(source, "rb") as src:
|
||||
shutil.copyfileobj(src, out)
|
||||
except Exception:
|
||||
try:
|
||||
os.remove(target)
|
||||
except OSError:
|
||||
pass
|
||||
raise
|
||||
stat = os.stat(target)
|
||||
rel_path = f"{SAVED_PREVIEW_SUBFOLDER}/{name}"
|
||||
item = {
|
||||
"filename": name,
|
||||
"subfolder": SAVED_PREVIEW_SUBFOLDER,
|
||||
"size_bytes": stat.st_size,
|
||||
"mtime": stat.st_mtime,
|
||||
"audio_url": _audio_url(rel_path, "output", stat.st_mtime),
|
||||
}
|
||||
return _attach_generation_info(output_dir, [item])[0]
|
||||
raise FileExistsError("No free file name")
|
||||
|
||||
|
||||
async def api_save_audio_preview(request):
|
||||
"""POST /anomalous/save_audio_preview {filename, subfolder} - Copy a temp preview into output/audio."""
|
||||
try:
|
||||
data = await request.json()
|
||||
except Exception:
|
||||
return web.json_response({"success": False, "error": "Invalid JSON payload"}, status=400)
|
||||
filename = str(data.get("filename", "")).strip()
|
||||
subfolder = str(data.get("subfolder", "")).strip().strip("/\\")
|
||||
if not filename or os.path.basename(filename) != filename:
|
||||
return web.json_response({"success": False, "error": "Invalid filename"}, status=400)
|
||||
try:
|
||||
item = await asyncio.to_thread(
|
||||
_save_preview, folder_paths.get_temp_directory(), folder_paths.get_output_directory(), subfolder, filename)
|
||||
except ValueError as e:
|
||||
return web.json_response({"success": False, "error": str(e)}, status=403)
|
||||
except FileNotFoundError:
|
||||
return web.json_response({"success": False, "code": "missing", "error": "Preview no longer exists"}, status=404)
|
||||
except OSError as e:
|
||||
return web.json_response({"success": False, "error": f"Failed to save: {e}"}, status=500)
|
||||
return web.json_response({"success": True, "audio": item})
|
||||
|
||||
|
||||
async def api_delete_audio_gallery(request):
|
||||
"""POST /anomalous/delete_audio_gallery - Delete one generated audio file."""
|
||||
try:
|
||||
data = await request.json()
|
||||
except Exception:
|
||||
return web.json_response({"success": False, "error": "Invalid JSON payload"}, status=400)
|
||||
|
||||
filename = str(data.get("filename", "")).strip()
|
||||
subfolder = str(data.get("subfolder", "")).strip().strip("/\\")
|
||||
if not filename or os.path.basename(filename) != filename:
|
||||
return web.json_response({"success": False, "error": "Invalid filename"}, status=400)
|
||||
if os.path.splitext(filename)[1].lower() not in AUDIO_EXTENSIONS:
|
||||
return web.json_response({"success": False, "error": "Only audio files can be deleted here"}, status=415)
|
||||
|
||||
try:
|
||||
target = resolve_within(folder_paths.get_output_directory(), subfolder, filename)
|
||||
except ValueError:
|
||||
return web.json_response({"success": False, "error": "Forbidden path"}, status=403)
|
||||
|
||||
if not os.path.isfile(target):
|
||||
return web.json_response({"success": False, "error": "File not found"}, status=404)
|
||||
try:
|
||||
await asyncio.to_thread(move_to_trash, target)
|
||||
except OSError as e:
|
||||
return web.json_response({"success": False, "error": trash_failure(e)}, status=409)
|
||||
return web.json_response({"success": True})
|
||||
@@ -0,0 +1,136 @@
|
||||
"""Read ComfyUI generation info embedded in saved audio (FLAC and Ogg/Opus comments).
|
||||
|
||||
ComfyUI's audio save/preview nodes store the API prompt as a `prompt` comment.
|
||||
Only the fields the audio gallery shows are extracted; nothing is written.
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
|
||||
MAX_TAG_BYTES = 16 * 1024 * 1024
|
||||
MAX_OGG_SCAN_BYTES = 32 * 1024 * 1024
|
||||
SPEECH_INPUTS = ("speech", "text", "gen_text")
|
||||
# "character": Anomalous_TTS (GPT-SoVITS) names the voice by character instead of a file.
|
||||
SAMPLE_INPUTS = ("sample", "ref_audio", "audio_prompt", "character")
|
||||
|
||||
|
||||
def _parse_vorbis_comment(data, offset=0):
|
||||
"""Parse a Vorbis comment block into {lowercase key: value}."""
|
||||
tags = {}
|
||||
try:
|
||||
vendor_len = int.from_bytes(data[offset:offset + 4], "little")
|
||||
pos = offset + 4 + vendor_len
|
||||
count = int.from_bytes(data[pos:pos + 4], "little")
|
||||
pos += 4
|
||||
for _ in range(min(count, 1024)):
|
||||
length = int.from_bytes(data[pos:pos + 4], "little")
|
||||
pos += 4
|
||||
entry = data[pos:pos + length].decode("utf-8", "replace")
|
||||
pos += length
|
||||
key, sep, value = entry.partition("=")
|
||||
if sep:
|
||||
tags.setdefault(key.lower(), value)
|
||||
except (IndexError, ValueError):
|
||||
pass
|
||||
return tags
|
||||
|
||||
|
||||
def _flac_tags(handle):
|
||||
if handle.read(4) != b"fLaC":
|
||||
return {}
|
||||
while True:
|
||||
header = handle.read(4)
|
||||
if len(header) < 4:
|
||||
return {}
|
||||
is_last = header[0] & 0x80
|
||||
block_type = header[0] & 0x7F
|
||||
length = int.from_bytes(header[1:4], "big")
|
||||
if block_type == 4:
|
||||
if length > MAX_TAG_BYTES:
|
||||
return {}
|
||||
return _parse_vorbis_comment(handle.read(length))
|
||||
handle.seek(length, os.SEEK_CUR)
|
||||
if is_last:
|
||||
return {}
|
||||
|
||||
|
||||
def _ogg_packets(handle, wanted=2):
|
||||
"""Yield the first `wanted` logical packets of an Ogg stream."""
|
||||
packet = b""
|
||||
scanned = 0
|
||||
found = 0
|
||||
while found < wanted and scanned < MAX_OGG_SCAN_BYTES:
|
||||
header = handle.read(27)
|
||||
if len(header) < 27 or header[:4] != b"OggS":
|
||||
return
|
||||
segments = header[26]
|
||||
lacing = handle.read(segments)
|
||||
scanned += 27 + segments
|
||||
for size in lacing:
|
||||
packet += handle.read(size)
|
||||
scanned += size
|
||||
if size < 255:
|
||||
yield packet
|
||||
packet = b""
|
||||
found += 1
|
||||
if found >= wanted:
|
||||
return
|
||||
if len(packet) > MAX_TAG_BYTES:
|
||||
return
|
||||
|
||||
|
||||
def _ogg_tags(handle):
|
||||
packets = list(_ogg_packets(handle, wanted=2))
|
||||
if len(packets) < 2:
|
||||
return {}
|
||||
comment = packets[1]
|
||||
if comment.startswith(b"OpusTags"):
|
||||
return _parse_vorbis_comment(comment, 8)
|
||||
if comment.startswith(b"\x03vorbis"):
|
||||
return _parse_vorbis_comment(comment, 7)
|
||||
return {}
|
||||
|
||||
|
||||
def read_audio_tags(path):
|
||||
"""Return {lowercase key: value} comments for FLAC/Ogg/Opus files, else {}."""
|
||||
ext = os.path.splitext(path)[1].lower()
|
||||
try:
|
||||
with open(path, "rb") as handle:
|
||||
if ext == ".flac":
|
||||
return _flac_tags(handle)
|
||||
if ext in (".ogg", ".opus"):
|
||||
return _ogg_tags(handle)
|
||||
except OSError:
|
||||
pass
|
||||
return {}
|
||||
|
||||
|
||||
def generation_info(path):
|
||||
"""Speech text, sample voice and seed of the TTS node that produced this file, if recorded."""
|
||||
raw = read_audio_tags(path).get("prompt")
|
||||
if not raw:
|
||||
return None
|
||||
try:
|
||||
prompt = json.loads(raw)
|
||||
except ValueError:
|
||||
return None
|
||||
if not isinstance(prompt, dict):
|
||||
return None
|
||||
|
||||
nodes = [node for node in prompt.values() if isinstance(node, dict) and isinstance(node.get("inputs"), dict)]
|
||||
# Prefer TTS nodes; otherwise any node with a speech-like text input.
|
||||
nodes.sort(key=lambda node: "tts" not in str(node.get("class_type", "")).lower())
|
||||
for node in nodes:
|
||||
inputs = node["inputs"]
|
||||
speech = next((inputs[key] for key in SPEECH_INPUTS if isinstance(inputs.get(key), str) and inputs[key].strip()), None)
|
||||
if speech is None:
|
||||
continue
|
||||
sample = next((inputs[key] for key in SAMPLE_INPUTS if isinstance(inputs.get(key), str)), None)
|
||||
seed = inputs.get("seed")
|
||||
return {
|
||||
"node_type": str(node.get("class_type") or ""),
|
||||
"speech": speech[:4000],
|
||||
"sample": sample.replace("\\", "/") if sample else None,
|
||||
"seed": seed if isinstance(seed, (int, float)) else None,
|
||||
}
|
||||
return None
|
||||
+591
@@ -0,0 +1,591 @@
|
||||
"""Backups of the user's own data (Settings -> Backup): one .zip to keep anywhere (a cloud
|
||||
drive, a USB stick), and putting it back on this or another computer.
|
||||
|
||||
A backup holds the plugin's stores (Workflow Recipes, combos, materials and saved prompts,
|
||||
parameter sets), optionally ComfyUI's own saved workflows, the plugin settings without the
|
||||
Civitai key, what the user set on models: <model>.anomalous.json (name, notes, link) and
|
||||
the user's cover (any cover that is not a copy of Civitai's <model>.civitai_bak.*), what a
|
||||
scan found (<model>.info; Civitai's cover only when asked, it can be hundreds of MB), and the
|
||||
model list (each model's folder, path, size, SHA-256 and link) so the models a new computer
|
||||
lacks can be downloaded again. Models are found again by SHA-256, else by models folder, path
|
||||
and size, so they match after a move.
|
||||
|
||||
Putting back never erases: a file missing here is added; a file that differs stays unless
|
||||
"replace" is chosen, and then the one here goes to the Recycle Bin first. A model's user file
|
||||
is merged field by field (empty fields are filled; "replace" takes the backup's values), and
|
||||
the backup's cover takes the place of a Civitai cover (whose copy stays as civitai_bak).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import tempfile
|
||||
import time
|
||||
import uuid
|
||||
import zipfile
|
||||
|
||||
import folder_paths
|
||||
from aiohttp import web
|
||||
|
||||
from .activity_log import add_entry
|
||||
from .folder_types import config_path
|
||||
from .material_store import get_materials_dir
|
||||
from .metadata import USER_FIELDS, clear_metadata_cache, get_metadata
|
||||
from .model_constants import CIVITAI_BACKUP_SUFFIXES, MEDIA_EXTENSIONS, PREVIEW_SUFFIXES, RESOLVABLE_MODEL_TYPES, is_model_file
|
||||
from .model_download import settings_path as download_settings_path
|
||||
from .notebooks import get_notebooks_dir
|
||||
from .parameters import _invalidate_parameter_notebooks_cache, get_parameters_dir
|
||||
from .path_utils import atomic_write_json, require_filename, resolve_within
|
||||
from .recipe_store import get_recipes_dir
|
||||
from .trash import TrashUnavailable, move_to_trash, trash_failure
|
||||
from . import version_manager
|
||||
|
||||
try:
|
||||
from ..model_identity import USER_INFO_SUFFIX, read_json, scan_info_path
|
||||
from .. import model_sidecars as sidecars
|
||||
except ImportError:
|
||||
from model_identity import USER_INFO_SUFFIX, read_json, scan_info_path
|
||||
import model_sidecars as sidecars
|
||||
|
||||
FORMAT = 1
|
||||
APP = "Anomalous Model Browser"
|
||||
ACTIVE_COVER_SUFFIXES = PREVIEW_SUFFIXES + MEDIA_EXTENSIONS # as scraper.py: <model>.preview.png or <model>.png
|
||||
SECRET_KEYS = {"CIVITAI_API_KEY", "DEEPL_API_KEY"} # never leave this computer
|
||||
SCAN_INFO_SUFFIXES = (".info", ".civitai.info")
|
||||
SKIP_FILES = {".legacy_imported.json"} # this computer's own migration marker
|
||||
MAX_BACKUP_BYTES = 4 * 1024 ** 3 # unpacked size of a backup that is still read
|
||||
MAX_MEMBERS = 200_000
|
||||
KEEP_EXPORTS = 3 # finished exports kept in the temp folder for downloading
|
||||
CHUNK = 1024 * 1024
|
||||
|
||||
PART_ORDER = ("recipes", "combos", "materials", "parameters", "comfy_workflows")
|
||||
|
||||
|
||||
def _comfy_workflows_dir():
|
||||
return os.path.join(folder_paths.get_user_directory(), "default", "workflows")
|
||||
|
||||
|
||||
def part_dirs():
|
||||
"""Each kept store and where it lives on this computer."""
|
||||
return {
|
||||
"recipes": get_recipes_dir(),
|
||||
"combos": get_notebooks_dir(),
|
||||
"materials": get_materials_dir(),
|
||||
"parameters": get_parameters_dir(),
|
||||
"comfy_workflows": _comfy_workflows_dir(),
|
||||
}
|
||||
|
||||
|
||||
def work_dir():
|
||||
path = os.path.join(folder_paths.get_temp_directory(), "anomalous_backups")
|
||||
os.makedirs(path, exist_ok=True)
|
||||
return path
|
||||
|
||||
|
||||
def _sha256_file(path):
|
||||
digest = hashlib.sha256()
|
||||
with open(path, "rb") as handle:
|
||||
for block in iter(lambda: handle.read(CHUNK), b""):
|
||||
digest.update(block)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def _store_files(directory):
|
||||
"""(path, '/'-relative path) of every file kept in a store."""
|
||||
if not os.path.isdir(directory):
|
||||
return
|
||||
for root, dirs, files in os.walk(directory):
|
||||
dirs[:] = sorted(d for d in dirs if d != "__pycache__")
|
||||
for name in sorted(files):
|
||||
if name in SKIP_FILES or name.endswith(".tmp"):
|
||||
continue
|
||||
path = os.path.join(root, name)
|
||||
yield path, os.path.relpath(path, directory).replace(os.sep, "/")
|
||||
|
||||
|
||||
def _model_roots():
|
||||
"""(models folder type, folder) once per folder: clip and text_encoders often share one."""
|
||||
seen = set()
|
||||
for folder_type in RESOLVABLE_MODEL_TYPES:
|
||||
try:
|
||||
roots = folder_paths.get_folder_paths(folder_type) or []
|
||||
except Exception: # noqa: BLE001 - a type this ComfyUI does not know
|
||||
continue
|
||||
for root in roots:
|
||||
key = os.path.normcase(os.path.abspath(root))
|
||||
if key in seen or not os.path.isdir(root):
|
||||
continue
|
||||
seen.add(key)
|
||||
yield folder_type, root
|
||||
|
||||
|
||||
def _models():
|
||||
"""(type, root, path, '/'-relative path) of every model file."""
|
||||
for folder_type, root in _model_roots():
|
||||
for walk_root, dirs, files in os.walk(root):
|
||||
dirs.sort()
|
||||
for name in sorted(files):
|
||||
if is_model_file(name):
|
||||
path = os.path.join(walk_root, name)
|
||||
yield folder_type, root, path, os.path.relpath(path, root).replace(os.sep, "/")
|
||||
|
||||
|
||||
def _model_facts(path):
|
||||
"""(SHA-256, download page) from the model's sidecars; nothing is computed."""
|
||||
try:
|
||||
meta = get_metadata(path) or {}
|
||||
except Exception: # noqa: BLE001 - an unreadable sidecar only means "match by path"
|
||||
return "", ""
|
||||
return str(meta.get("hash") or "").lower(), str(meta.get("source_url") or meta.get("civitai_url") or "")
|
||||
|
||||
|
||||
def _model_hash(path):
|
||||
return _model_facts(path)[0]
|
||||
|
||||
|
||||
def _settings_for_backup():
|
||||
data = read_json(config_path()) or {}
|
||||
return {key: value for key, value in data.items() if key not in SECRET_KEYS}
|
||||
|
||||
|
||||
def _version():
|
||||
try:
|
||||
return version_manager.current_state().get("label") or ""
|
||||
except Exception: # noqa: BLE001 - a copy that is no git checkout
|
||||
return ""
|
||||
|
||||
|
||||
# ---------- export ----------
|
||||
|
||||
def build_backup(include_models=True, include_comfy=True, include_library=True, include_scan=True, include_civitai_covers=False):
|
||||
"""Writes the backup .zip into the temp folder: (path, manifest)."""
|
||||
stamp = time.strftime("%Y%m%d-%H%M%S")
|
||||
path = os.path.join(work_dir(), f"AMB-backup-{stamp}.zip")
|
||||
manifest = {"format": FORMAT, "app": APP, "version": _version(), "created": time.time(), "parts": {}, "settings": False, "models": []}
|
||||
parts = [part for part in PART_ORDER if include_comfy or part != "comfy_workflows"]
|
||||
dirs = part_dirs()
|
||||
temporary = path + ".tmp"
|
||||
try:
|
||||
with zipfile.ZipFile(temporary, "w", zipfile.ZIP_DEFLATED, allowZip64=True) as archive:
|
||||
for part in parts:
|
||||
count = 0
|
||||
for file_path, rel in _store_files(dirs[part]):
|
||||
archive.write(file_path, f"stores/{part}/{rel}")
|
||||
count += 1
|
||||
manifest["parts"][part] = count
|
||||
archive.writestr("settings/config.json", json.dumps(_settings_for_backup(), ensure_ascii=False))
|
||||
if os.path.isfile(download_settings_path()):
|
||||
archive.write(download_settings_path(), "settings/download_settings.json")
|
||||
manifest["settings"] = True
|
||||
if include_library:
|
||||
manifest["library"] = []
|
||||
if include_models or include_library:
|
||||
for folder_type, _root, model_path, rel in _models():
|
||||
if include_library:
|
||||
digest, page = _model_facts(model_path)
|
||||
manifest["library"].append({"type": folder_type, "rel": rel, "size": os.path.getsize(model_path),
|
||||
"sha256": digest, "url": page})
|
||||
if not include_models:
|
||||
continue
|
||||
base = os.path.splitext(model_path)[0]
|
||||
user_file = sidecars.find(base, USER_INFO_SUFFIX)
|
||||
user_data = read_json(user_file) if user_file else None
|
||||
civitai, covers = sidecars.cover_owners(base)
|
||||
scan_info = scan_info_path(base) if include_scan else None
|
||||
backups = sidecars.backups(base)
|
||||
civitai_cover = civitai[0] if include_civitai_covers and civitai else None
|
||||
if not user_data and not covers and not scan_info and not civitai_cover:
|
||||
continue
|
||||
entry = {"id": len(manifest["models"]), "type": folder_type, "rel": rel,
|
||||
"size": os.path.getsize(model_path), "sha256": _model_hash(model_path), "user": bool(user_data), "cover": ""}
|
||||
folder = f"models/{entry['id']}/"
|
||||
if user_data:
|
||||
archive.writestr(folder + "user.json", json.dumps(user_data, ensure_ascii=False))
|
||||
if covers:
|
||||
entry["cover"] = covers[0][len(base):]
|
||||
archive.write(covers[0], f"{folder}cover{entry['cover']}")
|
||||
if scan_info:
|
||||
entry["info"] = sidecars.suffix_of(scan_info, base)
|
||||
archive.write(scan_info, f"{folder}scan{entry['info']}")
|
||||
if civitai_cover:
|
||||
# One copy: it is both the cover and Civitai's picture (kept aside or not).
|
||||
picture = backups[0] if backups else civitai_cover
|
||||
entry["civitai_cover"] = civitai_cover[len(base):]
|
||||
entry["civitai_bak"] = sidecars.suffix_of(backups[0], base) if backups else ".civitai_bak" + os.path.splitext(civitai_cover)[1]
|
||||
archive.write(picture, f"{folder}civitai{entry['civitai_bak']}")
|
||||
manifest["models"].append(entry)
|
||||
archive.writestr("manifest.json", json.dumps(manifest, ensure_ascii=False, indent=1))
|
||||
os.replace(temporary, path)
|
||||
finally:
|
||||
if os.path.exists(temporary):
|
||||
os.remove(temporary)
|
||||
_prune_exports()
|
||||
return path, manifest
|
||||
|
||||
|
||||
def _prune_exports():
|
||||
"""Keeps the newest finished exports; older ones are this plugin's own temp files."""
|
||||
exports = sorted((name for name in os.listdir(work_dir()) if name.startswith("AMB-backup-") and name.endswith(".zip")), reverse=True)
|
||||
for name in exports[KEEP_EXPORTS:]:
|
||||
try:
|
||||
os.remove(os.path.join(work_dir(), name))
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
# ---------- reading a backup ----------
|
||||
|
||||
class BackupError(ValueError):
|
||||
"""A file that is no backup of this plugin, or one that cannot be read safely."""
|
||||
|
||||
|
||||
def _safe_rel(rel):
|
||||
parts = rel.split("/")
|
||||
if not rel or rel.startswith("/") or "\\" in rel or ":" in rel or any(part in ("", ".", "..") for part in parts):
|
||||
raise BackupError(f"unsafe path in the backup: {rel}")
|
||||
return parts
|
||||
|
||||
|
||||
def open_backup(path):
|
||||
"""The zip and its manifest, after checking it is a backup and safe to unpack."""
|
||||
try:
|
||||
archive = zipfile.ZipFile(path)
|
||||
except (zipfile.BadZipFile, OSError) as error:
|
||||
raise BackupError("not a zip file") from error
|
||||
try:
|
||||
infos = archive.infolist()
|
||||
if len(infos) > MAX_MEMBERS or sum(info.file_size for info in infos) > MAX_BACKUP_BYTES:
|
||||
raise BackupError("the backup is too large")
|
||||
try:
|
||||
manifest = json.loads(archive.read("manifest.json"))
|
||||
except (KeyError, ValueError) as error:
|
||||
raise BackupError("no manifest: not a backup of this plugin") from error
|
||||
if not isinstance(manifest, dict) or manifest.get("app") != APP or manifest.get("format") != FORMAT:
|
||||
raise BackupError("not a backup of this plugin, or one from a newer version")
|
||||
for info in infos:
|
||||
if not info.is_dir():
|
||||
_safe_rel(info.filename)
|
||||
return archive, manifest
|
||||
except Exception:
|
||||
archive.close()
|
||||
raise
|
||||
|
||||
|
||||
def _store_members(archive):
|
||||
"""(part, '/'-relative path, ZipInfo) of each kept store file in the backup."""
|
||||
for info in archive.infolist():
|
||||
name = info.filename
|
||||
if info.is_dir() or not name.startswith("stores/"):
|
||||
continue
|
||||
bits = name.split("/", 2)
|
||||
if len(bits) == 3 and bits[1] in PART_ORDER:
|
||||
_, part, rel = bits
|
||||
_safe_rel(rel)
|
||||
yield part, rel, info
|
||||
|
||||
|
||||
def _member_sha256(archive, info):
|
||||
digest = hashlib.sha256()
|
||||
with archive.open(info) as handle:
|
||||
for block in iter(lambda: handle.read(CHUNK), b""):
|
||||
digest.update(block)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def _file_state(archive, info, target):
|
||||
if not os.path.isfile(target):
|
||||
return "new"
|
||||
if os.path.getsize(target) == info.file_size and _sha256_file(target) == _member_sha256(archive, info):
|
||||
return "same"
|
||||
return "differs"
|
||||
|
||||
|
||||
def _local_models():
|
||||
"""This computer's models: by SHA-256 and by (type, path) -> (path, size)."""
|
||||
by_hash, by_rel = {}, {}
|
||||
for folder_type, _root, path, rel in _models():
|
||||
size = os.path.getsize(path)
|
||||
digest = _model_hash(path)
|
||||
if digest:
|
||||
by_hash.setdefault(digest, path)
|
||||
by_rel[(folder_type, rel.lower())] = (path, size)
|
||||
return by_hash, by_rel
|
||||
|
||||
|
||||
def _match(entry, by_hash, by_rel):
|
||||
digest = str(entry.get("sha256") or "").lower()
|
||||
if digest and digest in by_hash:
|
||||
return by_hash[digest]
|
||||
found = by_rel.get((entry.get("type"), str(entry.get("rel") or "").lower()))
|
||||
return found[0] if found and found[1] == entry.get("size") else None
|
||||
|
||||
|
||||
def inspect_backup(path):
|
||||
"""What putting the backup back would do, before anything is written."""
|
||||
archive, manifest = open_backup(path)
|
||||
with archive:
|
||||
dirs = part_dirs()
|
||||
parts = {}
|
||||
for part, rel, info in _store_members(archive):
|
||||
counts = parts.setdefault(part, {"new": 0, "same": 0, "differs": 0})
|
||||
counts[_file_state(archive, info, resolve_within(dirs[part], *rel.split("/")))] += 1
|
||||
models = {"total": len(manifest.get("models") or []), "matched": 0, "missing": []}
|
||||
library = manifest.get("library") if isinstance(manifest.get("library"), list) else None
|
||||
summary = {"created": manifest.get("created"), "version": manifest.get("version") or "",
|
||||
"parts": {part: parts[part] for part in PART_ORDER if part in parts},
|
||||
"settings": bool(manifest.get("settings")), "models": models}
|
||||
if models["total"] or library:
|
||||
by_hash, by_rel = _local_models()
|
||||
for entry in manifest.get("models") or []:
|
||||
if _match(entry, by_hash, by_rel):
|
||||
models["matched"] += 1
|
||||
else:
|
||||
models["missing"].append(entry.get("rel") or "")
|
||||
if library is not None:
|
||||
# The models the old computer had and this one lacks: what can be downloaded again
|
||||
# (two copies of one file there are one download here).
|
||||
missing, seen = [], set()
|
||||
for entry in library:
|
||||
if not isinstance(entry, dict) or _match(entry, by_hash, by_rel):
|
||||
continue
|
||||
digest = str(entry.get("sha256") or "").lower()
|
||||
if digest and digest in seen:
|
||||
continue
|
||||
seen.add(digest)
|
||||
missing.append({key: entry.get(key) for key in ("type", "rel", "size", "sha256", "url")})
|
||||
summary["library"] = {"total": len(library), "missing": missing}
|
||||
return summary
|
||||
|
||||
|
||||
# ---------- putting back ----------
|
||||
|
||||
def _write_member(archive, info, target):
|
||||
os.makedirs(os.path.dirname(target), exist_ok=True)
|
||||
fd, temporary = tempfile.mkstemp(prefix=".restore-", suffix=".tmp", dir=os.path.dirname(target))
|
||||
try:
|
||||
with os.fdopen(fd, "wb") as output, archive.open(info) as source:
|
||||
shutil.copyfileobj(source, output, CHUNK)
|
||||
os.replace(temporary, target)
|
||||
finally:
|
||||
if os.path.exists(temporary):
|
||||
os.remove(temporary)
|
||||
|
||||
|
||||
def _restore_stores(archive, wanted, replace, result):
|
||||
dirs = part_dirs()
|
||||
for part, rel, info in _store_members(archive):
|
||||
if part not in wanted:
|
||||
continue
|
||||
target = resolve_within(dirs[part], *rel.split("/"))
|
||||
state = _file_state(archive, info, target)
|
||||
if state == "same" or (state == "differs" and not replace):
|
||||
result["skipped"] += 1
|
||||
continue
|
||||
if state == "differs":
|
||||
try:
|
||||
move_to_trash(target)
|
||||
except (TrashUnavailable, OSError) as error:
|
||||
result["failed"].append(f"{part}/{rel}: {trash_failure(error)}")
|
||||
continue
|
||||
result["replaced"] += 1
|
||||
else:
|
||||
result["added"] += 1
|
||||
_write_member(archive, info, target)
|
||||
|
||||
|
||||
def _restore_scan(archive, entry, base, folder, replace, result):
|
||||
"""What a scan found: the scan file where there is none (or replaced on request), and
|
||||
Civitai's cover where the model has no cover at all."""
|
||||
suffix = str(entry.get("info") or "")
|
||||
if suffix:
|
||||
if suffix not in SCAN_INFO_SUFFIXES:
|
||||
raise BackupError(f"unknown scan file name: {suffix}")
|
||||
info = archive.getinfo(folder + "scan" + suffix)
|
||||
local = scan_info_path(base)
|
||||
if not local or (replace and _sha256_file(local) != _member_sha256(archive, info)):
|
||||
if local:
|
||||
move_to_trash(local)
|
||||
_write_member(archive, info, sidecars.target(base, suffix))
|
||||
result["model_infos"] += 1
|
||||
cover, saved = str(entry.get("civitai_cover") or ""), str(entry.get("civitai_bak") or "")
|
||||
if cover and saved:
|
||||
if cover not in ACTIVE_COVER_SUFFIXES or saved not in CIVITAI_BACKUP_SUFFIXES:
|
||||
raise BackupError(f"unknown cover name: {cover}")
|
||||
info = archive.getinfo(folder + "civitai" + saved)
|
||||
civitai, mine = sidecars.cover_owners(base)
|
||||
if not civitai and not mine and not entry.get("cover"):
|
||||
# Civitai's picture becomes the cover, noted as Civitai's (no second copy aside).
|
||||
_write_member(archive, info, base + cover)
|
||||
if not sidecars.note_cover_hash(base, base + cover) and not sidecars.backups(base):
|
||||
_write_member(archive, info, sidecars.target(base, saved))
|
||||
result["model_civitai_covers"] += 1
|
||||
elif mine and not sidecars.backups(base):
|
||||
_write_member(archive, info, sidecars.target(base, saved)) # aside, while the user's cover shows
|
||||
|
||||
|
||||
def _restore_model(archive, entry, model_path, replace, result):
|
||||
base = os.path.splitext(model_path)[0]
|
||||
folder = f"models/{int(entry['id'])}/"
|
||||
_restore_scan(archive, entry, base, folder, replace, result)
|
||||
if entry.get("user"):
|
||||
backup = json.loads(archive.read(folder + "user.json"))
|
||||
user_file = sidecars.target(base, USER_INFO_SUFFIX)
|
||||
local = read_json(user_file) if os.path.isfile(user_file) else None
|
||||
merged = dict(local or {"format": 1})
|
||||
for key in USER_FIELDS:
|
||||
value = str(backup.get(key) or "").strip()
|
||||
if value and (replace or not str(merged.get(key) or "").strip()):
|
||||
merged[key] = backup[key]
|
||||
if merged != (local or {"format": 1}):
|
||||
if local and replace:
|
||||
move_to_trash(user_file) # the old values stay recoverable
|
||||
atomic_write_json(user_file, merged)
|
||||
result["model_notes"] += 1
|
||||
suffix = str(entry.get("cover") or "")
|
||||
if suffix:
|
||||
if suffix not in ACTIVE_COVER_SUFFIXES:
|
||||
raise BackupError(f"unknown cover name: {suffix}")
|
||||
info = archive.getinfo(folder + "cover" + suffix)
|
||||
civitai, mine = sidecars.cover_owners(base)
|
||||
member_hash = _member_sha256(archive, info)
|
||||
if any(_sha256_file(cover) == member_hash for cover in mine):
|
||||
return
|
||||
if mine and not replace:
|
||||
result["covers_kept"] += 1
|
||||
return
|
||||
if civitai and not sidecars.backups(base):
|
||||
sidecars.keep_aside(base, civitai.pop(0)) # Civitai's picture stays, to bring back
|
||||
for cover in mine + civitai: # Civitai's own copy stays as <model>.civitai_bak.*
|
||||
move_to_trash(cover)
|
||||
_write_member(archive, info, base + suffix)
|
||||
result["model_covers"] += 1
|
||||
|
||||
|
||||
def _restore_settings(archive, result):
|
||||
names = set(archive.namelist())
|
||||
if "settings/config.json" in names:
|
||||
backup = json.loads(archive.read("settings/config.json"))
|
||||
local = read_json(config_path()) or {}
|
||||
merged = {**{key: value for key, value in backup.items() if key not in SECRET_KEYS},
|
||||
**{key: local[key] for key in SECRET_KEYS if key in local}}
|
||||
atomic_write_json(config_path(), merged)
|
||||
result["settings"] = True
|
||||
if "settings/download_settings.json" in names:
|
||||
os.makedirs(os.path.dirname(download_settings_path()), exist_ok=True)
|
||||
atomic_write_json(download_settings_path(), json.loads(archive.read("settings/download_settings.json")))
|
||||
|
||||
|
||||
def apply_backup(path, parts=PART_ORDER, models=True, settings=False, replace=False):
|
||||
"""Puts the backup back as chosen; returns the counts for the user and the activity log."""
|
||||
archive, manifest = open_backup(path)
|
||||
result = {"added": 0, "replaced": 0, "skipped": 0, "model_notes": 0, "model_covers": 0, "model_infos": 0,
|
||||
"model_civitai_covers": 0, "covers_kept": 0, "models_missing": 0, "settings": False, "failed": []}
|
||||
with archive:
|
||||
_restore_stores(archive, set(parts) & set(PART_ORDER), replace, result)
|
||||
if models and manifest.get("models"):
|
||||
by_hash, by_rel = _local_models()
|
||||
for entry in manifest["models"]:
|
||||
model_path = _match(entry, by_hash, by_rel)
|
||||
if not model_path:
|
||||
result["models_missing"] += 1
|
||||
continue
|
||||
try:
|
||||
_restore_model(archive, entry, model_path, replace, result)
|
||||
except (TrashUnavailable, OSError, KeyError, ValueError) as error:
|
||||
result["failed"].append(f"{entry.get('rel')}: {trash_failure(error) if isinstance(error, (TrashUnavailable, OSError)) else error}")
|
||||
clear_metadata_cache()
|
||||
if settings and manifest.get("settings"):
|
||||
_restore_settings(archive, result)
|
||||
_invalidate_parameter_notebooks_cache()
|
||||
return result
|
||||
|
||||
|
||||
# ---------- routes ----------
|
||||
|
||||
def _error(message, status=400):
|
||||
return web.json_response({"status": "error", "error": str(message)}, status=status)
|
||||
|
||||
|
||||
async def api_export(request):
|
||||
try:
|
||||
body = await request.json()
|
||||
except Exception: # noqa: BLE001 - no body: the defaults
|
||||
body = {}
|
||||
path, manifest = await asyncio.to_thread(build_backup, body.get("models", True) is not False,
|
||||
body.get("comfy_workflows", True) is not False, body.get("library", True) is not False,
|
||||
body.get("scan", True) is not False, body.get("civitai_covers") is True)
|
||||
counts = {**manifest["parts"], "models": len(manifest["models"]), "library": len(manifest.get("library") or [])}
|
||||
await asyncio.to_thread(add_entry, "file", "backup_export", os.path.basename(path), {"backup": counts})
|
||||
return web.json_response({"status": "success", "name": os.path.basename(path), "size": os.path.getsize(path), "counts": counts})
|
||||
|
||||
|
||||
async def api_file(request):
|
||||
try:
|
||||
name = require_filename(request.query.get("name", ""))
|
||||
if not name.startswith("AMB-backup-") or not name.endswith(".zip"):
|
||||
raise ValueError("not a backup")
|
||||
path = resolve_within(work_dir(), name)
|
||||
except ValueError as error:
|
||||
return _error(error)
|
||||
if not os.path.isfile(path):
|
||||
return _error("This backup is gone; export it again.", 404)
|
||||
return web.FileResponse(path, headers={"Content-Disposition": f'attachment; filename="{name}"'})
|
||||
|
||||
|
||||
async def api_inspect(request):
|
||||
"""Receives the chosen .zip, keeps it in the temp folder and says what putting it back would do."""
|
||||
try:
|
||||
reader = await request.multipart()
|
||||
field = await reader.next()
|
||||
except (AssertionError, ValueError): # not a file upload at all
|
||||
return _error("no file")
|
||||
if field is None or field.name != "file":
|
||||
return _error("no file")
|
||||
token = uuid.uuid4().hex
|
||||
path = os.path.join(work_dir(), f"incoming-{token}.zip")
|
||||
size = 0
|
||||
with open(path, "wb") as output:
|
||||
while chunk := await field.read_chunk(CHUNK):
|
||||
size += len(chunk)
|
||||
if size > MAX_BACKUP_BYTES:
|
||||
output.close()
|
||||
os.remove(path)
|
||||
return _error("the backup is too large")
|
||||
output.write(chunk)
|
||||
try:
|
||||
summary = await asyncio.to_thread(inspect_backup, path)
|
||||
except BackupError as error:
|
||||
os.remove(path)
|
||||
return _error(error)
|
||||
return web.json_response({"status": "success", "token": token, **summary})
|
||||
|
||||
|
||||
async def api_apply(request):
|
||||
try:
|
||||
body = await request.json()
|
||||
token = str(body.get("token") or "")
|
||||
if not token.isalnum():
|
||||
raise ValueError("bad token")
|
||||
path = resolve_within(work_dir(), f"incoming-{token}.zip")
|
||||
except Exception as error: # noqa: BLE001
|
||||
return _error(error)
|
||||
if not os.path.isfile(path):
|
||||
return _error("This backup is gone; choose the file again.", 404)
|
||||
parts = [part for part in body.get("parts") or [] if part in PART_ORDER]
|
||||
try:
|
||||
result = await asyncio.to_thread(apply_backup, path, parts, body.get("models") is not False,
|
||||
body.get("settings") is True, body.get("replace") is True)
|
||||
except BackupError as error:
|
||||
return _error(error)
|
||||
os.remove(path)
|
||||
await asyncio.to_thread(add_entry, "file", "backup_import", str(body.get("name") or ""), {"backup": {**result, "failed": result["failed"][:20]}})
|
||||
return web.json_response({"status": "success", **result})
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
app.router.add_post("/anomalous/backup/export", api_export)
|
||||
app.router.add_get("/anomalous/backup/file", api_file)
|
||||
app.router.add_post("/anomalous/backup/inspect", api_inspect)
|
||||
app.router.add_post("/anomalous/backup/apply", api_apply)
|
||||
+57
-28
@@ -9,6 +9,13 @@ from aiohttp import web
|
||||
import folder_paths
|
||||
import struct
|
||||
|
||||
try:
|
||||
from ..net_proxy import CONFIG_KEY as PROXY_KEY, configured as configured_proxy, normalize as normalize_proxy
|
||||
from ..model_sidecars import layout as _side_file_layout
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from net_proxy import CONFIG_KEY as PROXY_KEY, configured as configured_proxy, normalize as normalize_proxy
|
||||
from model_sidecars import layout as _side_file_layout
|
||||
|
||||
async def api_get_config(request):
|
||||
script_dir = os.path.dirname(os.path.abspath(__file__))
|
||||
config_path = os.path.join(script_dir, "config.json")
|
||||
@@ -20,20 +27,27 @@ async def api_get_config(request):
|
||||
cfg = json.load(f)
|
||||
has_key = bool(cfg.get("CIVITAI_API_KEY", "").strip())
|
||||
folder_types = cfg.get("folder_types_config", [])
|
||||
except:
|
||||
pass
|
||||
if not has_key:
|
||||
legacy_config_path = os.path.join(os.path.dirname(script_dir), "config.json")
|
||||
if os.path.exists(legacy_config_path):
|
||||
try:
|
||||
with open(legacy_config_path, 'r', encoding='utf-8') as f:
|
||||
legacy_cfg = json.load(f)
|
||||
has_key = bool(legacy_cfg.get("CIVITAI_API_KEY", "").strip())
|
||||
except Exception:
|
||||
pass
|
||||
return web.json_response({"has_api_key": has_key, "folder_types_config": folder_types})
|
||||
except:
|
||||
pass
|
||||
if not has_key:
|
||||
legacy_config_path = os.path.join(os.path.dirname(script_dir), "config.json")
|
||||
if os.path.exists(legacy_config_path):
|
||||
try:
|
||||
with open(legacy_config_path, 'r', encoding='utf-8') as f:
|
||||
legacy_cfg = json.load(f)
|
||||
has_key = bool(legacy_cfg.get("CIVITAI_API_KEY", "").strip())
|
||||
except Exception:
|
||||
pass
|
||||
deepl_key = ""
|
||||
try:
|
||||
with open(config_path, 'r', encoding='utf-8') as f:
|
||||
deepl_key = json.load(f).get("DEEPL_API_KEY", "")
|
||||
except (OSError, ValueError, AttributeError):
|
||||
pass
|
||||
return web.json_response({"has_api_key": has_key, "has_deepl_key": bool(isinstance(deepl_key, str) and deepl_key.strip()),
|
||||
"proxy": configured_proxy(), "sidecar_layout": _side_file_layout(), "folder_types_config": folder_types})
|
||||
|
||||
async def api_save_config(request):
|
||||
async def api_save_config(request):
|
||||
try:
|
||||
data = await request.json()
|
||||
api_key = data.get("api_key")
|
||||
@@ -50,17 +64,32 @@ async def api_save_config(request):
|
||||
except:
|
||||
pass
|
||||
|
||||
if api_key is not None and not isinstance(api_key, str):
|
||||
return web.json_response({"status": "error", "message": "Invalid API key"}, status=400)
|
||||
if folder_types_config is not None and not isinstance(folder_types_config, list):
|
||||
return web.json_response({"status": "error", "message": "Invalid folder configuration"}, status=400)
|
||||
if "physical_folders_config" in data and not isinstance(data.get("physical_folders_config"), list):
|
||||
return web.json_response({"status": "error", "message": "Invalid physical folder configuration"}, status=400)
|
||||
if "folder_view_mode" in data and data.get("folder_view_mode") not in {"abstract", "physical"}:
|
||||
return web.json_response({"status": "error", "message": "Invalid folder view mode"}, status=400)
|
||||
|
||||
if api_key is not None:
|
||||
cfg["CIVITAI_API_KEY"] = api_key.strip()
|
||||
deepl_key = data.get("deepl_key")
|
||||
if api_key is not None and not isinstance(api_key, str):
|
||||
return web.json_response({"status": "error", "message": "Invalid API key"}, status=400)
|
||||
if deepl_key is not None and not isinstance(deepl_key, str):
|
||||
return web.json_response({"status": "error", "message": "Invalid DeepL key"}, status=400)
|
||||
proxy = None
|
||||
if "proxy" in data: # Settings -> Network (net_proxy.py); "" = the system's proxy
|
||||
try:
|
||||
proxy = normalize_proxy(data.get("proxy"))
|
||||
except ValueError as error:
|
||||
return web.json_response({"status": "error", "message": "Invalid proxy", "code": str(error)}, status=400)
|
||||
if folder_types_config is not None and not isinstance(folder_types_config, list):
|
||||
return web.json_response({"status": "error", "message": "Invalid folder configuration"}, status=400)
|
||||
if "physical_folders_config" in data and not isinstance(data.get("physical_folders_config"), list):
|
||||
return web.json_response({"status": "error", "message": "Invalid physical folder configuration"}, status=400)
|
||||
if "folder_view_mode" in data and data.get("folder_view_mode") not in {"abstract", "physical"}:
|
||||
return web.json_response({"status": "error", "message": "Invalid folder view mode"}, status=400)
|
||||
|
||||
if api_key is not None:
|
||||
cfg["CIVITAI_API_KEY"] = api_key.strip()
|
||||
|
||||
if deepl_key is not None: # Settings -> Translation (translation_routes.py)
|
||||
cfg["DEEPL_API_KEY"] = deepl_key.strip()
|
||||
|
||||
if proxy is not None:
|
||||
cfg[PROXY_KEY] = proxy
|
||||
|
||||
if folder_types_config is not None:
|
||||
cfg["folder_types_config"] = folder_types_config
|
||||
@@ -71,10 +100,10 @@ async def api_save_config(request):
|
||||
if "folder_view_mode" in data:
|
||||
cfg["folder_view_mode"] = data.get("folder_view_mode")
|
||||
|
||||
temp_path = config_path + ".tmp"
|
||||
with open(temp_path, 'w', encoding='utf-8') as f:
|
||||
json.dump(cfg, f, indent=4)
|
||||
os.replace(temp_path, config_path)
|
||||
temp_path = config_path + ".tmp"
|
||||
with open(temp_path, 'w', encoding='utf-8') as f:
|
||||
json.dump(cfg, f, indent=4)
|
||||
os.replace(temp_path, config_path)
|
||||
|
||||
return web.json_response({"status": "ok"})
|
||||
except Exception as e:
|
||||
|
||||
@@ -0,0 +1,373 @@
|
||||
"""Where a model the open workflow is missing can be downloaded from, for Model Check's
|
||||
"Download" (api/model_download.py fetches it).
|
||||
|
||||
Sources that name one exact file: Civitai by the file's hash (the workflow's fingerprint), a
|
||||
Civitai model version or file link, or a direct file link on Hugging Face (or its mirror) or
|
||||
GitHub, as a shared workflow carries them (AMB's model links, ComfyUI's own `properties.models`).
|
||||
Then ComfyUI-Manager's model list by file name (manager_catalog.py): with the fingerprint, only
|
||||
the entry whose file has it; without, the one entry of that name, marked `by_name` because a
|
||||
name is no proof (the page asks before it downloads one). Each answer says the file's size and
|
||||
SHA-256 when the site gives them, so the download can be checked.
|
||||
"""
|
||||
|
||||
import json
|
||||
import re
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
try:
|
||||
from ..civitai_client import USER_AGENT, _load_api_key, answered, api_hosts
|
||||
from ..net_proxy import urlopen
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from civitai_client import USER_AGENT, _load_api_key, answered, api_hosts
|
||||
from net_proxy import urlopen
|
||||
from . import manager_catalog
|
||||
|
||||
CIVITAI_HOSTS = ("civitai.com", "civitai.red")
|
||||
HF_HOSTS = ("huggingface.co", "hf-mirror.com")
|
||||
HF_MIRROR = "hf-mirror.com" # Hugging Face's mirror for mainland China (it sends other networks back)
|
||||
OTHER_HOSTS = ("github.com",)
|
||||
TIMEOUT = 15
|
||||
SHA256 = re.compile(r"^[0-9a-fA-F]{64}$")
|
||||
|
||||
|
||||
class SourceUnreachable(Exception):
|
||||
"""The site did not answer (network, timeout, server error)."""
|
||||
|
||||
|
||||
def host_of(url):
|
||||
try:
|
||||
parsed = urllib.parse.urlsplit(str(url).strip())
|
||||
except ValueError:
|
||||
return ""
|
||||
return (parsed.hostname or "").lower() if parsed.scheme == "https" else ""
|
||||
|
||||
|
||||
def _site(host, sites):
|
||||
return any(host == site or host.endswith("." + site) for site in sites)
|
||||
|
||||
|
||||
def allowed_download_url(url):
|
||||
"""Whether `url` is an https link on a site downloads may start from."""
|
||||
host = host_of(url)
|
||||
return bool(host) and _site(host, CIVITAI_HOSTS + HF_HOSTS + OTHER_HOSTS)
|
||||
|
||||
|
||||
def is_civitai(url):
|
||||
return _site(host_of(url), CIVITAI_HOSTS)
|
||||
|
||||
|
||||
def civitai_headers():
|
||||
headers = {"User-Agent": USER_AGENT}
|
||||
key = _load_api_key()
|
||||
if key:
|
||||
headers["Authorization"] = f"Bearer {key}"
|
||||
return headers
|
||||
|
||||
|
||||
def _get_json(url, headers):
|
||||
"""The JSON at `url`; None on 404; SourceUnreachable when it could not be asked."""
|
||||
try:
|
||||
with urlopen(urllib.request.Request(url, headers=headers), timeout=TIMEOUT) as response:
|
||||
return json.loads(response.read().decode("utf-8"))
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code in (400, 404):
|
||||
return None
|
||||
raise SourceUnreachable(f"HTTP {error.code}") from error
|
||||
except (urllib.error.URLError, OSError, ValueError) as error:
|
||||
raise SourceUnreachable(str(error)) from error
|
||||
|
||||
|
||||
def _civitai_json(path):
|
||||
"""Civitai's API answer at `path` (/api/v1/…), from whichever of its addresses answers
|
||||
(civitai_client.api_hosts); None on 404."""
|
||||
unreachable = None
|
||||
for host in api_hosts():
|
||||
try:
|
||||
data = _get_json(f"https://{host}{path}", civitai_headers())
|
||||
except SourceUnreachable as error:
|
||||
if isinstance(error.__cause__, urllib.error.HTTPError):
|
||||
raise # Civitai answered with an error: the other address is the same Civitai
|
||||
unreachable = error
|
||||
continue
|
||||
answered(host)
|
||||
return data
|
||||
raise unreachable
|
||||
|
||||
|
||||
def _civitai_page(version):
|
||||
domain = "civitai.red" if (version.get("model") or {}).get("nsfw") or (version.get("nsfwLevel") or 1) > 1 else "civitai.com"
|
||||
model_id = version.get("modelId")
|
||||
return f"https://{domain}/models/{model_id}?modelVersionId={version.get('id')}" if model_id else ""
|
||||
|
||||
|
||||
def _pick_civitai_file(files, file_hash="", name=""):
|
||||
"""The version's file with this hash (SHA-256 or a prefix such as AutoV2; None if it has
|
||||
none such). Without a hash: the file of this name, else the version's primary model file —
|
||||
the link names that version, and people rename their files."""
|
||||
files = [item for item in files or [] if isinstance(item, dict) and item.get("downloadUrl")]
|
||||
wanted = str(file_hash or "").upper()
|
||||
if wanted:
|
||||
for item in files:
|
||||
hashes = {str(value).upper() for value in (item.get("hashes") or {}).values()}
|
||||
sha = str((item.get("hashes") or {}).get("SHA256") or "").upper()
|
||||
if wanted in hashes or (len(wanted) >= 10 and sha.startswith(wanted)):
|
||||
return item
|
||||
return None
|
||||
if name:
|
||||
for item in files:
|
||||
if str(item.get("name", "")).lower() == name.lower():
|
||||
return item
|
||||
models = [item for item in files if item.get("type", "Model") == "Model"]
|
||||
return next((item for item in models if item.get("primary")), models[0] if models else None)
|
||||
|
||||
|
||||
def _from_civitai_version(version, file_hash="", name=""):
|
||||
picked = _pick_civitai_file(version.get("files"), file_hash, name)
|
||||
if not picked:
|
||||
return None
|
||||
sha = str((picked.get("hashes") or {}).get("SHA256") or "")
|
||||
return {
|
||||
"found": True,
|
||||
"source": "civitai",
|
||||
"download_url": picked["downloadUrl"],
|
||||
"file_name": picked.get("name") or "",
|
||||
"size": int(float(picked.get("sizeKB") or 0) * 1024),
|
||||
"sha256": sha.lower() if SHA256.match(sha) else "",
|
||||
"format": ((picked.get("metadata") or {}).get("format") or ""),
|
||||
"base_model": version.get("baseModel") or "",
|
||||
"model_name": (version.get("model") or {}).get("name") or "",
|
||||
"version_name": version.get("name") or "",
|
||||
"page": _civitai_page(version),
|
||||
}
|
||||
|
||||
|
||||
def civitai_by_hash(file_hash):
|
||||
version = _civitai_json(f"/api/v1/model-versions/by-hash/{urllib.parse.quote(file_hash)}")
|
||||
return _from_civitai_version(version, file_hash) if version else None
|
||||
|
||||
|
||||
def _civitai_version_id(url):
|
||||
parsed = urllib.parse.urlsplit(url)
|
||||
query = urllib.parse.parse_qs(parsed.query)
|
||||
if query.get("modelVersionId"):
|
||||
return query["modelVersionId"][0]
|
||||
match = re.search(r"/api/download/models/(\d+)", parsed.path) or re.search(r"/model-versions/(\d+)", parsed.path)
|
||||
return match.group(1) if match else ""
|
||||
|
||||
|
||||
def civitai_by_link(url, name, file_hash=""):
|
||||
"""A Civitai link that names a model version: its file of this hash or name."""
|
||||
version_id = _civitai_version_id(url)
|
||||
if not version_id.isdigit():
|
||||
return None
|
||||
version = _civitai_json(f"/api/v1/model-versions/{version_id}")
|
||||
return _from_civitai_version(version, file_hash, name) if version else None
|
||||
|
||||
|
||||
class _NoRedirect(urllib.request.HTTPRedirectHandler):
|
||||
def redirect_request(self, *args, **kwargs):
|
||||
return None
|
||||
|
||||
|
||||
def _hf_file_url(url, host=""):
|
||||
"""https://<hf>/<repo>/resolve/<rev>/<path> for a blob or resolve link to a file, else '';
|
||||
on `host` (Hugging Face or its mirror) when given."""
|
||||
parsed = urllib.parse.urlsplit(url)
|
||||
parts = [part for part in parsed.path.split("/") if part]
|
||||
for marker in ("resolve", "blob"):
|
||||
if marker in parts:
|
||||
at = parts.index(marker)
|
||||
if at >= 2 and len(parts) > at + 2:
|
||||
parts[at] = "resolve"
|
||||
return urllib.parse.urlunsplit(("https", host or parsed.netloc, "/" + "/".join(parts), "", ""))
|
||||
return ""
|
||||
|
||||
|
||||
def _head(url):
|
||||
"""(headers, redirected) of a HEAD request that does not follow redirects; None on 404,
|
||||
"gated" on 401/403."""
|
||||
opener = urllib.request.build_opener(_NoRedirect)
|
||||
request = urllib.request.Request(url, method="HEAD", headers={"User-Agent": USER_AGENT})
|
||||
try:
|
||||
return opener.open(request, timeout=TIMEOUT).headers, False
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code in (401, 403):
|
||||
return "gated"
|
||||
if error.code == 404:
|
||||
return None
|
||||
if error.code not in (301, 302, 303, 307, 308):
|
||||
raise SourceUnreachable(f"HTTP {error.code}") from error
|
||||
return error.headers, True
|
||||
except (urllib.error.URLError, OSError) as error:
|
||||
raise SourceUnreachable(str(error)) from error
|
||||
|
||||
|
||||
def hugging_face_file(url, host=""):
|
||||
"""A Hugging Face file link, fetched from `host` (huggingface.co or the mirror; the link's
|
||||
own when empty): its size and SHA-256 from the site's headers."""
|
||||
file_url = _hf_file_url(url, host)
|
||||
if not file_url:
|
||||
return None
|
||||
answer = _head(file_url)
|
||||
if isinstance(answer, tuple) and answer[1] and not answer[0].get("x-linked-size"):
|
||||
# Sent on to the other Hugging Face host (the mirror does that outside China): ask there.
|
||||
location = urllib.parse.urljoin(file_url, answer[0].get("Location") or "")
|
||||
if _site(host_of(location), HF_HOSTS) and host_of(location) != host_of(file_url):
|
||||
answer = _head(location)
|
||||
if answer is None:
|
||||
return None
|
||||
if answer == "gated":
|
||||
# The repository's page, where the user logs in and accepts its terms.
|
||||
parts = urllib.parse.urlsplit(file_url).path.strip("/").split("/")
|
||||
return {"found": False, "reason": "gated", "page": f"https://huggingface.co/{'/'.join(parts[:2])}"}
|
||||
headers, redirected = answer
|
||||
etag = str(headers.get("x-linked-etag") or headers.get("etag") or "").strip('"').replace("W/", "").strip('"')
|
||||
# A redirect's own length is not the file's: without x-linked-size (small files kept
|
||||
# outside large-file storage) the size is unknown.
|
||||
size = headers.get("x-linked-size") or (0 if redirected else headers.get("content-length")) or 0
|
||||
return {
|
||||
"found": True,
|
||||
"source": "huggingface",
|
||||
"mirror": host_of(file_url) == HF_MIRROR,
|
||||
"download_url": file_url,
|
||||
"file_name": urllib.parse.unquote(file_url.rsplit("/", 1)[-1]),
|
||||
"size": int(size) if str(size).isdigit() else 0,
|
||||
"sha256": etag.lower() if SHA256.match(etag) else "",
|
||||
"format": "",
|
||||
"base_model": "",
|
||||
"model_name": "",
|
||||
"version_name": "",
|
||||
"page": url,
|
||||
}
|
||||
|
||||
|
||||
def plain_link(url):
|
||||
"""A direct file link on GitHub (a release asset, or a file in a repository, fetched raw): no
|
||||
size or hash to check against."""
|
||||
parsed = urllib.parse.urlsplit(url)
|
||||
path = parsed.path
|
||||
if "/blob/" in path: # the page about the file; its raw form is the file
|
||||
path = path.replace("/blob/", "/raw/", 1)
|
||||
if "/releases/download/" not in path and "/raw/" not in path:
|
||||
return None
|
||||
return {
|
||||
"found": True, "source": "link", "download_url": urllib.parse.urlunsplit(("https", parsed.netloc, path, "", "")),
|
||||
"file_name": urllib.parse.unquote(path.rsplit("/", 1)[-1]), "size": 0, "sha256": "",
|
||||
"format": "", "base_model": "", "model_name": "", "version_name": "", "page": url,
|
||||
}
|
||||
|
||||
|
||||
def same_file(expected, sha256):
|
||||
"""Whether a fingerprint (full SHA-256 or a prefix of 10+, AutoV2) names this SHA-256."""
|
||||
expected, sha256 = str(expected or "").lower(), str(sha256 or "").lower()
|
||||
return len(expected) >= 10 and sha256.startswith(expected)
|
||||
|
||||
|
||||
def _is_sha_prefix(value):
|
||||
return len(value) >= 10 and bool(re.fullmatch(r"[0-9a-fA-F]+", value))
|
||||
|
||||
|
||||
class _Sites:
|
||||
"""Which sites stopped answering during one lookup, so the next models skip only those
|
||||
(offline in mainland China, Civitai fails while Hugging Face through its mirror works)."""
|
||||
|
||||
def __init__(self, down=None):
|
||||
self.down = down if down is not None else set()
|
||||
self.missed = False
|
||||
|
||||
def ask(self, site, call, *args):
|
||||
if site in self.down:
|
||||
self.missed = True
|
||||
return None
|
||||
try:
|
||||
return call(*args)
|
||||
except SourceUnreachable:
|
||||
self.down.add(site)
|
||||
self.missed = True
|
||||
return None
|
||||
|
||||
|
||||
def _by_link(sites, url, name, file_hash, hf_host):
|
||||
host = host_of(url)
|
||||
if _site(host, CIVITAI_HOSTS):
|
||||
return sites.ask("civitai", civitai_by_link, url, name, file_hash)
|
||||
if _site(host, HF_HOSTS):
|
||||
return sites.ask("huggingface", hugging_face_file, url, hf_host)
|
||||
if _site(host, OTHER_HOSTS):
|
||||
return plain_link(url)
|
||||
return None
|
||||
|
||||
|
||||
def _from_manager_list(sites, name, folder_type, file_hash, hf_host):
|
||||
"""A file of this name in ComfyUI-Manager's model list. With the workflow's fingerprint,
|
||||
only an entry whose file has that SHA-256 (several of the same name are each asked); without,
|
||||
the one entry of that name, marked `by_name` (nothing can tell it is the same file)."""
|
||||
entries = manager_catalog.candidates(name, folder_type)
|
||||
if not entries:
|
||||
return None
|
||||
if _is_sha_prefix(file_hash):
|
||||
for entry in entries[:6]:
|
||||
found = _by_link(sites, entry["url"], name, "", hf_host)
|
||||
if found and found.get("found") and same_file(file_hash, found.get("sha256")):
|
||||
return {**found, "via": "manager_list", "list_name": entry["name"], "by_name": False,
|
||||
"list_base": entry["base"], "list_site": manager_catalog.site_of(entry["url"])}
|
||||
return None
|
||||
if len(entries) != 1:
|
||||
return None # several files of that name: which one is unknowable
|
||||
found = _by_link(sites, entries[0]["url"], name, "", hf_host)
|
||||
if found and found.get("found"):
|
||||
return {**found, "via": "manager_list", "list_name": entries[0]["name"], "by_name": True,
|
||||
"base_model": found.get("base_model") or entries[0]["base"],
|
||||
"list_base": entries[0]["base"], "list_site": manager_catalog.site_of(entries[0]["url"])}
|
||||
return found
|
||||
|
||||
|
||||
def _same_file_on_hugging_face(sites, civitai, url, name, folder_type, hf_host):
|
||||
"""With the mirror on (mainland China, where Civitai is slow or out of reach and some of its
|
||||
files need a login), the same file (same SHA-256) on Hugging Face, from the workflow's link
|
||||
or ComfyUI-Manager's list, is fetched there instead. Civitai's name, base model and page stay."""
|
||||
sha = civitai.get("sha256") or ""
|
||||
if not SHA256.match(sha):
|
||||
return civitai
|
||||
other = None
|
||||
if url and _site(host_of(url), HF_HOSTS):
|
||||
other = _by_link(sites, url, name, "", hf_host)
|
||||
if not (other and other.get("found") and same_file(sha, other.get("sha256"))):
|
||||
other = None
|
||||
if other is None and name:
|
||||
other = _from_manager_list(sites, name, folder_type, sha, hf_host)
|
||||
if not other:
|
||||
return civitai
|
||||
keep = {key: civitai[key] for key in ("base_model", "model_name", "version_name", "page") if civitai.get(key)}
|
||||
return {**other, **keep, "via": other.get("via", ""), "also_on": "civitai"}
|
||||
|
||||
|
||||
def find_source(file_hash="", url="", name="", hf_mirror=False, folder_type="", down=None):
|
||||
"""Where one missing model can come from: {found, source, download_url, file_name, size,
|
||||
sha256, base_model, model_name, version_name, page}, or {found: False, reason}. Asked in
|
||||
turn: Civitai by the fingerprint, the workflow's link, ComfyUI-Manager's model list by file
|
||||
name. With `hf_mirror`, Hugging Face files come from its mirror (and without, never from it).
|
||||
`down` (a set kept across one lookup) names the sites that stopped answering."""
|
||||
sites = _Sites(down)
|
||||
hf_host = HF_MIRROR if hf_mirror else "huggingface.co"
|
||||
looked = False
|
||||
found = None
|
||||
if file_hash:
|
||||
looked = True
|
||||
found = sites.ask("civitai", civitai_by_hash, file_hash)
|
||||
if not found and url and host_of(url):
|
||||
looked = True
|
||||
found = _by_link(sites, url, name, file_hash, hf_host)
|
||||
if not (found and found.get("found")) and name:
|
||||
listed = _from_manager_list(sites, name, folder_type, file_hash, hf_host)
|
||||
looked = looked or listed is not None or bool(manager_catalog.candidates(name, folder_type))
|
||||
found = listed or found
|
||||
if found and found.get("found") and found.get("source") == "civitai" and hf_mirror:
|
||||
found = _same_file_on_hugging_face(sites, found, url, name, folder_type, hf_host)
|
||||
if found:
|
||||
return found
|
||||
if sites.missed:
|
||||
return {"found": False, "reason": "network"}
|
||||
return {"found": False, "reason": "not_found" if looked else "no_source"}
|
||||
+41
-4
@@ -1,4 +1,9 @@
|
||||
"""Configured model-folder visibility and scan-scope helpers."""
|
||||
"""Configured model-folder visibility and scan-scope helpers.
|
||||
|
||||
Shown folders are also the ones scans read, so a workflow can carry each model's fingerprint
|
||||
only for them. Text encoders, CLIP vision and upscalers are shown by default since
|
||||
2026-10 (FOLDER_DEFAULTS_VERSION 2); an older config.json gets them turned on once.
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
@@ -6,12 +11,44 @@ import os
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
DEFAULT_TYPES = ['checkpoints', 'loras', 'diffusion_models', 'unet', 'controlnet', 'vae',
|
||||
'text_encoders', 'clip', 'clip_vision', 'upscale_models']
|
||||
# Added to the defaults in version 2 (the components a workflow's fingerprints need most).
|
||||
ADDED_IN_2 = {'text_encoders', 'clip', 'clip_vision', 'upscale_models'}
|
||||
FOLDER_DEFAULTS_VERSION = 2
|
||||
|
||||
DEFAULT_PHYSICAL_FOLDER_NAMES = {
|
||||
'checkpoints', 'loras', 'unet', 'diffusion_models', 'controlnet', 'vae'
|
||||
'checkpoints', 'loras', 'unet', 'diffusion_models', 'controlnet', 'vae',
|
||||
'text_encoders', 'clip', 'clip_vision', 'upscale_models',
|
||||
}
|
||||
|
||||
|
||||
def config_path():
|
||||
return os.path.join(os.path.dirname(os.path.abspath(__file__)), "config.json")
|
||||
|
||||
|
||||
def upgrade_folder_defaults(path=None):
|
||||
"""Once per config.json: the folders added to the defaults are shown (and scanned) even
|
||||
where an earlier version saved them as hidden. True when the file changed."""
|
||||
path = path or config_path()
|
||||
try:
|
||||
with open(path, encoding='utf-8') as source:
|
||||
cfg = json.load(source)
|
||||
except (OSError, ValueError):
|
||||
return False # no config yet: the defaults apply as they are
|
||||
if not isinstance(cfg, dict) or int(cfg.get("folder_defaults_version") or 1) >= FOLDER_DEFAULTS_VERSION:
|
||||
return False
|
||||
for key in ("folder_types_config", "physical_folders_config"):
|
||||
for item in cfg.get(key) or []:
|
||||
if isinstance(item, dict) and item.get("type") in ADDED_IN_2:
|
||||
item["visible"] = True
|
||||
cfg["folder_defaults_version"] = FOLDER_DEFAULTS_VERSION
|
||||
atomic_write_json(path, cfg)
|
||||
return True
|
||||
|
||||
|
||||
def get_folder_view_mode():
|
||||
script_dir = os.path.dirname(os.path.abspath(__file__))
|
||||
config_path = os.path.join(script_dir, "config.json")
|
||||
@@ -149,7 +186,7 @@ def get_active_folder_types():
|
||||
config_path = os.path.join(script_dir, "config.json")
|
||||
|
||||
all_types = list(folder_paths.folder_names_and_paths.keys())
|
||||
default_types = ['checkpoints', 'loras', 'diffusion_models', 'unet', 'controlnet', 'vae']
|
||||
default_types = DEFAULT_TYPES
|
||||
|
||||
try:
|
||||
if os.path.exists(config_path):
|
||||
@@ -215,7 +252,7 @@ async def api_get_all_folder_types(request):
|
||||
else:
|
||||
# Abstract mode
|
||||
all_types = list(folder_paths.folder_names_and_paths.keys())
|
||||
default_types = ['checkpoints', 'loras', 'diffusion_models', 'controlnet', 'vae']
|
||||
default_types = DEFAULT_TYPES
|
||||
configured_types = set()
|
||||
try:
|
||||
if os.path.exists(config_path):
|
||||
|
||||
+86
-8
@@ -9,11 +9,22 @@ from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
from .image_search import filter_images
|
||||
from .media_routes import (
|
||||
CARD_POSTER_VIDEO_EXTENSIONS,
|
||||
CARD_THUMBNAIL_STATIC_EXTENSIONS,
|
||||
_build_card_thumbnail,
|
||||
_build_video_poster,
|
||||
)
|
||||
from .path_utils import require_filename, resolve_within
|
||||
from .trash import move_to_trash, trash_failure
|
||||
|
||||
|
||||
GALLERY_SNAPSHOT_SECONDS = 10
|
||||
MAX_CACHED_GALLERY_IMAGES = 50_000
|
||||
GALLERY_IMAGE_EXTENSIONS = {'.png', '.jpg', '.jpeg', '.webp', '.gif', '.avif'}
|
||||
# Videos a browser plays in the viewer; not .avi (Chrome and Edge cannot).
|
||||
GALLERY_VIDEO_EXTENSIONS = {'.mp4', '.webm', '.mov', '.mkv'}
|
||||
GALLERY_MEDIA = ("all", "image", "video")
|
||||
_gallery_snapshot_lock = threading.Lock()
|
||||
_gallery_snapshot = {"root": None, "expires": 0, "images": []}
|
||||
|
||||
@@ -22,7 +33,8 @@ def _collect_gallery_images(output_dir):
|
||||
images = []
|
||||
for root, _, files in os.walk(output_dir):
|
||||
for filename in files:
|
||||
if os.path.splitext(filename)[1].lower() not in {'.png', '.jpg', '.jpeg', '.webp', '.gif'}:
|
||||
ext = os.path.splitext(filename)[1].lower()
|
||||
if ext not in GALLERY_IMAGE_EXTENSIONS and ext not in GALLERY_VIDEO_EXTENSIONS:
|
||||
continue
|
||||
try:
|
||||
mtime = os.path.getmtime(os.path.join(root, filename))
|
||||
@@ -32,7 +44,9 @@ def _collect_gallery_images(output_dir):
|
||||
images.append({
|
||||
"filename": filename,
|
||||
"subfolder": "" if subfolder == "." else subfolder.replace(os.sep, '/'),
|
||||
"type": "output", "mtime": mtime,
|
||||
"type": "output",
|
||||
"mtime": mtime,
|
||||
"media_type": "video" if ext in GALLERY_VIDEO_EXTENSIONS else "image",
|
||||
})
|
||||
images.sort(key=lambda item: (item['mtime'], item['subfolder'], item['filename']), reverse=True)
|
||||
return images
|
||||
@@ -56,33 +70,94 @@ def _invalidate_gallery_snapshot():
|
||||
_gallery_snapshot.update(root=None, expires=0, images=[])
|
||||
|
||||
|
||||
def _gallery_listing(output_dir, refresh, query):
|
||||
def _format(filename):
|
||||
"""The format name the gallery's settings use: the extension, with .jpeg counted as jpg."""
|
||||
ext = os.path.splitext(filename)[1].lower().lstrip('.')
|
||||
return 'jpg' if ext == 'jpeg' else ext
|
||||
|
||||
|
||||
def _gallery_listing(output_dir, refresh, query, media="image", hidden=frozenset()):
|
||||
"""Outputs, newest first. `media`: "image" (the default, for callers that show pictures),
|
||||
"video" or "all"; `hidden`: format names left out (see _format)."""
|
||||
images = _gallery_images(output_dir, refresh)
|
||||
if media != "all" or hidden:
|
||||
images = [item for item in images
|
||||
if media in ("all", item["media_type"]) and _format(item["filename"]) not in hidden]
|
||||
return filter_images(os.path.realpath(output_dir), images, query) if query else images
|
||||
|
||||
|
||||
def _gallery_page_source(output_dir, refresh, query, media, hidden, kept_only=False):
|
||||
"""The listing (only the images kept as a recipe, combo or prompt when `kept_only`), and
|
||||
whether the output folder has any video (the gallery offers its Pictures / Videos switch
|
||||
only then)."""
|
||||
images = _gallery_listing(output_dir, refresh, query, media, hidden)
|
||||
if kept_only:
|
||||
from .kept_images import kept_keys # here: kept_images reaches back to this module through the stores
|
||||
kept = kept_keys()
|
||||
images = [item for item in images if (item.get("subfolder") or "", item["filename"]) in kept]
|
||||
has_videos = any(item["media_type"] == "video" for item in _gallery_images(output_dir))
|
||||
return images, has_videos
|
||||
|
||||
|
||||
async def api_get_gallery_images(request):
|
||||
"""GET /anomalous/gallery_images?page&limit&refresh&term=..&term=.. (or q) - Output images, optionally searched by embedded generation info."""
|
||||
"""GET /anomalous/gallery_images?page&limit&refresh&term=..&term=.. (or q)&media=all|image|video&hide=mkv,gif&kept=1
|
||||
- Outputs (pictures only unless `media` says otherwise), optionally searched by embedded
|
||||
generation info, without the `hide` formats; with `kept=1` only those kept as something."""
|
||||
try:
|
||||
page = max(1, int(request.query.get('page', 1)))
|
||||
limit = min(200, max(1, int(request.query.get('limit', 50))))
|
||||
# Repeated `term` params keep phrases whole; `q` is split on whitespace.
|
||||
terms = [term for term in request.query.getall('term', []) if term.strip()]
|
||||
query = terms or request.query.get('q', '').strip()
|
||||
images = await asyncio.to_thread(_gallery_listing, folder_paths.get_output_directory(), request.query.get('refresh') == '1', query)
|
||||
media = request.query.get('media', 'image')
|
||||
if media not in GALLERY_MEDIA:
|
||||
raise ValueError(media)
|
||||
hidden = frozenset(part.strip().lower().lstrip('.') for part in request.query.get('hide', '').split(','))
|
||||
images, has_videos = await asyncio.to_thread(
|
||||
_gallery_page_source, folder_paths.get_output_directory(), request.query.get('refresh') == '1',
|
||||
query, media, hidden - {''}, request.query.get('kept') == '1')
|
||||
total = len(images)
|
||||
start = (page - 1) * limit
|
||||
return web.json_response({"images": images[start:start + limit], "total": total,
|
||||
"page": page, "pages": (total + limit - 1) // limit})
|
||||
"page": page, "pages": (total + limit - 1) // limit,
|
||||
"has_videos": has_videos})
|
||||
except (TypeError, ValueError):
|
||||
return web.json_response({"error": "Invalid pagination"}, status=400)
|
||||
return web.json_response({"error": "Invalid page or filter"}, status=400)
|
||||
except OSError:
|
||||
return web.json_response({"error": "Could not list output images"}, status=500)
|
||||
|
||||
|
||||
async def api_output_thumbnail(request):
|
||||
"""GET /anomalous/output_thumbnail?filename&subfolder - the gallery grid's 512 px WebP of an
|
||||
output image/video (cached like model cards); the original stays at ComfyUI's /view."""
|
||||
output_dir = folder_paths.get_output_directory()
|
||||
try:
|
||||
filename = require_filename(request.query.get('filename'))
|
||||
file_path = resolve_within(resolve_within(output_dir, request.query.get('subfolder', '')), filename)
|
||||
except ValueError:
|
||||
return web.json_response({"status": "error", "message": "Invalid parameters"}, status=400)
|
||||
if not os.path.isfile(file_path):
|
||||
return web.json_response({"status": "error", "message": "File not found"}, status=404)
|
||||
served = file_path
|
||||
ext = os.path.splitext(file_path)[1].lower()
|
||||
if ext in CARD_THUMBNAIL_STATIC_EXTENSIONS:
|
||||
served = await asyncio.to_thread(_build_card_thumbnail, file_path)
|
||||
elif ext in CARD_POSTER_VIDEO_EXTENSIONS:
|
||||
poster = await asyncio.to_thread(_build_video_poster, file_path)
|
||||
if poster:
|
||||
served = poster
|
||||
# Revalidate (cheap 304s): an output file can be replaced under the same name.
|
||||
return web.FileResponse(served, headers={'Cache-Control': 'no-cache'})
|
||||
|
||||
|
||||
async def api_delete_gallery_image(request):
|
||||
try:
|
||||
data = await request.json()
|
||||
except ValueError:
|
||||
data = None
|
||||
if not isinstance(data, dict):
|
||||
return web.json_response({"status": "error", "message": "Invalid request body"}, status=400)
|
||||
try:
|
||||
filename = data.get("filename")
|
||||
subfolder = data.get("subfolder", "")
|
||||
|
||||
@@ -95,7 +170,10 @@ async def api_delete_gallery_image(request):
|
||||
return web.json_response({"status": "error", "message": "Invalid parameters"}, status=400)
|
||||
|
||||
if os.path.exists(file_path):
|
||||
os.remove(file_path)
|
||||
try:
|
||||
await asyncio.to_thread(move_to_trash, file_path)
|
||||
except OSError as e:
|
||||
return web.json_response({"status": "error", "message": trash_failure(e)}, status=409)
|
||||
_invalidate_gallery_snapshot()
|
||||
return web.json_response({"status": "success"})
|
||||
else:
|
||||
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
"""What a Hugging Face repository says about a model downloaded from it (model_download.py):
|
||||
the model card's first example image becomes its cover, and its trigger words, example prompts
|
||||
and base model go into its notes, with the repository as its link. Hugging Face cannot be asked
|
||||
by fingerprint, so this works only for files downloaded from it (the repository is known then).
|
||||
|
||||
Nothing the user or a scan already has is replaced: a cover only when the model has none, notes
|
||||
and link only when empty (in the user's layer, <model>.anomalous.json).
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
from .model_constants import MEDIA_EXTENSIONS, PREVIEW_SUFFIXES
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
try:
|
||||
from ..model_identity import USER_INFO_SUFFIX, read_json
|
||||
from ..model_sidecars import target
|
||||
from ..civitai_client import USER_AGENT
|
||||
from ..net_proxy import urlopen
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from model_identity import USER_INFO_SUFFIX, read_json
|
||||
from model_sidecars import target
|
||||
from civitai_client import USER_AGENT
|
||||
from net_proxy import urlopen
|
||||
|
||||
TIMEOUT = 15
|
||||
MAX_COVER_BYTES = 20 * 1024 * 1024
|
||||
IMAGE_TYPES = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp", "image/gif": ".gif"}
|
||||
IMAGE_FILE = (".png", ".jpg", ".jpeg", ".webp")
|
||||
HF_HOSTS = ("huggingface.co", "hf-mirror.com")
|
||||
MAX_PROMPTS = 3
|
||||
|
||||
|
||||
def repo_of(url):
|
||||
"""("org/name", host) of a Hugging Face file link, or None."""
|
||||
parsed = urllib.parse.urlsplit(url)
|
||||
parts = [part for part in parsed.path.split("/") if part]
|
||||
if (parsed.hostname or "") not in HF_HOSTS or "resolve" not in parts or parts.index("resolve") < 2:
|
||||
return None
|
||||
return "/".join(parts[:2]), parsed.hostname
|
||||
|
||||
|
||||
def _get(url, limit=None):
|
||||
request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
|
||||
with urlopen(request, timeout=TIMEOUT) as response:
|
||||
data = response.read(limit + 1 if limit else -1)
|
||||
return data, str(response.headers.get("Content-Type", "")).split(";")[0].strip().lower()
|
||||
|
||||
|
||||
def _file_url(repo, host, path):
|
||||
"""A link to a file of the repository, on `host` (the mirror when the download used it)."""
|
||||
if path.startswith(("https://", "http://")):
|
||||
parsed = urllib.parse.urlsplit(path)
|
||||
if parsed.hostname not in HF_HOSTS:
|
||||
return ""
|
||||
return urllib.parse.urlunsplit(("https", host, parsed.path, parsed.query, ""))
|
||||
return f"https://{host}/{repo}/resolve/main/{urllib.parse.quote(path.lstrip('/'))}"
|
||||
|
||||
|
||||
def _as_list(value):
|
||||
if isinstance(value, str):
|
||||
return [value] if value.strip() else []
|
||||
return [str(item) for item in value if str(item).strip()] if isinstance(value, list) else []
|
||||
|
||||
|
||||
def read_card(repo, host):
|
||||
"""{images, prompts, trigger, base} from the repository's model card (empty when it has none)."""
|
||||
data, _type = _get(f"https://{host}/api/models/{repo}?expand[]=cardData&expand[]=siblings")
|
||||
info = json.loads(data.decode("utf-8"))
|
||||
card = info.get("cardData") or {}
|
||||
widgets = [item for item in card.get("widget") or [] if isinstance(item, dict)]
|
||||
images = [(item.get("output") or {}).get("url") for item in widgets]
|
||||
images = [url for url in (_file_url(repo, host, str(path)) for path in images if path) if url]
|
||||
if not images: # no examples in the card: the repository's own pictures
|
||||
files = [item.get("rfilename", "") for item in info.get("siblings") or [] if isinstance(item, dict)]
|
||||
images = [_file_url(repo, host, name) for name in files if name.lower().endswith(IMAGE_FILE)][:1]
|
||||
prompts = [str(item.get("text")).strip() for item in widgets if isinstance(item.get("text"), str) and item["text"].strip()]
|
||||
return {"images": images, "prompts": prompts[:MAX_PROMPTS],
|
||||
"trigger": _as_list(card.get("instance_prompt")), "base": _as_list(card.get("base_model"))}
|
||||
|
||||
|
||||
def save_cover(image_url, base_path):
|
||||
"""The image as the model's cover (<model>.preview.<ext>) when it has none yet; True if saved."""
|
||||
if any(os.path.exists(base_path + suffix) for suffix in PREVIEW_SUFFIXES + MEDIA_EXTENSIONS):
|
||||
return False
|
||||
data, content_type = _get(image_url, MAX_COVER_BYTES)
|
||||
extension = IMAGE_TYPES.get(content_type)
|
||||
if not extension or len(data) > MAX_COVER_BYTES:
|
||||
return False
|
||||
target = base_path + ".preview" + extension
|
||||
temporary = target + ".part"
|
||||
with open(temporary, "wb") as output:
|
||||
output.write(data)
|
||||
os.replace(temporary, target)
|
||||
return True
|
||||
|
||||
|
||||
def notes_text(repo, card):
|
||||
lines = [f"Hugging Face: {repo}"]
|
||||
if card["base"]:
|
||||
lines.append("Base model: " + ", ".join(card["base"]))
|
||||
if card["trigger"]:
|
||||
lines.append("Trigger words: " + ", ".join(card["trigger"]))
|
||||
if card["prompts"]:
|
||||
lines.append("Example prompts:")
|
||||
lines.extend("- " + prompt[:400] for prompt in card["prompts"])
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def save_notes(base_path, repo, card):
|
||||
"""The card's words as the model's notes and the repository as its link, where both are empty."""
|
||||
path = target(base_path, USER_INFO_SUFFIX)
|
||||
if os.path.exists(path) and read_json(path) is None:
|
||||
return False # unreadable: leave it to the user
|
||||
user = read_json(path) or {"format": 1}
|
||||
changed = False
|
||||
if not str(user.get("custom_notes") or "").strip():
|
||||
user["custom_notes"] = notes_text(repo, card)
|
||||
changed = True
|
||||
if not str(user.get("source_url") or "").strip():
|
||||
user["source_url"] = f"https://huggingface.co/{repo}"
|
||||
changed = True
|
||||
if changed:
|
||||
atomic_write_json(path, user)
|
||||
return changed
|
||||
|
||||
|
||||
def enrich(model_path, download_url):
|
||||
"""Cover and notes for a model just downloaded from Hugging Face: {cover, notes}."""
|
||||
located = repo_of(download_url)
|
||||
if not located:
|
||||
return {"cover": False, "notes": False}
|
||||
repo, host = located
|
||||
base_path = os.path.splitext(model_path)[0]
|
||||
card = read_card(repo, host)
|
||||
cover = False
|
||||
for image in card["images"][:2]:
|
||||
try:
|
||||
cover = save_cover(image, base_path)
|
||||
break
|
||||
except OSError:
|
||||
continue
|
||||
return {"cover": cover, "notes": save_notes(base_path, repo, card)}
|
||||
+7
-2
@@ -76,11 +76,12 @@ def _normalise_model_ref(value):
|
||||
|
||||
|
||||
def build_record(path):
|
||||
"""Searchable text, recorded model hashes and referenced model files for one image."""
|
||||
"""Searchable text, recorded model hashes, referenced model files and node types for one image."""
|
||||
name = os.path.basename(path)
|
||||
texts = [name]
|
||||
hashes = set()
|
||||
models = set()
|
||||
types = set()
|
||||
if path.lower().endswith(".png"):
|
||||
try:
|
||||
chunks = read_png_text(path)
|
||||
@@ -92,7 +93,11 @@ def build_record(path):
|
||||
if not isinstance(node, dict):
|
||||
continue
|
||||
texts.append(str(node.get("class_type", "")))
|
||||
if isinstance(node.get("class_type"), str):
|
||||
types.add(node["class_type"])
|
||||
for key, value in (node.get("inputs") or {}).items():
|
||||
if isinstance(value, dict) and isinstance(value.get("lora"), str):
|
||||
value = value["lora"] # a row of rgthree's Power Lora Loader
|
||||
if isinstance(value, str):
|
||||
texts.append(value)
|
||||
if MODEL_FILE.search(value):
|
||||
@@ -111,7 +116,7 @@ def build_record(path):
|
||||
models |= _normalise_model_ref(model_name)
|
||||
if chunks.get("parameters"):
|
||||
texts.append(chunks["parameters"])
|
||||
return {"text": "\n".join(texts).lower(), "hashes": hashes, "models": models}
|
||||
return {"text": "\n".join(texts).lower(), "hashes": hashes, "models": models, "types": types}
|
||||
|
||||
|
||||
def _load_json(raw):
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
"""What each output image was kept as (GET /anomalous/kept_images), for the gallery's star:
|
||||
the Workflow Recipe whose source image it is, the combo made from it (a notebook file with
|
||||
`source_image`), the saved prompt taken from it (a prompt plan material whose source names
|
||||
the image). Each is {filename, name}, or null when the image was not kept as that."""
|
||||
|
||||
import asyncio
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from .material_store import _list_materials, get_materials_dir
|
||||
from .notebooks import _list_notebooks
|
||||
from .recipe_store import _list_recipes, get_recipes_dir
|
||||
|
||||
KINDS = ("recipe", "combo", "prompt")
|
||||
|
||||
|
||||
def _kept_images():
|
||||
kept = {}
|
||||
|
||||
def mark(image, kind, filename, name):
|
||||
if not isinstance(image, dict) or not isinstance(image.get("filename"), str) or not image["filename"]:
|
||||
return
|
||||
subfolder = image.get("subfolder") if isinstance(image.get("subfolder"), str) else ""
|
||||
entry = kept.setdefault((subfolder, image["filename"]), dict.fromkeys(KINDS))
|
||||
if entry[kind] is None:
|
||||
entry[kind] = {"filename": filename, "name": str(name or "")}
|
||||
|
||||
for recipe in _list_recipes(get_recipes_dir()):
|
||||
mark(recipe["data"].get("source_image"), "recipe", recipe["filename"], recipe["data"].get("name"))
|
||||
for note in _list_notebooks():
|
||||
mark(note["data"].get("source_image"), "combo", note["filename"], note["name"])
|
||||
for material in _list_materials(get_materials_dir()):
|
||||
if material.get("kind") == "prompt_plan":
|
||||
mark(material.get("source_image"), "prompt", material["filename"], material.get("name"))
|
||||
return [{"subfolder": subfolder, "filename": filename, **entry} for (subfolder, filename), entry in kept.items()]
|
||||
|
||||
|
||||
def kept_keys():
|
||||
"""{(subfolder, filename)} of every output image kept as anything (the gallery's ★ view)."""
|
||||
return {(item["subfolder"], item["filename"]) for item in _kept_images()}
|
||||
|
||||
|
||||
async def api_kept_images(request):
|
||||
try:
|
||||
images = await asyncio.to_thread(_kept_images)
|
||||
except (OSError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Could not list kept images"}, status=500)
|
||||
return web.json_response({"status": "success", "images": images})
|
||||
@@ -0,0 +1,117 @@
|
||||
"""What only this computer may do. ComfyUI started with --listen lets other devices on the
|
||||
network open the page: they may look (lists, searches, pictures, covers), but every change
|
||||
under /anomalous/ (writing, moving and deleting files, downloads, scans, translations, backups,
|
||||
version switches, saved settings) answers only requests from the computer ComfyUI runs on
|
||||
(AGENTS.md 安全底线, rule 4). One middleware decides it for all routes: a request other than
|
||||
GET is local-only unless it is a read sent as POST (OPEN_POSTS); a GET is open unless it is not
|
||||
a plain read (LOCAL_GETS). A request is local when it comes from a loopback address, through no
|
||||
proxy, naming a loopback host; checking the Host also keeps out a page that reached this server
|
||||
under another name (DNS rebinding).
|
||||
|
||||
ComfyUI on a rented cloud server is only ever opened from another device. An empty file named
|
||||
`allow_remote_changes` in the plugin's folder, made on that server, lets every device that can
|
||||
open the page change things too (may_change); it is read once, when ComfyUI starts, and the
|
||||
page cannot make or remove it. MCP keeps to this computer either way."""
|
||||
|
||||
import ipaddress
|
||||
import os
|
||||
import shlex
|
||||
import urllib.parse
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
PREFIX = "/anomalous/"
|
||||
PROXY_HEADERS = ("Forwarded", "X-Forwarded-For", "X-Real-IP", "X-Forwarded-Host")
|
||||
LOCAL_NAMES = ("localhost",)
|
||||
# Reads sent as POST (their lists are long): open to other devices too. They write nothing.
|
||||
OPEN_POSTS = frozenset({
|
||||
"/anomalous/resolve_paths_to_previews",
|
||||
"/anomalous/resolve_hash_batch",
|
||||
"/anomalous/inspect_image_material",
|
||||
})
|
||||
# GETs that are more than a read: a backup of all your data, a call to GitHub, your folders.
|
||||
LOCAL_GETS = frozenset({
|
||||
"/anomalous/backup/file",
|
||||
"/anomalous/version/releases",
|
||||
"/anomalous/tts_version/releases",
|
||||
"/anomalous/import/folders",
|
||||
"/anomalous/civitai_check",
|
||||
"/anomalous/usage/check", # reads every output and saved workflow
|
||||
})
|
||||
# Routes that answer other devices themselves (MCP replies in JSON-RPC).
|
||||
OWN_CHECK = frozenset({"/anomalous/mcp"})
|
||||
READS = ("GET", "HEAD", "OPTIONS")
|
||||
REMOTE_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "allow_remote_changes")
|
||||
REMOTE_CHANGES = os.path.isfile(REMOTE_FILE)
|
||||
if REMOTE_CHANGES:
|
||||
print("[Anomalous Browser] allow_remote_changes 文件存在：任何能打开页面的设备都能扫描、移动、删除模型和改设置。"
|
||||
" The allow_remote_changes file is there: every device that can open the page may change things.", flush=True)
|
||||
MESSAGE = ("只能在运行 ComfyUI 的电脑上操作，别的设备只能浏览。"
|
||||
" Only the computer ComfyUI runs on can do this; other devices can only look.")
|
||||
|
||||
|
||||
def loopback_host(name):
|
||||
if not name:
|
||||
return False
|
||||
name = name.strip("[]").lower()
|
||||
if name in LOCAL_NAMES:
|
||||
return True
|
||||
try:
|
||||
return ipaddress.ip_address(name).is_loopback
|
||||
except ValueError:
|
||||
return False
|
||||
|
||||
|
||||
def is_local(request):
|
||||
"""The request comes from this computer, directly, and names a loopback host."""
|
||||
if not loopback_host(request.remote or ""):
|
||||
return False
|
||||
if any(header in request.headers for header in PROXY_HEADERS):
|
||||
return False
|
||||
return loopback_host(urllib.parse.urlsplit("//" + request.headers.get("Host", "")).hostname)
|
||||
|
||||
|
||||
def may_change(request):
|
||||
"""The request may change things: it comes from this computer, or remote changes are allowed."""
|
||||
return REMOTE_CHANGES or is_local(request)
|
||||
|
||||
|
||||
def needs_local(method, path):
|
||||
"""Whether a request to `path` with `method` must come from this computer."""
|
||||
if not path.startswith(PREFIX) or path in OWN_CHECK:
|
||||
return False
|
||||
if method.upper() in READS:
|
||||
return path in LOCAL_GETS
|
||||
return path not in OPEN_POSTS
|
||||
|
||||
|
||||
def refusal():
|
||||
return web.json_response({"status": "error", "success": False, "error": "local_only", "code": "local_only",
|
||||
"message": MESSAGE}, status=403)
|
||||
|
||||
|
||||
@web.middleware
|
||||
async def local_only_middleware(request, handler):
|
||||
if needs_local(request.method, request.path) and not may_change(request):
|
||||
return refusal()
|
||||
return await handler(request)
|
||||
|
||||
|
||||
def switch_command():
|
||||
"""The line to paste into the server's terminal that makes the allow_remote_changes file, or
|
||||
removes it when it is there. On Windows `echo off >` makes the file in cmd and PowerShell
|
||||
alike (only that it exists counts)."""
|
||||
if os.name == "nt":
|
||||
return f'del "{REMOTE_FILE}"' if REMOTE_CHANGES else f'echo off > "{REMOTE_FILE}"'
|
||||
return ("rm -f " if REMOTE_CHANGES else "touch ") + shlex.quote(REMOTE_FILE)
|
||||
|
||||
|
||||
async def api_access(request):
|
||||
"""GET /anomalous/access - whether this page is on this computer and whether it may change
|
||||
things: {"local": bool, "changes": bool}; for another device also "command", the line that
|
||||
turns remote changes on or off (it only runs where someone types it, on the server)."""
|
||||
local = is_local(request)
|
||||
answer = {"local": local, "changes": may_change(request)}
|
||||
if not local:
|
||||
answer["command"] = switch_command()
|
||||
return web.json_response(answer)
|
||||
@@ -0,0 +1,40 @@
|
||||
"""What a LoRA file trains, read from its safetensors header: whether it also has text-encoder
|
||||
weights, so inserting it wires the CLIP line too (graph_splice.js planLoraInsertion).
|
||||
|
||||
GET /anomalous/lora_info?name=<the loader's lora_name> -> {text_encoder}.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import struct
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
# Key prefixes of text-encoder weights: kohya lora_te / lora_te1 / lora_te2, te1 / te2, diffusers text_encoder.
|
||||
TEXT_ENCODER_KEYS = ("lora_te", "te_", "te1", "te2", "text_encoder")
|
||||
MAX_HEADER_BYTES = 100 * 1024 * 1024
|
||||
|
||||
|
||||
def trains_text_encoder(path):
|
||||
"""Whether the LoRA at `path` has text-encoder weights. Other formats, or a header that
|
||||
cannot be read, count as yes: the CLIP line then goes through it, which costs nothing."""
|
||||
if not str(path).lower().endswith(".safetensors"):
|
||||
return True
|
||||
try:
|
||||
with open(path, "rb") as source:
|
||||
size = struct.unpack("<Q", source.read(8))[0]
|
||||
if size > MAX_HEADER_BYTES:
|
||||
return True
|
||||
keys = json.loads(source.read(size))
|
||||
except (OSError, ValueError, struct.error):
|
||||
return True
|
||||
return any(key.startswith(TEXT_ENCODER_KEYS) for key in keys if key != "__metadata__")
|
||||
|
||||
|
||||
async def api_lora_info(request):
|
||||
name = request.query.get("name", "")
|
||||
path = folder_paths.get_full_path("loras", name) if name else None # only names ComfyUI lists
|
||||
if not path:
|
||||
return web.json_response({"error": "Unknown LoRA"}, status=404)
|
||||
return web.json_response({"text_encoder": await asyncio.to_thread(trains_text_encoder, path)})
|
||||
@@ -0,0 +1,108 @@
|
||||
"""Where ComfyUI-Manager's model list says a model file comes from, for Model Check's downloads
|
||||
(download_sources.find_source). The list (model-list.json, a few hundred common models: base
|
||||
models, VAEs, text encoders, upscalers, ControlNets… mostly on Hugging Face) is read from the
|
||||
Manager installed here; without it there is nothing to find. A list entry is only a file of the
|
||||
same name: download_sources checks it against the workflow's fingerprint, or offers it as such.
|
||||
"""
|
||||
|
||||
import importlib.util
|
||||
import json
|
||||
import os
|
||||
|
||||
import folder_paths
|
||||
|
||||
# The list's model types and save paths -> ComfyUI folder types.
|
||||
TYPE_FOLDERS = {
|
||||
"checkpoint": "checkpoints", "checkpoints": "checkpoints", "lora": "loras", "loras": "loras",
|
||||
"vae": "vae", "taesd": "vae_approx", "vae_approx": "vae_approx", "clip": "text_encoders",
|
||||
"text_encoders": "text_encoders", "clip_vision": "clip_vision", "unet": "diffusion_models",
|
||||
"diffusion_model": "diffusion_models", "diffusion_models": "diffusion_models", "controlnet": "controlnet",
|
||||
"upscale": "upscale_models", "upscale_models": "upscale_models", "embeddings": "embeddings",
|
||||
"embedding": "embeddings", "gligen": "gligen", "style_models": "style_models",
|
||||
}
|
||||
# ComfyUI's older names for the same folders.
|
||||
SAME_FOLDER = {"unet": "diffusion_models", "clip": "text_encoders"}
|
||||
|
||||
_cache = {"path": "", "mtime": 0.0, "index": {}}
|
||||
|
||||
|
||||
def list_path():
|
||||
"""The Manager's model-list.json on this computer, or ''."""
|
||||
roots = []
|
||||
try:
|
||||
roots = list(folder_paths.get_folder_paths("custom_nodes") or [])
|
||||
except Exception:
|
||||
pass
|
||||
for root in roots:
|
||||
try:
|
||||
names = sorted(os.listdir(root))
|
||||
except OSError:
|
||||
continue
|
||||
for name in names:
|
||||
path = os.path.join(root, name, "model-list.json")
|
||||
if "manager" in name.lower() and os.path.isfile(path):
|
||||
return path
|
||||
try: # the Manager installed as a Python package
|
||||
spec = importlib.util.find_spec("comfyui_manager")
|
||||
for location in (spec.submodule_search_locations or []) if spec else []:
|
||||
path = os.path.join(location, "model-list.json")
|
||||
if os.path.isfile(path):
|
||||
return path
|
||||
except (ImportError, ValueError):
|
||||
pass
|
||||
return ""
|
||||
|
||||
|
||||
def site_of(url):
|
||||
"""Where a list entry's file is: the host and, on Hugging Face or GitHub, the repository."""
|
||||
parts = str(url or "").split("/")
|
||||
if len(parts) < 3:
|
||||
return ""
|
||||
host = parts[2].lower()
|
||||
return "/".join([host, *parts[3:5]]) if host in ("huggingface.co", "hf-mirror.com", "github.com") and len(parts) >= 5 else host
|
||||
|
||||
|
||||
def _folder(entry):
|
||||
path = str(entry.get("save_path") or "").replace("\\", "/").strip("/")
|
||||
first = path.split("/")[0].lower() if path and path != "default" else ""
|
||||
return TYPE_FOLDERS.get(first) or TYPE_FOLDERS.get(str(entry.get("type") or "").lower(), "")
|
||||
|
||||
|
||||
def _index():
|
||||
path = list_path()
|
||||
if not path:
|
||||
return {}
|
||||
try:
|
||||
mtime = os.path.getmtime(path)
|
||||
except OSError:
|
||||
return {}
|
||||
if path != _cache["path"] or mtime != _cache["mtime"]:
|
||||
index = {}
|
||||
try:
|
||||
with open(path, encoding="utf-8") as source:
|
||||
models = json.load(source).get("models") or []
|
||||
except (OSError, ValueError, AttributeError):
|
||||
models = []
|
||||
for entry in models:
|
||||
if not isinstance(entry, dict) or not entry.get("filename") or not str(entry.get("url", "")).startswith("https://"):
|
||||
continue
|
||||
index.setdefault(str(entry["filename"]).lower(), []).append({
|
||||
"name": str(entry.get("name") or entry["filename"]), "url": entry["url"],
|
||||
"folder": _folder(entry), "base": str(entry.get("base") or ""),
|
||||
})
|
||||
_cache.update(path=path, mtime=mtime, index=index)
|
||||
return _cache["index"]
|
||||
|
||||
|
||||
def candidates(file_name, folder_type=""):
|
||||
"""The list's entries for a file of this name (any case) that fit `folder_type`, one per URL.
|
||||
When the node's folder type is known, an entry whose type the list does not say does not fit."""
|
||||
wanted = SAME_FOLDER.get(folder_type, folder_type)
|
||||
seen, found = set(), []
|
||||
for entry in _index().get(os.path.basename(str(file_name)).lower(), []):
|
||||
if wanted and SAME_FOLDER.get(entry["folder"], entry["folder"]) != wanted:
|
||||
continue
|
||||
if entry["url"] not in seen:
|
||||
seen.add(entry["url"])
|
||||
found.append(entry)
|
||||
return found
|
||||
@@ -25,6 +25,8 @@ def _material_assets_dir(materials_dir, filename, create=False):
|
||||
|
||||
def _inspect_source_image(source_image):
|
||||
source = _normalise_source_image(source_image)
|
||||
if source is None:
|
||||
raise ValueError("Missing source image")
|
||||
if not source["filename"].lower().endswith(".png"):
|
||||
raise ValueError("Only PNG output images can contain reusable workflow metadata")
|
||||
source_path = _output_source_path(source)
|
||||
|
||||
@@ -371,6 +371,14 @@ def _recipe_link_fingerprint(recipe):
|
||||
return hashlib.sha256(payload).hexdigest()
|
||||
|
||||
|
||||
def _summary_source_image(source):
|
||||
"""The output image a material was taken from, as {filename, subfolder}, or None."""
|
||||
image = source.get("image")
|
||||
if not isinstance(image, dict) or not isinstance(image.get("filename"), str) or not image["filename"]:
|
||||
return None
|
||||
return {"filename": image["filename"], "subfolder": image.get("subfolder") if isinstance(image.get("subfolder"), str) else ""}
|
||||
|
||||
|
||||
def _material_summary(filename, material):
|
||||
image = material.get("image") or {}
|
||||
source = material.get("source") if isinstance(material.get("source"), dict) else {}
|
||||
@@ -398,6 +406,8 @@ def _material_summary(filename, material):
|
||||
"label": str(source.get("parameter_name") or source.get("recipe_name") or source.get("notebook_name") or "").strip(),
|
||||
},
|
||||
"source_fingerprint": str(source.get("parameter_signature") or image.get("source_sha256") or ""),
|
||||
"moved_to_recipe": str(material.get("moved_to_recipe") or ""),
|
||||
"source_image": _summary_source_image(source),
|
||||
}
|
||||
if source.get("recipe_filename"):
|
||||
summary["source_recipe"] = {
|
||||
|
||||
+17
-50
@@ -19,11 +19,10 @@ from .material_schema import (
|
||||
_normalise_prompt_plan,
|
||||
_recipe_link_fingerprint,
|
||||
)
|
||||
from .parameters import get_parameters_dir
|
||||
from .recipe_constants import MAX_RECIPE_BYTES
|
||||
from .recipe_store import _read_recipe, get_recipes_dir
|
||||
from .trash import move_to_trash
|
||||
from .utils import atomic_write_json as _atomic_write_json, require_filename, resolve_within
|
||||
from .workflow_schema import _parameter_signature, _validate_workflow
|
||||
|
||||
|
||||
_material_write_lock = threading.RLock()
|
||||
@@ -58,47 +57,6 @@ def _read_material(path):
|
||||
return value
|
||||
|
||||
|
||||
def _read_parameter_source(recipe_filename, parameter_filename=None):
|
||||
recipe_filename = require_filename(recipe_filename)
|
||||
if not recipe_filename.endswith(".json") or recipe_filename.startswith("."):
|
||||
raise ValueError("Invalid recipe filename")
|
||||
recipe_path = resolve_within(get_recipes_dir(), recipe_filename)
|
||||
if os.path.getsize(recipe_path) > MAX_RECIPE_BYTES:
|
||||
raise ValueError("Recipe source is too large")
|
||||
recipe = _read_recipe(recipe_path)
|
||||
source = recipe
|
||||
if parameter_filename:
|
||||
parameter_filename = require_filename(parameter_filename)
|
||||
if not parameter_filename.endswith(".json") or parameter_filename.startswith("."):
|
||||
raise ValueError("Invalid parameter filename")
|
||||
parameter_path = resolve_within(get_parameters_dir(), parameter_filename)
|
||||
if os.path.getsize(parameter_path) > MAX_RECIPE_BYTES:
|
||||
raise ValueError("Parameter notebook is too large")
|
||||
with open(parameter_path, "r", encoding="utf-8") as parameter_file:
|
||||
source = json.load(parameter_file)
|
||||
if not isinstance(source, dict) or source.get("recipe_filename") != recipe_filename:
|
||||
raise ValueError("Parameter notebook does not belong to recipe")
|
||||
workflow = source.get("workflow") if isinstance(source, dict) else None
|
||||
if not isinstance(workflow, dict):
|
||||
raise ValueError("Parameter source has no workflow")
|
||||
_validate_workflow(workflow)
|
||||
return recipe_filename, parameter_filename, recipe, source, workflow
|
||||
|
||||
|
||||
def _parameter_source_record(recipe_filename, parameter_filename, recipe, source, workflow):
|
||||
record = {
|
||||
"type": "recipe_parameter_notebook" if parameter_filename else "workflow_recipe",
|
||||
**_snapshot_recipe_source(recipe_filename),
|
||||
"parameter_signature": (_parameter_signature(workflow) or {}).get("value") or "",
|
||||
}
|
||||
if parameter_filename:
|
||||
record["parameter_filename"] = parameter_filename
|
||||
record["parameter_name"] = str(source.get("name") or "").strip()[:200]
|
||||
elif isinstance(recipe, dict):
|
||||
record["parameter_name"] = str(recipe.get("name") or "").strip()[:200]
|
||||
return record
|
||||
|
||||
|
||||
def _snapshot_recipe_source(recipe_filename):
|
||||
if not recipe_filename:
|
||||
return {}
|
||||
@@ -253,14 +211,17 @@ def _query_materials(materials_dir, query):
|
||||
if len(node_type) > 200:
|
||||
raise ValueError("Invalid node type")
|
||||
if len(search) > 200 or len(tag) > 60 or kind not in (
|
||||
"", "image_workflow_snapshot", "image_node_selection", "recipe_parameter_selection", "prompt_note_bundle", "prompt_text", "prompt_plan"
|
||||
"", "image_workflow_snapshot", "image_node_selection", "recipe_parameter_selection", "node_parameter_selection",
|
||||
"prompt_note_bundle", "prompt_text", "prompt_plan"
|
||||
):
|
||||
raise ValueError("Invalid material filter")
|
||||
# Whole workflows live with the recipes: "all" is the pieces, and one moved there is not listed.
|
||||
materials = [material for material in materials
|
||||
if (not search or search in " ".join([material["name"], *material["node_types"], *material.get("tags", [])]).casefold())
|
||||
if not material.get("moved_to_recipe")
|
||||
and (not search or search in " ".join([material["name"], *material["node_types"], *material.get("tags", [])]).casefold())
|
||||
and (not tag or tag in [value.casefold() for value in material.get("tags", [])])
|
||||
and (not kind or material["kind"] == kind)
|
||||
and (category == "all" or _material_category(material) == category)
|
||||
and (_material_category(material) == category if category != "all" else _material_category(material) != "workflow")
|
||||
and (not node_type or node_type in material["node_types"])]
|
||||
total = len(materials)
|
||||
limit = min(100, max(1, int(query.get("limit", 48))))
|
||||
@@ -288,10 +249,16 @@ def _update_material_details(materials_dir, filename, name, tags, prompt_role_ov
|
||||
return _with_live_recipe_source(_material_summary(filename, material))
|
||||
|
||||
|
||||
def _mark_material_moved(materials_dir, filename, recipe_filename):
|
||||
"""Notes that a kept workflow now lives as recipe `recipe_filename`; the material file stays."""
|
||||
with _material_write_lock:
|
||||
path = resolve_within(materials_dir, filename)
|
||||
material = _read_material(path)
|
||||
material["moved_to_recipe"] = recipe_filename
|
||||
_atomic_write_json(path, material)
|
||||
|
||||
|
||||
def _delete_material(materials_dir, filename, path):
|
||||
with _material_write_lock:
|
||||
_read_material(path)
|
||||
os.remove(path)
|
||||
assets_dir = _material_assets_dir(materials_dir, filename)
|
||||
if os.path.isdir(assets_dir):
|
||||
shutil.rmtree(assets_dir)
|
||||
move_to_trash(path, _material_assets_dir(materials_dir, filename))
|
||||
|
||||
+33
-148
@@ -25,16 +25,13 @@ from .material_schema import (
|
||||
_normalise_material_tags,
|
||||
_normalise_prompt_role_overrides,
|
||||
_normalise_selected_node_ids,
|
||||
_parameter_signature,
|
||||
_prompt_excerpt,
|
||||
_prompt_groups_from_roles,
|
||||
_prompt_roles_for_workflow,
|
||||
_workflow_hashes_for_blocks,
|
||||
)
|
||||
from .notebooks import MAX_NOTEBOOK_BYTES
|
||||
from .parameters import get_parameters_dir
|
||||
from .recipe_constants import MAX_RECIPE_BYTES
|
||||
from .recipe_schema import _build_model_references
|
||||
from .recipe_schema import _build_model_references, _normalise_source_image
|
||||
from .recipe_store import get_recipes_dir
|
||||
from .utils import atomic_write_json as _atomic_write_json, require_filename, resolve_within
|
||||
|
||||
@@ -43,8 +40,6 @@ MATERIAL_SCHEMA_VERSION = 1
|
||||
|
||||
_store_get_materials_dir = _store.get_materials_dir
|
||||
_store_read_material = _store._read_material
|
||||
_store_read_parameter_source = _store._read_parameter_source
|
||||
_store_parameter_source_record = _store._parameter_source_record
|
||||
_store_snapshot_recipe_source = _store._snapshot_recipe_source
|
||||
_store_live_recipe_source = _store._live_recipe_source
|
||||
_store_with_live_recipe_source = _store._with_live_recipe_source
|
||||
@@ -89,16 +84,6 @@ def _read_material(path):
|
||||
return _store_read_material(path)
|
||||
|
||||
|
||||
def _read_parameter_source(recipe_filename, parameter_filename=None):
|
||||
_store.get_recipes_dir = get_recipes_dir
|
||||
_store.get_parameters_dir = get_parameters_dir
|
||||
return _store_read_parameter_source(recipe_filename, parameter_filename)
|
||||
|
||||
|
||||
def _parameter_source_record(recipe_filename, parameter_filename, recipe, source, workflow):
|
||||
return _store_parameter_source_record(recipe_filename, parameter_filename, recipe, source, workflow)
|
||||
|
||||
|
||||
def _snapshot_recipe_source(filename):
|
||||
_store.get_recipes_dir = get_recipes_dir
|
||||
return _store_snapshot_recipe_source(filename)
|
||||
@@ -263,136 +248,6 @@ async def api_save_image_material(request):
|
||||
})
|
||||
|
||||
|
||||
async def api_save_parameter_material(request):
|
||||
try:
|
||||
payload = await request.json()
|
||||
recipe_filename, parameter_filename, recipe, source, workflow = await asyncio.to_thread(
|
||||
_read_parameter_source,
|
||||
payload.get("recipe_filename", ""),
|
||||
payload.get("parameter_filename"),
|
||||
)
|
||||
source_name = str(source.get("name") or recipe.get("name") or "参数素材").strip()
|
||||
name = payload.get("name") or source_name
|
||||
if not isinstance(name, str) or not (name := name.strip()) or len(name) > MAX_MATERIAL_NAME_LENGTH:
|
||||
raise ValueError("Invalid material name")
|
||||
tags = _normalise_material_tags(payload.get("tags", recipe.get("tags") or []))
|
||||
allow_duplicate = payload.get("allow_duplicate", False)
|
||||
if not isinstance(allow_duplicate, bool):
|
||||
raise ValueError("Invalid duplicate preference")
|
||||
|
||||
reusable_ids = [
|
||||
node.get("id") for node in workflow.get("nodes", [])
|
||||
if isinstance(node, dict) and node.get("id") is not None
|
||||
and isinstance(node.get("widgets_values"), list) and node.get("widgets_values")
|
||||
]
|
||||
raw_selection = payload.get("selected_node_ids")
|
||||
selected_node_ids = _normalise_selected_node_ids(
|
||||
workflow,
|
||||
reusable_ids if raw_selection is None else raw_selection,
|
||||
)
|
||||
reusable_keys = {str(value) for value in reusable_ids}
|
||||
if any(str(value) not in reusable_keys for value in selected_node_ids):
|
||||
raise ValueError("Selected node has no reusable parameters")
|
||||
selected_keys = {str(value) for value in selected_node_ids}
|
||||
blocks = [
|
||||
block for block in _node_blocks(workflow, include_values=False)
|
||||
if str(block.get("node_id")) in selected_keys
|
||||
]
|
||||
references = [
|
||||
reference for reference in _build_model_references(source, verify_identities=False)
|
||||
if str(reference.get("node_id")) in selected_keys
|
||||
]
|
||||
source_record = _parameter_source_record(
|
||||
recipe_filename, parameter_filename, recipe, source, workflow
|
||||
)
|
||||
material_id = uuid.uuid4().hex
|
||||
filename = f"material_{int(time.time())}_{material_id}.json"
|
||||
material = {
|
||||
"schema_version": MATERIAL_SCHEMA_VERSION,
|
||||
"id": material_id,
|
||||
"kind": "recipe_parameter_selection",
|
||||
"name": name,
|
||||
"tags": tags,
|
||||
"timestamp": int(time.time() * 1000),
|
||||
"source": source_record,
|
||||
"workflow": workflow,
|
||||
"model_references": references,
|
||||
"capabilities": ["apply_node_parameters"],
|
||||
"selection": {"scope": "nodes", "node_ids": selected_node_ids},
|
||||
}
|
||||
params = source.get("params") if isinstance(source.get("params"), dict) else {}
|
||||
prompt_role_overrides = _normalise_prompt_role_overrides(params.get("promptRoleOverrides"))
|
||||
if prompt_role_overrides:
|
||||
material["promptRoleOverrides"] = prompt_role_overrides
|
||||
materials_dir = get_materials_dir()
|
||||
duplicate = await asyncio.to_thread(
|
||||
_persist_parameter_material, materials_dir, filename, material, allow_duplicate
|
||||
)
|
||||
if duplicate:
|
||||
return web.json_response({
|
||||
"status": "duplicate",
|
||||
"filename": duplicate["filename"],
|
||||
"name": duplicate["name"],
|
||||
}, status=409)
|
||||
except (AttributeError, TypeError, ValueError, json.JSONDecodeError):
|
||||
return web.json_response({"status": "error", "message": "Could not save parameter material"}, status=400)
|
||||
except FileNotFoundError:
|
||||
return web.json_response({"status": "error", "message": "Parameter source not found"}, status=404)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not save parameter material"}, status=500)
|
||||
return web.json_response({
|
||||
"status": "success",
|
||||
"filename": filename,
|
||||
"material": _with_live_recipe_source(_material_summary(filename, material)),
|
||||
"node_blocks": blocks,
|
||||
})
|
||||
|
||||
|
||||
async def api_save_prompt_note_material(request):
|
||||
try:
|
||||
payload = await request.json()
|
||||
scope = payload.get("scope", "note")
|
||||
if scope not in ("note", "prompt"):
|
||||
raise ValueError("Invalid prompt scope")
|
||||
source_filename = require_filename(payload.get("notebook_filename", ""))
|
||||
if not source_filename.endswith(".json") or source_filename.startswith("."):
|
||||
raise ValueError("Invalid notebook filename")
|
||||
name = payload.get("name", "")
|
||||
if not isinstance(name, str) or not name.strip() or len(name.strip()) > MAX_MATERIAL_NAME_LENGTH:
|
||||
raise ValueError("Invalid material name")
|
||||
note = _normalise_prompt_note(payload.get("note"), scope == "prompt")
|
||||
if scope == "prompt" and not note["promptEn"].strip():
|
||||
raise ValueError("Prompt is empty")
|
||||
tags = _normalise_material_tags(payload.get("tags", []))
|
||||
allow_duplicate = payload.get("allow_duplicate", False)
|
||||
if not isinstance(allow_duplicate, bool):
|
||||
raise ValueError("Invalid duplicate preference")
|
||||
signature = hashlib.sha256(json.dumps(note, ensure_ascii=False, sort_keys=True, allow_nan=False).encode("utf-8")).hexdigest()
|
||||
material_id = uuid.uuid4().hex
|
||||
filename = f"material_{int(time.time())}_{material_id}.json"
|
||||
material = {
|
||||
"schema_version": MATERIAL_SCHEMA_VERSION, "id": material_id,
|
||||
"kind": "prompt_text" if scope == "prompt" else "prompt_note_bundle",
|
||||
"name": name.strip(), "tags": tags, "timestamp": int(time.time() * 1000),
|
||||
"source": {"type": "prompt_note", "notebook_filename": source_filename,
|
||||
"notebook_name": name.strip(), "parameter_signature": signature},
|
||||
"note": note, "selection": {"scope": scope},
|
||||
"capabilities": ["copy_prompt", "restore_prompt_note"],
|
||||
}
|
||||
duplicate = await asyncio.to_thread(
|
||||
_persist_parameter_material, get_materials_dir(), filename, material, allow_duplicate
|
||||
)
|
||||
if duplicate:
|
||||
return web.json_response({"status": "duplicate", "filename": duplicate["filename"],
|
||||
"name": duplicate["name"]}, status=409)
|
||||
return web.json_response({"status": "success", "filename": filename,
|
||||
"material": _material_summary(filename, material)})
|
||||
except (AttributeError, TypeError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Invalid prompt note material"}, status=400)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not save prompt note material"}, status=500)
|
||||
|
||||
|
||||
async def api_save_prompt_plan(request):
|
||||
try:
|
||||
payload = await request.json()
|
||||
@@ -404,13 +259,16 @@ async def api_save_prompt_plan(request):
|
||||
allow_duplicate = payload.get("allow_duplicate", False)
|
||||
if not isinstance(allow_duplicate, bool):
|
||||
raise ValueError("Invalid duplicate preference")
|
||||
# The output image the prompts were taken from, so the gallery can show it was kept.
|
||||
source_image = _normalise_source_image(payload.get("source_image"))
|
||||
signature = hashlib.sha256(json.dumps(plan, ensure_ascii=False, sort_keys=True).encode("utf-8")).hexdigest()
|
||||
material_id = uuid.uuid4().hex
|
||||
filename = f"material_{int(time.time())}_{material_id}.json"
|
||||
material = {"schema_version": MATERIAL_SCHEMA_VERSION, "id": material_id,
|
||||
"kind": "prompt_plan", "name": name.strip(), "tags": tags,
|
||||
"timestamp": int(time.time() * 1000), "plan": plan,
|
||||
"source": {"type": "prompt_plan", "parameter_signature": signature},
|
||||
"source": {"type": "prompt_plan", "parameter_signature": signature,
|
||||
**({"image": source_image} if source_image else {})},
|
||||
"capabilities": ["compose_prompt"], "selection": {"scope": "prompt_plan"}}
|
||||
duplicate = await asyncio.to_thread(_persist_parameter_material, get_materials_dir(), filename, material, allow_duplicate)
|
||||
if duplicate:
|
||||
@@ -432,6 +290,24 @@ async def api_get_materials(request):
|
||||
return web.json_response({"status": "error", "message": "Could not list materials"}, status=500)
|
||||
|
||||
|
||||
async def api_mark_material_moved(request):
|
||||
"""POST {filename, recipe}: the kept workflow `filename` was saved as recipe `recipe`."""
|
||||
try:
|
||||
payload = await request.json()
|
||||
filename = require_filename(payload.get("filename", ""))
|
||||
recipe = require_filename(payload.get("recipe", ""))
|
||||
if not filename.endswith(".json") or not recipe.endswith(".json"):
|
||||
raise ValueError("Invalid material")
|
||||
await asyncio.to_thread(_store._mark_material_moved, get_materials_dir(), filename, recipe)
|
||||
return web.json_response({"status": "success"})
|
||||
except (AttributeError, TypeError, ValueError, json.JSONDecodeError):
|
||||
return web.json_response({"status": "error", "message": "Invalid material"}, status=400)
|
||||
except FileNotFoundError:
|
||||
return web.json_response({"status": "error", "message": "Material not found"}, status=404)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not update material"}, status=500)
|
||||
|
||||
|
||||
async def api_update_material(request):
|
||||
try:
|
||||
payload = await request.json()
|
||||
@@ -514,7 +390,8 @@ async def api_get_materials_by_node_type(request):
|
||||
def collect():
|
||||
matches = []
|
||||
for summary in _list_materials(materials_dir):
|
||||
if node_type not in summary["node_types"]:
|
||||
# A whole workflow moved to a recipe is offered through the recipe's own sets.
|
||||
if node_type not in summary["node_types"] or summary.get("moved_to_recipe"):
|
||||
continue
|
||||
try:
|
||||
material = _read_material(resolve_within(materials_dir, summary["filename"]))
|
||||
@@ -522,6 +399,10 @@ async def api_get_materials_by_node_type(request):
|
||||
continue
|
||||
blocks = [block for block in _material_node_blocks(material, include_values=True) if block["type"] == node_type]
|
||||
if blocks:
|
||||
# Where the values came from, for Current node: a kept picture, or a node saved there.
|
||||
source = material.get("source") if isinstance(material.get("source"), dict) else {}
|
||||
image = source.get("image") if isinstance(source.get("image"), dict) else {}
|
||||
preview = str((material.get("image") if isinstance(material.get("image"), dict) else {}).get("preview_asset_id") or "")
|
||||
matches.append({
|
||||
"filename": summary["filename"],
|
||||
"name": summary["name"],
|
||||
@@ -529,6 +410,10 @@ async def api_get_materials_by_node_type(request):
|
||||
"timestamp": summary["timestamp"],
|
||||
"blocks": blocks,
|
||||
"workflow_hashes": _workflow_hashes_for_blocks(material["workflow"], blocks),
|
||||
"origin": str(source.get("type") or ""),
|
||||
"source_image": {"filename": str(image["filename"]), "subfolder": str(image.get("subfolder") or "")}
|
||||
if isinstance(image.get("filename"), str) and image["filename"] else None,
|
||||
"preview": preview if preview.lower().endswith((".png", ".webp")) else "",
|
||||
})
|
||||
return matches
|
||||
|
||||
|
||||
@@ -0,0 +1,359 @@
|
||||
"""The MCP tools that act: on the open canvas, through the page (mcp_bridge.py and
|
||||
web/modules/mcp_bridge.js, which use Anomalous's own canvas code, so every change is one
|
||||
Ctrl+Z step and lands in the activity log marked as the AI's), and on this ComfyUI server
|
||||
through its own routes (scans, Anomalous TTS speech), so they behave exactly as from the UI.
|
||||
|
||||
Nothing here deletes or renames files. Tools that overwrite something on the canvas say so
|
||||
(destructiveHint); AI apps ask the user before calling tools that are not read-only.
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import ssl
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
from . import ai_gates, mcp_fill, model_advice, run_refusal
|
||||
from .lora_info import trains_text_encoder
|
||||
from .mcp_bridge import PageRefused, PageUnavailable, ask_page
|
||||
from .mcp_tools import MAX_LIMIT, ToolError, _resolve_model, _schema
|
||||
|
||||
SPEAK_WAIT_SECONDS = 120
|
||||
HISTORY_POLL_SECONDS = 1.5
|
||||
|
||||
|
||||
def _page(action, args=None, timeout=30):
|
||||
try:
|
||||
return ask_page(action, args, timeout)
|
||||
except (PageUnavailable, PageRefused) as error:
|
||||
raise ToolError(str(error))
|
||||
|
||||
|
||||
def _rel(base_dir, file_path):
|
||||
return os.path.relpath(file_path, base_dir).replace(os.sep, "/")
|
||||
|
||||
|
||||
def _local(ctx, method, path, body=None, timeout=20):
|
||||
"""(status, JSON) of one request to this ComfyUI server's own routes."""
|
||||
data = json.dumps(body).encode("utf-8") if body is not None else None
|
||||
request = urllib.request.Request(ctx["base_url"] + path, data=data, method=method,
|
||||
headers={"Content-Type": "application/json"})
|
||||
# Loopback only (mcp_server checked the host); a self-signed certificate is the user's own.
|
||||
context = ssl._create_unverified_context() if ctx["base_url"].startswith("https:") else None
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=timeout, context=context) as response:
|
||||
return response.status, json.loads(response.read() or b"null")
|
||||
except urllib.error.HTTPError as error:
|
||||
try:
|
||||
return error.code, json.loads(error.read() or b"null")
|
||||
except ValueError:
|
||||
return error.code, None
|
||||
except (urllib.error.URLError, OSError) as error:
|
||||
raise ToolError(f"Could not reach ComfyUI's own server: {error}")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- canvas (through the page)
|
||||
|
||||
def describe_canvas(ctx):
|
||||
return _page("describe_canvas")
|
||||
|
||||
|
||||
def set_prompt(ctx, prompt, role="positive", node_id=None, mode="replace"):
|
||||
if role not in ("positive", "negative") or mode not in ("replace", "append"):
|
||||
raise ToolError("role is positive or negative; mode is replace or append.")
|
||||
return _page("set_prompt", {"text": str(prompt), "role": role, "node_id": node_id, "mode": mode})
|
||||
|
||||
|
||||
def _base_note(result, folder_type, file_path):
|
||||
"""The page's answer without the model line it reports, and base_model_note when a LoRA on that
|
||||
line does not suit its main model (model_advice.py)."""
|
||||
if not isinstance(result, dict):
|
||||
return result
|
||||
line = result.pop("line", None) or {}
|
||||
if folder_type == "loras":
|
||||
note = model_advice.lora_note(file_path, line)
|
||||
else:
|
||||
notes = (model_advice.lora_note(path, {"model": line.get("model")}) for path in model_advice.lora_paths(line.get("loras")))
|
||||
note = next((item for item in notes if item), None)
|
||||
if note:
|
||||
result["base_model_note"] = note
|
||||
return result
|
||||
|
||||
|
||||
def set_model(ctx, node_id, model_id):
|
||||
folder_type, _idx, base_dir, file_path = _resolve_model(model_id)
|
||||
result = _page("set_model", {"node_id": node_id, "model": {"type": folder_type, "path": _rel(base_dir, file_path)}})
|
||||
return _base_note(result, folder_type, file_path)
|
||||
|
||||
|
||||
def add_lora(ctx, model_id, after_node_id=None, strength_model=1.0, strength_clip=1.0):
|
||||
folder_type, _idx, base_dir, file_path = _resolve_model(model_id)
|
||||
if folder_type != "loras":
|
||||
raise ToolError("add_lora takes a model from the loras folder.")
|
||||
result = _page("add_lora", {"model": {"type": folder_type, "path": _rel(base_dir, file_path)},
|
||||
"text_encoder": trains_text_encoder(file_path), "after_node_id": after_node_id,
|
||||
"strength_model": float(strength_model), "strength_clip": float(strength_clip)})
|
||||
return _base_note(result, folder_type, file_path)
|
||||
|
||||
|
||||
def place_combo(ctx, name):
|
||||
return _page("place_combo", {"name": str(name)})
|
||||
|
||||
|
||||
def check_workflow_models(ctx):
|
||||
return _page("check_models", timeout=90)
|
||||
|
||||
|
||||
def fix_workflow_models(ctx):
|
||||
return _page("fix_models", timeout=90)
|
||||
|
||||
|
||||
def download_missing_models(ctx, names=None):
|
||||
return _page("download_missing", {"names": [str(name) for name in names or []]}, timeout=120)
|
||||
|
||||
|
||||
def download_model(ctx, type, url="", hash="", folder=None, name=""):
|
||||
if not (url or hash):
|
||||
raise ToolError("Give url (a Civitai, Hugging Face or GitHub link to the file or model version) or hash.")
|
||||
return _page("download_model", {"url": str(url), "hash": str(hash), "type": str(type),
|
||||
"folder": None if folder is None else str(folder), "name": str(name or "")}, timeout=90)
|
||||
|
||||
|
||||
def download_status(ctx):
|
||||
status, data = _local(ctx, "GET", "/anomalous/download/status")
|
||||
if status != 200:
|
||||
raise ToolError(f"Download status unavailable ({status}).")
|
||||
jobs = []
|
||||
for job in (data or {}).get("jobs", []):
|
||||
total = job.get("total") or 0
|
||||
jobs.append({"file": job.get("rel"), "type": job.get("type"), "state": job.get("state"), "error": job.get("error") or None,
|
||||
"percent": round(job["received"] * 100 / total) if total else None, "size": total or None,
|
||||
"checked": job.get("verified"), "for_model": job.get("value") or None})
|
||||
return {"downloads": jobs, "meaning": "state: queued, running, verifying, done (checked: its fingerprint matched), "
|
||||
"failed (error says why; starting it again continues it), cancelled."}
|
||||
|
||||
|
||||
def run_workflow(ctx, batch=1, wait_seconds=55, workflow=None, **slots):
|
||||
from .ai_run_tracking import checked_wait
|
||||
checked_wait(wait_seconds) # Reject a wait that is no number before anything can be submitted.
|
||||
batch = max(1, min(8, int(batch)))
|
||||
filled = mcp_fill.fill(ctx, workflow, **slots) # a saved workflow and its blanks first (mcp_fill.py)
|
||||
try:
|
||||
answer = ask_page("run_workflow", {"batch": batch}, required_capability="prompt_ids")
|
||||
except (PageUnavailable, PageRefused) as error:
|
||||
raise ToolError(str(error))
|
||||
ids = answer.get("prompt_ids") if isinstance(answer, dict) else None
|
||||
page = answer if isinstance(answer, dict) else {}
|
||||
if (not isinstance(ids, list) or not ids or len(ids) > batch
|
||||
or any(not isinstance(pid, str) or not pid or len(pid) > 128 for pid in ids) or len(set(ids)) != len(ids)):
|
||||
raise ToolError((run_refusal.say(answer.get("refusal")) or answer.get("submission_error") if isinstance(answer, dict) else None)
|
||||
or "No valid submission receipts. Check ComfyUI's queue before retrying; do not repeat automatically.")
|
||||
answer = {"prompt_ids": ids, "queued": len(ids), "requested": batch,
|
||||
"note": ("If this answer does not say it is done, the user tells you when it is: say it is running and end "
|
||||
"your turn; run_status then brings its pictures." if ai_gates.run_wait() == "call" else
|
||||
"Follow these runs with run_status (wait_seconds up to 55).")
|
||||
+ " Do not repeat the batch; accepted prompts are already queued."}
|
||||
if filled:
|
||||
answer["filled"] = filled
|
||||
# Some prompts may have been accepted before validation or a transport failure stopped the batch.
|
||||
if len(ids) < batch:
|
||||
answer["submission_error"] = f"Only {len(ids)} of {batch} prompts were accepted."
|
||||
told = run_refusal.say(page.get("refusal"))
|
||||
if told:
|
||||
answer["submission_error"] += f" {told}"
|
||||
return answer
|
||||
|
||||
|
||||
def open_in_anomalous(ctx, model_id):
|
||||
folder_type, path_idx, base_dir, file_path = _resolve_model(model_id)
|
||||
return _page("open_model", {"type": folder_type, "path_idx": path_idx, "rel": _rel(base_dir, file_path)})
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- this server
|
||||
|
||||
def scan_models(ctx, what="new", model_ids=None):
|
||||
body = {"offline_only": False, "skip_rename": False, "virtual_rename": True, "physical_rename": False,
|
||||
"force_overwrite": False, "retry_unmatched": what == "retry_unmatched"}
|
||||
if what == "models":
|
||||
folders = {}
|
||||
for model_id in model_ids or []:
|
||||
folder_type, path_idx, base_dir, file_path = _resolve_model(model_id)
|
||||
subfolder, _, filename = _rel(base_dir, file_path).rpartition("/")
|
||||
folders.setdefault((folder_type, path_idx, "/" + subfolder), []).append(filename)
|
||||
if not folders:
|
||||
raise ToolError("what=models needs model_ids from search_models.")
|
||||
body["targets"] = [{"type": t, "path_idx": i, "subfolder": s, "files": files} for (t, i, s), files in folders.items()]
|
||||
elif what not in ("new", "retry_unmatched"):
|
||||
raise ToolError("what is new, retry_unmatched or models.")
|
||||
status, data = _local(ctx, "POST", "/anomalous/scan_all", body)
|
||||
if status == 409:
|
||||
raise ToolError("A scan is already running; call scan_report later to see it.")
|
||||
if status != 200 or (data or {}).get("status") != "ok":
|
||||
raise ToolError(f"The scan did not start: {(data or {}).get('message') or status}")
|
||||
return {"started": True, "note": "Scans run in the background and only read .safetensors files. "
|
||||
"Call scan_report in a minute or two for what it found."}
|
||||
|
||||
|
||||
def _tts_characters(ctx):
|
||||
status, data = _local(ctx, "GET", "/anomalous_tts/characters")
|
||||
if status == 404:
|
||||
raise ToolError("Anomalous TTS is not installed, so there are no voices.")
|
||||
if status != 200 or not isinstance(data, dict):
|
||||
raise ToolError(f"Could not read the voices ({status}).")
|
||||
return data.get("characters") or []
|
||||
|
||||
|
||||
def list_voices(ctx):
|
||||
return {"voices": [{"character": item.get("name"), "language": item.get("language") or "",
|
||||
"emotions": sorted((item.get("emotions") or {}).keys()),
|
||||
**({"problem": item.get("error") or item.get("settings_error")}
|
||||
if item.get("error") or item.get("settings_error") else {})}
|
||||
for item in _tts_characters(ctx)]}
|
||||
|
||||
|
||||
def _output_prefix(character):
|
||||
"""Where the audio page saves a character's lines (audio_script.js ttsOutputPrefix)."""
|
||||
parts = [re.sub(r'[<>:"\\|?*\x00-\x1f]', "_", part).strip() or "_" for part in str(character).split("/")]
|
||||
parts = ["_" if re.fullmatch(r"\.+", part) else part for part in parts]
|
||||
return f"audio/{'/'.join(parts)}/{parts[-1]}"
|
||||
|
||||
|
||||
def speak(ctx, character, text, seed=None, language="auto"):
|
||||
names = {item.get("name") for item in _tts_characters(ctx)}
|
||||
if character not in names:
|
||||
raise ToolError(f"No voice called {character!r}; list_voices names them.")
|
||||
if not str(text).strip():
|
||||
raise ToolError("text is empty.")
|
||||
seed = int(seed) if seed is not None else int(time.time() * 1000) % 2**31
|
||||
prompt = {"1": {"class_type": "AnomalousTTS_CharacterSpeech",
|
||||
"inputs": {"character": character, "text": str(text), "seed": seed, "language": language}},
|
||||
"2": {"class_type": "SaveAudio", "inputs": {"audio": ["1", 0], "filename_prefix": _output_prefix(character)}}}
|
||||
status, data = _local(ctx, "POST", "/prompt", {"prompt": prompt, "client_id": "anomalous-mcp"})
|
||||
prompt_id = (data or {}).get("prompt_id")
|
||||
if status != 200 or not prompt_id:
|
||||
errors = (data or {}).get("node_errors") or (data or {}).get("error") or status
|
||||
raise ToolError(f"ComfyUI refused the speech job: {json.dumps(errors, ensure_ascii=False)[:500]}")
|
||||
deadline = time.monotonic() + SPEAK_WAIT_SECONDS
|
||||
while time.monotonic() < deadline:
|
||||
time.sleep(HISTORY_POLL_SECONDS)
|
||||
_status, history = _local(ctx, "GET", f"/history/{prompt_id}")
|
||||
record = (history or {}).get(prompt_id) or {}
|
||||
state = record.get("status") or {}
|
||||
if state.get("status_str") == "error":
|
||||
messages = [m[1].get("exception_message") for m in state.get("messages") or [] if m and m[0] == "execution_error"]
|
||||
raise ToolError(f"Speech failed: {messages[0] if messages else 'see the ComfyUI console'}")
|
||||
if state.get("completed"):
|
||||
files = [f"{item.get('subfolder')}/{item.get('filename')}".replace("\\", "/").strip("/")
|
||||
for output in (record.get("outputs") or {}).values() for item in output.get("audio") or []]
|
||||
return {"done": True, "seed": seed, "files": files,
|
||||
"note": "Saved under ComfyUI's output folder; it shows in Anomalous's audio gallery."}
|
||||
return {"done": False, "prompt_id": prompt_id, "seed": seed,
|
||||
"note": "Still generating (ComfyUI may be busy with other jobs); search_audio will list it when done."}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- registry
|
||||
|
||||
_NODE = {"type": "integer", "description": "A node id."}
|
||||
_MODEL = {"type": "string", "description": "model_id from search_models."}
|
||||
|
||||
|
||||
def _action(name, title, description, run, properties=None, required=(), destructive=False, open_world=False,
|
||||
read_only=False):
|
||||
return name, {"run": run, "context": True, "spec": {
|
||||
"name": name, "title": title, "description": description,
|
||||
"inputSchema": _schema(properties, required),
|
||||
"annotations": {"title": title, "readOnlyHint": read_only, "destructiveHint": destructive,
|
||||
"idempotentHint": read_only, "openWorldHint": open_world},
|
||||
}}
|
||||
|
||||
|
||||
ACTIONS = dict([
|
||||
_action("describe_canvas", "Read the canvas",
|
||||
"The workflow open in ComfyUI now: each node's id, type, title, settings, which prompt box is "
|
||||
"positive or negative, and where its inputs come from. Call it before changing settings; "
|
||||
"get_situation gives the canvas in brief (a line a node, what is still unwired and what fits it).",
|
||||
describe_canvas, read_only=True),
|
||||
_action("set_prompt", "Write a prompt",
|
||||
"Writes text into the workflow's positive or negative prompt box (or the one on node_id). "
|
||||
"mode=append adds to what is there. One Ctrl+Z step.",
|
||||
set_prompt, {"prompt": {"type": "string"}, "role": {"type": "string", "enum": ["positive", "negative"], "default": "positive"},
|
||||
"node_id": _NODE, "mode": {"type": "string", "enum": ["replace", "append"], "default": "replace"}},
|
||||
["prompt"], destructive=True),
|
||||
_action("set_model", "Swap a node's model",
|
||||
"Puts a model into a loader node (checkpoint, LoRA, VAE…) on the canvas, replacing the one it had. "
|
||||
"base_model_note in the answer: a LoRA and the main model are for different base models.",
|
||||
set_model, {"node_id": _NODE, "model_id": _MODEL}, ["node_id", "model_id"], destructive=True),
|
||||
_action("add_lora", "Add a LoRA",
|
||||
"Inserts a LoRA loader after after_node_id (default: the main model loader, past its LoRAs) and moves "
|
||||
"what that node fed behind it; the CLIP line too when the LoRA trains the text encoder. base_model_note in "
|
||||
"the answer: the LoRA is for another base model than the main model.",
|
||||
add_lora, {"model_id": _MODEL, "after_node_id": _NODE,
|
||||
"strength_model": {"type": "number", "default": 1.0}, "strength_clip": {"type": "number", "default": 1.0}},
|
||||
["model_id"]),
|
||||
_action("place_combo", "Place a combo",
|
||||
"Adds one of the user's combos (list_combos) to the canvas as a new wired group: model loader, LoRAs, "
|
||||
"positive and negative prompt, or a node-structure combo's own nodes and links. Nothing already there "
|
||||
"changes; ports to nodes outside the combo (sampler…) stay open.",
|
||||
place_combo, {"name": {"type": "string", "description": "Combo name from list_combos."}}, ["name"]),
|
||||
_action("check_workflow_models", "Check missing models",
|
||||
"Models the open workflow names that this computer lacks, and which Anomalous can put back (the same "
|
||||
"file by hash, or a likely one).",
|
||||
check_workflow_models, read_only=True),
|
||||
_action("fix_workflow_models", "Fix missing models",
|
||||
"Puts back every missing model found by hash; likely ones are left to the user. One Ctrl+Z step.",
|
||||
fix_workflow_models, destructive=True),
|
||||
_action("download_missing_models", "Download missing models",
|
||||
"Downloads the models the open workflow is missing whose source is certain: Civitai found by the "
|
||||
"workflow's fingerprint, or a file link the workflow carries. A file name alone is never used. Files go "
|
||||
"where the user's download settings say and are checked against the fingerprint before use; finished "
|
||||
"ones are put into their nodes. names limits it to those files. Large files take a while.",
|
||||
download_missing_models, {"names": {"type": "array", "items": {"type": "string"}, "maxItems": MAX_LIMIT,
|
||||
"description": "Only these model file names (default: all missing)."}},
|
||||
open_world=True),
|
||||
_action("download_model", "Download a model",
|
||||
"Downloads one model into this computer's models folder of `type` (loras, checkpoints, vae, "
|
||||
"diffusion_models, text_encoders, upscale_models…): from url (a Civitai model-version link, or a Hugging "
|
||||
"Face / GitHub link to the file) or by its Civitai hash. folder is a subfolder inside that type's folder "
|
||||
"(default: the user's download settings); name the file name (default: the site's). Never replaces a file.",
|
||||
download_model, {"type": {"type": "string"}, "url": {"type": "string"}, "hash": {"type": "string"},
|
||||
"folder": {"type": "string"}, "name": {"type": "string"}}, ["type"], open_world=True),
|
||||
_action("download_status", "Downloads", "How the downloads of this ComfyUI run are going.", download_status,
|
||||
read_only=True),
|
||||
_action("run_workflow", "Run the workflow",
|
||||
"Queues the workflow (uses the GPU). In the same call: workflow (a saved one) opens in the task's tab "
|
||||
"once and is reused; prompt, negative, seed (every sampler), width/height (the start latent), image "
|
||||
"(its LoadImage) and values (any setting by name: {\"steps\": 30}, or {\"12\": {\"denoise\": 0.5}} when "
|
||||
"several nodes have it) fill it in; the rest stays. Without workflow they fill the open canvas. Then "
|
||||
"run_status, never the output folder.",
|
||||
run_workflow, {"batch": {"type": "integer", "minimum": 1, "maximum": 8, "default": 1},
|
||||
"wait_seconds": {"type": "number", "minimum": 0, "maximum": 55, "default": 55,
|
||||
"description": "Seconds to wait for it to end."},
|
||||
"workflow": {"type": "string", "description": "A name from list_workflows."},
|
||||
"prompt": {"type": "string"}, "negative": {"type": "string"},
|
||||
"seed": {"type": "integer", "minimum": 0},
|
||||
"width": {"type": "integer", "minimum": 16, "maximum": 16384},
|
||||
"height": {"type": "integer", "minimum": 16, "maximum": 16384},
|
||||
"image": {"type": "string", "description": "subfolder/name.png, output or input folder."},
|
||||
"image_node": {"type": "integer", "description": "Which LoadImage, when there are several."},
|
||||
"values": {"type": "object", "description": "Other settings by name, any node's."}}),
|
||||
_action("open_in_anomalous", "Show a model",
|
||||
"Opens Anomalous Model Browser on this model's page, so the user sees its cover and details.",
|
||||
open_in_anomalous, {"model_id": _MODEL}, ["model_id"]),
|
||||
_action("scan_models", "Scan models",
|
||||
"Starts a scan that fetches covers, trigger words and base models from Civitai (by file hash) for "
|
||||
"models not scanned yet (new), looks unmatched ones up again (retry_unmatched), or scans model_ids.",
|
||||
scan_models, {"what": {"type": "string", "enum": ["new", "retry_unmatched", "models"], "default": "new"},
|
||||
"model_ids": {"type": "array", "items": {"type": "string"}, "maxItems": MAX_LIMIT}},
|
||||
open_world=True),
|
||||
_action("list_voices", "Voices",
|
||||
"The Anomalous TTS characters (GPT-SoVITS voices) with their language and emotions.", list_voices,
|
||||
read_only=True),
|
||||
_action("speak", "Speak a line",
|
||||
"Has an Anomalous TTS character read text and saves the audio. Emotion tags like {happy} switch "
|
||||
"emotion mid-text; waits up to two minutes.",
|
||||
speak, {"character": {"type": "string", "description": "From list_voices."}, "text": {"type": "string"},
|
||||
"seed": {"type": "integer"}, "language": {"type": "string", "default": "auto"}},
|
||||
["character", "text"]),
|
||||
])
|
||||
@@ -0,0 +1,213 @@
|
||||
<!doctype html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Anomalous</title>
|
||||
<!-- Anomalous's card in the AI app's conversation (api/mcp_apps.py). Everything the AI or the task
|
||||
says is drawn with textContent; pictures are inline thumbnails; nothing is loaded from elsewhere. -->
|
||||
<style>
|
||||
:root { --bg: #ffffff; --soft: #f4f4f6; --line: #e2e2e8; --text: #1d1d22; --dim: #6b6b75; --accent: #7c5cdb; --ok: #2f9e6e; --warn: #c98a04; --bad: #d64545; }
|
||||
:root.dark { --bg: #1d1d22; --soft: #26262d; --line: #36363f; --text: #ececf1; --dim: #9a9aa6; --accent: #b39eef; --ok: #52b98d; --warn: #fbbf24; --bad: #f87171; }
|
||||
* { box-sizing: border-box; }
|
||||
body { margin: 0; padding: 14px 16px; background: var(--bg); color: var(--text); font: 13.5px/1.55 system-ui, -apple-system, "Segoe UI", "Microsoft YaHei", sans-serif; }
|
||||
.head { display: flex; align-items: center; gap: 8px; margin-bottom: 10px; }
|
||||
.brand { color: var(--accent); font-weight: 600; font-size: 12px; }
|
||||
.title { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-weight: 600; }
|
||||
.state { padding: 1px 8px; border-radius: 999px; background: var(--soft); color: var(--dim); font-size: 11.5px; }
|
||||
.state.live { color: var(--ok); }
|
||||
.steps { display: flex; flex-direction: column; gap: 4px; margin: 0 0 10px; padding: 0; list-style: none; }
|
||||
.steps li { display: flex; gap: 8px; color: var(--dim); font-size: 12.5px; }
|
||||
.steps li::before { content: "•"; color: var(--ok); }
|
||||
.steps li.running::before { color: var(--accent); }
|
||||
.steps li.asking::before, .steps li.allowed::before { color: var(--warn); }
|
||||
.steps li.bad::before { color: var(--bad); }
|
||||
.steps li span { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.pictures { display: grid; grid-template-columns: repeat(auto-fill, minmax(96px, 1fr)); gap: 6px; margin-bottom: 10px; }
|
||||
.pictures img { width: 100%; aspect-ratio: 1; object-fit: cover; border-radius: 8px; background: var(--soft); }
|
||||
.box { margin-bottom: 10px; padding: 10px 12px; border: 1px solid var(--line); border-radius: 10px; background: var(--soft); }
|
||||
.box.warn { border-color: var(--warn); }
|
||||
.question { margin-bottom: 8px; font-weight: 600; }
|
||||
.options { display: flex; flex-wrap: wrap; gap: 6px; }
|
||||
button { padding: 6px 12px; border: 1px solid var(--line); border-radius: 8px; background: var(--bg); color: var(--text); font: inherit; font-size: 12.5px; cursor: pointer; }
|
||||
button:hover:not(:disabled) { border-color: var(--accent); }
|
||||
button:disabled { opacity: 0.5; cursor: default; }
|
||||
button.primary { border-color: var(--accent); background: var(--accent); color: #fff; }
|
||||
input { flex: 1; min-width: 0; padding: 6px 10px; border: 1px solid var(--line); border-radius: 8px; background: var(--bg); color: var(--text); font: inherit; }
|
||||
.row { display: flex; gap: 6px; }
|
||||
.foot { display: flex; align-items: center; justify-content: space-between; gap: 8px; color: var(--dim); font-size: 12px; }
|
||||
.link { padding: 0; border: 0; background: none; color: var(--accent); }
|
||||
.note { margin-bottom: 8px; color: var(--dim); font-size: 12px; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div id="card"><div class="note" id="loading"></div></div>
|
||||
<script>
|
||||
(() => {
|
||||
let zh = /^zh/i.test(navigator.language || '');
|
||||
const words = {
|
||||
loading: ['Reading the task from Anomalous…', '正在从 AMB 读取任务…'],
|
||||
live: ['Working', '进行中'], done: ['Done', '已完成'],
|
||||
asking: ['The AI waits for your OK in Anomalous', 'AI 在等你在 AMB 里点头'],
|
||||
askingHow: ['Allowing is only done in Anomalous\'s AI workbench, so the AI can never allow itself.', '为了安全，允许只能在 AMB 的 AI 工作台里点，AI 自己没法替你点。'],
|
||||
openAmb: ['Open in Anomalous', '在 AMB 里看'], send: ['Send', '发送'], refresh: ['Refresh', '刷新'],
|
||||
picked: ['I picked in the card: ', '我在卡片里选了：'], typed: ['My answer in the card: ', '我在卡片里回答：'],
|
||||
youAnswered: ['You answered: ', '你回答了：'], none: ['No task to show yet.', '还没有任务可看。'],
|
||||
};
|
||||
const t = key => words[key][zh ? 1 : 0];
|
||||
const card = document.getElementById('card');
|
||||
document.getElementById('loading').textContent = t('loading');
|
||||
|
||||
// JSON-RPC with the AI app (MCP Apps): requests wait for their answer by id.
|
||||
let nextId = 1;
|
||||
const waiting = new Map();
|
||||
const send = (message) => window.parent.postMessage({ jsonrpc: '2.0', ...message }, '*');
|
||||
const request = (method, params) => new Promise((resolve, reject) => {
|
||||
const id = nextId++;
|
||||
waiting.set(id, { resolve, reject });
|
||||
send({ id, method, params });
|
||||
});
|
||||
const notify = (method, params) => send({ method, params });
|
||||
const resize = () => notify('ui/notifications/size-changed', { width: document.body.scrollWidth, height: document.body.scrollHeight });
|
||||
|
||||
let target = {}; // { panel } or { task }: what the card shows
|
||||
let openUrl = '';
|
||||
let polls = 0;
|
||||
let timer = null;
|
||||
|
||||
function el(tag, className, text) {
|
||||
const node = document.createElement(tag);
|
||||
if (className) node.className = className;
|
||||
if (text !== undefined) node.textContent = String(text);
|
||||
return node;
|
||||
}
|
||||
|
||||
async function callTool(name, args) {
|
||||
const result = await request('tools/call', { name, arguments: args });
|
||||
if (result?.isError) throw new Error(result.content?.[0]?.text || 'error');
|
||||
return result?.structuredContent || {};
|
||||
}
|
||||
|
||||
async function answer(question, choice, text, label) {
|
||||
card.querySelectorAll('button, input').forEach((node) => { node.disabled = true; });
|
||||
try {
|
||||
await callTool('app_answer', { panel: question.panel, block: question.block, ...(choice ? { choice: [choice] } : { text }) });
|
||||
// Also said in the conversation, so the AI goes on even when it is not waiting.
|
||||
await request('ui/message', { role: 'user', content: [{ type: 'text', text: (choice ? t('picked') : t('typed')) + label }] }).catch(() => {});
|
||||
} catch (error) {
|
||||
card.append(el('div', 'note', error.message));
|
||||
}
|
||||
await load();
|
||||
}
|
||||
|
||||
function questionBox(question) {
|
||||
const box = el('div', 'box');
|
||||
box.append(el('div', 'question', question.question));
|
||||
if (question.type === 'input') {
|
||||
const row = el('div', 'row');
|
||||
const field = el('input');
|
||||
const go = el('button', 'primary', t('send'));
|
||||
go.onclick = () => field.value.trim() && answer(question, null, field.value.trim(), field.value.trim());
|
||||
field.onkeydown = (event) => { if (event.key === 'Enter') go.click(); };
|
||||
row.append(field, go);
|
||||
box.append(row);
|
||||
} else {
|
||||
const options = el('div', 'options');
|
||||
for (const option of question.options) {
|
||||
const pick = el('button', '', option.label);
|
||||
pick.onclick = () => answer(question, option.id, null, option.label);
|
||||
options.append(pick);
|
||||
}
|
||||
box.append(options);
|
||||
}
|
||||
return box;
|
||||
}
|
||||
|
||||
function draw(view) {
|
||||
openUrl = view.open_url || openUrl;
|
||||
const head = el('div', 'head');
|
||||
head.append(el('span', 'brand', 'Anomalous'), el('span', 'title', view.title || ''),
|
||||
el('span', `state${view.ended ? '' : ' live'}`, t(view.ended ? 'done' : 'live')));
|
||||
const steps = el('ul', 'steps');
|
||||
for (const step of view.steps || []) {
|
||||
const line = el('li', `${step.state || ''}${step.ok === false ? ' bad' : ''}`);
|
||||
line.append(el('span', '', step.text || step.tool));
|
||||
steps.append(line);
|
||||
}
|
||||
const parts = [head, steps];
|
||||
if (view.pictures?.length) {
|
||||
const pictures = el('div', 'pictures');
|
||||
for (const picture of view.pictures) {
|
||||
const image = el('img');
|
||||
image.alt = picture.name;
|
||||
image.title = picture.name;
|
||||
image.src = picture.src; // a data: thumbnail from Anomalous
|
||||
image.onload = resize;
|
||||
pictures.append(image);
|
||||
}
|
||||
parts.push(pictures);
|
||||
}
|
||||
for (const item of view.answered || []) parts.push(el('div', 'note', `${t('youAnswered')}${item.question ? `${item.question} ` : ''}${item.answer}`));
|
||||
for (const question of view.questions || []) parts.push(questionBox(question));
|
||||
if (view.asking?.length) {
|
||||
const box = el('div', 'box warn');
|
||||
box.append(el('div', 'question', t('asking')), el('div', 'note', t('askingHow')));
|
||||
parts.push(box);
|
||||
}
|
||||
const foot = el('div', 'foot');
|
||||
const open = el('button', 'link', t('openAmb'));
|
||||
open.onclick = () => openUrl && request('ui/open-link', { url: openUrl }).catch(() => {});
|
||||
const again = el('button', 'link', t('refresh'));
|
||||
again.onclick = () => { polls = 0; load(); };
|
||||
foot.append(open, again);
|
||||
parts.push(foot);
|
||||
card.replaceChildren(...parts);
|
||||
resize();
|
||||
// Follows the task for a few minutes while it goes on; Refresh starts again.
|
||||
clearTimeout(timer);
|
||||
if (!view.ended && polls++ < 36) timer = setTimeout(load, 5000);
|
||||
}
|
||||
|
||||
async function load() {
|
||||
try {
|
||||
draw(await callTool('app_task_view', target));
|
||||
} catch (_) {
|
||||
card.replaceChildren(el('div', 'note', t('none')));
|
||||
resize();
|
||||
}
|
||||
}
|
||||
|
||||
window.addEventListener('message', (event) => {
|
||||
if (event.source !== window.parent) return;
|
||||
const message = event.data;
|
||||
if (!message || message.jsonrpc !== '2.0') return;
|
||||
if (message.id !== undefined && waiting.has(message.id)) {
|
||||
const { resolve, reject } = waiting.get(message.id);
|
||||
waiting.delete(message.id);
|
||||
if (message.error) reject(new Error(message.error.message));
|
||||
else resolve(message.result);
|
||||
return;
|
||||
}
|
||||
if (message.method === 'ui/notifications/tool-result') {
|
||||
const data = message.params?.structuredContent || {};
|
||||
target = data.panel ? { panel: String(data.panel) } : data.task ? { task: String(data.task) } : {};
|
||||
polls = 0;
|
||||
load();
|
||||
} else if (message.method === 'ui/notifications/host-context-changed') {
|
||||
document.documentElement.classList.toggle('dark', message.params?.theme === 'dark');
|
||||
}
|
||||
});
|
||||
|
||||
request('ui/initialize', { appInfo: { name: 'anomalous-task-card', version: '1.0.0' }, appCapabilities: {}, protocolVersion: '2026-01-26' })
|
||||
.then((result) => {
|
||||
const context = result?.hostContext || {};
|
||||
if (context.locale) zh = /^zh/i.test(context.locale);
|
||||
document.documentElement.classList.toggle('dark', context.theme === 'dark');
|
||||
notify('ui/notifications/initialized', {});
|
||||
resize();
|
||||
})
|
||||
.catch(() => {});
|
||||
})();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
"""Anomalous's card inside the AI app's conversation (the MCP Apps extension,
|
||||
io.modelcontextprotocol/ui): AI apps that support it (Claude, ChatGPT, VS Code…) show the page
|
||||
mcp_app/task_card.html under the results of the tools in CARD_TOOLS, in a sandboxed frame of
|
||||
theirs. It is Anomalous's own page, never anything an AI wrote; the AI's data reaches it only as
|
||||
text. The card reads the task through app_task_view and answers the AI's questions through
|
||||
app_answer, two tools for the card only (visibility "app": apps that follow the extension keep
|
||||
them from the AI; an AI that calls them anyway only reads its own task or answers its own
|
||||
question). Their results go to the card, not the AI. The card never answers a gate:
|
||||
an OK for what an AI may do is only given in Anomalous (ai_gates.py), so a tool the AI could
|
||||
reach can never grant it. The pictures it shows are the gallery's thumbnails, inline (the frame
|
||||
loads nothing from this server).
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
from . import ai_panels, ai_tasks
|
||||
from .mcp_tools import ToolError, _image_content, _resolve_image, _schema
|
||||
|
||||
EXTENSION = "io.modelcontextprotocol/ui"
|
||||
MIME = "text/html;profile=mcp-app"
|
||||
CARD_URI = "ui://anomalous/task-card.html"
|
||||
CARD_TOOLS = ("show_panel", "ask_user", "report", "run_workflow", "begin_task")
|
||||
MAX_PICTURES = 6
|
||||
MAX_STEPS = 8
|
||||
HTML = os.path.join(os.path.dirname(__file__), "mcp_app", "task_card.html")
|
||||
|
||||
|
||||
def resources():
|
||||
return [{"uri": CARD_URI, "name": "task-card", "title": "Anomalous task card", "mimeType": MIME,
|
||||
"description": "What the AI is doing in Anomalous: its steps, pictures and questions."}]
|
||||
|
||||
|
||||
def read(uri):
|
||||
"""resources/read for the card, or None for another address."""
|
||||
if uri != CARD_URI:
|
||||
return None
|
||||
with open(HTML, encoding="utf-8") as source:
|
||||
html = source.read()
|
||||
return {"contents": [{"uri": CARD_URI, "mimeType": MIME, "text": html, "_meta": {"ui": {"prefersBorder": True}}}]}
|
||||
|
||||
|
||||
def with_card(spec):
|
||||
"""A tool's spec naming the card that shows its results (and the older flat key some apps read)."""
|
||||
if spec["name"] not in CARD_TOOLS:
|
||||
return spec
|
||||
return {**spec, "_meta": {**spec.get("_meta", {}), "ui": {"resourceUri": CARD_URI}, "ui/resourceUri": CARD_URI}}
|
||||
|
||||
|
||||
def _picture(result):
|
||||
rel = "/".join(part for part in (result.get("subfolder"), result.get("filename")) if part)
|
||||
try:
|
||||
_, path = _resolve_image(rel)
|
||||
except ToolError:
|
||||
return None
|
||||
item = _image_content(path)
|
||||
return {"name": result["filename"], "src": f"data:{item['mimeType']};base64,{item['data']}"} if item else None
|
||||
|
||||
|
||||
def _words(step):
|
||||
"""A line for a step: its note or panel title, else what it was about (its summary without the tool)."""
|
||||
summary = step.get("summary", "")
|
||||
about = summary.split(": ", 1)[1] if summary.startswith(f"{step['tool']}: ") else summary
|
||||
return ai_tasks._short(step.get("text") or (step.get("panel") or {}).get("title") or about or step["tool"], 120)
|
||||
|
||||
|
||||
def _answered(step):
|
||||
"""What the user already answered on a panel step: [{question, answer}]."""
|
||||
blocks = {block["id"]: block for block in step["panel"]["blocks"]}
|
||||
return [{"question": blocks.get(block, {}).get("question", ""), "answer": "(left to the AI)" if given.get("skipped") else "、".join(given.get("labels") or [given.get("text", "")])}
|
||||
for block, given in step.get("answers", {}).items()]
|
||||
|
||||
|
||||
def _questions(step):
|
||||
"""The open questions of a panel step, as the card draws them (choices and picks as buttons, input as a line)."""
|
||||
panel = step["panel"]
|
||||
out = []
|
||||
for block in panel["blocks"]:
|
||||
if block["type"] not in ai_panels.INTERACTIVE or block["id"] in step.get("answers", {}) or panel.get("closed"):
|
||||
continue
|
||||
options = block.get("options") or [{"id": item["id"], "label": item.get("label") or item["id"]} for item in block.get("items", [])]
|
||||
out.append({"panel": panel["id"], "block": block["id"], "type": block["type"], "question": block.get("question", ""),
|
||||
"options": [{"id": option["id"], "label": option.get("label") or option["id"]} for option in options]})
|
||||
return out
|
||||
|
||||
|
||||
def task_view(ctx, panel=None, task=None):
|
||||
"""The card's view of a task: the panel's task, task `task`, or the calling app's active one."""
|
||||
with ai_tasks._lock:
|
||||
found = ai_panels._find(str(panel))[0] if panel else None
|
||||
task_id = found["id"] if found else task or ai_tasks.active_task_id(ctx.get("client") or "AI", ctx.get("session") or "")
|
||||
record = ai_tasks.get_task(task_id) if task_id else None
|
||||
if not record:
|
||||
raise ToolError("No task to show.")
|
||||
steps = [step for step in record["steps"] if step.get("kind") != "look"]
|
||||
pictures = [result for step in record["steps"] for result in step.get("results") or [] if result.get("type") == "image"]
|
||||
seen, shown = set(), []
|
||||
for result in reversed(pictures):
|
||||
key = (result.get("subfolder"), result.get("filename"))
|
||||
if key in seen or len(shown) >= MAX_PICTURES:
|
||||
continue
|
||||
seen.add(key)
|
||||
picture = _picture(result)
|
||||
if picture:
|
||||
shown.append(picture)
|
||||
return {
|
||||
"task": record["id"], "title": record.get("title") or "", "ended": bool(record.get("ended")),
|
||||
"steps": [{"tool": step["tool"], "kind": step["kind"], "state": step.get("state", "done"), "ok": step.get("ok", True),
|
||||
"stage": step.get("stage"), "text": _words(step)}
|
||||
for step in steps[-MAX_STEPS:]],
|
||||
"pictures": list(reversed(shown)),
|
||||
"questions": [question for step in record["steps"] if step.get("kind") == "panel" for question in _questions(step)],
|
||||
"answered": [item for step in record["steps"] if step.get("kind") == "panel" for item in _answered(step)][-3:],
|
||||
"asking": [step.get("gate", {}).get("gate") for step in record["steps"] if step.get("state") == "asking"],
|
||||
"open_url": f"{ctx.get('base_url', '')}/",
|
||||
}
|
||||
|
||||
|
||||
def answer(ctx, panel, block, choice=None, text=None):
|
||||
"""The user's answer from the card to one of the AI's questions (never a gate)."""
|
||||
task, step = None, None
|
||||
with ai_tasks._lock:
|
||||
task, step = ai_panels._find(str(panel))
|
||||
if not step:
|
||||
raise ToolError("No such panel.")
|
||||
try:
|
||||
ai_panels.answer(task["id"], step["id"], str(block), choice, text)
|
||||
except ai_panels.PanelError as error:
|
||||
raise ToolError(str(error))
|
||||
return {"answered": True}
|
||||
|
||||
|
||||
def _app_tool(name, title, description, run, properties, required=()):
|
||||
return name, {"run": run, "context": True, "spec": {
|
||||
"name": name, "title": title, "description": description, "inputSchema": _schema(properties, required),
|
||||
"annotations": {"title": title, "readOnlyHint": name == "app_task_view"},
|
||||
"_meta": {"ui": {"resourceUri": CARD_URI, "visibility": ["app"]}},
|
||||
}}
|
||||
|
||||
|
||||
APP_TOOLS = dict([
|
||||
_app_tool("app_task_view", "Card: the task", "Only for Anomalous's own card in the conversation; never call it.",
|
||||
task_view, {"panel": {"type": "string"}, "task": {"type": "string"}}),
|
||||
_app_tool("app_answer", "Card: answer", "Only for Anomalous's own card, when the user answers there; never call it.",
|
||||
answer, {"panel": {"type": "string"}, "block": {"type": "string"}, "choice": {"type": "array", "items": {"type": "string"}},
|
||||
"text": {"type": "string"}}, ["panel", "block"]),
|
||||
])
|
||||
@@ -0,0 +1,37 @@
|
||||
"""Normalize an unambiguous argument name before approval, execution and task recording.
|
||||
|
||||
Only a known other name counts (ALIASES, names light models were seen to write in the tool exams,
|
||||
docs/architecture/tool-exam.md): a value of the right type under any other name may mean something
|
||||
else (set_prompt {style: "anime"} is not a prompt), and that call is answered with what the tool takes.
|
||||
"""
|
||||
|
||||
ALIASES = { # needed argument -> other names that mean it
|
||||
"workflow": {"name", "workflow_name"},
|
||||
"image": {"file", "filename", "image_name"},
|
||||
"prompt": {"text", "positive"},
|
||||
"model_id": {"model", "id"},
|
||||
"node_id": {"node", "id"},
|
||||
}
|
||||
JSON_TYPES = {"string": (str,), "integer": (int,), "number": (int, float), "boolean": (bool,), "array": (list,), "object": (dict,)}
|
||||
|
||||
|
||||
def prepare_arguments(spec, arguments):
|
||||
"""Return (arguments, (wrong, right) or None), without changing the caller's dictionary."""
|
||||
unknown = set(arguments) - set(spec["properties"])
|
||||
missing = [key for key in spec.get("required", []) if key not in arguments]
|
||||
if len(unknown) != 1 or len(missing) != 1:
|
||||
return arguments, None
|
||||
wrong, right = next(iter(unknown)), missing[0]
|
||||
if wrong not in ALIASES.get(right, ()):
|
||||
return arguments, None
|
||||
kinds = JSON_TYPES.get(spec["properties"][right].get("type"))
|
||||
value = arguments[wrong]
|
||||
if not kinds or not isinstance(value, kinds) or (isinstance(value, bool) and bool not in kinds):
|
||||
return arguments, None
|
||||
corrected = {key: value for key, value in arguments.items() if key != wrong}
|
||||
corrected[right] = value
|
||||
return corrected, (wrong, right)
|
||||
|
||||
|
||||
def renaming_note(name, renamed):
|
||||
return f"Took {renamed[0]} as {renamed[1]}: {name} calls it {renamed[1]}."
|
||||
@@ -0,0 +1,90 @@
|
||||
"""The way from an MCP tool to the open ComfyUI page, for what only the page can do (the
|
||||
canvas lives in the browser).
|
||||
|
||||
`ask_page` sends {id, action, args} as the "anomalous.mcp" event over ComfyUI's websocket
|
||||
to every open ComfyUI page and waits. One page claims it (the first claim wins, visible
|
||||
pages claim first: web/modules/mcp_bridge.js), does the action with Anomalous's own canvas
|
||||
code and posts the outcome back; `claim` and `resolve` take those posts
|
||||
(routes in mcp_server.py). With no page open, or none answering in time, the tool fails
|
||||
with words the AI can pass on. Actions on the canvas carry the task's own tab
|
||||
(ai_task_canvas.py), and the tab the page made or opened for it is kept.
|
||||
"""
|
||||
|
||||
import threading
|
||||
import uuid
|
||||
|
||||
TIMEOUT_SECONDS = 30
|
||||
MAX_WAITING = 20
|
||||
|
||||
_lock = threading.Lock()
|
||||
_waiting = {} # id -> {"event": Event, "claimed": bool, "outcome": dict | None}
|
||||
|
||||
|
||||
class PageUnavailable(Exception):
|
||||
"""No ComfyUI page took or finished the action."""
|
||||
|
||||
|
||||
class PageRefused(Exception):
|
||||
"""The page tried and said why it could not (missing node, wrong model type…)."""
|
||||
|
||||
|
||||
def _server():
|
||||
from server import PromptServer # ComfyUI's; imported late so tests can run without it
|
||||
return PromptServer.instance
|
||||
|
||||
|
||||
def ask_page(action, args=None, timeout=TIMEOUT_SECONDS, required_capability=None):
|
||||
"""Runs `action` in the open ComfyUI page; its result value. Call from a worker thread."""
|
||||
server = _server()
|
||||
if not getattr(server, "sockets", None):
|
||||
raise PageUnavailable("ComfyUI is not open in a browser on this computer. Open it, then try again.")
|
||||
from . import ai_task_canvas
|
||||
|
||||
task_canvas = ai_task_canvas.spec(action)
|
||||
if task_canvas:
|
||||
args = {**(args or {}), "_task_canvas": task_canvas}
|
||||
request_id = uuid.uuid4().hex
|
||||
entry = {"event": threading.Event(), "claimed": False, "outcome": None, "required": required_capability}
|
||||
with _lock:
|
||||
if len(_waiting) >= MAX_WAITING:
|
||||
raise PageUnavailable("Too many canvas actions are waiting; try again in a moment.")
|
||||
_waiting[request_id] = entry
|
||||
try:
|
||||
server.send_sync("anomalous.mcp", {"id": request_id, "action": action, "args": args or {}})
|
||||
if not entry["event"].wait(timeout):
|
||||
raise PageUnavailable("The ComfyUI page did not answer in time. Is it open and not frozen? "
|
||||
"If the action was taken late, check the canvas before repeating it.")
|
||||
finally:
|
||||
with _lock:
|
||||
_waiting.pop(request_id, None)
|
||||
outcome = entry["outcome"] or {}
|
||||
if task_canvas and outcome.get("tab"):
|
||||
ai_task_canvas.remember(outcome["tab"])
|
||||
if not outcome.get("ok"):
|
||||
raise PageRefused(str(outcome.get("error") or "The page could not do that."))
|
||||
return outcome.get("value")
|
||||
|
||||
|
||||
def claim(request_id, capabilities=None):
|
||||
"""True for the first page that asks to do request `request_id`."""
|
||||
with _lock:
|
||||
entry = _waiting.get(request_id)
|
||||
if entry is None or entry["claimed"] or entry["outcome"] is not None:
|
||||
return False
|
||||
if entry.get("required") and (not isinstance(capabilities, list) or entry["required"] not in capabilities):
|
||||
entry["outcome"] = {"ok": False, "error": "Refresh the ComfyUI browser page before running from AI. Nothing was queued."}
|
||||
entry["event"].set()
|
||||
return False
|
||||
entry["claimed"] = True
|
||||
return True
|
||||
|
||||
|
||||
def resolve(request_id, outcome):
|
||||
"""The claiming page's outcome: {ok, value} or {ok: false, error}. False when nobody waits."""
|
||||
with _lock:
|
||||
entry = _waiting.get(request_id)
|
||||
if entry is None or not entry["claimed"] or entry["outcome"] is not None:
|
||||
return False
|
||||
entry["outcome"] = outcome if isinstance(outcome, dict) else {"ok": False, "error": "Malformed answer"}
|
||||
entry["event"].set()
|
||||
return True
|
||||
@@ -0,0 +1,314 @@
|
||||
"""The MCP tools that build a workflow on the canvas the user sees: add_node, connect_nodes,
|
||||
set_values, remove_nodes and new_workflow (a new tab, blank or built from a workflow in
|
||||
ComfyUI's API form) run in the open page like mcp_actions.py's canvas tools
|
||||
(web/modules/mcp_canvas_edit.js: each one Ctrl+Z step, in the activity log as the AI's, so the
|
||||
AI workbench shows what it changed), and find_nodes reads the node types this ComfyUI has
|
||||
from its own /object_info. Arguments are checked here for shape and size; the page checks
|
||||
them against the nodes themselves before anything changes."""
|
||||
|
||||
import json
|
||||
import threading
|
||||
import time
|
||||
|
||||
from . import ai_tasks, ai_toolbox, mcp_fill
|
||||
from .mcp_actions import _action, _local, _page
|
||||
from .mcp_tools import ToolError
|
||||
|
||||
MAX_FOUND = 20
|
||||
MAX_SEARCH = 5
|
||||
MAX_CHOICES_NAMED = 60
|
||||
MAX_REMOVE = 30
|
||||
MAX_WORKFLOW_NODES = 200
|
||||
MAX_WORKFLOW_BYTES = 1_000_000
|
||||
INFO_SECONDS = 120
|
||||
|
||||
_info = {"at": 0.0, "data": None}
|
||||
_info_lock = threading.Lock()
|
||||
|
||||
|
||||
def object_info(ctx):
|
||||
"""ComfyUI's node definitions, as its own page reads them (kept a little while)."""
|
||||
with _info_lock:
|
||||
if _info["data"] is None or time.monotonic() - _info["at"] > INFO_SECONDS:
|
||||
status, data = _local(ctx, "GET", "/object_info", timeout=60)
|
||||
if status != 200 or not isinstance(data, dict):
|
||||
raise ToolError(f"ComfyUI's node list is unavailable ({status}).")
|
||||
_info.update(at=time.monotonic(), data=data)
|
||||
return _info["data"]
|
||||
|
||||
|
||||
def forget_object_info():
|
||||
"""After a model moved: the next look reads ComfyUI's lists anew."""
|
||||
with _info_lock:
|
||||
_info["data"] = None
|
||||
|
||||
|
||||
def _input(name, conf, required, choices):
|
||||
kind, options = (conf + [None, None])[:2] if isinstance(conf, list) else (conf, None)
|
||||
options = options if isinstance(options, dict) else {}
|
||||
out = {"name": name, "required": required}
|
||||
listed = kind if isinstance(kind, list) else options.get("options") if kind == "COMBO" else None
|
||||
if isinstance(listed, list):
|
||||
out["type"] = "choice"
|
||||
out["choices"] = [str(item) for item in listed[:choices]]
|
||||
if len(listed) > choices:
|
||||
out["choices_count"] = len(listed)
|
||||
else:
|
||||
out["type"] = str(kind)
|
||||
for key in ("default", "min", "max", "multiline"):
|
||||
if key in options and isinstance(options[key], (str, int, float, bool)):
|
||||
out[key] = options[key] if not isinstance(options[key], str) else options[key][:200]
|
||||
if options.get("forceInput"):
|
||||
out["socket_only"] = True
|
||||
return out
|
||||
|
||||
|
||||
def _picked(ctx):
|
||||
"""What the user picked for this task (ai_toolbox.py): its node types and packs come first in every search."""
|
||||
return ai_toolbox.effective(ai_tasks.get_task(ctx["task"])) if ctx.get("task") else None
|
||||
|
||||
|
||||
def _allowed(ctx, types):
|
||||
"""Refuses node types the user's "only" picks leave out, before the page is asked."""
|
||||
if not ctx.get("task"):
|
||||
return
|
||||
info = object_info(ctx)
|
||||
refused = ai_toolbox.refused(ctx["task"], types, info)
|
||||
if refused:
|
||||
box = ai_toolbox.effective(ai_tasks.get_task(ctx["task"])) or {}
|
||||
allowed = [*(box.get("nodes") or []), *(f"every node of the pack {pack}" for pack in box.get("packs") or [])]
|
||||
raise ToolError(f"For this task the user allowed only these node types (and ComfyUI's built-in ones): "
|
||||
f"{', '.join(allowed) or 'none'}. Not allowed: {', '.join(refused)}. "
|
||||
"If you need one, ask the user in the AI workbench (show_panel) instead.")
|
||||
|
||||
|
||||
def _node(type_name, info, choices):
|
||||
inputs = []
|
||||
for section, required in (("required", True), ("optional", False)):
|
||||
for name, conf in ((info.get("input") or {}).get(section) or {}).items():
|
||||
inputs.append(_input(name, conf, required, choices))
|
||||
names = info.get("output_name") or info.get("output") or []
|
||||
outputs = [{"slot": slot, "name": str(name), "type": str(kind)}
|
||||
for slot, (name, kind) in enumerate(zip(names, info.get("output") or []))]
|
||||
source = ai_toolbox.source_of(info)
|
||||
return {"type": type_name, "display_name": info.get("display_name") or type_name, "category": info.get("category") or "",
|
||||
"source": source, "description": str(info.get("description") or "")[:300], "inputs": inputs, "outputs": outputs,
|
||||
**({"paid": True} if source == "api" else {}), **({"deprecated": True} if info.get("deprecated") else {})}
|
||||
|
||||
|
||||
def find_nodes(ctx, query="", types=None):
|
||||
info = object_info(ctx)
|
||||
if types:
|
||||
missing = [name for name in types if name not in info]
|
||||
found = [_node(name, info[name], MAX_CHOICES_NAMED) for name in types if name in info][:MAX_FOUND]
|
||||
return {"nodes": found, **({"not_found": missing} if missing else {})}
|
||||
words = str(query or "").lower().split()
|
||||
if not words:
|
||||
raise ToolError("Give query (words in a node's name, category or description) or types.")
|
||||
picked = _picked(ctx)
|
||||
scored = []
|
||||
for name, item in info.items():
|
||||
haystack = " ".join(str(part or "") for part in (name, item.get("display_name"), item.get("category"), item.get("description"))).lower()
|
||||
if all(word in haystack for word in words):
|
||||
label = f"{name} {item.get('display_name') or ''}".lower()
|
||||
scored.append((not ai_toolbox.chosen(picked, name, item), 0 if name.lower() == " ".join(words) else 1 if all(w in label for w in words) else 2,
|
||||
bool(item.get("deprecated")), ai_toolbox.source_of(item) == "api", len(name), name))
|
||||
scored.sort()
|
||||
# Searching identifies candidates; don't repeat hundreds of model choices/settings for each.
|
||||
nodes = []
|
||||
for *_rest, name in scored[:MAX_SEARCH]:
|
||||
detail = _node(name, info[name], 0)
|
||||
nodes.append({"type": name, "display_name": str(detail["display_name"])[:80],
|
||||
"source": str(detail["source"])[:80],
|
||||
"description": detail["description"][:96],
|
||||
"inputs": [f"{i['name'][:48]}:{i['type'][:48]}" for i in detail["inputs"][:8]],
|
||||
"outputs": [f"{i['name'][:48]}:{i['type'][:48]}" for i in detail["outputs"][:8]],
|
||||
**{k: detail[k] for k in ("paid", "deprecated") if k in detail},
|
||||
**({"more_inputs": len(detail["inputs"]) - 8} if len(detail["inputs"]) > 8 else {})})
|
||||
for node in nodes:
|
||||
if ai_toolbox.chosen(picked, node["type"], info[node["type"]]):
|
||||
node["picked_by_user"] = True
|
||||
while len(nodes) > 1 and len(json.dumps(nodes, ensure_ascii=False)) > 3000:
|
||||
nodes.pop()
|
||||
return {"nodes": nodes, "total_matches": len(scored),
|
||||
"note": "Brief candidates; types=[chosen type] gives settings/choices and output slots when needed. "
|
||||
"Narrow query for other matches. picked_by_user: preferred; paid: spends credits, use only when asked."}
|
||||
|
||||
|
||||
def _id(value, what):
|
||||
if isinstance(value, bool) or not isinstance(value, (int, str)) or not str(value).strip() or len(str(value)) > 40:
|
||||
raise ToolError(f"{what} is a node id from describe_canvas or a tool's answer.")
|
||||
return value
|
||||
|
||||
|
||||
def _type(value):
|
||||
if not isinstance(value, str) or not value.strip() or len(value) > 200:
|
||||
raise ToolError("type is a node type, as find_nodes gives it (e.g. KSampler).")
|
||||
return value.strip()
|
||||
|
||||
|
||||
def _next(answer):
|
||||
"""The checklist's next step after a change (the page answers with what is still unwired)."""
|
||||
if isinstance(answer, dict):
|
||||
answer["next"] = ("Connect the new branch to an output; it does not reach one yet."
|
||||
if answer.get("reaches_output") is False else
|
||||
"Wire unwired inputs with connect_nodes; unique types need only the two node IDs."
|
||||
if answer.get("unwired") else "No required input is unwired; run_workflow validates and runs the graph.")
|
||||
return answer
|
||||
|
||||
|
||||
def _ids(value, label):
|
||||
if value is None:
|
||||
return []
|
||||
items = value if isinstance(value, list) else [value]
|
||||
if not 1 <= len(items) <= 8:
|
||||
raise ToolError(f"{label} names 1 to 8 node IDs.")
|
||||
return [_id(item, label) for item in items]
|
||||
|
||||
|
||||
def add_node(ctx, type, values=None, title="", near_node_id=None, insert_after=None, insert_type=None,
|
||||
wire_from=None, wire_to=None, replace=False):
|
||||
if not isinstance(replace, bool):
|
||||
raise ToolError("replace must be true or false.")
|
||||
if insert_type is not None and (insert_after is None or not isinstance(insert_type, str) or not 0 < len(insert_type) <= 60):
|
||||
raise ToolError("insert_type names a through type (e.g. IMAGE) and needs insert_after.")
|
||||
wiring = {"wire_from": _ids(wire_from, "wire_from"), "wire_to": _ids(wire_to, "wire_to"), "replace": replace}
|
||||
if insert_after is not None:
|
||||
wiring.update(insert_after=_id(insert_after, "insert_after"), insert_type=insert_type)
|
||||
_allowed(ctx, [_type(type)])
|
||||
return _next(_page("add_node", {"type": _type(type), "values": mcp_fill.flat_values(values), "title": str(title or "")[:120],
|
||||
"near_node_id": None if near_node_id is None else _id(near_node_id, "near_node_id"), **wiring}))
|
||||
|
||||
|
||||
def _api_nodes(nodes, canvas_refs=False):
|
||||
"""A workflow (or group) in ComfyUI's API form, checked for shape and size; the page checks the rest.
|
||||
With canvas_refs a link may name a canvas node as "#12", an output by slot or name, and a node wire_to."""
|
||||
if not isinstance(nodes, dict) or not 0 < len(nodes) <= MAX_WORKFLOW_NODES:
|
||||
raise ToolError(f"nodes is a workflow in ComfyUI's API form: {{id: {{class_type, inputs}}}}, up to {MAX_WORKFLOW_NODES} nodes.")
|
||||
if len(json.dumps(nodes, ensure_ascii=False)) > MAX_WORKFLOW_BYTES:
|
||||
raise ToolError("That workflow is too large.")
|
||||
for key, spec in nodes.items():
|
||||
if (len(key) > 40 or not isinstance(spec, dict) or not isinstance(spec.get("class_type"), str)
|
||||
or not isinstance(spec.get("inputs", {}), dict)):
|
||||
raise ToolError(f"Node {key[:40]}: each node is {{class_type, inputs: {{name: value or [node id, output slot]}}}}.")
|
||||
_type(spec["class_type"])
|
||||
mcp_fill.flat_values({name: value for name, value in spec.get("inputs", {}).items() if not isinstance(value, list)})
|
||||
if not canvas_refs:
|
||||
continue
|
||||
if key.startswith("#"):
|
||||
raise ToolError(f"Node {key[:40]}: a key of the group cannot start with #, which names canvas nodes.")
|
||||
for name, value in spec.get("inputs", {}).items():
|
||||
if isinstance(value, list) and (len(value) != 2 or not isinstance(value[0], (str, int)) or isinstance(value[1], bool)
|
||||
or not isinstance(value[1], (str, int)) or len(str(value[1])) > 100):
|
||||
raise ToolError(f"Node {key[:40]}, input {name[:100]}: a link is [a key of this group or \"#<canvas node id>\", output slot or name].")
|
||||
if isinstance(value, list) and isinstance(value[1], str) and value[1].strip().isdigit():
|
||||
value[1] = int(value[1])
|
||||
if spec.get("wire_to") is not None:
|
||||
spec["wire_to"] = _ids(spec["wire_to"], f"{key[:40]}.wire_to")
|
||||
return nodes
|
||||
|
||||
|
||||
def add_nodes(ctx, nodes, near_node_id=None, replace=False):
|
||||
if not isinstance(replace, bool):
|
||||
raise ToolError("replace must be true or false.")
|
||||
_api_nodes(nodes, canvas_refs=True)
|
||||
_allowed(ctx, [spec["class_type"] for spec in nodes.values()])
|
||||
return _next(_page("add_nodes", {"nodes": nodes, "replace": replace,
|
||||
"near_node_id": None if near_node_id is None else _id(near_node_id, "near_node_id")}, timeout=60))
|
||||
|
||||
|
||||
def connect_nodes(ctx, from_node_id, to_node_id, input=None, output=None, replace=None):
|
||||
if output is not None and (isinstance(output, bool) or not isinstance(output, (int, str)) or len(str(output)) > 100):
|
||||
raise ToolError("output is the output's slot number or its name.")
|
||||
output = int(output) if isinstance(output, str) and output.strip().isdigit() else output
|
||||
if input is not None and (not isinstance(input, str) or not input or len(input) > 100):
|
||||
raise ToolError("input is the input's name, as add_node, find_nodes or describe_canvas give it.")
|
||||
if replace is not None and not isinstance(replace, bool):
|
||||
raise ToolError("replace must be true or false.")
|
||||
# Preserve the old explicit-input form's default output and replacement behaviour.
|
||||
if input is not None and output is None:
|
||||
output = 0
|
||||
return _next(_page("connect_nodes", {"from_node_id": _id(from_node_id, "from_node_id"), "output": output,
|
||||
"to_node_id": _id(to_node_id, "to_node_id"), "input": input, "replace": replace}))
|
||||
|
||||
|
||||
def set_values(ctx, node_id=None, values=None):
|
||||
if node_id is None:
|
||||
return _page("set_values", {"node_id": None, "values": mcp_fill.node_values(values)})
|
||||
if not values:
|
||||
raise ToolError("values is an object {setting name: value}.")
|
||||
return _page("set_values", {"node_id": _id(node_id, "node_id"), "values": mcp_fill.flat_values(values)})
|
||||
|
||||
|
||||
def remove_nodes(ctx, node_ids):
|
||||
if not isinstance(node_ids, list) or not 0 < len(node_ids) <= MAX_REMOVE:
|
||||
raise ToolError(f"node_ids lists 1 to {MAX_REMOVE} node ids.")
|
||||
return _next(_page("remove_nodes", {"node_ids": [_id(item, "node_ids") for item in node_ids]}))
|
||||
|
||||
|
||||
def new_workflow(ctx, name="", nodes=None):
|
||||
if nodes is not None:
|
||||
_api_nodes(nodes)
|
||||
_allowed(ctx, [spec["class_type"] for spec in nodes.values()])
|
||||
return _page("new_workflow", {"name": str(name or "")[:60], "nodes": nodes}, timeout=60)
|
||||
|
||||
|
||||
def open_workflow(ctx, workflow):
|
||||
filename, name = mcp_fill.saved_workflow(workflow)
|
||||
return _page("open_workflow", {"filename": filename, "name": name}, timeout=60)
|
||||
|
||||
|
||||
_NODE_ID = {"type": "integer", "description": "A node id."}
|
||||
_VALUES = {"type": "object", "description": "{setting: value}; a choice exactly as listed."}
|
||||
_NEIGHBOURS = {"oneOf": [_NODE_ID, {"type": "array", "items": _NODE_ID, "minItems": 1, "maxItems": 8}]}
|
||||
|
||||
CANVAS_TOOLS = dict([
|
||||
_action("find_nodes", "Look up node types",
|
||||
"Node types, built in and custom. query: up to 5 brief candidates; types=[...]: their inputs, "
|
||||
"choices, ranges and outputs.",
|
||||
find_nodes, {"query": {"type": "string"}, "types": {"type": "array", "items": {"type": "string"}, "maxItems": MAX_FOUND}},
|
||||
read_only=True),
|
||||
_action("add_node", "Add a node",
|
||||
"Adds a node, wired in the same call: wire_from feeds it, wire_to takes its output (an input already "
|
||||
"fed is spliced, its old source now feeding the new node: a ControlNet or LoRA before a KSampler); "
|
||||
"insert_after=ID splices it behind a node. Same type or same socket name wires itself; anything "
|
||||
"ambiguous changes nothing and lists the choices; replace:true replaces what it cannot splice. One "
|
||||
"Ctrl+Z step. Several nodes wired to each other (an inpaint or upscale branch): add_nodes, in one call.",
|
||||
add_node, {"type": {"type": "string", "description": "A node type from find_nodes, e.g. KSampler."},
|
||||
"values": _VALUES, "title": {"type": "string"}, "near_node_id": _NODE_ID,
|
||||
"insert_after": _NODE_ID, "insert_type": {"type": "string", "description": "Through type, only if asked (e.g. IMAGE)."},
|
||||
"wire_from": _NEIGHBOURS, "wire_to": _NEIGHBOURS, "replace": {"type": "boolean"}}, ["type"]),
|
||||
_action("add_nodes", "Add a group of nodes",
|
||||
"Adds a group of nodes in one call, as one block, in ComfyUI's API form: {\"a\": {\"class_type\": "
|
||||
"\"VAEEncode\", \"inputs\": {\"pixels\": [\"#12\", 0], \"vae\": [\"#4\", \"VAE\"]}}, \"b\": {..., \"inputs\": "
|
||||
"{\"samples\": [\"a\", 0]}, \"wire_to\": 15}}. A link names a key of the group or a canvas node \"#id\", and "
|
||||
"an output slot or name; wire_to as in add_node. Checked first; one Ctrl+Z step; the answer maps keys "
|
||||
"to node ids.",
|
||||
add_nodes, {"nodes": {"type": "object"}, "near_node_id": _NODE_ID, "replace": {"type": "boolean"}}, ["nodes"]),
|
||||
_action("connect_nodes", "Wire two nodes",
|
||||
"Wires two nodes: every unique matching type, and same-type sockets of the same name (positive to "
|
||||
"positive). Anything ambiguous (a lone CONDITIONING into positive or negative, wildcards) changes "
|
||||
"nothing and lists the choices; then give output and input. replace:true lets it replace wires. One "
|
||||
"Ctrl+Z step.",
|
||||
connect_nodes, {"from_node_id": _NODE_ID, "output": {"type": "string", "description": "Optional output slot number or name."},
|
||||
"to_node_id": _NODE_ID, "input": {"type": "string"}, "replace": {"type": "boolean"}},
|
||||
["from_node_id", "to_node_id"]),
|
||||
_action("set_values", "Change a node's settings",
|
||||
"Changes settings of any node, a third party's too, checked against what each takes: {setting: value} "
|
||||
"goes to the one node that has it; name the node when several do: {\"12\": {\"denoise\": 0.5}}; or "
|
||||
"node_id with its settings. Prompts: set_prompt; models: set_model. One Ctrl+Z step.",
|
||||
set_values, {"node_id": _NODE_ID, "values": _VALUES}, ["values"], destructive=True),
|
||||
_action("remove_nodes", "Remove nodes",
|
||||
"Removes nodes from the open workflow, with their wires. One Ctrl+Z step.",
|
||||
remove_nodes, {"node_ids": {"type": "array", "items": _NODE_ID, "maxItems": MAX_REMOVE}}, ["node_ids"],
|
||||
destructive=True),
|
||||
_action("new_workflow", "Start a new workflow",
|
||||
"Opens a new workflow tab, the user's open one untouched: blank, or built from nodes in ComfyUI's API "
|
||||
"form ({\"1\": {\"class_type\": \"CLIPTextEncode\", \"inputs\": {\"text\": \"...\", \"clip\": [\"2\", 1]}}}: a value "
|
||||
"or [node id, output slot]). Checked before it opens; the answer maps your ids to node ids.",
|
||||
new_workflow, {"name": {"type": "string"}, "nodes": {"type": "object"}}),
|
||||
_action("open_workflow", "Open a saved workflow",
|
||||
"Opens one of the user's saved workflows (list_workflows names them) in a new tab, leaving the open one "
|
||||
"as it was, to run it or build on it with add_node, connect_nodes and set_values.",
|
||||
open_workflow, {"workflow": {"type": "string", "description": "A workflow name from list_workflows."}}, ["workflow"]),
|
||||
])
|
||||
@@ -0,0 +1,114 @@
|
||||
"""A directory of the tools by what an AI wants to do, so it goes straight to the right one, as
|
||||
ARCHITECTURE.md does for the code: each tool under its stage of the work (action_catalog.TOOLS),
|
||||
with its title, in the catalog's order. It is built from the registry, so a new tool shows up by
|
||||
itself (tests/test_mcp_directory.py checks that every stage has a heading). mcp_server.py puts it
|
||||
into begin_task's answer, and into get_situation's while there is no task yet.
|
||||
|
||||
AI apps keep the tool list they fetched (Antigravity files it away and fetches it again only when
|
||||
it reconnects), so after Anomalous is updated an app can go on with the old one: new tools missing,
|
||||
gone ones still called. listed() keeps which list each app fetched last (a fingerprint, in
|
||||
anomalous/ai_tool_lists.json); a call from an app whose list is not today's tells the AI, and notes
|
||||
it on the task (task["stale_tools"]) so the workbench tells the user how to reconnect, until the app
|
||||
fetches the list again.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
|
||||
from . import action_catalog, ai_tasks
|
||||
from .mcp_tools import retext
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
SECTIONS = ( # stage -> heading, in the order work usually goes
|
||||
("run", "Run a workflow"), ("canvas", "The workflow on the canvas"), ("model", "Models"), ("prompt", "Prompts"),
|
||||
("combo", "Combos"), ("picture", "Pictures"), ("voice", "Voices"), ("library", "The library"),
|
||||
(None, "The task and the user"),
|
||||
)
|
||||
NOTE = "The tools by what you want to do: go straight to the one you need instead of looking around first."
|
||||
STALE_NOTE = ("Your app holds an older list of Anomalous's tools (Anomalous was updated since it fetched it): some may "
|
||||
"be missing or gone. The call went through, but tell the user in report to reconnect the app to Anomalous "
|
||||
"(Antigravity: restart it, or switch the anomalous MCP server off and on) and to go on in a new chat.")
|
||||
_lists = None # app -> fingerprint of the tool list it fetched last
|
||||
|
||||
|
||||
def directory(specs):
|
||||
"""{heading: "tool (title), ..."} for the tools of `specs` {name: spec}."""
|
||||
sections = {}
|
||||
for name, entry in action_catalog.TOOLS.items():
|
||||
if name in specs:
|
||||
sections.setdefault(entry.stage, []).append(f"{name} ({specs[name].get('title') or name})")
|
||||
return {"note": NOTE, **{heading: ", ".join(sections[stage]) for stage, heading in SECTIONS if stage in sections}}
|
||||
|
||||
|
||||
def attach(result, name, specs):
|
||||
"""Puts the directory into begin_task's answer, and into get_situation's while there is no task."""
|
||||
data = result.get("structuredContent") if isinstance(result, dict) and not result.get("isError") else None
|
||||
if not isinstance(data, dict) or not (name == "begin_task" or (name == "get_situation" and not data.get("task"))):
|
||||
return result
|
||||
retext(result, {**data, "directory": directory(specs)})
|
||||
return result
|
||||
|
||||
|
||||
def fingerprint(tools):
|
||||
return hashlib.sha256(json.dumps(tools, sort_keys=True, ensure_ascii=False).encode("utf-8")).hexdigest()[:16]
|
||||
|
||||
|
||||
def _path():
|
||||
return os.path.join(os.path.dirname(ai_tasks.tasks_dir()), "ai_tool_lists.json")
|
||||
|
||||
|
||||
def _known():
|
||||
global _lists
|
||||
if _lists is None:
|
||||
try:
|
||||
with open(_path(), encoding="utf-8") as source:
|
||||
stored = json.load(source)
|
||||
except (OSError, ValueError):
|
||||
stored = {}
|
||||
_lists = stored if isinstance(stored, dict) else {}
|
||||
return _lists
|
||||
|
||||
|
||||
def listed(client, tools):
|
||||
"""The app `client` fetched `tools`: kept, and the notes on its tasks go."""
|
||||
with ai_tasks._lock:
|
||||
known = _known()
|
||||
if known.get(client) != fingerprint(tools):
|
||||
known[client] = fingerprint(tools)
|
||||
atomic_write_json(_path(), known)
|
||||
changed = [task for task in ai_tasks._load().values() if task.get("stale_tools") and task.get("client") == client]
|
||||
for task in changed:
|
||||
task.pop("stale_tools")
|
||||
ai_tasks._save(task)
|
||||
for task in changed:
|
||||
ai_tasks._notify(task["id"])
|
||||
|
||||
|
||||
def stale(client, tools):
|
||||
"""Whether the app `client` fetched another list than `tools` last (one never seen fetching: no)."""
|
||||
with ai_tasks._lock:
|
||||
known = _known().get(client)
|
||||
return bool(known) and known != fingerprint(tools)
|
||||
|
||||
|
||||
def tell_stale(result, task_id):
|
||||
"""Says so in the call's answer, and notes it on the task for the workbench."""
|
||||
if isinstance(result, dict):
|
||||
data = result.get("structuredContent")
|
||||
first = (result.get("content") or [None])[0]
|
||||
if isinstance(data, dict) and not result.get("isError"):
|
||||
retext(result, {**data, "tool_list": STALE_NOTE})
|
||||
elif isinstance(first, dict) and first.get("type") == "text":
|
||||
result["content"][0] = {**first, "text": f"{first.get('text', '')} {STALE_NOTE}"}
|
||||
if not task_id:
|
||||
return result
|
||||
with ai_tasks._lock:
|
||||
task = ai_tasks._load().get(task_id)
|
||||
if task is None or task.get("stale_tools"):
|
||||
return result
|
||||
task["stale_tools"] = time.time()
|
||||
ai_tasks._save(task)
|
||||
ai_tasks._notify(task_id)
|
||||
return result
|
||||
+102
@@ -0,0 +1,102 @@
|
||||
"""run_workflow's blanks: a daily run in one call, so a small model need not read and edit the canvas.
|
||||
|
||||
With `workflow` (a saved workflow's name) the run opens it in the task's tab the first time and
|
||||
reuses that tab after (the page marks a tab open_workflow opened with the workflow's file); what
|
||||
the AI fills in goes into it first (web/modules/mcp_canvas_edit.js fill_slots): the positive and
|
||||
negative prompt boxes, the seed of every sampler, the empty latent's width and height, the
|
||||
picture its LoadImage reads (from the input or the output folder, found here, never copied;
|
||||
image_node says which LoadImage when there are several), and `values`: any other setting by its
|
||||
name, a third-party node's as well, for the one node that has it ({node id: {...}} when several
|
||||
do; set_values takes the same). No fixed list of blanks grows here. The rest stays as saved. Without
|
||||
`workflow` the blanks go into the canvas the run would run. All of it is checked before anything
|
||||
changes, and it is one Ctrl+Z step logged as the AI's.
|
||||
"""
|
||||
|
||||
from . import ai_task_canvas, ai_tasks
|
||||
from .mcp_bridge import PageRefused, PageUnavailable, ask_page
|
||||
from .mcp_tools import ToolError, _resolve_folder_image, list_workflows
|
||||
|
||||
SLOTS = ("prompt", "negative", "seed", "width", "height", "image", "image_node", "values")
|
||||
MAX_VALUES = 60
|
||||
MAX_TEXT = 20000
|
||||
|
||||
|
||||
def flat_values(values):
|
||||
"""{setting name: value}, checked for shape and size; the page checks what each setting takes."""
|
||||
if values is None:
|
||||
return {}
|
||||
if not isinstance(values, dict) or len(values) > MAX_VALUES:
|
||||
raise ToolError(f"values is an object {{setting name: value}} of up to {MAX_VALUES} settings.")
|
||||
for name, value in values.items():
|
||||
if len(name) > 100 or not (isinstance(value, (bool, int, float)) or (isinstance(value, str) and len(value) <= MAX_TEXT)):
|
||||
raise ToolError(f"The value of {name[:100]} is a number, true/false or text of up to {MAX_TEXT} characters.")
|
||||
return values
|
||||
|
||||
|
||||
def node_values(values):
|
||||
"""Settings by name ({setting name: value}) or for one node ({node id: {setting name: value}})."""
|
||||
if not isinstance(values, dict) or not values:
|
||||
raise ToolError('values is {setting name: value}, or {"<node id>": {setting name: value}} for one node.')
|
||||
nested = {key: value for key, value in values.items() if isinstance(value, dict)}
|
||||
for key, settings in nested.items():
|
||||
if not str(key).isdigit():
|
||||
raise ToolError(f"values.{str(key)[:40]}: only a node id takes an object of settings.")
|
||||
flat_values(settings)
|
||||
flat_values({key: value for key, value in values.items() if key not in nested})
|
||||
if len(values) - len(nested) + sum(len(settings) for settings in nested.values()) > MAX_VALUES:
|
||||
raise ToolError(f"values sets up to {MAX_VALUES} settings at once.")
|
||||
return values
|
||||
|
||||
|
||||
def saved_workflow(name):
|
||||
"""(file name, name) of the user's saved workflow called `name`."""
|
||||
from .recipe_store import _list_recipes, get_recipes_dir
|
||||
|
||||
name = str(name or "").strip()
|
||||
if not name or not any(item["name"] == name for item in list_workflows(name, 50)["workflows"]):
|
||||
raise ToolError(f"No saved workflow called {name}; list_workflows names them.")
|
||||
filename = next((recipe["filename"] for recipe in _list_recipes(get_recipes_dir())
|
||||
if (recipe["data"].get("name") or recipe["filename"]) == name), None)
|
||||
return filename, name
|
||||
|
||||
|
||||
def _picture(image):
|
||||
"""The value a LoadImage takes for picture `image`: in the input folder as it is, from the
|
||||
output folder with ComfyUI's "[output]" mark (it reads it from there)."""
|
||||
for folder in ("input", "output"):
|
||||
try:
|
||||
rel, _path = _resolve_folder_image(image, folder)
|
||||
except ToolError:
|
||||
continue
|
||||
return rel if folder == "input" else f"{rel} [output]"
|
||||
raise ToolError(f"{image} is in neither ComfyUI's input nor its output folder; search_images lists the pictures in the output.")
|
||||
|
||||
|
||||
def _page(action, args, timeout=30):
|
||||
try:
|
||||
return ask_page(action, args, timeout)
|
||||
except (PageUnavailable, PageRefused) as error:
|
||||
raise ToolError(str(error))
|
||||
|
||||
|
||||
def fill(ctx, workflow=None, **slots):
|
||||
"""Opens `workflow` for the task (once) and fills `slots` in; what was set, or None when nothing was asked."""
|
||||
slots = {key: value for key, value in slots.items() if key in SLOTS and value not in (None, "")}
|
||||
if not workflow and not slots:
|
||||
return None
|
||||
if "image" in slots:
|
||||
slots["image"] = _picture(slots["image"])
|
||||
if "values" in slots:
|
||||
node_values(slots["values"])
|
||||
filename = name = None
|
||||
if workflow:
|
||||
filename, name = saved_workflow(workflow)
|
||||
task = ai_tasks.get_task(ctx.get("task")) if ctx.get("task") else None
|
||||
no_tab_yet = bool(task) and ai_task_canvas.mode_of(task) == "new" and not (task.get("canvas") or {}).get("tab")
|
||||
filled = None if workflow and no_tab_yet else _page("fill_slots", {"filename": filename, **slots})
|
||||
if workflow and (filled is None or filled.get("needs_open")):
|
||||
_page("open_workflow", {"filename": filename, "name": name}, timeout=60)
|
||||
filled = _page("fill_slots", {"filename": filename, **slots})
|
||||
if filled.get("needs_open"):
|
||||
raise ToolError(f"The saved workflow {name} did not open; nothing was run.")
|
||||
return {**({"workflow": name} if name else {}), **(filled.get("set") or {})}
|
||||
@@ -0,0 +1,86 @@
|
||||
"""zoom_image, the AI's closer look: part of a picture (in ComfyUI's output, input or temp folder)
|
||||
cut out and shown larger, and the same part of a second picture beside it to compare a before
|
||||
and an after, attached to the answer. It reads only: the pictures stay as they are. With it an AI
|
||||
need not crop, enlarge or compare pictures with code of its own (each such command asks the user
|
||||
to allow it). The region is in fractions of the picture, as the user's marks give theirs."""
|
||||
|
||||
import base64
|
||||
import io
|
||||
|
||||
from PIL import Image
|
||||
|
||||
from .mcp_tools import ToolError, _resolve_folder_image, _tool
|
||||
|
||||
MIN_SIZE, MAX_SIZE, DEFAULT_SIZE = 256, 1024, 768
|
||||
MAX_ENLARGE = 4 # a tiny part is shown at most this many times its size
|
||||
MIN_PIXELS = 8
|
||||
|
||||
|
||||
def _box(region, width, height):
|
||||
"""Region {x, y, width, height} (fractions 0-1, default the whole picture) as a pixel box."""
|
||||
region = region if isinstance(region, dict) else {}
|
||||
try:
|
||||
x, y = (min(1.0, max(0.0, float(region.get(key, 0)))) for key in ("x", "y"))
|
||||
w, h = (min(1.0, max(0.0, float(region.get(key, 1)))) for key in ("width", "height"))
|
||||
except (TypeError, ValueError):
|
||||
raise ToolError("region is {x, y, width, height}, each a fraction 0-1 of the picture.")
|
||||
left, top = round(x * width), round(y * height)
|
||||
right, bottom = min(width, round((x + w) * width)), min(height, round((y + h) * height))
|
||||
if right - left < MIN_PIXELS or bottom - top < MIN_PIXELS:
|
||||
raise ToolError(f"The region is under {MIN_PIXELS} pixels across; give a larger one.")
|
||||
return left, top, right, bottom
|
||||
|
||||
|
||||
def _part(path, region, size):
|
||||
"""(facts, MCP image item) of `region` of the picture at `path`, its longer side `size` at most."""
|
||||
try:
|
||||
with Image.open(path) as picture:
|
||||
box = _box(region, picture.width, picture.height)
|
||||
part = picture.crop(box).convert("RGB")
|
||||
whole = f"{picture.width}x{picture.height}"
|
||||
except (OSError, ValueError, Image.DecompressionBombError):
|
||||
raise ToolError("The picture cannot be read.")
|
||||
scale = min(size / max(part.size), MAX_ENLARGE)
|
||||
shown = part.resize((max(1, round(part.width * scale)), max(1, round(part.height * scale))), Image.LANCZOS)
|
||||
data = io.BytesIO()
|
||||
shown.save(data, "JPEG", quality=88)
|
||||
facts = {"picture": whole, "region": f"x {box[0]}-{box[2]}, y {box[1]}-{box[3]} px", "shown": f"{shown.width}x{shown.height}"}
|
||||
return facts, {"type": "image", "data": base64.b64encode(data.getvalue()).decode("ascii"), "mimeType": "image/jpeg"}
|
||||
|
||||
|
||||
def zoom_image(image, region=None, folder="output", compare_with="", compare_folder="", size=DEFAULT_SIZE):
|
||||
try:
|
||||
size = min(MAX_SIZE, max(MIN_SIZE, int(size)))
|
||||
except (TypeError, ValueError):
|
||||
raise ToolError(f"size is {MIN_SIZE}-{MAX_SIZE} pixels.")
|
||||
rel, path = _resolve_folder_image(image, folder)
|
||||
facts, item = _part(path, region, size)
|
||||
answer = {"image": rel, "folder": folder, **facts}
|
||||
extra = [item]
|
||||
if compare_with:
|
||||
other_folder = compare_folder or folder
|
||||
other_rel, other_path = _resolve_folder_image(compare_with, other_folder)
|
||||
other_facts, other_item = _part(other_path, region, size)
|
||||
answer["compare_with"] = {"image": other_rel, "folder": other_folder, **other_facts}
|
||||
answer["note"] = "Two pictures are attached: first image, then compare_with, the same region of each."
|
||||
extra.append(other_item)
|
||||
return answer, extra
|
||||
|
||||
|
||||
_REGION = {"type": "object", "description": "Fractions 0-1, like the user's marks; default all.",
|
||||
"properties": {name: {"type": "number", "minimum": 0, "maximum": 1} for name in ("x", "y", "width", "height")}}
|
||||
_FOLDER = {"type": "string", "enum": ["output", "input", "temp"], "default": "output"}
|
||||
|
||||
LOOK_TOOLS = dict([
|
||||
_tool("zoom_image", "Look closer at a picture",
|
||||
"Part of a picture larger, at full detail (a hand, a face, a seam). folder: output, input or temp. "
|
||||
"compare_with: a second picture, the same region beside it. Use it instead of cropping with code; "
|
||||
"change pictures only by running a workflow, never by editing their files.",
|
||||
zoom_image, {"image": {"type": "string", "description": "As the other tools name it."},
|
||||
"region": _REGION, "folder": _FOLDER,
|
||||
"compare_with": {"type": "string", "description": "A second picture."},
|
||||
"compare_folder": {"type": "string", "enum": ["output", "input", "temp"],
|
||||
"description": "Default: folder."},
|
||||
"size": {"type": "integer", "minimum": MIN_SIZE, "maximum": MAX_SIZE, "default": DEFAULT_SIZE}},
|
||||
["image"]),
|
||||
])
|
||||
@@ -0,0 +1,170 @@
|
||||
"""Where a model loads, for the AI: search_models and get_model (mcp_tools.py finds the files)
|
||||
say which node types list each file among their choices (ComfyUI's /object_info, kept a little
|
||||
while by mcp_canvas_edit.py), and, when a file's header says it is another kind than the folder
|
||||
it is in (model_placement.py, the models page's Tidy view), where it belongs and that nothing
|
||||
loads it where it is. So the AI picks the right node at once, or has the model moved, instead of
|
||||
searching ComfyUI itself. move_model moves one model with its covers and notes as Tidy does,
|
||||
behind the "files" gate (the user says yes first unless they let it go ahead)."""
|
||||
|
||||
import os
|
||||
import threading
|
||||
|
||||
import folder_paths
|
||||
|
||||
from . import mcp_canvas_edit, mcp_tools, model_advice, model_placement
|
||||
from .mcp_actions import _action
|
||||
from .mcp_tools import _LIMIT, _QUERY, ToolError
|
||||
from .model_constants import MODEL_EXTENSIONS
|
||||
from .model_import import Refused, import_types
|
||||
|
||||
MAX_LOADERS = 6
|
||||
|
||||
_lock = threading.Lock()
|
||||
_index = {"of": None, "inputs": [], "by_choice": {}}
|
||||
|
||||
|
||||
def _plain(name):
|
||||
return str(name).replace("\\", "/")
|
||||
|
||||
|
||||
def _choices(conf):
|
||||
if not isinstance(conf, list) or not conf:
|
||||
return None
|
||||
if isinstance(conf[0], list):
|
||||
return conf[0]
|
||||
options = conf[1] if len(conf) > 1 and isinstance(conf[1], dict) else {}
|
||||
return options.get("options") if conf[0] == "COMBO" and isinstance(options.get("options"), list) else None
|
||||
|
||||
|
||||
def _built(info):
|
||||
"""The drop-downs of model files in node definitions `info`: [(node type, choices)] and choice -> their places."""
|
||||
with _lock:
|
||||
if _index["of"] is info:
|
||||
return _index
|
||||
inputs, by_choice = [], {}
|
||||
for node_type, item in info.items():
|
||||
for section in ("required", "optional"):
|
||||
for conf in ((item.get("input") or {}).get(section) or {}).values():
|
||||
listed = [_plain(choice) for choice in _choices(conf) or [] if isinstance(choice, str)]
|
||||
if not any(choice.lower().endswith(MODEL_EXTENSIONS) for choice in listed):
|
||||
continue
|
||||
for choice in listed:
|
||||
by_choice.setdefault(choice, []).append(len(inputs))
|
||||
inputs.append((node_type, frozenset(listed)))
|
||||
_index.update(of=info, inputs=inputs, by_choice=by_choice)
|
||||
return _index
|
||||
|
||||
|
||||
def _folder(folder_type):
|
||||
return frozenset(_plain(name) for name in folder_paths.get_filename_list(folder_type))
|
||||
|
||||
|
||||
def _readers(ctx, folder_type, rel=None):
|
||||
"""Node types with a drop-down of the whole folder `folder_type` (one that lists `rel`, when given)."""
|
||||
index = _built(mcp_canvas_edit.object_info(ctx))
|
||||
folder = _folder(folder_type)
|
||||
if not folder:
|
||||
return []
|
||||
places = index["by_choice"].get(_plain(rel), []) if rel else range(len(index["inputs"]))
|
||||
found = []
|
||||
for at in places:
|
||||
node_type, choices = index["inputs"][at]
|
||||
if folder <= choices and node_type not in found:
|
||||
found.append(node_type)
|
||||
return found[:MAX_LOADERS]
|
||||
|
||||
|
||||
def _about(ctx, model):
|
||||
"""`model` (from mcp_tools) with what loads it: loaded_by, or belongs_in and placement when it is misfiled."""
|
||||
folder_type, root, base_dir, path = mcp_tools._resolve_model(model["model_id"])
|
||||
rel = os.path.relpath(path, base_dir).replace(os.sep, "/")
|
||||
home = model_placement.belongs(model_placement.one(folder_type, root, rel, path))
|
||||
if not home or home["works"]:
|
||||
model["loaded_by"] = _readers(ctx, folder_type, rel)
|
||||
return model
|
||||
kind, to = home["kind"], home["to"]
|
||||
readers = _readers(ctx, kind)
|
||||
words = (f"Its header says it is a {kind} file, but it is in {folder_type}: the nodes listing it there cannot load it"
|
||||
+ (f"; {', '.join(readers)} load {kind} files." if readers else "."))
|
||||
there = os.path.join(folder_paths.get_folder_paths(kind)[to["root"]], *to["rel"].split("/"))
|
||||
if os.path.isfile(there):
|
||||
words += (f" A file of the same name is already in {kind} (model_id {kind}:{to['root']}:{to['rel']}): use that one. "
|
||||
"If it is the same file, this copy is extra; the user can recycle it in Anomalous's models page (Tidy).")
|
||||
else:
|
||||
words += f" move_model with to_type {kind} moves it there (the user confirms first)."
|
||||
model.update(belongs_in=kind, placement=words)
|
||||
return model
|
||||
|
||||
|
||||
def search_models(ctx, query="", type="", base_model="", source="", limit=20):
|
||||
found = mcp_tools.search_models(query, type, base_model, source, limit)
|
||||
for model in found["models"]:
|
||||
_about(ctx, model)
|
||||
return found
|
||||
|
||||
|
||||
def get_model(ctx, model_id, include_cover=False):
|
||||
detail, extra = mcp_tools.get_model(model_id, include_cover)
|
||||
folder_type, _idx, _base, path = mcp_tools._resolve_model(model_id)
|
||||
examples = model_advice.author_examples(path, folder_type, detail.get("sha256", ""))
|
||||
if examples:
|
||||
detail["author_examples"] = examples
|
||||
return _about(ctx, detail), extra
|
||||
|
||||
|
||||
def move_model(ctx, model_id, to_type):
|
||||
folder_type, root, base_dir, path = mcp_tools._resolve_model(model_id)
|
||||
rel = os.path.relpath(path, base_dir).replace(os.sep, "/")
|
||||
item = model_placement.one(folder_type, root, rel, path)
|
||||
home = model_placement.belongs(item)
|
||||
to_type = str(to_type or "")
|
||||
if to_type == folder_type:
|
||||
raise ToolError(f"It is in {to_type} already.")
|
||||
if to_type not in import_types():
|
||||
raise ToolError(f"to_type is one of {', '.join(import_types())}.")
|
||||
to = home["to"] if home and home["kind"] == to_type else model_placement.home_for(item, to_type)
|
||||
if not to:
|
||||
raise ToolError(f"This ComfyUI has no {to_type} folder.")
|
||||
if os.path.exists(os.path.join(folder_paths.get_folder_paths(to_type)[to["root"]], *to["rel"].split("/"))):
|
||||
raise ToolError(f"A file of the same name is already in {to_type} (model_id {to_type}:{to['root']}:{to['rel']}); "
|
||||
"nothing was moved. Use that one; the user can recycle an extra copy in Anomalous's models page (Tidy).")
|
||||
try:
|
||||
moved = model_placement.move({"type": folder_type, "root": root, "rel": rel,
|
||||
"to_type": to_type, "to_root": to["root"], "to_rel": to["rel"]})
|
||||
except Refused as error:
|
||||
raise ToolError(f"Not moved ({error.code}).")
|
||||
mcp_canvas_edit.forget_object_info()
|
||||
answer = {"moved": {"from": f"{folder_type}/{rel}", "to": f"{moved['type']}/{moved['rel']}"},
|
||||
"model_id": f"{moved['type']}:{moved['root']}:{moved['rel']}",
|
||||
"loaded_by": _readers(ctx, moved["type"], moved["rel"])}
|
||||
if moved["left"]:
|
||||
answer["left_behind"] = moved["left"] # covers or notes that could not go along
|
||||
return answer
|
||||
|
||||
|
||||
MODEL_TOOLS = dict([
|
||||
_action("search_models", "Search models",
|
||||
"Model files by name, trigger word or base model: model_id, and loaded_by (the node types that list "
|
||||
"the file). A misfiled one comes with belongs_in: nothing loads it where it is.",
|
||||
search_models, {
|
||||
"query": _QUERY,
|
||||
"type": {"type": "string", "description": "A models folder: checkpoints, loras, vae…"},
|
||||
"base_model": {"type": "string", "description": "e.g. SDXL, Pony, Flux."},
|
||||
"source": {"type": "string", "enum": ["civitai", "inferred_from_file", "not_scanned"],
|
||||
"description": "Where the model's information came from."},
|
||||
"limit": _LIMIT}, read_only=True),
|
||||
_action("get_model", "Model details",
|
||||
"Everything known about one model: Civitai name, version and link, trigger words, base model, description, "
|
||||
"the user's own name and notes, author_examples (the sampler, steps, CFG, size and, for a LoRA, the weight "
|
||||
"its author's example pictures used: a good start), and loaded_by (or belongs_in and placement) as in "
|
||||
"search_models. include_cover attaches its cover picture.",
|
||||
get_model, {"model_id": {"type": "string", "description": "From search_models."},
|
||||
"include_cover": {"type": "boolean", "default": False}}, ["model_id"], read_only=True),
|
||||
_action("move_model", "Move a model to its folder",
|
||||
"Moves a model the user has in the wrong models folder (search_models says belongs_in) to where it loads, "
|
||||
"with its covers and notes, as Anomalous's Tidy view does; never over a file. The answer gives its new "
|
||||
"model_id and loaded_by; the canvas lists it from then on.",
|
||||
move_model, {"model_id": {"type": "string", "description": "From search_models."},
|
||||
"to_type": {"type": "string", "description": "The models folder to move it to: belongs_in from search_models."}},
|
||||
["model_id", "to_type"], destructive=True),
|
||||
])
|
||||
@@ -0,0 +1,59 @@
|
||||
"""Ready-made requests the user can start from their AI app (MCP prompts; Claude shows them as
|
||||
slash commands such as /anomalous:pick_best): each is a few lines telling the AI how to do a
|
||||
common job with Anomalous's tools so the user can watch, choose and step in on the AI workbench.
|
||||
They only shape the AI's first message; they change nothing themselves."""
|
||||
|
||||
PROMPTS = {
|
||||
"workbench_task": {
|
||||
"title": "Start a task on the AI workbench",
|
||||
"description": "Do something in ComfyUI the way the user can follow on Anomalous's AI workbench.",
|
||||
"arguments": [{"name": "what", "description": "What to do", "required": True}],
|
||||
"text": ("Use Anomalous for this: {what}\n"
|
||||
"Call begin_task with a short title in my language first. Show your plan, then results, with "
|
||||
"show_panel in the order they happen; when a choice is mine, ask it with ask_user (or a picks panel, "
|
||||
"waiting with get_answers), never in this chat. Honour any user_messages that come with a tool result. End with report(done=true)."),
|
||||
},
|
||||
"pick_best": {
|
||||
"title": "Make a few, let me pick",
|
||||
"description": "Make several variations with the open workflow and let the user pick one.",
|
||||
"arguments": [{"name": "what", "description": "What to vary (seed, LoRA weight, prompt…)", "required": True},
|
||||
{"name": "count", "description": "How many (default 3)", "required": False}],
|
||||
"text": ("Make {count} variations of the open ComfyUI workflow, changing: {what}.\n"
|
||||
"Call begin_task first. Read the canvas (describe_canvas), change one thing per run, run the workflow "
|
||||
"each time and find the pictures with search_images. Then show them with show_panel as a picks block, "
|
||||
"each with what you changed as its reason, and wait for my pick with get_answers. Put the chosen "
|
||||
"settings back on the canvas and report(done=true)."),
|
||||
},
|
||||
"fix_missing_models": {
|
||||
"title": "Fix the missing models",
|
||||
"description": "Find what the open workflow lacks and put it back, asking before downloads.",
|
||||
"arguments": [],
|
||||
"text": ("Check the open workflow's models with check_workflow_models (call begin_task first). Put back the ones "
|
||||
"Anomalous found with certainty (fix_workflow_models). Show what is still missing with show_panel as a "
|
||||
"table, and ask me with choices before downloading anything. report(done=true) when finished."),
|
||||
},
|
||||
"explain_canvas": {
|
||||
"title": "Explain the open workflow",
|
||||
"description": "A picture of the open workflow's main chain with a short explanation.",
|
||||
"arguments": [],
|
||||
"text": ("Explain the workflow open in ComfyUI. Call begin_task, read it with describe_canvas, then show_panel "
|
||||
"with a diagram block of its main chain (loaders, prompts, sampler, decoding, saving; node_id on each "
|
||||
"box) and a few lines of text on what each part does and which settings matter most. Change nothing."),
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def list_prompts():
|
||||
return {"prompts": [{"name": name, "title": item["title"], "description": item["description"], "arguments": item["arguments"]}
|
||||
for name, item in PROMPTS.items()]}
|
||||
|
||||
|
||||
def get_prompt(name, arguments=None):
|
||||
"""prompts/get, or None for an unknown name or a missing required argument."""
|
||||
item = PROMPTS.get(name)
|
||||
arguments = arguments if isinstance(arguments, dict) else {}
|
||||
if not item or any(arg["required"] and not str(arguments.get(arg["name"], "")).strip() for arg in item["arguments"]):
|
||||
return None
|
||||
values = {"what": "", "count": "3", **{key: str(value) for key, value in arguments.items()}}
|
||||
return {"description": item["description"],
|
||||
"messages": [{"role": "user", "content": {"type": "text", "text": item["text"].format(**values)}}]}
|
||||
@@ -0,0 +1,315 @@
|
||||
"""MCP endpoint: AI apps (Claude, Cursor, Cherry Studio…) use Anomalous's library as tools.
|
||||
|
||||
POST /anomalous/mcp speaks the Model Context Protocol's Streamable HTTP transport, both eras:
|
||||
- modern (2026-07-28): stateless; every request carries its protocol version in `_meta` and
|
||||
the MCP-Protocol-Version / Mcp-Method / Mcp-Name headers, which must match the body;
|
||||
- legacy (2025-03-26 to 2025-11-25): an `initialize` handshake first. No session is kept
|
||||
(sessions are optional there), so both eras are served the same stateless way.
|
||||
Only this computer may connect: the peer must be loopback, no proxy header may be present,
|
||||
and Host and Origin (when sent) must name a loopback host, which stops DNS rebinding.
|
||||
Answers are always one JSON object; there are no server-initiated messages. The tools are
|
||||
in mcp_tools.py (reading), mcp_actions.py (acting) and mcp_task_tools.py (the AI workbench's
|
||||
begin_task and report); every call is kept as a step of a task (ai_tasks.py) for the AI
|
||||
workbench page, starting in state "running" and updated on completion, with unread user
|
||||
messages and panel answers attached to the next successful tool response, and pictures changed
|
||||
outside Anomalous since the AI's previous call shown and told (ai_outside.py). POST
|
||||
/anomalous/mcp/bridge is where the open ComfyUI page claims and answers canvas actions
|
||||
(mcp_bridge.py).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import base64
|
||||
import time
|
||||
import urllib.parse
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from . import ai_callers, ai_gates, ai_outside, ai_panels, ai_run_tracking, ai_task_canvas, ai_task_runs, ai_tasks, mcp_apps, mcp_bridge, mcp_directory, mcp_prompts
|
||||
from .local_guard import is_local as _is_local, loopback_host as _loopback_host
|
||||
from .mcp_actions import ACTIONS
|
||||
from .mcp_canvas_edit import CANVAS_TOOLS
|
||||
from .mcp_model_use import MODEL_TOOLS
|
||||
from .mcp_look import LOOK_TOOLS
|
||||
from .mcp_situation import SITUATION_TOOLS
|
||||
from .mcp_task_tools import TASK_TOOLS
|
||||
from .mcp_tools import TOOLS as READ_TOOLS, call_tool, retext
|
||||
from .mcp_arguments import prepare_arguments, renaming_note
|
||||
|
||||
TOOLS = {**READ_TOOLS, **MODEL_TOOLS, **LOOK_TOOLS, **ACTIONS, **CANVAS_TOOLS, **TASK_TOOLS, **SITUATION_TOOLS, **mcp_apps.APP_TOOLS}
|
||||
CAPABILITIES = {
|
||||
"tools": {"listChanged": False}, "prompts": {"listChanged": False}, "resources": {"listChanged": False},
|
||||
"extensions": {mcp_apps.EXTENSION: {"mimeTypes": [mcp_apps.MIME]}}, # the card in the conversation (mcp_apps.py)
|
||||
}
|
||||
|
||||
MODERN_VERSIONS = ("2026-07-28",)
|
||||
LEGACY_VERSIONS = ("2025-11-25", "2025-06-18", "2025-03-26")
|
||||
SERVER_INFO = {"name": "anomalous-model-browser", "title": "Anomalous Model Browser", "version": "1.0.0"}
|
||||
INSTRUCTIONS = (
|
||||
"Tools over the user's ComfyUI library as Anomalous Model Browser keeps it: model files with "
|
||||
"their Civitai information, output images with their generation settings, combos (a model, "
|
||||
"LoRAs and a prompt), workflow recipes, saved prompts, generated audio, the scan status and "
|
||||
"the activity log; and tools that act on the workflow open in ComfyUI (get_situation gives flow chains; "
|
||||
"describe_canvas only for details) or build one where the user watches: find_nodes searches brief types; "
|
||||
"add_node wires in the same call (wire_from/wire_to; wire_to=ID splices it in front of that node, "
|
||||
"insert_after=ID behind it); add_nodes adds a whole group in ComfyUI's API form in one call; "
|
||||
"connect_nodes needs only two IDs unless sockets are ambiguous. Reuse receipts instead of rereading "
|
||||
"the graph. new_workflow opens a tab only when needed. Tools also scan models or have an "
|
||||
"Anomalous TTS voice speak. Canvas changes "
|
||||
"are single Ctrl+Z steps and are logged as the AI's; nothing deletes files. Ids returned by "
|
||||
"one tool (model_id, image, node ids) are what the others take. For what no tool does, tell "
|
||||
"the user where in Anomalous to do it (the rail on the left: Models, Gallery, Workflows, "
|
||||
"Combos, Prompts, Voices). begin_task's answer carries a directory of the tools by what you want to do: "
|
||||
"look there and go straight to the tool. In a new chat on a task, or when unsure where things stand, call get_situation "
|
||||
"first: the task, the canvas in brief (what is still unwired) and the next step in one answer. "
|
||||
"The user watches your work in Anomalous's AI workbench: call begin_task "
|
||||
"with a short title when you start what they asked for (it continues the waiting or active task; "
|
||||
"new_task=true is only for a separate user request), and report to explain a choice, hand in "
|
||||
"pictures made another way, or end the task (done=true). The user can write to you or answer "
|
||||
"panel questions there: call get_answers to wait for or read them, and any unread user_messages "
|
||||
"or user_answers attached to a tool result must also be honoured. While you work on an Anomalous task, ask "
|
||||
"the user every question (a choice, a preference, yes or no) with ask_user, never in your own chat or its "
|
||||
"question form: the user watches and answers in Anomalous. Until they say the task is done, end every round "
|
||||
"with ask_user (what next, or whether to go ahead), not with a note or panel alone; only a run, download or "
|
||||
"scan going on lets you end your turn without asking. Likewise write your explanations and replies "
|
||||
"there with report (reply_to answers their message or marks), not only in your chat. Show plans, workflow explanations "
|
||||
"and results in chronological order with show_panel; update_panel appends new content below what "
|
||||
"the user already saw. Use run_workflow for execution: it returns real state/results after a bounded wait. "
|
||||
"If you submit through /prompt or another tool, immediately call track_run with YOUR returned prompt_ids "
|
||||
"and task ID, or the workbench cannot observe it. For running results use run_status(wait_seconds=55); "
|
||||
"do not inspect output directories or resubmit to find out whether it finished. Change pictures only by "
|
||||
"running workflows, never with code of your own; if you do use another tool (a command, a script, files), "
|
||||
"say what you ran with log_outside."
|
||||
)
|
||||
LIST_TTL_MS = 300000
|
||||
# Requests run tools in threads; a few at a time is plenty for one person's AI app.
|
||||
_slots = asyncio.Semaphore(4)
|
||||
|
||||
|
||||
PARSE_ERROR, INVALID_REQUEST, METHOD_NOT_FOUND, INVALID_PARAMS = -32700, -32600, -32601, -32602
|
||||
HEADER_MISMATCH, UNSUPPORTED_VERSION = -32020, -32022
|
||||
|
||||
|
||||
def _origin_ok(request):
|
||||
origin = request.headers.get("Origin")
|
||||
return origin is None or _loopback_host(urllib.parse.urlsplit(origin).hostname)
|
||||
|
||||
|
||||
def _decode_header(value):
|
||||
"""Mcp-Name values outside plain ASCII come as =?base64?…?=."""
|
||||
if value and value.startswith("=?base64?") and value.endswith("?="):
|
||||
try:
|
||||
return base64.b64decode(value[9:-2], validate=True).decode("utf-8")
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
return None
|
||||
return value
|
||||
|
||||
|
||||
def _error(id_, code, message, status=200, data=None):
|
||||
error = {"code": code, "message": message}
|
||||
if data is not None:
|
||||
error["data"] = data
|
||||
body = {"jsonrpc": "2.0", "error": error}
|
||||
if id_ is not None:
|
||||
body["id"] = id_
|
||||
return web.json_response(body, status=status)
|
||||
|
||||
|
||||
def _result(id_, result, modern):
|
||||
if modern:
|
||||
result = {"resultType": "complete", **result}
|
||||
return web.json_response({"jsonrpc": "2.0", "id": id_, "result": result})
|
||||
|
||||
|
||||
def _tools():
|
||||
"""The tool list AI apps are offered, as tools/list gives it."""
|
||||
return [mcp_apps.with_card(tool["spec"]) for tool in TOOLS.values()]
|
||||
|
||||
|
||||
def _tool_list(modern):
|
||||
result = {"tools": _tools()}
|
||||
if modern:
|
||||
result.update(ttlMs=LIST_TTL_MS, cacheScope="public")
|
||||
return result
|
||||
|
||||
|
||||
def _initialize(params):
|
||||
requested = params.get("protocolVersion")
|
||||
return {
|
||||
"protocolVersion": requested if requested in LEGACY_VERSIONS else LEGACY_VERSIONS[0],
|
||||
"capabilities": CAPABILITIES,
|
||||
"serverInfo": SERVER_INFO,
|
||||
"instructions": INSTRUCTIONS,
|
||||
}
|
||||
|
||||
|
||||
def _discover():
|
||||
return {
|
||||
"supportedVersions": list(MODERN_VERSIONS + LEGACY_VERSIONS),
|
||||
"capabilities": CAPABILITIES,
|
||||
"_meta": {"io.modelcontextprotocol/serverInfo": SERVER_INFO},
|
||||
"instructions": INSTRUCTIONS,
|
||||
"ttlMs": LIST_TTL_MS,
|
||||
"cacheScope": "public",
|
||||
}
|
||||
|
||||
|
||||
def _modern_header_problem(request, method, params, version):
|
||||
"""Why the mirrored headers do not match the body (2026-07-28), or None."""
|
||||
if request.headers.get("MCP-Protocol-Version") != version:
|
||||
return "MCP-Protocol-Version header missing or not the body's protocol version"
|
||||
if request.headers.get("Mcp-Method") != method:
|
||||
return "Mcp-Method header missing or not the body's method"
|
||||
if method in ("tools/call", "prompts/get", "resources/read"):
|
||||
name = params.get("uri") if method == "resources/read" else params.get("name")
|
||||
if _decode_header(request.headers.get("Mcp-Name")) != name:
|
||||
return "Mcp-Name header missing or not the body's name"
|
||||
return None
|
||||
|
||||
|
||||
async def _call(params, request):
|
||||
name = params.get("name")
|
||||
raw_arguments = params.get("arguments") or {}
|
||||
if not isinstance(name, str) or name not in TOOLS or not isinstance(raw_arguments, dict):
|
||||
return None
|
||||
arguments = dict(raw_arguments)
|
||||
client = ai_callers.client_of(request.headers, params)
|
||||
session = ai_callers.session_of(request.headers, params)
|
||||
task_id = ai_callers.task_of(request.headers, params, arguments)
|
||||
if "task" in arguments and "task" not in TOOLS[name]["spec"]["inputSchema"].get("properties", {}):
|
||||
arguments.pop("task", None)
|
||||
arguments, renamed = prepare_arguments(TOOLS[name]["spec"]["inputSchema"], arguments)
|
||||
ctx = {"base_url": f"{request.scheme}://{request.host}", "client": client, "session": session, "task": task_id} # loopback, checked in api_mcp
|
||||
started = time.time()
|
||||
read_only = bool(TOOLS[name]["spec"].get("annotations", {}).get("readOnlyHint", True))
|
||||
step_ref = await asyncio.to_thread(
|
||||
ai_tasks.begin_step, client, name, arguments, started, read_only, session=session, task_id=task_id,
|
||||
)
|
||||
active_task = step_ref[0] if step_ref else task_id
|
||||
if active_task:
|
||||
ctx["task"] = active_task
|
||||
outside = None
|
||||
if name not in mcp_apps.APP_TOOLS: # the card's own calls do not reach the AI
|
||||
outside = await asyncio.to_thread(ai_outside.check, active_task or ai_tasks.active_task_id(client, session))
|
||||
canvas_call = ai_task_canvas.begin_call(active_task) # the page works on the task's own tab
|
||||
try:
|
||||
# The user's gate first (ai_gates.py): it may wait for their OK, or answer for them.
|
||||
result = await asyncio.to_thread(ai_gates.check, name, arguments, step_ref)
|
||||
if result is None:
|
||||
async with _slots:
|
||||
result = await asyncio.to_thread(call_tool, TOOLS, name, arguments, ctx)
|
||||
except BaseException as error:
|
||||
failed_result = {"content": [{"type": "text", "text": f"{name} failed: {error}"}], "isError": True}
|
||||
await asyncio.to_thread(
|
||||
ai_tasks.finish_step, client, name, arguments, failed_result, started, read_only,
|
||||
step_ref=step_ref, session=session, task_id=active_task,
|
||||
)
|
||||
raise
|
||||
if renamed and not result.get("isError") and isinstance(result.get("structuredContent"), dict):
|
||||
retext(result, {**result["structuredContent"], "arguments_note": renaming_note(name, renamed)})
|
||||
step = await asyncio.to_thread(
|
||||
ai_tasks.finish_step, client, name, arguments, result, started, read_only,
|
||||
step_ref=step_ref, session=session, task_id=active_task,
|
||||
)
|
||||
ai_task_canvas.tell(result, canvas_call)
|
||||
if name == "run_workflow" and step and step.get("state") == "running":
|
||||
ai_task_runs.watch(step["id"], result.get("structuredContent") or {})
|
||||
await asyncio.to_thread(ai_run_tracking.wait_for_receipt, result, client, session, active_task,
|
||||
ai_run_tracking.checked_wait(arguments.get("wait_seconds", 55)), step["id"])
|
||||
# The user's news and the run's go to the AI, never to the card's own calls (they do not reach the AI).
|
||||
if name not in mcp_apps.APP_TOOLS and isinstance(result, dict) and not result.get("isError"):
|
||||
resolved_task = active_task or await asyncio.to_thread(ai_tasks.active_task_id, client, session=session)
|
||||
if name not in ("run_workflow", "run_status", "stop_run") and resolved_task:
|
||||
await asyncio.to_thread(ai_task_runs.tell, result, resolved_task)
|
||||
await asyncio.to_thread(ai_task_runs.show_pictures, result, resolved_task)
|
||||
if name != "get_answers" and name not in mcp_apps.APP_TOOLS and isinstance(result, dict) and not result.get("isError"):
|
||||
await asyncio.to_thread(ai_panels.attach_pending, result, client, task_id=resolved_task or ("" if session else None))
|
||||
mcp_directory.attach(result, name, {key: tool["spec"] for key, tool in TOOLS.items() if key not in mcp_apps.APP_TOOLS})
|
||||
if name not in mcp_apps.APP_TOOLS and mcp_directory.stale(client, _tools()):
|
||||
await asyncio.to_thread(mcp_directory.tell_stale, result, active_task)
|
||||
return ai_outside.tell(result, outside)
|
||||
|
||||
|
||||
async def api_mcp(request):
|
||||
"""POST /anomalous/mcp - one JSON-RPC request or notification per POST."""
|
||||
if request.method != "POST":
|
||||
return web.Response(status=405, headers={"Allow": "POST"})
|
||||
if not _is_local(request) or not _origin_ok(request):
|
||||
return _error(None, INVALID_REQUEST, "Only this computer may use the Anomalous MCP endpoint.", status=403)
|
||||
try:
|
||||
body = await request.json()
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
return _error(None, PARSE_ERROR, "Body is not JSON", status=400)
|
||||
if not isinstance(body, dict) or body.get("jsonrpc") != "2.0" or not isinstance(body.get("method"), str):
|
||||
return _error(None, INVALID_REQUEST, "Expected one JSON-RPC 2.0 request (batches are not supported)", status=400)
|
||||
if "id" not in body:
|
||||
return web.Response(status=202) # notifications (initialized, cancelled) need no answer
|
||||
id_, method = body["id"], body["method"]
|
||||
params = body.get("params") if isinstance(body.get("params"), dict) else {}
|
||||
|
||||
if method == "initialize":
|
||||
return _result(id_, _initialize(params), modern=False)
|
||||
meta = params.get("_meta") if isinstance(params.get("_meta"), dict) else {}
|
||||
version = meta.get("io.modelcontextprotocol/protocolVersion")
|
||||
modern = version is not None
|
||||
if modern:
|
||||
if version not in MODERN_VERSIONS:
|
||||
return _error(id_, UNSUPPORTED_VERSION, "Unsupported protocol version", status=400,
|
||||
data={"supported": list(MODERN_VERSIONS + LEGACY_VERSIONS), "requested": version})
|
||||
problem = _modern_header_problem(request, method, params, version)
|
||||
if problem:
|
||||
return _error(id_, HEADER_MISMATCH, f"Header mismatch: {problem}", status=400)
|
||||
else:
|
||||
header = request.headers.get("MCP-Protocol-Version")
|
||||
if header is not None and header not in LEGACY_VERSIONS:
|
||||
return _error(id_, INVALID_REQUEST, f"Unsupported protocol version {header}", status=400,
|
||||
data={"supported": list(MODERN_VERSIONS + LEGACY_VERSIONS), "requested": header})
|
||||
|
||||
if method == "server/discover" and modern:
|
||||
return _result(id_, _discover(), modern)
|
||||
if method == "ping":
|
||||
return _result(id_, {}, modern)
|
||||
if method == "tools/list":
|
||||
listing = _tool_list(modern)
|
||||
await asyncio.to_thread(mcp_directory.listed, ai_callers.client_of(request.headers, params), listing["tools"])
|
||||
return _result(id_, listing, modern)
|
||||
if method == "prompts/list":
|
||||
return _result(id_, mcp_prompts.list_prompts(), modern)
|
||||
if method == "prompts/get":
|
||||
prompt = mcp_prompts.get_prompt(params.get("name"), params.get("arguments"))
|
||||
if prompt is None:
|
||||
return _error(id_, INVALID_PARAMS, f"Unknown prompt or missing arguments: {params.get('name')}")
|
||||
return _result(id_, prompt, modern)
|
||||
if method == "resources/list":
|
||||
return _result(id_, {"resources": mcp_apps.resources()}, modern)
|
||||
if method == "resources/read":
|
||||
resource = await asyncio.to_thread(mcp_apps.read, params.get("uri"))
|
||||
if resource is None:
|
||||
return _error(id_, INVALID_PARAMS, f"Unknown resource: {params.get('uri')}")
|
||||
return _result(id_, resource, modern)
|
||||
if method == "tools/call":
|
||||
result = await _call(params, request)
|
||||
if result is None:
|
||||
return _error(id_, INVALID_PARAMS, f"Unknown tool or bad arguments: {params.get('name')}")
|
||||
return _result(id_, result, modern)
|
||||
return _error(id_, METHOD_NOT_FOUND, f"Method not found: {method}", status=404 if modern else 200)
|
||||
|
||||
|
||||
async def api_mcp_bridge(request):
|
||||
"""POST /anomalous/mcp/bridge - the open page claims a canvas action ({id, claim: true} ->
|
||||
{granted}) and then answers it ({id, outcome: {ok, value} | {ok: false, error}})."""
|
||||
if not _is_local(request) or not _origin_ok(request):
|
||||
return web.json_response({"error": "This computer only"}, status=403)
|
||||
try:
|
||||
body = await request.json()
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
body = None
|
||||
if not isinstance(body, dict) or not isinstance(body.get("id"), str):
|
||||
return web.json_response({"error": "Expected {id, claim} or {id, outcome}"}, status=400)
|
||||
if body.get("claim") is True:
|
||||
return web.json_response({"granted": mcp_bridge.claim(body["id"], body.get("capabilities"))})
|
||||
return web.json_response({"accepted": mcp_bridge.resolve(body["id"], body.get("outcome"))})
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
app.router.add_route("*", "/anomalous/mcp", api_mcp)
|
||||
app.router.add_post("/anomalous/mcp/bridge", api_mcp_bridge)
|
||||
@@ -0,0 +1,98 @@
|
||||
"""get_situation: where an AI's task stands, in one answer small enough to stay in its chat.
|
||||
|
||||
The task (what the user asked last, questions and gates still waiting for them, decisions so
|
||||
far, pictures made, steps done outside Anomalous), the canvas in brief (web/modules/
|
||||
mcp_canvas_brief.js: flow chains, brief node lines, missing inputs and outputs that fit,
|
||||
ComfyUI's errors), the latest run, and the one thing to do next. For an AI starting a new chat
|
||||
on a task or unsure where it is: a small model reads this instead of describe_canvas, find_nodes
|
||||
and the task's history. Unread messages of the user's come with it as with every answer
|
||||
(ai_panels.attach_pending).
|
||||
"""
|
||||
|
||||
from . import ai_decisions, ai_task_runs, ai_tasks
|
||||
from .mcp_bridge import PageRefused, PageUnavailable, ask_page
|
||||
from .mcp_tools import _schema, tool_text
|
||||
|
||||
BUDGET = 3600 # characters: Antigravity files away an answer past about 4,000 and has the AI open it
|
||||
MAX_TEXT = 200
|
||||
|
||||
|
||||
def _last_asked(task):
|
||||
"""The user's latest words or marks in the task, in short."""
|
||||
for step in reversed(task.get("steps") or []):
|
||||
if step.get("kind") == "user" and step.get("tool") in ("user_message", "user_marks", "user_pictures"):
|
||||
return {"what": step["tool"].removeprefix("user_"), "text": str(step.get("text") or "")[:MAX_TEXT], "id": step["id"]}
|
||||
return None
|
||||
|
||||
|
||||
def _canvas():
|
||||
try:
|
||||
return ask_page("describe_canvas", {"brief": True}, timeout=15)
|
||||
except PageUnavailable as error:
|
||||
return {"unavailable": str(error)}
|
||||
except PageRefused as error: # no workflow open, or the task's tab cannot be opened
|
||||
return {"unavailable": str(error)}
|
||||
|
||||
|
||||
def _next(summary, run, canvas):
|
||||
if summary["asks"]:
|
||||
return f"{summary['asks']} question(s) or gate(s) wait for the user: get_answers waits for their answer."
|
||||
if run.get("state") in ("queued", "running", "asking", "allowed"):
|
||||
return "A run is going: run_status(wait_seconds=55) waits for it; do not run again."
|
||||
if any("not in list" in str(item.get("error")) for item in canvas.get("errors") or ()):
|
||||
return ("A model or file the workflow names is not on this computer: check_workflow_models says which and what "
|
||||
"can stand in (fix_workflow_models, download_missing_models); do not guess other choices.")
|
||||
if canvas.get("errors"):
|
||||
return "ComfyUI refused the last run: fix the nodes in canvas.errors (set_values, connect_nodes), then run_workflow."
|
||||
if canvas.get("unwired"):
|
||||
return "Wire canvas.unwired with connect_nodes (fits lists outputs that fit each), then run_workflow."
|
||||
if run.get("state") == "done" and run.get("pictures"):
|
||||
return "Look at the run's pictures (zoom_image) and tell the user with report what came out."
|
||||
return "Go on with what the user asked (task.asked); run_workflow runs the canvas, report tells the user."
|
||||
|
||||
|
||||
def get_situation(ctx, task=None):
|
||||
client, session = ctx.get("client") or "AI", ctx.get("session") or ""
|
||||
task_id = ai_tasks.active_task_id(client, session, task or ctx.get("task"))
|
||||
record = ai_tasks.get_task(task_id) if task_id else None
|
||||
run = {"state": "none"}
|
||||
answer = {}
|
||||
if record:
|
||||
summary = ai_tasks.task_summary(record)
|
||||
pictures = [item["filename"] for step in record.get("steps") or [] for item in step.get("results") or [] if item.get("type") == "image"]
|
||||
answer["task"] = {"id": record["id"], "title": record.get("title") or "", "steps": summary["steps"],
|
||||
"asked": _last_asked(record), "waiting_for_user": summary["asks"],
|
||||
"decisions": ai_decisions.lines(record, limit=4), "pictures": pictures[-3:],
|
||||
"outside_anomalous": summary["kinds"].get("outside", 0)}
|
||||
status = ai_task_runs.status(client, session, task_id)
|
||||
run = {key: status[key] for key in ("state", "summary", "pictures") if status.get(key)}
|
||||
else:
|
||||
summary = {"asks": 0}
|
||||
answer["task"] = None
|
||||
answer["task_note"] = "No task yet: begin_task names what the user asked for."
|
||||
canvas = _canvas()
|
||||
answer.update(run=run, canvas=canvas)
|
||||
answer["next"] = _next(summary, run, canvas)
|
||||
# Trim detail before chains and decisions; preserve actionable missing inputs and errors.
|
||||
while len(tool_text(answer)) > BUDGET and canvas.get("lines"):
|
||||
canvas["lines"].pop()
|
||||
canvas["more_nodes"] = canvas.get("more_nodes", 0) + 1
|
||||
while len(tool_text(answer)) > BUDGET and canvas.get("chains"):
|
||||
canvas["chains"].pop()
|
||||
canvas["more_chains"] = canvas.get("more_chains", 0) + 1
|
||||
while len(tool_text(answer)) > BUDGET and record and answer["task"]["decisions"]:
|
||||
answer["task"]["decisions"].pop(0)
|
||||
return answer
|
||||
|
||||
|
||||
SITUATION_TOOLS = {
|
||||
"get_situation": {"run": get_situation, "context": True, "spec": {
|
||||
"name": "get_situation", "title": "Where things stand",
|
||||
"description": "The whole picture in one call: the task (what the user asked last, what waits for them, decisions, "
|
||||
"pictures), the canvas in brief (flow chains, inputs nothing feeds and what fits them, errors), the "
|
||||
"latest run, and next: the one thing to do now. Call it first in a new chat, and whenever unsure.",
|
||||
"inputSchema": _schema({"task": {"type": "string", "description": "begin_task's id (optional)."}}),
|
||||
"annotations": {"title": "Where things stand", "readOnlyHint": True, "destructiveHint": False,
|
||||
"idempotentHint": True, "openWorldHint": False},
|
||||
}},
|
||||
}
|
||||
@@ -0,0 +1,423 @@
|
||||
"""MCP tools that shape the AI workbench's record (ai_tasks.py): begin_task names a piece of
|
||||
work, report leaves a note for the user (with pictures made outside Anomalous's tools),
|
||||
show_panel / update_panel draw a panel from Anomalous's blocks (ai_panels.py), get_answers
|
||||
reads what the user picked or typed on it, log_outside keeps what the AI did with other tools
|
||||
(ai_outside.py)."""
|
||||
|
||||
from . import ai_answer_wait, ai_decisions, ai_marks, ai_message_refs, ai_outside, ai_panels, ai_repaint, ai_run_control, ai_run_tracking, ai_task_links, ai_task_runs, ai_tasks, ai_toolbox
|
||||
from .mcp_tools import MAX_LIMIT, ToolError, _schema
|
||||
|
||||
PACK_TYPES = 150 # node types listed per picked pack
|
||||
ASK_WAIT_MIN = 30 # ask_user waits this long even when told not to: the user, reading the work, often answers at once
|
||||
ASK_NEXT = ("Before you end your turn, ask_user what to do next or whether to go ahead: a note or a panel alone leaves "
|
||||
"the user waiting. Only a run, a download or a scan going on lets you end it without asking.")
|
||||
|
||||
|
||||
def begin_task(ctx, title, new_task=False):
|
||||
title = str(title or "").strip()
|
||||
if not title:
|
||||
raise ToolError("title is empty: a few words on what the user asked for.")
|
||||
task = ai_tasks.begin_task(
|
||||
ctx.get("client") or "AI", title, new_task=bool(new_task),
|
||||
session=ctx.get("session") or "", task_id=ctx.get("task"),
|
||||
)
|
||||
answer = {"task": task["id"], "title": task["title"], "note": (
|
||||
"Continue this task; do not begin another for its steps. Every AMB call is a step the user sees, opens and "
|
||||
"undoes in Anomalous's AI workbench. Ask them with ask_user (they answer there, not in your chat); report "
|
||||
"explains a choice or hands in pictures, done=true at the end. Run with run_workflow; a run queued another "
|
||||
"way needs track_run(prompt_ids) with your own IDs. In the task's own tab, do not switch tabs yourself. "
|
||||
"Everything is in AMB's tools (models, pictures, node types, the canvas, runs and their previews): do not "
|
||||
"read ComfyUI's folders or source, run preprocessors or call its routes yourself. Change pictures only by "
|
||||
"running workflows, never by editing files with code. If you use another tool anyway, log_outside right "
|
||||
"after. Unsure where things stand: get_situation. The directory below lists the tools by what you want to do.")}
|
||||
answer["next"] = ("get_situation shows where things stand; a daily run is one call: run_workflow(workflow: a saved "
|
||||
"one, with the prompt, seed or size to change).")
|
||||
box = ai_toolbox.effective(ai_tasks.get_task(task["id"]))
|
||||
if box:
|
||||
answer["toolbox"] = ai_toolbox.words(box)
|
||||
goes_on = ai_task_links.carried(task)
|
||||
if goes_on:
|
||||
answer["continues"] = goes_on # the task this one goes on from, and what was decided there
|
||||
decided = ai_decisions.lines(ai_tasks.get_task(task["id"]))
|
||||
if decided:
|
||||
answer["decisions"] = decided # what was settled so far, the user's own choices in Anomalous too
|
||||
if task.get("about"):
|
||||
# Handed over from a model page, an image or a combo in Anomalous: the ids the tools take.
|
||||
answer["about"] = task["about"]
|
||||
answer["about_note"] = ("The user started this task from these in Anomalous; work with them: model_id goes to "
|
||||
"set_model / add_lora / get_model, image to get_image_info, a combo's name to place_combo, "
|
||||
"a workflow's name to open_workflow.")
|
||||
return answer
|
||||
|
||||
|
||||
def report(ctx, text="", images=None, done=False, reply_to=None, task=None):
|
||||
try:
|
||||
step, missing = ai_tasks.report(
|
||||
ctx.get("client") or "AI", text, images or [], bool(done),
|
||||
session=ctx.get("session") or "", task_id=task or ctx.get("task"), reply_to=reply_to,
|
||||
)
|
||||
except ValueError as error:
|
||||
raise ToolError(str(error))
|
||||
answer = {"noted": True, "pictures": len(step["results"])}
|
||||
if not done:
|
||||
answer["next"] = ASK_NEXT
|
||||
if any(mark in str(text or "") for mark in ("?", "？")):
|
||||
answer["next"] = "Your note asks the user something: ask it with ask_user (options to press) instead. " + ASK_NEXT
|
||||
if missing:
|
||||
answer["not_found"] = missing
|
||||
answer["note"] = "Pictures are paths inside ComfyUI's output folder (subfolder/name.png), as search_images gives them."
|
||||
return answer
|
||||
|
||||
|
||||
def log_outside(ctx, what, why="", files=None, task=None):
|
||||
try:
|
||||
step = ai_outside.log(ctx.get("client") or "AI", what, why, files, session=ctx.get("session") or "",
|
||||
task_id=task or ctx.get("task"))
|
||||
except ValueError as error:
|
||||
raise ToolError(str(error))
|
||||
return {"logged": True, "step": step["id"]}
|
||||
|
||||
|
||||
def log_decision(ctx, title, decision, reason="", rejected=None, by="user", related=None, task=None):
|
||||
try:
|
||||
step = ai_decisions.log(ctx.get("client") or "AI", title, decision, reason, rejected, by, related,
|
||||
session=ctx.get("session") or "", task_id=task or ctx.get("task"))
|
||||
except ValueError as error:
|
||||
raise ToolError(str(error))
|
||||
return {"recorded": True, "step": step["id"], "related": step["decision"]["related"]}
|
||||
|
||||
|
||||
def show_panel(ctx, title, blocks, task=None):
|
||||
try:
|
||||
panel = ai_panels.show(
|
||||
ctx.get("client") or "AI", title, blocks,
|
||||
session=ctx.get("session") or "", task_id=task or ctx.get("task"),
|
||||
)
|
||||
except ai_panels.PanelError as error:
|
||||
raise ToolError(str(error))
|
||||
asks = [block["id"] for block in panel["blocks"] if block["type"] in ai_panels.INTERACTIVE]
|
||||
answer = {"panel": panel["id"], "shown": True,
|
||||
"blocks": [{"id": block["id"], "type": block["type"]} for block in panel["blocks"]]}
|
||||
if asks:
|
||||
answer["questions"] = asks
|
||||
answer["note"] = ("The user answers in Anomalous when they get to it; call get_answers with this panel id "
|
||||
"(wait_seconds up to 55 waits for it) before going on with what depends on it.")
|
||||
else:
|
||||
answer["next"] = ASK_NEXT
|
||||
return answer
|
||||
|
||||
|
||||
def ask_user(ctx, question, options=None, multiple=False, other=True, wait_seconds=ai_panels.MAX_WAIT, task=None):
|
||||
"""A question in the AI workbench, where the user watches the work: options to press (one may be
|
||||
recommended), a line of their own; waits for the answer."""
|
||||
block = ({"type": "choices", "id": "answer", "options": options, "multiple": bool(multiple), "other": bool(other)}
|
||||
if options else {"type": "input", "id": "answer", "question": str(question or "")[:200]})
|
||||
try:
|
||||
panel = ai_panels.show(ctx.get("client") or "AI", question, [block], session=ctx.get("session") or "",
|
||||
task_id=task or ctx.get("task"), tool="ask_user")
|
||||
except ai_panels.PanelError as error:
|
||||
raise ToolError(str(error))
|
||||
return _answer_of(ctx, panel["id"], wait_seconds)
|
||||
|
||||
|
||||
def propose_repaint_area(ctx, title, marks, areas=None, grow=12, feather=8, note="", wait_seconds=ai_panels.MAX_WAIT):
|
||||
"""The area to repaint for the user's marks, theirs beside the AI's for them to pick (ai_repaint.py); waits like ask_user."""
|
||||
try:
|
||||
panel = ai_repaint.propose(ctx.get("client") or "AI", title, str(marks or ""), areas, grow, feather,
|
||||
str(note or "")[:400], session=ctx.get("session") or "")
|
||||
except ai_repaint.RepaintError as error:
|
||||
raise ToolError(str(error))
|
||||
return _answer_of(ctx, panel["id"], wait_seconds)
|
||||
|
||||
|
||||
def _answer_of(ctx, panel_id, wait_seconds):
|
||||
"""The answer to the question of panel `panel_id` once the user gives it, waiting at least ASK_WAIT_MIN."""
|
||||
client = ctx.get("client") or "AI"
|
||||
try:
|
||||
answer = ai_answer_wait.collect(client, panel_id, max(ASK_WAIT_MIN, float(wait_seconds or 0)))
|
||||
given = next((item for item in answer["answers"] if item["question"] == "answer"), None)
|
||||
if not given:
|
||||
if answer.get("messages") and answer.get("still_waiting"):
|
||||
# Read the user's new instruction before considering an automatic choice.
|
||||
answer.update(ai_answer_wait.wait_on(panel_id, allow_recommended=False))
|
||||
return {"answered": False, "panel": panel_id, **answer}
|
||||
except ai_panels.PanelError as error:
|
||||
raise ToolError(str(error))
|
||||
out = {"answered": True, "panel": panel_id, "next": "Go on with the user's answer; log_decision it when it settles a choice."}
|
||||
if answer.get("messages"):
|
||||
out["messages"] = answer["messages"]
|
||||
if given.get("inpaint_image"):
|
||||
out.update(inpaint_image=given["inpaint_image"], inpaint_note=given["note"])
|
||||
elif given.get("note"):
|
||||
out["next"] = given["note"]
|
||||
if given.get("skipped"):
|
||||
out.update(skipped=True, note="The user left this to you: decide it yourself, log_decision what you chose and "
|
||||
"go on. Do not ask the same again.")
|
||||
elif given.get("text"):
|
||||
out["text"] = given["text"]
|
||||
if given.get("choice") == ["other"]:
|
||||
out["note"] = "None of your options: the user wrote their own answer."
|
||||
else:
|
||||
out.update(choice=given.get("choice"), labels=given.get("labels"))
|
||||
if given.get("recommended_on_timeout"):
|
||||
out.update(recommended_on_timeout=True, next=ai_answer_wait.TOOK)
|
||||
return out
|
||||
|
||||
|
||||
def update_panel(ctx, panel, title=None, blocks=None, closed=None, task=None):
|
||||
del ctx, task
|
||||
try:
|
||||
updated = ai_panels.update(panel, title, blocks, closed)
|
||||
except ai_panels.PanelError as error:
|
||||
raise ToolError(str(error))
|
||||
return {"updated": True, "blocks": [{"id": block.get("id"), "type": block["type"]}
|
||||
for block in updated["blocks"]]}
|
||||
|
||||
|
||||
def run_status(ctx, wait_seconds=0, task=None):
|
||||
try:
|
||||
return ai_task_runs.status(ctx.get("client") or "AI", ctx.get("session") or "", task or ctx.get("task"), wait_seconds)
|
||||
except ValueError as error:
|
||||
raise ToolError(str(error))
|
||||
|
||||
|
||||
def show_run_map(ctx, title, run=None, task=None):
|
||||
client, session = ctx.get("client") or "AI", ctx.get("session") or ""
|
||||
task_id = ai_tasks.active_task_id(client, session, task or ctx.get("task"))
|
||||
runs = [step for step in (ai_tasks.get_task(task_id) or {}).get("steps", []) if step.get("tool") == "run_workflow"] if task_id else []
|
||||
found = next((step for step in reversed(runs) if step.get("map") and (not run or step["id"] == run)), None)
|
||||
if not found:
|
||||
raise ToolError("No run of this task has its shape yet: it is read once ComfyUI has queued the run (run_workflow).")
|
||||
try:
|
||||
panel = ai_panels.show(client, title, [{"type": "run_map", "step": found["id"]}], session=session, task_id=task_id,
|
||||
tool="show_run_map")
|
||||
except ai_panels.PanelError as error:
|
||||
raise ToolError(str(error))
|
||||
boxes = found["map"]["boxes"]
|
||||
return {"panel": panel["id"], "shown": True, "run": found["id"], "changes": found.get("changes") or [],
|
||||
"boxes": [{"node_id": box["id"], "title": box["title"], "role": box["role"]} for box in boxes]}
|
||||
|
||||
|
||||
def stop_run(ctx, task=None):
|
||||
client, session = ctx.get("client") or "AI", ctx.get("session") or ""
|
||||
task_id = ai_tasks.active_task_id(client, session, task or ctx.get("task"))
|
||||
run = next((step for step in reversed((ai_tasks.get_task(task_id) or {}).get("steps", []))
|
||||
if step.get("tool") == "run_workflow"), None) if task_id else None
|
||||
if not run:
|
||||
raise ToolError("No run in this task yet.")
|
||||
try:
|
||||
done = ai_run_control.stop(run["id"], by="ai", task_id=task_id)
|
||||
except ai_run_control.RunControlError as error:
|
||||
raise ToolError(str(error))
|
||||
return {**done, "stopped": True, "note": "Stopping: run_status(wait_seconds=10) confirms it ended."}
|
||||
|
||||
|
||||
def get_toolbox(ctx, task=None):
|
||||
from .mcp_canvas_edit import find_nodes
|
||||
|
||||
task_id = task or ctx.get("task") or ai_tasks.active_task_id(ctx.get("client") or "AI", ctx.get("session") or "")
|
||||
box = ai_toolbox.effective(ai_tasks.get_task(task_id)) if task_id else None
|
||||
if not box:
|
||||
return {"picked": False, "note": "The user picked nothing for this task; use what fits."}
|
||||
answer = {"picked": True, "mode": box["mode"], "note": ai_toolbox.words(box)}
|
||||
if box.get("nodes"):
|
||||
found = find_nodes(ctx, types=box["nodes"])
|
||||
answer["nodes"] = found["nodes"]
|
||||
if found.get("not_found"):
|
||||
answer["page_only_nodes"] = found["not_found"] # helpers that live only in the page: add_node takes them
|
||||
if box.get("packs"):
|
||||
from .mcp_canvas_edit import object_info
|
||||
|
||||
info = object_info(ctx)
|
||||
answer["packs"] = []
|
||||
for pack in box["packs"]:
|
||||
types = sorted(name for name, item in info.items() if ai_toolbox.source_of(item) == pack)
|
||||
answer["packs"].append({"pack": pack, "count": len(types), "node_types": [
|
||||
{"type": name, "display_name": info[name].get("display_name") or name, "category": info[name].get("category") or ""}
|
||||
for name in types[:PACK_TYPES]]})
|
||||
answer["packs_note"] = "Every node type of a pack is the user's pick; find_nodes(types=[...]) gives one in full."
|
||||
for kind in ("combos", "workflows", "prompts"):
|
||||
if box.get(kind):
|
||||
answer[kind] = [found for name in box[kind] if (found := ai_message_refs.lookup(kind, name)) is not None]
|
||||
if box.get("models"):
|
||||
answer["models"] = [ai_message_refs.lookup("models", model_id) or {"model_id": model_id, "missing": True} for model_id in box["models"]]
|
||||
return answer
|
||||
|
||||
|
||||
def get_answers(ctx, panel=None, wait_seconds=0, task=None):
|
||||
try:
|
||||
client = ctx.get("client") or "AI"
|
||||
task_id = task or ctx.get("task") or None
|
||||
if not task_id and ctx.get("session"):
|
||||
task_id = ai_tasks.active_task_id(client, ctx["session"]) or ""
|
||||
answer = ai_answer_wait.collect(client, panel, wait_seconds, task_id=task_id)
|
||||
return answer, ai_marks.image_items(answer.get("messages") or []) # marked pictures, as pictures
|
||||
except ai_panels.PanelError as error:
|
||||
raise ToolError(str(error))
|
||||
|
||||
|
||||
BLOCKS_HELP = (
|
||||
"blocks, top to bottom, each {type, ...}: heading {text}; text {text, tone: normal|muted|tip|warning}; "
|
||||
"images {items: [{image: 'subfolder/name.png' from search_images, caption, marks: [{x, y, r | w, h, label, "
|
||||
"color: red|green|blue|yellow|purple}]}], layout: row|grid|compare} (marks: circles or boxes with a label, x/y/w/h/r "
|
||||
"as fractions 0-1 of the picture, x/y the centre; a click on the label zooms there); "
|
||||
"slider {before: {image}, after: {image}, before_label, after_label} (one picture over the other, a line to drag); "
|
||||
"picks {id, question, items: [{id, image, label, reason, recommended}] (2-12), multiple} (pictures to choose from, "
|
||||
"each with 'take this one'; the user can also put a picture's workflow back on the canvas); "
|
||||
"diagram {nodes: [{id, label, detail, node_id, color}], edges: [{from, to, label}], direction: right|down} (boxes and "
|
||||
"arrows Anomalous lays out; node_id from describe_canvas makes a box find that node); "
|
||||
"models {items: [{model_id from search_models, note}]} (cards with their covers, a click opens them); "
|
||||
"table {columns: [...], rows: [[...]]}; list {items: [...], ordered}; params {items: [{label, value}]}; "
|
||||
"choices {id, question, options: [{id, label, detail}] (2-8), multiple} (buttons the user presses); "
|
||||
"input {id, question, placeholder} (a line the user types); progress {label, value, max} (your own "
|
||||
"numbers: they never move by themselves, so keep them current with update_panel; a run's real progress shows "
|
||||
"in the workbench already, draw none for it); divider {}. "
|
||||
"Each block may have a stable id; the tool returns block ids in display order. "
|
||||
"Plain text only (no markup, no links); up to 30 blocks, 12 pictures or models a block."
|
||||
)
|
||||
|
||||
_TASK_PROP = {"type": "string", "description": "begin_task's id (optional)."}
|
||||
|
||||
|
||||
def _task_tool(name, title, description, run, properties, required=()):
|
||||
return name, {"run": run, "context": True, "spec": {
|
||||
"name": name, "title": title, "description": description,
|
||||
"inputSchema": _schema(properties, required),
|
||||
"annotations": {"title": title, "readOnlyHint": name in ("run_status", "get_toolbox"), "destructiveHint": False,
|
||||
"idempotentHint": False, "openWorldHint": False},
|
||||
}}
|
||||
|
||||
|
||||
def _question_with_images(run):
|
||||
"""The question receipt also carries pictures the user sent while it was waiting."""
|
||||
def call(ctx, **arguments):
|
||||
result = run(ctx, **arguments)
|
||||
return result, ai_marks.image_items(result.get("messages") or [])
|
||||
return call
|
||||
|
||||
|
||||
TASK_TOOLS = dict([
|
||||
_task_tool("track_run", "Track an externally submitted run",
|
||||
"Immediately after YOU submit to this ComfyUI server via /prompt or another tool, attach the exact "
|
||||
"prompt_ids returned by your submissions to your task. This does NOT submit or rerun anything. "
|
||||
"The workbench then shows real queue/node progress and results. Never use another user's IDs or "
|
||||
"guess from queue differences. Repeating the same IDs is safe. Waits up to wait_seconds and returns "
|
||||
"state, summary, pictures and errors; if still running, keep waiting with run_status(wait_seconds=55).",
|
||||
ai_run_tracking.track_run, {"prompt_ids": {"type": "array", "items": {"type": "string"}, "minItems": 1, "maxItems": 8},
|
||||
"task": _TASK_PROP, "wait_seconds": {"type": "number", "minimum": 0, "maximum": 55, "default": 15}}, ["prompt_ids"]),
|
||||
_task_tool("begin_task", "Begin a task",
|
||||
"Call first: names what the user asked for in Anomalous's AI workbench, where they see, open and undo "
|
||||
"each of your steps. Continues the waiting or active task; new_task=true only for a separate request.",
|
||||
begin_task, {"title": {"type": "string", "description": "A few words, in the user's language."},
|
||||
"new_task": {"type": "boolean", "default": False}},
|
||||
["title"]),
|
||||
_task_tool("report", "Tell the user",
|
||||
"A note in the AI workbench, where the user reads your work: your choices, what to look at, what is "
|
||||
"left, your answers. Markdown headings, lists, bold and code are laid out. reply_to: the id of the "
|
||||
"user's message you answer. images: output pictures (subfolder/name.png) to keep with the task. "
|
||||
"done=true ends it.",
|
||||
report, {"text": {"type": "string"},
|
||||
"images": {"type": "array", "items": {"type": "string"}, "maxItems": MAX_LIMIT},
|
||||
"done": {"type": "boolean", "default": False},
|
||||
"reply_to": {"type": "string", "description": "The message id you answer."},
|
||||
"task": _TASK_PROP}),
|
||||
_task_tool("log_outside", "Say what you did outside Anomalous",
|
||||
"Right after using a tool that is not Anomalous's (a command, a script, files, another server): what "
|
||||
"you ran, why, and the files it touched, for the task's timeline. Prefer Anomalous's tools.",
|
||||
log_outside, {"what": {"type": "string"}, "why": {"type": "string"},
|
||||
"files": {"type": "array", "items": {"type": "string"}, "maxItems": ai_outside.MAX_FILES},
|
||||
"task": _TASK_PROP},
|
||||
["what"]),
|
||||
_task_tool("log_decision", "Record a decision",
|
||||
"Records a settled decision of the task (a style, a model, a fix, what to drop) where the user looks "
|
||||
"back on it: title, decision, reason, rejected options, by (user, ai or together), related step ids. "
|
||||
"The user's own choices in Anomalous are kept already.",
|
||||
log_decision, {"title": {"type": "string"}, "decision": {"type": "string"}, "reason": {"type": "string"},
|
||||
"rejected": {"type": "array", "items": {"type": "string"}, "maxItems": ai_decisions.MAX_REJECTED},
|
||||
"by": {"type": "string", "enum": list(ai_decisions.BY), "default": "user"},
|
||||
"related": {"type": "array", "items": {"type": "string"}, "maxItems": ai_decisions.MAX_RELATED},
|
||||
"task": _TASK_PROP},
|
||||
["title", "decision"]),
|
||||
_task_tool("show_panel", "Show the user a panel",
|
||||
"Draws a panel in the AI workbench, in Anomalous's own style, from blocks: to compare pictures side by "
|
||||
"side, present models with their covers, lay out settings, a table, and to ask (buttons or a line of "
|
||||
"text). Use a new panel for each new phase (plan, workflow, then results), in the order they happen. "
|
||||
"Use it when a choice is the user's, or to show results better than words do. " + BLOCKS_HELP,
|
||||
show_panel, {"title": {"type": "string"},
|
||||
"blocks": {"type": "array", "items": {"type": "object"}, "maxItems": ai_panels.MAX_BLOCKS},
|
||||
"task": _TASK_PROP},
|
||||
["title", "blocks"]),
|
||||
_task_tool("ask_user", "Ask the user",
|
||||
"Asks the user in the AI workbench and waits: a question with 2-8 options ({label, detail, "
|
||||
"recommended}; mark your suggestion recommended=true), and a line for their own answer unless "
|
||||
"other=false; no options: a free answer. Use it for every choice that is the user's, not your chat's "
|
||||
f"question form. Waits at least {ASK_WAIT_MIN} s, up to wait_seconds; unanswered and keep_waiting: wait on "
|
||||
"with get_answers. End every round of work with it.",
|
||||
_question_with_images(ask_user), {"question": {"type": "string"},
|
||||
"options": {"type": "array", "maxItems": 8, "items": {"type": "object", "properties": {
|
||||
"label": {"type": "string"}, "detail": {"type": "string"}, "recommended": {"type": "boolean"}}}},
|
||||
"multiple": {"type": "boolean", "default": False}, "other": {"type": "boolean", "default": True},
|
||||
"wait_seconds": {"type": "number", "minimum": 0, "maximum": ai_panels.MAX_WAIT, "default": ai_panels.MAX_WAIT},
|
||||
"task": _TASK_PROP},
|
||||
["question"]),
|
||||
_task_tool("propose_repaint_area", "Agree on the area to repaint",
|
||||
"Before repainting only the marked areas: the user's marks are rough, so show them the area you would "
|
||||
"repaint. marks: the marks' message id. areas: boxes or ellipses {shape, x, y, w, h} as fractions of the "
|
||||
"picture (x, y its top left), or none to keep the marks; grow: pixels added around; feather: pixels of "
|
||||
"soft edge. The user sees theirs and yours side by side and picks one, or marks again; with an area "
|
||||
"picked the answer has inpaint_image (the picture with that area as its alpha, in ComfyUI's input "
|
||||
"folder) and inpaint_note. Build the repaint yourself. Waits like ask_user.",
|
||||
_question_with_images(propose_repaint_area), {"title": {"type": "string", "description": "A few words, in the user's language."},
|
||||
"marks": {"type": "string"},
|
||||
"areas": {"type": "array", "maxItems": ai_repaint.MAX_AREAS, "items": {"type": "object", "properties": {
|
||||
"shape": {"type": "string", "enum": list(ai_repaint.SHAPES)}, "x": {"type": "number"},
|
||||
"y": {"type": "number"}, "w": {"type": "number"}, "h": {"type": "number"}}}},
|
||||
"grow": {"type": "integer", "minimum": 0, "maximum": ai_repaint.MAX_GROW, "default": 12},
|
||||
"feather": {"type": "integer", "minimum": 0, "maximum": ai_repaint.MAX_FEATHER, "default": 8},
|
||||
"note": {"type": "string", "description": "Why you moved it, in a line."},
|
||||
"wait_seconds": {"type": "number", "minimum": 0, "maximum": ai_panels.MAX_WAIT, "default": ai_panels.MAX_WAIT}},
|
||||
["title", "marks"]),
|
||||
_task_tool("update_panel", "Change a panel",
|
||||
"Adds new output at the BOTTOM of an existing panel, preserving earlier content and its order. "
|
||||
"Send only the new blocks; repeated unchanged blocks are kept once. To deliberately correct an "
|
||||
"existing block or update a progress bar/question in place, include its returned block id and "
|
||||
"the same type. Omitted blocks are retained, not deleted. Never reuse an old block id for a new "
|
||||
"result: append it or use show_panel for the next phase. Up to 30 total blocks per panel. "
|
||||
"Can also change title, or set closed=true to stop answers; existing answers stay.",
|
||||
update_panel, {"panel": {"type": "string"}, "title": {"type": "string"},
|
||||
"blocks": {"type": "array", "items": {"type": "object"}, "maxItems": ai_panels.MAX_BLOCKS},
|
||||
"closed": {"type": "boolean"}, "task": _TASK_PROP}, ["panel"]),
|
||||
_task_tool("run_status", "How the run is going",
|
||||
"Your task's latest run: none, queued (runs ahead), running (node, steps, percent), done (its "
|
||||
"pictures; the first answer telling you it ended attaches up to 4) or failed; summary says it in a "
|
||||
"sentence. wait_seconds (up to 55) waits for the end. Call it instead of guessing or looking in "
|
||||
"folders.",
|
||||
run_status, {"wait_seconds": {"type": "number", "minimum": 0, "maximum": ai_task_runs.MAX_STATUS_WAIT, "default": 0},
|
||||
"task": _TASK_PROP}),
|
||||
_task_tool("show_run_map", "Show what the run really was",
|
||||
"Puts the shape of your task's latest run (or `run`, a run step id) on the user's stage: the nodes it "
|
||||
"really ran as boxes (models, LoRAs with weights, prompts, size, sampler settings, saving), linked, "
|
||||
"each one locates its node on the canvas, with what changed since the run before. Anomalous reads it "
|
||||
"from the prompt ComfyUI queued, so use this instead of drawing the workflow yourself; add your "
|
||||
"explanation with report. title: a few words in the user's language.",
|
||||
show_run_map, {"title": {"type": "string"}, "run": {"type": "string"}, "task": _TASK_PROP}, ["title"]),
|
||||
_task_tool("stop_run", "Stop the run",
|
||||
"Stops your task's run: its queued prompts leave the queue, the running one is interrupted (never "
|
||||
"anyone else's). When run_status warns it is far too big and the user agrees, or when the user asks.",
|
||||
stop_run, {"task": _TASK_PROP}),
|
||||
_task_tool("get_toolbox", "What the user picked for you",
|
||||
"The node types, whole custom node packs, combos, saved workflows, prompts and models the user picked in "
|
||||
"the AI workbench for this task, in full (inputs and outputs of the nodes, each pack's node types, the "
|
||||
"combos' models and prompts…), and how strictly: prefer (use them first) or only (add_node and "
|
||||
"new_workflow accept only those node types and the packs' besides ComfyUI's built-in ones). "
|
||||
"begin_task says when there are any.",
|
||||
get_toolbox, {"task": _TASK_PROP}),
|
||||
_task_tool("get_answers", "Read the user's answers and messages",
|
||||
"What the user picked or typed on your panels and wrote to you in the AI workbench since you last "
|
||||
"asked, each once (kind=change: something they changed themselves; keep it). panel: one panel. "
|
||||
"wait_seconds (up to 55) waits when nothing is there. still_waiting: questions not answered, and "
|
||||
"keep_waiting=true: call it again; skipped=true: they left it to you, decide yourself.",
|
||||
get_answers, {"panel": {"type": "string"},
|
||||
"wait_seconds": {"type": "number", "minimum": 0, "maximum": ai_panels.MAX_WAIT, "default": 0},
|
||||
"task": _TASK_PROP}),
|
||||
])
|
||||
@@ -0,0 +1,577 @@
|
||||
"""The MCP endpoint's (mcp_server.py) reading tools: views of the library (mcp_actions.py acts).
|
||||
|
||||
`call_tool` runs any tool of a registry, these and mcp_actions.py's. search_models and get_model
|
||||
are offered through mcp_model_use.py, which adds what loads each model.
|
||||
|
||||
Each tool is a plain function over the same stores the browser's pages use (model catalog
|
||||
and sidecars, output gallery, combos, workflow recipes, saved prompts, generated audio, scan
|
||||
results, activity log). They never write. Results are small, already-summarised JSON (an AI
|
||||
reads them), with ids the detail tools take back: model_id "type:path_idx:relative/path" and
|
||||
image "subfolder/file.png" under ComfyUI's output folder. A tool's mistake (bad id, missing
|
||||
file) comes back as a tool error the AI can read and correct, never as an exception.
|
||||
"""
|
||||
|
||||
import base64
|
||||
import datetime
|
||||
import html
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
|
||||
import folder_paths
|
||||
from PIL import Image
|
||||
|
||||
from .activity_log import list_entries
|
||||
from .audio_catalog import _gallery_page as _audio_page
|
||||
from .gallery_routes import _gallery_listing
|
||||
from .image_search import read_png_text
|
||||
from .kept_images import _kept_images
|
||||
from .material_store import _list_materials, _read_material, get_materials_dir
|
||||
from .media_routes import _build_card_thumbnail
|
||||
from .metadata import get_metadata
|
||||
from .mcp_arguments import prepare_arguments, renaming_note
|
||||
from .model_catalog import _iter_search_models
|
||||
from .model_constants import MEDIA_EXTENSIONS, MODEL_EXTENSIONS, PREVIEW_SUFFIXES
|
||||
from .notebooks import _list_notebooks
|
||||
from .path_utils import model_file_within, resolve_folder_subdir, resolve_within
|
||||
from .recipe_store import _list_recipes, get_recipes_dir
|
||||
from .scan_report import last_scan_path
|
||||
from .scan_summary import _summarize
|
||||
|
||||
MAX_LIMIT = 50
|
||||
MAX_SEARCH_PICTURES = 6 # search_images(with_pictures): the first few attached
|
||||
MAX_TEXT = 1500
|
||||
MAX_IMAGE_BYTES = 1_500_000
|
||||
IMAGE_TYPES = {".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp"}
|
||||
SOURCES = {"civitai": "civitai", "local": "inferred_from_file", "": "not_scanned"}
|
||||
|
||||
|
||||
class ToolError(Exception):
|
||||
"""A problem the AI can fix (bad id, nothing there); shown to it as the tool's result."""
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- helpers
|
||||
|
||||
def _text(value, limit=MAX_TEXT):
|
||||
"""Plain text from HTML-ish Civitai descriptions, shortened."""
|
||||
value = html.unescape(re.sub(r"<[^>]+>", " ", str(value or "")))
|
||||
value = re.sub(r"\s+", " ", value).strip()
|
||||
return value if len(value) <= limit else value[:limit] + "…"
|
||||
|
||||
|
||||
def _when(seconds):
|
||||
try:
|
||||
return datetime.datetime.fromtimestamp(float(seconds)).isoformat(timespec="seconds")
|
||||
except (TypeError, ValueError, OverflowError, OSError):
|
||||
return None
|
||||
|
||||
|
||||
def _limit(value, default=20):
|
||||
try:
|
||||
return max(1, min(MAX_LIMIT, int(value)))
|
||||
except (TypeError, ValueError):
|
||||
return default
|
||||
|
||||
|
||||
def _terms(query):
|
||||
return [term for term in str(query or "").lower().split() if term]
|
||||
|
||||
|
||||
def _matches(terms, *texts):
|
||||
haystack = " ".join(str(text or "") for text in texts).lower()
|
||||
return all(term in haystack for term in terms)
|
||||
|
||||
|
||||
def _model_id(folder_type, path_idx, base_dir, file_path):
|
||||
return f"{folder_type}:{path_idx}:{os.path.relpath(file_path, base_dir).replace(os.sep, '/')}"
|
||||
|
||||
|
||||
def _resolve_model(model_id):
|
||||
"""(type, path_idx, base_dir, file_path) for a model_id from search_models."""
|
||||
parts = str(model_id or "").split(":", 2)
|
||||
if len(parts) != 3:
|
||||
raise ToolError("model_id looks like 'loras:0:folder/file.safetensors'; take it from search_models.")
|
||||
folder_type, path_idx, rel = parts
|
||||
rel = rel.replace("\\", "/").strip("/")
|
||||
subfolder, filename = os.path.split(rel)
|
||||
try:
|
||||
path_idx = int(path_idx)
|
||||
base_dir, target_dir = resolve_folder_subdir(folder_type, path_idx, "/" + subfolder)
|
||||
file_path = model_file_within(target_dir, filename)
|
||||
except (ValueError, KeyError, TypeError):
|
||||
raise ToolError(f"No models folder for {model_id}.")
|
||||
if not filename.lower().endswith(MODEL_EXTENSIONS) or not os.path.isfile(file_path):
|
||||
raise ToolError(f"No model file at {model_id}; it may have been moved or renamed.")
|
||||
return folder_type, path_idx, base_dir, file_path
|
||||
|
||||
|
||||
def _resolve_image(image):
|
||||
"""The output image at `image` ('subfolder/file.png'), checked to stay inside the output folder."""
|
||||
rel = str(image or "").replace("\\", "/").strip("/")
|
||||
try:
|
||||
path = resolve_within(folder_paths.get_output_directory(), rel)
|
||||
except ValueError:
|
||||
raise ToolError("image is a path under ComfyUI's output folder, as search_images returns it.")
|
||||
if os.path.splitext(path)[1].lower() not in IMAGE_TYPES or not os.path.isfile(path):
|
||||
raise ToolError(f"No output image at {image}: it is not (or no longer) in ComfyUI's output folder; "
|
||||
"the user may have deleted it. search_images lists the pictures there.")
|
||||
return rel, path
|
||||
|
||||
|
||||
def _resolve_folder_image(image, folder):
|
||||
"""(rel, path) of picture `image` ('subfolder/file.png') in ComfyUI's output, input (where
|
||||
LoadImage reads) or temp folder (where PreviewImage writes), checked to stay inside it."""
|
||||
if folder == "output":
|
||||
return _resolve_image(image)
|
||||
if folder not in ("input", "temp"):
|
||||
raise ToolError("folder is output, input or temp.")
|
||||
rel = str(image or "").replace("\\", "/").strip("/")
|
||||
try:
|
||||
path = resolve_within(getattr(folder_paths, f"get_{folder}_directory")(), rel)
|
||||
except ValueError:
|
||||
raise ToolError(f"image is a path under ComfyUI's {folder} folder.")
|
||||
if os.path.splitext(path)[1].lower() not in IMAGE_TYPES or not os.path.isfile(path):
|
||||
raise ToolError(f"No picture at {image} in ComfyUI's {folder} folder.")
|
||||
return rel, path
|
||||
|
||||
|
||||
def _input_facts(path):
|
||||
"""Size of an input or preview picture and, when it has an alpha, the area LoadImage gives as MASK (1 - alpha)."""
|
||||
try:
|
||||
with Image.open(path) as picture:
|
||||
facts = {"width": picture.width, "height": picture.height}
|
||||
if "A" not in picture.getbands():
|
||||
facts["mask"] = "none: no alpha, so LoadImage's MASK is empty"
|
||||
return facts
|
||||
area = picture.getchannel("A").point(lambda value: 255 if value < 128 else 0)
|
||||
except (OSError, ValueError, Image.DecompressionBombError):
|
||||
return {"note": "The picture cannot be read."}
|
||||
box = area.getbbox()
|
||||
if not box:
|
||||
facts["mask"] = "none: fully opaque, so LoadImage's MASK is empty"
|
||||
return facts
|
||||
share = area.histogram()[255] / (facts["width"] * facts["height"])
|
||||
left, top, right, bottom = (round(100 * value / size) for value, size in zip(box, (facts["width"], facts["height"]) * 2))
|
||||
facts["mask"] = {"share": f"{round(100 * share, 1)}%", "area": f"x {left}-{right}%, y {top}-{bottom}% of the picture",
|
||||
"meaning": "LoadImage gives this area as MASK: what to repaint"}
|
||||
return facts
|
||||
|
||||
|
||||
def _image_content(path):
|
||||
"""An MCP image item: the 512 px thumbnail the gallery uses, or None when too big or unreadable."""
|
||||
try:
|
||||
thumb = _build_card_thumbnail(path)
|
||||
with open(thumb, "rb") as source:
|
||||
data = source.read(MAX_IMAGE_BYTES + 1)
|
||||
except OSError:
|
||||
return None
|
||||
if len(data) > MAX_IMAGE_BYTES:
|
||||
return None
|
||||
mime = IMAGE_TYPES.get(os.path.splitext(thumb)[1].lower(), "image/webp")
|
||||
return {"type": "image", "data": base64.b64encode(data).decode("ascii"), "mimeType": mime}
|
||||
|
||||
|
||||
def _kept_lookup():
|
||||
return {(item["subfolder"], item["filename"]): {kind: (value or {}).get("name") for kind, value in item.items()
|
||||
if kind in ("recipe", "combo", "prompt") and value}
|
||||
for item in _kept_images()}
|
||||
|
||||
|
||||
def _model_brief(folder_type, path_idx, base_dir, file_path, meta):
|
||||
rel_dir = os.path.relpath(os.path.dirname(file_path), base_dir).replace(os.sep, "/")
|
||||
try:
|
||||
size_mb = round(os.path.getsize(file_path) / 1048576, 1)
|
||||
except OSError:
|
||||
size_mb = None
|
||||
return {
|
||||
"model_id": _model_id(folder_type, path_idx, base_dir, file_path),
|
||||
"name": meta.get("custom_name") or meta.get("name") or os.path.basename(file_path),
|
||||
"file": os.path.basename(file_path),
|
||||
"type": folder_type,
|
||||
"folder": "" if rel_dir == "." else rel_dir,
|
||||
"base_model": meta.get("baseModel") or "",
|
||||
"source": SOURCES.get(meta.get("info_source", ""), "not_scanned"),
|
||||
"trigger_words": list(meta.get("trainedWords") or [])[:8],
|
||||
"size_mb": size_mb,
|
||||
}
|
||||
|
||||
|
||||
def _each_model():
|
||||
"""Every model file once (folders registered twice, like unet and diffusion_models, count once).
|
||||
ComfyUI also registers custom_nodes, whose node packs carry files of their own: not the library."""
|
||||
seen = set()
|
||||
for folder_type, path_idx, base_dir, file_path in _iter_search_models():
|
||||
if folder_type == "custom_nodes" or not file_path.lower().endswith(MODEL_EXTENSIONS):
|
||||
continue
|
||||
real = os.path.normcase(os.path.realpath(file_path))
|
||||
if real in seen:
|
||||
continue
|
||||
seen.add(real)
|
||||
yield folder_type, path_idx, base_dir, file_path
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- models and scans
|
||||
|
||||
def search_models(query="", type="", base_model="", source="", limit=20):
|
||||
terms, wanted_base, found = _terms(query), str(base_model or "").lower(), []
|
||||
total = 0
|
||||
type = str(type or "").lower()
|
||||
for folder_type, path_idx, base_dir, file_path in _each_model():
|
||||
if type and type not in (folder_type, folder_type.rstrip("s")): # "checkpoint" finds the checkpoints too
|
||||
continue
|
||||
meta = get_metadata(file_path)
|
||||
if wanted_base and wanted_base not in str(meta.get("baseModel") or "").lower():
|
||||
continue
|
||||
if source and SOURCES.get(meta.get("info_source", ""), "not_scanned") != source:
|
||||
continue
|
||||
if not _matches(terms, os.path.relpath(file_path, base_dir), meta.get("name"), meta.get("custom_name"),
|
||||
meta.get("baseModel"), " ".join(meta.get("trainedWords") or [])):
|
||||
continue
|
||||
total += 1
|
||||
if len(found) < _limit(limit):
|
||||
found.append(_model_brief(folder_type, path_idx, base_dir, file_path, meta))
|
||||
return {"total_matches": total, "models": found}
|
||||
|
||||
|
||||
def get_model(model_id, include_cover=False):
|
||||
folder_type, path_idx, base_dir, file_path = _resolve_model(model_id)
|
||||
meta = get_metadata(file_path)
|
||||
detail = _model_brief(folder_type, path_idx, base_dir, file_path, meta)
|
||||
detail.update({
|
||||
"trigger_words": list(meta.get("trainedWords") or []),
|
||||
"civitai_name": meta.get("name") or "",
|
||||
"version": meta.get("version_name") or "",
|
||||
"civitai_url": meta.get("civitai_url") or "",
|
||||
"download_link": meta.get("source_url") or "",
|
||||
"user_notes": meta.get("custom_notes") or "",
|
||||
"fields_set_by_user": list(meta.get("user_fields") or []),
|
||||
"description": _text(meta.get("description")),
|
||||
"sha256": meta.get("hash") or "",
|
||||
})
|
||||
if meta.get("info_source") == "local":
|
||||
detail["why_not_on_civitai"] = meta.get("unmatched_reason") or "unknown"
|
||||
extra = []
|
||||
if include_cover:
|
||||
base = os.path.splitext(file_path)[0]
|
||||
cover = next((base + suffix for suffix in PREVIEW_SUFFIXES + MEDIA_EXTENSIONS
|
||||
if os.path.splitext(suffix)[1].lower() in IMAGE_TYPES and os.path.isfile(base + suffix)), None)
|
||||
item = _image_content(cover) if cover else None
|
||||
detail["cover"] = "attached" if item else "none"
|
||||
extra = [item] if item else []
|
||||
return detail, extra
|
||||
|
||||
|
||||
def library_overview():
|
||||
by_type, by_base = {}, {}
|
||||
for folder_type, _idx, _base, file_path in _each_model():
|
||||
by_type[folder_type] = by_type.get(folder_type, 0) + 1
|
||||
base = get_metadata(file_path).get("baseModel") or "unknown"
|
||||
by_base[base] = by_base.get(base, 0) + 1
|
||||
summary = _summarize()
|
||||
return {
|
||||
"models_by_type": dict(sorted(by_type.items(), key=lambda item: -item[1])),
|
||||
"models_by_base_model": dict(sorted(by_base.items(), key=lambda item: -item[1])[:20]),
|
||||
"scan": {key: summary[key] for key in ("total", "matched", "unmatched", "new", "pending")},
|
||||
"combos": len(_list_notebooks()),
|
||||
"workflow_recipes": len(_list_recipes(get_recipes_dir())),
|
||||
"saved_prompts": sum(1 for item in _list_materials(get_materials_dir()) if item.get("kind") == "prompt_plan"),
|
||||
}
|
||||
|
||||
|
||||
def scan_report():
|
||||
summary = _summarize()
|
||||
try:
|
||||
with open(last_scan_path(), encoding="utf-8") as source:
|
||||
last = json.load(source)
|
||||
except (OSError, ValueError):
|
||||
last = None
|
||||
report = {
|
||||
"counts": {key: summary[key] for key in ("total", "matched", "unmatched", "new", "pending")},
|
||||
"meaning": "matched: found on Civitai; unmatched: base model inferred from the file (reason says why); "
|
||||
"new: never scanned; pending: unmatched only because Civitai was not asked (offline or no connection).",
|
||||
"unmatched_models": summary["unmatched_models"][:MAX_LIMIT],
|
||||
"not_scanned_models": summary["new_models"][:MAX_LIMIT],
|
||||
}
|
||||
if isinstance(last, dict) and last.get("counts"):
|
||||
report["last_scan"] = {"finished": _when(last.get("finished")), "kind": last.get("kind"),
|
||||
"counts": last.get("counts"), "civitai_unreachable": bool(last.get("civitai_down")),
|
||||
"models": (last.get("files") or [])[:30]}
|
||||
return report
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- outputs
|
||||
|
||||
def search_images(query="", limit=20, page=1, with_pictures=False):
|
||||
images = _gallery_listing(folder_paths.get_output_directory(), False, str(query or "").strip())
|
||||
limit = _limit(limit)
|
||||
try:
|
||||
page = max(1, int(page))
|
||||
except (TypeError, ValueError):
|
||||
page = 1
|
||||
kept = _kept_lookup()
|
||||
chosen = images[(page - 1) * limit:page * limit]
|
||||
found = {
|
||||
"total_matches": len(images), "page": page,
|
||||
"images": [{"image": "/".join(part for part in (item["subfolder"], item["filename"]) if part),
|
||||
"created": _when(item.get("mtime")),
|
||||
**({"kept_as": kept[(item["subfolder"], item["filename"])]}
|
||||
if (item["subfolder"], item["filename"]) in kept else {})}
|
||||
for item in chosen],
|
||||
}
|
||||
if not with_pictures:
|
||||
return found
|
||||
pictures = [] # the first few themselves, in the order listed, so an AI that sees pictures need not ask for each
|
||||
for entry in found["images"][:MAX_SEARCH_PICTURES]:
|
||||
item = _image_content(_resolve_image(entry["image"])[1])
|
||||
entry["attached"] = bool(item)
|
||||
if item:
|
||||
pictures.append(item)
|
||||
return found, pictures
|
||||
|
||||
|
||||
def get_image_info(image, include_image=False, folder="output"):
|
||||
if folder != "output":
|
||||
rel, path = _resolve_folder_image(image, folder)
|
||||
info = {"image": rel, "folder": folder, "created": _when(os.path.getmtime(path)), **_input_facts(path)}
|
||||
extra = [item for item in [_image_content(path)] if include_image and item]
|
||||
if include_image:
|
||||
info["image_attached"] = bool(extra)
|
||||
return info, extra
|
||||
rel, path = _resolve_image(image)
|
||||
info = {"image": rel, "created": _when(os.path.getmtime(path))}
|
||||
chunks = read_png_text(path) if path.lower().endswith(".png") else {}
|
||||
try:
|
||||
prompt = json.loads(chunks.get("prompt") or "null")
|
||||
except ValueError:
|
||||
prompt = None
|
||||
if isinstance(prompt, dict):
|
||||
nodes, models = [], set()
|
||||
for node_id, node in list(prompt.items())[:80]:
|
||||
if not isinstance(node, dict):
|
||||
continue
|
||||
inputs = {}
|
||||
for key, value in (node.get("inputs") or {}).items():
|
||||
if isinstance(value, str):
|
||||
inputs[key] = _text(value, 2000) if len(value) > 2000 else value
|
||||
if value.lower().endswith(MODEL_EXTENSIONS):
|
||||
models.add(value.replace("\\", "/"))
|
||||
elif isinstance(value, (int, float, bool)):
|
||||
inputs[key] = value
|
||||
nodes.append({"id": node_id, "type": node.get("class_type"), "inputs": inputs})
|
||||
info.update(models_used=sorted(models), nodes=nodes)
|
||||
elif chunks.get("parameters"):
|
||||
info["parameters"] = _text(chunks["parameters"], 4000)
|
||||
else:
|
||||
info["note"] = "No generation settings are stored in this image."
|
||||
kept = _kept_lookup().get(tuple(rel.rsplit("/", 1)) if "/" in rel else ("", rel))
|
||||
if kept:
|
||||
info["kept_as"] = kept
|
||||
extra = []
|
||||
if include_image:
|
||||
item = _image_content(path)
|
||||
info["image_attached"] = bool(item)
|
||||
extra = [item] if item else []
|
||||
return info, extra
|
||||
|
||||
|
||||
def search_audio(query="", limit=20):
|
||||
items, total, _more = _audio_page(folder_paths.get_output_directory(), 1, _limit(limit), str(query or "").lower().strip())
|
||||
return {"total_matches": total, "audio": [{
|
||||
"file": "/".join(part for part in (item["subfolder"], item["filename"]) if part),
|
||||
"created": _when(item.get("mtime")),
|
||||
"speech": (item.get("generation") or {}).get("speech") or "",
|
||||
"voice_sample": (item.get("generation") or {}).get("sample") or "",
|
||||
"seed": (item.get("generation") or {}).get("seed"),
|
||||
} for item in items]}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- what the user kept
|
||||
|
||||
def _model_name(model):
|
||||
if isinstance(model, dict):
|
||||
return model.get("filename") or model.get("name") or ""
|
||||
return str(model or "")
|
||||
|
||||
|
||||
def combo_view(note):
|
||||
"""A combo (one of _list_notebooks) as the AI and the materials picker see it, with its LoRAs and texts."""
|
||||
data = note.get("data") or {}
|
||||
if data.get("kind") == "nodes": # its own node structure: model and text slots by their names
|
||||
structure = data.get("structure") or {}
|
||||
values = data.get("values") or {}
|
||||
slots = structure.get("slots") or []
|
||||
models = [{"slot": s.get("label") or s.get("widget"), "folder": s.get("folder") or "",
|
||||
"file": os.path.basename(str(values.get(s["id"]) or "").replace("\\", "/"))}
|
||||
for s in slots if s.get("kind") == "model"]
|
||||
texts = [{"slot": s.get("label") or s.get("widget"), "text": _text(values.get(s["id"]), 400)}
|
||||
for s in slots if s.get("kind") == "text"]
|
||||
combo = {"name": note.get("name"), "kind": "node structure", "models": models, "texts": texts,
|
||||
"nodes": [n.get("name") or n.get("type") for n in structure.get("nodes") or []],
|
||||
"main_model": models[0]["file"] if models else "", "prompt": texts[0]["text"] if texts else ""}
|
||||
return combo, [model["file"] for model in models[1:]] + [text["text"] for text in texts[1:]]
|
||||
loras = [_model_name(lora) for lora in data.get("loras") or []]
|
||||
return {"name": note.get("name"), "base_model": data.get("baseModel") or "", "main_model": _model_name(data.get("mainModel")),
|
||||
"loras": loras, "prompt": _text(data.get("promptEn"), 800)}, loras
|
||||
|
||||
|
||||
def list_combos(query="", limit=20, *, exact_name=False):
|
||||
terms, found = _terms(query), []
|
||||
for note in _list_notebooks():
|
||||
combo, loras = combo_view(note)
|
||||
if exact_name and combo["name"] != query:
|
||||
continue
|
||||
if not exact_name and not _matches(terms, combo["name"], combo["main_model"], combo["prompt"], " ".join(loras)):
|
||||
continue
|
||||
found.append(combo)
|
||||
return {"total_matches": len(found), "combos": found[:_limit(limit)]}
|
||||
|
||||
|
||||
def list_workflows(query="", limit=20, *, exact_name=False):
|
||||
terms, found = _terms(query), []
|
||||
for recipe in _list_recipes(get_recipes_dir()):
|
||||
data = recipe.get("data") or {}
|
||||
params = json.dumps(data.get("params") or {}, ensure_ascii=False)
|
||||
if exact_name and (data.get("name") or recipe["filename"]) != query:
|
||||
continue
|
||||
if not exact_name and not _matches(terms, data.get("name"), " ".join(data.get("tags") or []), data.get("notes"), params):
|
||||
continue
|
||||
found.append({"name": data.get("name") or recipe["filename"], "tags": data.get("tags") or [],
|
||||
"notes": _text(data.get("notes"), 500), "saved": _when((data.get("timestamp") or 0) / 1000),
|
||||
"settings": params if len(params) <= MAX_TEXT else params[:MAX_TEXT] + "…"})
|
||||
return {"total_matches": len(found), "workflows": found[:_limit(limit)]}
|
||||
|
||||
|
||||
def saved_prompts():
|
||||
"""Every saved prompt plan: {name, tags, positive, negative}."""
|
||||
directory = get_materials_dir()
|
||||
for summary in _list_materials(directory):
|
||||
if summary.get("kind") != "prompt_plan" or summary.get("moved_to_recipe"):
|
||||
continue
|
||||
try:
|
||||
plan = _read_material(os.path.join(directory, summary["filename"])).get("plan") or {}
|
||||
except (OSError, ValueError, KeyError):
|
||||
continue
|
||||
yield {"name": summary.get("name"), "tags": summary.get("tags") or [],
|
||||
"positive": _text(plan.get("positive"), 1200), "negative": _text(plan.get("negative"), 600)}
|
||||
|
||||
|
||||
def list_saved_prompts(query="", limit=20):
|
||||
terms = _terms(query)
|
||||
found = [prompt for prompt in saved_prompts()
|
||||
if _matches(terms, prompt["name"], " ".join(prompt["tags"]), prompt["positive"], prompt["negative"])]
|
||||
return {"total_matches": len(found), "prompts": found[:_limit(limit)]}
|
||||
|
||||
|
||||
def recent_activity(limit=10, source=""):
|
||||
entries = list_entries(_limit(limit), source if source in ("canvas", "file") else None)
|
||||
return {"entries": [{"time": _when(entry.get("time")), "source": entry.get("source"), "action": entry.get("action"),
|
||||
"target": entry.get("target") or "", "detail": entry.get("detail") or {}} for entry in entries]}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- registry
|
||||
|
||||
def _schema(properties=None, required=()):
|
||||
schema = {"type": "object", "properties": properties or {}, "additionalProperties": False}
|
||||
if required:
|
||||
schema["required"] = list(required)
|
||||
return schema
|
||||
|
||||
|
||||
_QUERY = {"type": "string", "description": "Words that must all appear; empty lists all."}
|
||||
_LIMIT = {"type": "integer", "minimum": 1, "maximum": MAX_LIMIT, "default": 20}
|
||||
|
||||
|
||||
def _tool(name, title, description, run, properties=None, required=()):
|
||||
return name, {"run": run, "spec": {
|
||||
"name": name, "title": title, "description": description,
|
||||
"inputSchema": _schema(properties, required),
|
||||
"annotations": {"title": title, "readOnlyHint": True, "destructiveHint": False,
|
||||
"idempotentHint": True, "openWorldHint": False},
|
||||
}}
|
||||
|
||||
|
||||
TOOLS = dict([
|
||||
_tool("library_overview", "Library overview",
|
||||
"How many models of each type and base model the user has, how many are scanned, and how many "
|
||||
"combos, workflow recipes and saved prompts they kept. A good first call.", library_overview),
|
||||
_tool("scan_report", "Scan status",
|
||||
"Which models are matched on Civitai, which are not and why, which were never scanned, and what the last scan did.",
|
||||
scan_report),
|
||||
_tool("search_images", "Search output images",
|
||||
"Output images, newest first, by words in their prompt, model or settings (a LoRA name, 'seed:123'). "
|
||||
"with_pictures attaches the first 6 (512 px).",
|
||||
search_images, {"query": _QUERY, "limit": _LIMIT, "page": {"type": "integer", "minimum": 1, "default": 1},
|
||||
"with_pictures": {"type": "boolean", "default": False}}),
|
||||
_tool("get_image_info", "Image generation settings",
|
||||
"How an output image was made (prompts, models, seed, sampler…) and whether the user kept it. "
|
||||
"folder=input: a picture LoadImage reads; folder=temp: a run's preview; both with their size and MASK "
|
||||
"area. include_image attaches a 512 px copy; zoom_image shows a part larger.",
|
||||
get_image_info, {"image": {"type": "string", "description": "From search_images; for folder=input, the name LoadImage takes."},
|
||||
"include_image": {"type": "boolean", "default": False},
|
||||
"folder": {"type": "string", "enum": ["output", "input", "temp"], "default": "output"}}, ["image"]),
|
||||
_tool("list_combos", "Combos",
|
||||
"The user's combos (搭配): a main model, LoRAs and a prompt kept together, or (kind \"node "
|
||||
"structure\") model nodes and text nodes saved from the canvas with their links, listed by slot.", list_combos,
|
||||
{"query": _QUERY, "limit": _LIMIT}),
|
||||
_tool("list_workflows", "Workflow recipes",
|
||||
"The user's saved workflow recipes with tags, notes and their main settings.", list_workflows,
|
||||
{"query": _QUERY, "limit": _LIMIT}),
|
||||
_tool("list_saved_prompts", "Saved prompts",
|
||||
"Prompts the user saved in the Prompt Studio, with positive and negative text.", list_saved_prompts,
|
||||
{"query": _QUERY, "limit": _LIMIT}),
|
||||
_tool("search_audio", "Generated audio",
|
||||
"Speech the user generated (Anomalous TTS), newest first, with its text, voice and seed.", search_audio,
|
||||
{"query": _QUERY, "limit": _LIMIT}),
|
||||
_tool("recent_activity", "Activity log",
|
||||
"What Anomalous changed recently, newest first: canvas edits it made and files it saved, scanned or deleted.",
|
||||
recent_activity, {"limit": {**_LIMIT, "default": 10}, "source": {"type": "string", "enum": ["canvas", "file"]}}),
|
||||
])
|
||||
|
||||
|
||||
def tool_text(data):
|
||||
"""A result as the AI reads it: JSON without spaces. Apps keep a long one out of the chat and
|
||||
have the AI open it as a file (Antigravity past about 4,000 characters), so every character counts."""
|
||||
return json.dumps(data, ensure_ascii=False, separators=(",", ":"))
|
||||
|
||||
|
||||
def call_tool(tools, name, arguments, ctx=None):
|
||||
"""An MCP tools/call result for tool `name` of `tools` (run in a worker thread). Tools marked
|
||||
`context` get `ctx` ({base_url} of this server) first."""
|
||||
tool = tools[name]
|
||||
spec = tool["spec"]["inputSchema"]
|
||||
arguments, renamed = prepare_arguments(spec, arguments)
|
||||
unknown = set(arguments) - set(spec["properties"])
|
||||
missing = [key for key in spec.get("required", []) if key not in arguments]
|
||||
if unknown or missing:
|
||||
wrong = "; ".join(part for part in (unknown and f"Unknown arguments {sorted(unknown)}", missing and f"missing {missing}") if part)
|
||||
takes = ", ".join(key + (" (needed)" if key in spec.get("required", []) else "") for key in spec["properties"] if key != "task")
|
||||
return _failure(f"{wrong}. {name} takes: {takes or 'nothing'}.")
|
||||
try:
|
||||
value = tool["run"](ctx, **arguments) if tool.get("context") else tool["run"](**arguments)
|
||||
except ToolError as error:
|
||||
return _failure(str(error))
|
||||
except Exception as error: # noqa: BLE001 - an AI app gets a readable failure, never a dropped request
|
||||
logging.getLogger(__name__).warning("Anomalous MCP tool %s failed", name, exc_info=True)
|
||||
return _failure(f"{name} failed: {error}")
|
||||
data, extra = value if isinstance(value, tuple) else (value, [])
|
||||
if renamed and isinstance(data, dict):
|
||||
data = {**data, "arguments_note": renaming_note(name, renamed)}
|
||||
return {"content": [{"type": "text", "text": tool_text(data)}, *extra],
|
||||
"structuredContent": data, "isError": False}
|
||||
|
||||
|
||||
def retext(result, data):
|
||||
"""A tool result with `data` as its structured content and as its text (the rest of its content kept)."""
|
||||
result["structuredContent"] = data
|
||||
content = list(result.get("content") or [])
|
||||
text = {"type": "text", "text": tool_text(data)}
|
||||
if content and isinstance(content[0], dict) and content[0].get("type") == "text":
|
||||
content[0] = text
|
||||
else:
|
||||
content.insert(0, text)
|
||||
result["content"] = content
|
||||
|
||||
|
||||
def _failure(message):
|
||||
return {"content": [{"type": "text", "text": message}], "isError": True}
|
||||
+195
-45
@@ -1,6 +1,13 @@
|
||||
"""Model cover, thumbnail-cache, and generated-image lookup routes."""
|
||||
"""Model cover, thumbnail-cache, and generated-image lookup routes.
|
||||
|
||||
Card images are 512 px WebP copies of the covers (a video cover gets one of its first
|
||||
frame, the poster), kept in the user folder so they survive ComfyUI restarts (ComfyUI
|
||||
empties its temp folder on every start). Listing a folder queues the covers not made yet
|
||||
for one background worker, so scrolling and the next visit find them ready.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import collections
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
@@ -19,6 +26,8 @@ from .path_utils import require_filename, resolve_folder_subdir, resolve_within
|
||||
CARD_THUMBNAIL_EDGE = 512
|
||||
CARD_THUMBNAIL_CACHE_LIMIT = 256 * 1024 * 1024
|
||||
CARD_THUMBNAIL_STATIC_EXTENSIONS = {'.png', '.jpg', '.jpeg', '.webp', '.avif'}
|
||||
CARD_POSTER_VIDEO_EXTENSIONS = {'.mp4', '.webm', '.mov', '.avi', '.mkv'}
|
||||
CARD_WARM_QUEUE_LIMIT = 512
|
||||
_thumbnail_cleanup_lock = threading.Lock()
|
||||
_thumbnail_generation_slots = threading.BoundedSemaphore(2)
|
||||
_thumbnail_last_cleanup = 0.0
|
||||
@@ -26,17 +35,53 @@ _thumbnail_created_since_cleanup = 0
|
||||
|
||||
|
||||
def _thumbnail_cache_directory():
|
||||
"""<user folder>/anomalous/cache/card_thumbnails; the system temp folder if there is none."""
|
||||
try:
|
||||
base_dir = folder_paths.get_temp_directory()
|
||||
user_dir = folder_paths.get_user_directory()
|
||||
except Exception:
|
||||
base_dir = None
|
||||
if not isinstance(base_dir, (str, os.PathLike)):
|
||||
base_dir = tempfile.gettempdir()
|
||||
cache_dir = os.path.join(base_dir, "anomalous_model_browser", "card_thumbnails")
|
||||
user_dir = None
|
||||
if isinstance(user_dir, (str, os.PathLike)):
|
||||
cache_dir = os.path.join(user_dir, "anomalous", "cache", "card_thumbnails")
|
||||
else:
|
||||
cache_dir = os.path.join(tempfile.gettempdir(), "anomalous_model_browser", "card_thumbnails")
|
||||
os.makedirs(cache_dir, exist_ok=True)
|
||||
return cache_dir
|
||||
|
||||
|
||||
def thumbnail_cache_usage():
|
||||
"""(file count, bytes) of the card image cache, for the settings page."""
|
||||
count = size = 0
|
||||
try:
|
||||
with os.scandir(_thumbnail_cache_directory()) as iterator:
|
||||
for entry in iterator:
|
||||
if entry.is_file() and entry.name.endswith('.webp'):
|
||||
count += 1
|
||||
try:
|
||||
size += entry.stat().st_size
|
||||
except OSError:
|
||||
pass
|
||||
except OSError:
|
||||
pass
|
||||
return count, size
|
||||
|
||||
|
||||
def clear_thumbnail_cache():
|
||||
"""Delete the derived card images (never a cover); they are made again when needed."""
|
||||
removed = 0
|
||||
try:
|
||||
with os.scandir(_thumbnail_cache_directory()) as iterator:
|
||||
for entry in iterator:
|
||||
if entry.is_file() and entry.name.endswith('.webp'):
|
||||
try:
|
||||
os.remove(entry.path)
|
||||
removed += 1
|
||||
except OSError:
|
||||
pass
|
||||
except OSError:
|
||||
pass
|
||||
return removed
|
||||
|
||||
|
||||
def _prune_thumbnail_cache(cache_dir, created=False):
|
||||
"""Occasionally cap the derived thumbnail cache without touching source covers."""
|
||||
global _thumbnail_last_cleanup, _thumbnail_created_since_cleanup
|
||||
@@ -80,28 +125,61 @@ def _prune_thumbnail_cache(cache_dir, created=False):
|
||||
break
|
||||
|
||||
|
||||
def _cached_card_path(source_path, kind=''):
|
||||
"""Where the card image of `source_path` is cached: keyed by the file's identity and edge."""
|
||||
source_stat = os.stat(source_path)
|
||||
cache_key = "\0".join((
|
||||
os.path.realpath(source_path),
|
||||
str(source_stat.st_size),
|
||||
str(source_stat.st_mtime_ns),
|
||||
str(getattr(source_stat, 'st_ctime_ns', 0)),
|
||||
str(CARD_THUMBNAIL_EDGE),
|
||||
*((kind,) if kind else ()),
|
||||
))
|
||||
digest = hashlib.sha256(cache_key.encode('utf-8', errors='surrogatepass')).hexdigest()
|
||||
cache_dir = _thumbnail_cache_directory()
|
||||
return cache_dir, os.path.join(cache_dir, f"{digest}.webp")
|
||||
|
||||
|
||||
def _reuse_cached(cache_dir, cached_path):
|
||||
if not os.path.isfile(cached_path):
|
||||
return False
|
||||
try:
|
||||
os.utime(cached_path, None)
|
||||
except OSError:
|
||||
pass
|
||||
_prune_thumbnail_cache(cache_dir)
|
||||
return True
|
||||
|
||||
|
||||
def _save_card_image(image, cache_dir, cached_path):
|
||||
"""Shrink a PIL image to the card edge and store it as WebP (atomically)."""
|
||||
from PIL import Image
|
||||
|
||||
resampling = getattr(Image, 'Resampling', Image).LANCZOS
|
||||
image.thumbnail((CARD_THUMBNAIL_EDGE, CARD_THUMBNAIL_EDGE), resampling)
|
||||
if image.mode not in ('RGB', 'RGBA'):
|
||||
image = image.convert('RGBA' if 'transparency' in image.info else 'RGB')
|
||||
temp_path = f"{cached_path}.{os.getpid()}.{threading.get_ident()}.tmp"
|
||||
try:
|
||||
image.save(temp_path, format='WEBP', quality=84, method=4)
|
||||
os.replace(temp_path, cached_path)
|
||||
finally:
|
||||
if os.path.exists(temp_path):
|
||||
try:
|
||||
os.remove(temp_path)
|
||||
except OSError:
|
||||
pass
|
||||
_prune_thumbnail_cache(cache_dir, created=True)
|
||||
|
||||
|
||||
def _build_card_thumbnail_impl(source_path):
|
||||
"""Return a cached 512px WebP card image, or the original on any safe fallback."""
|
||||
try:
|
||||
from PIL import Image, ImageOps
|
||||
|
||||
source_stat = os.stat(source_path)
|
||||
cache_key = "\0".join((
|
||||
os.path.realpath(source_path),
|
||||
str(source_stat.st_size),
|
||||
str(source_stat.st_mtime_ns),
|
||||
str(getattr(source_stat, 'st_ctime_ns', 0)),
|
||||
str(CARD_THUMBNAIL_EDGE),
|
||||
))
|
||||
digest = hashlib.sha256(cache_key.encode('utf-8', errors='surrogatepass')).hexdigest()
|
||||
cache_dir = _thumbnail_cache_directory()
|
||||
cached_path = os.path.join(cache_dir, f"{digest}.webp")
|
||||
if os.path.isfile(cached_path):
|
||||
try:
|
||||
os.utime(cached_path, None)
|
||||
except OSError:
|
||||
pass
|
||||
_prune_thumbnail_cache(cache_dir)
|
||||
cache_dir, cached_path = _cached_card_path(source_path)
|
||||
if _reuse_cached(cache_dir, cached_path):
|
||||
return cached_path
|
||||
|
||||
with Image.open(source_path) as image:
|
||||
@@ -110,23 +188,7 @@ def _build_card_thumbnail_impl(source_path):
|
||||
image = ImageOps.exif_transpose(image)
|
||||
if max(image.size) <= CARD_THUMBNAIL_EDGE:
|
||||
return source_path
|
||||
resampling = getattr(Image, 'Resampling', Image).LANCZOS
|
||||
image.thumbnail((CARD_THUMBNAIL_EDGE, CARD_THUMBNAIL_EDGE), resampling)
|
||||
if image.mode not in ('RGB', 'RGBA'):
|
||||
image = image.convert('RGBA' if 'transparency' in image.info else 'RGB')
|
||||
temp_path = (
|
||||
f"{cached_path}.{os.getpid()}.{threading.get_ident()}.tmp"
|
||||
)
|
||||
try:
|
||||
image.save(temp_path, format='WEBP', quality=84, method=4)
|
||||
os.replace(temp_path, cached_path)
|
||||
finally:
|
||||
if os.path.exists(temp_path):
|
||||
try:
|
||||
os.remove(temp_path)
|
||||
except OSError:
|
||||
pass
|
||||
_prune_thumbnail_cache(cache_dir, created=True)
|
||||
_save_card_image(image, cache_dir, cached_path)
|
||||
return cached_path
|
||||
except Exception:
|
||||
return source_path
|
||||
@@ -138,6 +200,77 @@ def _build_card_thumbnail(source_path):
|
||||
return _build_card_thumbnail_impl(source_path)
|
||||
|
||||
|
||||
def _build_video_poster_impl(source_path):
|
||||
"""A cached 512 px WebP of a video cover's first frame, or None (no decoder, bad file)."""
|
||||
try:
|
||||
cache_dir, cached_path = _cached_card_path(source_path, 'poster')
|
||||
if _reuse_cached(cache_dir, cached_path):
|
||||
return cached_path
|
||||
import av # PyAV ships with ComfyUI for its video nodes
|
||||
|
||||
with av.open(source_path) as container:
|
||||
stream = next((s for s in container.streams if s.type == 'video'), None)
|
||||
if stream is None:
|
||||
return None
|
||||
stream.thread_type = 'AUTO'
|
||||
frame = next(container.decode(stream), None)
|
||||
if frame is None:
|
||||
return None
|
||||
image = frame.to_image()
|
||||
_save_card_image(image, cache_dir, cached_path)
|
||||
return cached_path
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def _build_video_poster(source_path):
|
||||
with _thumbnail_generation_slots:
|
||||
return _build_video_poster_impl(source_path)
|
||||
|
||||
|
||||
# ---------- background warm-up of card images ----------
|
||||
|
||||
_warm_queue = collections.deque()
|
||||
_warm_pending = set()
|
||||
_warm_lock = threading.Lock()
|
||||
_warm_thread = None
|
||||
|
||||
|
||||
def _warm_worker():
|
||||
"""One thread, one decode at a time, a short rest between: never more than half the slots."""
|
||||
global _warm_thread
|
||||
while True:
|
||||
with _warm_lock:
|
||||
if not _warm_queue:
|
||||
_warm_thread = None
|
||||
return
|
||||
path = _warm_queue.popleft()
|
||||
_warm_pending.discard(path)
|
||||
ext = os.path.splitext(path)[1].lower()
|
||||
if ext in CARD_POSTER_VIDEO_EXTENSIONS:
|
||||
_build_video_poster(path)
|
||||
else:
|
||||
_build_card_thumbnail(path)
|
||||
time.sleep(0.02)
|
||||
|
||||
|
||||
def queue_card_images(paths):
|
||||
"""Make the card images of these covers in the background (bounded, deduplicated)."""
|
||||
global _warm_thread
|
||||
with _warm_lock:
|
||||
for path in paths:
|
||||
ext = os.path.splitext(path)[1].lower()
|
||||
if ext not in CARD_THUMBNAIL_STATIC_EXTENSIONS and ext not in CARD_POSTER_VIDEO_EXTENSIONS:
|
||||
continue
|
||||
if path in _warm_pending or len(_warm_queue) >= CARD_WARM_QUEUE_LIMIT:
|
||||
continue
|
||||
_warm_pending.add(path)
|
||||
_warm_queue.append(path)
|
||||
if _warm_queue and _warm_thread is None:
|
||||
_warm_thread = threading.Thread(target=_warm_worker, name="anomalous-card-images", daemon=True)
|
||||
_warm_thread.start()
|
||||
|
||||
|
||||
async def api_serve_image(request):
|
||||
"""Dedicated image serving endpoint for model preview images."""
|
||||
folder_type = request.query.get('type', 'checkpoints')
|
||||
@@ -169,20 +302,25 @@ async def api_serve_image(request):
|
||||
'.mp4': 'video/mp4',
|
||||
'.webm': 'video/webm',
|
||||
'.mov': 'video/quicktime',
|
||||
'.avi': 'video/x-msvideo'
|
||||
'.avi': 'video/x-msvideo',
|
||||
'.mkv': 'video/x-matroska'
|
||||
}
|
||||
content_type = content_types.get(ext)
|
||||
if content_type is None:
|
||||
return web.Response(status=415, text='Unsupported media type')
|
||||
|
||||
served_path = file_path
|
||||
if (
|
||||
request.query.get('variant') == 'card'
|
||||
and ext in CARD_THUMBNAIL_STATIC_EXTENSIONS
|
||||
):
|
||||
variant = request.query.get('variant')
|
||||
if variant == 'card' and ext in CARD_THUMBNAIL_STATIC_EXTENSIONS:
|
||||
served_path = await asyncio.to_thread(_build_card_thumbnail, file_path)
|
||||
if served_path != file_path:
|
||||
content_type = 'image/webp'
|
||||
elif variant == 'poster':
|
||||
# The card's still image of a video cover; nothing (404) when it cannot be read.
|
||||
poster = await asyncio.to_thread(_build_video_poster, file_path) if ext in CARD_POSTER_VIDEO_EXTENSIONS else None
|
||||
if not poster:
|
||||
return web.Response(status=404, text='No poster')
|
||||
served_path, content_type = poster, 'image/webp'
|
||||
|
||||
headers = {'Content-Type': content_type}
|
||||
if request.query.get('t'):
|
||||
@@ -190,6 +328,18 @@ async def api_serve_image(request):
|
||||
return web.FileResponse(served_path, headers=headers)
|
||||
|
||||
|
||||
async def api_card_cache(request):
|
||||
"""GET /anomalous/card_cache - how many card images are cached and their size."""
|
||||
count, size = await asyncio.to_thread(thumbnail_cache_usage)
|
||||
return web.json_response({"count": count, "bytes": size, "limit": CARD_THUMBNAIL_CACHE_LIMIT})
|
||||
|
||||
|
||||
async def api_clear_card_cache(request):
|
||||
"""POST /anomalous/card_cache/clear - delete the derived card images (made again when shown)."""
|
||||
removed = await asyncio.to_thread(clear_thumbnail_cache)
|
||||
return web.json_response({"status": "ok", "removed": removed})
|
||||
|
||||
|
||||
async def api_clear_cache(request):
|
||||
try:
|
||||
from .metadata import clear_metadata_cache
|
||||
|
||||
+239
-191
@@ -4,198 +4,246 @@ import json
|
||||
import urllib.parse
|
||||
import subprocess
|
||||
import threading
|
||||
import asyncio
|
||||
import copy
|
||||
from functools import lru_cache
|
||||
from aiohttp import web
|
||||
import asyncio
|
||||
import copy
|
||||
from functools import lru_cache
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
import struct
|
||||
try:
|
||||
from ..model_identity import sidecar_file_hash
|
||||
except ImportError:
|
||||
from model_identity import sidecar_file_hash
|
||||
|
||||
def _select_info_file(data, file_path):
|
||||
"""Select the Civitai file entry that actually describes ``file_path``.
|
||||
|
||||
A model version may contain a checkpoint, text encoder, and VAE in the same
|
||||
``files`` array. Taking the first SHA256 silently assigns the dependency's
|
||||
hash to every local sidecar copied from that version. Physical byte size is
|
||||
the strongest cheap discriminator available here and remains valid after a
|
||||
local rename. Filenames are intentionally excluded: local renames are the
|
||||
reason provenance recovery exists and cannot be identity evidence.
|
||||
"""
|
||||
entries = []
|
||||
for file_info in data.get("files", []):
|
||||
if not isinstance(file_info, dict):
|
||||
continue
|
||||
hashes = file_info.get("hashes", {})
|
||||
sha256 = hashes.get("SHA256") if isinstance(hashes, dict) else None
|
||||
if not sha256:
|
||||
continue
|
||||
|
||||
size_bytes = None
|
||||
try:
|
||||
if file_info.get("sizeKB") is not None:
|
||||
size_bytes = int(round(float(file_info["sizeKB"]) * 1024))
|
||||
except (TypeError, ValueError, OverflowError):
|
||||
pass
|
||||
entries.append((file_info, str(sha256), size_bytes))
|
||||
|
||||
if not entries:
|
||||
return None
|
||||
|
||||
try:
|
||||
physical_size = os.path.getsize(file_path)
|
||||
except OSError:
|
||||
physical_size = None
|
||||
|
||||
if physical_size is not None:
|
||||
size_matches = [entry for entry in entries if entry[2] == physical_size]
|
||||
if len(size_matches) == 1:
|
||||
return size_matches[0][0]
|
||||
if len(size_matches) > 1:
|
||||
return None
|
||||
|
||||
# Offline-generated metadata commonly contains one injected hash without
|
||||
# Civitai size/name data. It is safe only when there is a single candidate.
|
||||
if len(entries) == 1:
|
||||
return entries[0][0]
|
||||
return None
|
||||
|
||||
|
||||
def _select_info_hash(data, file_path):
|
||||
selected = _select_info_file(data, file_path)
|
||||
if not selected:
|
||||
return ""
|
||||
hashes = selected.get("hashes", {})
|
||||
return str(hashes.get("SHA256", "")) if isinstance(hashes, dict) else ""
|
||||
|
||||
|
||||
def _positive_civitai_id(value):
|
||||
"""Return a real Civitai identifier, excluding offline sentinel values."""
|
||||
if isinstance(value, bool):
|
||||
return None
|
||||
try:
|
||||
parsed = int(value)
|
||||
except (TypeError, ValueError, OverflowError):
|
||||
return None
|
||||
return parsed if parsed > 0 else None
|
||||
|
||||
def _read_metadata(file_path):
|
||||
base_path = os.path.splitext(file_path)[0]
|
||||
metadata = {
|
||||
"name": os.path.basename(base_path),
|
||||
"description": "",
|
||||
"notes": "",
|
||||
"trainedWords": [],
|
||||
"baseModel": "",
|
||||
"civitai_url": "",
|
||||
"source_url": "",
|
||||
"hash": "",
|
||||
"hash_algorithm": "sha256",
|
||||
"hash_scope": "file",
|
||||
"hash_source": "",
|
||||
"custom_name": "",
|
||||
"custom_notes": ""
|
||||
}
|
||||
|
||||
info_files = [f"{base_path}.info", f"{base_path}.civitai.info"]
|
||||
for info_file in info_files:
|
||||
if os.path.exists(info_file):
|
||||
try:
|
||||
with open(info_file, 'r', encoding='utf-8') as f:
|
||||
data = json.load(f)
|
||||
|
||||
name = data.get("name", "")
|
||||
if "model" in data and isinstance(data["model"], dict):
|
||||
model_name = data["model"].get("name", "")
|
||||
name = f"{model_name} - {name}".strip(' -')
|
||||
|
||||
description = data.get("description", "") or ""
|
||||
if not description and "model" in data and isinstance(data["model"], dict):
|
||||
description = data["model"].get("description", "")
|
||||
notes = data.get("notes", "")
|
||||
trained_words = data.get("trainedWords", [])
|
||||
base_model = data.get("baseModel", "")
|
||||
|
||||
model_id = _positive_civitai_id(data.get("modelId"))
|
||||
version_id = _positive_civitai_id(data.get("id"))
|
||||
civitai_url = ""
|
||||
if model_id is not None:
|
||||
# Handle Civitai's new mature content policy
|
||||
nsfw_level = data.get("nsfwLevel", 1)
|
||||
is_nsfw = False
|
||||
if "model" in data and isinstance(data["model"], dict):
|
||||
is_nsfw = data["model"].get("nsfw", False)
|
||||
|
||||
domain = "civitai.red" if (nsfw_level > 1 or is_nsfw) else "civitai.com"
|
||||
civitai_url = f"https://{domain}/models/{model_id}"
|
||||
if version_id is not None:
|
||||
civitai_url += f"?modelVersionId={version_id}"
|
||||
|
||||
|
||||
selected_file = _select_info_file(data, file_path)
|
||||
hash_val, hash_source = sidecar_file_hash(data, file_path, selected_file)
|
||||
if hash_val:
|
||||
metadata["hash_source"] = hash_source
|
||||
|
||||
if name: metadata["name"] = name
|
||||
if description: metadata["description"] = description
|
||||
if notes: metadata["notes"] = notes
|
||||
if trained_words: metadata["trainedWords"] = trained_words
|
||||
if base_model: metadata["baseModel"] = base_model
|
||||
if civitai_url: metadata["civitai_url"] = civitai_url
|
||||
if model_id is not None: metadata["model_id"] = model_id
|
||||
if version_id is not None: metadata["version_id"] = version_id
|
||||
if hash_val: metadata["hash"] = hash_val
|
||||
if "anomalous_custom_name" in data and data["anomalous_custom_name"]: metadata["custom_name"] = data["anomalous_custom_name"]
|
||||
if "anomalous_custom_notes" in data and data["anomalous_custom_notes"]: metadata["custom_notes"] = data["anomalous_custom_notes"]
|
||||
if "anomalous_source_url" in data and data["anomalous_source_url"]: metadata["source_url"] = data["anomalous_source_url"]
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return metadata
|
||||
|
||||
|
||||
def _file_signature(file_path):
|
||||
try:
|
||||
stat = os.stat(file_path)
|
||||
return (stat.st_size, stat.st_mtime_ns, stat.st_ctime_ns)
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
def _metadata_signature(file_path):
|
||||
base_path = os.path.splitext(file_path)[0]
|
||||
return (
|
||||
_file_signature(file_path),
|
||||
_file_signature(f"{base_path}.info"),
|
||||
_file_signature(f"{base_path}.civitai.info"),
|
||||
)
|
||||
|
||||
|
||||
@lru_cache(maxsize=4096)
|
||||
def _get_metadata_cached(file_path, signature):
|
||||
# ``signature`` is deliberately unused by the parser itself; it is part of
|
||||
# the cache key and changes whenever the model or either metadata sidecar
|
||||
# changes. The cache is bounded so removed/renamed models cannot grow it
|
||||
# without limit.
|
||||
return _read_metadata(file_path)
|
||||
|
||||
|
||||
def get_metadata(file_path):
|
||||
normalized_path = os.path.realpath(file_path)
|
||||
signature = _metadata_signature(normalized_path)
|
||||
# Metadata contains mutable lists. Never expose the cached object directly.
|
||||
return copy.deepcopy(_get_metadata_cached(normalized_path, signature))
|
||||
|
||||
|
||||
def clear_metadata_cache():
|
||||
_get_metadata_cached.cache_clear()
|
||||
|
||||
|
||||
def get_metadata_cache_info():
|
||||
return _get_metadata_cached.cache_info()
|
||||
try:
|
||||
from ..model_identity import USER_INFO_SUFFIX, is_unmatched, read_json, sidecar_file_hash, sidecar_info, unmatched_reason
|
||||
from ..model_sidecars import find
|
||||
except ImportError:
|
||||
from model_identity import USER_INFO_SUFFIX, is_unmatched, read_json, sidecar_file_hash, sidecar_info, unmatched_reason
|
||||
from model_sidecars import find
|
||||
from .model_heads import inspect as inspect_file # the header, read once per file version
|
||||
|
||||
# Fields the model editor sets: <model>.anomalous.json key -> metadata key.
|
||||
USER_FIELDS = {"custom_name": "custom_name", "custom_notes": "custom_notes", "source_url": "source_url"}
|
||||
|
||||
def _select_info_file(data, file_path):
|
||||
"""Select the Civitai file entry that actually describes ``file_path``.
|
||||
|
||||
A model version may contain a checkpoint, text encoder, and VAE in the same
|
||||
``files`` array. Taking the first SHA256 silently assigns the dependency's
|
||||
hash to every local sidecar copied from that version. Physical byte size is
|
||||
the strongest cheap discriminator available here and remains valid after a
|
||||
local rename. Filenames are intentionally excluded: local renames are the
|
||||
reason provenance recovery exists and cannot be identity evidence.
|
||||
"""
|
||||
entries = []
|
||||
for file_info in data.get("files", []):
|
||||
if not isinstance(file_info, dict):
|
||||
continue
|
||||
hashes = file_info.get("hashes", {})
|
||||
sha256 = hashes.get("SHA256") if isinstance(hashes, dict) else None
|
||||
if not sha256:
|
||||
continue
|
||||
|
||||
size_bytes = None
|
||||
try:
|
||||
if file_info.get("sizeKB") is not None:
|
||||
size_bytes = int(round(float(file_info["sizeKB"]) * 1024))
|
||||
except (TypeError, ValueError, OverflowError):
|
||||
pass
|
||||
entries.append((file_info, str(sha256), size_bytes))
|
||||
|
||||
if not entries:
|
||||
return None
|
||||
|
||||
try:
|
||||
physical_size = os.path.getsize(file_path)
|
||||
except OSError:
|
||||
physical_size = None
|
||||
|
||||
if physical_size is not None:
|
||||
size_matches = [entry for entry in entries if entry[2] == physical_size]
|
||||
if len(size_matches) == 1:
|
||||
return size_matches[0][0]
|
||||
if len(size_matches) > 1:
|
||||
return None
|
||||
|
||||
# Offline-generated metadata commonly contains one injected hash without
|
||||
# Civitai size/name data. It is safe only when there is a single candidate.
|
||||
if len(entries) == 1:
|
||||
return entries[0][0]
|
||||
return None
|
||||
|
||||
|
||||
def _select_info_hash(data, file_path):
|
||||
selected = _select_info_file(data, file_path)
|
||||
if not selected:
|
||||
return ""
|
||||
hashes = selected.get("hashes", {})
|
||||
return str(hashes.get("SHA256", "")) if isinstance(hashes, dict) else ""
|
||||
|
||||
|
||||
def _positive_civitai_id(value):
|
||||
"""Return a real Civitai identifier, excluding offline sentinel values."""
|
||||
if isinstance(value, bool):
|
||||
return None
|
||||
try:
|
||||
parsed = int(value)
|
||||
except (TypeError, ValueError, OverflowError):
|
||||
return None
|
||||
return parsed if parsed > 0 else None
|
||||
|
||||
def _info_base(file_path, base_path):
|
||||
"""Where the model's info files are read: beside the model as named; for a link with none
|
||||
beside it, beside the file it links to, where another tool (A1111's Civitai Helper) may
|
||||
have left them. Only read there: covers, edits and scans stay beside the link."""
|
||||
if os.path.islink(file_path) and not (find(base_path, ".info") or os.path.exists(base_path + ".civitai.info")):
|
||||
return os.path.splitext(os.path.realpath(file_path))[0]
|
||||
return base_path
|
||||
|
||||
|
||||
def _read_metadata(file_path):
|
||||
base_path = os.path.splitext(file_path)[0]
|
||||
info_base = _info_base(file_path, base_path)
|
||||
metadata = {
|
||||
"name": os.path.basename(base_path),
|
||||
"description": "",
|
||||
"notes": "",
|
||||
"trainedWords": [],
|
||||
"baseModel": "",
|
||||
"civitai_url": "",
|
||||
"source_url": "",
|
||||
"hash": "",
|
||||
"hash_algorithm": "sha256",
|
||||
"hash_scope": "file",
|
||||
"hash_source": "",
|
||||
"custom_name": "",
|
||||
"custom_notes": "",
|
||||
"version_name": "", # the Civitai version ("v2.0", "Illustrious"…), told apart on the card
|
||||
"base_guess": "", # no base model known yet (not scanned): what the file's header tells
|
||||
# "civitai" (matched), "local" (only what the file tells: no match, or offline) or "" (not scanned)
|
||||
"info_source": "",
|
||||
"unmatched_reason": "", # for "local": not_found | network | offline | "" (scanned before this was kept)
|
||||
"user_fields": [],
|
||||
"scan_choice": "", # the user's "skip" / "scan" (model_identity.scan_choice)
|
||||
"not_drawing": False, # not scanned yet, and its header looks like no drawing model
|
||||
}
|
||||
|
||||
info_files = [path for path in (find(info_base, ".info"), f"{info_base}.civitai.info") if path]
|
||||
for info_file in info_files:
|
||||
if os.path.exists(info_file):
|
||||
try:
|
||||
with open(info_file, 'r', encoding='utf-8') as f:
|
||||
data = json.load(f)
|
||||
|
||||
name = data.get("name", "")
|
||||
if "model" in data and isinstance(data["model"], dict):
|
||||
model_name = data["model"].get("name", "")
|
||||
# A model and version of one name (what the file alone tells) read once.
|
||||
name = f"{model_name} - {name}" if model_name and name and model_name != name else model_name or name
|
||||
|
||||
description = data.get("description", "") or ""
|
||||
if not description and "model" in data and isinstance(data["model"], dict):
|
||||
description = data["model"].get("description", "")
|
||||
notes = data.get("notes", "")
|
||||
trained_words = data.get("trainedWords", [])
|
||||
base_model = data.get("baseModel", "")
|
||||
|
||||
model_id = _positive_civitai_id(data.get("modelId"))
|
||||
version_id = _positive_civitai_id(data.get("id"))
|
||||
civitai_url = ""
|
||||
if model_id is not None:
|
||||
# Handle Civitai's new mature content policy
|
||||
nsfw_level = data.get("nsfwLevel", 1)
|
||||
is_nsfw = False
|
||||
if "model" in data and isinstance(data["model"], dict):
|
||||
is_nsfw = data["model"].get("nsfw", False)
|
||||
|
||||
domain = "civitai.red" if (nsfw_level > 1 or is_nsfw) else "civitai.com"
|
||||
civitai_url = f"https://{domain}/models/{model_id}"
|
||||
if version_id is not None:
|
||||
civitai_url += f"?modelVersionId={version_id}"
|
||||
|
||||
|
||||
selected_file = _select_info_file(data, file_path)
|
||||
hash_val, hash_source = sidecar_file_hash(data, file_path, selected_file)
|
||||
if hash_val:
|
||||
metadata["hash_source"] = hash_source
|
||||
|
||||
if name: metadata["name"] = name
|
||||
if description: metadata["description"] = description
|
||||
if notes: metadata["notes"] = notes
|
||||
if trained_words: metadata["trainedWords"] = trained_words
|
||||
if base_model: metadata["baseModel"] = base_model
|
||||
if civitai_url: metadata["civitai_url"] = civitai_url
|
||||
if model_id is not None: metadata["model_id"] = model_id
|
||||
if version_id is not None: metadata["version_id"] = version_id
|
||||
if version_id is not None and isinstance(data.get("model"), dict) and isinstance(data.get("name"), str):
|
||||
metadata["version_name"] = data["name"].strip()
|
||||
if hash_val: metadata["hash"] = hash_val
|
||||
if "anomalous_custom_name" in data and data["anomalous_custom_name"]: metadata["custom_name"] = data["anomalous_custom_name"]
|
||||
if "anomalous_custom_notes" in data and data["anomalous_custom_notes"]: metadata["custom_notes"] = data["anomalous_custom_notes"]
|
||||
if "anomalous_source_url" in data and data["anomalous_source_url"]: metadata["source_url"] = data["anomalous_source_url"]
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
scan = sidecar_info(info_base)
|
||||
if scan is not None:
|
||||
metadata["info_source"] = "local" if is_unmatched(scan) else "civitai"
|
||||
metadata["unmatched_reason"] = unmatched_reason(scan)
|
||||
if scan is None:
|
||||
found = inspect_file(file_path)
|
||||
if not metadata["baseModel"]:
|
||||
metadata["base_guess"] = found.get("base") or ""
|
||||
# A header that reads but names no drawing model kind (a voice model, say).
|
||||
metadata["not_drawing"] = found["format"] == "safetensors" and not found["kind"]
|
||||
# The user's own layer comes last and wins, also when a field was cleared on purpose ("").
|
||||
user_file = find(base_path, USER_INFO_SUFFIX)
|
||||
user = (read_json(user_file) if user_file else None) or {}
|
||||
if user.get("scan") in ("skip", "scan"):
|
||||
metadata["scan_choice"] = user["scan"]
|
||||
for key, field in USER_FIELDS.items():
|
||||
if isinstance(user.get(key), str):
|
||||
metadata[field] = user[key]
|
||||
metadata["user_fields"].append(field)
|
||||
return metadata
|
||||
|
||||
|
||||
def _file_signature(file_path):
|
||||
try:
|
||||
stat = os.stat(file_path)
|
||||
return (stat.st_size, stat.st_mtime_ns, stat.st_ctime_ns)
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
def _metadata_signature(file_path):
|
||||
base_path = os.path.splitext(file_path)[0]
|
||||
return (
|
||||
_file_signature(file_path),
|
||||
_file_signature(find(base_path, ".info") or f"{base_path}.info"),
|
||||
_file_signature(f"{base_path}.civitai.info"),
|
||||
_file_signature(find(base_path, USER_INFO_SUFFIX) or base_path + USER_INFO_SUFFIX),
|
||||
)
|
||||
|
||||
|
||||
@lru_cache(maxsize=4096)
|
||||
def _get_metadata_cached(file_path, signature):
|
||||
# ``signature`` is deliberately unused by the parser itself; it is part of
|
||||
# the cache key and changes whenever the model or either metadata sidecar
|
||||
# changes. The cache is bounded so removed/renamed models cannot grow it
|
||||
# without limit.
|
||||
return _read_metadata(file_path)
|
||||
|
||||
|
||||
def get_metadata(file_path):
|
||||
# As named, not resolved: a model that is a link has its covers and info beside the link.
|
||||
normalized_path = os.path.abspath(file_path)
|
||||
signature = _metadata_signature(normalized_path)
|
||||
# Metadata contains mutable lists. Never expose the cached object directly.
|
||||
return copy.deepcopy(_get_metadata_cached(normalized_path, signature))
|
||||
|
||||
|
||||
def clear_metadata_cache():
|
||||
_get_metadata_cached.cache_clear()
|
||||
|
||||
|
||||
def get_metadata_cache_info():
|
||||
return _get_metadata_cached.cache_info()
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,182 @@
|
||||
"""What Anomalous knows about using a model well, told to the AI so it need not guess:
|
||||
|
||||
- the settings its author's example pictures were made with (the Civitai record a scan keeps
|
||||
beside the file: images[].meta), summed up for get_model: how many pictures, the sampler and
|
||||
scheduler most used, the range of steps and CFG, the most used size and, for a LoRA, the
|
||||
weight it was used at: by its file hash, name or Civitai version, else the LoRA most of the
|
||||
pictures name (their names are the author's own files, and often an older version's);
|
||||
- whether a LoRA suits the main model it is put on: add_lora and set_model compare their base
|
||||
models (the scan's, else what the file's header tells) and say so when the families differ
|
||||
(an SD 1.5 LoRA on an SDXL checkpoint does nothing useful) or, more softly, when two bases of one
|
||||
family differ (a Pony LoRA on an Illustrious checkpoint). A note only: the call is made.
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
from collections import Counter
|
||||
|
||||
import folder_paths
|
||||
|
||||
from . import metadata
|
||||
|
||||
# Base model names (Civitai's, or what model_kind.py infers) by the architecture their files share.
|
||||
FAMILIES = (
|
||||
("SDXL", ("sdxl", "pony", "illustrious", "noob")), ("SD 1.x", ("sd 1",)), ("SD 2.x", ("sd 2",)),
|
||||
("SD 3", ("sd 3", "sd3")), ("Flux.1", ("flux.1", "flux 1", "chroma")), ("Flux.2", ("flux.2", "flux 2")),
|
||||
)
|
||||
# Bases trained far from their family's: a LoRA of one on another of the family loads but may look off.
|
||||
OWN_WAYS = ("pony", "illustrious", "noob", "chroma")
|
||||
MAIN_TYPES = ("checkpoints", "diffusion_models", "unet")
|
||||
MAX_EXAMPLES = 20
|
||||
|
||||
|
||||
def family(base):
|
||||
"""The architecture family of a base model name ("" when none is known)."""
|
||||
lowered = str(base or "").strip().lower()
|
||||
if not lowered or lowered in ("other", "unknown"):
|
||||
return ""
|
||||
for name, marks in FAMILIES:
|
||||
if lowered.startswith(marks):
|
||||
return name
|
||||
return lowered
|
||||
|
||||
|
||||
def base_of(file_path):
|
||||
"""A model file's base model: the scan's, else what its header tells."""
|
||||
meta = metadata.get_metadata(file_path)
|
||||
return meta.get("baseModel") or meta.get("base_guess") or ""
|
||||
|
||||
|
||||
def _main_base(value):
|
||||
"""The base model of a main loader's choice (its drop-down value), or ""."""
|
||||
for folder_type in MAIN_TYPES:
|
||||
try:
|
||||
path = folder_paths.get_full_path(folder_type, value)
|
||||
except (KeyError, TypeError):
|
||||
path = None
|
||||
if path:
|
||||
return base_of(path)
|
||||
return ""
|
||||
|
||||
|
||||
def lora_paths(values):
|
||||
"""The files of LoRA drop-down values that ComfyUI can find."""
|
||||
paths = []
|
||||
for value in values or []:
|
||||
try:
|
||||
path = folder_paths.get_full_path("loras", value)
|
||||
except (KeyError, TypeError):
|
||||
path = None
|
||||
if path:
|
||||
paths.append(path)
|
||||
return paths
|
||||
|
||||
|
||||
def lora_note(lora_path, line):
|
||||
"""A note when the LoRA at `lora_path` does not suit the main model of `line` (the page's
|
||||
{"model": the main loader's choice}), else None."""
|
||||
main = _main_base((line or {}).get("model") or "")
|
||||
lora = base_of(lora_path)
|
||||
if not main or not lora or main.lower() == lora.lower():
|
||||
return None
|
||||
if family(main) != family(lora):
|
||||
return (f"Base model clash: this LoRA is for {lora}, the main model ({line['model']}) is {main}; it will not "
|
||||
f"work as meant. Pick one with search_models(type='loras', base_model='{main}'), or remove it.")
|
||||
if lora.lower().startswith(OWN_WAYS) or main.lower().startswith(OWN_WAYS):
|
||||
return (f"This LoRA was made for {lora}, the main model is {main}: same family, so it loads, but it may "
|
||||
f"look weaker or off. search_models(type='loras', base_model='{main}') finds ones made for it.")
|
||||
return None
|
||||
|
||||
|
||||
def _number(value):
|
||||
try:
|
||||
number = float(str(value).strip())
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
return number if number == number and abs(number) < 1e6 else None
|
||||
|
||||
|
||||
def _span(numbers):
|
||||
"""'25' or '20–30' for a list of numbers, '' for none."""
|
||||
if not numbers:
|
||||
return ""
|
||||
low, high = min(numbers), max(numbers)
|
||||
say = lambda number: f"{number:g}"
|
||||
return say(low) if low == high else f"{say(low)}–{say(high)}"
|
||||
|
||||
|
||||
def _common(values, total):
|
||||
"""'euler (6 of 10)': the most used value and in how many of the `total` pictures."""
|
||||
counted = Counter(value for value in values if value)
|
||||
if not counted:
|
||||
return ""
|
||||
value, times = counted.most_common(1)[0]
|
||||
return str(value) if times == total else f"{value} ({times} of {total})"
|
||||
|
||||
|
||||
def _loras(meta):
|
||||
"""[(who, weight)] of the LoRAs one picture's settings name: who is a hash, a file name or "v<version>"."""
|
||||
found = []
|
||||
for item in meta.get("resources") or []:
|
||||
if isinstance(item, dict) and str(item.get("type", "")).lower() == "lora":
|
||||
found.append((str(item.get("hash") or item.get("name") or "").lower(), _number(item.get("weight"))))
|
||||
for item in meta.get("additionalResources") or []:
|
||||
if isinstance(item, dict) and str(item.get("type", "lora")).lower() == "lora":
|
||||
found.append((os.path.splitext(os.path.basename(str(item.get("name", ""))))[0].lower(), _number(item.get("strength"))))
|
||||
for item in meta.get("civitaiResources") or []:
|
||||
if isinstance(item, dict) and str(item.get("type", "")).lower() == "lora" and item.get("modelVersionId") is not None:
|
||||
found.append((f"v{item['modelVersionId']}", _number(item.get("weight"))))
|
||||
return [(who, weight) for who, weight in found if who and weight is not None]
|
||||
|
||||
|
||||
def _lora_weights(metas, own):
|
||||
"""The weights this LoRA was used at in its pictures: those naming it (`own`: its hash, file
|
||||
name, version), else the one LoRA most of them name; none when two are named as often."""
|
||||
per = [_loras(meta) for meta in metas]
|
||||
named = Counter(who for found in per for who in {who for who, _weight in found})
|
||||
mine = {who for who in named if who in own}
|
||||
if not mine:
|
||||
common = [(who, times) for who, times in named.most_common(2) if times * 5 >= len(metas) * 3]
|
||||
if common and (len(common) == 1 or common[0][1] > common[1][1]):
|
||||
mine = {common[0][0]}
|
||||
return [weight for found in per for who, weight in found if who in mine]
|
||||
|
||||
|
||||
def _record(file_path):
|
||||
"""The Civitai record kept beside the model (its .info), or None."""
|
||||
base_path = os.path.splitext(file_path)[0]
|
||||
info_base = metadata._info_base(file_path, base_path)
|
||||
for path in (metadata.find(info_base, ".info"), f"{info_base}.civitai.info"):
|
||||
if path and os.path.isfile(path):
|
||||
try:
|
||||
with open(path, encoding="utf-8") as handle:
|
||||
data = json.load(handle)
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
if isinstance(data, dict) and isinstance(data.get("images"), list):
|
||||
return data
|
||||
return None
|
||||
|
||||
|
||||
def author_examples(file_path, folder_type, sha256=""):
|
||||
"""What the author's example pictures were made with, summed up; {} when nothing is kept."""
|
||||
record = _record(file_path)
|
||||
metas = [image.get("meta") for image in (record or {}).get("images") or []
|
||||
if isinstance(image, dict) and isinstance(image.get("meta"), dict)][:MAX_EXAMPLES]
|
||||
if not metas:
|
||||
return {}
|
||||
sizes = [meta.get("Size") or (f"{meta['width']}x{meta['height']}" if meta.get("width") and meta.get("height") else "")
|
||||
for meta in metas]
|
||||
found = {
|
||||
"pictures": len(metas),
|
||||
"sampler": _common([str(meta.get("sampler") or "") for meta in metas if str(meta.get("sampler")).lower() != "undefined"], len(metas)),
|
||||
"scheduler": _common([str(meta.get("scheduler") or meta.get("Schedule type") or "") for meta in metas], len(metas)),
|
||||
"steps": _span([n for n in (_number(meta.get("steps")) for meta in metas) if n is not None]),
|
||||
"cfg": _span([n for n in (_number(meta.get("cfgScale")) for meta in metas) if n is not None]),
|
||||
"size": _common([str(size) for size in sizes], len(metas)),
|
||||
"clip_skip": _span([n for n in (_number(meta.get("clipSkip") or meta.get("Clip skip")) for meta in metas) if n is not None]),
|
||||
}
|
||||
if folder_type == "loras":
|
||||
own = {(sha256 or "")[:10].lower(), os.path.splitext(os.path.basename(file_path))[0].lower(), f"v{record.get('id')}"} - {""}
|
||||
found["lora_weight"] = _span(_lora_weights(metas, own))
|
||||
return {key: value for key, value in found.items() if value}
|
||||
+32
-131
@@ -1,7 +1,6 @@
|
||||
"""Model folder discovery, listing, search, and presentation lookup."""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import urllib.parse
|
||||
|
||||
@@ -9,13 +8,31 @@ from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
from .metadata import get_metadata
|
||||
from .model_constants import MEDIA_EXTENSIONS, MODEL_EXTENSIONS, PREVIEW_SUFFIXES
|
||||
try:
|
||||
from ..model_sidecars import HIDDEN_DIR
|
||||
except ImportError:
|
||||
from model_sidecars import HIDDEN_DIR
|
||||
from .model_constants import MEDIA_EXTENSIONS, PREVIEW_SUFFIXES, is_model_file
|
||||
from .model_media import _cache_token, _preview_url_for_model
|
||||
from .folder_types import (
|
||||
get_active_folder_types, get_active_model_roots,
|
||||
get_active_physical_basenames, get_folder_view_mode,
|
||||
)
|
||||
from .path_utils import resolve_folder_subdir
|
||||
from .path_utils import model_reference_within, resolve_folder_subdir
|
||||
|
||||
def _folder_tree(base_dir):
|
||||
"""{'/'-relative folder: {path, name, has_models, model_count}} under a model root; the
|
||||
.amb folders hold side files only (model_sidecars)."""
|
||||
tree = {}
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
dirs[:] = [name for name in dirs if name != HIDDEN_DIR]
|
||||
count = sum(1 for f in files if is_model_file(f))
|
||||
rel = os.path.relpath(root, base_dir)
|
||||
rel = '/' if rel == '.' else '/' + rel.replace('\\', '/')
|
||||
tree[rel] = {"path": rel, "name": os.path.basename(root) if rel != '/' else '[Root]',
|
||||
"has_models": count > 0, "model_count": count}
|
||||
return tree
|
||||
|
||||
|
||||
def _collect_folder_models(target_dir, folder_type, path_idx, rel_subfolder, page, limit):
|
||||
"""Collect one folder in a worker thread with a single directory listing."""
|
||||
@@ -32,7 +49,7 @@ def _collect_folder_models(target_dir, folder_type, path_idx, rel_subfolder, pag
|
||||
return {"models": [], "total": 0, "page": page, "limit": limit}
|
||||
|
||||
valid_files = sorted(
|
||||
(name for name in file_entries if name.endswith(('.safetensors', '.ckpt', '.pt'))),
|
||||
(name for name in file_entries if is_model_file(name)),
|
||||
key=str.lower,
|
||||
)
|
||||
total = len(valid_files)
|
||||
@@ -121,20 +138,7 @@ def _collect_folders():
|
||||
|
||||
for item in matched:
|
||||
base_dir = item["base_dir"]
|
||||
tree = {}
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
has_models = any(f.endswith(('.safetensors', '.ckpt', '.pt')) for f in files)
|
||||
rel = os.path.relpath(root, base_dir)
|
||||
if rel == '.':
|
||||
rel = '/'
|
||||
else:
|
||||
rel = '/' + rel.replace('\\', '/')
|
||||
tree[rel] = {
|
||||
"path": rel,
|
||||
"name": os.path.basename(root) if rel != '/' else '[Root]',
|
||||
"has_models": has_models,
|
||||
"model_count": sum(1 for f in files if f.endswith(('.safetensors', '.ckpt', '.pt')))
|
||||
}
|
||||
tree = _folder_tree(base_dir)
|
||||
|
||||
label = item["bn"]
|
||||
if len(matched) > 1:
|
||||
@@ -164,20 +168,7 @@ def _collect_folders():
|
||||
continue
|
||||
seen_dirs.add(real_path)
|
||||
|
||||
tree = {}
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
has_models = any(f.endswith(('.safetensors', '.ckpt', '.pt')) for f in files)
|
||||
rel = os.path.relpath(root, base_dir)
|
||||
if rel == '.':
|
||||
rel = '/'
|
||||
else:
|
||||
rel = '/' + rel.replace('\\', '/')
|
||||
tree[rel] = {
|
||||
"path": rel,
|
||||
"name": os.path.basename(root) if rel != '/' else '[Root]',
|
||||
"has_models": has_models,
|
||||
"model_count": sum(1 for f in files if f.endswith(('.safetensors', '.ckpt', '.pt')))
|
||||
}
|
||||
tree = _folder_tree(base_dir)
|
||||
|
||||
try:
|
||||
folder_basename = os.path.basename(os.path.normpath(base_dir))
|
||||
@@ -253,7 +244,7 @@ def _iter_search_models():
|
||||
continue
|
||||
for root, _, files in os.walk(base_dir):
|
||||
for filename in files:
|
||||
if filename.lower().endswith(MODEL_EXTENSIONS + ('.sft',)):
|
||||
if is_model_file(filename):
|
||||
yield folder_type, path_idx, base_dir, os.path.join(root, filename)
|
||||
|
||||
|
||||
@@ -310,7 +301,7 @@ def _walk_model_files(target_types):
|
||||
continue
|
||||
for root, _, files in os.walk(base_dir):
|
||||
for filename in files:
|
||||
if not filename.lower().endswith(MODEL_EXTENSIONS):
|
||||
if not is_model_file(filename):
|
||||
continue
|
||||
file_path = os.path.join(root, filename)
|
||||
real_path = os.path.realpath(file_path)
|
||||
@@ -448,15 +439,14 @@ def _resolve_paths_to_model_info_sync(paths, folder_types=None, exact_only=False
|
||||
real_base_dir = os.path.realpath(base_dir)
|
||||
roots.append((folder_type, path_idx, real_base_dir))
|
||||
for original, _, relative_path in requested:
|
||||
relative = relative_path.replace('/', os.sep)
|
||||
candidate = os.path.realpath(os.path.join(real_base_dir, relative))
|
||||
try:
|
||||
if os.path.commonpath((real_base_dir, candidate)) != real_base_dir:
|
||||
continue
|
||||
candidate = model_reference_within(real_base_dir, relative_path.replace('/', os.sep))
|
||||
except ValueError:
|
||||
continue
|
||||
if os.path.isfile(candidate) and candidate.lower().endswith(('.safetensors', '.ckpt', '.pt', '.bin', '.sft')):
|
||||
exact_results[original] = _model_info_for_path(folder_type, path_idx, base_dir, candidate)
|
||||
if os.path.isfile(candidate) and is_model_file(candidate):
|
||||
# The candidate lies under the real folder: a folder that is a link (a junction
|
||||
# to another drive, a short 8.3 name) would give a subfolder of "../.." or fail.
|
||||
exact_results[original] = _model_info_for_path(folder_type, path_idx, real_base_dir, candidate)
|
||||
|
||||
unresolved = [(original, normalized) for original, normalized, _ in requested if original not in exact_results]
|
||||
if exact_only or not unresolved:
|
||||
@@ -469,7 +459,7 @@ def _resolve_paths_to_model_info_sync(paths, folder_types=None, exact_only=False
|
||||
for folder_type, path_idx, base_dir in roots:
|
||||
for root, _, files in os.walk(base_dir):
|
||||
for filename in files:
|
||||
if not filename.lower().endswith(('.safetensors', '.ckpt', '.pt', '.bin', '.sft')):
|
||||
if not is_model_file(filename):
|
||||
continue
|
||||
rel_path = os.path.relpath(os.path.join(root, filename), base_dir).replace(os.sep, '/').lower()
|
||||
basename = filename.lower()
|
||||
@@ -542,7 +532,6 @@ async def api_resolve_paths_to_previews(request):
|
||||
|
||||
|
||||
def _collect_all_scan_models(page, limit):
|
||||
source_library_extensions = {'.safetensors', '.ckpt', '.pt', '.pth', '.bin', '.sft', '.gguf'}
|
||||
all_tuples = []
|
||||
for model_root in get_active_model_roots():
|
||||
t = model_root["type"]
|
||||
@@ -550,7 +539,7 @@ def _collect_all_scan_models(page, limit):
|
||||
base_dir = model_root["base_dir"]
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
for f in files:
|
||||
if os.path.splitext(f)[1].lower() in source_library_extensions:
|
||||
if is_model_file(f):
|
||||
all_tuples.append((t, path_idx, root, base_dir, f))
|
||||
|
||||
all_tuples.sort(key=lambda x: (x[0], x[4].lower()))
|
||||
@@ -602,91 +591,3 @@ async def api_get_all_scan_models(request):
|
||||
limit = int(request.query.get('limit', 0))
|
||||
payload = await asyncio.to_thread(_collect_all_scan_models, page, limit)
|
||||
return web.json_response(payload)
|
||||
|
||||
|
||||
async def api_batch_select(request):
|
||||
folder_key = request.query.get('folderKey', 'ALL')
|
||||
action = request.query.get('action', 'all')
|
||||
|
||||
def matches_condition(file_path, root, base_name):
|
||||
if action == 'all':
|
||||
return True
|
||||
elif action == 'no_preview':
|
||||
for ext in PREVIEW_SUFFIXES + MEDIA_EXTENSIONS:
|
||||
if os.path.exists(os.path.join(root, base_name + ext)):
|
||||
return False
|
||||
return True
|
||||
elif action == 'no_desc':
|
||||
info_file = file_path + '.info'
|
||||
civitai_info = os.path.join(root, base_name + '.civitai.info')
|
||||
if os.path.exists(civitai_info):
|
||||
try:
|
||||
with open(civitai_info, 'r', encoding='utf-8') as f:
|
||||
data = json.load(f)
|
||||
if data.get('description', '').strip():
|
||||
return False
|
||||
except: pass
|
||||
if os.path.exists(info_file):
|
||||
try:
|
||||
with open(info_file, 'r', encoding='utf-8') as f:
|
||||
data = json.load(f)
|
||||
if data.get('description', '').strip():
|
||||
return False
|
||||
except: pass
|
||||
return True
|
||||
return False
|
||||
|
||||
results = {}
|
||||
|
||||
if folder_key == 'ALL':
|
||||
target_types = get_active_folder_types()
|
||||
seen_dirs = set()
|
||||
for t in target_types:
|
||||
try: paths = folder_paths.get_folder_paths(t)
|
||||
except Exception: continue
|
||||
if not paths: continue
|
||||
for path_idx, base_dir in enumerate(paths):
|
||||
if base_dir in seen_dirs: continue
|
||||
seen_dirs.add(base_dir)
|
||||
if not os.path.exists(base_dir): continue
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
for f in files:
|
||||
if f.endswith(('.safetensors', '.ckpt', '.pt', '.bin', '.sft')):
|
||||
file_path = os.path.join(root, f)
|
||||
base_name = os.path.splitext(f)[0]
|
||||
if matches_condition(file_path, root, base_name):
|
||||
rel_subfolder = os.path.relpath(root, base_dir)
|
||||
if rel_subfolder == '.': rel_subfolder = ''
|
||||
else: rel_subfolder = rel_subfolder.replace('\\', '/')
|
||||
fkey = f"{t}|{path_idx}|{rel_subfolder}"
|
||||
if fkey not in results: results[fkey] = []
|
||||
results[fkey].append(f)
|
||||
else:
|
||||
parts = folder_key.split('|')
|
||||
if len(parts) >= 3:
|
||||
t = parts[0]
|
||||
path_idx = int(parts[1])
|
||||
subfolder = parts[2]
|
||||
|
||||
try: paths = folder_paths.get_folder_paths(t)
|
||||
except Exception: paths = []
|
||||
|
||||
if paths and path_idx < len(paths):
|
||||
try:
|
||||
base_dir, target_dir = resolve_folder_subdir(t, path_idx, subfolder)
|
||||
except ValueError:
|
||||
return web.json_response({"selected": {}})
|
||||
|
||||
if os.path.exists(target_dir):
|
||||
try: entries = os.listdir(target_dir)
|
||||
except: entries = []
|
||||
for f in entries:
|
||||
if f.endswith(('.safetensors', '.ckpt', '.pt', '.bin', '.sft')):
|
||||
file_path = os.path.join(target_dir, f)
|
||||
if os.path.isfile(file_path):
|
||||
base_name = os.path.splitext(f)[0]
|
||||
if matches_condition(file_path, target_dir, base_name):
|
||||
if folder_key not in results: results[folder_key] = []
|
||||
results[folder_key].append(f)
|
||||
|
||||
return web.json_response({"selected": results})
|
||||
|
||||
+10
-3
@@ -1,16 +1,23 @@
|
||||
"""Shared model catalog, media, and recovery constants."""
|
||||
|
||||
MEDIA_EXTENSIONS = ('.png', '.jpg', '.jpeg', '.webp', '.gif', '.avif', '.mp4', '.webm', '.mov', '.avi')
|
||||
MODEL_EXTENSIONS = ('.safetensors', '.ckpt', '.pt', '.bin')
|
||||
# Model files the browser lists, counts and looks up: GGUF and .pth too (quantized
|
||||
# diffusion models, upscalers). Compared without case: see is_model_file().
|
||||
MODEL_EXTENSIONS = ('.safetensors', '.ckpt', '.pt', '.pth', '.bin', '.sft', '.gguf')
|
||||
PREVIEW_SUFFIXES = tuple(f'.preview{ext}' for ext in MEDIA_EXTENSIONS)
|
||||
CIVITAI_BACKUP_SUFFIXES = tuple(f'.civitai_bak{ext}' for ext in MEDIA_EXTENSIONS)
|
||||
SIDECAR_SUFFIXES = (
|
||||
'.info', '.civitai.info', '.json', '.txt', '.yaml',
|
||||
'.info', '.civitai.info', '.anomalous.json', '.json', '.txt', '.yaml',
|
||||
*MEDIA_EXTENSIONS,
|
||||
*PREVIEW_SUFFIXES,
|
||||
*CIVITAI_BACKUP_SUFFIXES,
|
||||
)
|
||||
RESOLVABLE_MODEL_TYPES = (
|
||||
'checkpoints', 'loras', 'unet', 'diffusion_models', 'controlnet',
|
||||
'vae', 'vae_approx', 'clip', 'text_encoders', 'clip_vision',
|
||||
'vae', 'vae_approx', 'clip', 'text_encoders', 'clip_vision', 'upscale_models',
|
||||
)
|
||||
|
||||
|
||||
def is_model_file(name):
|
||||
"""Whether a file name is a model file (MODEL_EXTENSIONS, any case)."""
|
||||
return name.lower().endswith(MODEL_EXTENSIONS)
|
||||
|
||||
@@ -0,0 +1,444 @@
|
||||
"""Downloading the models the open workflow is missing (Model Check's "Download").
|
||||
|
||||
POST /anomalous/download/lookup {items: [{key, hash, url, value, types}]} -> where each can come
|
||||
from (download_sources.find_source) and the model folders of its type: [{index, path, free,
|
||||
subfolders}].
|
||||
POST /anomalous/download/start {download_url, type, root, rel, sha256, size, ...} -> {id}
|
||||
GET /anomalous/download/status -> {jobs}
|
||||
POST /anomalous/download/cancel {id}
|
||||
GET/POST /anomalous/download/settings -> where downloads go ({place, folder}), kept in
|
||||
user/anomalous/download_settings.json; imported models (model_import.py) follow the same folder.
|
||||
|
||||
One download runs at a time, into "<file>.part" next to where the file goes; an interrupted one
|
||||
continues from there. The finished file is checked against the SHA-256 the workflow or the site
|
||||
gives, and only then gets its name; a file that is already there is never replaced. The Civitai
|
||||
key goes only to Civitai (not along a redirect to its file storage).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
from . import hf_card, manager_catalog
|
||||
from .activity_log import add_entry, log_path
|
||||
from .download_sources import (
|
||||
SHA256, USER_AGENT, allowed_download_url, find_source, host_of, is_civitai, same_file, _load_api_key,
|
||||
)
|
||||
from .path_utils import atomic_write_json, resolve_within
|
||||
|
||||
try:
|
||||
from ..net_proxy import urlopen
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from net_proxy import urlopen
|
||||
|
||||
MODEL_EXTENSIONS = (".safetensors", ".ckpt", ".pt", ".pth", ".bin", ".sft", ".gguf")
|
||||
CHUNK = 1024 * 1024
|
||||
SPACE_MARGIN = 200 * 1024 * 1024
|
||||
MAX_SUBFOLDERS = 300
|
||||
KEEP_FINISHED = 50
|
||||
# hf_mirror None: not chosen yet (the page takes the mirror for a Chinese interface).
|
||||
DEFAULT_SETTINGS = {"place": "workflow", "folder": "{base}", "hf_mirror": None}
|
||||
|
||||
_lock = threading.Lock()
|
||||
_jobs = {} # id -> job dict, in the order started
|
||||
_queue = []
|
||||
_worker = None
|
||||
|
||||
|
||||
class DownloadError(Exception):
|
||||
def __init__(self, code, message=""):
|
||||
super().__init__(message or code)
|
||||
self.code = code
|
||||
|
||||
|
||||
async def _body(request):
|
||||
"""The request's JSON object, or {} when it is not one (each route then refuses it)."""
|
||||
try:
|
||||
data = await request.json()
|
||||
except ValueError:
|
||||
return {}
|
||||
return data if isinstance(data, dict) else {}
|
||||
|
||||
|
||||
# --- settings ---------------------------------------------------------------------------
|
||||
|
||||
def settings_path():
|
||||
return os.path.join(os.path.dirname(log_path()), "download_settings.json")
|
||||
|
||||
|
||||
def read_settings():
|
||||
settings = dict(DEFAULT_SETTINGS)
|
||||
try:
|
||||
with open(settings_path(), encoding="utf-8") as source:
|
||||
saved = json.load(source)
|
||||
if saved.get("place") in ("workflow", "folder"):
|
||||
settings["place"] = saved["place"]
|
||||
if isinstance(saved.get("folder"), str):
|
||||
settings["folder"] = saved["folder"]
|
||||
if isinstance(saved.get("hf_mirror"), bool):
|
||||
settings["hf_mirror"] = saved["hf_mirror"]
|
||||
except (OSError, ValueError, AttributeError):
|
||||
pass
|
||||
return settings
|
||||
|
||||
|
||||
def clean_folder(folder):
|
||||
"""A relative folder ('' = the type's own folder), '/' separated; ValueError if it climbs out."""
|
||||
parts = [part.strip() for part in str(folder or "").replace("\\", "/").split("/") if part.strip()]
|
||||
for part in parts:
|
||||
if part in (".", "..") or ":" in part or any(char in part for char in '<>"|?*'):
|
||||
raise ValueError("Invalid folder")
|
||||
return "/".join(parts)
|
||||
|
||||
|
||||
async def api_settings(request):
|
||||
if request.method == "POST":
|
||||
data = await _body(request)
|
||||
settings = read_settings()
|
||||
if data.get("place") in ("workflow", "folder"):
|
||||
settings["place"] = data["place"]
|
||||
if isinstance(data.get("hf_mirror"), bool):
|
||||
settings["hf_mirror"] = data["hf_mirror"]
|
||||
if "folder" in data:
|
||||
try:
|
||||
# {base} is filled with the model's base model when a download starts.
|
||||
settings["folder"] = clean_folder(data.get("folder"))
|
||||
except ValueError:
|
||||
return web.json_response({"error": "Invalid folder"}, status=400)
|
||||
atomic_write_json(settings_path(), settings)
|
||||
return web.json_response(settings)
|
||||
return web.json_response(read_settings())
|
||||
|
||||
|
||||
# --- lookup -----------------------------------------------------------------------------
|
||||
|
||||
def folder_type_for(types):
|
||||
known = getattr(folder_paths, "folder_names_and_paths", {})
|
||||
for name in types or []:
|
||||
if isinstance(name, str) and name in known:
|
||||
return name
|
||||
return ""
|
||||
|
||||
|
||||
def _subfolders(root):
|
||||
found = []
|
||||
for current, dirs, _files in os.walk(root):
|
||||
dirs[:] = sorted(name for name in dirs if not name.startswith("."))
|
||||
depth = os.path.relpath(current, root).count(os.sep)
|
||||
for name in dirs:
|
||||
found.append(os.path.relpath(os.path.join(current, name), root).replace(os.sep, "/"))
|
||||
if len(found) >= MAX_SUBFOLDERS:
|
||||
return found
|
||||
if depth >= 1:
|
||||
dirs[:] = []
|
||||
return found
|
||||
|
||||
|
||||
def roots_of(folder_type):
|
||||
"""The model folders of a type: [{index, path, exists, free, subfolders}]."""
|
||||
roots = []
|
||||
for index, path in enumerate(folder_paths.get_folder_paths(folder_type) or []):
|
||||
exists = os.path.isdir(path)
|
||||
probe = path if exists else os.path.dirname(path)
|
||||
try:
|
||||
free = shutil.disk_usage(probe).free if os.path.isdir(probe) else 0
|
||||
except OSError:
|
||||
free = 0
|
||||
roots.append({"index": index, "path": path, "exists": exists, "free": free,
|
||||
"subfolders": _subfolders(path) if exists else []})
|
||||
return roots
|
||||
|
||||
|
||||
def lookup_item(item, hf_mirror=False, down=None):
|
||||
"""Where one item can come from; `down` (kept across one lookup) names the sites that
|
||||
stopped answering, so the next items skip only those."""
|
||||
file_hash = str(item.get("hash") or "").strip()
|
||||
name = os.path.basename(str(item.get("value") or "").replace("\\", "/"))
|
||||
found = find_source(file_hash, str(item.get("url") or "").strip(), name, hf_mirror,
|
||||
folder_type_for(item.get("types")), down)
|
||||
if found.get("found") and file_hash and found.get("sha256") and len(file_hash) >= 10 \
|
||||
and all(c in "0123456789abcdefABCDEF" for c in file_hash) and not same_file(file_hash, found["sha256"]):
|
||||
# The link names another file than the one the workflow was saved with.
|
||||
return {"found": False, "reason": "different_file", "page": found.get("page", "")}
|
||||
return found
|
||||
|
||||
|
||||
async def api_lookup(request):
|
||||
"""Items already looked up (`known`) only get their type and folders. Once a site does not
|
||||
answer, the rest do not ask it (offline: no wait per model); the other sites still are."""
|
||||
data = await _body(request)
|
||||
items, hf_mirror = data.get("items"), data.get("hf_mirror") is True
|
||||
if not isinstance(items, list):
|
||||
return web.json_response({"error": "items must be a list"}, status=400)
|
||||
results, types, down = [], {}, set()
|
||||
for item in items[:100]:
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
folder_type = folder_type_for(item.get("types"))
|
||||
if item.get("known"):
|
||||
result = {"found": False, "reason": "known"}
|
||||
else:
|
||||
result = await asyncio.to_thread(lookup_item, item, hf_mirror, down)
|
||||
result.update(key=item.get("key"), type=folder_type)
|
||||
if folder_type and folder_type not in types:
|
||||
types[folder_type] = await asyncio.to_thread(roots_of, folder_type)
|
||||
results.append(result)
|
||||
# Whether ComfyUI-Manager's model list is here: without it, Model Check says it is one more source.
|
||||
manager_list = bool(await asyncio.to_thread(manager_catalog.list_path))
|
||||
return web.json_response({"results": results, "roots": types, "settings": read_settings(), "manager_list": manager_list})
|
||||
|
||||
|
||||
# --- downloads --------------------------------------------------------------------------
|
||||
|
||||
def _public(job):
|
||||
public = {key: job[key] for key in ("id", "key", "state", "error", "received", "total", "rel", "type",
|
||||
"root", "value", "file", "source", "verified")}
|
||||
public["host"] = host_of(job["url"])
|
||||
return public
|
||||
|
||||
|
||||
def plan_job(data):
|
||||
"""A queued job from a start request, or ValueError / DownloadError saying why not."""
|
||||
url = str(data.get("download_url") or "")
|
||||
if not allowed_download_url(url):
|
||||
raise DownloadError("bad_source")
|
||||
folder_type = folder_type_for([data.get("type")])
|
||||
if not folder_type:
|
||||
raise DownloadError("bad_type")
|
||||
paths = folder_paths.get_folder_paths(folder_type) or []
|
||||
root_index = data.get("root", 0)
|
||||
if not isinstance(root_index, int) or not 0 <= root_index < len(paths):
|
||||
raise DownloadError("bad_root")
|
||||
rel = clean_folder(data.get("rel"))
|
||||
if not rel.lower().endswith(MODEL_EXTENSIONS):
|
||||
raise DownloadError("bad_name")
|
||||
root = os.path.realpath(paths[root_index])
|
||||
dest = resolve_within(root, *rel.split("/"))
|
||||
if os.path.exists(dest):
|
||||
raise DownloadError("exists")
|
||||
size = int(data.get("size") or 0)
|
||||
probe = root
|
||||
while probe and not os.path.isdir(probe):
|
||||
probe = os.path.dirname(probe)
|
||||
if size and probe and shutil.disk_usage(probe).free < size + SPACE_MARGIN:
|
||||
raise DownloadError("no_space")
|
||||
sha256 = str(data.get("sha256") or "").lower()
|
||||
with _lock:
|
||||
if any(job["dest"] == dest and job["state"] in ("queued", "running", "verifying") for job in _jobs.values()):
|
||||
raise DownloadError("already")
|
||||
return {
|
||||
"id": uuid.uuid4().hex[:12], "key": str(data.get("key") or ""), "state": "queued", "error": "",
|
||||
"received": 0, "total": size, "rel": rel, "type": folder_type, "root": root_index,
|
||||
"value": str(data.get("value") or ""), "file": os.path.basename(dest), "dest": dest, "url": url,
|
||||
"sha256": sha256 if SHA256.match(sha256) else "", "expected": str(data.get("hash") or "").lower(),
|
||||
"source": str(data.get("source") or ""), "page": str(data.get("page") or ""),
|
||||
"verified": False, "cancel": False, "finished": 0,
|
||||
}
|
||||
|
||||
|
||||
def _open(job, start):
|
||||
headers = {"User-Agent": USER_AGENT}
|
||||
if start:
|
||||
headers["Range"] = f"bytes={start}-"
|
||||
request = urllib.request.Request(job["url"], headers=headers)
|
||||
key = _load_api_key() if is_civitai(job["url"]) else None
|
||||
if key: # not carried along the redirect to the file storage
|
||||
request.add_unredirected_header("Authorization", f"Bearer {key}")
|
||||
try:
|
||||
return urlopen(request, timeout=60)
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code in (401, 403):
|
||||
raise DownloadError("needs_key" if is_civitai(job["url"]) and not key else "forbidden") from error
|
||||
if error.code == 404:
|
||||
raise DownloadError("gone") from error
|
||||
if error.code == 416 and start:
|
||||
raise DownloadError("restart") from error
|
||||
raise DownloadError("network", f"HTTP {error.code}") from error
|
||||
except (urllib.error.URLError, OSError) as error:
|
||||
raise DownloadError("network", str(error)) from error
|
||||
|
||||
|
||||
def _hash_existing(path, digest):
|
||||
with open(path, "rb") as source:
|
||||
for chunk in iter(lambda: source.read(CHUNK), b""):
|
||||
digest.update(chunk)
|
||||
|
||||
|
||||
def _fetch(job):
|
||||
part = job["dest"] + ".part"
|
||||
os.makedirs(os.path.dirname(job["dest"]), exist_ok=True)
|
||||
digest = hashlib.sha256()
|
||||
start = os.path.getsize(part) if os.path.isfile(part) else 0
|
||||
try:
|
||||
response = _open(job, start)
|
||||
except DownloadError as error:
|
||||
if error.code != "restart":
|
||||
raise
|
||||
start, response = 0, _open(job, 0)
|
||||
with response:
|
||||
if start and response.status != 206:
|
||||
start = 0 # the site sends the whole file again
|
||||
if "text/html" in str(response.headers.get("Content-Type", "")).lower():
|
||||
raise DownloadError("not_a_file") # a login or error page, not the model
|
||||
if start:
|
||||
_hash_existing(part, digest)
|
||||
length = int(response.headers.get("Content-Length") or 0)
|
||||
job["total"] = start + length if length else job["total"]
|
||||
job["received"] = start
|
||||
with open(part, "ab" if start else "wb") as target:
|
||||
while True:
|
||||
if job["cancel"]:
|
||||
raise DownloadError("cancelled")
|
||||
chunk = response.read(CHUNK)
|
||||
if not chunk:
|
||||
break
|
||||
target.write(chunk)
|
||||
digest.update(chunk)
|
||||
job["received"] += len(chunk)
|
||||
return part, digest.hexdigest()
|
||||
|
||||
|
||||
def _finish(job, part, sha256):
|
||||
job["state"] = "verifying"
|
||||
if job["total"] and job["received"] != job["total"]:
|
||||
raise DownloadError("network", "incomplete")
|
||||
expected = job["sha256"] or (job["expected"] if len(job["expected"]) >= 10 else "")
|
||||
if expected and not same_file(expected, sha256):
|
||||
os.remove(part) # our own unfinished download, not a file of the user's
|
||||
raise DownloadError("hash_mismatch")
|
||||
job["verified"] = bool(expected)
|
||||
if os.path.exists(job["dest"]):
|
||||
raise DownloadError("exists")
|
||||
os.replace(part, job["dest"])
|
||||
if host_of(job["url"]) in ("huggingface.co", "hf-mirror.com"):
|
||||
try: # the model card's example image as cover, its words as notes (never over the user's)
|
||||
job["card"] = hf_card.enrich(job["dest"], job["url"])
|
||||
except Exception as error:
|
||||
print(f"[Anomalous Browser] Download: the Hugging Face model card was not read: {error}")
|
||||
forget_file_lists()
|
||||
|
||||
|
||||
def forget_file_lists():
|
||||
"""ComfyUI's file lists and the browser's model metadata see a file that just arrived
|
||||
(a download, an import)."""
|
||||
for cache in (getattr(folder_paths, "filename_list_cache", None), getattr(folder_paths, "cache_helper", None)):
|
||||
try:
|
||||
cache.clear()
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
from .metadata import clear_metadata_cache
|
||||
clear_metadata_cache()
|
||||
except Exception as error:
|
||||
print(f"[Anomalous Browser] Could not clear the model cache: {error}")
|
||||
|
||||
|
||||
def _record(job, sha256):
|
||||
add_entry("file", "model_download", job["rel"], {"download": {
|
||||
"type": job["type"], "path_idx": job["root"], "rel": job["rel"], "file": job["file"],
|
||||
"size": job["received"], "sha256": sha256, "verified": job["verified"],
|
||||
"source": job["source"], "page": job["page"], "value": job["value"], "card": job.get("card"),
|
||||
}})
|
||||
|
||||
|
||||
def run_job(job):
|
||||
job["state"] = "running"
|
||||
try:
|
||||
part, sha256 = _fetch(job)
|
||||
_finish(job, part, sha256)
|
||||
job["state"] = "done"
|
||||
try:
|
||||
_record(job, sha256)
|
||||
except Exception as error:
|
||||
print(f"[Anomalous Browser] Download: could not record it in the activity log: {error}")
|
||||
except DownloadError as error:
|
||||
job["state"] = "cancelled" if error.code == "cancelled" else "failed"
|
||||
job["error"] = error.code
|
||||
if error.code == "cancelled" and os.path.isfile(job["dest"] + ".part"):
|
||||
os.remove(job["dest"] + ".part") # our own unfinished download
|
||||
if error.code not in ("cancelled",):
|
||||
print(f"[Anomalous Browser] Download of {job['rel']} failed: {error}")
|
||||
except Exception as error:
|
||||
job["state"], job["error"] = "failed", "unknown"
|
||||
print(f"[Anomalous Browser] Download of {job['rel']} failed: {error}")
|
||||
job["finished"] = time.time()
|
||||
|
||||
|
||||
def _work():
|
||||
global _worker
|
||||
while True:
|
||||
with _lock:
|
||||
job = next((item for item in _queue if item["state"] == "queued"), None)
|
||||
if job is None:
|
||||
_queue.clear()
|
||||
_worker = None
|
||||
return
|
||||
_queue.remove(job)
|
||||
run_job(job)
|
||||
|
||||
|
||||
def enqueue(job):
|
||||
global _worker
|
||||
with _lock:
|
||||
_jobs[job["id"]] = job
|
||||
_queue.append(job)
|
||||
finished = [item for item in _jobs.values() if item["finished"]]
|
||||
for old in finished[:-KEEP_FINISHED]:
|
||||
_jobs.pop(old["id"], None)
|
||||
if _worker is None:
|
||||
_worker = threading.Thread(target=_work, daemon=True, name="anomalous-download")
|
||||
_worker.start()
|
||||
|
||||
|
||||
async def api_start(request):
|
||||
data = await _body(request)
|
||||
if not data:
|
||||
return web.json_response({"error": "bad_request"}, status=400)
|
||||
try:
|
||||
job = await asyncio.to_thread(plan_job, data)
|
||||
except DownloadError as error:
|
||||
return web.json_response({"error": error.code}, status=409 if error.code in ("exists", "already") else 400)
|
||||
except (ValueError, TypeError) as error:
|
||||
return web.json_response({"error": "bad_path", "message": str(error)}, status=400)
|
||||
enqueue(job)
|
||||
return web.json_response(_public(job))
|
||||
|
||||
|
||||
async def api_status(request):
|
||||
with _lock:
|
||||
jobs = [_public(job) for job in _jobs.values()]
|
||||
return web.json_response({"jobs": jobs})
|
||||
|
||||
|
||||
async def api_cancel(request):
|
||||
data = await _body(request)
|
||||
with _lock:
|
||||
job = _jobs.get(str(data.get("id") or ""))
|
||||
if not job:
|
||||
return web.json_response({"error": "unknown"}, status=404)
|
||||
if job["state"] == "queued":
|
||||
job["state"], job["error"], job["finished"] = "cancelled", "cancelled", time.time()
|
||||
if job in _queue:
|
||||
_queue.remove(job)
|
||||
else:
|
||||
job["cancel"] = True
|
||||
return web.json_response(_public(job))
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
app.router.add_post("/anomalous/download/lookup", api_lookup)
|
||||
app.router.add_post("/anomalous/download/start", api_start)
|
||||
app.router.add_get("/anomalous/download/status", api_status)
|
||||
app.router.add_post("/anomalous/download/cancel", api_cancel)
|
||||
app.router.add_get("/anomalous/download/settings", api_settings)
|
||||
app.router.add_post("/anomalous/download/settings", api_settings)
|
||||
@@ -0,0 +1,125 @@
|
||||
"""Shows a model file in this computer's file manager: Explorer or Finder with the file
|
||||
selected, the folder on Linux; or, without a file name, opens a models folder (a type's root
|
||||
or a subfolder). The request names it the way the browser lists it (type, folder index,
|
||||
subfolder, file name), never a path, and local_guard lets only this computer ask (a POST)."""
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from .utils import model_file_within, resolve_folder_subdir
|
||||
|
||||
|
||||
def _explorer_windows():
|
||||
"""Handles of the open Explorer folder windows (window class CabinetWClass)."""
|
||||
import ctypes
|
||||
from ctypes import wintypes
|
||||
|
||||
found = []
|
||||
callback_type = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)
|
||||
|
||||
def collect(hwnd, _):
|
||||
name = ctypes.create_unicode_buffer(64)
|
||||
ctypes.windll.user32.GetClassNameW(hwnd, name, 64)
|
||||
if name.value == "CabinetWClass":
|
||||
found.append(hwnd)
|
||||
return True
|
||||
|
||||
ctypes.windll.user32.EnumWindows(callback_type(collect), 0)
|
||||
return found
|
||||
|
||||
|
||||
def _window_title(hwnd):
|
||||
import ctypes
|
||||
|
||||
title = ctypes.create_unicode_buffer(512)
|
||||
ctypes.windll.user32.GetWindowTextW(hwnd, title, 512)
|
||||
return title.value
|
||||
|
||||
|
||||
def _to_front(hwnd):
|
||||
"""Windows keeps a background program (ComfyUI here) from raising a window; borrowing the
|
||||
foreground window's input queue for a moment lets it."""
|
||||
import ctypes
|
||||
|
||||
user32, kernel32 = ctypes.windll.user32, ctypes.windll.kernel32
|
||||
foreground = user32.GetForegroundWindow()
|
||||
theirs = user32.GetWindowThreadProcessId(foreground, None)
|
||||
mine = kernel32.GetCurrentThreadId()
|
||||
attached = theirs and theirs != mine and user32.AttachThreadInput(mine, theirs, True)
|
||||
try:
|
||||
user32.ShowWindow(hwnd, 9 if user32.IsIconic(hwnd) else 5) # SW_RESTORE / SW_SHOW
|
||||
user32.BringWindowToTop(hwnd)
|
||||
user32.SetForegroundWindow(hwnd)
|
||||
finally:
|
||||
if attached:
|
||||
user32.AttachThreadInput(mine, theirs, False)
|
||||
|
||||
|
||||
def _raise_explorer(folder, before):
|
||||
"""Waits up to 3 s for the window showing `folder` (a new one, or the open one Explorer
|
||||
reused) and brings it to the front."""
|
||||
names = (os.path.basename(folder).lower(), os.path.normcase(folder).lower())
|
||||
|
||||
def shows_folder(hwnd):
|
||||
# The folder's name (or full path), then " - File Explorer" in the system's language.
|
||||
title = _window_title(hwnd).lower()
|
||||
return any(title == name or title.startswith(name + " - ") for name in names)
|
||||
|
||||
for _ in range(30):
|
||||
time.sleep(0.1)
|
||||
windows = _explorer_windows()
|
||||
fresh = [hwnd for hwnd in windows if hwnd not in before]
|
||||
match = fresh or [hwnd for hwnd in windows if shows_folder(hwnd)]
|
||||
if match:
|
||||
_to_front(match[0])
|
||||
return
|
||||
|
||||
|
||||
def _reveal(path):
|
||||
if sys.platform == "win32":
|
||||
before = set(_explorer_windows())
|
||||
subprocess.Popen(f'explorer /select,"{path}"')
|
||||
threading.Thread(target=_raise_explorer, args=(os.path.dirname(path), before), daemon=True).start()
|
||||
elif sys.platform == "darwin":
|
||||
subprocess.Popen(["open", "-R", path])
|
||||
else:
|
||||
subprocess.Popen(["xdg-open", os.path.dirname(path)])
|
||||
|
||||
|
||||
def _open_folder(folder):
|
||||
if sys.platform == "win32":
|
||||
before = set(_explorer_windows())
|
||||
subprocess.Popen(f'explorer "{folder}"')
|
||||
threading.Thread(target=_raise_explorer, args=(folder, before), daemon=True).start()
|
||||
elif sys.platform == "darwin":
|
||||
subprocess.Popen(["open", folder])
|
||||
else:
|
||||
subprocess.Popen(["xdg-open", folder])
|
||||
|
||||
|
||||
async def api_open_model_folder(request):
|
||||
"""{type, path_idx, subfolder, filename}: Explorer with the model selected; without a
|
||||
filename, the folder (type root or subfolder) itself."""
|
||||
try:
|
||||
data = await request.json()
|
||||
except ValueError:
|
||||
data = None
|
||||
if not isinstance(data, dict):
|
||||
return web.json_response({"status": "error", "message": "Invalid request body"}, status=400)
|
||||
try:
|
||||
_, folder = resolve_folder_subdir(data.get("type", ""), int(data.get("path_idx", 0)), data.get("subfolder", "/"))
|
||||
filename = data.get("filename")
|
||||
path = model_file_within(folder, filename) if filename else None
|
||||
except (ValueError, KeyError, TypeError):
|
||||
return web.json_response({"status": "error", "message": "Invalid request parameters"}, status=400)
|
||||
if not os.path.isfile(path) if path else not os.path.isdir(folder):
|
||||
return web.json_response({"status": "error", "message": "Not found"}, status=404)
|
||||
try:
|
||||
_reveal(path) if path else _open_folder(folder)
|
||||
except OSError as error:
|
||||
return web.json_response({"status": "error", "message": str(error)}, status=500)
|
||||
return web.json_response({"status": "success"})
|
||||
@@ -0,0 +1,101 @@
|
||||
"""What a model file's header says (model_kind.inspect_file: kind, base model, format), kept on
|
||||
disk so each file version is read once, also across restarts. With many models, or models on a
|
||||
network drive (a NAS, a cloud server's model disk), reading every header again each time the
|
||||
scan page or a models folder opens takes minutes; the header only changes with the file.
|
||||
|
||||
Kept in user/anomalous/model_heads.json by the file's real path, with its size and time: a
|
||||
changed file is read again. At most MAX_ENTRIES files, the longest unused dropped first, and
|
||||
written a few seconds after the last change (one write for a whole folder). Only this plugin
|
||||
reads it; it is a cache, not data to back up. It is kept on disk once the plugin's routes are
|
||||
set up (keep_on_disk); before that (tests, tools) it lives in memory only."""
|
||||
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
|
||||
from .activity_log import log_path
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
try:
|
||||
from ..model_identity import read_json
|
||||
from ..model_kind import inspect_file
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from model_identity import read_json
|
||||
from model_kind import inspect_file
|
||||
|
||||
MAX_ENTRIES = 50000 # about 6 MB on disk; a library has far fewer models
|
||||
MAX_BYTES = 64 * 1024 * 1024 # a cache file larger than this is not read (nor written)
|
||||
SAVE_AFTER_S = 5
|
||||
FIELDS = ("kind", "base", "sure", "format")
|
||||
|
||||
_lock = threading.Lock()
|
||||
_heads = None # {real path: [size, mtime_ns, last used (days), kind, base, sure, format]}
|
||||
_timer = None
|
||||
_on_disk = False
|
||||
|
||||
|
||||
def keep_on_disk():
|
||||
"""From now on the cache is read from and written to cache_path() (the plugin's start)."""
|
||||
global _on_disk
|
||||
_on_disk = True
|
||||
|
||||
|
||||
def cache_path():
|
||||
return os.path.join(os.path.dirname(log_path()), "model_heads.json")
|
||||
|
||||
|
||||
def _load():
|
||||
global _heads
|
||||
if _heads is None:
|
||||
try:
|
||||
data = read_json(cache_path()) if _on_disk and os.path.getsize(cache_path()) <= MAX_BYTES else None
|
||||
except OSError:
|
||||
data = None
|
||||
_heads = {key: value for key, value in (data or {}).items()
|
||||
if isinstance(key, str) and isinstance(value, list) and len(value) == 3 + len(FIELDS)}
|
||||
return _heads
|
||||
|
||||
|
||||
def save():
|
||||
"""Writes the cache now (also what the timer does)."""
|
||||
global _timer
|
||||
with _lock:
|
||||
_timer = None
|
||||
heads = _load()
|
||||
if len(heads) > MAX_ENTRIES:
|
||||
for key in sorted(heads, key=lambda name: heads[name][2])[:len(heads) - MAX_ENTRIES]:
|
||||
del heads[key]
|
||||
snapshot = dict(heads)
|
||||
try:
|
||||
atomic_write_json(cache_path(), snapshot, max_bytes=MAX_BYTES)
|
||||
except (OSError, ValueError) as error:
|
||||
print(f"[Anomalous Browser] Model header cache not saved: {error}")
|
||||
|
||||
|
||||
def _save_soon():
|
||||
global _timer
|
||||
if _on_disk and _timer is None:
|
||||
_timer = threading.Timer(SAVE_AFTER_S, save)
|
||||
_timer.daemon = True
|
||||
_timer.start()
|
||||
|
||||
|
||||
def inspect(path):
|
||||
"""model_kind.inspect_file(path), from the cache while the file is unchanged."""
|
||||
try:
|
||||
stat = os.stat(path)
|
||||
except OSError:
|
||||
return inspect_file(path)
|
||||
real, today = os.path.realpath(path), int(time.time() // 86400)
|
||||
with _lock:
|
||||
known = _load().get(real)
|
||||
if known and known[0] == stat.st_size and known[1] == stat.st_mtime_ns:
|
||||
if known[2] != today:
|
||||
known[2] = today
|
||||
_save_soon()
|
||||
return dict(zip(FIELDS, known[3:]))
|
||||
found = inspect_file(path)
|
||||
with _lock:
|
||||
_load()[real] = [stat.st_size, stat.st_mtime_ns, today, *(found.get(field) for field in FIELDS)]
|
||||
_save_soon()
|
||||
return found
|
||||
@@ -0,0 +1,435 @@
|
||||
"""Putting a model file the user drops on the models page into the right models folder.
|
||||
|
||||
A browser gives a dropped file's name, size, time and bytes, never its path. So:
|
||||
GET /anomalous/import/folders -> {types: {type: roots}, settings}: the folders a model can go to
|
||||
(model_download.roots_of) and the download settings, whose folder rule ({base}) imports share.
|
||||
POST /anomalous/import/inspect?name&size&mtime body: the file's first bytes (its header)
|
||||
-> what it is (model_kind.classify), files of the same name already there, and, when this
|
||||
computer's Downloads or Desktop holds that very file (same name, size and time; asked only
|
||||
by the computer ComfyUI runs on), a `token` for it.
|
||||
POST /anomalous/import/identify {token} -> its SHA-256, what Civitai knows of it (base model,
|
||||
model and version name) and a scanned model with the same SHA-256, if any.
|
||||
POST /anomalous/import/place {token, type, root, rel, keep} -> moves that file there (a copy
|
||||
when `keep`); same drive = a rename, another drive = copy, then the original goes.
|
||||
PUT /anomalous/import/upload?type&root&rel&size body: the whole file -> written there.
|
||||
identify, place and upload answer only the computer ComfyUI runs on, unless remote changes
|
||||
are allowed (local_guard.may_change).
|
||||
|
||||
A file already at the destination is never replaced: the new one gets " (2)". Each import is
|
||||
one activity log entry (model_import).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import shutil
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
try:
|
||||
from ..model_identity import file_sha256
|
||||
from ..model_kind import classify, inspect_file, parse_gguf, parse_safetensors
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from model_identity import file_sha256
|
||||
from model_kind import classify, inspect_file, parse_gguf, parse_safetensors
|
||||
from .activity_log import add_entry
|
||||
from .download_sources import SourceUnreachable, civitai_by_hash
|
||||
from .local_guard import is_local as _is_local, may_change
|
||||
from .model_download import (
|
||||
CHUNK, MODEL_EXTENSIONS, SPACE_MARGIN, clean_folder, folder_type_for, forget_file_lists, read_settings, roots_of,
|
||||
)
|
||||
from .path_utils import resolve_within
|
||||
|
||||
KINDS = ("checkpoints", "loras", "vae", "text_encoders", "diffusion_models", "controlnet", "embeddings",
|
||||
"clip_vision", "upscale_models", "ipadapter", "model_patches")
|
||||
SEARCH_DEPTH = 2
|
||||
SEARCH_LIMIT = 20000
|
||||
TIME_SLACK_MS = 2000
|
||||
KEEP_TOKENS = 200
|
||||
_FOLDER_IDS = { # Windows known folders: Downloads, Desktop
|
||||
"downloads": "{374DE290-123F-4565-9164-39C4925E467B}",
|
||||
"desktop": "{B4BFCC3A-DB2C-424C-B029-7FE99A87C641}",
|
||||
}
|
||||
|
||||
_lock = threading.Lock()
|
||||
_tokens = {} # token -> {path, name, size}
|
||||
|
||||
|
||||
class Refused(Exception):
|
||||
"""An import that cannot be done; `code` says why (the page has a sentence for each)."""
|
||||
|
||||
def __init__(self, code):
|
||||
super().__init__(code)
|
||||
self.code = code
|
||||
|
||||
|
||||
def _error(code, status=400):
|
||||
return web.json_response({"error": code}, status=status)
|
||||
|
||||
|
||||
# --- where the dropped file is on this computer --------------------------------------------
|
||||
|
||||
def _known_folder(name):
|
||||
if os.name == "nt":
|
||||
try:
|
||||
import ctypes
|
||||
from ctypes import wintypes
|
||||
folder_id = uuid.UUID(_FOLDER_IDS[name]).bytes_le
|
||||
path = ctypes.c_wchar_p()
|
||||
shell = ctypes.windll.shell32
|
||||
shell.SHGetKnownFolderPath.argtypes = [ctypes.c_char_p, wintypes.DWORD, wintypes.HANDLE, ctypes.POINTER(ctypes.c_wchar_p)]
|
||||
if shell.SHGetKnownFolderPath(folder_id, 0, None, ctypes.byref(path)) == 0:
|
||||
found = path.value
|
||||
ctypes.windll.ole32.CoTaskMemFree(path)
|
||||
if found and os.path.isdir(found):
|
||||
return found
|
||||
except Exception:
|
||||
pass
|
||||
fallback = os.path.expanduser("~/" + name.capitalize())
|
||||
return fallback if os.path.isdir(fallback) else ""
|
||||
|
||||
|
||||
def search_folders():
|
||||
"""[(label, path)] where dropped files usually come from: Downloads, then Desktop."""
|
||||
found = []
|
||||
for label in ("downloads", "desktop"):
|
||||
path = _known_folder(label)
|
||||
if path and all(os.path.realpath(path) != os.path.realpath(other) for _, other in found):
|
||||
found.append((label, path))
|
||||
return found
|
||||
|
||||
|
||||
def find_original(name, size, mtime_ms, folders=None):
|
||||
"""(label, path) of the file with this name, size and time in `folders` (and their
|
||||
subfolders two deep), else None."""
|
||||
wanted = name.lower()
|
||||
seen = 0
|
||||
for label, base in folders if folders is not None else search_folders():
|
||||
for current, dirs, files in os.walk(base):
|
||||
depth = 0 if current == base else os.path.relpath(current, base).count(os.sep) + 1
|
||||
dirs[:] = sorted(item for item in dirs if not item.startswith(".")) if depth < SEARCH_DEPTH else []
|
||||
for file in files:
|
||||
seen += 1
|
||||
if seen > SEARCH_LIMIT:
|
||||
return None
|
||||
if file.lower() != wanted:
|
||||
continue
|
||||
path = os.path.join(current, file)
|
||||
try:
|
||||
stat = os.stat(path)
|
||||
except OSError:
|
||||
continue
|
||||
if stat.st_size == size and (not mtime_ms or abs(stat.st_mtime * 1000 - mtime_ms) <= TIME_SLACK_MS):
|
||||
return label, path
|
||||
return None
|
||||
|
||||
|
||||
def _remember(path, name, size):
|
||||
token = uuid.uuid4().hex
|
||||
with _lock:
|
||||
_tokens[token] = {"path": path, "name": name, "size": size}
|
||||
while len(_tokens) > KEEP_TOKENS:
|
||||
_tokens.pop(next(iter(_tokens)))
|
||||
return token
|
||||
|
||||
|
||||
def _original(token):
|
||||
with _lock:
|
||||
item = _tokens.get(str(token or ""))
|
||||
if not item or not os.path.isfile(item["path"]) or os.path.getsize(item["path"]) != item["size"]:
|
||||
raise Refused("gone")
|
||||
return item
|
||||
|
||||
|
||||
# --- what it is ----------------------------------------------------------------------------
|
||||
|
||||
def import_types():
|
||||
known = getattr(folder_paths, "folder_names_and_paths", {})
|
||||
return [kind for kind in KINDS if kind in known]
|
||||
|
||||
|
||||
def classify_head(name, head):
|
||||
"""classify() from a file's first bytes, by its extension."""
|
||||
lower = name.lower()
|
||||
if lower.endswith((".safetensors", ".sft")):
|
||||
return classify("safetensors", parse_safetensors(head))
|
||||
if lower.endswith(".gguf"):
|
||||
return classify("gguf", parse_gguf(head))
|
||||
return classify(None, None)
|
||||
|
||||
|
||||
def same_name(kind, name):
|
||||
"""Files of this name already in the type's folders: [{root, rel, size}]."""
|
||||
if not kind:
|
||||
return []
|
||||
wanted, found = name.lower(), []
|
||||
for index, base in enumerate(folder_paths.get_folder_paths(kind) or []):
|
||||
if not os.path.isdir(base):
|
||||
continue
|
||||
for current, _dirs, files in os.walk(base):
|
||||
for file in files:
|
||||
if file.lower() == wanted:
|
||||
path = os.path.join(current, file)
|
||||
found.append({"root": index, "rel": os.path.relpath(path, base).replace(os.sep, "/"),
|
||||
"size": os.path.getsize(path)})
|
||||
return found[:10]
|
||||
|
||||
|
||||
def inspect(name, size, mtime_ms, head, local):
|
||||
found = find_original(name, size, mtime_ms) if local else None
|
||||
if found:
|
||||
result = inspect_file(found[1])
|
||||
result.pop("format", None)
|
||||
result.update(token=_remember(found[1], name, size), where=found[0])
|
||||
else:
|
||||
result = classify_head(name, head)
|
||||
if result["kind"] not in import_types():
|
||||
result.update(kind="", sure=False)
|
||||
result["same_name"] = same_name(result["kind"], name)
|
||||
return result
|
||||
|
||||
|
||||
def _same_hash(sha256):
|
||||
"""Where a scanned model with this SHA-256 is ("sub/name.safetensors"), else None."""
|
||||
from .model_resolution import collect_model_hash_index
|
||||
names = [key for key, value in collect_model_hash_index().items() if str(value.get("hash") or "").lower() == sha256]
|
||||
return next((key for key in names if "/" in key), names[0] if names else None)
|
||||
|
||||
|
||||
def identify(token):
|
||||
"""SHA-256, Civitai's record, and an already scanned copy, of a found file."""
|
||||
item = _original(token)
|
||||
sha256 = file_sha256(item["path"])
|
||||
result = {"sha256": sha256, "civitai": None, "reason": "", "duplicate": _same_hash(sha256)}
|
||||
try:
|
||||
found = civitai_by_hash(sha256)
|
||||
if found:
|
||||
result["civitai"] = {key: found.get(key, "") for key in ("base_model", "model_name", "version_name", "page")}
|
||||
else:
|
||||
result["reason"] = "not_found"
|
||||
except SourceUnreachable:
|
||||
result["reason"] = "network"
|
||||
return result
|
||||
|
||||
|
||||
# --- putting it there ----------------------------------------------------------------------
|
||||
|
||||
def free_path(path):
|
||||
"""`path`, or "name (2).ext", "name (3).ext"… when it is taken."""
|
||||
if not os.path.exists(path) and not os.path.exists(path + ".part"):
|
||||
return path
|
||||
stem, ext = os.path.splitext(path)
|
||||
number = 2
|
||||
while os.path.exists(f"{stem} ({number}){ext}") or os.path.exists(f"{stem} ({number}){ext}.part"):
|
||||
number += 1
|
||||
return f"{stem} ({number}){ext}"
|
||||
|
||||
|
||||
def destination(data, size=0):
|
||||
"""(type, root index, root path, dest) for a place/upload request; Refused if refused."""
|
||||
folder_type = folder_type_for([data.get("type")])
|
||||
if folder_type not in import_types():
|
||||
raise Refused("bad_type")
|
||||
paths = folder_paths.get_folder_paths(folder_type) or []
|
||||
try:
|
||||
root_index = int(data.get("root", 0))
|
||||
except (TypeError, ValueError):
|
||||
raise Refused("bad_root")
|
||||
if not 0 <= root_index < len(paths):
|
||||
raise Refused("bad_root")
|
||||
try:
|
||||
rel = clean_folder(data.get("rel"))
|
||||
root = os.path.realpath(paths[root_index])
|
||||
dest = resolve_within(root, *rel.split("/"))
|
||||
except ValueError:
|
||||
raise Refused("bad_path")
|
||||
if not rel.lower().endswith(MODEL_EXTENSIONS):
|
||||
raise Refused("bad_name")
|
||||
probe = root
|
||||
while probe and not os.path.isdir(probe):
|
||||
probe = os.path.dirname(probe)
|
||||
if size and probe and shutil.disk_usage(probe).free < size + SPACE_MARGIN:
|
||||
raise Refused("no_space")
|
||||
os.makedirs(os.path.dirname(dest), exist_ok=True)
|
||||
return folder_type, root_index, root, free_path(dest)
|
||||
|
||||
|
||||
def _same_drive(first, second):
|
||||
"""Whether `first` can be renamed to `second`; a link counts where the link is (moving
|
||||
it moves the link, not the model disk behind it)."""
|
||||
try:
|
||||
return os.lstat(first).st_dev == os.stat(os.path.dirname(second)).st_dev
|
||||
except OSError:
|
||||
return False
|
||||
|
||||
|
||||
def _rename_new(source, dest):
|
||||
"""Renames `source` to `dest` and never over a file there, even one that appeared since
|
||||
free_path looked (FileExistsError). Windows' rename refuses a taken name by itself; elsewhere
|
||||
a hard link does (of a link itself, not what it points to), with a last look for the file
|
||||
systems that have none."""
|
||||
if os.name == "nt":
|
||||
os.rename(source, dest)
|
||||
return
|
||||
try:
|
||||
os.link(source, dest, follow_symlinks=False)
|
||||
except FileExistsError:
|
||||
raise
|
||||
except OSError: # no hard links here (FAT, some network shares)
|
||||
if os.path.lexists(dest):
|
||||
raise FileExistsError(dest)
|
||||
os.rename(source, dest)
|
||||
return
|
||||
os.remove(source)
|
||||
|
||||
|
||||
def _looks_whole(source, copy):
|
||||
"""Whether `copy` has `source`'s size and its very bytes at the start, the middle and the end
|
||||
(a megabyte each): a cut or garbled copy shows, at no felt cost, with no fingerprint needed."""
|
||||
size = os.path.getsize(source)
|
||||
if os.path.getsize(copy) != size:
|
||||
return False
|
||||
with open(source, "rb") as first, open(copy, "rb") as second:
|
||||
for at in sorted({0, max(0, size // 2 - CHUNK // 2), max(0, size - CHUNK)}):
|
||||
first.seek(at)
|
||||
second.seek(at)
|
||||
if first.read(CHUNK) != second.read(CHUNK):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def move_into(source, dest, keep):
|
||||
"""Moves (or with `keep` copies) `source` to `dest`, never over a file; a copy goes through
|
||||
"<dest>.part" and is checked (_looks_whole) before the original goes."""
|
||||
if not keep and _same_drive(source, dest):
|
||||
_rename_new(source, dest)
|
||||
return
|
||||
part = dest + ".part"
|
||||
try:
|
||||
shutil.copyfile(source, part)
|
||||
if not _looks_whole(source, part):
|
||||
raise Refused("incomplete")
|
||||
_rename_new(part, dest)
|
||||
except BaseException:
|
||||
if os.path.exists(part):
|
||||
os.remove(part) # our own unfinished copy
|
||||
raise
|
||||
if not keep:
|
||||
os.remove(source) # moved: the whole file is at dest now
|
||||
|
||||
|
||||
def _finish(folder_type, root_index, root, dest, how, size):
|
||||
forget_file_lists()
|
||||
rel = os.path.relpath(dest, root).replace(os.sep, "/")
|
||||
add_entry("file", "model_import", rel, {"import": {
|
||||
"type": folder_type, "path_idx": root_index, "rel": rel, "file": os.path.basename(dest), "size": size, "how": how,
|
||||
}})
|
||||
return {"type": folder_type, "root": root_index, "rel": rel, "file": os.path.basename(dest)}
|
||||
|
||||
|
||||
def place(data):
|
||||
item = _original(data.get("token"))
|
||||
keep = data.get("keep") is True
|
||||
folder_type, root_index, root, dest = destination(data, item["size"] if keep else 0)
|
||||
move_into(item["path"], dest, keep)
|
||||
if not keep:
|
||||
with _lock:
|
||||
_tokens.pop(str(data.get("token")), None)
|
||||
return _finish(folder_type, root_index, root, dest, "copy" if keep else "move", item["size"])
|
||||
|
||||
|
||||
# --- routes --------------------------------------------------------------------------------
|
||||
|
||||
async def api_folders(request):
|
||||
types = {}
|
||||
for kind in import_types():
|
||||
types[kind] = await asyncio.to_thread(roots_of, kind)
|
||||
return web.json_response({"types": types, "settings": read_settings()})
|
||||
|
||||
|
||||
async def api_inspect(request):
|
||||
name = os.path.basename(str(request.query.get("name") or "").replace("\\", "/"))
|
||||
if not name.lower().endswith(MODEL_EXTENSIONS):
|
||||
return _error("not_model")
|
||||
try:
|
||||
size = int(request.query.get("size") or 0)
|
||||
mtime_ms = float(request.query.get("mtime") or 0)
|
||||
except ValueError:
|
||||
return _error("bad_request")
|
||||
head = await request.read()
|
||||
result = await asyncio.to_thread(inspect, name, size, mtime_ms, head, _is_local(request))
|
||||
return web.json_response(result)
|
||||
|
||||
|
||||
async def api_identify(request):
|
||||
if not may_change(request):
|
||||
return _error("not_local", 403)
|
||||
try:
|
||||
data = await request.json()
|
||||
return web.json_response(await asyncio.to_thread(identify, data.get("token")))
|
||||
except Refused as error:
|
||||
return _error(error.code, 404)
|
||||
except (ValueError, AttributeError):
|
||||
return _error("bad_request")
|
||||
|
||||
|
||||
async def api_place(request):
|
||||
if not may_change(request):
|
||||
return _error("not_local", 403)
|
||||
try:
|
||||
data = await request.json()
|
||||
return web.json_response(await asyncio.to_thread(place, data))
|
||||
except Refused as error:
|
||||
return _error(error.code, 404 if error.code == "gone" else 400)
|
||||
except (ValueError, AttributeError):
|
||||
return _error("bad_request")
|
||||
except OSError as error:
|
||||
print(f"[Anomalous Browser] Import: could not put the file in place: {error}")
|
||||
return _error("io", 500)
|
||||
|
||||
|
||||
async def api_upload(request):
|
||||
if not may_change(request):
|
||||
return _error("not_local", 403)
|
||||
try:
|
||||
size = int(request.query.get("size") or 0)
|
||||
folder_type, root_index, root, dest = await asyncio.to_thread(destination, dict(request.query), size)
|
||||
except Refused as error:
|
||||
return _error(error.code)
|
||||
except ValueError:
|
||||
return _error("bad_request")
|
||||
part = dest + ".part"
|
||||
received = 0
|
||||
try:
|
||||
target = await asyncio.to_thread(open, part, "wb")
|
||||
try:
|
||||
async for chunk in request.content.iter_chunked(CHUNK):
|
||||
await asyncio.to_thread(target.write, chunk)
|
||||
received += len(chunk)
|
||||
finally:
|
||||
await asyncio.to_thread(target.close)
|
||||
if size and received != size:
|
||||
raise Refused("incomplete")
|
||||
dest = free_path(dest) if os.path.exists(dest) else dest
|
||||
await asyncio.to_thread(os.replace, part, dest)
|
||||
except BaseException as error:
|
||||
if os.path.exists(part):
|
||||
os.remove(part) # our own unfinished upload
|
||||
if isinstance(error, Refused):
|
||||
return _error(error.code)
|
||||
if isinstance(error, OSError):
|
||||
print(f"[Anomalous Browser] Import: upload failed: {error}")
|
||||
return _error("io", 500)
|
||||
raise
|
||||
return web.json_response(await asyncio.to_thread(_finish, folder_type, root_index, root, dest, "upload", received))
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
app.router.add_get("/anomalous/import/folders", api_folders)
|
||||
app.router.add_post("/anomalous/import/inspect", api_inspect)
|
||||
app.router.add_post("/anomalous/import/identify", api_identify)
|
||||
app.router.add_post("/anomalous/import/place", api_place)
|
||||
app.router.add_put("/anomalous/import/upload", api_upload)
|
||||
+56
-11
@@ -9,7 +9,12 @@ from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
from .model_constants import MEDIA_EXTENSIONS, PREVIEW_SUFFIXES
|
||||
from .utils import require_filename, resolve_folder_subdir, resolve_within
|
||||
try:
|
||||
from ..model_sidecars import backups, is_civitai_cover, keep_aside
|
||||
except ImportError:
|
||||
from model_sidecars import backups, is_civitai_cover, keep_aside
|
||||
from .trash import move_to_trash
|
||||
from .utils import model_file_within, require_filename, resolve_folder_subdir, resolve_within
|
||||
|
||||
def _cache_token(file_path):
|
||||
try:
|
||||
@@ -29,13 +34,21 @@ async def _handle_custom_cover(target_dir, filename, save_func, source_ext='.png
|
||||
|
||||
dest_path = os.path.join(target_dir, f"{base_name}{preview_ext}")
|
||||
|
||||
# Delete any existing .preview.* files to ensure only one custom cover is active
|
||||
for ext in PREVIEW_SUFFIXES:
|
||||
p = os.path.join(target_dir, f"{base_name}{ext}")
|
||||
if os.path.exists(p) and p != dest_path:
|
||||
try: os.remove(p)
|
||||
except: pass
|
||||
|
||||
# Civitai's picture, when it is the cover, is kept aside first, to bring back from the editor.
|
||||
base = os.path.join(target_dir, base_name)
|
||||
covers = [path for path in (os.path.join(target_dir, f"{base_name}{ext}") for ext in PREVIEW_SUFFIXES) if os.path.isfile(path)]
|
||||
if not backups(base):
|
||||
civitai = next((path for path in covers if is_civitai_cover(path, base, [])), None)
|
||||
if civitai:
|
||||
keep_aside(base, civitai)
|
||||
|
||||
# Only one cover is active: the others go to the Recycle Bin (a failure keeps them).
|
||||
older = [os.path.join(target_dir, f"{base_name}{ext}") for ext in PREVIEW_SUFFIXES]
|
||||
try:
|
||||
move_to_trash(*[path for path in older if path != dest_path])
|
||||
except OSError as e:
|
||||
print(f"[Anomalous Browser] Old cover kept: {e}")
|
||||
|
||||
await save_func(dest_path)
|
||||
|
||||
|
||||
@@ -131,12 +144,44 @@ def _preview_url_for_model(folder_type, path_idx, base_dir, file_path):
|
||||
)
|
||||
if not preview_file:
|
||||
return ""
|
||||
rel_subfolder = os.path.relpath(root, base_dir)
|
||||
return _media_url(folder_type, path_idx, base_dir, os.path.join(root, preview_file))
|
||||
|
||||
|
||||
def _media_url(folder_type, path_idx, base_dir, media_path):
|
||||
"""The /anomalous/image URL of a file beside a model, with a token that changes with it."""
|
||||
rel_subfolder = os.path.relpath(os.path.dirname(media_path), base_dir)
|
||||
if rel_subfolder == '.':
|
||||
rel_subfolder = '/'
|
||||
q_type = urllib.parse.quote(folder_type)
|
||||
q_idx = str(path_idx)
|
||||
q_sub = urllib.parse.quote(rel_subfolder)
|
||||
q_file = urllib.parse.quote(preview_file)
|
||||
version = _cache_token(os.path.join(root, preview_file))
|
||||
q_file = urllib.parse.quote(os.path.basename(media_path))
|
||||
version = _cache_token(media_path)
|
||||
return f"/anomalous/image?type={q_type}&path_idx={q_idx}&subfolder={q_sub}&filename={q_file}&t={version}"
|
||||
|
||||
|
||||
def _model_covers(folder_type, path_idx, base_dir, file_path):
|
||||
"""Civitai's own image kept aside (<model>.civitai_bak.*, beside or in .amb) as a URL, or "",
|
||||
and whether the cover shown is another picture (the user's), not Civitai's (model_sidecars)."""
|
||||
base = os.path.splitext(file_path)[0]
|
||||
kept = backups(base)
|
||||
saved = kept[0] if kept else ""
|
||||
shown = next((base + suffix for suffix in PREVIEW_SUFFIXES + MEDIA_EXTENSIONS if os.path.isfile(base + suffix)), "")
|
||||
custom = bool(shown) and not is_civitai_cover(shown, base, kept)
|
||||
return {"civitai": _media_url(folder_type, path_idx, base_dir, saved) if saved else "", "custom": custom}
|
||||
|
||||
|
||||
async def api_model_covers(request):
|
||||
"""GET /anomalous/model_covers?type&path_idx&subfolder&filename - for the model editor: the
|
||||
Civitai cover it can bring back, and whether the one shown is the user's."""
|
||||
try:
|
||||
folder_type = request.query.get('type', '')
|
||||
path_idx = int(request.query.get('path_idx', 0))
|
||||
filename = require_filename(request.query.get('filename', ''))
|
||||
base_dir, target_dir = resolve_folder_subdir(folder_type, path_idx, request.query.get('subfolder', '/'))
|
||||
file_path = model_file_within(target_dir, filename)
|
||||
except (ValueError, KeyError, TypeError):
|
||||
return web.json_response({"error": "Invalid model location"}, status=400)
|
||||
if not os.path.isfile(file_path):
|
||||
return web.json_response({"error": "Model not found"}, status=404)
|
||||
return web.json_response(await asyncio.to_thread(_model_covers, folder_type, path_idx, base_dir, file_path))
|
||||
|
||||
+71
-60
@@ -2,6 +2,7 @@
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
|
||||
from aiohttp import web
|
||||
@@ -14,8 +15,18 @@ from .model_constants import (
|
||||
CIVITAI_BACKUP_SUFFIXES, MEDIA_EXTENSIONS, MODEL_EXTENSIONS,
|
||||
PREVIEW_SUFFIXES, SIDECAR_SUFFIXES,
|
||||
)
|
||||
from .activity_log import ACTIVITY_DETAIL
|
||||
from .metadata import get_metadata
|
||||
from .model_catalog import _resolve_paths_to_model_info_sync
|
||||
from .utils import require_filename, resolve_folder_subdir, resolve_within
|
||||
from .trash import move_to_trash, trash_failure
|
||||
from .utils import atomic_write_json
|
||||
try:
|
||||
from ..model_identity import USER_INFO_SUFFIX, read_json
|
||||
from ..model_sidecars import drop_empty_hidden_dir, existing, follow, is_civitai_cover, note_cover_hash, target
|
||||
except ImportError:
|
||||
from model_identity import USER_INFO_SUFFIX, read_json
|
||||
from model_sidecars import drop_empty_hidden_dir, existing, follow, is_civitai_cover, note_cover_hash, target
|
||||
from .utils import model_file_within, require_filename, resolve_folder_subdir
|
||||
|
||||
def _first_existing_sidecar(base_path, suffixes):
|
||||
for suffix in suffixes:
|
||||
@@ -26,8 +37,9 @@ def _first_existing_sidecar(base_path, suffixes):
|
||||
|
||||
|
||||
def _reset_model_cover(base_path):
|
||||
"""Restore a recoverable cover without destroying the only existing image."""
|
||||
backup_path, backup_suffix = _first_existing_sidecar(base_path, CIVITAI_BACKUP_SUFFIXES)
|
||||
"""Restore a recoverable cover without destroying the only existing image. Civitai's picture
|
||||
kept aside becomes the cover again and is then noted as Civitai's instead of kept twice."""
|
||||
backup_path, backup_suffix = next(iter(existing(base_path, CIVITAI_BACKUP_SUFFIXES)), (None, None))
|
||||
original_path, _ = _first_existing_sidecar(base_path, MEDIA_EXTENSIONS)
|
||||
preview_paths = [
|
||||
f"{base_path}{suffix}"
|
||||
@@ -44,9 +56,9 @@ def _reset_model_cover(base_path):
|
||||
# remains untouched. os.replace then makes the actual restore atomic.
|
||||
shutil.copy2(backup_path, temp_path)
|
||||
os.replace(temp_path, restored_path)
|
||||
for preview_path in preview_paths:
|
||||
if preview_path != restored_path and os.path.isfile(preview_path):
|
||||
os.remove(preview_path)
|
||||
move_to_trash(*[path for path in preview_paths if path != restored_path])
|
||||
if note_cover_hash(base_path, restored_path):
|
||||
move_to_trash(backup_path) # the cover is Civitai's picture now: no second copy
|
||||
except Exception as exc:
|
||||
try:
|
||||
if os.path.isfile(temp_path):
|
||||
@@ -56,12 +68,14 @@ def _reset_model_cover(base_path):
|
||||
return False, 'restore_failed', str(exc)
|
||||
return True, 'civitai_backup', None
|
||||
|
||||
if any(is_civitai_cover(path, base_path, []) for path in preview_paths):
|
||||
return True, 'civitai_backup', None # Civitai's picture is the cover already
|
||||
|
||||
if original_path:
|
||||
try:
|
||||
for preview_path in preview_paths:
|
||||
os.remove(preview_path)
|
||||
move_to_trash(*preview_paths)
|
||||
except Exception as exc:
|
||||
return False, 'restore_failed', str(exc)
|
||||
return False, 'restore_failed', trash_failure(exc)
|
||||
return True, 'original_cover', None
|
||||
|
||||
if preview_paths:
|
||||
@@ -75,6 +89,11 @@ def _reset_model_cover(base_path):
|
||||
async def api_delete_model(request):
|
||||
try:
|
||||
data = await request.json()
|
||||
except ValueError:
|
||||
data = None
|
||||
if not isinstance(data, dict):
|
||||
return web.json_response({"status": "error", "message": "Invalid request body"}, status=400)
|
||||
try:
|
||||
folder_type = data.get('type', 'checkpoints')
|
||||
subfolder = data.get('subfolder', '/')
|
||||
filename = data.get('filename', '')
|
||||
@@ -86,43 +105,33 @@ async def api_delete_model(request):
|
||||
try:
|
||||
filename = require_filename(filename)
|
||||
_, target_dir = resolve_folder_subdir(folder_type, path_idx, subfolder)
|
||||
model_path = resolve_within(target_dir, filename)
|
||||
model_path = model_file_within(target_dir, filename)
|
||||
except (ValueError, KeyError):
|
||||
return web.json_response({"status": "error", "message": "Invalid request parameters"}, status=400)
|
||||
if not os.path.exists(model_path):
|
||||
return web.json_response({"status": "error", "message": "Model file not found"})
|
||||
|
||||
# 1. 优先尝试删除你点击的主模型文件
|
||||
try:
|
||||
os.remove(model_path)
|
||||
except Exception as e:
|
||||
error_msg = str(e)
|
||||
if "being used" in error_msg or "WinError 32" in error_msg or "Permission" in error_msg:
|
||||
error_msg = "文件被占用 (正在被 ComfyUI 使用)。请先重启 ComfyUI 或在工作流中卸载该模型后再删除！"
|
||||
return web.json_response({"status": "error", "message": f"主模型删除失败: {error_msg}"})
|
||||
|
||||
base_name = os.path.splitext(filename)[0]
|
||||
|
||||
# 2. 主模型成功删除后，再清理配套的垃圾文件
|
||||
# Sidecars are keyed by stem, not by the main model extension. If a
|
||||
# second real model shares this stem, preserve the shared sidecars for
|
||||
# the survivor instead of treating that model as cleanup debris.
|
||||
shared_stem_in_use = any(
|
||||
os.path.isfile(os.path.join(target_dir, base_name + model_ext))
|
||||
for model_ext in MODEL_EXTENSIONS
|
||||
for model_ext in MODEL_EXTENSIONS if base_name + model_ext != filename
|
||||
)
|
||||
deleted_files = [filename]
|
||||
if not shared_stem_in_use:
|
||||
for suffix in SIDECAR_SUFFIXES:
|
||||
file_to_del = os.path.join(target_dir, base_name + suffix)
|
||||
if os.path.isfile(file_to_del):
|
||||
try:
|
||||
os.remove(file_to_del)
|
||||
deleted_files.append(base_name + suffix)
|
||||
except Exception as e:
|
||||
print(f"[Anomalous Browser] Warning: Failed to delete {file_to_del}: {e}")
|
||||
|
||||
# 3. 修正：前端期待的成功状态是 "success" 而不是 "ok"
|
||||
sidecars = [] if shared_stem_in_use else [
|
||||
path for path, _ in existing(os.path.join(target_dir, base_name), SIDECAR_SUFFIXES)
|
||||
]
|
||||
# The model and its covers and info go to the Recycle Bin together, or nothing moves.
|
||||
try:
|
||||
moved = move_to_trash(model_path, *sidecars)
|
||||
except Exception as e:
|
||||
return web.json_response({"status": "error", "message": trash_failure(e)})
|
||||
drop_empty_hidden_dir(target_dir)
|
||||
deleted_files = [os.path.basename(path) for path in moved]
|
||||
request[ACTIVITY_DETAIL] = {"files": deleted_files}
|
||||
|
||||
# 前端期待的成功状态是 "success" 而不是 "ok"
|
||||
return web.json_response({
|
||||
"status": "success",
|
||||
"deleted": deleted_files,
|
||||
@@ -135,6 +144,10 @@ async def api_delete_model(request):
|
||||
return web.json_response({"status": "error", "message": str(e)}, status=500)
|
||||
|
||||
|
||||
def _is_web_link(text):
|
||||
return not text or (len(text) <= 2048 and re.fullmatch(r"https?://[^\s/]+\.\S+", text, re.IGNORECASE) is not None)
|
||||
|
||||
|
||||
async def api_update_metadata(request):
|
||||
try:
|
||||
data = await request.json()
|
||||
@@ -163,7 +176,7 @@ async def api_update_metadata(request):
|
||||
try:
|
||||
filename = require_filename(extracted_filename)
|
||||
_, target_dir = resolve_folder_subdir(folder_type, path_idx, subfolder)
|
||||
file_path = resolve_within(target_dir, filename)
|
||||
file_path = model_file_within(target_dir, filename)
|
||||
except (ValueError, KeyError):
|
||||
pass
|
||||
|
||||
@@ -183,6 +196,9 @@ async def api_update_metadata(request):
|
||||
|
||||
if not file_path or not os.path.exists(file_path):
|
||||
return web.json_response({"status": "error", "message": "Model not found"})
|
||||
# A source link is opened from the page: a web address or nothing.
|
||||
if custom_source_url is not None and not _is_web_link(str(custom_source_url).strip()):
|
||||
return web.json_response({"status": "error", "message": "The source link must be an http(s) address."}, status=400)
|
||||
|
||||
physical_rename_skipped = physical_rename_requested and is_physical_rename_protected(
|
||||
folder_type=folder_type,
|
||||
@@ -192,28 +208,19 @@ async def api_update_metadata(request):
|
||||
|
||||
base_name = os.path.splitext(file_path)[0]
|
||||
model_ext = os.path.splitext(file_path)[1]
|
||||
info_file = f"{base_name}.civitai.info"
|
||||
|
||||
info_data = {}
|
||||
if os.path.exists(info_file):
|
||||
parsed = False
|
||||
for enc in ['utf-8', 'utf-8-sig', 'mbcs', 'latin-1']:
|
||||
try:
|
||||
with open(info_file, 'r', encoding=enc) as f:
|
||||
info_data = json.load(f)
|
||||
parsed = True
|
||||
break
|
||||
except Exception:
|
||||
pass
|
||||
if not parsed:
|
||||
return web.json_response({"status": "error", "message": "Failed to parse existing .civitai.info file due to encoding or corruption. Rename aborted to prevent data loss."})
|
||||
|
||||
# The user's edits have a file of their own (<model>.anomalous.json): a scan never
|
||||
# writes it, and other tools that rewrite .civitai.info cannot lose them.
|
||||
user_file = target(base_name, USER_INFO_SUFFIX)
|
||||
if os.path.exists(user_file) and read_json(user_file) is None:
|
||||
return web.json_response({"status": "error", "message": f"{os.path.basename(user_file)} is unreadable; nothing was changed."})
|
||||
user_data = read_json(user_file) or {"format": 1}
|
||||
before = get_metadata(file_path) # what was shown, for the activity log
|
||||
if 'custom_name' in data:
|
||||
info_data["anomalous_custom_name"] = custom_name
|
||||
user_data["custom_name"] = str(custom_name)
|
||||
if 'custom_notes' in data:
|
||||
info_data["anomalous_custom_notes"] = custom_notes
|
||||
user_data["custom_notes"] = str(custom_notes)
|
||||
if custom_source_url is not None:
|
||||
info_data["anomalous_source_url"] = str(custom_source_url).strip()
|
||||
user_data["source_url"] = str(custom_source_url).strip()
|
||||
|
||||
reset_cover = data.get('reset_cover', False)
|
||||
cover_reset = None
|
||||
@@ -222,8 +229,7 @@ async def api_update_metadata(request):
|
||||
if reset_cover:
|
||||
cover_reset, cover_reset_source, cover_reset_warning = _reset_model_cover(base_name)
|
||||
|
||||
with open(info_file, 'w', encoding='utf-8') as f:
|
||||
json.dump(info_data, f, indent=4, ensure_ascii=False)
|
||||
atomic_write_json(user_file, user_data)
|
||||
|
||||
new_filename = filename
|
||||
|
||||
@@ -237,15 +243,20 @@ async def api_update_metadata(request):
|
||||
if new_file_path != file_path and not os.path.exists(new_file_path):
|
||||
os.rename(file_path, new_file_path)
|
||||
|
||||
for suffix in SIDECAR_SUFFIXES:
|
||||
old_sidecar = f"{base_name}{suffix}"
|
||||
if os.path.isfile(old_sidecar):
|
||||
os.rename(old_sidecar, os.path.join(target_dir, f"{safe_name}{suffix}"))
|
||||
for old_sidecar, suffix in existing(base_name, SIDECAR_SUFFIXES):
|
||||
os.rename(old_sidecar, follow(old_sidecar, os.path.join(target_dir, safe_name), suffix))
|
||||
|
||||
new_filename = f"{safe_name}{model_ext}"
|
||||
elif os.path.exists(new_file_path) and new_file_path != file_path:
|
||||
return web.json_response({"status": "error", "message": "A file with the target physical name already exists."})
|
||||
|
||||
sent = [key for key in ("custom_name", "custom_notes") if key in data]
|
||||
sent += ["source_url"] if custom_source_url is not None else []
|
||||
fields = [{"field": key, "before": before.get(key) or "", "after": user_data[key]}
|
||||
for key in sent if user_data[key] != (before.get(key) or "")]
|
||||
if new_filename != filename:
|
||||
fields.append({"field": "filename", "before": filename, "after": new_filename})
|
||||
request[ACTIVITY_DETAIL] = {"fields": fields}
|
||||
response_data = {
|
||||
"status": "success",
|
||||
"new_filename": new_filename,
|
||||
|
||||
@@ -0,0 +1,313 @@
|
||||
"""Models in the wrong models folder, and identical copies (the models page's Tidy view,
|
||||
ui_model_tidy.js).
|
||||
|
||||
GET /anomalous/placement/check[?deep=1] -> {misplaced, duplicates, unchecked}
|
||||
misplaced: models whose header (model_kind.py, only when sure) names another type than
|
||||
the folder they are in, with where they belong (the same subfolder in a folder of that
|
||||
type, on the same drive when there is one) and whether they still load where they are.
|
||||
duplicates: files with the same SHA-256 — known from scans, else read now for files of
|
||||
the same size (small ones always, large ones with deep). unchecked: the same-size large
|
||||
files a deep check would still read.
|
||||
GET /anomalous/placement/look?type&root&rel -> {kind, sure, base}: what one model's header says
|
||||
it is, even when unsure (the models page's "Change type", ui_model_retype.js).
|
||||
POST /anomalous/placement/move {type, root, rel, to_type, to_root, to_rel} -> moves a model
|
||||
and its sidecars (covers, info, the user's notes); never over a file (" (2)"). Only for
|
||||
the computer ComfyUI runs on, unless remote changes are allowed (local_guard.may_change).
|
||||
|
||||
belongs() is the same check for one file (the AI's search_models and move_model,
|
||||
api/mcp_model_use.py). Removing a copy goes through /anomalous/delete_model (Recycle Bin). Headers and computed
|
||||
SHA-256s are kept in memory per file (path, size, time).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import threading
|
||||
import urllib.parse
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
try:
|
||||
from ..model_identity import file_sha256
|
||||
from ..model_kind import inspect_file
|
||||
from ..model_sidecars import drop_empty_hidden_dir, existing, follow
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from model_identity import file_sha256
|
||||
from model_kind import inspect_file
|
||||
from model_sidecars import drop_empty_hidden_dir, existing, follow
|
||||
from .activity_log import add_entry
|
||||
from .local_guard import may_change
|
||||
from .metadata import get_metadata
|
||||
from .model_constants import MEDIA_EXTENSIONS, PREVIEW_SUFFIXES, SIDECAR_SUFFIXES
|
||||
from .model_download import MODEL_EXTENSIONS, clean_folder, forget_file_lists
|
||||
from .model_import import Refused, destination, import_types, move_into
|
||||
from .path_utils import model_reference_within
|
||||
|
||||
# (folder type, what the file is): it loads there all the same.
|
||||
WORKS_ANYWAY = {("diffusion_models", "checkpoints")}
|
||||
# Same-size files up to this are read at once (LoRAs, embeddings); larger ones on "Compare".
|
||||
AUTO_HASH = 256 * 1024 * 1024
|
||||
CACHE_LIMIT = 5000
|
||||
|
||||
_lock = threading.Lock()
|
||||
_heads = {} # path -> (size, mtime_ns, inspect_file result)
|
||||
_hashes = {} # path -> (size, mtime_ns, sha256)
|
||||
|
||||
|
||||
def _cached(store, path, stat, compute):
|
||||
key = (stat.st_size, stat.st_mtime_ns)
|
||||
with _lock:
|
||||
hit = store.get(path)
|
||||
if hit and hit[:2] == key:
|
||||
return hit[2]
|
||||
value = compute(path)
|
||||
with _lock:
|
||||
if len(store) >= CACHE_LIMIT:
|
||||
store.clear()
|
||||
store[path] = (*key, value)
|
||||
return value
|
||||
|
||||
|
||||
def library():
|
||||
"""Every model file once: [{type, root, rel, path, size, dev}] (a folder listed under two
|
||||
types counts for the first)."""
|
||||
seen, files = set(), []
|
||||
for folder_type in import_types():
|
||||
for index, base in enumerate(folder_paths.get_folder_paths(folder_type) or []):
|
||||
if not os.path.isdir(base):
|
||||
continue
|
||||
for current, dirs, names in os.walk(base):
|
||||
dirs[:] = sorted(name for name in dirs if not name.startswith("."))
|
||||
for name in sorted(names):
|
||||
if not name.lower().endswith(MODEL_EXTENSIONS):
|
||||
continue
|
||||
path = os.path.join(current, name)
|
||||
real = os.path.realpath(path)
|
||||
if real in seen:
|
||||
continue
|
||||
seen.add(real)
|
||||
try:
|
||||
stat = os.stat(path)
|
||||
except OSError:
|
||||
continue
|
||||
files.append({"type": folder_type, "root": index, "rel": os.path.relpath(path, base).replace(os.sep, "/"),
|
||||
"path": path, "size": stat.st_size, "dev": stat.st_dev, "stat": stat})
|
||||
return files
|
||||
|
||||
|
||||
def _card(item):
|
||||
"""What the page shows of a file: its name (the user's, else Civitai's, else the file's),
|
||||
Civitai version and cover URL."""
|
||||
try:
|
||||
meta = get_metadata(item["path"])
|
||||
except Exception:
|
||||
meta = {}
|
||||
folder, name = os.path.split(item["path"])
|
||||
stem = os.path.splitext(name)[0]
|
||||
cover = next((stem + suffix for suffix in PREVIEW_SUFFIXES + MEDIA_EXTENSIONS
|
||||
if os.path.isfile(os.path.join(folder, stem + suffix))), "")
|
||||
sub = item["rel"].rpartition("/")[0]
|
||||
url = ""
|
||||
if cover:
|
||||
url = (f"/anomalous/image?type={urllib.parse.quote(item['type'])}&path_idx={item['root']}"
|
||||
f"&subfolder={urllib.parse.quote(sub)}&filename={urllib.parse.quote(cover)}")
|
||||
version = meta.get("version_name") or ""
|
||||
name = meta.get("custom_name") or ""
|
||||
if not name and meta.get("model_id"): # Civitai's "Model - Version": the model's part
|
||||
full = meta.get("name") or ""
|
||||
name = full[:-len(" - " + version)] if version and full.endswith(" - " + version) else full
|
||||
return {"name": name or stem, "version": version, "preview_url": url}
|
||||
|
||||
|
||||
def home_for(item, kind):
|
||||
"""Where a file of `kind` goes: its own subfolder and name, in a folder of that type,
|
||||
preferably on its drive (a move is then a rename)."""
|
||||
roots = []
|
||||
for index, base in enumerate(folder_paths.get_folder_paths(kind) or []):
|
||||
if os.path.isdir(base):
|
||||
roots.append((index, os.stat(base).st_dev))
|
||||
if not roots:
|
||||
return None
|
||||
index = next((index for index, dev in roots if dev == item["dev"]), roots[0][0])
|
||||
return {"type": kind, "root": index, "rel": item["rel"]}
|
||||
|
||||
|
||||
def misplaced(files):
|
||||
found = []
|
||||
for item in files:
|
||||
result = _cached(_heads, item["path"], item["stat"], inspect_file)
|
||||
kind = result.get("kind")
|
||||
if not kind or not result.get("sure") or kind == item["type"] or kind not in import_types():
|
||||
continue
|
||||
home = home_for(item, kind)
|
||||
if home:
|
||||
found.append({"type": item["type"], "root": item["root"], "rel": item["rel"], "size": item["size"],
|
||||
"kind": kind, "base": result.get("base", ""), "works": (item["type"], kind) in WORKS_ANYWAY,
|
||||
"to": home, **_card(item)})
|
||||
return found
|
||||
|
||||
|
||||
def one(folder_type, root, rel, path):
|
||||
"""One model file as library() lists it."""
|
||||
stat = os.stat(path)
|
||||
return {"type": folder_type, "root": root, "rel": rel, "path": path, "size": stat.st_size, "dev": stat.st_dev, "stat": stat}
|
||||
|
||||
|
||||
def belongs(item):
|
||||
"""misplaced() of one file (from one()): where it belongs, or None when it is where it goes or its kind is unsure."""
|
||||
found = misplaced([item])
|
||||
return found[0] if found else None
|
||||
|
||||
|
||||
def _known_hash(item):
|
||||
try:
|
||||
value = str(get_metadata(item["path"]).get("hash") or "").lower()
|
||||
except Exception:
|
||||
value = ""
|
||||
if len(value) == 64:
|
||||
return value
|
||||
with _lock:
|
||||
hit = _hashes.get(item["path"])
|
||||
return hit[2] if hit and hit[:2] == (item["stat"].st_size, item["stat"].st_mtime_ns) else ""
|
||||
|
||||
|
||||
def _copy(item):
|
||||
"""One of identical files: where it is, how it shows, whether its folder fits what it is
|
||||
(the copy to keep, when only one does)."""
|
||||
kind = _cached(_heads, item["path"], item["stat"], inspect_file).get("kind")
|
||||
return {"type": item["type"], "root": item["root"], "rel": item["rel"],
|
||||
"fits": not kind or kind == item["type"], **_card(item)}
|
||||
|
||||
|
||||
def duplicates(files, deep=False):
|
||||
"""(groups of identical files, {groups, bytes} still to read for a deep check)."""
|
||||
by_size = {}
|
||||
for item in files:
|
||||
if item["size"]:
|
||||
by_size.setdefault(item["size"], []).append(item)
|
||||
groups, unchecked = {}, {"groups": 0, "bytes": 0}
|
||||
for size, items in by_size.items():
|
||||
if len(items) < 2:
|
||||
continue
|
||||
unknown = [item for item in items if not _known_hash(item)]
|
||||
read = deep or size <= AUTO_HASH
|
||||
if unknown and not read:
|
||||
unchecked["groups"] += 1
|
||||
unchecked["bytes"] += size * len(unknown)
|
||||
for item in items:
|
||||
sha = _known_hash(item)
|
||||
if not sha and read:
|
||||
sha = _cached(_hashes, item["path"], item["stat"], file_sha256)
|
||||
if sha:
|
||||
groups.setdefault(sha, []).append(item)
|
||||
found = [{"sha256": sha, "size": items[0]["size"], "files": [_copy(item) for item in items]}
|
||||
for sha, items in groups.items() if len(items) > 1]
|
||||
return found, unchecked
|
||||
|
||||
|
||||
def check(deep=False):
|
||||
files = library()
|
||||
found, unchecked = duplicates(files, deep)
|
||||
return {"misplaced": misplaced(files), "duplicates": found, "unchecked": unchecked, "checked": len(files)}
|
||||
|
||||
|
||||
def _sidecars(path):
|
||||
"""The model's covers, info and notes: files named by its stem, beside it or in the folder's
|
||||
.amb, unless another model in its folder has that stem too (then they are shared, and stay)."""
|
||||
folder, name = os.path.split(path)
|
||||
stem = os.path.splitext(name)[0]
|
||||
if any(os.path.isfile(os.path.join(folder, stem + ext)) for ext in MODEL_EXTENSIONS if stem + ext != name):
|
||||
return []
|
||||
return existing(os.path.join(folder, stem), SIDECAR_SUFFIXES)
|
||||
|
||||
|
||||
def _source(folder_type, root, rel):
|
||||
"""(root index, clean rel, file) of the model at type `folder_type`, root index `root`, `rel`."""
|
||||
if folder_type not in import_types():
|
||||
raise Refused("bad_type")
|
||||
paths = folder_paths.get_folder_paths(folder_type) or []
|
||||
try:
|
||||
index = int(root)
|
||||
if index < 0:
|
||||
raise IndexError(index)
|
||||
base = os.path.realpath(paths[index])
|
||||
rel = clean_folder(rel)
|
||||
source = model_reference_within(base, rel.replace("/", os.sep))
|
||||
except (ValueError, TypeError, IndexError):
|
||||
raise Refused("bad_path")
|
||||
if not os.path.isfile(source) or not rel.lower().endswith(MODEL_EXTENSIONS):
|
||||
raise Refused("gone")
|
||||
return index, rel, source
|
||||
|
||||
|
||||
def look(folder_type, root, rel):
|
||||
"""What the header of one model says it is: {type, root, rel, kind, sure, base}."""
|
||||
index, rel, source = _source(folder_type, root, rel)
|
||||
found = _cached(_heads, source, os.stat(source), inspect_file)
|
||||
return {"type": folder_type, "root": index, "rel": rel, "kind": found.get("kind") or "",
|
||||
"sure": bool(found.get("sure")), "base": found.get("base") or ""}
|
||||
|
||||
|
||||
def move(data):
|
||||
folder_type = data.get("type")
|
||||
index, rel, source = _source(folder_type, data.get("root", 0), data.get("rel"))
|
||||
to_type, to_root, root_path, dest = destination(
|
||||
{"type": data.get("to_type"), "root": data.get("to_root", 0), "rel": data.get("to_rel")}, os.path.getsize(source))
|
||||
sidecars = _sidecars(source)
|
||||
move_into(source, dest, keep=False)
|
||||
moved, left = [os.path.basename(dest)], []
|
||||
dest_stem = os.path.splitext(dest)[0]
|
||||
for path, suffix in sidecars:
|
||||
target = follow(path, dest_stem, suffix)
|
||||
try:
|
||||
if os.path.exists(target):
|
||||
raise FileExistsError(target)
|
||||
move_into(path, target, keep=False)
|
||||
moved.append(os.path.basename(target))
|
||||
except OSError as error:
|
||||
left.append(os.path.basename(path))
|
||||
print(f"[Anomalous Browser] Tidy: {os.path.basename(path)} stayed where it was: {error}")
|
||||
drop_empty_hidden_dir(os.path.dirname(source))
|
||||
forget_file_lists()
|
||||
to_rel = os.path.relpath(dest, root_path).replace(os.sep, "/")
|
||||
add_entry("file", "model_move", to_rel, {"move": {
|
||||
"from": {"type": folder_type, "path_idx": index, "rel": rel},
|
||||
"to": {"type": to_type, "path_idx": to_root, "rel": to_rel}, "files": moved, "left": left,
|
||||
}})
|
||||
return {"type": to_type, "root": to_root, "rel": to_rel, "left": left}
|
||||
|
||||
|
||||
async def api_check(request):
|
||||
deep = request.query.get("deep") == "1"
|
||||
return web.json_response(await asyncio.to_thread(check, deep))
|
||||
|
||||
|
||||
async def api_look(request):
|
||||
query = request.query
|
||||
try:
|
||||
return web.json_response(await asyncio.to_thread(look, query.get("type"), query.get("root", "0"), query.get("rel")))
|
||||
except Refused as error:
|
||||
return web.json_response({"error": error.code}, status=404 if error.code == "gone" else 400)
|
||||
|
||||
|
||||
async def api_move(request):
|
||||
if not may_change(request):
|
||||
return web.json_response({"error": "not_local"}, status=403)
|
||||
try:
|
||||
data = await request.json()
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError
|
||||
return web.json_response(await asyncio.to_thread(move, data))
|
||||
except Refused as error:
|
||||
return web.json_response({"error": error.code}, status=404 if error.code == "gone" else 400)
|
||||
except ValueError:
|
||||
return web.json_response({"error": "bad_request"}, status=400)
|
||||
except OSError as error:
|
||||
print(f"[Anomalous Browser] Tidy: could not move the model: {error}")
|
||||
return web.json_response({"error": "io"}, status=500)
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
app.router.add_get("/anomalous/placement/check", api_check)
|
||||
app.router.add_get("/anomalous/placement/look", api_look)
|
||||
app.router.add_post("/anomalous/placement/move", api_move)
|
||||
+8
-10
@@ -3,16 +3,17 @@
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import struct
|
||||
import threading
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
try:
|
||||
from ..model_identity import computed_file_identity, normalise_sha256
|
||||
from ..model_identity import computed_file_identity, file_sha256, infer_base_model_from_header, normalise_sha256
|
||||
from ..model_sidecars import find, target
|
||||
except ImportError:
|
||||
from model_identity import computed_file_identity, normalise_sha256
|
||||
from model_identity import computed_file_identity, file_sha256, infer_base_model_from_header, normalise_sha256
|
||||
from model_sidecars import find, target
|
||||
try:
|
||||
from ..model_policies import requires_hash_for_model_recovery
|
||||
except ImportError:
|
||||
@@ -106,14 +107,12 @@ def _size_candidate_payload(candidate, require_hash=False):
|
||||
def _compute_and_save_fallback_info(file_path, file_hash):
|
||||
try:
|
||||
base_path = os.path.splitext(file_path)[0]
|
||||
info_path = base_path + ".info"
|
||||
civitai_info_path = base_path + ".civitai.info"
|
||||
if os.path.exists(info_path) or os.path.exists(civitai_info_path):
|
||||
info_path = info_path if os.path.exists(info_path) else civitai_info_path
|
||||
info_path = find(base_path, ".info") or (civitai_info_path if os.path.exists(civitai_info_path) else None)
|
||||
if info_path:
|
||||
with open(info_path, encoding='utf-8') as source:
|
||||
info_data = json.load(source)
|
||||
else:
|
||||
from scraper import infer_base_model_from_header
|
||||
filename = os.path.basename(file_path)
|
||||
inferred_base = infer_base_model_from_header(file_path) if file_path.lower().endswith('.safetensors') else ""
|
||||
if inferred_base == 'Unknown':
|
||||
@@ -131,7 +130,7 @@ def _compute_and_save_fallback_info(file_path, file_hash):
|
||||
"files": [{"hashes": {"SHA256": file_hash.lower()}}]
|
||||
}
|
||||
info_data["anomalous_file_identity"] = computed_file_identity(file_path, file_hash)
|
||||
atomic_write_json(info_path, info_data)
|
||||
atomic_write_json(info_path or target(base_path, ".info"), info_data)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
@@ -159,10 +158,9 @@ def _resolve_from_candidates(candidates, target_hash="", target_size=None, filen
|
||||
# dynamically compute their hash on-demand to test against target_hash
|
||||
unhashed_size_matches = [c for c in size_matches if not _candidate_hashes(c)]
|
||||
if unhashed_size_matches:
|
||||
from scraper import calculate_sha256
|
||||
for candidate in unhashed_size_matches:
|
||||
try:
|
||||
computed_hash = calculate_sha256(candidate["path"]).upper()
|
||||
computed_hash = file_sha256(candidate["path"]).upper()
|
||||
candidate.setdefault("hashes", set()).add(computed_hash)
|
||||
if computed_hash == target_hash:
|
||||
_compute_and_save_fallback_info(candidate["path"], computed_hash)
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
"""One model type as a single list: a models folder and all its subfolders (the models page's type chips).
|
||||
|
||||
Listing a type also queues its covers' card images for the background (media_routes).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import urllib.parse
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
from .model_catalog import _collect_folder_models
|
||||
from .media_routes import queue_card_images
|
||||
|
||||
|
||||
def _collect_type_models(folder_type, path_idx):
|
||||
"""Every model under one registered models folder, folder by folder in name order."""
|
||||
try:
|
||||
base_dir = folder_paths.get_folder_paths(folder_type)[path_idx]
|
||||
except Exception:
|
||||
return []
|
||||
if not os.path.isdir(base_dir):
|
||||
return []
|
||||
models = []
|
||||
for root, dirs, _files in os.walk(base_dir):
|
||||
dirs.sort(key=str.lower)
|
||||
rel = os.path.relpath(root, base_dir).replace('\\', '/')
|
||||
models += _collect_folder_models(root, folder_type, path_idx, '' if rel == '.' else rel, 1, 0)["models"]
|
||||
return models
|
||||
|
||||
|
||||
async def api_get_type_models(request):
|
||||
"""GET /anomalous/type_models?type&path_idx - {models, total}; each model names its own subfolder."""
|
||||
try:
|
||||
path_idx = int(request.query.get('path_idx', 0))
|
||||
except ValueError:
|
||||
path_idx = -1
|
||||
if path_idx < 0:
|
||||
return web.json_response({"status": "error", "message": "Invalid path_idx"}, status=400)
|
||||
models = await asyncio.to_thread(_collect_type_models, request.query.get('type', ''), path_idx)
|
||||
queue_card_images(_cover_paths(models))
|
||||
return web.json_response({"models": models, "total": len(models)})
|
||||
|
||||
|
||||
def _cover_paths(models):
|
||||
"""The cover file of each listed model: it sits beside the model, named in its preview URL."""
|
||||
paths = []
|
||||
for model in models:
|
||||
query = urllib.parse.urlparse(model.get("preview_url") or "").query
|
||||
name = urllib.parse.parse_qs(query).get("filename", [""])[0]
|
||||
if name and model.get("file_path"):
|
||||
paths.append(os.path.join(os.path.dirname(model["file_path"]), name))
|
||||
return paths
|
||||
@@ -0,0 +1,365 @@
|
||||
"""When each model and node pack here was last used (the models page's Tidy tab, "Not used lately").
|
||||
|
||||
GET /anomalous/usage/check -> {models, packs, seen, now, ledger_since}
|
||||
Evidence, read only when the user asks:
|
||||
- the run record (usage_ledger.py): every run since it started, kept or not, and every
|
||||
workflow opened on the page (the open tabs are noted just before a check);
|
||||
- the outputs from before that: PNG images (their prompt names model files and node types;
|
||||
image_search.cached_record) and FLAC / Ogg sounds (audio_metadata), dated by the file;
|
||||
- the saved ComfyUI workflows, recipes, combos and parameter sets (any string naming a model
|
||||
file, any node type, any SHA-256).
|
||||
A model counts as used when its path, its file name (two files of one name: both count, the
|
||||
safe side) or its scanned SHA-256 appears.
|
||||
Nothing new is judged: a model or pack counts as idle since its last use or since it came
|
||||
here (`added`: the file's or folder's creation date), whichever is later.
|
||||
models: idle for 30 days or more, with {type, root, rel, size, name, version, preview_url,
|
||||
last_used (seconds or null), outputs, runs, opened, saved (saved files naming it), added}.
|
||||
packs: the node packs in custom_nodes but this plugin and ComfyUI Manager, {name, nodes,
|
||||
last_used, outputs, runs, opened, saved, added, web (it adds to ComfyUI's page too), feeds (packs
|
||||
whose nodes take a kind of thing only its nodes make), words (what to search the Manager
|
||||
for), kept (the user said they still use it)}; a pack of no nodes only works on the page or
|
||||
the server, nothing here can tell.
|
||||
seen: {outputs, saved, capped} what was read (capped: some outputs or files were not).
|
||||
ledger_since: when the run record started (null: nothing run since).
|
||||
|
||||
POST /anomalous/usage/keep {pack, kept} -> {kept: [names]}
|
||||
What no record can show (a pack used only through its panels or buttons) the user says:
|
||||
"I still use it", kept in user/anomalous/usage_kept.json ({packs: {name: since}}); only a
|
||||
pack ComfyUI loaded can be marked, any name unmarked.
|
||||
|
||||
What none of this can show (a workflow from before the record, dropped in and never saved) is
|
||||
said on the page; nothing here deletes or disables anything.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import threading
|
||||
import time
|
||||
|
||||
import folder_paths
|
||||
from aiohttp import web
|
||||
|
||||
from . import usage_ledger
|
||||
from .audio_metadata import read_audio_tags
|
||||
from .backup import part_dirs
|
||||
from .image_search import MODEL_FILE, cached_record
|
||||
from .model_placement import _card, _known_hash, library
|
||||
from .path_utils import atomic_write_json
|
||||
|
||||
RECENT_SECONDS = 30 * 24 * 3600 # used or added within this: not listed
|
||||
MAX_IMAGES = 100_000 # outputs read at most, images and sounds
|
||||
MAX_SAVED = 20_000
|
||||
MAX_JSON_BYTES = 20 * 1024 * 1024
|
||||
SAVED_PARTS = ("comfy_workflows", "recipes", "combos", "parameters")
|
||||
SOUNDS = (".flac", ".ogg", ".opus")
|
||||
SHA256 = re.compile(r"^[0-9a-fA-F]{64}$")
|
||||
PLUGIN_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
NOT_LISTED = {os.path.basename(PLUGIN_DIR).lower(), "comfyui-manager"} # the tools doing the tidying
|
||||
FEEDS_SHOWN = 3
|
||||
# Words left out of what the Manager is searched for: its search wants all words, in order, in
|
||||
# one of a pack's title, author or description, and pack folders carry these where titles do not.
|
||||
SEARCH_NOISE = {"comfyui", "comfy", "custom", "customnodes", "node", "nodes", "pack", "main", "master"}
|
||||
|
||||
_kept_lock = threading.Lock()
|
||||
|
||||
|
||||
def _refs(value):
|
||||
ref = str(value).replace("\\", "/").strip().lower()
|
||||
return {ref, ref.rsplit("/", 1)[-1]}
|
||||
|
||||
|
||||
def _arrived(stat, changed=True):
|
||||
"""When a file or folder came here: its creation date, or its last change when that is later
|
||||
(`changed`; a copied file keeps its old change date, a folder's changes with every update)."""
|
||||
born = getattr(stat, "st_birthtime", None) or stat.st_ctime
|
||||
return max(born, stat.st_mtime) if changed else born
|
||||
|
||||
|
||||
class Evidence:
|
||||
"""Per model reference / hash / node type: how many outputs, runs, openings and saved files,
|
||||
and the latest time."""
|
||||
|
||||
def __init__(self):
|
||||
self.outputs, self.runs, self.opened, self.saved, self.last = {}, {}, {}, {}, {}
|
||||
self.seen = {"outputs": 0, "saved": 0, "capped": False}
|
||||
|
||||
def add(self, keys, when=None):
|
||||
for key in keys:
|
||||
if when is None:
|
||||
self.saved[key] = self.saved.get(key, 0) + 1
|
||||
else:
|
||||
self.outputs[key] = self.outputs.get(key, 0) + 1
|
||||
self.last[key] = max(self.last.get(key, 0), when)
|
||||
|
||||
def add_noted(self, counts, key, when, count):
|
||||
"""A run record entry; `counts` is self.runs or self.opened."""
|
||||
counts[key] = counts.get(key, 0) + count
|
||||
self.last[key] = max(self.last.get(key, 0), when)
|
||||
|
||||
def of(self, keys):
|
||||
keys = [key for key in keys if key]
|
||||
last = max((self.last.get(key, 0) for key in keys), default=0)
|
||||
return {"last_used": last or None,
|
||||
**{kind: max((counts.get(key, 0) for key in keys), default=0)
|
||||
for kind, counts in (("outputs", self.outputs), ("runs", self.runs), ("opened", self.opened), ("saved", self.saved))}}
|
||||
|
||||
|
||||
def _walk_json(value, found):
|
||||
"""Model references ('m:'), SHA-256s ('h:') and node types ('t:') anywhere in saved JSON."""
|
||||
stack = [value]
|
||||
while stack:
|
||||
item = stack.pop()
|
||||
if isinstance(item, dict):
|
||||
for key in ("type", "class_type"):
|
||||
if isinstance(item.get(key), str) and item[key]:
|
||||
found.add("t:" + item[key])
|
||||
stack.extend(item.values())
|
||||
elif isinstance(item, list):
|
||||
stack.extend(item)
|
||||
elif isinstance(item, str):
|
||||
if MODEL_FILE.search(item):
|
||||
found.update("m:" + ref for ref in _refs(item))
|
||||
elif SHA256.match(item):
|
||||
found.add("h:" + item.upper())
|
||||
|
||||
|
||||
def _read_saved(evidence):
|
||||
dirs = part_dirs()
|
||||
for part in SAVED_PARTS:
|
||||
base = dirs.get(part)
|
||||
if not base or not os.path.isdir(base):
|
||||
continue
|
||||
for current, folders, names in os.walk(base):
|
||||
folders[:] = [name for name in folders if not name.startswith(".")]
|
||||
for name in names:
|
||||
if not name.lower().endswith(".json"):
|
||||
continue
|
||||
if evidence.seen["saved"] >= MAX_SAVED:
|
||||
evidence.seen["capped"] = True
|
||||
return
|
||||
path = os.path.join(current, name)
|
||||
try:
|
||||
if os.path.getsize(path) > MAX_JSON_BYTES:
|
||||
continue
|
||||
with open(path, encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
found = set()
|
||||
_walk_json(data, found)
|
||||
evidence.seen["saved"] += 1
|
||||
evidence.add(found)
|
||||
|
||||
|
||||
def _sound_keys(path):
|
||||
"""What a sound's embedded prompt names, as evidence keys; empty without one."""
|
||||
try:
|
||||
prompt = json.loads(read_audio_tags(path).get("prompt") or "null")
|
||||
except (OSError, ValueError):
|
||||
return set()
|
||||
if not isinstance(prompt, dict):
|
||||
return set()
|
||||
types, models = usage_ledger.prompt_uses(prompt)
|
||||
return {"t:" + node_type for node_type in types} | {"m:" + ref for model in models for ref in _refs(model)}
|
||||
|
||||
|
||||
def _read_outputs(evidence):
|
||||
base = folder_paths.get_output_directory()
|
||||
for current, folders, names in os.walk(base):
|
||||
folders[:] = [name for name in folders if not name.startswith(".")]
|
||||
for name in names:
|
||||
lower = name.lower()
|
||||
if not lower.endswith((".png",) + SOUNDS):
|
||||
continue
|
||||
if evidence.seen["outputs"] >= MAX_IMAGES:
|
||||
evidence.seen["capped"] = True
|
||||
return
|
||||
path = os.path.join(current, name)
|
||||
try:
|
||||
when = os.stat(path).st_mtime
|
||||
except OSError:
|
||||
continue
|
||||
if lower.endswith(SOUNDS):
|
||||
keys = _sound_keys(path)
|
||||
else:
|
||||
record = cached_record(path, when)
|
||||
if not record:
|
||||
continue
|
||||
keys = {"m:" + ref for ref in record["models"]} | {"h:" + sha for sha in record["hashes"]}
|
||||
keys |= {"t:" + node_type for node_type in record.get("types", ())}
|
||||
if not keys:
|
||||
continue
|
||||
evidence.seen["outputs"] += 1
|
||||
evidence.add(keys, when)
|
||||
|
||||
|
||||
def _read_ledger(evidence):
|
||||
"""Every run and opened workflow since the record started; its start, or None."""
|
||||
ledger = usage_ledger.read()
|
||||
for names, counts in ((ledger, evidence.runs), (ledger["opened"], evidence.opened)):
|
||||
for node_type, (when, count) in names["types"].items():
|
||||
evidence.add_noted(counts, "t:" + node_type, when, count)
|
||||
for model, (when, count) in names["models"].items():
|
||||
for ref in _refs(model):
|
||||
evidence.add_noted(counts, "m:" + ref, when, count)
|
||||
return ledger["started"]
|
||||
|
||||
|
||||
def _io_types(cls):
|
||||
"""(kinds of thing a node takes, kinds it makes); combo lists and '*' left out."""
|
||||
taken, made = set(), set()
|
||||
try:
|
||||
inputs = cls.INPUT_TYPES() or {}
|
||||
for group in ("required", "optional"):
|
||||
for spec in (inputs.get(group) or {}).values():
|
||||
kind = spec[0] if isinstance(spec, (list, tuple)) and spec else spec
|
||||
if isinstance(kind, str):
|
||||
taken.add(kind)
|
||||
except Exception: # noqa: BLE001 - a pack's own code; it only means "takes nothing known"
|
||||
pass
|
||||
try:
|
||||
made = {kind for kind in (cls.RETURN_TYPES or ()) if isinstance(kind, str)}
|
||||
except Exception: # noqa: BLE001
|
||||
pass
|
||||
return taken - {"*"}, made - {"*"}
|
||||
|
||||
|
||||
def _search_words(name):
|
||||
words = [word for word in re.split(r"[\s_.\-]+", name.lower()) if word and word not in SEARCH_NOISE]
|
||||
return " ".join(words) or name.lower()
|
||||
|
||||
|
||||
def _pack_dirs():
|
||||
"""{name: {name, path, dir, types: []}} for the node packs ComfyUI loaded from custom_nodes."""
|
||||
import nodes # ComfyUI's registry, filled once ComfyUI has loaded the packs
|
||||
|
||||
roots = []
|
||||
try:
|
||||
roots = [os.path.normcase(os.path.realpath(root)) for root in folder_paths.get_folder_paths("custom_nodes") or []]
|
||||
except Exception: # noqa: BLE001
|
||||
pass
|
||||
packs = {}
|
||||
for module, directory in (getattr(nodes, "LOADED_MODULE_DIRS", {}) or {}).items():
|
||||
real = os.path.normcase(os.path.realpath(directory))
|
||||
name = os.path.splitext(os.path.basename(module))[0]
|
||||
if real in roots: # a single .py file in custom_nodes
|
||||
packs[name] = {"name": name, "path": os.path.join(directory, name + ".py"), "dir": None, "types": []}
|
||||
elif os.path.normcase(os.path.realpath(os.path.dirname(directory))) in roots:
|
||||
packs[name] = {"name": name, "path": directory, "dir": real, "types": []}
|
||||
return packs
|
||||
|
||||
|
||||
def _packs():
|
||||
"""[{name, path, dir, types, web, feeds}] for the node packs ComfyUI loaded from custom_nodes."""
|
||||
import nodes
|
||||
|
||||
packs = _pack_dirs()
|
||||
io, core = {}, set()
|
||||
for node_type, cls in (getattr(nodes, "NODE_CLASS_MAPPINGS", {}) or {}).items():
|
||||
module = str(getattr(cls, "RELATIVE_PYTHON_MODULE", "") or "")
|
||||
taken, made = _io_types(cls)
|
||||
pack = module.split(".", 2)[1] if module.startswith("custom_nodes.") else None
|
||||
if pack in packs:
|
||||
packs[pack]["types"].append(node_type)
|
||||
io.setdefault(pack, [set(), set()])
|
||||
io[pack][0] |= taken
|
||||
io[pack][1] |= made
|
||||
elif pack is None:
|
||||
core |= taken | made
|
||||
|
||||
web_dirs = [os.path.normcase(os.path.realpath(path)) for path in (getattr(nodes, "EXTENSION_WEB_DIRS", {}) or {}).values()]
|
||||
for name, pack in packs.items():
|
||||
pack["web"] = bool(pack["dir"]) and any(path == pack["dir"] or path.startswith(pack["dir"] + os.sep) for path in web_dirs)
|
||||
own = io.get(name, [set(), set()])[1] - core
|
||||
pack["feeds"] = sorted((other for other, (taken, _) in io.items() if other != name and own & taken), key=str.lower)
|
||||
return [pack for name, pack in packs.items() if name.lower() not in NOT_LISTED]
|
||||
|
||||
|
||||
def kept_path():
|
||||
return os.path.join(os.path.dirname(usage_ledger.ledger_path()), "usage_kept.json")
|
||||
|
||||
|
||||
def _kept():
|
||||
"""{pack name: since} the user still uses."""
|
||||
try:
|
||||
with open(kept_path(), encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
except (OSError, ValueError):
|
||||
return {}
|
||||
packs = data.get("packs") if isinstance(data, dict) else None
|
||||
return packs if isinstance(packs, dict) else {}
|
||||
|
||||
|
||||
def keep(name, kept):
|
||||
"""Marks pack `name` as still used (`kept`) or not; the names marked. KeyError: not a loaded pack."""
|
||||
with _kept_lock:
|
||||
packs = _kept()
|
||||
if kept:
|
||||
if name not in _pack_dirs() or name.lower() in NOT_LISTED:
|
||||
raise KeyError(name)
|
||||
packs[name] = time.time()
|
||||
else:
|
||||
packs.pop(name, None)
|
||||
atomic_write_json(kept_path(), {"packs": packs})
|
||||
return sorted(packs)
|
||||
|
||||
|
||||
def check(now=None):
|
||||
now = time.time() if now is None else now
|
||||
evidence = Evidence()
|
||||
ledger_since = _read_ledger(evidence)
|
||||
_read_saved(evidence)
|
||||
_read_outputs(evidence)
|
||||
|
||||
models = []
|
||||
for item in library():
|
||||
keys = ["m:" + ref for ref in _refs(item["rel"])]
|
||||
sha = _known_hash(item)
|
||||
if sha:
|
||||
keys.append("h:" + sha.upper())
|
||||
use = evidence.of(keys)
|
||||
added = _arrived(item["stat"]) if item.get("stat") else None
|
||||
if now - max(use["last_used"] or 0, added or 0) < RECENT_SECONDS:
|
||||
continue
|
||||
models.append({"type": item["type"], "root": item["root"], "rel": item["rel"], "size": item["size"],
|
||||
"added": added, **_card(item), **use})
|
||||
|
||||
packs, kept = [], _kept()
|
||||
for pack in sorted(_packs(), key=lambda entry: entry["name"].lower()):
|
||||
uses = [evidence.of(["t:" + node_type]) for node_type in pack["types"]]
|
||||
try:
|
||||
added = _arrived(os.stat(pack["path"]), changed=False)
|
||||
except OSError:
|
||||
added = None
|
||||
packs.append({"name": pack["name"], "nodes": len(pack["types"]), "added": added, "web": pack["web"],
|
||||
"feeds": pack["feeds"][:FEEDS_SHOWN], "words": _search_words(pack["name"]), "kept": pack["name"] in kept,
|
||||
"last_used": max((use["last_used"] or 0 for use in uses), default=0) or None,
|
||||
**{kind: max((use[kind] for use in uses), default=0) for kind in ("outputs", "runs", "opened", "saved")}})
|
||||
return {"models": models, "packs": packs, "seen": evidence.seen, "now": now, "ledger_since": ledger_since}
|
||||
|
||||
|
||||
async def api_check(request):
|
||||
return web.json_response(await asyncio.to_thread(check))
|
||||
|
||||
|
||||
async def api_keep(request):
|
||||
try:
|
||||
data = await request.json()
|
||||
except ValueError:
|
||||
data = None
|
||||
name, kept = (data.get("pack"), data.get("kept")) if isinstance(data, dict) else (None, None)
|
||||
if not isinstance(name, str) or not name or not isinstance(kept, bool):
|
||||
return web.json_response({"error": "bad_request"}, status=400)
|
||||
try:
|
||||
return web.json_response({"kept": await asyncio.to_thread(keep, name, kept)})
|
||||
except KeyError:
|
||||
return web.json_response({"error": "unknown_pack"}, status=404)
|
||||
except (OSError, ValueError):
|
||||
return web.json_response({"error": "write_failed"}, status=500)
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
app.router.add_get("/anomalous/usage/check", api_check)
|
||||
app.router.add_post("/anomalous/usage/keep", api_keep)
|
||||
+1
-1
@@ -10,7 +10,7 @@ from .model_catalog import (
|
||||
_allowed_folder_types, _collect_all_scan_models, _collect_folder_models,
|
||||
_collect_folders, _find_model_sync, _iter_search_models, _model_info_for_path,
|
||||
_resolve_paths_to_model_info_sync, _resolve_paths_to_previews_sync,
|
||||
api_base_models, api_batch_select, api_compatible_models, api_find_model,
|
||||
api_base_models, api_compatible_models, api_find_model,
|
||||
api_get_all_scan_models, api_get_folders, api_get_models,
|
||||
api_resolve_paths_to_previews,
|
||||
)
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
"""GET /anomalous/civitai_check: whether this computer reaches Civitai now, through the proxy in
|
||||
Settings -> Network when one is set (net_proxy.py); for Settings' "Test" button and the first-run
|
||||
setup. One small request with the key, if one is set, so a key Civitai refuses is told apart;
|
||||
when civitai.com does not answer, Civitai's other address (civitai.red) is asked too, and the
|
||||
answer says which one answered (`host`). It goes online, so it answers this computer only
|
||||
(local_guard LOCAL_GETS)."""
|
||||
|
||||
import asyncio
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from .download_sources import civitai_headers
|
||||
|
||||
try:
|
||||
from ..civitai_client import API_HOSTS, answered
|
||||
from ..net_proxy import configured, failure, urlopen
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from civitai_client import API_HOSTS, answered
|
||||
from net_proxy import configured, failure, urlopen
|
||||
|
||||
PROBE_PATH = "/api/v1/models?limit=1"
|
||||
TIMEOUT = 8
|
||||
|
||||
|
||||
def check_civitai():
|
||||
"""{reachable, key ('set' | 'none' | 'refused'), ms, error, failure (net_proxy.failure), proxy,
|
||||
host (the address that answered, or '')}."""
|
||||
headers = civitai_headers()
|
||||
key = "set" if "Authorization" in headers else "none"
|
||||
started = time.monotonic()
|
||||
|
||||
def answer(reachable, key, error="", why="", host=""):
|
||||
return {"reachable": reachable, "key": key, "ms": round((time.monotonic() - started) * 1000),
|
||||
"error": error, "failure": why, "proxy": configured(), "host": host}
|
||||
first = None
|
||||
for host in API_HOSTS:
|
||||
try:
|
||||
with urlopen(urllib.request.Request(f"https://{host}{PROBE_PATH}", headers=headers), timeout=TIMEOUT) as response:
|
||||
response.read(1024)
|
||||
answered(host)
|
||||
return answer(True, key, host=host)
|
||||
except urllib.error.HTTPError as error:
|
||||
# Civitai answered: the network is fine; 401/403 with a key means the key is refused.
|
||||
answered(host)
|
||||
if error.code in (401, 403) and key == "set":
|
||||
return answer(True, "refused", f"HTTP {error.code}", failure(error), host)
|
||||
return answer(error.code < 500, key, f"HTTP {error.code}", failure(error), host)
|
||||
except (urllib.error.URLError, OSError, ValueError) as error:
|
||||
reason = getattr(error, "reason", None) or error
|
||||
first = first or answer(False, key, str(reason)[:200], failure(error))
|
||||
return first
|
||||
|
||||
|
||||
async def api_civitai_check(request):
|
||||
return web.json_response(await asyncio.to_thread(check_civitai))
|
||||
|
||||
|
||||
def register_routes(app):
|
||||
app.router.add_get("/anomalous/civitai_check", api_civitai_check)
|
||||
@@ -0,0 +1,65 @@
|
||||
"""Saving one canvas node's current values as a parameter material (the current-node panel's "save")."""
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from . import materials
|
||||
from .material_schema import MAX_MATERIAL_NAME_LENGTH, _material_summary, _normalise_material_tags
|
||||
from .notebooks import MAX_NOTEBOOK_BYTES
|
||||
|
||||
|
||||
def _node_material(payload):
|
||||
node = payload.get("node")
|
||||
if not isinstance(node, dict):
|
||||
raise ValueError("Invalid node")
|
||||
node_type = node.get("type")
|
||||
if not isinstance(node_type, str) or not node_type.strip() or len(node_type) > 200:
|
||||
raise ValueError("Invalid node type")
|
||||
values = node.get("widgets_values")
|
||||
if not isinstance(values, list) or not values:
|
||||
raise ValueError("Invalid node values")
|
||||
encoded = json.dumps([node_type, values], ensure_ascii=False, allow_nan=False, sort_keys=True)
|
||||
if len(encoded.encode("utf-8")) > MAX_NOTEBOOK_BYTES:
|
||||
raise ValueError("Node values are too large")
|
||||
title = node.get("title") if isinstance(node.get("title"), str) else ""
|
||||
title = title.strip()[:200] or node_type
|
||||
name = payload.get("name") or title
|
||||
if not isinstance(name, str) or not (name := name.strip()) or len(name) > MAX_MATERIAL_NAME_LENGTH:
|
||||
raise ValueError("Invalid material name")
|
||||
return {
|
||||
"schema_version": materials.MATERIAL_SCHEMA_VERSION,
|
||||
"id": uuid.uuid4().hex,
|
||||
"kind": "node_parameter_selection",
|
||||
"name": name,
|
||||
"tags": _normalise_material_tags(payload.get("tags", [])),
|
||||
"timestamp": int(time.time() * 1000),
|
||||
"source": {
|
||||
"type": "canvas_node",
|
||||
"parameter_name": title,
|
||||
"parameter_signature": hashlib.sha256(encoded.encode("utf-8")).hexdigest(),
|
||||
},
|
||||
"workflow": {"nodes": [{"id": 1, "type": node_type, "title": title, "widgets_values": values}]},
|
||||
"selection": {"scope": "nodes", "node_ids": [1]},
|
||||
"capabilities": ["apply_node_parameters"],
|
||||
}
|
||||
|
||||
|
||||
async def api_save_node_material(request):
|
||||
try:
|
||||
material = _node_material(await request.json())
|
||||
except (AttributeError, TypeError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Invalid node material"}, status=400)
|
||||
filename = f"material_{int(time.time())}_{material['id']}.json"
|
||||
try:
|
||||
duplicate = await asyncio.to_thread(
|
||||
materials._persist_parameter_material, materials.get_materials_dir(), filename, material, False)
|
||||
except (OSError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Could not save node material"}, status=500)
|
||||
if duplicate:
|
||||
return web.json_response({"status": "duplicate", "filename": duplicate["filename"], "name": duplicate["name"]}, status=409)
|
||||
return web.json_response({"status": "success", "filename": filename, "material": _material_summary(filename, material)})
|
||||
+127
-123
@@ -1,136 +1,140 @@
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import threading
|
||||
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
from .utils import atomic_write_json, require_filename, resolve_within
|
||||
|
||||
|
||||
MAX_NOTEBOOK_BYTES = 2 * 1024 * 1024
|
||||
LEGACY_NOTEBOOKS_DIR = os.path.join(os.path.dirname(__file__), "notebooks")
|
||||
_notebooks_lock = threading.RLock()
|
||||
|
||||
|
||||
def _read_notebook(path):
|
||||
if os.path.getsize(path) > MAX_NOTEBOOK_BYTES:
|
||||
raise ValueError("Notebook is too large")
|
||||
with open(path, encoding="utf-8") as source:
|
||||
data = json.load(source)
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError("Invalid notebook")
|
||||
return data
|
||||
|
||||
|
||||
def _migrate_notebooks(directory):
|
||||
marker = resolve_within(directory, ".legacy_imported.json")
|
||||
if os.path.exists(marker):
|
||||
return
|
||||
skipped = []
|
||||
if os.path.isdir(LEGACY_NOTEBOOKS_DIR):
|
||||
for filename in sorted(os.listdir(LEGACY_NOTEBOOKS_DIR)):
|
||||
if not filename.endswith(".json") or filename.startswith("."):
|
||||
continue
|
||||
try:
|
||||
source = resolve_within(LEGACY_NOTEBOOKS_DIR, require_filename(filename))
|
||||
data = _read_notebook(source)
|
||||
except (OSError, ValueError):
|
||||
skipped.append(filename)
|
||||
logging.warning("Anomalous: could not migrate notebook %s; original preserved", filename)
|
||||
continue
|
||||
target = resolve_within(directory, filename)
|
||||
if os.path.exists(target):
|
||||
try:
|
||||
if _read_notebook(target) == data:
|
||||
continue
|
||||
except (OSError, ValueError):
|
||||
pass
|
||||
digest = hashlib.sha256(json.dumps(data, sort_keys=True).encode()).hexdigest()[:12]
|
||||
recovered = f"{os.path.splitext(filename)[0][:100]}_legacy_{digest}.json"
|
||||
target = resolve_within(directory, recovered)
|
||||
if os.path.exists(target):
|
||||
if _read_notebook(target) != data:
|
||||
raise ValueError("Conflicting migrated notebook")
|
||||
continue
|
||||
atomic_write_json(target, data, MAX_NOTEBOOK_BYTES)
|
||||
atomic_write_json(marker, {"version": 1, "skipped": skipped})
|
||||
|
||||
|
||||
def get_notebooks_dir():
|
||||
user_dir = folder_paths.get_user_directory()
|
||||
directory = os.path.join(user_dir, "workflows", "anomalous_notebooks")
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
with _notebooks_lock:
|
||||
_migrate_notebooks(directory)
|
||||
return directory
|
||||
|
||||
|
||||
def _list_notebooks():
|
||||
with _notebooks_lock:
|
||||
directory = get_notebooks_dir()
|
||||
notebooks = []
|
||||
for filename in sorted(os.listdir(directory)):
|
||||
if not filename.endswith(".json") or filename.startswith("."):
|
||||
continue
|
||||
try:
|
||||
data = _read_notebook(resolve_within(directory, filename))
|
||||
notebooks.append({"filename": filename, "name": data.get("name", filename[:-5]), "data": data})
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
return notebooks
|
||||
|
||||
from .trash import move_to_trash
|
||||
from .utils import atomic_write_json, require_filename, resolve_within
|
||||
|
||||
|
||||
MAX_NOTEBOOK_BYTES = 2 * 1024 * 1024
|
||||
LEGACY_NOTEBOOKS_DIR = os.path.join(os.path.dirname(__file__), "notebooks")
|
||||
_notebooks_lock = threading.RLock()
|
||||
|
||||
|
||||
def _read_notebook(path):
|
||||
if os.path.getsize(path) > MAX_NOTEBOOK_BYTES:
|
||||
raise ValueError("Notebook is too large")
|
||||
with open(path, encoding="utf-8") as source:
|
||||
data = json.load(source)
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError("Invalid notebook")
|
||||
return data
|
||||
|
||||
|
||||
def _migrate_notebooks(directory):
|
||||
marker = resolve_within(directory, ".legacy_imported.json")
|
||||
if os.path.exists(marker):
|
||||
return
|
||||
skipped = []
|
||||
if os.path.isdir(LEGACY_NOTEBOOKS_DIR):
|
||||
for filename in sorted(os.listdir(LEGACY_NOTEBOOKS_DIR)):
|
||||
if not filename.endswith(".json") or filename.startswith("."):
|
||||
continue
|
||||
try:
|
||||
source = resolve_within(LEGACY_NOTEBOOKS_DIR, require_filename(filename))
|
||||
data = _read_notebook(source)
|
||||
except (OSError, ValueError):
|
||||
skipped.append(filename)
|
||||
logging.warning("Anomalous: could not migrate notebook %s; original preserved", filename)
|
||||
continue
|
||||
target = resolve_within(directory, filename)
|
||||
if os.path.exists(target):
|
||||
try:
|
||||
if _read_notebook(target) == data:
|
||||
continue
|
||||
except (OSError, ValueError):
|
||||
pass
|
||||
digest = hashlib.sha256(json.dumps(data, sort_keys=True).encode()).hexdigest()[:12]
|
||||
recovered = f"{os.path.splitext(filename)[0][:100]}_legacy_{digest}.json"
|
||||
target = resolve_within(directory, recovered)
|
||||
if os.path.exists(target):
|
||||
if _read_notebook(target) != data:
|
||||
raise ValueError("Conflicting migrated notebook")
|
||||
continue
|
||||
atomic_write_json(target, data, MAX_NOTEBOOK_BYTES)
|
||||
atomic_write_json(marker, {"version": 1, "skipped": skipped})
|
||||
|
||||
|
||||
def get_notebooks_dir():
|
||||
user_dir = folder_paths.get_user_directory()
|
||||
directory = os.path.join(user_dir, "workflows", "anomalous_notebooks")
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
with _notebooks_lock:
|
||||
_migrate_notebooks(directory)
|
||||
return directory
|
||||
|
||||
|
||||
def _list_notebooks():
|
||||
with _notebooks_lock:
|
||||
directory = get_notebooks_dir()
|
||||
notebooks = []
|
||||
for filename in sorted(os.listdir(directory)):
|
||||
if not filename.endswith(".json") or filename.startswith("."):
|
||||
continue
|
||||
try:
|
||||
data = _read_notebook(resolve_within(directory, filename))
|
||||
notebooks.append({"filename": filename, "name": data.get("name", filename[:-5]), "data": data})
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
return notebooks
|
||||
|
||||
|
||||
async def api_get_notebooks(request):
|
||||
try:
|
||||
notebooks = await asyncio.to_thread(_list_notebooks)
|
||||
return web.json_response({"notebooks": notebooks})
|
||||
except (OSError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Could not load notebooks"}, status=500)
|
||||
|
||||
|
||||
def _save_notebook(filename, data):
|
||||
with _notebooks_lock:
|
||||
atomic_write_json(resolve_within(get_notebooks_dir(), filename), data, MAX_NOTEBOOK_BYTES)
|
||||
|
||||
try:
|
||||
notebooks = await asyncio.to_thread(_list_notebooks)
|
||||
return web.json_response({"notebooks": notebooks})
|
||||
except (OSError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Could not load notebooks"}, status=500)
|
||||
|
||||
|
||||
def _save_notebook(filename, data):
|
||||
with _notebooks_lock:
|
||||
atomic_write_json(resolve_within(get_notebooks_dir(), filename), data, MAX_NOTEBOOK_BYTES)
|
||||
|
||||
|
||||
async def api_save_notebook(request):
|
||||
try:
|
||||
payload = await request.json()
|
||||
filename = require_filename(payload.get("filename", ""))
|
||||
if filename.startswith("."):
|
||||
raise ValueError("Invalid notebook filename")
|
||||
if not filename.endswith(".json"):
|
||||
filename += ".json"
|
||||
data = payload.get("data")
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError("Invalid notebook")
|
||||
await asyncio.to_thread(_save_notebook, filename, data)
|
||||
payload = await request.json()
|
||||
filename = require_filename(payload.get("filename", ""))
|
||||
if filename.startswith("."):
|
||||
raise ValueError("Invalid notebook filename")
|
||||
if not filename.endswith(".json"):
|
||||
filename += ".json"
|
||||
data = payload.get("data")
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError("Invalid notebook")
|
||||
await asyncio.to_thread(_save_notebook, filename, data)
|
||||
return web.json_response({"status": "success"})
|
||||
except (AttributeError, TypeError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Invalid notebook"}, status=400)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not save notebook"}, status=500)
|
||||
|
||||
|
||||
def _delete_notebook(filename):
|
||||
with _notebooks_lock:
|
||||
os.remove(resolve_within(get_notebooks_dir(), filename))
|
||||
|
||||
except (AttributeError, TypeError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Invalid notebook"}, status=400)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not save notebook"}, status=500)
|
||||
|
||||
|
||||
def _delete_notebook(filename):
|
||||
with _notebooks_lock:
|
||||
path = resolve_within(get_notebooks_dir(), filename)
|
||||
if not os.path.isfile(path):
|
||||
raise FileNotFoundError(path)
|
||||
move_to_trash(path)
|
||||
|
||||
|
||||
async def api_delete_notebook(request):
|
||||
try:
|
||||
payload = await request.json()
|
||||
filename = require_filename(payload.get("filename", ""))
|
||||
if not filename.endswith(".json") or filename.startswith("."):
|
||||
raise ValueError("Invalid notebook filename")
|
||||
await asyncio.to_thread(_delete_notebook, filename)
|
||||
return web.json_response({"status": "success"})
|
||||
except (AttributeError, TypeError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Invalid notebook"}, status=400)
|
||||
except FileNotFoundError:
|
||||
return web.json_response({"status": "error", "message": "Notebook not found"}, status=404)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not delete notebook"}, status=500)
|
||||
payload = await request.json()
|
||||
filename = require_filename(payload.get("filename", ""))
|
||||
if not filename.endswith(".json") or filename.startswith("."):
|
||||
raise ValueError("Invalid notebook filename")
|
||||
await asyncio.to_thread(_delete_notebook, filename)
|
||||
return web.json_response({"status": "success"})
|
||||
except (AttributeError, TypeError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Invalid notebook"}, status=400)
|
||||
except FileNotFoundError:
|
||||
return web.json_response({"status": "error", "message": "Notebook not found"}, status=404)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not delete notebook"}, status=500)
|
||||
|
||||
+58
-3
@@ -9,9 +9,10 @@ from aiohttp import web
|
||||
import folder_paths
|
||||
from .utils import require_filename, resolve_within
|
||||
from .recipe_constants import MAX_RECIPE_BYTES
|
||||
from .recipe_images import _parameter_gallery_images
|
||||
from .recipe_images import _parameter_gallery_images, _pictures_by_signature
|
||||
from .recipe_store import get_recipes_dir, _read_recipe
|
||||
from .workflow_schema import _parameter_signature
|
||||
from .trash import move_to_trash
|
||||
|
||||
def get_parameters_dir():
|
||||
# Store parameter notebooks in the user directory
|
||||
@@ -49,6 +50,42 @@ async def api_get_parameters(request):
|
||||
return web.json_response({"notebooks": notebooks})
|
||||
|
||||
|
||||
MAX_COUNTED_NOTEBOOKS = 5000
|
||||
|
||||
|
||||
def _parameter_set_signatures(parameters_dir):
|
||||
"""Each recipe's parameter sets by their values' signature: {recipe filename: [signature]},
|
||||
so the page can leave out the set saved with the recipe itself. Files over the save limit,
|
||||
unreadable ones and any past the first MAX_COUNTED_NOTEBOOKS are skipped."""
|
||||
sets = {}
|
||||
try:
|
||||
filenames = sorted(name for name in os.listdir(parameters_dir) if name.endswith(".json"))
|
||||
except OSError:
|
||||
return sets
|
||||
for filename in filenames[:MAX_COUNTED_NOTEBOOKS]:
|
||||
try:
|
||||
file_path = resolve_within(parameters_dir, filename)
|
||||
if os.path.getsize(file_path) > MAX_RECIPE_BYTES:
|
||||
continue
|
||||
with open(file_path, "r", encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
if not isinstance(data, dict):
|
||||
continue
|
||||
recipe_filename = data.get("recipe_filename")
|
||||
signature = data.get("parameter_signature")
|
||||
value = signature.get("value") if isinstance(signature, dict) else None
|
||||
if isinstance(recipe_filename, str) and recipe_filename:
|
||||
sets.setdefault(recipe_filename, []).append(value if isinstance(value, str) else "")
|
||||
return sets
|
||||
|
||||
|
||||
async def api_get_parameter_set_signatures(request):
|
||||
sets = await asyncio.to_thread(_parameter_set_signatures, get_parameters_dir())
|
||||
return web.json_response({"sets": sets})
|
||||
|
||||
|
||||
_parameter_notebooks_cache = None
|
||||
_parameter_notebooks_cache_time = 0
|
||||
|
||||
@@ -151,10 +188,12 @@ async def api_get_parameters_by_type(request):
|
||||
if recipe_fn not in grouped:
|
||||
grouped[recipe_fn] = []
|
||||
|
||||
signature = (nb.get("data", {}).get("parameter_signature") or {})
|
||||
grouped[recipe_fn].append({
|
||||
"filename": nb.get("filename"),
|
||||
"name": nb.get("name"),
|
||||
"timestamp": nb.get("timestamp"),
|
||||
"signature": signature.get("value") if isinstance(signature, dict) else "",
|
||||
"nodes": matched_nodes
|
||||
})
|
||||
|
||||
@@ -295,8 +334,7 @@ async def api_delete_parameter(request):
|
||||
try:
|
||||
parameters_dir = get_parameters_dir()
|
||||
file_path = resolve_within(parameters_dir, filename)
|
||||
if os.path.exists(file_path):
|
||||
os.remove(file_path)
|
||||
move_to_trash(file_path)
|
||||
_invalidate_parameter_notebooks_cache()
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not delete parameter notebook"}, status=500)
|
||||
@@ -349,6 +387,23 @@ async def api_rename_parameter(request):
|
||||
|
||||
return web.json_response({"status": "success", "filename": filename, "name": new_name})
|
||||
|
||||
MAX_PICTURE_SIGNATURES = 64
|
||||
|
||||
|
||||
async def api_get_parameter_pictures(request):
|
||||
"""GET /anomalous/parameter_pictures?signatures=a,b - for Current node: how many recent
|
||||
output pictures were made with each parameter set's values, and the newest, in one pass."""
|
||||
signatures = {value.lower() for value in request.query.get("signatures", "").split(",") if value}
|
||||
if not signatures or len(signatures) > MAX_PICTURE_SIGNATURES \
|
||||
or any(not re.fullmatch(r"[0-9a-f]{64}", value) for value in signatures):
|
||||
return web.json_response({"status": "error", "message": "Invalid signatures"}, status=400)
|
||||
try:
|
||||
pictures, scanned = await asyncio.to_thread(_pictures_by_signature, signatures)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not read the pictures"}, status=500)
|
||||
return web.json_response({"status": "success", "pictures": pictures, "scanned": scanned})
|
||||
|
||||
|
||||
async def api_get_parameter_gallery(request):
|
||||
"""Find recent output PNGs whose embedded parameters match one parameter notebook."""
|
||||
try:
|
||||
|
||||
+18
-4
@@ -32,16 +32,30 @@ def _model_roots():
|
||||
yield folder_type, path_index, os.path.realpath(base_dir)
|
||||
|
||||
|
||||
def model_file_within(directory, filename):
|
||||
"""The model file `filename` (a bare name) in `directory`, which was resolved inside its
|
||||
models folder already, as named: a model that is a link stays the link (on a cloud server
|
||||
the models folder links into a shared, read-only model disk). Its covers and info are the
|
||||
ones beside the link, edits are written there and a delete moves the link; only the folder
|
||||
part must stay inside the models folder, and the name cannot leave it."""
|
||||
return os.path.join(directory, require_filename(filename))
|
||||
|
||||
|
||||
def model_reference_within(base_dir, relative):
|
||||
"""model_file_within for a path relative to the models folder `base_dir` (subfolders and
|
||||
a file name): the subfolders must stay inside it, through links too."""
|
||||
head, name = os.path.split(relative)
|
||||
return model_file_within(resolve_within(base_dir, head), name)
|
||||
|
||||
|
||||
def _resolve_exact_model_reference(saved_value):
|
||||
"""Resolve one saved model value without recursive scanning or hashing."""
|
||||
if not isinstance(saved_value, str) or not saved_value.strip():
|
||||
return None
|
||||
relative_value = saved_value.replace("/", os.sep)
|
||||
for folder_type, path_index, base_dir in _model_roots():
|
||||
candidate = os.path.realpath(os.path.join(base_dir, relative_value))
|
||||
try:
|
||||
if os.path.commonpath((base_dir, candidate)) != base_dir:
|
||||
continue
|
||||
candidate = model_reference_within(base_dir, relative_value)
|
||||
except ValueError:
|
||||
continue
|
||||
if not os.path.isfile(candidate) or not candidate.lower().endswith(MODEL_FILE_SUFFIXES):
|
||||
@@ -68,7 +82,7 @@ def resolve_folder_subdir(folder_type, path_idx=0, subfolder='/'):
|
||||
|
||||
|
||||
def require_filename(filename):
|
||||
if not isinstance(filename, str) or not filename or os.path.basename(filename) != filename:
|
||||
if not isinstance(filename, str) or filename in ("", ".", "..") or os.path.basename(filename) != filename:
|
||||
raise ValueError("Invalid filename")
|
||||
return filename
|
||||
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
"""Every model file in a few words, for the canvas's quick search (GET /anomalous/quick_index,
|
||||
web/modules/quick_search_data.js): its folder type, place and file, the name it shows, its
|
||||
base model, a few trigger words and its cover's URL. Read once when the search bar opens;
|
||||
the bar keeps it a little while. Files a folder type shares with another (unet and
|
||||
diffusion_models) are listed once; node packs' own files are not models."""
|
||||
|
||||
import asyncio
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from .model_catalog import _collect_all_scan_models
|
||||
|
||||
MAX_WORDS = 6
|
||||
|
||||
|
||||
def _words(meta):
|
||||
words = meta.get("trainedWords") or meta.get("trigger_words") or []
|
||||
if isinstance(words, str):
|
||||
words = [words]
|
||||
return [str(word) for word in words if str(word).strip()][:MAX_WORDS]
|
||||
|
||||
|
||||
def compact_models(models):
|
||||
"""`models` (the shape GET /anomalous/all_scan_models gives) in a few words each."""
|
||||
seen, found = set(), []
|
||||
for model in models:
|
||||
if model.get("type") == "custom_nodes":
|
||||
continue
|
||||
key = (model.get("subfolder") or "", model.get("filename"), model.get("size_bytes"))
|
||||
if key in seen:
|
||||
continue
|
||||
seen.add(key)
|
||||
meta = model.get("metadata") or {}
|
||||
found.append({
|
||||
"type": model.get("type"),
|
||||
"path_idx": model.get("path_idx", 0),
|
||||
"subfolder": model.get("subfolder") or "",
|
||||
"filename": model.get("filename"),
|
||||
"name": str(meta.get("custom_name") or "").strip(),
|
||||
"civitai_name": str(meta.get("name") or "").strip(),
|
||||
"base": str(meta.get("baseModel") or "").strip(),
|
||||
"words": _words(meta),
|
||||
"preview_url": model.get("preview_url") or "",
|
||||
})
|
||||
return found
|
||||
|
||||
|
||||
async def api_quick_index(request):
|
||||
payload = await asyncio.to_thread(_collect_all_scan_models, 1, 0)
|
||||
return web.json_response({"models": compact_models(payload.get("models") or [])})
|
||||
@@ -7,6 +7,9 @@ MAX_TAGS = 20
|
||||
MAX_TAG_LENGTH = 60
|
||||
MAX_NOTES_LENGTH = 3000
|
||||
MAX_MODEL_NOTE_LENGTH = 1000
|
||||
MAX_FOCUS_PARAMS = 12
|
||||
MAX_FOCUS_NOTE_LENGTH = 120
|
||||
MAX_FOCUS_NAME_LENGTH = 200
|
||||
MAX_THUMBNAIL_LENGTH = 1_500_000
|
||||
MAX_SOURCE_SUBFOLDER_LENGTH = 500
|
||||
MAX_RECIPE_BYTES = 12 * 1024 * 1024
|
||||
|
||||
+30
-1
@@ -1,6 +1,7 @@
|
||||
"""Contained Recipe image assets and bounded output-gallery inspection."""
|
||||
|
||||
from io import BytesIO
|
||||
from functools import lru_cache
|
||||
import hashlib
|
||||
import heapq
|
||||
import json
|
||||
@@ -192,6 +193,34 @@ def _recipe_gallery_images(node_signature):
|
||||
return matches, scanned
|
||||
|
||||
|
||||
@lru_cache(maxsize=4096)
|
||||
def _picture_parameter_signature(image_path, mtime_ns):
|
||||
"""A picture's parameter signature, read once per version of the file."""
|
||||
return _embedded_parameter_signature(image_path)
|
||||
|
||||
|
||||
def _pictures_by_signature(signatures):
|
||||
"""({signature: {"count", "newest": {filename, subfolder}}}, pictures read) for the recent
|
||||
output pictures made with each of `signatures`, newest first, in one pass."""
|
||||
output_dir = folder_paths.get_output_directory()
|
||||
found = {}
|
||||
if not os.path.isdir(output_dir):
|
||||
return found, 0
|
||||
scanned = 0
|
||||
for mtime_ns, image_path in _recent_output_pngs(output_dir):
|
||||
scanned += 1
|
||||
signature = _picture_parameter_signature(image_path, mtime_ns)
|
||||
if signature not in signatures:
|
||||
continue
|
||||
entry = found.setdefault(signature, {"count": 0, "newest": None})
|
||||
entry["count"] += 1
|
||||
if entry["newest"] is None:
|
||||
relative_dir = os.path.relpath(os.path.dirname(image_path), output_dir)
|
||||
entry["newest"] = {"filename": os.path.basename(image_path),
|
||||
"subfolder": "" if relative_dir == "." else relative_dir.replace("\\", "/")}
|
||||
return found, scanned
|
||||
|
||||
|
||||
def _parameter_gallery_images(parameter_signature):
|
||||
output_dir = folder_paths.get_output_directory()
|
||||
if not os.path.isdir(output_dir):
|
||||
@@ -200,7 +229,7 @@ def _parameter_gallery_images(parameter_signature):
|
||||
scanned = 0
|
||||
for mtime_ns, image_path in _recent_output_pngs(output_dir):
|
||||
scanned += 1
|
||||
if _embedded_parameter_signature(image_path) != parameter_signature:
|
||||
if _picture_parameter_signature(image_path, mtime_ns) != parameter_signature:
|
||||
continue
|
||||
relative_dir = os.path.relpath(os.path.dirname(image_path), output_dir)
|
||||
subfolder = "" if relative_dir == "." else relative_dir.replace("\\", "/")
|
||||
|
||||
+45
-80
@@ -1,4 +1,7 @@
|
||||
"""Bounded import/export for self-contained Workflow Recipe packages."""
|
||||
"""Recipe packages (配方包): one Workflow Recipe as a .zip to give to someone else — the recipe,
|
||||
its cover, its models' thumbnails and, when asked, its versions — and taking one in as a new
|
||||
recipe card. Bounded: entry names, count, sizes, compression ratio and checksums are checked
|
||||
before anything is written; an import never replaces a recipe (a taken name gets " (2)")."""
|
||||
|
||||
import hashlib
|
||||
import io
|
||||
@@ -9,6 +12,7 @@ import shutil
|
||||
import stat
|
||||
import tempfile
|
||||
import time
|
||||
import urllib.parse
|
||||
import uuid
|
||||
import zipfile
|
||||
|
||||
@@ -19,10 +23,6 @@ from .recipe_store import get_recipes_dir
|
||||
from .utils import require_filename, resolve_within
|
||||
|
||||
|
||||
# Release gates: package transfers stay closed until validation is complete.
|
||||
# Keep the format implementation for compatibility testing.
|
||||
RECIPE_PACKAGE_EXPORT_ENABLED = False
|
||||
RECIPE_PACKAGE_IMPORT_ENABLED = False
|
||||
PACKAGE_VERSION = 1
|
||||
MAX_UPLOAD_BYTES = 32 * 1024 * 1024
|
||||
MAX_ENTRY_COUNT = 256
|
||||
@@ -134,6 +134,18 @@ def _cover_asset_id(recipe):
|
||||
return require_filename(asset_id)
|
||||
|
||||
|
||||
def _picture_summary(recipe):
|
||||
"""What a package shows the receiver: (has a cover, how many model thumbnails). The cover
|
||||
is usually the small image inside recipe.json (`thumbnail`), not an asset file."""
|
||||
thumbnail = recipe.get("thumbnail")
|
||||
has_cover = bool(_cover_asset_id(recipe)) or (
|
||||
isinstance(thumbnail, str) and thumbnail.lower().startswith(recipe_schema.SAFE_THUMBNAIL_PREFIXES))
|
||||
references = recipe.get("params", {}).get("model_references", [])
|
||||
models = {_asset_id_from_reference(item) for item in references if isinstance(item, dict)} if isinstance(references, list) else set()
|
||||
models.discard(None)
|
||||
return has_cover, len(models)
|
||||
|
||||
|
||||
def _validate_manifest(manifest, archive, names):
|
||||
if not isinstance(manifest, dict) or manifest.get("package_version") != PACKAGE_VERSION:
|
||||
raise ValueError("Unsupported recipe package version")
|
||||
@@ -212,7 +224,7 @@ def _recipe_history_files(recipes_dir, filename):
|
||||
|
||||
|
||||
def _build_export(raw_recipe, recipes_dir, filename, options):
|
||||
include_snapshots = options.get("include_snapshots") is True
|
||||
include_snapshots = options.get("include_snapshots", True) is True
|
||||
include_history = options.get("include_history") is True
|
||||
include_identity = options.get("include_identity", True) is True
|
||||
include_model_notes = options.get("include_model_notes", True) is True
|
||||
@@ -372,42 +384,26 @@ def _write_staged_json(path, value):
|
||||
|
||||
|
||||
def _commit_import(record, payload):
|
||||
"""Writes the inspected package as a new recipe (never over one): (filename, name)."""
|
||||
recipes_dir = get_recipes_dir()
|
||||
package_recipe = json.loads(json.dumps(record["recipe"], ensure_ascii=False))
|
||||
collision = payload.get("collision", "rename")
|
||||
name_override = payload.get("name")
|
||||
if name_override is not None:
|
||||
if not isinstance(name_override, str) or not name_override.strip():
|
||||
raise ValueError("Invalid imported recipe name")
|
||||
package_recipe["name"] = name_override.strip()
|
||||
|
||||
existing_names = _existing_recipe_names(recipes_dir)
|
||||
target_filename = None
|
||||
if collision == "replace":
|
||||
target_filename = require_filename(payload.get("target_filename", ""))
|
||||
if not target_filename.endswith(".json"):
|
||||
raise ValueError("Invalid replacement target")
|
||||
if not os.path.isfile(resolve_within(recipes_dir, target_filename)):
|
||||
raise FileNotFoundError
|
||||
elif collision != "rename":
|
||||
raise ValueError("Unsupported collision choice")
|
||||
else:
|
||||
package_recipe["name"] = _unique_name(package_recipe.get("name", ""), existing_names)
|
||||
package_recipe["name"] = _unique_name(package_recipe.get("name", ""), _existing_recipe_names(recipes_dir))
|
||||
|
||||
normalized = recipe_schema._normalise_recipe(package_recipe)
|
||||
normalized["presentation"]["imported"] = True
|
||||
filename = target_filename or f"recipe_{int(time.time())}_{uuid.uuid4().hex[:8]}.json"
|
||||
filename = f"recipe_{int(time.time())}_{uuid.uuid4().hex[:8]}.json"
|
||||
normalized = recipe_schema._enrich_recipe(normalized)
|
||||
|
||||
staging = tempfile.mkdtemp(prefix=".recipe-import-", dir=recipes_dir)
|
||||
final_path = resolve_within(recipes_dir, filename)
|
||||
final_assets = recipe_images._recipe_assets_dir(recipes_dir, filename)
|
||||
final_history = recipe_store._history_dir(recipes_dir, filename)
|
||||
backup_recipe = None
|
||||
backup_assets = None
|
||||
backup_history = None
|
||||
installed_assets = False
|
||||
installed_history = False
|
||||
installed = []
|
||||
try:
|
||||
archive, _ = _validate_zip(record["raw"])
|
||||
with archive:
|
||||
@@ -419,54 +415,33 @@ def _commit_import(record, payload):
|
||||
for name in record["history_names"]:
|
||||
history = _parse_json(_read_zip_entry(archive, name), "historical recipe")
|
||||
_write_staged_json(os.path.join(history_stage, require_filename(name.split("/", 1)[1])), history)
|
||||
|
||||
if collision == "replace":
|
||||
backup_recipe = os.path.join(staging, "old-recipe.json")
|
||||
os.replace(final_path, backup_recipe)
|
||||
if os.path.isdir(final_assets):
|
||||
backup_assets = os.path.join(staging, "old-assets")
|
||||
shutil.move(final_assets, backup_assets)
|
||||
if record["history_names"] and os.path.isdir(final_history):
|
||||
backup_history = os.path.join(staging, "old-history")
|
||||
shutil.move(final_history, backup_history)
|
||||
|
||||
os.replace(os.path.join(staging, "recipe.json"), final_path)
|
||||
# The images first, the recipe last: a recipe card never shows without its pictures.
|
||||
staged_assets = os.path.join(staging, "assets")
|
||||
if os.path.isdir(staged_assets):
|
||||
if os.listdir(staged_assets):
|
||||
os.makedirs(os.path.dirname(final_assets), exist_ok=True)
|
||||
os.replace(staged_assets, final_assets)
|
||||
installed_assets = True
|
||||
installed.append(final_assets)
|
||||
if record["history_names"]:
|
||||
history_stage = os.path.join(staging, "history")
|
||||
if os.path.isdir(final_history):
|
||||
shutil.rmtree(final_history)
|
||||
os.replace(history_stage, final_history)
|
||||
installed_history = True
|
||||
os.makedirs(os.path.dirname(final_history), exist_ok=True)
|
||||
os.replace(os.path.join(staging, "history"), final_history)
|
||||
installed.append(final_history)
|
||||
os.replace(os.path.join(staging, "recipe.json"), final_path)
|
||||
except Exception:
|
||||
if collision == "replace" and backup_recipe and os.path.isfile(backup_recipe):
|
||||
if installed_assets and os.path.isdir(final_assets):
|
||||
shutil.rmtree(final_assets, ignore_errors=True)
|
||||
if installed_history and os.path.isdir(final_history):
|
||||
shutil.rmtree(final_history, ignore_errors=True)
|
||||
if os.path.isfile(final_path):
|
||||
os.remove(final_path)
|
||||
os.replace(backup_recipe, final_path)
|
||||
if backup_assets and os.path.isdir(backup_assets):
|
||||
shutil.move(backup_assets, final_assets)
|
||||
if backup_history and os.path.isdir(backup_history):
|
||||
shutil.move(backup_history, final_history)
|
||||
for path in installed: # this import's own new folders; nothing of the user's
|
||||
shutil.rmtree(path, ignore_errors=True)
|
||||
raise
|
||||
finally:
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
return filename, normalized.get("name", "")
|
||||
|
||||
|
||||
def _download_name(recipe, filename):
|
||||
"""The .zip's name for the browser: the recipe's name, safe on every system."""
|
||||
name = "".join("_" if char in '<>:"/\\|?*' or ord(char) < 32 else char for char in str(recipe.get("name") or "")).strip(" .")
|
||||
return f"{name or os.path.splitext(filename)[0]}.anomalous-recipe.zip"
|
||||
|
||||
|
||||
async def api_export_recipe_package(request):
|
||||
if not RECIPE_PACKAGE_EXPORT_ENABLED:
|
||||
return web.json_response({
|
||||
"status": "error",
|
||||
"code": "recipe_export_disabled",
|
||||
"message": "Recipe package export is temporarily unavailable",
|
||||
}, status=503)
|
||||
try:
|
||||
payload = await request.json()
|
||||
filename = require_filename(payload.get("filename", ""))
|
||||
@@ -481,19 +456,13 @@ async def api_export_recipe_package(request):
|
||||
return web.json_response({"status": "error", "message": "Recipe not found"}, status=404)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not export recipe"}, status=500)
|
||||
return web.Response(
|
||||
body=package,
|
||||
content_type="application/zip",
|
||||
headers={"Content-Disposition": f'attachment; filename="{os.path.splitext(filename)[0]}.anomalous-recipe.zip"'},
|
||||
)
|
||||
name = _download_name(recipe, filename)
|
||||
return web.Response(body=package, content_type="application/zip", headers={
|
||||
"Content-Disposition": f"attachment; filename=\"recipe.anomalous-recipe.zip\"; filename*=UTF-8''{urllib.parse.quote(name)}",
|
||||
})
|
||||
|
||||
|
||||
async def api_import_recipe_package_inspect(request):
|
||||
if not RECIPE_PACKAGE_IMPORT_ENABLED:
|
||||
return web.json_response({
|
||||
"status": "error", "code": "recipe_import_disabled",
|
||||
"message": "Recipe package import is temporarily unavailable",
|
||||
}, status=503)
|
||||
try:
|
||||
raw = await request.content.read(MAX_UPLOAD_BYTES + 1)
|
||||
report = await asyncio.to_thread(_inspect_package, raw)
|
||||
@@ -507,17 +476,15 @@ async def api_import_recipe_package_inspect(request):
|
||||
"token": token,
|
||||
"recipe": {"name": report["recipe"].get("name", ""), "tags": report["recipe"].get("tags", [])},
|
||||
"asset_count": len(report["asset_names"]),
|
||||
"has_cover": _picture_summary(report["recipe"])[0],
|
||||
"model_pictures": _picture_summary(report["recipe"])[1],
|
||||
"history_count": len(report["history_names"]),
|
||||
"existing_names": _existing_recipe_names(get_recipes_dir()),
|
||||
"imported_name": _unique_name(report["recipe"].get("name", ""), _existing_recipe_names(get_recipes_dir())),
|
||||
})
|
||||
|
||||
|
||||
async def api_import_recipe_package_commit(request):
|
||||
if not RECIPE_PACKAGE_IMPORT_ENABLED:
|
||||
return web.json_response({
|
||||
"status": "error", "code": "recipe_import_disabled",
|
||||
"message": "Recipe package import is temporarily unavailable",
|
||||
}, status=503)
|
||||
try:
|
||||
payload = await request.json()
|
||||
token = payload.get("token")
|
||||
@@ -529,8 +496,6 @@ async def api_import_recipe_package_commit(request):
|
||||
filename, name = await asyncio.to_thread(_commit_import, record, payload)
|
||||
except (AttributeError, TypeError, ValueError, json.JSONDecodeError):
|
||||
return web.json_response({"status": "error", "message": "Could not commit recipe package"}, status=400)
|
||||
except FileNotFoundError:
|
||||
return web.json_response({"status": "error", "message": "Replacement recipe not found"}, status=404)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not commit recipe package"}, status=500)
|
||||
return web.json_response({"status": "success", "filename": filename, "name": name})
|
||||
|
||||
+73
-5
@@ -18,13 +18,31 @@ from .workflow_schema import (
|
||||
_widget_values, _workflow_fingerprint,
|
||||
)
|
||||
|
||||
# All-in-one loaders with a verified serialized widget layout. Must stay in sync
|
||||
# with ALL_IN_ONE_LOADER_SPECS in web/modules/recipe_identity.js.
|
||||
ALL_IN_ONE_LOADER_SPECS = {
|
||||
# ComfyUI-Easy-Use: ckpt_name, vae_name, clip_skip, lora_name, ...
|
||||
"easy a1111loader": ((0, "checkpoint", "ckpt_name"), (1, "vae", "vae_name"), (3, "lora", "lora_name")),
|
||||
# ComfyUI-Easy-Use: ckpt_name, config_name, vae_name, clip_skip, lora_name, ...
|
||||
"easy fullloader": ((0, "checkpoint", "ckpt_name"), (2, "vae", "vae_name"), (4, "lora", "lora_name")),
|
||||
# efficiency-nodes-comfyui: ckpt_name, vae_name, clip_skip, lora_name, ...
|
||||
"efficient loader": ((0, "checkpoint", "ckpt_name"), (1, "vae", "vae_name"), (3, "lora", "lora_name")),
|
||||
}
|
||||
PLACEHOLDER_MODEL_VALUES = {"none", "baked vae"}
|
||||
POWER_LORA_TYPE = "power lora loader (rgthree)"
|
||||
EASY_LORA_STACK_TYPE = "easy lorastack"
|
||||
EASY_STACK_ROWS = 10
|
||||
|
||||
|
||||
def _model_reference_specs(node):
|
||||
"""Known loader adapters only; arbitrary third-party widgets stay parameters."""
|
||||
node_type = _node_type(node)
|
||||
lowered = node_type.lower()
|
||||
lowered = node_type.lower().strip()
|
||||
specs = []
|
||||
|
||||
if re.search(r"checkpointloader(simple)?$", lowered):
|
||||
if lowered in ALL_IN_ONE_LOADER_SPECS:
|
||||
specs.extend(ALL_IN_ONE_LOADER_SPECS[lowered])
|
||||
elif re.search(r"checkpointloader(simple)?$", lowered):
|
||||
specs.append((0, "checkpoint", "checkpoint"))
|
||||
elif lowered.endswith("unetloader"):
|
||||
specs.append((0, "unet", "unet"))
|
||||
@@ -45,6 +63,29 @@ def _model_reference_specs(node):
|
||||
return specs
|
||||
|
||||
|
||||
def _model_reference_values(node):
|
||||
"""(widget_index, category, widget_name, saved_value) for every model a saved node names: known
|
||||
loaders by position, and two stack nodes by their rows: rgthree's Power Lora Loader (a row is a
|
||||
dict {on, lora, strength}; switched-off rows load nothing) and Easy-Use's LoRA stack
|
||||
(lora_N_name at 3 + 4*(N-1), up to num_loras). Must stay in sync with nodeModelValues in
|
||||
web/modules/recipe_identity.js."""
|
||||
values = _widget_values(node)
|
||||
lowered = _node_type(node).lower().strip()
|
||||
if lowered == POWER_LORA_TYPE:
|
||||
rows = [(index, value) for index, value in enumerate(values) if isinstance(value, dict) and "lora" in value]
|
||||
return [(index, "lora", f"lora_{row}", value.get("lora"))
|
||||
for row, (index, value) in enumerate(rows, 1) if value.get("on") is not False]
|
||||
if lowered == EASY_LORA_STACK_TYPE:
|
||||
try:
|
||||
count = max(0, min(int(values[2]), EASY_STACK_ROWS))
|
||||
except (IndexError, TypeError, ValueError):
|
||||
count = 0
|
||||
return [(3 + 4 * row, "lora", f"lora_{row + 1}_name", values[3 + 4 * row] if 3 + 4 * row < len(values) else None)
|
||||
for row in range(count)]
|
||||
return [(index, category, name, values[index] if index < len(values) else None)
|
||||
for index, category, name in _model_reference_specs(node)]
|
||||
|
||||
|
||||
def _identity_for_reference(saved_value):
|
||||
resolved = _resolve_exact_model_reference(saved_value)
|
||||
if not resolved:
|
||||
@@ -138,11 +179,11 @@ def _build_model_references(recipe, verify_identities=False):
|
||||
for node in workflow.get("nodes", []) if isinstance(workflow, dict) else []:
|
||||
if not isinstance(node, dict):
|
||||
continue
|
||||
values = _widget_values(node)
|
||||
for widget_index, category, widget_name in _model_reference_specs(node):
|
||||
saved_value = values[widget_index] if widget_index < len(values) else None
|
||||
for widget_index, category, widget_name, saved_value in _model_reference_values(node):
|
||||
if not isinstance(saved_value, str) or not saved_value.strip():
|
||||
continue
|
||||
if saved_value.strip().lower() in PLACEHOLDER_MODEL_VALUES:
|
||||
continue
|
||||
identity_result = _identity_for_reference(saved_value)
|
||||
if isinstance(identity_result, tuple):
|
||||
identity, origin = (identity_result + (None,))[:2]
|
||||
@@ -260,6 +301,31 @@ def _normalise_source_image(value):
|
||||
}
|
||||
|
||||
|
||||
def _normalise_focus_params(entries):
|
||||
"""A workflow's focus values (重点参数): [{node, type, widget, note}], all short text; anything else is refused."""
|
||||
if not isinstance(entries, list) or len(entries) > MAX_FOCUS_PARAMS:
|
||||
raise ValueError("Invalid recipe focus values")
|
||||
kept = []
|
||||
seen = set()
|
||||
for entry in entries:
|
||||
if not isinstance(entry, dict):
|
||||
raise ValueError("Invalid recipe focus value")
|
||||
node, node_type, widget, note = (entry.get(key, "") for key in ("node", "type", "widget", "note"))
|
||||
if not all(isinstance(value, str) for value in (node, node_type, widget, note)):
|
||||
raise ValueError("Invalid recipe focus value")
|
||||
if (
|
||||
not node or not widget or len(node) > 32
|
||||
or max(len(node_type), len(widget)) > MAX_FOCUS_NAME_LENGTH
|
||||
or len(note) > MAX_FOCUS_NOTE_LENGTH
|
||||
):
|
||||
raise ValueError("Invalid recipe focus value")
|
||||
if (node, widget) in seen:
|
||||
continue
|
||||
seen.add((node, widget))
|
||||
kept.append({"node": node, "type": node_type, "widget": widget, "note": note.strip()})
|
||||
return kept
|
||||
|
||||
|
||||
def _normalise_recipe(payload):
|
||||
if not isinstance(payload, dict):
|
||||
raise ValueError("Invalid recipe")
|
||||
@@ -307,6 +373,8 @@ def _normalise_recipe(payload):
|
||||
reference["user_note"] = user_note.strip()
|
||||
else:
|
||||
reference.pop("user_note", None)
|
||||
if "focusParams" in params:
|
||||
params["focusParams"] = _normalise_focus_params(params["focusParams"])
|
||||
_validate_workflow(workflow)
|
||||
workflow_scope = payload.get("workflow_scope", "complete")
|
||||
if workflow_scope not in {"partial", "complete"}:
|
||||
|
||||
+6
-8
@@ -11,6 +11,7 @@ import folder_paths
|
||||
|
||||
from .recipe_constants import MAX_HISTORY_VERSIONS
|
||||
from .recipe_images import _recipe_assets_dir
|
||||
from .trash import move_to_trash
|
||||
from .utils import require_filename, resolve_within
|
||||
|
||||
def get_recipes_dir():
|
||||
@@ -131,11 +132,8 @@ def _list_recipe_history(recipes_dir, filename):
|
||||
|
||||
|
||||
def _delete_recipe_with_history(recipes_dir, filename):
|
||||
"""Delete an explicitly selected recipe and its contained local history."""
|
||||
os.remove(resolve_within(recipes_dir, filename))
|
||||
history_dir = _history_dir(recipes_dir, filename)
|
||||
if os.path.isdir(history_dir):
|
||||
shutil.rmtree(history_dir)
|
||||
assets_dir = _recipe_assets_dir(recipes_dir, filename)
|
||||
if os.path.isdir(assets_dir):
|
||||
shutil.rmtree(assets_dir)
|
||||
"""Moves an explicitly selected recipe, its history and its images to the Recycle Bin."""
|
||||
path = resolve_within(recipes_dir, filename)
|
||||
if not os.path.isfile(path):
|
||||
raise FileNotFoundError(path)
|
||||
move_to_trash(path, _history_dir(recipes_dir, filename), _recipe_assets_dir(recipes_dir, filename))
|
||||
|
||||
+36
-1
@@ -26,13 +26,14 @@ from .recipe_schema import (
|
||||
_enrich_recipe as _schema_enrich_recipe, _normalise_recipe, _normalise_source_image,
|
||||
_identity_for_reference as _schema_identity_for_reference,
|
||||
_model_reference_key, _model_reference_specs,
|
||||
_model_roots, _preserve_model_reference_fields,
|
||||
_model_roots, _normalise_focus_params, _preserve_model_reference_fields,
|
||||
_resolve_exact_model_reference, _updated_recipe, _workflow_identity_for_reference,
|
||||
)
|
||||
from .recipe_store import (
|
||||
_archive_recipe, _delete_recipe_with_history, _history_dir, _list_recipe_history,
|
||||
_list_recipes, _read_recipe, _write_recipe, get_recipes_dir,
|
||||
)
|
||||
from .local_guard import may_change
|
||||
from .utils import require_filename, resolve_within
|
||||
from .workflow_schema import (
|
||||
_clean_volatile_params, _node_title, _node_type, _normalise_workflow_key,
|
||||
@@ -359,6 +360,40 @@ async def api_update_recipe(request):
|
||||
})
|
||||
|
||||
|
||||
def _set_recipe_focus(recipes_dir, filename, entries):
|
||||
"""Writes a recipe's focus values (重点参数) alone: no version kept, nothing else read again."""
|
||||
focus = _normalise_focus_params(entries)
|
||||
path = resolve_within(recipes_dir, filename)
|
||||
if os.path.getsize(path) > MAX_RECIPE_BYTES:
|
||||
raise ValueError("Recipe is too large")
|
||||
recipe = _read_recipe(path)
|
||||
if not isinstance(recipe, dict) or not isinstance(recipe.get("workflow"), dict):
|
||||
raise ValueError("Invalid recipe")
|
||||
params = recipe.get("params") if isinstance(recipe.get("params"), dict) else {}
|
||||
recipe["params"] = {**params, "focusParams": focus}
|
||||
_write_recipe(recipes_dir, filename, recipe)
|
||||
return focus
|
||||
|
||||
|
||||
async def api_set_recipe_focus(request):
|
||||
"""Marks or notes a recipe's focus values (a star in its details). Only from this computer (local_guard.may_change)."""
|
||||
if not may_change(request):
|
||||
return web.json_response({"status": "error", "message": "Only from this computer"}, status=403)
|
||||
try:
|
||||
payload = await request.json()
|
||||
filename = require_filename(payload.get("filename", ""))
|
||||
if not filename.endswith(".json"):
|
||||
raise ValueError("Invalid filename")
|
||||
focus = await asyncio.to_thread(_set_recipe_focus, get_recipes_dir(), filename, payload.get("focusParams"))
|
||||
except FileNotFoundError:
|
||||
return web.json_response({"status": "error", "message": "File not found"}, status=404)
|
||||
except (AttributeError, ValueError, json.JSONDecodeError):
|
||||
return web.json_response({"status": "error", "message": "Invalid focus values"}, status=400)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not update recipe"}, status=500)
|
||||
return web.json_response({"status": "success", "focusParams": focus})
|
||||
|
||||
|
||||
async def api_get_recipe_history(request):
|
||||
try:
|
||||
filename = require_filename(request.query.get("filename", ""))
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
"""ComfyUI's refusal of a run, said as what to do next: run_workflow's answer when ComfyUI does not
|
||||
take the prompt. The page passes the refusal on as data (web/modules/mcp_run.js `refusal`: its
|
||||
error and each node's, from ComfyUI's validation); each problem becomes one line naming the node,
|
||||
what is wrong and the tool that fixes it, so the AI does not have to read ComfyUI's raw report and
|
||||
guess. Kinds not listed here keep ComfyUI's own message."""
|
||||
|
||||
MAX_LINES = 8
|
||||
|
||||
NODE_HINTS = {
|
||||
"required_input_missing": "node {node} ({class_type}) has nothing wired into {input}: connect_nodes into it, or add_node with wire_to={node}",
|
||||
"bad_linked_input": "node {node} ({class_type}): {input} is wired from an output of the wrong kind; connect_nodes the right one ({details})",
|
||||
"return_type_mismatch": "node {node} ({class_type}): {input} is wired from an output of the wrong kind; connect_nodes the right one ({details})",
|
||||
"invalid_input_type": "node {node} ({class_type}): {input} has a value of the wrong kind ({details}); set_values with the right one",
|
||||
"value_smaller_than_min": "node {node} ({class_type}): {input} = {value} is below its minimum ({details}); set_values within the range",
|
||||
"value_bigger_than_max": "node {node} ({class_type}): {input} = {value} is above its maximum ({details}); set_values within the range",
|
||||
"value_not_in_list": ("node {node} ({class_type}): {input} = {value} is not one of its choices. A model this computer "
|
||||
"lacks: check_workflow_models / fix_workflow_models, or search_models then set_model; otherwise "
|
||||
"set_values with one of its choices (find_nodes lists them)"),
|
||||
}
|
||||
TOP_HINTS = {
|
||||
"prompt_no_outputs": ("the workflow has no output node: add SaveImage (or PreviewImage) behind the VAE Decode with "
|
||||
"add_node(type='SaveImage', wire_from=<its id>)"),
|
||||
"invalid_prompt": "{message} {details}: a node type this ComfyUI does not have; find_nodes for one it has, or ask the user to install its node pack",
|
||||
}
|
||||
|
||||
|
||||
class _Blank(dict):
|
||||
def __missing__(self, key):
|
||||
return "?"
|
||||
|
||||
|
||||
def _say(template, item):
|
||||
return template.format_map(_Blank({key: str(value) for key, value in item.items() if value not in (None, "")}))
|
||||
|
||||
|
||||
def say(refusal):
|
||||
"""What to do about ComfyUI's refusal (the page's `refusal` data), or "" when it says nothing."""
|
||||
if not isinstance(refusal, dict):
|
||||
return ""
|
||||
lines = []
|
||||
for item in refusal.get("nodes") or []:
|
||||
if isinstance(item, dict):
|
||||
template = NODE_HINTS.get(item.get("type"))
|
||||
lines.append(_say(template, item) if template else
|
||||
_say("node {node} ({class_type}): {message} {details}", item).replace(" ?", ""))
|
||||
if not lines:
|
||||
template = TOP_HINTS.get(refusal.get("type"))
|
||||
if template:
|
||||
lines.append(_say(template, refusal))
|
||||
elif refusal.get("message"):
|
||||
lines.append(_say("{message} {details}", refusal).replace(" ?", ""))
|
||||
if not lines:
|
||||
return ""
|
||||
more = len(lines) - MAX_LINES
|
||||
return ("ComfyUI did not take the run: " + "; ".join(lines[:MAX_LINES]) + (f"; and {more} more" if more > 0 else "")
|
||||
+ ". Fix these, then run_workflow again.")
|
||||
@@ -0,0 +1,74 @@
|
||||
"""The user's choice to leave a model out of scans, or keep it in: POST /anomalous/scan_choice,
|
||||
kept in each model's <model>.anomalous.json ("scan"; model_identity.scan_choice reads it). The
|
||||
scan page asks it about new models that look like no drawing model; a model's details change it."""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from .local_guard import may_change
|
||||
from .path_utils import atomic_write_json, resolve_folder_subdir
|
||||
from .utils import model_file_within
|
||||
|
||||
try:
|
||||
from ..model_identity import USER_INFO_SUFFIX, read_json
|
||||
from ..model_sidecars import target as sidecar_target
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from model_identity import USER_INFO_SUFFIX, read_json
|
||||
from model_sidecars import target as sidecar_target
|
||||
|
||||
MAX_CHOICE_FILES = 2000
|
||||
|
||||
|
||||
def _set_scan_choice(targets, choice):
|
||||
"""Writes the user's scan choice into each picked model's <model>.anomalous.json ("scan":
|
||||
"skip" or "scan"; "" removes it). `targets`: [{type, path_idx, subfolder, files}] as a scan
|
||||
takes them. Returns (models changed, file names left as they were: not found, not a
|
||||
.safetensors, or an unreadable .anomalous.json)."""
|
||||
if choice not in ("skip", "scan", "") or not isinstance(targets, list):
|
||||
raise ValueError("Invalid scan choice")
|
||||
picked = []
|
||||
for target in targets:
|
||||
names = target.get("files") if isinstance(target, dict) else None
|
||||
if not isinstance(names, list) or not all(isinstance(name, str) for name in names):
|
||||
raise ValueError("each target needs a list of file names")
|
||||
_, target_dir = resolve_folder_subdir(target.get("type"), int(target.get("path_idx", 0)), target.get("subfolder") or "/")
|
||||
picked += [(target_dir, name) for name in names]
|
||||
if len(picked) > MAX_CHOICE_FILES:
|
||||
raise ValueError("Too many models")
|
||||
changed, failed = 0, []
|
||||
for target_dir, name in picked:
|
||||
try:
|
||||
path = model_file_within(target_dir, name)
|
||||
except ValueError:
|
||||
failed.append(name)
|
||||
continue
|
||||
user_file = sidecar_target(os.path.splitext(path)[0], USER_INFO_SUFFIX)
|
||||
user = read_json(user_file)
|
||||
if not name.endswith(".safetensors") or not os.path.isfile(path) or (user is None and os.path.exists(user_file)):
|
||||
failed.append(name)
|
||||
continue
|
||||
user = user or {"format": 1}
|
||||
if choice:
|
||||
user["scan"] = choice
|
||||
else:
|
||||
user.pop("scan", None)
|
||||
atomic_write_json(user_file, user)
|
||||
changed += 1
|
||||
return changed, failed
|
||||
|
||||
|
||||
async def api_set_scan_choice(request):
|
||||
"""POST /anomalous/scan_choice {targets, choice} - leave models out of scans ("skip"), keep
|
||||
them in ("scan"), or forget the choice (""). Only from this computer (local_guard.may_change)."""
|
||||
if not may_change(request):
|
||||
return web.json_response({"status": "error", "message": "Only from this computer"}, status=403)
|
||||
try:
|
||||
data = await request.json()
|
||||
changed, failed = await asyncio.to_thread(_set_scan_choice, data.get("targets"), data.get("choice", ""))
|
||||
except (AttributeError, KeyError, TypeError, ValueError):
|
||||
return web.json_response({"status": "error", "message": "Invalid scan choice"}, status=400)
|
||||
except OSError:
|
||||
return web.json_response({"status": "error", "message": "Could not save the choice"}, status=500)
|
||||
return web.json_response({"status": "success", "changed": changed, "failed": failed})
|
||||
@@ -0,0 +1,169 @@
|
||||
"""What a scan did, model by model.
|
||||
|
||||
The scraper appends one JSON line per model it changed to a report file (--report-file),
|
||||
plus events: "civitai_down" when Civitai stopped answering, "done" with the count of models
|
||||
left as they were. When a scan ends, ScanJob turns the lines of all its folders into one
|
||||
result: kept as the last scan (GET /anomalous/last_scan, shown on the scan page) and recorded
|
||||
in the activity log, with each model located by type, path index and relative path so the
|
||||
browser can open it (GET /anomalous/scan_model).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
|
||||
from aiohttp import web
|
||||
import folder_paths
|
||||
|
||||
from .activity_log import MAX_CHANGES, add_entry, log_path
|
||||
from .folder_types import get_active_folder_types
|
||||
from .model_catalog import _model_info_for_path
|
||||
from .path_utils import atomic_write_json, resolve_folder_subdir
|
||||
|
||||
MAX_FILES = 2000 # models kept in the last scan's result
|
||||
FILE_FIELDS = ("status", "reason", "name", "base", "cover", "error")
|
||||
|
||||
|
||||
def last_scan_path():
|
||||
return os.path.join(os.path.dirname(log_path()), "last_scan.json")
|
||||
|
||||
|
||||
def locate_root(directory):
|
||||
"""(type, path_idx) of the models folder that is `directory`, shown types first; None if none."""
|
||||
target = os.path.normcase(os.path.realpath(directory))
|
||||
active = get_active_folder_types()
|
||||
types = active + [name for name in folder_paths.folder_names_and_paths if name not in active]
|
||||
for folder_type in types:
|
||||
try:
|
||||
paths = folder_paths.get_folder_paths(folder_type) or []
|
||||
except Exception:
|
||||
continue
|
||||
for path_idx, path in enumerate(paths):
|
||||
if os.path.normcase(os.path.realpath(path)) == target:
|
||||
return folder_type, path_idx
|
||||
return None
|
||||
|
||||
|
||||
def read_report(path):
|
||||
"""(model entries, events) from a report file; both empty when there is none."""
|
||||
entries, events = [], []
|
||||
try:
|
||||
with open(path, encoding="utf-8") as source:
|
||||
for line in source:
|
||||
try:
|
||||
item = json.loads(line)
|
||||
except ValueError:
|
||||
continue
|
||||
if isinstance(item, dict):
|
||||
(events if "event" in item else entries).append(item)
|
||||
except OSError:
|
||||
pass
|
||||
return entries, events
|
||||
|
||||
|
||||
class ScanJob:
|
||||
"""One scan from start to end: what to call it, its options, and its folders' reports."""
|
||||
|
||||
def __init__(self, kind, data):
|
||||
self.kind = kind # "all" | "picked" | "one"
|
||||
self.options = {key: bool(data.get(key)) for key in ("offline_only", "retry_unmatched", "force_overwrite")}
|
||||
self.started = time.time()
|
||||
self.files = []
|
||||
self.unchanged = 0
|
||||
self.civitai_down = False
|
||||
self.civitai_error = "" # why Civitai could not be reached (net_proxy.failure), the first one
|
||||
self.errors = []
|
||||
|
||||
def add_folder(self, report_file, base_dir, located=None):
|
||||
"""Reads (and removes) one scraper run's report. `located`: (type, path_idx) of base_dir."""
|
||||
located = located or locate_root(base_dir) or ("", 0)
|
||||
entries, events = read_report(report_file)
|
||||
try:
|
||||
os.remove(report_file)
|
||||
except OSError:
|
||||
pass
|
||||
for event in events:
|
||||
if event.get("event") == "done":
|
||||
self.unchanged += int(event.get("unchanged") or 0)
|
||||
elif event.get("event") == "civitai_down":
|
||||
self.civitai_down = True
|
||||
self.civitai_error = self.civitai_error or str(event.get("reason") or "")[:40]
|
||||
for entry in entries:
|
||||
path = entry.get("renamed_to") if entry.get("renamed_to") and entry.get("status") != "failed" else entry.get("file")
|
||||
if not isinstance(path, str):
|
||||
continue
|
||||
item = {key: entry[key] for key in FILE_FIELDS if entry.get(key)}
|
||||
item.update(type=located[0], path_idx=located[1], filename=os.path.basename(path),
|
||||
rel=os.path.relpath(path, base_dir).replace(os.sep, "/"))
|
||||
if entry.get("renamed_to") and item["status"] != "failed":
|
||||
item["renamed_from"] = os.path.basename(entry.get("file") or "")
|
||||
if entry.get("duplicate_of"):
|
||||
item["duplicate"] = True
|
||||
self.files.append(item)
|
||||
|
||||
def add_error(self, message):
|
||||
self.errors.append(str(message)[:300])
|
||||
|
||||
def result(self):
|
||||
files = self.files
|
||||
counts = {
|
||||
"matched": sum(item["status"] == "matched" for item in files),
|
||||
"inferred": sum(item["status"] == "inferred" for item in files),
|
||||
"failed": sum(item["status"] == "failed" for item in files),
|
||||
"covers": sum(item.get("cover") == "new" for item in files),
|
||||
"renamed": sum(bool(item.get("renamed_from")) for item in files),
|
||||
"unchanged": self.unchanged,
|
||||
}
|
||||
return {
|
||||
"kind": self.kind, "options": self.options, "started": self.started,
|
||||
"finished": time.time(), "counts": counts, "civitai_down": self.civitai_down,
|
||||
"civitai_error": self.civitai_error,
|
||||
"errors": self.errors[:10], "files": files[:MAX_FILES],
|
||||
}
|
||||
|
||||
def finish(self):
|
||||
"""Keeps the result as the last scan and records it in the activity log. Never raises:
|
||||
the scan itself is done, the record of it is a convenience."""
|
||||
result = self.result()
|
||||
try:
|
||||
atomic_write_json(last_scan_path(), result)
|
||||
except Exception as error: # noqa: BLE001
|
||||
print(f"[Anomalous Browser] Could not keep the scan result: {error}")
|
||||
try:
|
||||
target = result["files"][0]["filename"] if self.kind == "one" and result["files"] else ""
|
||||
detail = {"scan": {key: result[key] for key in ("kind", "options", "counts", "civitai_down", "civitai_error", "errors")},
|
||||
"files": result["files"][:MAX_CHANGES], "total": len(self.files),
|
||||
"seconds": round(result["finished"] - result["started"])}
|
||||
add_entry("file", "scan_done", target, detail)
|
||||
except Exception as error: # noqa: BLE001
|
||||
print(f"[Anomalous Browser] Could not record the scan in the activity log: {error}")
|
||||
return result
|
||||
|
||||
|
||||
async def api_last_scan(request):
|
||||
"""GET /anomalous/last_scan - the last scan's result, or {} before the first one."""
|
||||
def read():
|
||||
try:
|
||||
with open(last_scan_path(), encoding="utf-8") as source:
|
||||
data = json.load(source)
|
||||
return data if isinstance(data, dict) else {}
|
||||
except (OSError, ValueError):
|
||||
return {}
|
||||
return web.json_response(await asyncio.to_thread(read))
|
||||
|
||||
|
||||
async def api_scan_model(request):
|
||||
"""GET /anomalous/scan_model?type&path_idx&rel - one model as the grid lists it, to open it."""
|
||||
rel = request.query.get("rel", "").replace("\\", "/").strip("/")
|
||||
subfolder, filename = os.path.split(rel)
|
||||
try:
|
||||
path_idx = int(request.query.get("path_idx", 0))
|
||||
base_dir, target_dir = resolve_folder_subdir(request.query.get("type", ""), path_idx, "/" + subfolder)
|
||||
except (ValueError, KeyError, TypeError):
|
||||
return web.json_response({"error": "Invalid model location"}, status=400)
|
||||
file_path = os.path.join(target_dir, filename)
|
||||
if not filename or filename in (".", "..") or not os.path.isfile(file_path):
|
||||
return web.json_response({"error": "Model not found"}, status=404)
|
||||
model = await asyncio.to_thread(_model_info_for_path, request.query.get("type"), path_idx, base_dir, file_path)
|
||||
return web.json_response({"model": model})
|
||||
@@ -0,0 +1,262 @@
|
||||
"""What the scan page shows before a scan: how many models are matched on Civitai, unmatched or
|
||||
new, and which ones the last two are (located like the scan report's models, so the page can
|
||||
open them); also the model files a scan never reads (other formats than .safetensors), so the
|
||||
page can say why they are not there, the models the user set to "don't scan", and the new ones
|
||||
whose header looks like no drawing model (a voice model, say), for the page to ask about. The
|
||||
components a drawing model loads (VAE, text encoders…) are counted and listed on their own too,
|
||||
since many are not on Civitai and that is no fault; and some covers of the scanned models, for
|
||||
the scan card's band of pictures. And for the scan page's picker, every model
|
||||
a scan reads with its name, size, cover and state.
|
||||
|
||||
Working the summary out reads every model folder, which takes a while with many models or on
|
||||
a network drive. So the last one is kept (in memory, and in user/anomalous/scan_summary.json
|
||||
for after a restart) and handed out at once (`?quick=1`) while a fresh one is worked out;
|
||||
requests that come meanwhile wait for that same one instead of reading the folders again. The
|
||||
models found on Civitai are kept with it and listed on request (GET /anomalous/scan_matched),
|
||||
so the page's summary stays small."""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import time
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from aiohttp import web
|
||||
|
||||
from .activity_log import log_path
|
||||
from .folder_types import get_active_scan_paths
|
||||
from .metadata import get_metadata
|
||||
from .path_utils import atomic_write_json
|
||||
from .model_media import _preview_url_for_model
|
||||
from .scan_report import locate_root
|
||||
|
||||
try:
|
||||
from ..model_identity import is_unmatched, read_json, scan_choice, sidecar_info, unmatched_reason
|
||||
except ImportError: # loaded outside the package (tests)
|
||||
from model_identity import is_unmatched, read_json, scan_choice, sidecar_info, unmatched_reason
|
||||
|
||||
MAX_LISTED = 2000 # models listed per kind; the counts stay exact
|
||||
MAX_PICKABLE = 5000 # models the picker lists; its total stays exact
|
||||
COVER_SAMPLE = 48 # covers the scan card's band gets (it shows as many as fit)
|
||||
# Model files in other formats: listed as "not scanned" (scans read only .safetensors).
|
||||
OTHER_MODEL_EXTENSIONS = (".ckpt", ".pt", ".pth", ".bin", ".gguf", ".onnx", ".sft", ".engine")
|
||||
# Folders of the parts a drawing model loads: many are not on Civitai, and that is no fault.
|
||||
COMPONENT_TYPES = ("vae", "clip", "text_encoders", "clip_vision", "upscale_models")
|
||||
# What the picker needs of a model's metadata: its card badge (model_source.js) and its name.
|
||||
PICKER_FIELDS = ("info_source", "unmatched_reason", "scan_choice", "not_drawing", "baseModel", "base_guess", "custom_name")
|
||||
# New models' headers are read this many at a time: on a network drive (a NAS, a cloud server's
|
||||
# model disk) each read waits on the network, and a thousand one after another take minutes.
|
||||
# They are read through get_metadata, whose cache keeps them until the file changes (the page
|
||||
# opened again reads none, and the picker after it finds them there).
|
||||
HEAD_READERS = 16
|
||||
MAX_SAVED_BYTES = 16 * 1024 * 1024 # the kept summary; MAX_LISTED keeps it far smaller
|
||||
_last = {} # the last summary worked out ("summary", "at") and its models found on Civitai ("matched")
|
||||
_working = None # the summary being worked out (an asyncio future), shared by the requests meanwhile
|
||||
|
||||
|
||||
def _walk():
|
||||
"""Each model file in the active scan folders once, as ((type, path_idx), base_dir, path,
|
||||
other): the .safetensors files scans read, and (`other`) model files in other formats outside
|
||||
hidden folders (tools keep their working files there)."""
|
||||
seen = set()
|
||||
for base_dir in get_active_scan_paths():
|
||||
located = locate_root(base_dir) or ("", 0)
|
||||
for root, _dirs, files in os.walk(base_dir):
|
||||
hidden = any(part.startswith(".") for part in os.path.relpath(root, base_dir).split(os.sep) if part != ".")
|
||||
for filename in files:
|
||||
other = filename.lower().endswith(OTHER_MODEL_EXTENSIONS)
|
||||
if not filename.endswith(".safetensors") and not (other and not hidden):
|
||||
continue
|
||||
path = os.path.join(root, filename)
|
||||
real = os.path.realpath(path)
|
||||
if real in seen:
|
||||
continue
|
||||
seen.add(real)
|
||||
yield located, base_dir, path, other
|
||||
|
||||
|
||||
def _looks_not_drawing(path):
|
||||
"""Whether the header of a new model reads but names no drawing model kind."""
|
||||
return bool(get_metadata(path).get("not_drawing"))
|
||||
|
||||
|
||||
def _found_item(item, info):
|
||||
"""A model found on Civitai, for the list of them: where it is, Civitai's name, its base model."""
|
||||
model = info.get("model") if isinstance(info.get("model"), dict) else {}
|
||||
names = [str(model.get("name") or ""), str(info.get("name") or "")]
|
||||
return {**item, "name": " · ".join(name for name in names if name), "base": str(info.get("baseModel") or "")}
|
||||
|
||||
|
||||
def _summarize(with_matched=False):
|
||||
"""Counts the files the scanner handles (.safetensors in the active scan folders), each once.
|
||||
`pending`: unmatched models Civitai was never asked about (offline, or unreachable then),
|
||||
which the next online scan looks up. `skipped`: model files in other formats. `excluded`:
|
||||
models set to "don't scan", not in the other counts. A new model not chosen about whose
|
||||
header reads but names no drawing model kind carries `not_drawing` (counted too); only new
|
||||
models' headers are read. Models in a component folder carry `component` (counted too) and
|
||||
are listed again, matched ones as well, in `component_models` with their `state`
|
||||
(matched | unmatched | new); `components` counts them. `covers`: see `_covers`."""
|
||||
total = matched = 0
|
||||
unmatched, new, skipped, excluded, components, scanned, to_read, found = [], [], [], [], [], [], [], []
|
||||
for located, base_dir, path, other in _walk():
|
||||
item = {"type": located[0], "path_idx": located[1], "filename": os.path.basename(path),
|
||||
"rel": os.path.relpath(path, base_dir).replace(os.sep, "/")}
|
||||
if other:
|
||||
skipped.append(item)
|
||||
continue
|
||||
base = os.path.splitext(path)[0]
|
||||
choice = scan_choice(base)
|
||||
if choice == "skip":
|
||||
excluded.append(item)
|
||||
continue
|
||||
total += 1
|
||||
info = sidecar_info(base)
|
||||
if located[0] in COMPONENT_TYPES:
|
||||
item["component"] = True
|
||||
components.append(item)
|
||||
elif info is not None:
|
||||
scanned.append((located, base_dir, path))
|
||||
if info is not None and not is_unmatched(info):
|
||||
matched += 1
|
||||
item["state"] = "matched"
|
||||
if with_matched and not item.get("component"):
|
||||
found.append(_found_item(item, info))
|
||||
continue
|
||||
if info is None:
|
||||
if not choice:
|
||||
to_read.append((item, path))
|
||||
item["state"] = "new"
|
||||
new.append(item)
|
||||
else:
|
||||
item.update(state="unmatched", reason=unmatched_reason(info), base=info.get("baseModel") or "")
|
||||
unmatched.append(item)
|
||||
if to_read:
|
||||
with ThreadPoolExecutor(max_workers=HEAD_READERS) as pool:
|
||||
for (item, _path), not_drawing in zip(to_read, pool.map(_looks_not_drawing, [path for _item, path in to_read])):
|
||||
if not_drawing:
|
||||
item["not_drawing"] = True
|
||||
return {
|
||||
**({"matched_models": found} if with_matched else {}),
|
||||
"total": total, "matched": matched, "unmatched": len(unmatched), "new": len(new),
|
||||
"pending": sum(item["reason"] in ("offline", "network") for item in unmatched),
|
||||
"damaged": sum(item["reason"] == "damaged" for item in unmatched),
|
||||
"not_drawing": sum(bool(item.get("not_drawing")) for item in new),
|
||||
"excluded": len(excluded), "excluded_models": excluded[:MAX_LISTED],
|
||||
"unmatched_models": unmatched[:MAX_LISTED], "new_models": new[:MAX_LISTED],
|
||||
"skipped": len(skipped), "skipped_models": skipped[:MAX_LISTED],
|
||||
"components": {
|
||||
"total": len(components),
|
||||
**{state: sum(item["state"] == state for item in components) for state in ("matched", "unmatched", "new")},
|
||||
"pending": sum(item.get("reason") in ("offline", "network") for item in components),
|
||||
},
|
||||
"component_models": components[:MAX_LISTED],
|
||||
"covers": _covers(scanned),
|
||||
}
|
||||
|
||||
|
||||
def _modified(entry):
|
||||
try:
|
||||
return os.path.getmtime(entry[2])
|
||||
except OSError:
|
||||
return 0
|
||||
|
||||
|
||||
def _covers(scanned):
|
||||
"""Up to COVER_SAMPLE covers of the scanned models (components left out, they seldom have
|
||||
one), the newest model files first, as {name, preview_url}: the scan card's band of pictures."""
|
||||
covers = []
|
||||
for located, base_dir, path in sorted(scanned, key=_modified, reverse=True):
|
||||
url = _preview_url_for_model(located[0], located[1], base_dir, path)
|
||||
if url:
|
||||
covers.append({"name": os.path.splitext(os.path.basename(path))[0], "preview_url": url})
|
||||
if len(covers) >= COVER_SAMPLE:
|
||||
break
|
||||
return covers
|
||||
|
||||
|
||||
def _pickable():
|
||||
"""Every model a scan reads (the models set to "don't scan" too), located like the summary's,
|
||||
with its size, cover and what its card badge needs; `roots`: the name of each models folder
|
||||
they are in and of the folder holding it, to tell two folders of one type apart."""
|
||||
models, roots, total = [], {}, 0
|
||||
for located, base_dir, path, other in _walk():
|
||||
if other:
|
||||
continue
|
||||
total += 1
|
||||
if len(models) >= MAX_PICKABLE:
|
||||
continue
|
||||
key = f"{located[0]}|{located[1]}"
|
||||
if key not in roots:
|
||||
roots[key] = {"type": located[0], "path_idx": located[1], "name": os.path.basename(os.path.normpath(base_dir)),
|
||||
"parent": os.path.basename(os.path.dirname(os.path.normpath(base_dir)))}
|
||||
meta = get_metadata(path)
|
||||
try:
|
||||
size = os.path.getsize(path)
|
||||
except OSError:
|
||||
size = 0
|
||||
models.append({
|
||||
"type": located[0], "path_idx": located[1], "filename": os.path.basename(path),
|
||||
"rel": os.path.relpath(path, base_dir).replace(os.sep, "/"), "size": size,
|
||||
"preview_url": _preview_url_for_model(located[0], located[1], base_dir, path),
|
||||
"metadata": {field: meta.get(field) for field in PICKER_FIELDS},
|
||||
})
|
||||
return {"models": models, "total": total, "roots": list(roots.values())}
|
||||
|
||||
|
||||
def _summary_path():
|
||||
return os.path.join(os.path.dirname(log_path()), "scan_summary.json")
|
||||
|
||||
|
||||
def _work_out():
|
||||
"""A fresh summary, kept as the last one (and on disk when it changed)."""
|
||||
summary = _summarize(with_matched=True)
|
||||
matched = summary.pop("matched_models")
|
||||
changed = summary != _last.get("summary")
|
||||
_last.update(summary=summary, matched=matched[:MAX_PICKABLE], matched_total=len(matched), at=time.time())
|
||||
if changed:
|
||||
try:
|
||||
atomic_write_json(_summary_path(), {"at": _last["at"], "summary": summary}, max_bytes=MAX_SAVED_BYTES)
|
||||
except (OSError, ValueError) as error:
|
||||
print(f"[Anomalous Browser] Scan summary not kept: {error}")
|
||||
return summary
|
||||
|
||||
|
||||
async def _fresh():
|
||||
global _working
|
||||
if _working is None or _working.done():
|
||||
_working = asyncio.ensure_future(asyncio.to_thread(_work_out))
|
||||
return await asyncio.shield(_working)
|
||||
|
||||
|
||||
def _kept():
|
||||
"""The last summary ({"at", "summary"}), from memory or from disk; None before the first."""
|
||||
if _last.get("summary"):
|
||||
return {"at": _last["at"], "summary": _last["summary"]}
|
||||
try:
|
||||
if os.path.getsize(_summary_path()) > MAX_SAVED_BYTES:
|
||||
return None
|
||||
except OSError:
|
||||
return None
|
||||
data = read_json(_summary_path())
|
||||
return data if data and isinstance(data.get("summary"), dict) else None
|
||||
|
||||
|
||||
async def api_scan_summary(request):
|
||||
"""GET /anomalous/scan_summary - counts, and the unmatched and new models. `?quick=1`: the
|
||||
last one at once ({"at", "summary"}, or {} before the first), for the page to show while it
|
||||
asks for a fresh one."""
|
||||
if request.query.get("quick"):
|
||||
return web.json_response(await asyncio.to_thread(_kept) or {})
|
||||
return web.json_response(await _fresh())
|
||||
|
||||
|
||||
async def api_scan_matched(request):
|
||||
"""GET /anomalous/scan_matched - the models found on Civitai (components apart), as the last
|
||||
summary saw them: {"models": [{type, path_idx, filename, rel, name, base}], "total"}."""
|
||||
if "matched" not in _last:
|
||||
await _fresh()
|
||||
return web.json_response({"models": _last.get("matched") or [], "total": _last.get("matched_total", 0)})
|
||||
|
||||
|
||||
async def api_scan_pickable(request):
|
||||
"""GET /anomalous/scan_pickable - the models the scan settings' picker lists."""
|
||||
return web.json_response(await asyncio.to_thread(_pickable))
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user