fix: 🐛 fix from merge

This is what started all my frontend experiments, but it has been
"cleaned" since in `main`

.editorconfig

@@ -1,2 +0,0 @@
-[*]
-end_of_line = lf

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,9 +1,7 @@
 name: 🐞 Bug Report
-title: '[bug] '
+title: "[bug] "
 description: Report a bug
-labels: ['type: 🐛 bug', 'status: 🧹 needs triage']
-assignees:
-  - melMass
+labels: ["type: 🐛 bug", "status: 🧹 needs triage"]
 
 body:
   - type: markdown
@@ -12,8 +10,6 @@ body:
         ## Before submiting an issue
         - Make sure to read the README & INSTALL instructions.  
         - Please search for [existing issues](https://github.com/melMass/comfy_mtb/issues?q=is%3Aissue) around your problem before filing a report.
-        - Optionally check the `#mtb-nodes` channel on the Banodoco discord:  
-          [![](https://dcbadge.vercel.app/api/server/AXhsabmDhn?style=flat)](https://discord.gg/IAXhsabmDhn)
 
         ### Try using the debug mode to get more info
 
@@ -44,30 +40,16 @@ body:
       label: Expected behavior
       description: A clear description of what you expected to happen.
 
-  - type: dropdown
-    id: os
+  - type: textarea
+    id: info
     attributes:
-      label: Operating System
-      description: What OS are you using?
-      options:
-        - Windows (Default)
-        - Linux
-        - Mac
-      default: 0
-    validations:
-      required: true
+      label: Platform and versions
+      description: "informations about the environment you run Comfy in"
+      render: sh
+      placeholder: |
+        - OS: [e.g. Linux]
+        - Comfy Mode [e.g. custom env, standalone, google colab]
 
-  - type: dropdown
-    id: comfy_mode
-    attributes:
-      label: Comfy Mode
-      description: What flavor of Comfy do you use?
-      options:
-        - Comfy Portable (embed) (Default)
-        - In a custom virtual env (venv, virtualenv, conda...)
-        - Google Colab
-        - Other (online services, containers etc..)
-      default: 0
     validations:
       required: true
 

.github/workflows/publish_action.yml

@@ -1,20 +0,0 @@
-name: 📦 Publish to Comfy registry
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - main
-    paths:
-      - "pyproject.toml"
-
-jobs:
-  publish-node:
-    name: Publish Custom Node to registry
-    runs-on: ubuntu-latest
-    steps:
-      - name: ♻️ Check out code
-        uses: actions/checkout@v4
-      - name: 📦 Publish Custom Node
-        uses: Comfy-Org/publish-node-action@main
-        with:
-          personal_access_token: ${{ secrets.COMFY_REGISTRY_TOKEN }}

.gitignore

@@ -2,7 +2,4 @@ __pycache__
 *.py[cod]
 *.onnx
 wheels/
-node_modules/
-compose.yaml
-comfy_mtb.wsb
-Dockerfile
+node_modules/

.gitmodules

@@ -7,6 +7,3 @@
 [submodule "extern/frame_interpolation"]
 	path = extern/frame_interpolation
 	url = https://github.com/google-research/frame-interpolation
-[submodule "wiki"]
-	path = wiki
-	url = https://github.com/melMass/comfy_mtb.wiki.git

.nvim.lua

@@ -1,10 +0,0 @@
--- HACK: this should theorically not be needed since the lsp should read from the pyproject
--- tried: ruff-lsp or basedpyright
-
-local comfyRoot = vim.fn.expand("%:p:h:h:h")
-
-if not vim.env.PYTHONPATH or vim.env.PYTHONPATH == "" then
-	vim.env.PYTHONPATH = comfyRoot
-else
-	vim.env.PYTHONPATH = vim.env.PYTHONPATH .. ";" .. comfyRoot
-end

.pre-commit-config.yaml

@@ -1,8 +0,0 @@
-default_language_version:
-  python: python3.10
-repos:
-  - repo: https://github.com/melmass/hooks
-    rev: e8c6c18175ed4f6e30f23991de7989411e09c73b
-    hooks:
-      - id: fix-trailing-whitespace
-      - id: bump-version

CHANGELOG.md

@@ -1,402 +0,0 @@
-# Changelog
-
-This is an automated changelog based on the commits in this repository.
-
-Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases) for more information.
-## [main] - 2024-03-07
-
-### Bug Fixes
-
-- 🐛 font fallback ([9fccdee](https://github.com/melMass/comfy_mtb/commit/9fccdee82d721e88c64d2292c209fec869524dd2))
-- ✨ optional inputs of colored image ([cd32f26](https://github.com/melMass/comfy_mtb/commit/cd32f26b167088d6b489e43b260c187ea5e4d223)) by [@ScottNealon](https://github.com/ScottNealon) in [#147](https://github.com/melMass/comfy_mtb/pull/147)
-- 📝 adds a way to not load the imagefeed ([501c330](https://github.com/melMass/comfy_mtb/commit/501c3301056b2851555cccd75ab3ff15b1ab8e0c))
-- 🐛 colored image mask input ([30c4311](https://github.com/melMass/comfy_mtb/commit/30c4311b69f6481a34f968cb67a9b5ce5d2e9fda))
-- 🐛 handle font cache errors ([c43a661](https://github.com/melMass/comfy_mtb/commit/c43a661ba31dcd7720b4f32d8e96760e6191fbd9))
-- 💄 register the COLOR type even for external extensions ([12b134a](https://github.com/melMass/comfy_mtb/commit/12b134ab4c937c192aaf4a3667d9885dd4fe43ca))
-- ✨ mask crop output ([59a361a](https://github.com/melMass/comfy_mtb/commit/59a361af5870b8ffc984c6680dd3282d3553dcf9))
-- 🚑️ thread font loading ([e4da832](https://github.com/melMass/comfy_mtb/commit/e4da832b99bd640b72c31b67178a3168e3238fa0))
-- 📦 changed way of creating bbox from mask ([14ee9e2](https://github.com/melMass/comfy_mtb/commit/14ee9e23c009ab55fa3b2fc6ec60fb683c46d57d)) by [@Yurchikian](https://github.com/Yurchikian) in [#124](https://github.com/melMass/comfy_mtb/pull/124)
-- ✨ expose invert of bboxfrommask ([53cb503](https://github.com/melMass/comfy_mtb/commit/53cb503866da6d83b47eaeb8073039ace2ae0a95))
-- ✨ less strict csv parsing ([d5c4c5f](https://github.com/melMass/comfy_mtb/commit/d5c4c5f2649ecdb4bf7b517c5b33bbf8df753047))
-- 🐛 fit number regression ([c8658df](https://github.com/melMass/comfy_mtb/commit/c8658dfbdd3a0ca8c3e88cd1adfddc55c7444045))
-- 🐛 remove uneeded installs ([4e07450](https://github.com/melMass/comfy_mtb/commit/4e07450bcabb0105b5610e52f7d4692ea07f9c1d))
-- 🐛 import issue ([255ac03](https://github.com/melMass/comfy_mtb/commit/255ac036bab1d776301857843d0e7a85e9a9dcb8))
-- 🐛 wrong output for bbox ([8d12b59](https://github.com/melMass/comfy_mtb/commit/8d12b59844958fbc696d01d51162f97262664ae9))
-- 🚑️ fallback when symlink detection fails ([278f22c](https://github.com/melMass/comfy_mtb/commit/278f22c2093b6eca63d2d00f7936774918707e4e))
-- ✨ handle malformed styles.csv ([e6f6502](https://github.com/melMass/comfy_mtb/commit/e6f65026735770df8aced4a3acb75550ff1c84da))
-- 🐛 encoding ([5af2840](https://github.com/melMass/comfy_mtb/commit/5af284067c65042bcdfff04a5d5a2360bf9e4af7))
-- ⚡️ add the cli deps ([bb90e04](https://github.com/melMass/comfy_mtb/commit/bb90e0415f6a1ececbf468815dc0f5959d9a34e8))
-- 🚑️ check for symlink ([25b933c](https://github.com/melMass/comfy_mtb/commit/25b933c698b250a411549d2600fae49bec225b7a))
-- 🚑️ remove problematic dependencies ([5dfea51](https://github.com/melMass/comfy_mtb/commit/5dfea51dd8db2a4829e559eadeda22374b51c8a4))
-- 🐛 batch support ([f1ff9fc](https://github.com/melMass/comfy_mtb/commit/f1ff9fc7c4684ad673c3178df3b8142dcf0b16ac))
-- 🐛 automatically disable tiling if seamless is on ([4605f74](https://github.com/melMass/comfy_mtb/commit/4605f74f370d4d221ab1d50f21b72910fa6909c7))
-- 🐛 debug node ([dc500b7](https://github.com/melMass/comfy_mtb/commit/dc500b788e885205f017956da6a71a677f822941))
-- ⚡️ hack to handle prompt validation ([d49b257](https://github.com/melMass/comfy_mtb/commit/d49b2578c247dcba9b09b374d99f5cc45cac172d))
-- ✨ deepbump update ([87b245c](https://github.com/melMass/comfy_mtb/commit/87b245c6a6895490e3612b235879fa90b62dea2b))
-- 👷 user folder_paths to retrieve comfy root ([38df58a](https://github.com/melMass/comfy_mtb/commit/38df58a78c363ef2657011893d4d811676b1c664))
-- 🐛 typo ([90aee83](https://github.com/melMass/comfy_mtb/commit/90aee83797a863cf4797cdbe187f949061cbd176))
-- 🐛 do not resolve symlink for "here" ([a50b11b](https://github.com/melMass/comfy_mtb/commit/a50b11bdaa66f4e805811b1676c937ade11318c2))
-- ✏️ use Union to allow support for <3.10 ([88a2779](https://github.com/melMass/comfy_mtb/commit/88a277968745ac990406b14d300a8ada9c575b11)) by [@M1kep](https://github.com/M1kep) in [#91](https://github.com/melMass/comfy_mtb/pull/91)
-- ⚡️ simplify widgets cleanup ([cdd098e](https://github.com/melMass/comfy_mtb/commit/cdd098e10258401402b8023c9143532cfa4a1745))
-- ✨ don't assume the install was ran ([cc43654](https://github.com/melMass/comfy_mtb/commit/cc43654af2987bc8860557caa99cde91e8309b21))
-- 🐛 install ([616b2bf](https://github.com/melMass/comfy_mtb/commit/616b2bfc6c629cef1d30cb0d717bd805c3a086aa))
-- 🐛 properly escape paths ([22cac9b](https://github.com/melMass/comfy_mtb/commit/22cac9b2d95910197941b73e7548735470bd3b17))
-- 🐛 use relative paths in JS ([e2773ff](https://github.com/melMass/comfy_mtb/commit/e2773ff22e43e7756ad618344a03d661a576cf35))
-- 💄 BatchFromHistory when "listening" ([3b07984](https://github.com/melMass/comfy_mtb/commit/3b07984716402fbbf5da41020bf73befd52e7ebf))
-- ✨ save gif widget removal ([fe8f519](https://github.com/melMass/comfy_mtb/commit/fe8f519f8860b0610d8cafcd9b843b4171c2b3d4))
-
-### Documentation
-
-- 📝 add changelog ([0d817bf](https://github.com/melMass/comfy_mtb/commit/0d817bf326b4a22e2221264a414af50c3b7048b9))
-- 📄 add note+ screenshot ([90d9636](https://github.com/melMass/comfy_mtb/commit/90d96366c8b7637b55d1b4f88cb9aca217c1414b))
-- 📝 add cover image ([6b993b8](https://github.com/melMass/comfy_mtb/commit/6b993b84071bbb80ba1b8bd63576f31e35d05590))
-- 📝 fix image size ([3e8c2fe](https://github.com/melMass/comfy_mtb/commit/3e8c2fe789925e7017c2f8c8d9164c139588aba4))
-- 📝 add image ([3e93ea6](https://github.com/melMass/comfy_mtb/commit/3e93ea6f2c73353891b1a3f6223b5730bc69df37))
-- 📝 explain optional nodes ([cea0b08](https://github.com/melMass/comfy_mtb/commit/cea0b08eb044756ab1b408f630435095b8969d36))
-- 📝 add the example previews from the wiki ([8f90986](https://github.com/melMass/comfy_mtb/commit/8f909864bfaa9f2d0fbdcf3942eacb9d78ee8fb8))
-- 📝 update node list ([4917e31](https://github.com/melMass/comfy_mtb/commit/4917e31c427c74d28c830fd7b2423cab393ba0f8))
-- 📝 add some deprecation warnings and recommendations ([e11df9d](https://github.com/melMass/comfy_mtb/commit/e11df9d45c81d93f4334841de036b4aa3364375a))
-- 📝 add a reference to SlickComfy for colab ([bb35098](https://github.com/melMass/comfy_mtb/commit/bb35098c656b0b2d30909b83df0a3b65c5975f78))
-
-### Features
-
-- ✨ add "To Device" ([c28181f](https://github.com/melMass/comfy_mtb/commit/c28181f1615d2e183767aa76cc2350934330e546))
-- ✨ add note+ example ([90f3bc2](https://github.com/melMass/comfy_mtb/commit/90f3bc2d953b299ea34e9e3a925f1a824b488855))
-- 💄 node+ improvements ([4b29395](https://github.com/melMass/comfy_mtb/commit/4b29395000254382882c0d1be115b2ed80cd7c99))
-- 📝 add note plus ([605c8db](https://github.com/melMass/comfy_mtb/commit/605c8db320e1531c6347f6888606fa50d8eb268b))
-- 🚧 add playlist nodes ([cf96572](https://github.com/melMass/comfy_mtb/commit/cf965727e8e7064328704d88cd0410c61f1e686e))
-- 🚨 add missing node ([16c1a59](https://github.com/melMass/comfy_mtb/commit/16c1a59312b1d9841f5f8a814eff93a1ddf04edb))
-- ✨ Math Expression node ([142624e](https://github.com/melMass/comfy_mtb/commit/142624eea616a5622387b1b641c02605455ee6f1))
-- 🚀 add optional inputs to colored image ([049983d](https://github.com/melMass/comfy_mtb/commit/049983dbe2dbce6b772908468c4042d2bfde5eb2))
-- ✨ Add support for extra_model_paths.yaml ([d7b8ac8](https://github.com/melMass/comfy_mtb/commit/d7b8ac8e0c98b0d7a2e21889d35aad9f6b093560))
-- ✨ add batch shake ([af94203](https://github.com/melMass/comfy_mtb/commit/af94203d1b461d934ca1c44211ca0f71a5d05d48))
-- ✨ enhance concat images ([a798eb0](https://github.com/melMass/comfy_mtb/commit/a798eb07d0d891cfbd47013b442ef2fa3d7cc5bc))
-- 💄 add a few more batch nodes ([c1d42de](https://github.com/melMass/comfy_mtb/commit/c1d42de0fcde86d2a167fb4b5e781ee987814da2))
-- ✨ Batch node utilities ([cef5023](https://github.com/melMass/comfy_mtb/commit/cef5023efc17366a2e937ef43944de3587707fac))
-- 🚨 Image Stack node (horizontal and vertical stack) ([bb3277d](https://github.com/melMass/comfy_mtb/commit/bb3277d85f4ca21735cb1f5237cb1430db88c183))
-- 🚀 add seamless model hack ([21acc87](https://github.com/melMass/comfy_mtb/commit/21acc87ff0a84b7588f4b5aae0aeb5ae94bbbfbe))
-- 🔧 debug handle a few more types ([638498c](https://github.com/melMass/comfy_mtb/commit/638498c6b47c2b2cab82f76aec1f3d46df67f263))
-- 🎨 Add an editor for the styles loader ([2faa2f2](https://github.com/melMass/comfy_mtb/commit/2faa2f2a148a4dbf5525e4945f688a239f244546))
-- ✨ add a static assets path ([6a00d1d](https://github.com/melMass/comfy_mtb/commit/6a00d1da5a8a5fa47af1bf1ab5d3cd206c599841))
-- ✨ add  Interpolate Clip Sequential ([a71c273](https://github.com/melMass/comfy_mtb/commit/a71c273baf450ad7e2a7e032451f015d3be3e9e9))
-
-### Miscellaneous Tasks
-
-- 🧹 applied some linting ([fe49312](https://github.com/melMass/comfy_mtb/commit/fe49312cbef03c6540304448fa88aa7a88391efa))
-- 📝 header links not parsed ([514c0d2](https://github.com/melMass/comfy_mtb/commit/514c0d2eda9990435eb18258d4bbd1aa137feb3d))
-- 📝 hardcode links in changelog ([915b744](https://github.com/melMass/comfy_mtb/commit/915b7444a9db83f349d83b636304af0d276f529f))
-- 🔖 local updates ([6c5e5d3](https://github.com/melMass/comfy_mtb/commit/6c5e5d36379bdab223b4503e42b7956b55a82ab0))
-- 📝 update node list ([dd27f99](https://github.com/melMass/comfy_mtb/commit/dd27f990c72fa94aff205eb314a8ea360f57479e))
-- ✨ update node_list ([537a0d8](https://github.com/melMass/comfy_mtb/commit/537a0d8108d0caa3ab2daeafd1d25d680214ef26))
-- ✨ local stuff ([9afad1a](https://github.com/melMass/comfy_mtb/commit/9afad1a1680073006d946be10f8c97b75ddfe253))
-- 📝 fix update issue template ([da290db](https://github.com/melMass/comfy_mtb/commit/da290dbcf2952a56be9334f7bf9dc4d8fa64a21d))
-- 📝 update issue template ([b949bb4](https://github.com/melMass/comfy_mtb/commit/b949bb406bc1929634600465ea389eaedefe6e6f))
-
-### Refactor
-
-- ⚡️ small local fixes ([bcac665](https://github.com/melMass/comfy_mtb/commit/bcac66508d2e788cc437da289d1ccede19465b8c))
-- 🗑️ remove unused code in install script ([5b75436](https://github.com/melMass/comfy_mtb/commit/5b75436610c6312adf47c6baa3e9fe9cc7d56dcf))
-
-### Merge
-
-- 🔀 pull request #109 from melMass/dev/0.2.0 ([87e301d](https://github.com/melMass/comfy_mtb/commit/87e301d120a542d5aabe544bec10d38dbd19b2f6)) in [#109](https://github.com/melMass/comfy_mtb/pull/109)
-- 🔀 pull request #86 from melMass/feature/styles-editor ([cbdb816](https://github.com/melMass/comfy_mtb/commit/cbdb816164900061ddaa1671f4287763d0b79ee1)) in [#86](https://github.com/melMass/comfy_mtb/pull/86)
-
-### Wip
-
-- 🚧 add text template node ([af2175a](https://github.com/melMass/comfy_mtb/commit/af2175a1fc0c2fb29ef3493f242fe45ec6fcabac))
-
-## New Contributors
-* [@ScottNealon](https://github.com/ScottNealon) made their first contribution in [#147](https://github.com/melMass/comfy_mtb/pull/147)
-* [@Yurchikian](https://github.com/Yurchikian) made their first contribution in [#124](https://github.com/melMass/comfy_mtb/pull/124)
-* [@M1kep](https://github.com/M1kep) made their first contribution in [#91](https://github.com/melMass/comfy_mtb/pull/91)
-## [0.1.4] - 2023-08-12
-
-### Bug Fixes
-
-- 🚀 pending fixes ([ea5d73d](https://github.com/melMass/comfy_mtb/commit/ea5d73d48cfa4046f48a52609cff7f754d8364ed))
-- 🚑️ image resize infinite loop ([30d6cfe](https://github.com/melMass/comfy_mtb/commit/30d6cfe81292d0f7702544b3c2cbad1820c4a926))
-- ✨ update example files ([610afe0](https://github.com/melMass/comfy_mtb/commit/610afe031f21d737b2fd5128e4be7100b6666181))
-- 🐛 simplify install steps ([4fc84d6](https://github.com/melMass/comfy_mtb/commit/4fc84d615dd0f546442c3537f00c52366db4ca9b))
-- ✨ refactor ([8523392](https://github.com/melMass/comfy_mtb/commit/8523392df74c586dc940841ddbb5069943b16f7d))
-- 🐛 debug rgba ([40560f8](https://github.com/melMass/comfy_mtb/commit/40560f8154d3ddeabf708be4d111370648d466ac))
-- 🎨 rename fun to generate ([e7f72f9](https://github.com/melMass/comfy_mtb/commit/e7f72f9825da58254e3084b4ba91f76e6cf2cf5f))
-- ✨ refactor existing ([1144466](https://github.com/melMass/comfy_mtb/commit/11444662b9198861b62aff06a08b9c9ea01dd8bd))
-- ⚡️ move getbatchfromhistory to graphutils ([2eccba4](https://github.com/melMass/comfy_mtb/commit/2eccba4e33b21d1d080cb2f415f76a93488120f0))
-- 🚧 wip dependency installer UI ([630b492](https://github.com/melMass/comfy_mtb/commit/630b492347f75d7308b31a000061b41d7dfa4a10))
-- 🐛 image feed zorder ([0fb2d4d](https://github.com/melMass/comfy_mtb/commit/0fb2d4da90a7e65f82b3f9c8942a68e360456cf7))
-- ⬇️ download_antelopev2 ([4dd5321](https://github.com/melMass/comfy_mtb/commit/4dd532185223a1fa5978446e7bb75d32d77ebdb5))
-- 🚑️ frontend pushed too early ([91f60d4](https://github.com/melMass/comfy_mtb/commit/91f60d4c463c474ac10e868e8e73e13fa019856b))
-- 🚑️ missing input ([84ac8ac](https://github.com/melMass/comfy_mtb/commit/84ac8ac852aeb962029bfd8369fe5ed59a203977))
-- 🐛 shell command bug ([3d5075f](https://github.com/melMass/comfy_mtb/commit/3d5075fea2e219a179271c9810017c7e38bff6cc))
-- 🚑️ remove pipe mode from the install.py ([b854a30](https://github.com/melMass/comfy_mtb/commit/b854a302ce4708d2ad2dac249860308dbdcae5a6))
-- ⚡️ colab install ([36d8e6b](https://github.com/melMass/comfy_mtb/commit/36d8e6bdb06edab72ccfb686266d2e644a9f028c))
-- 🚑️ install typo ([ffa1a87](https://github.com/melMass/comfy_mtb/commit/ffa1a87b9184df5a3699a6118714b39d359bde4d))
-
-### Documentation
-
-- 📝 link the actual action instead of badge ([098d74a](https://github.com/melMass/comfy_mtb/commit/098d74a3cd8449d836569a074995e20d775c6728))
-- 📝 add action badge ([e74314b](https://github.com/melMass/comfy_mtb/commit/e74314b04eb218c140482ccf704b61af06db3f4d))
-
-### Features
-
-- 💫 export to prores -> export with ffmpeg ([a4d99d9](https://github.com/melMass/comfy_mtb/commit/a4d99d966b1207191243a9749385b998d1a9c6b1))
-- 🔥 add any to string & refactor ([dbdb872](https://github.com/melMass/comfy_mtb/commit/dbdb872b74e18c16feb44bd037abc3aafbb4700f))
-- ✨ add UI for interpolate clip sequential ([5ec5511](https://github.com/melMass/comfy_mtb/commit/5ec551143302b2a94ca82e477f684ecee23f1459))
-- ✨ add portable reqs ([3f14b16](https://github.com/melMass/comfy_mtb/commit/3f14b1676d28f5ffa1f47fda00b9bc244951045c))
-- ✨ add border extension ([fb64484](https://github.com/melMass/comfy_mtb/commit/fb644847ca434123e8e8e4991d33949fd31e3cbe))
-- ✨ use PIL for gif saving ([2bc7ae8](https://github.com/melMass/comfy_mtb/commit/2bc7ae88bf4cdfa575d11233c0e6f7b07f9dfd23))
-- 🎨 update node list ([a54d7d5](https://github.com/melMass/comfy_mtb/commit/a54d7d5346c272898dd4e67c65495de7325ab3a0))
-- ✨ install fix ([512de60](https://github.com/melMass/comfy_mtb/commit/512de6023e55f2cc47516bf44436efe22157273f)) in [#41](https://github.com/melMass/comfy_mtb/pull/41)
-
-### Miscellaneous Tasks
-
-- 💄 encoding ([49c64c7](https://github.com/melMass/comfy_mtb/commit/49c64c74eb3e99f456b563bbd79e3fe47a85c70d))
-- 🚀 only fetch controlnet_preprocessor deps ([414beb9](https://github.com/melMass/comfy_mtb/commit/414beb99a1f9bf719eca6ac139c9b2ccdfd6d743))
-- 🚀 add controlnetpreprocessors to tests ([63b3aec](https://github.com/melMass/comfy_mtb/commit/63b3aece2ba05adc2b655afeb41e3d47e7887b33))
-- ✨ remove unused input ([d4f791d](https://github.com/melMass/comfy_mtb/commit/d4f791d7a14ba9cb8abd7c95ba70b081fee5fb7c))
-- ✨ use the same cwd as manager ([2ff0467](https://github.com/melMass/comfy_mtb/commit/2ff04672daff773d52e1552dca1bf616bc32daa6))
-- 🎨 no brace glob ([bbfcb62](https://github.com/melMass/comfy_mtb/commit/bbfcb62c398de39058bcb6e18161425059d53e8e))
-- 🎨 extract txt ([a22fd01](https://github.com/melMass/comfy_mtb/commit/a22fd01d664276e4cd833ae1326feeece1d1deaf))
-- 🎨 also push wheels_order to releases ([8e5b776](https://github.com/melMass/comfy_mtb/commit/8e5b7765cc0c6730bd5517ccfd56e817ea39bd3a))
-- 🚧 more info for bug reports ([3dadc11](https://github.com/melMass/comfy_mtb/commit/3dadc119f44fca1029ec4b349d71ce99fb20a4b6))
-- ✨ individual wheels ([346ff64](https://github.com/melMass/comfy_mtb/commit/346ff649d50c9f0286ad2243938406fefb62853b))
-
-### Refactor
-
-- 🚧 tidy ([4f30829](https://github.com/melMass/comfy_mtb/commit/4f30829e06c41b3685644bfe7bece07e0bcfb70e))
-- ♻️ get batch from history ([13d255a](https://github.com/melMass/comfy_mtb/commit/13d255a730b08c4903647875350b9b3dcd61b4a6))
-
-### Revert
-
-- 💄 use BOOLEAN instead of BOOL ([cfb3b23](https://github.com/melMass/comfy_mtb/commit/cfb3b237cf64b512414a17f71e6d89c3355aa8ef))
-
-### Testing
-
-- 🧪 remove sha input ([c5bbe83](https://github.com/melMass/comfy_mtb/commit/c5bbe83008bb194cbd6ad5e3dc70cb3850b18985))
-- 🧪 ci for comfy embedded ([7b3afca](https://github.com/melMass/comfy_mtb/commit/7b3afca8179760e35e8a6fbf742080dee13e4fc7))
-
-### Merge
-
-- 🔀 pull request #50 from melMass/dev/august-refactor ([2ecd470](https://github.com/melMass/comfy_mtb/commit/2ecd4700d77c0727e6b5d2124e0a6ebd48ec96ed)) in [#50](https://github.com/melMass/comfy_mtb/pull/50)
-
-## [0.1.3] - 2023-07-29
-
-### Bug Fixes
-
-- 🔥 manage pip from install only, remove requirements.txt ([247fbfb](https://github.com/melMass/comfy_mtb/commit/247fbfbc216b8259d607e0699d5b990b6a06ca71)) in [#38](https://github.com/melMass/comfy_mtb/pull/38)
-- 🎨 use image ratio for imagefeed ([f5cd56c](https://github.com/melMass/comfy_mtb/commit/f5cd56ce861c8c0a931744ae6cf2b96e9c8bca06))
-
-### Documentation
-
-- 📝 update imagefeed preview ([cbcacbe](https://github.com/melMass/comfy_mtb/commit/cbcacbe3c92ebb5f74d046b83504c3723710f130))
-- 📝 fix typo and add more details ([7c020ba](https://github.com/melMass/comfy_mtb/commit/7c020bab288aa7d17dc937b5f102319d43c3ebb3))
-
-### Miscellaneous Tasks
-
-- ✨ use wheel order if present ([9b24edd](https://github.com/melMass/comfy_mtb/commit/9b24eddd9c51004af08d7ac6ff2b6473dd3ee161))
-- ✨ store order of install for wheels ([5053142](https://github.com/melMass/comfy_mtb/commit/505314294f02e7c19ac95e4d0ed37fd397a54b46))
-
-## [0.1.2] - 2023-07-28
-
-### Bug Fixes
-
-- ✨ various small things ([0e311cf](https://github.com/melMass/comfy_mtb/commit/0e311cf2c64cf2b4861d4cc612a3409390e3039a))
-- 📝 last release ([889f08c](https://github.com/melMass/comfy_mtb/commit/889f08c08b721be8fdb4e4d7eacc47169d5692d6)) in [#36](https://github.com/melMass/comfy_mtb/pull/36)
-- 📝 narrow requirements ([5d661b2](https://github.com/melMass/comfy_mtb/commit/5d661b2509fecf3940c3c0fab25b16ec0eae7a2d))
-- ✨ Separate FaceAnalysis model loading ([d143e83](https://github.com/melMass/comfy_mtb/commit/d143e83dba3bffa16e1b98d7ad1e9cf92dc94db2))
-- ⚡️ update examples to match wiki ([3dfe98c](https://github.com/melMass/comfy_mtb/commit/3dfe98c7957df48723380de85e1242a424ec23de))
-
-### Documentation
-
-- 📝 add readme for web extensions features ([be162a2](https://github.com/melMass/comfy_mtb/commit/be162a20477258627fa0d742c97a478bd085ff4f))
-- 📝 link to the proper lang instructions ([232cf89](https://github.com/melMass/comfy_mtb/commit/232cf8966cc20291b60c68f487dfd37bf6aa4dfa)) in [#33](https://github.com/melMass/comfy_mtb/pull/33)
-- 📝 update readmes ([96a0618](https://github.com/melMass/comfy_mtb/commit/96a0618c5990a8559a9e2dd17c868d3465b8ca90))
-
-### Miscellaneous Tasks
-
-- 🎉 bump version ([9e751a2](https://github.com/melMass/comfy_mtb/commit/9e751a242f4e9afee3dc5c871c414b29b9706ff6))
-- 👷 remove stale example ([c237737](https://github.com/melMass/comfy_mtb/commit/c2377374201fc34b107c8b7db1cdeb2f483d1e18))
-- 🐛 fix size ([c0cc557](https://github.com/melMass/comfy_mtb/commit/c0cc5572d8c727568eca8a3d0f116a1f540c31ff))
-
-## [0.1.1] - 2023-07-24
-
-### Bug Fixes
-
-- 🎨 improve a bit the HTML response of endpoints ([50d51c7](https://github.com/melMass/comfy_mtb/commit/50d51c70d04e49e9df524975c171288c0fc0b20f))
-- 🐛 caching issues ([55c9736](https://github.com/melMass/comfy_mtb/commit/55c9736a9b2ca036926be4b06406121bfb9ebad2))
-- 🔥 remove notice ([abf1e82](https://github.com/melMass/comfy_mtb/commit/abf1e82adb9fac8cd70d5c409baad55309ef6fe1))
-- 🔥 use BOOL everywhere ([a393793](https://github.com/melMass/comfy_mtb/commit/a393793cfa93721eac46295723076a1dda940dcd))
-
-### Documentation
-
-- 📝 added lang links ([bbdac97](https://github.com/melMass/comfy_mtb/commit/bbdac97e49af4e90d22eeec3f63b96ecc126ffcf))
-- 📝 add comfyforum example ([10d0503](https://github.com/melMass/comfy_mtb/commit/10d05031b1791ab3534cf838be6eb75df638dfb6))
-
-### Features
-
-- 🚧 jupyter seems to require an __init__ there ([9a4eda3](https://github.com/melMass/comfy_mtb/commit/9a4eda3ef573bf382c13515f67ae8a415bf61abd))
-- ⚡️ use notify ([a2ecc11](https://github.com/melMass/comfy_mtb/commit/a2ecc11ebde79c2403959bf09c258f3a2465894a))
-- ✨ first version of Notify ([7e9c97e](https://github.com/melMass/comfy_mtb/commit/7e9c97ecb48672b25e5ed17b9b35dba9208ac311))
-- ⚡️ add an "actions" endpoint ([3de160a](https://github.com/melMass/comfy_mtb/commit/3de160af25b516c02aaa8cc32baec16e9ef358fb))
-- ✨ add Unsplash Image node ([8d3cc39](https://github.com/melMass/comfy_mtb/commit/8d3cc39b72dff1b5eb61bf7e2e395753c138ec8a))
-- ✨ add back Save Tensors ([7142b28](https://github.com/melMass/comfy_mtb/commit/7142b284adc7fba9a1bdafd1a52621bfc168bde1))
-- ✨ add TransformImage node ([11128ff](https://github.com/melMass/comfy_mtb/commit/11128ff85a7e0b4a54f405548969c2478da26df6))
-
-### Miscellaneous Tasks
-
-- 🚀 bump version ([cf86552](https://github.com/melMass/comfy_mtb/commit/cf865529ab64b350cd7af964b41160e7d130d12d))
-- 🚀 Remove large files from release ([3b9190a](https://github.com/melMass/comfy_mtb/commit/3b9190a69b002b8933c097fd6655bb4fe07264d2))
-
-### Refactor
-
-- ✨ cleaned up frontend code a bit ([3801a44](https://github.com/melMass/comfy_mtb/commit/3801a443bc1e89c70fdb35ce0b1724d86fa22928))
-- ⚡️ remove empty inits ([21729b2](https://github.com/melMass/comfy_mtb/commit/21729b2784a50fcaf24a63ac283bdae475a53ce7))
-
-### Merge
-
-- 🔀 pull request #32 from melMass/dev/next ([8695cd3](https://github.com/melMass/comfy_mtb/commit/8695cd3f1b6d27b5cd6c616ed1215ea2f25c5304)) in [#32](https://github.com/melMass/comfy_mtb/pull/32)
-
-## [0.1.0] - 2023-07-22
-
-### Bug Fixes
-
-- 🔥 properly match built wheels ([119b4d6](https://github.com/melMass/comfy_mtb/commit/119b4d6e16c2a90db1664ccaac748507feb73ea0)) in [#30](https://github.com/melMass/comfy_mtb/pull/30)
-- ✨ also try to copy web if symlink fails ([0df55de](https://github.com/melMass/comfy_mtb/commit/0df55def29fb992751010f6b8a707699f230ff37))
-- ✨ install process tested in comfy-manager (embed, colab) ([b40730d](https://github.com/melMass/comfy_mtb/commit/b40730ddbc3f8e3e7d5a17e9e9e4526ff37977fd))
-- 🚀 try to support remote install too ([3c66de2](https://github.com/melMass/comfy_mtb/commit/3c66de2500a89efd2d2e3af88fc58429af725789))
-- 💄 save gif issues ([7335003](https://github.com/melMass/comfy_mtb/commit/7335003346e83666c5dee631b8e6b15586d871e7))
-- 🚑️ always use latest for now ([fccf313](https://github.com/melMass/comfy_mtb/commit/fccf31348994ab6e344a1ab00a8f9998309f9319))
-- 🐛 install logic ([7e301e2](https://github.com/melMass/comfy_mtb/commit/7e301e2a067d41cba9b8ef357496dd1df94e4cdd))
-- 🎉 remove tests & add missing docs ([4e6b877](https://github.com/melMass/comfy_mtb/commit/4e6b87719989aa144946c5c9a43b9398c20bf11e))
-- ⚡️ update node_list ([c794d6a](https://github.com/melMass/comfy_mtb/commit/c794d6a071778220d654b526d2edfddcc79752fc))
-- 🚑️ set debug level from endpoint ([18402e3](https://github.com/melMass/comfy_mtb/commit/18402e3be1ab47e10109cfd2dff18863a1ee56f7))
-- 🐛 add base64 prefix to outputs ([0950f99](https://github.com/melMass/comfy_mtb/commit/0950f9914c9bbed7c89f3de33a967cb76f9d0bbb))
-- 🎨 refactor and add Gif preview on node ([c2e8379](https://github.com/melMass/comfy_mtb/commit/c2e83794faeb8da708c98908882e38b2a42827bd))
-- ✨ Various widgets issues ([27500ca](https://github.com/melMass/comfy_mtb/commit/27500ca432d686774b991045b7cffc58c0b67faf))
-- 🔥 deprecate some nodes and fix image list ([9aa934f](https://github.com/melMass/comfy_mtb/commit/9aa934f70ff6adf91efb26aa8e5cb21ec575196a))
-- 🐛 crop nodes ([67d3783](https://github.com/melMass/comfy_mtb/commit/67d3783ac9186da6bba4b7dc7e8dc3d5db5a1b0f))
-- 🐛 tensor2pil ([8a59508](https://github.com/melMass/comfy_mtb/commit/8a59508ff91d6b2d9ca287ef1c054ec5755337a4))
-- ⚡️ a few missing __doc__ ([ab09cca](https://github.com/melMass/comfy_mtb/commit/ab09ccadd905bebbf1b7b2d992e96e36fc60d68a))
-- ⚡️ from tensor2np always returning a list ([6168b3a](https://github.com/melMass/comfy_mtb/commit/6168b3a2ac38b5eebed3daf9e52df5742abf6813))
-- 🚑️ TF by default fills vram ([c225da5](https://github.com/melMass/comfy_mtb/commit/c225da5f298acb4cb2b39022382543c0c966d428))
-- ✨ leftovers ([da3e6f4](https://github.com/melMass/comfy_mtb/commit/da3e6f47c6073e73cf9d3a3cd23ba5ccbe1fedce))
-- ✨ handle non fork gdown in model dll ([95797e8](https://github.com/melMass/comfy_mtb/commit/95797e823e12e62ae8758753f60c34afbe19ec90))
-- ✨ properly add the submodules ([00510ed](https://github.com/melMass/comfy_mtb/commit/00510ed0b8583dd64518daa67d963582f4f029d3))
-- 📌 remove sad talker for now ([1622cbc](https://github.com/melMass/comfy_mtb/commit/1622cbcb9d51ddd0e1a8b4d87ba47b99327163eb))
-- 🎨 narrow requirements ([1a92ef7](https://github.com/melMass/comfy_mtb/commit/1a92ef734dd4271efc875856038f9e3b6b9ded6c))
-- 🚀 use the comfy util to handle graph interruption ([9752f3e](https://github.com/melMass/comfy_mtb/commit/9752f3e9dec9aa59cfa809aa14f0151594c03858))
-- 🔥 much faster (using GPU) on windows ([2f455aa](https://github.com/melMass/comfy_mtb/commit/2f455aaca55c0a044735c768b295d077b2f5b8d6))
-- 🐛 uint8 to uint16 ([be5a655](https://github.com/melMass/comfy_mtb/commit/be5a655cfaba1794f7b09c82d65de42e2b031720))
-- ✨ add missing requirements ([b779bc3](https://github.com/melMass/comfy_mtb/commit/b779bc39ac19f779aeb73c98b916671d1d16806f))
-- 📝 don't propagate base logs ([7fd99c2](https://github.com/melMass/comfy_mtb/commit/7fd99c25c4e50566def5c5166a9d9059b1febfa6))
-- 🐛 bg upscaler in gfpgan ([fee48ad](https://github.com/melMass/comfy_mtb/commit/fee48adff3d66960cb17836f3f4efbfd0c8740c4))
-- 📝 separate debug / info better ([e24863d](https://github.com/melMass/comfy_mtb/commit/e24863d1f9f63f367a2b392e6228ffa42927b71b))
-- 🔥 change log level of the base logger ([7538c2c](https://github.com/melMass/comfy_mtb/commit/7538c2c4bad8390a32226dc0a5a6ef978b00d201))
-- ✨ handle externs dynamicly ([6ef308a](https://github.com/melMass/comfy_mtb/commit/6ef308a87062c91e2d7249c05d96c6fb76e5a6c4))
-- 🐛 separate faceswap model load ([8e267c0](https://github.com/melMass/comfy_mtb/commit/8e267c0204ce5abe8e113fd401234d49f377646a))
-
-### Documentation
-
-- 📝 fold each comfy mode ([3c3c438](https://github.com/melMass/comfy_mtb/commit/3c3c4380bd1a3f0eed5216b835e076c26fce2f88))
-- 📝 add more description to examples ([46eab5c](https://github.com/melMass/comfy_mtb/commit/46eab5ca2f0e04d872d87c849b11551fd219bdb9))
-- 📝 add model notice ([cbe67ed](https://github.com/melMass/comfy_mtb/commit/cbe67edd4befb7260be01fa09af8448e5bcf5680))
-- 📝 add preview for examples ([b5176ca](https://github.com/melMass/comfy_mtb/commit/b5176ca0ee489ada52b6632f68b794b4f709d5ba))
-- 📝 add jp and cn (using deep translation) ([da559b9](https://github.com/melMass/comfy_mtb/commit/da559b9eaf135a49c0ab9bfa45573baf0c18dfb2))
-- 📝 update readme ([b0fb522](https://github.com/melMass/comfy_mtb/commit/b0fb5222cb19e4004533d3367863be5c9ce8e72b)) in [#15](https://github.com/melMass/comfy_mtb/pull/15)
-- 📝 update README.md ([f8dc768](https://github.com/melMass/comfy_mtb/commit/f8dc768635a2d21f6ff81b42c418724c432159bf))
-- 📝 updated instructions ([c3b9fd4](https://github.com/melMass/comfy_mtb/commit/c3b9fd4afedbb46748aef17b40e167a4cfad65f5))
-
-### Features
-
-- ✨ update install instructions ([7be37db](https://github.com/melMass/comfy_mtb/commit/7be37dbbfac45e8038f94ced8a2fa8ec2b06fb34))
-- 🚀 add install script ([dad3966](https://github.com/melMass/comfy_mtb/commit/dad3966ba219c1998e4fc7f6e641864fb0e7c3e8))
-- 🚧 add my CLIs ([44eaae5](https://github.com/melMass/comfy_mtb/commit/44eaae5c79f4dbec344053d945e7275be5c3c0a5))
-- ✨comfy_widget shared utils ([91bb95d](https://github.com/melMass/comfy_mtb/commit/91bb95da914468de533b040324700c7f9707e4fb))
-- 🚀 debug node ([b27b8ef](https://github.com/melMass/comfy_mtb/commit/b27b8ef91fe7335b1df3766547edaf4b9625ae4d))
-- ✨ add FitNumber node ([aa551eb](https://github.com/melMass/comfy_mtb/commit/aa551ebe57801c69010815119fe21e19a858780c))
-- 🔥 add API endpoints ([95afbdb](https://github.com/melMass/comfy_mtb/commit/95afbdbf76e66897e632252d876384ada9acf153))
-- ✨ categorize ([d2b3962](https://github.com/melMass/comfy_mtb/commit/d2b396236a10fe620ebebabd5a22c36159921913))
-- 🚀 add a few examples ([b9c1d3d](https://github.com/melMass/comfy_mtb/commit/b9c1d3df7a1460fe9ffa84f6f9ea0cfb5409de1a))
-- ✨ added a way to export the node list ([5f5297f](https://github.com/melMass/comfy_mtb/commit/5f5297f80debc77f3fda2f0d37b3acff8419140d))
-- ✨ WIP batch from history ([cde7293](https://github.com/melMass/comfy_mtb/commit/cde72938d5ffd09179f5974676e12d4599a8d6ff))
-- ✨ extract node names using ast ([38f6147](https://github.com/melMass/comfy_mtb/commit/38f61473bc23b4c5d4efc5048d54c059565a6fa0))
-- 🔥 add batch support for load image sequence ([3faadc4](https://github.com/melMass/comfy_mtb/commit/3faadc4b8a5049cb8c264b8a3d50565adec405f1))
-- 🎨 add support for image.size(0) == 0 ([629e2b5](https://github.com/melMass/comfy_mtb/commit/629e2b5f5fbebe4e79e8b7a4cff2de6017e79225))
-- ✨ image feed ([99eb5ae](https://github.com/melMass/comfy_mtb/commit/99eb5ae0c7413f6ab1f24cfc8337c9b1b2d9824c))
-- ✨ FILM interpolation nodes ([e04e77e](https://github.com/melMass/comfy_mtb/commit/e04e77eb097735ec1369dec51238cdcc5abe39b7))
-- ✨ add an headless option for model downloads ([217e8a1](https://github.com/melMass/comfy_mtb/commit/217e8a1546d06b97250d99612ac6bdb5ce89e155))
-- 🐛 support batch count > 1 for restore face ([8ef48a0](https://github.com/melMass/comfy_mtb/commit/8ef48a013a8d6b832b8c0c7dcabc1b78c27ff207))
-- 🚧 wrapper for GFPGAN bg upscaler ([88cdcc6](https://github.com/melMass/comfy_mtb/commit/88cdcc6a87dae452924e8915eccdadc69d7d136e))
-- ✨ add GFPGAN (FaceRestore) ([3a6e545](https://github.com/melMass/comfy_mtb/commit/3a6e5450502f3b1d7c505178fc9ba337cd95c39e))
-
-### Miscellaneous Tasks
-
-- ✨ before categorize ([0cc54e5](https://github.com/melMass/comfy_mtb/commit/0cc54e58ec86c28354cae37e14f39e831c13ea02))
-- ✨ add more issue templates ([710a638](https://github.com/melMass/comfy_mtb/commit/710a638a8187ef08254478f684307dccdebcded2)) in [#25](https://github.com/melMass/comfy_mtb/pull/25)
-- ✨ add bug report template ([f927bc7](https://github.com/melMass/comfy_mtb/commit/f927bc7c9a82951e6df4763433732f20ea87e9cb))
-- 🍻 create FUNDING.yml ([f634fe0](https://github.com/melMass/comfy_mtb/commit/f634fe0e6b2db28138e4bd7932fbfc8606a0f033))
-- 🍻 add bmc to readme ([cd1b603](https://github.com/melMass/comfy_mtb/commit/cd1b603565464fe98a718e1fbaa8c7cd84057576))
-- 📝 extra files from another branch ([b78be8f](https://github.com/melMass/comfy_mtb/commit/b78be8fd3cd36666fd94a3ab08eca11cce526043))
-- 🚀 push leftovers ([4c41fe7](https://github.com/melMass/comfy_mtb/commit/4c41fe7af9f8e16d895eb06223349e1294dd4698))
-
-### Refactor
-
-- ♻️ removes a few nodes, moved other around ([4d8ddac](https://github.com/melMass/comfy_mtb/commit/4d8ddaca320ce483640d030618e70730b3453df2))
-- ♻️ remove test ([68c250e](https://github.com/melMass/comfy_mtb/commit/68c250e890dacae9f627b0d266ad6dcab0fa0c8b))
-- 🚧 remove color_widget ([e480d07](https://github.com/melMass/comfy_mtb/commit/e480d071171cffa789930620f1e7ccc76473bf93))
-
-### Testing
-
-- 🔧 pipe detection ([ee17d57](https://github.com/melMass/comfy_mtb/commit/ee17d57c3d6d71fda1a5acc2cf85f936c525bc87))
-
-### Install
-
-- 🚧 handle symlink errors ([d982b69](https://github.com/melMass/comfy_mtb/commit/d982b69a58c05ccead9c49370764beaa4549992a))
-
-### Merge
-
-- 🔀 pull request #22 from melMass/dev/next-release ([c34de0a](https://github.com/melMass/comfy_mtb/commit/c34de0ab351b2c95d7fa4fab4487155bee6bfa3a)) in [#22](https://github.com/melMass/comfy_mtb/pull/22)
-- 🎉 pull request #11 from dev/frame_interpolation ([1e28606](https://github.com/melMass/comfy_mtb/commit/1e28606427bcc8d895b87eaa6cd4147ab6d9a11f)) in [#11](https://github.com/melMass/comfy_mtb/pull/11)
-- 🎉 pull request #8 from dev/small-fixes ([7585624](https://github.com/melMass/comfy_mtb/commit/7585624de5895eb34c6a520d4dab18b47e64b6ca)) in [#8](https://github.com/melMass/comfy_mtb/pull/8)
-
-## [0.0.1] - 2023-06-28
-
-### Bug Fixes
-
-- 🤦 add missing file ([e2c4561](https://github.com/melMass/comfy_mtb/commit/e2c456147c260b4e9d583662e3bb9d6d9a019a5e))
-- ✨ small edits ([bcf55ca](https://github.com/melMass/comfy_mtb/commit/bcf55ca9a3a07067be3319182501f7b635e5d2ba))
-- ⚡️ add support for batch in roop ([2dae020](https://github.com/melMass/comfy_mtb/commit/2dae02056a11ddfe1f84ee040818028177e404b5))
-- 🔥 various preparing for the first tag ([793784a](https://github.com/melMass/comfy_mtb/commit/793784a5fd08e8a70d670fc8edbc3bb5b6e13e67))
-- 🐛 various bugs ([afd0843](https://github.com/melMass/comfy_mtb/commit/afd08431458e3bbb14a25c84a87408113edf5db5))
-- ⚡️ add missing controls to QRCode ([7e86b0e](https://github.com/melMass/comfy_mtb/commit/7e86b0ed4d300021517f6c5cf28a45012497b5c5))
-
-### Documentation
-
-- 📝 add rembg screenshot ([9a2d523](https://github.com/melMass/comfy_mtb/commit/9a2d52325f87ecf6342ef4897da919006755b9db))
-- 📝 add a few screenshots ([e162336](https://github.com/melMass/comfy_mtb/commit/e162336cd366d39cd4b96f05b3c9c68eecec3dc4))
-- 📝 update readme ([7f3070d](https://github.com/melMass/comfy_mtb/commit/7f3070debbc3330da50ff845621ce299894cf862))
-
-### Features
-
-- 💄 faceswap node using roop ([966a14b](https://github.com/melMass/comfy_mtb/commit/966a14b40d88f4fccfb2eaa5ff9b222f0eedd7cb))
-- ✨ sync local changes ([647bf9e](https://github.com/melMass/comfy_mtb/commit/647bf9e94195c279a620c74c2253471b9c4b90f7))
-- ✨ bbox from alpha ([37abf8a](https://github.com/melMass/comfy_mtb/commit/37abf8aad12f4711c6d82c6be4be6fa3578e7af5))
-- ✨ a111 like style loader ([f59b68e](https://github.com/melMass/comfy_mtb/commit/f59b68e3ad92841a4d189d8dddf7b41e915c9b4e))
-- ✨ add a color type and widget ([9a2e986](https://github.com/melMass/comfy_mtb/commit/9a2e986327c34227a707beab6d9929b0a05e41e6))
-- ✨ add a few nodes ([811443b](https://github.com/melMass/comfy_mtb/commit/811443b92161815db1cdff81898e8834dcd6fbfa))
-- ✨ add SadTalker as a submodule ([3fb8716](https://github.com/melMass/comfy_mtb/commit/3fb871651b12bce62d8e911bd3884f417f80c937))
-- 🚨 push local changes ([6cac344](https://github.com/melMass/comfy_mtb/commit/6cac344f6fb15ebb902acee70ee71edc585ec4bc))
-- ⚡️ initial commit ([1ae3bbc](https://github.com/melMass/comfy_mtb/commit/1ae3bbc89ae6e0d2e8c61122485bd0df837e17c2))
-
-### Miscellaneous Tasks
-
-- 🚀 add gh action ([572b4d5](https://github.com/melMass/comfy_mtb/commit/572b4d52bce1398660d4d7ca0c5c48c11e0128e3)) in [#4](https://github.com/melMass/comfy_mtb/pull/4)
-
-[main]: https://github.com/melMass/comfy_mtb/compare/v0.1.4..main
-[0.1.4]: https://github.com/melMass/comfy_mtb/compare/v0.1.3..v0.1.4
-[0.1.3]: https://github.com/melMass/comfy_mtb/compare/v0.1.2..v0.1.3
-[0.1.2]: https://github.com/melMass/comfy_mtb/compare/v0.1.1..v0.1.2
-[0.1.1]: https://github.com/melMass/comfy_mtb/compare/v0.1.0..v0.1.1
-[0.1.0]: https://github.com/melMass/comfy_mtb/compare/v0.0.1..v0.1.0
-

INSTALL.md

@@ -4,6 +4,7 @@
     - [ComfyUI Manager](#comfyui-manager)
     - [Virtual Env](#virtual-env)
   - [Models Download](#models-download)
+    - [Web Extensions](#web-extensions)
   - [Old installation method (MANUAL)](#old-installation-method-manual)
     - [Dependencies](#dependencies)
 
@@ -34,6 +35,11 @@ then follow the prompt or just press enter to download every models.
   python scripts/download_models.py -y
   ```
 
+### Web Extensions
+
+On first run the script [tries to symlink](https://github.com/melMass/comfy_mtb/blob/d982b69a58c05ccead9c49370764beaa4549992a/__init__.py#L45-L61) the [web extensions](https://github.com/melMass/comfy_mtb/tree/main/web) to your comfy `web/extensions` folder. In case it fails you can manually copy the mtb folder to `ComfyUI/web/extensions` it only provides a color widget for now shared by a few nodes:  
+
+<img alt="color widget preview" src="https://github.com/melMass/comfy_mtb/assets/7041726/cff7e66a-4cc4-4866-b35b-10af0bb2d110" width=450>
 
 ## Old installation method (MANUAL)
 ### Dependencies

README.md

@@ -1,7 +1,6 @@
 # MTB Nodes
-[![embedded test](https://github.com/melMass/comfy_mtb/actions/workflows/test_embedded.yml/badge.svg)](https://github.com/melMass/comfy_mtb/actions/workflows/test_embedded.yml)
 
-![home](https://repository-images.githubusercontent.com/649047066/a3eef9a7-20dd-4ef9-b839-884502d4e873)
+[![embedded test](https://github.com/melMass/comfy_mtb/actions/workflows/test_embedded.yml/badge.svg)](https://github.com/melMass/comfy_mtb/actions/workflows/test_embedded.yml)
 
 <!-- omit in toc -->
 
@@ -15,60 +14,24 @@
 
 [**Install Guide**](./INSTALL.md) | [**Examples**](https://github.com/melMass/comfy_mtb/wiki/Examples)
 
-There is now a dedicated `#mtb-nodes` channel on the Banodoco discord:  
-[![](https://dcbadge.vercel.app/api/server/AXhsabmDhn?style=flat)](https://discord.gg/IAXhsabmDhn)
-
----
-
 Welcome to the MTB Nodes project! This codebase is open for you to explore and utilize as you wish. Its primary purpose is to build proof-of-concepts (POCs) for implementation in [MLOPs](https://github.com/Bismuth-Consultancy-BV/MLOPs). Many nodes in this project are inspired by existing community contributions or built-in functionalities.
 
 Before proceeding, please be aware of the licenses associated with certain libraries used in this project. For example, the `deepbump` library is licensed under [GPLv3](https://github.com/HugoTini/DeepBump/blob/master/LICENSE).
 
-- [Web Extensions](#web-extensions)
 - [Node List](#node-list)
-  - [Animation](#animation)
   - [bbox](#bbox)
   - [colors](#colors)
+  - [face detection / swapping](#face-detection--swapping)
+  - [image interpolation (animation)](#image-interpolation-animation)
   - [image ops](#image-ops)
   - [latent utils](#latent-utils)
-  - [textures](#textures)
   - [misc utils](#misc-utils)
-  - [Optional nodes](#optional-nodes)
-    - [face detection / swapping](#face-detection--swapping)
-    - [image interpolation (animation)](#image-interpolation-animation)
+  - [textures](#textures)
 - [Comfy Resources](#comfy-resources)
 
-# Web Extensions
-mtb add a few widgets like `COLOR`
-
-<img alt="color widget preview" src="https://github.com/melMass/comfy_mtb/assets/7041726/cff7e66a-4cc4-4866-b35b-10af0bb2d110" width=450>
-
-A few nodes have the concept of "dynamic" inputs:  
-<img alt="dynamic inputs" width=450  src="https://github.com/melMass/comfy_mtb/assets/7041726/10b3976e-b212-4968-91eb-f34c02bb80c3" />
-
-<!-- NOTE: Here it should just be some examples and warnings, move the rest to the wiki -->
 
 # Node List
 
-## Animation
-- `Animation Builder`: Convenient way to manage basic animation maths at the core of many of my workflows (both worflows for the following GIFs are in the [examples](https://github.com/melMass/comfy_mtb/wiki/Examples))  
-
-  **[Example lerping two conditions (blue car -> yellow car)](https://github.com/melMass/comfy_mtb/blob/main/examples/03-animation_builder-condition-lerp.json)**
-  
-  <img width=300 src="https://user-images.githubusercontent.com/7041726/260258970-d6d66d96-fb34-40d0-9038-cbabf0714c5d.gif"/>  
-  
-
-  **[Example using image transforms a feedback for a fake deforum effect](https://github.com/melMass/comfy_mtb/blob/main/examples/04-animation_builder-deforum.json)**
-  
-  <img width=300 src="https://user-images.githubusercontent.com/7041726/260261504-303a1037-60d3-4b31-a589-b15d549752f6.gif"/>
-  
-- `Batch Float`: Generates a batch of float values with interpolation.
-- `Batch Shape`: Generates a batch of 2D shapes with optional shading (experimental).
-- `Batch Transform`: Transform a batch of images using a batch of keyframes.  
-  <img width=400 src="https://github.com/melMass/comfy_mtb/assets/7041726/3f217de1-79aa-49b0-a66a-35cf29dd8f01"/>
-- `Export With Ffmpeg`: Export with FFmpeg, it used to be export to Proress and is still tailored for YUV
-- `Fit Number` : Fit the input float using a source and target range, you can also control the interpolation curve from a list of presets (default to linear)
-  
 ## bbox
 - `Bounding Box`: BBox constructor (custom type),
 - `BBox From Mask`: From a mask extract the bounding box
@@ -80,7 +43,21 @@ A few nodes have the concept of "dynamic" inputs:
 - `RGB to HSV`: -,
 - `HSV to RGB`: -,
 - `Color Correct`: Basic color correction tools  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/7c20ac83-31ff-40ea-a1a0-06c2acefb2ef" width=400/>
+  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/7c20ac83-31ff-40ea-a1a0-06c2acefb2ef" width=345/>
+
+## face detection / swapping
+- `Face Swap`: Face swap using deepinsight/insightface models (this node used to be called `Roop` in early versions, it does the same, roop is *just* an app that uses those model)
+  > **Note**
+  > The face index allow you to choose which face to replace as you can see here:  
+  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/2e9d6066-c466-4a01-bd6c-315f7f1e8b42" width=320/>
+- `Load Face Swap Model`: Load an insightface model for face swapping
+- `Restore Face`: Using [GFPGan](https://github.com/TencentARC/GFPGAN) to restore faces, works great in conjunction with `Face Swap` and supports Comfy native upscalers for the `bg_upscaler`
+  
+## image interpolation (animation)
+- `Load Film Model`: Loads a [FILM](https://github.com/google-research/frame-interpolation) model
+- `Film Interpolation`: Process input frames using [FILM](https://github.com/google-research/frame-interpolation)  
+  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/3afd1647-6634-4b92-a34b-51432e6a9834" width=400/>
+- `Export to Prores (experimental)`: Exports the input frames to a ProRes 4444 mov file. This is using ffmpeg stdin to send raw numpy arrays, used with `Film Interpolation` and very simple for now but could be expanded upon.
 
 ## image ops
 - `Blur`: Blur an image using a Gaussian filter.
@@ -97,16 +74,8 @@ A few nodes have the concept of "dynamic" inputs:
 ## latent utils
 - `Latent Lerp`: Linear interpolation (blend) between two latent 
 
-## textures
-- `Model Patch Seamless`: Use the [seamless diffusion "hack"](https://gitlab.com/-/snippets/2395088) to patch any model to infere seamless images, check the [examples](https://github.com/melMass/comfy_mtb/wiki/Examples) to see how to use all those textures node together  
-  <img width=500 src="https://user-images.githubusercontent.com/7041726/272970506-9db516b5-45d2-4389-b904-b3a94660f24c.png"/>
-- `DeepBump`: Normal & height maps generation from single pictures  
-  <img width=500 src="https://user-images.githubusercontent.com/7041726/272970715-7e4477f6-8e18-4839-9864-83d07d6690a1.png"/>
-- `Image Tile Offset`: Mimics an old photoshop technique to check for seamless textures by offsetting tiles of the image.  
-  <img width=600 src="https://github.com/melMass/comfy_mtb/assets/7041726/cbcc51fb-922f-433f-acf1-c6c6c2a7ffc4" />
 
 ## misc utils
-- `Any To String`: Tries to take any input and convert it to a string.
 - `Concat Images`: Takes two image stream and merge them as a batch of images supported by other Comfy pipelines.
 - `Image Resize Factor`: **Deprecated**, I since discovered the builtin image resize.
 - `Text To Image`: Utils to convert text to image using a font
@@ -117,57 +86,13 @@ A few nodes have the concept of "dynamic" inputs:
 - `Save Tensors`: Debug node that will probably be removed in the future
 - `Int to Number`: Supplement for WASSuite number nodes
 - `Smart Step`: A very basic tool to control the steps (start/stop) of the `KAdvancedSampler` using percentage
-- `Load Image From Url`: Load an image from the given URL
 
+## textures
 
-## Optional nodes
-
-These nodes are still bundled in mtb, but moving forward (>0.2.0) they won't
-be setup by the install script and their dependencies won't install either.
-The reason is mostly that they all have a better alternatives available and tensorflow on windows was not a fun experience and since Python 3.11 not an experience at all.
-
-For linux and mac users though these nodes didn't cause any issue and I personally still use them, these are the extra requirements needed:
-
-```console
-.venv/python -m pip install tensorflow facexlib insightface basicsr
-```
-
-### face detection / swapping
-> **Warning**
-> Those nodes were among the first to be implemented they do work, but on windows the installation is still not properly handled for everyone  
-> As alternatives you can use [reactor](https://github.com/Gourieff/comfyui-reactor-node) for face swap and [facerestore](https://github.com/Haidra-Org/hordelib/tree/main/hordelib/nodes/facerestore) for restoration  
-> You can check [this video](https://www.youtube.com/watch?v=FShlpMxbU0E) for a tutorial by Ferniclestix using these alternatives  
-
-- `Face Swap`: Face swap using deepinsight/insightface models (this node used to be called `Roop` in early versions, it does the same, roop is *just* an app that uses those model)  
-  <img  width=320 src="https://user-images.githubusercontent.com/7041726/260261217-54e33446-183f-4dda-88b3-d38a1e6de980.gif"/>
-- `Load Face Swap Model`: Load an insightface model for face swapping
-- `Restore Face`: Using [GFPGan](https://github.com/TencentARC/GFPGAN) to restore faces, works great in conjunction with `Face Swap` and supports Comfy native upscalers for the `bg_upscaler`
-  
-### image interpolation (animation)
-> **Warning**
-> The FILM nodes will be deprecated at some point after 0.2.0, [Fannovel16](https://github.com/Fannovel16/ComfyUI-Frame-Interpolation)'s interpolation nodes implement it and they rely on a pytorch implementation of FILM
-> which solves the issues related to the ones included in mtb. They will probably remain available if your system meet the requirements and ignored otherwise.
-
-<details><summary>Why?</summary>
-  
-> **Windows only issue**: This requires tensorflow-gpu that is unfortunately not a thing anymore on Windows since 2.10.1 (unless you use a complex WSL passthrough setup but it's still not "Windows")  
-> Using this old version is quite clunky and require some patching that install.py does automatically, but the main issue is that no wheels are available for python > 3.10
-> Comfy-nightly is already using Python 11 so installing this old tf version won't work there.  
-> You can in any case install the normal up to date tensorflow but that will run on CPU and is much MUCH slower for FILM inference.
-</details>
-
-- `Load Film Model`: Loads a [FILM](https://github.com/google-research/frame-interpolation) model
-- `Film Interpolation`: Process input frames using [FILM](https://github.com/google-research/frame-interpolation)  
-  <img width=400 src="https://github.com/melMass/comfy_mtb/assets/7041726/3afd1647-6634-4b92-a34b-51432e6a9834"/>  
-  <img width=400 src="https://user-images.githubusercontent.com/7041726/260259079-c0f04a63-960c-43a7-ba78-a45cd5ac7514.gif"/>
-- `Export to Prores (experimental)`: Exports the input frames to a ProRes 4444 mov file. This is using ffmpeg stdin to send raw numpy arrays, used with `Film Interpolation` and very simple for now but could be expanded upon.
+- `DeepBump`: Normal & height maps generation from single pictures
 
 # Comfy Resources
 
-**Misc**
-
-- [Slick ComfyUI by NoCrypt](https://colab.research.google.com/drive/1ZMvLWEiYITmBJngtqeIQToeNuiydwI0z#scrollTo=1fWMaexXS188): A colab notebook with batteries included!
-
 **Guides**:
 - [Official Examples (eng)](https://comfyanonymous.github.io/ComfyUI_examples/)
 - [ComfyUI Community Manual (eng)](https://blenderneko.github.io/ComfyUI-docs/) by @BlenderNeko

__init__.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# -*- coding:utf-8 -*-
 ###
 # File: __init__.py
 # Project: comfy_mtb
@@ -6,47 +7,33 @@
 # Copyright (c) 2023 Mel Massadian
 #
 ###
-
-__version__ = "0.1.5"
-
 import os
 
-# TODO: don't override this if the user has that setup already
-if not os.environ.get("TF_FORCE_GPU_ALLOW_GROWTH"):
-    os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"
+# todo: don't override this if the user has that setup already
+os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"
+os.environ["TF_GPU_ALLOCATOR"] = "cuda_malloc_async"
 
-if not os.environ.get("TF_GPU_ALLOCATOR"):
-    os.environ["TF_GPU_ALLOCATOR"] = "cuda_malloc_async"
-
-import ast
-import contextlib
-import importlib
-import json
-import logging
-import shutil
 import traceback
-from importlib import reload
-from pathlib import Path
-
-from aiohttp import web
-from server import PromptServer
-
-import nodes
-
-from .endpoint import endlog
-from .log import blue_text, cyan_text, get_label, get_summary, log
-from .utils import comfy_dir, here
+from .log import log, blue_text, cyan_text, get_summary, get_label
+from .utils import here
+from .utils import comfy_dir
+import importlib
+import os
+import ast
+import json
 
 NODE_CLASS_MAPPINGS = {}
 NODE_DISPLAY_NAME_MAPPINGS = {}
 NODE_CLASS_MAPPINGS_DEBUG = {}
-WEB_DIRECTORY = "./web"
+
+__version__ = "0.1.4"
 
 
-def extract_nodes_from_source(filename: Path):
+def extract_nodes_from_source(filename):
     source_code = ""
 
-    source_code = filename.read_text(encoding="utf-8")
+    with open(filename, "r") as file:
+        source_code = file.read()
 
     nodes = []
 
@@ -71,7 +58,7 @@ def extract_nodes_from_source(filename: Path):
 
 
 def load_nodes():
-    errors: list[str] = []
+    errors = []
     nodes = []
     nodes_failed = []
 
@@ -83,16 +70,14 @@ def load_nodes():
                 module = importlib.import_module(
                     f".nodes.{module_name}", package=__package__
                 )
-                _nodes = getattr(module, "__nodes__", [])
+                _nodes = getattr(module, "__nodes__")
                 nodes.extend(_nodes)
                 log.debug(f"Imported {module_name} nodes")
 
             except AttributeError:
-                log.debug(f"Skipping wip module {module_name}")
                 pass  # wip nodes
             except Exception:
                 error_message = traceback.format_exc().splitlines()[-1]
-
                 errors.append(
                     f"Failed to import module {module_name} because {error_message}"
                 )
@@ -100,8 +85,8 @@ def load_nodes():
                 nodes_failed.extend(extract_nodes_from_source(filename))
 
     if errors:
-        log.debug(
-            "Some nodes failed to load:\n\t"
+        log.info(
+            f"Some nodes failed to load:\n\t"
             + "\n\t".join(errors)
             + "\n\n"
             + "Check that you properly installed the dependencies.\n"
@@ -112,82 +97,56 @@ def load_nodes():
 
 
 # - REGISTER WEB EXTENSIONS
-def uninstall_old_web_extensions():
-    web_extensions_root = comfy_dir / "web" / "extensions"
-    web_mtb = web_extensions_root / "mtb"
+web_extensions_root = comfy_dir / "web" / "extensions"
+web_mtb = web_extensions_root / "mtb"
 
-    if web_mtb.exists() and hasattr(nodes, "EXTENSION_WEB_DIRS"):
+if web_mtb.exists():
+    log.debug(f"Web extensions folder found at {web_mtb}")
+    if not os.path.islink(web_mtb.as_posix()):
+        log.warn(
+            f"Web extensions folder at {web_mtb} is not a symlink, if updating please delete it before"
+        )
+
+
+elif web_extensions_root.exists():
+    web_tgt = here / "web"
+    src = web_tgt.as_posix()
+    dst = web_mtb.as_posix()
+    try:
+        if os.name == "nt":
+            import _winapi
+
+            _winapi.CreateJunction(src, dst)
+        else:
+            os.symlink(web_tgt.as_posix(), web_mtb.as_posix())
+
+    except OSError:
+        log.warn(f"Failed to create symlink to {web_mtb}, trying to copy it")
         try:
-            if web_mtb.is_symlink():
-                web_mtb.unlink()
-            else:
-                shutil.rmtree(web_mtb)
+            import shutil
+
+            shutil.copytree(web_tgt, web_mtb)
+            log.info(f"Successfully copied {web_tgt} to {web_mtb}")
         except Exception as e:
-            log.warning(
-                f"Failed to remove web mtb directory: {e}\nPlease manually remove it from disk ({web_mtb}) and restart the server."
+            log.warn(
+                f"Failed to symlink and copy {web_tgt} to {web_mtb}. Please copy the folder manually."
             )
+            log.warn(e)
 
-
-# uninstall_old_web_extensions()
-
-
-# - GATHER WIKI PAGES
-def wiki_to_classname(s: str):
-    wiki_name = s.replace("nodes-", "", 1)
-    return "MTB_" + "".join(
-        [part.capitalize() for part in wiki_name.split("-")]
+    except Exception as e:
+        log.warn(
+            f"Failed to create symlink to {web_mtb}. Please copy the folder manually."
+        )
+        log.warn(e)
+else:
+    log.warn(
+        f"Comfy root probably not found automatically, please copy the folder {web_mtb} manually in the web/extensions folder of ComfyUI"
     )
 
-
-def classname_to_wiki(s: str):
-    classname = s.replace("MTB_", "")
-    parts = []
-    start = 0
-    for i in range(1, len(classname)):
-        if classname[i].isupper():
-            parts.append(classname[start:i].lower())
-            start = i
-    parts.append(classname[start:].lower())
-    return "nodes-" + "-".join(parts)
-
-
-wiki = here / "wiki"
-node_docs = {}
-if wiki.exists() and wiki.is_dir():
-    node_docs = {
-        wiki_to_classname(x.stem): x.read_text(encoding="utf-8")
-        for x in (wiki / "nodes").glob("*.md")
-    }
-
-
 # - REGISTER NODES
-
-
-MTB_EXPORT = os.environ.get("MTB_EXPORT")
-
 nodes, failed = load_nodes()
 for node_class in nodes:
-    class_name: str = node_class.__name__
-    linked_doc = node_docs.get(class_name)
-
-    if not hasattr(node_class, "DESCRIPTION"):
-        if linked_doc:
-            log.debug(f"Found linked doc for {class_name}, using it")
-            node_class.DESCRIPTION = linked_doc
-        elif node_class.__doc__:
-            log.debug(f"Using __doc__ as description for {class_name}")
-            node_class.DESCRIPTION = node_class.__doc__
-            if MTB_EXPORT:
-                wiki_name = classname_to_wiki(class_name)
-                (wiki / "nodes" / wiki_name + ".md").write_text(
-                    node_class.__doc__, encoding="utf-8"
-                )
-
-        else:
-            log.debug(
-                f"None of the methods could retrieve documentation for {class_name}"
-            )
-
+    class_name = node_class.__name__
     node_label = f"{get_label(class_name)} (mtb)"
     NODE_CLASS_MAPPINGS[node_label] = node_class
     NODE_DISPLAY_NAME_MAPPINGS[class_name] = node_label
@@ -207,70 +166,32 @@ for node_class in nodes:
                 )
             )
 
-log.debug(
-    "Loaded the following nodes:\n\t"
+log.info(
+    f"Loaded the following nodes:\n\t"
     + "\n\t".join(
         f"{cyan_text(k)}: {blue_text(get_summary(doc)) if doc else '-'}"
         for k, doc in NODE_CLASS_MAPPINGS_DEBUG.items()
     )
 )
 
-log.info(f"loaded {cyan_text(len(nodes))} nodes successfuly")
-if failed:
-    with contextlib.suppress(Exception):
-        base_url, port = utils.get_server_info()
-        log.info(
-            f"Some nodes ({len(failed)}) could not be loaded. This can be ignored, but go to http://{base_url}:{port}/mtb if you want more information."
-        )
-
-
 # - ENDPOINT
-
+from server import PromptServer
+from .log import log
+from aiohttp import web
+from importlib import reload
+import logging
+from .endpoint import endlog
 
 if hasattr(PromptServer, "instance"):
     restore_deps = ["basicsr"]
-    onnx_deps = ["onnxruntime"]
-    swap_deps = ["insightface"] + onnx_deps
+    swap_deps = ["insightface", "onnxruntime"]
+
     node_dependency_mapping = {
-        "QrCode": ["qrcode"],
-        "DeepBump": onnx_deps,
         "FaceSwap": swap_deps,
         "LoadFaceSwapModel": swap_deps,
         "LoadFaceAnalysisModel": restore_deps,
     }
 
-    PromptServer.instance.app.router.add_static(
-        "/mtb-assets/", path=(here / "html").as_posix()
-    )
-
-    # NOTE: we add an extra static path to avoid comfy mechanism
-    # that loads every script in web.
-    PromptServer.instance.app.add_routes(
-        [web.static("/mtb_async", (here / "web_async").as_posix())]
-    )
-
-    @PromptServer.instance.routes.get("/mtb/manage")
-    async def manage(request):
-        from . import endpoint
-
-        reload(endpoint)
-
-        endlog.debug("Initializing Manager")
-        if "text/html" in request.headers.get("Accept", ""):
-            csv_editor = endpoint.csv_editor()
-
-            tabview = endpoint.render_tab_view(Styles=csv_editor)
-            return web.Response(
-                text=endpoint.render_base_template("MTB", tabview),
-                content_type="text/html",
-            )
-
-        return web.json_response(
-            {
-                "message": "manage only has a POST api for now",
-            }
-        )
-
     @PromptServer.instance.routes.get("/mtb/status")
     async def get_full_library(request):
         from . import endpoint
@@ -334,10 +255,9 @@ if hasattr(PromptServer, "instance"):
             # # Return an HTML page
             html_response = """
             <div class="flex-container menu">
-                <a href="/mtb/manage">manage</a>
                 <a href="/mtb/debug">debug</a>
                 <a href="/mtb/status">status</a>
-            </div>
+            </div>            
             """
             return web.Response(
                 text=endpoint.render_base_template("MTB", html_response),

biome.json

@@ -1,22 +0,0 @@
-{
-    "$schema": "https://biomejs.dev/schemas/1.6.1/schema.json",
-    "organizeImports": {
-        "enabled": true
-    },
-    "linter": {
-        "enabled": true,
-        "rules": {
-            "recommended": true
-        }
-    },
-    "formatter": {
-        "lineEnding": "lf"
-    },
-    "javascript": {
-        "formatter": {
-            "quoteStyle": "single",
-            "semicolons": "asNeeded",
-            "indentWidth": 2
-        }
-    }
-}

cliff.toml

@@ -1,83 +0,0 @@
-[changelog]
-header = """
-# Changelog\n
-This is an automated changelog based on the commits in this repository.
-
-Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases) for more information.
-"""
-# https://keats.github.io/tera/docs/#introduction
-body = """
-{% if version -%}\
-    ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
-{% else %}\
-    ## [Unreleased]
-{% endif -%}\
-
-{% for group, commits in commits | group_by(attribute="group") %}
-    ### {{ group | upper_first }}
-    {% for commit in commits %}
-        - {% if commit.breaking %}[**breaking**] {% endif %}{{ commit.message | upper_first | trim }} ([{{ commit.id | truncate(length=7, end="") }}](<REPO>/commit/{{ commit.id }}))\
-            {% if commit.github.username and commit.github.username != remote.github.owner %} by [@{{ commit.github.username }}](https://github.com/{{ commit.github.username }}){%- endif -%}
-            {% if commit.github.pr_number %} in [#{{ commit.github.pr_number }}](<REPO>/pull/{{ commit.github.pr_number }}){%- endif -%}
-    {% endfor %}
-{% endfor %}
-
-{%- if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
-  ## New Contributors
-{%- endif -%}
-
-{% for contributor in github.contributors | filter(attribute="is_first_time", value=true) %}
-  * [@{{ contributor.username }}](https://github.com/{{ contributor.username }}) made their first contribution in [#{{ contributor.pr_number }}](<REPO>/pull/{{ contributor.pr_number }})\
-{%- endfor %}\n
-"""
-footer = """
-{% for release in releases -%}
-    {% if release.version -%}
-        {% if release.previous.version -%}
-            [{{ release.version | trim_start_matches(pat="v") }}]: \
-                <REPO>/compare/{{ release.previous.version }}..{{ release.version }}
-        {% endif -%}
-    {% else -%}
-        [unreleased]: <REPO>/compare/{{ release.previous.version }}..HEAD
-    {% endif -%}
-{% endfor %}
-"""
-trim = true
-postprocessors = [
-  { pattern = '<REPO>', replace = "https://github.com/melMass/comfy_mtb" }, # replace repository URL
-]
-
-[git]
-# https://www.conventionalcommits.org
-conventional_commits = true
-filter_unconventional = true
-split_commits = false
-commit_preprocessors = [
-  # { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](<REPO>/issues/${2}))" }, # replace issue numbers
-  { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "" },
-]
-commit_parsers = [
-  { message = "^feat", group = "Features" },
-  { message = "^fix", group = "Bug Fixes" },
-  { message = "^doc", group = "Documentation" },
-  { message = "^perf", group = "Performance" },
-  { message = "^refactor", group = "Refactor" },
-  { message = "^style", group = "Styling" },
-  { message = "^test", group = "Testing" },
-  { message = "^chore\\(release\\): prepare for", skip = true },
-  { message = "^chore\\(deps\\)", skip = true },
-  { message = "^chore\\(pr\\)", skip = true },
-  { message = "^chore\\(pull\\)", skip = true },
-  { message = "^chore|ci", group = "Miscellaneous Tasks" },
-  { body = ".*security", group = "Security" },
-  { message = "^revert", group = "Revert" },
-]
-protect_breaking_commits = false
-filter_commits = false
-tag_pattern = "v[0-9].*"
-topo_order = false
-sort_commits = "newest"
-
-[remote.github]
-owner = "melMass"
-repo = "comfy_mtb"

endpoint.py

@@ -1,59 +1,40 @@
-import csv
-
+from .utils import here, run_command, comfy_mode
 from aiohttp import web
-
 from .log import mklog
-from .utils import (
-    backup_file,
-    import_install,
-    reqs_map,
-    run_command,
-    styles_dir,
-)
+import sys
 
 endlog = mklog("mtb endpoint")
 
 # - ACTIONS
-import sys
-from pathlib import Path
+import requirements
 
-import_install("requirements")
 
 
 def ACTIONS_installDependency(dependency_names=None):
     if dependency_names is None:
         return {"error": "No dependency name provided"}
     endlog.debug(f"Received Install Dependency request for {dependency_names}")
-    # reqs = []
-    resolved_names = [reqs_map.get(name, name) for name in dependency_names]
-    try:
-        run_command(
-            [Path(sys.executable), "-m", "pip", "install"] + resolved_names
-        )
-        return {"success": True}
-
-    except Exception as e:
-        return {"error": f"Failed to install dependencies: {e}"}
-
-    # if platform.system() == "Windows":
-    #     reqs = list(requirements.parse((here / "reqs_windows.txt").read_text()))
-    # else:
-    #     reqs = list(requirements.parse((here / "reqs.txt").read_text()))
-    # print([x.specs for x in reqs])
-    # print(
-    #     "\n".join([f"{x.line} {''.join(x.specs[0] if x.specs else '')}" for x in reqs])
-    # )
-    # for dependency_name in dependency_names:
-    #     for req in reqs:
-    #         if req.name == dependency_name:
-    #             endlog.debug(f"Dependency {dependency_name} installed")
-    #             break
+    reqs = []
+    if comfy_mode == "embeded":
+        reqs = list(requirements.parse((here / "reqs_portable.txt").read_text()))
+    else:
+        reqs = list(requirements.parse((here / "reqs.txt").read_text()))
+    print([x.specs for x in reqs])
+    print(
+        "\n".join([f"{x.line} {''.join(x.specs[0] if x.specs else '')}" for x in reqs])
+    )
+    for dependency_name in dependency_names:
+        for req in reqs:
+            if req.name == dependency_name:
+                endlog.debug(f"Dependency {dependency_name} installed")
+                break
+    return {"success": True}
 
 
 def ACTIONS_getStyles(style_name=None):
-    from .nodes.conditions import MTB_StylesLoader
+    from .nodes.conditions import StylesLoader
 
-    styles = MTB_StylesLoader.options
+    styles = StylesLoader.options
     match_list = ["name"]
     if styles:
         filtered_styles = {
@@ -62,41 +43,11 @@ def ACTIONS_getStyles(style_name=None):
             if not key.startswith("__") and key not in match_list
         }
         if style_name:
-            return filtered_styles.get(
-                style_name, {"error": "Style not found"}
-            )
+            return filtered_styles.get(style_name, {"error": "Style not found"})
         return filtered_styles
     return {"error": "No styles found"}
 
 
-def ACTIONS_saveStyle(data):
-    # endlog.debug(f"Received Save Styles for {data.keys()}")
-    # endlog.debug(data)
-
-    styles = [f.name for f in styles_dir.iterdir() if f.suffix == ".csv"]
-    target = None
-    rows = []
-    for fp, content in data.items():
-        if fp in styles:
-            endlog.debug(f"Overwriting {fp}")
-            target = styles_dir / fp
-            rows = content
-            break
-
-    if not target:
-        endlog.warning(
-            f"Could not determine the target file for {data.keys()}"
-        )
-        return {"error": "Could not determine the target file for the style"}
-
-    backup_file(target)
-
-    with target.open("w", newline="", encoding="utf-8") as file:
-        csv_writer = csv.writer(file, quoting=csv.QUOTE_ALL)
-        for row in rows:
-            csv_writer.writerow(row)
-
-
 async def do_action(request) -> web.Response:
     endlog.debug("Init action request")
     request_data = await request.json()
@@ -114,16 +65,11 @@ async def do_action(request) -> web.Response:
         return web.json_response({"result": result})
 
     available_methods = [
-        attr[len("ACTIONS_") :]
-        for attr in globals()
-        if attr.startswith("ACTIONS_")
+        attr[len("ACTIONS_") :] for attr in globals() if attr.startswith("ACTIONS_")
     ]
 
     return web.json_response(
-        {
-            "error": "Invalid method name.",
-            "available_methods": available_methods,
-        }
+        {"error": "Invalid method name.", "available_methods": available_methods}
     )
 
 
@@ -137,131 +83,6 @@ def dependencies_button(name, dependencies):
         """
 
 
-def csv_editor():
-    inputs = [f for f in styles_dir.iterdir() if f.suffix == ".csv"]
-    # rows = {f.stem: list(csv.reader(f.read_text("utf8"))) for f in styles}
-
-    style_files = {}
-    for file in inputs:
-        with open(file, encoding="utf8") as f:
-            parsed = csv.reader(f)
-            style_files[file.name] = []
-            for row in parsed:
-                endlog.debug(f"Adding style {row[0]}")
-                style_files[file.name].append((row[0], row[1], row[2]))
-
-    html_out = """
-            <div id="style-editor">
-             <h1>Style Editor</h1>
-            
-            """
-    for current, styles in style_files.items():
-        current_out = f"<h3>{current}</h3>"
-        table_rows = []
-        for index, style in enumerate(styles):
-            table_rows += (
-                (["<tr>"] + [f"<th>{cell}</th>" for cell in style] + ["</tr>"])
-                if index == 0
-                else (
-                    ["<tr>"]
-                    + [
-                        f"<td><input type='text' value='{cell}'></td>"
-                        if i == 0
-                        else f"<td><textarea name='Text1' cols='40' rows='5'>{cell}</textarea></td>"
-                        for i, cell in enumerate(style)
-                    ]
-                    + ["</tr>"]
-                )
-            )
-        current_out += (
-            f"<table data-id='{current}' data-filename='{current}'>"
-            + "".join(table_rows)
-            + "</table>"
-        )
-        current_out += f"<button data-id='{current}' onclick='saveTableData(this.getAttribute(\"data-id\"))'>Save {current}</button>"
-
-        html_out += add_foldable_region(current, current_out)
-
-    html_out += "</div>"
-    html_out += """<script src='/mtb-assets/js/saveTableData.js'></script>"""
-
-    return html_out
-
-
-def render_tab_view(**kwargs):
-    tab_headers = []
-    tab_contents = []
-
-    for idx, (tab_name, content) in enumerate(kwargs.items()):
-        active_class = "active" if idx == 0 else ""
-        tab_headers.append(
-            f"<button class='tablinks {active_class}' onclick=\"openTab(event, '{tab_name}')\">{tab_name}</button>"
-        )
-        tab_contents.append(
-            f"<div id='{tab_name}' class='tabcontent {active_class}'>{content}</div>"
-        )
-
-    headers_str = "\n".join(tab_headers)
-    contents_str = "\n".join(tab_contents)
-
-    return f"""
-<div class='tab-container'>
-    <div class='tab'>
-        {headers_str}
-    </div>
-    {contents_str}
-    </div>
-    <script src='/mtb-assets/js/tabSwitch.js'></script>
-    """
-
-
-def add_foldable_region(title, content):
-    symbol_id = f"{title}-symbol"
-    return f"""
-    <div class='foldable'>
-        <div class='foldable-title' onclick="toggleFoldable('{title}', '{symbol_id}')">
-            <span id='{symbol_id}' class='foldable-symbol'>&#9655;</span>
-            {title}
-        </div>
-        <div id='{title}' class='foldable-content'>
-            {content}
-        </div>
-    </div>
-    <script src='/mtb-assets/js/foldable.js'></script>
-    """
-
-
-def add_split_pane(left_content, right_content, vertical=True):
-    orientation = "vertical" if vertical else "horizontal"
-    return f"""
-    <div class="split-pane {orientation}">
-        <div id="leftPane">
-            {left_content}
-        </div>
-        <div id="resizer"></div>
-        <div id="rightPane">
-            {right_content}
-        </div>
-    </div>
-    <script>
-        initSplitPane({str(vertical).lower()});
-    </script>
-    <script src='/mtb-assets/js/splitPane.js'></script>
-    """
-
-
-def add_dropdown(title, options):
-    option_str = "\n".join(
-        [f"<option value='{opt}'>{opt}</option>" for opt in options]
-    )
-    return f"""
-    <select>
-        <option disabled selected>{title}</option>
-        {option_str}
-    </select>
-    """
-
-
 def render_table(table_dict, sort=True, title=None):
     table_dict = sorted(
         table_dict.items(), key=lambda item: item[0]
@@ -272,15 +93,11 @@ def render_table(table_dict, sort=True, title=None):
         if isinstance(item, dict):
             if "dependencies" in item:
                 table_rows += f"<tr><td>{name}</td><td>"
-                table_rows += (
-                    f"{dependencies_button(name,item['dependencies'])}"
-                )
+                table_rows += f"{dependencies_button(name,item['dependencies'])}"
 
                 table_rows += "</td></tr>"
             else:
-                table_rows += (
-                    f"<tr><td>{name}</td><td>{render_table(item)}</td></tr>"
-                )
+                table_rows += f"<tr><td>{name}</td><td>{render_table(item)}</td></tr>"
         # elif isinstance(item, str):
         #     table_rows += f"<tr><td>{name}</td><td>{item}</td></tr>"
         else:
@@ -305,13 +122,21 @@ def render_table(table_dict, sort=True, title=None):
 
 
 def render_base_template(title, content):
+    css_content = ""
+    css_path = here / "html" / "style.css"
+    if css_path:
+        with open(css_path, "r") as css_file:
+            css_content = css_file.read()
+
     github_icon_svg = """<svg xmlns="http://www.w3.org/2000/svg" fill="whitesmoke" height="3em" viewBox="0 0 496 512"><path d="M165.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3.3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6zm-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5.3-6.2 2.3zm44.2-1.7c-2.9.7-4.9 2.6-4.6 4.9.3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9zM244.8 8C106.1 8 0 113.3 0 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.2 352.9c-1.3 1-1 3.3.7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1zm-10.8-8.1c-.7 1.3.3 2.9 2.3 3.9 1.6 1 3.6.7 4.3-.7.7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3.7zm32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3.7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/></svg>"""
     return f"""
     <!DOCTYPE html>
     <html>
     <head>
         <title>{title}</title>
-        <link rel="stylesheet" href="/mtb-assets/style.css"/>
+        <style>
+            {css_content}
+        </style>
     </head>
     <script type="module">
         import {{ api }} from '/scripts/api.js'

env.nu

@@ -1,147 +0,0 @@
-# NOTE: This file is only use for development you can ignore it
-
-use path.nu *
-
-def get_root [--clean] {
-    if $clean {
-        $env.COMFY_CLEAN_ROOT 
-    } else {
-        $env.COMFY_ROOT
-    }
-}
-
-export def "comfy build-web" [] {
-    cd $env.COMFY_MTB
-    cd web_source
-    npm run build
-    cp dist/*.js ../web/dist
-}
-
-export def "comfy dev-web" [] {
-    cd $env.COMFY_MTB
-    cd web_source
-    npm run dev
-}
-
-
-# start the comfy server
-export def "comfy start" [--clean, --listen] {
-    let root = get_root --clean=($clean)
-    cd $root
-    MTB_DEBUG=true python main.py --port 3000 --preview-method auto ...(if $listen {["--listen"]} else {[]})
-}
-
-# update comfy itself and merge master in current branch
-export def "comfy update" [
-    --clean # ??
-    --rebase # Rebase instead of merge
-] {
-    let root = get_root --clean=($clean)
-    let models = $"($root)/models"
-    cd $root
-    let branch_name = (git rev-parse --abbrev-ref HEAD | str trim)
-    print $"(ansi yellow_italic)Backing up and removing models symlinks(ansi reset)"
-
-    cd $models
-
-    # find all symlinks
-    let links = (ls -la | 
-        where not ($it.target | is-empty) | 
-        select name target | 
-        sort-by name)
-		
-
-	if not ($links | is-empty) {
-          $links | save -f links.nuon
-          # remove them
-          open links.nuon | each {|p| rm $p.name }
-	}
-
-    cd $root
-
-    print $"(ansi yellow_italic)Checking out to master(ansi reset)"
-    git checkout master
-
-    print $"(ansi yellow_italic)Fetching and pulling remote updates(ansi reset)"
-    git fetch
-    git pull
-
-    print $"(ansi yellow_italic)Back to our branch \(($branch_name)\)(ansi reset)"
-    git checkout -
-
-    if $rebase {
-        print $"(ansi yellow_italic)Rebasing changes(ansi reset)"
-        git rebase master
-
-    } else {
-        print $"(ansi yellow_italic)Merging changes(ansi reset)"
-        git merge master
-    }
-
-    print $"(ansi yellow_italic)Linking back the models(ansi reset)"
-    
-    cd $models
-    # resymlink them
-    open links.nuon | each {|p| link -a $p.target $p.name }
-
-    let commit_count = (git rev-list --count $branch_name $"^origin/($branch_name)")
-
-
-    print $"(ansi green_bold)Update successful \(($commit_count) new commits\)(ansi reset)"
-
-
-}
-
-export def "comfy toggle_extensions" [--clean] {
-    let root = get_root --clean=($clean)
-    cd $root
-    cd custom_nodes
-    let exts = (ls | where type in ["dir","symlink"] | get name)
-    let choices = ($exts | input list -m "choose extension to toggle") 
-    if ($choices | is-empty) {
-        return
-    }
-
-    print $choices
-
-    let filtered = $choices | wrap name | upsert enabled {|p| not ($p.name | str ends-with ".disabled")}
-            
-    print $filtered 
-    $filtered | each {|f|
-        let new_name = ($f.name | str replace ".disabled" "")
-       
-        let new_name = if $f.enabled {
-            $"($new_name).disabled"
-        } else {
-            $new_name
-        }
-        print $"Moving ($f.name) to ($new_name)"
-        mv $f.name $new_name
-    }
-}
-
-# git pull all extensions
-export def "comfy update_extensions" [--clean] {
-    let root = get_root --clean=($clean)
-    cd $root
-    cd custom_nodes
-    git multipull .
-}
-
-
-
-export-env {
-  $env.COMFY_MTB = ("." | path expand)
-  $env.CUDA_ROOT =  'C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\'
-
-  $env.CUDA_HOME = $env.CUDA_ROOT
-
-  $env.COMFY_ROOT = ("../.." | path expand)
-  $env.COMFY_CLEAN_ROOT =  ($env.COMFY_ROOT | path dirname | path join ComfyClean)
-
-  path-add 'C:/Portable/TensorRT-8.6.0.12/lib'
-  path-add ($env.CUDA_ROOT | path join bin)
-  overlay use ../../.venv/Scripts/activate.nu 
-}
-
-

errors.py

@@ -1,7 +0,0 @@
-class ModelNotFound(Exception):
-    def __init__(self, model_name, *args, **kwargs):
-        super().__init__(
-            f"The model {model_name} could not be found, make sure to download it using ComfyManager first.\nrepository: https://github.com/ltdrdata/ComfyUI-Manager",
-            *args,
-            **kwargs,
-        )

examples/05-seamless_texture.json

@@ -1,905 +0,0 @@
-{
-  "last_node_id": 97,
-  "last_link_id": 179,
-  "nodes": [
-    {
-      "id": 6,
-      "type": "CLIPTextEncode",
-      "pos": [
-        -1165.8749246009997,
-        30
-      ],
-      "size": [
-        422.84503173828125,
-        164.31304931640625
-      ],
-      "flags": {},
-      "order": 4,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "clip",
-          "type": "CLIP",
-          "link": 3
-        }
-      ],
-      "outputs": [
-        {
-          "name": "CONDITIONING",
-          "type": "CONDITIONING",
-          "links": [
-            4,
-            158
-          ],
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "CLIPTextEncode"
-      },
-      "widgets_values": [
-        "Closeup texture of rocks"
-      ],
-      "color": "#432",
-      "bgcolor": "#653",
-      "shape": 1
-    },
-    {
-      "id": 7,
-      "type": "CLIPTextEncode",
-      "pos": [
-        -1175.8749246009997,
-        250
-      ],
-      "size": [
-        425.27801513671875,
-        180.6060791015625
-      ],
-      "flags": {},
-      "order": 5,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "clip",
-          "type": "CLIP",
-          "link": 5
-        }
-      ],
-      "outputs": [
-        {
-          "name": "CONDITIONING",
-          "type": "CONDITIONING",
-          "links": [
-            6
-          ],
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "CLIPTextEncode"
-      },
-      "widgets_values": [
-        "((drawing, cartoon, painting, sketch, blur, depth of field, dof))"
-      ],
-      "color": "#432",
-      "bgcolor": "#653",
-      "shape": 1
-    },
-    {
-      "id": 89,
-      "type": "Reroute",
-      "pos": [
-        350,
-        803
-      ],
-      "size": [
-        75,
-        26
-      ],
-      "flags": {},
-      "order": 9,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "",
-          "type": "*",
-          "link": 176
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "IMAGE",
-          "links": [
-            167
-          ]
-        }
-      ],
-      "properties": {
-        "showOutputText": false,
-        "horizontal": false
-      }
-    },
-    {
-      "id": 4,
-      "type": "CheckpointLoaderSimple",
-      "pos": [
-        -1740,
-        236
-      ],
-      "size": [
-        315,
-        98
-      ],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "outputs": [
-        {
-          "name": "MODEL",
-          "type": "MODEL",
-          "links": [
-            170
-          ],
-          "slot_index": 0
-        },
-        {
-          "name": "CLIP",
-          "type": "CLIP",
-          "links": [
-            3,
-            5
-          ],
-          "slot_index": 1
-        },
-        {
-          "name": "VAE",
-          "type": "VAE",
-          "links": [],
-          "slot_index": 2
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "CheckpointLoaderSimple"
-      },
-      "widgets_values": [
-        "revAnimated_v122.safetensors"
-      ],
-      "shape": 1
-    },
-    {
-      "id": 63,
-      "type": "SaveImage",
-      "pos": [
-        1315,
-        18
-      ],
-      "size": [
-        539.2050170898438,
-        617.2159423828125
-      ],
-      "flags": {},
-      "order": 13,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 115
-        }
-      ],
-      "title": "Normal",
-      "properties": {},
-      "widgets_values": [
-        "Normal"
-      ],
-      "shape": 1
-    },
-    {
-      "id": 67,
-      "type": "SaveImage",
-      "pos": [
-        2095,
-        22
-      ],
-      "size": [
-        539.2050170898438,
-        617.2159423828125
-      ],
-      "flags": {},
-      "order": 16,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 119
-        }
-      ],
-      "title": "Curvature",
-      "properties": {},
-      "widgets_values": [
-        "Curvature"
-      ],
-      "shape": 1
-    },
-    {
-      "id": 69,
-      "type": "SaveImage",
-      "pos": [
-        1560,
-        1290
-      ],
-      "size": [
-        539.2050170898438,
-        617.2159423828125
-      ],
-      "flags": {},
-      "order": 17,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 121
-        }
-      ],
-      "title": "Depth",
-      "properties": {},
-      "widgets_values": [
-        "Height"
-      ],
-      "shape": 1
-    },
-    {
-      "id": 91,
-      "type": "Model Patch Seamless (mtb)",
-      "pos": [
-        -1150,
-        -146
-      ],
-      "size": [
-        430.8000183105469,
-        78
-      ],
-      "flags": {},
-      "order": 3,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "model",
-          "type": "MODEL",
-          "link": 170
-        }
-      ],
-      "outputs": [
-        {
-          "name": "Original Model (passthrough)",
-          "type": "MODEL",
-          "links": null,
-          "shape": 3
-        },
-        {
-          "name": "Patched Model",
-          "type": "MODEL",
-          "links": [
-            169
-          ],
-          "shape": 3,
-          "slot_index": 1
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "Model Patch Seamless (mtb)"
-      },
-      "widgets_values": [
-        true
-      ],
-      "color": "#232",
-      "bgcolor": "#353"
-    },
-    {
-      "id": 93,
-      "type": "PreviewImage",
-      "pos": [
-        1115,
-        -597
-      ],
-      "size": [
-        451.3526306152344,
-        478.3444519042969
-      ],
-      "flags": {},
-      "order": 12,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 179
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "PreviewImage"
-      }
-    },
-    {
-      "id": 43,
-      "type": "VAELoader",
-      "pos": [
-        -598.2757622278747,
-        577.3595309932109
-      ],
-      "size": [
-        387.48089599609375,
-        70.60645294189453
-      ],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "outputs": [
-        {
-          "name": "VAE",
-          "type": "VAE",
-          "links": [
-            174
-          ],
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "VAELoader"
-      },
-      "widgets_values": [
-        "vae-ft-mse-840000-ema-pruned.safetensors"
-      ],
-      "shape": 1
-    },
-    {
-      "id": 97,
-      "type": "Image Tile Offset (mtb)",
-      "pos": [
-        617,
-        -598
-      ],
-      "size": [
-        315,
-        58
-      ],
-      "flags": {},
-      "order": 10,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": 178
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            179
-          ],
-          "shape": 3,
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "Image Tile Offset (mtb)"
-      },
-      "widgets_values": [
-        2
-      ],
-      "color": "#232",
-      "bgcolor": "#353"
-    },
-    {
-      "id": 96,
-      "type": "Vae Decode (mtb)",
-      "pos": [
-        -52,
-        40
-      ],
-      "size": [
-        315,
-        126
-      ],
-      "flags": {},
-      "order": 7,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "samples",
-          "type": "LATENT",
-          "link": 173
-        },
-        {
-          "name": "vae",
-          "type": "VAE",
-          "link": 174
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            175,
-            176,
-            178
-          ],
-          "shape": 3,
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "Vae Decode (mtb)"
-      },
-      "widgets_values": [
-        true,
-        false,
-        512
-      ],
-      "color": "#232",
-      "bgcolor": "#353"
-    },
-    {
-      "id": 46,
-      "type": "SaveImage",
-      "pos": [
-        533,
-        25
-      ],
-      "size": [
-        539.2050170898438,
-        617.2159423828125
-      ],
-      "flags": {},
-      "order": 8,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 175
-        }
-      ],
-      "title": "Albedo",
-      "properties": {},
-      "widgets_values": [
-        "Albedo"
-      ],
-      "shape": 1
-    },
-    {
-      "id": 74,
-      "type": "EmptyLatentImage",
-      "pos": [
-        -1075.8749246009997,
-        480
-      ],
-      "size": [
-        315,
-        106
-      ],
-      "flags": {},
-      "order": 2,
-      "mode": 0,
-      "outputs": [
-        {
-          "name": "LATENT",
-          "type": "LATENT",
-          "links": [
-            132
-          ],
-          "shape": 3,
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "EmptyLatentImage"
-      },
-      "widgets_values": [
-        768,
-        768,
-        1
-      ],
-      "color": "#323",
-      "bgcolor": "#535",
-      "shape": 1
-    },
-    {
-      "id": 62,
-      "type": "Deep Bump (mtb)",
-      "pos": [
-        727,
-        801
-      ],
-      "size": [
-        315,
-        130
-      ],
-      "flags": {},
-      "order": 11,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": 167
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            115,
-            118,
-            122
-          ],
-          "shape": 3,
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "Deep Bump (mtb)"
-      },
-      "widgets_values": [
-        "Color to Normals",
-        "SMALL",
-        "SMALLEST",
-        true
-      ],
-      "color": "#232",
-      "bgcolor": "#353",
-      "shape": 1
-    },
-    {
-      "id": 66,
-      "type": "Deep Bump (mtb)",
-      "pos": [
-        1626,
-        808
-      ],
-      "size": [
-        315,
-        130
-      ],
-      "flags": {},
-      "order": 14,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": 118
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            119
-          ],
-          "shape": 3,
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "Deep Bump (mtb)"
-      },
-      "widgets_values": [
-        "Normals to Curvature",
-        "SMALL",
-        "SMALLEST",
-        true
-      ],
-      "color": "#232",
-      "bgcolor": "#353",
-      "shape": 1
-    },
-    {
-      "id": 68,
-      "type": "Deep Bump (mtb)",
-      "pos": [
-        1185,
-        1288
-      ],
-      "size": [
-        315,
-        130
-      ],
-      "flags": {},
-      "order": 15,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": 122
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            121
-          ],
-          "shape": 3,
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "Deep Bump (mtb)"
-      },
-      "widgets_values": [
-        "Normals to Height",
-        "SMALL",
-        "SMALLEST",
-        true
-      ],
-      "color": "#232",
-      "bgcolor": "#353",
-      "shape": 1
-    },
-    {
-      "id": 3,
-      "type": "KSampler",
-      "pos": [
-        -518.2757622278748,
-        47.359530993211024
-      ],
-      "size": [
-        315,
-        474
-      ],
-      "flags": {},
-      "order": 6,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "model",
-          "type": "MODEL",
-          "link": 169
-        },
-        {
-          "name": "positive",
-          "type": "CONDITIONING",
-          "link": 4
-        },
-        {
-          "name": "negative",
-          "type": "CONDITIONING",
-          "link": 6
-        },
-        {
-          "name": "latent_image",
-          "type": "LATENT",
-          "link": 132
-        }
-      ],
-      "outputs": [
-        {
-          "name": "LATENT",
-          "type": "LATENT",
-          "links": [
-            173
-          ],
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "KSampler"
-      },
-      "widgets_values": [
-        1001,
-        "fixed",
-        28,
-        8,
-        "dpmpp_2m",
-        "normal",
-        1
-      ],
-      "color": "#222",
-      "bgcolor": "#000",
-      "shape": 1
-    }
-  ],
-  "links": [
-    [
-      3,
-      4,
-      1,
-      6,
-      0,
-      "CLIP"
-    ],
-    [
-      4,
-      6,
-      0,
-      3,
-      1,
-      "CONDITIONING"
-    ],
-    [
-      5,
-      4,
-      1,
-      7,
-      0,
-      "CLIP"
-    ],
-    [
-      6,
-      7,
-      0,
-      3,
-      2,
-      "CONDITIONING"
-    ],
-    [
-      115,
-      62,
-      0,
-      63,
-      0,
-      "IMAGE"
-    ],
-    [
-      118,
-      62,
-      0,
-      66,
-      0,
-      "IMAGE"
-    ],
-    [
-      119,
-      66,
-      0,
-      67,
-      0,
-      "IMAGE"
-    ],
-    [
-      121,
-      68,
-      0,
-      69,
-      0,
-      "IMAGE"
-    ],
-    [
-      122,
-      62,
-      0,
-      68,
-      0,
-      "IMAGE"
-    ],
-    [
-      132,
-      74,
-      0,
-      3,
-      3,
-      "LATENT"
-    ],
-    [
-      158,
-      6,
-      0,
-      86,
-      0,
-      "*"
-    ],
-    [
-      167,
-      89,
-      0,
-      62,
-      0,
-      "IMAGE"
-    ],
-    [
-      169,
-      91,
-      1,
-      3,
-      0,
-      "MODEL"
-    ],
-    [
-      170,
-      4,
-      0,
-      91,
-      0,
-      "MODEL"
-    ],
-    [
-      173,
-      3,
-      0,
-      96,
-      0,
-      "LATENT"
-    ],
-    [
-      174,
-      43,
-      0,
-      96,
-      1,
-      "VAE"
-    ],
-    [
-      175,
-      96,
-      0,
-      46,
-      0,
-      "IMAGE"
-    ],
-    [
-      176,
-      96,
-      0,
-      89,
-      0,
-      "*"
-    ],
-    [
-      178,
-      96,
-      0,
-      97,
-      0,
-      "IMAGE"
-    ],
-    [
-      179,
-      97,
-      0,
-      93,
-      0,
-      "IMAGE"
-    ]
-  ],
-  "groups": [
-    {
-      "title": "Seamless Diffusion",
-      "bounding": [
-        -1752,
-        -392,
-        1658,
-        1102
-      ],
-      "color": "#3f789e",
-      "font_size": 76,
-      "locked": false
-    },
-    {
-      "title": "Seamless Check",
-      "bounding": [
-        421,
-        -795,
-        1374,
-        763
-      ],
-      "color": "#3f789e",
-      "font_size": 76,
-      "locked": false
-    }
-  ],
-  "config": {},
-  "extra": {},
-  "version": 0.4
-}

examples/08-note-plus.json

@@ -1 +0,0 @@
-{"last_node_id":9,"last_link_id":0,"nodes":[{"id":9,"type":"Note Plus (mtb)","pos":[332, 139, 0, 0, 0, 0, 0, 0, 0, 0],"size":[573.4446126650389, 1292.5298919072263],"flags":{},"order":0,"mode":0,"inputs":[],"outputs":[],"title":"Note+ (mtb)","properties":{},"widgets_values":["# Note+ Demo\n\n# Images \nyou can resize them (see showdown syntax)\n\n![Minion](https://octodex.github.com/images/minion.png =120x*)\n\n# iFrame (embeds)\n<iframe src=\"https://www.youtube.com/embed/tgbNymZ7vqY\">\n</iframe>\n\n# Headings\n\n# h1 Heading:smile:\n\n## h2 Heading\n\n### h3 Heading\n\n#### h4 Heading\n\n##### h5 Heading\n\n###### h6 Heading\n\n# Tables\n\nColons can be used to align columns.\n\n| Tables|Are|Cool |\n| ------------- |:-----------:| ----:|\n| col 3 is| right-aligned | $1600 |\n| col 2 is| centered| $12 |\n| zebra stripes | are neat|$1 |\n\nEmphasis, aka italics, with _asterisks_ or _underscores_.\n\nStrong emphasis, aka bold, with **asterisks** or **underscores**.\n\nCombined emphasis with **asterisks and _underscores_**.\n\nStrikethrough uses two tildes. ~~Scratch this.~~\n\n**This is bold text**\n\n**This is bold text**\n\n_This is italic text_\n\n_This is italic text_\n\n~~Strikethrough~~\n\n1. First ordered list item\n2. Another item\n\n- Unordered sub-list.\n\n1. Actual numbers don't matter, just that it's a number\n1. Ordered sub-list\n1. And another item.\n1.\n\n- [x] Finish my changes\n- [] Push my commits to GitHub\n- [] Open a pull request\n- [x] mentions:@melmass, #refs, [links](), **formatting**, and <del>tags</del> supported\n- [x] list syntax required (any unordered or ordered list supported)\n- [x] this is a complete item\n- [] this is an incomplete item\n","markdown","*{\ncolor:whitesmoke;\n}\n\nh1{\ncolor:cyan;\n}\nh2{\ncolor:yellow;\n}\nh3{\ncolor:pink;\n}\n\nstrong{\ncolor:red;\n}"],"color":"#223","bgcolor":"#335","shape":1}],"links":[],"groups":[],"config":{},"extra":{},"version":0.4}

html/js/foldable.js

@@ -1,20 +0,0 @@
-/**
- * File: foldable.js
- * Project: comfy_mtb
- * Author: Mel Massadian
- *
- * Copyright (c) 2023 Mel Massadian
- *
- */
-
-function toggleFoldable(elementId, symbolId) {
-  const content = document.getElementById(elementId)
-  const symbol = document.getElementById(symbolId)
-  if (content.style.display === 'none' || content.style.display === '') {
-    content.style.display = 'flex'
-    symbol.innerHTML = '▽' // Down arrow
-  } else {
-    content.style.display = 'none'
-    symbol.innerHTML = '▷' // Right arrow
-  }
-}

html/js/saveTableData.js

@@ -1,54 +0,0 @@
-/**
- * File: saveTableData.js
- * Project: comfy_mtb
- * Author: Mel Massadian
- *
- * Copyright (c) 2023 Mel Massadian
- *
- */
-
-function saveTableData(identifier) {
-  const table = document.querySelector(
-    `#style-editor table[data-id='${identifier}']`
-  )
-
-  let currentData = []
-  const rows = table.querySelectorAll('tr')
-  const filename = table.getAttribute('data-id')
-
-  rows.forEach((row, rowIndex) => {
-    const rowData = []
-    const cells =
-      rowIndex === 0
-        ? row.querySelectorAll('th')
-        : row.querySelectorAll('td input, td textarea')
-
-    cells.forEach((cell) => {
-      rowData.push(rowIndex === 0 ? cell.textContent : cell.value)
-    })
-
-    currentData.push(rowData)
-  })
-
-  let tablesData = {}
-  tablesData[filename] = currentData
-
-  console.debug('Sending styles to manage endpoint:', tablesData)
-  fetch('/mtb/actions', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      name: 'saveStyle',
-      args: tablesData,
-    }),
-  })
-    .then((response) => response.json())
-    .then((data) => {
-      console.debug('Success:', data)
-    })
-    .catch((error) => {
-      console.error('Error:', error)
-    })
-}

html/js/splitPane.js

@@ -1,34 +0,0 @@
-/**
- * File: splitPane.js
- * Project: comfy_mtb
- * Author: Mel Massadian
- *
- * Copyright (c) 2023 Mel Massadian
- *
- */
-
-function initSplitPane(vertical) {
-  let resizer = document.getElementById('resizer')
-  let left = document.getElementById('leftPane')
-  let right = document.getElementById('rightPane')
-  resizer.addEventListener('mousedown', function (e) {
-    document.addEventListener('mousemove', onMouseMove)
-    document.addEventListener('mouseup', function () {
-      document.removeEventListener('mousemove', onMouseMove)
-    })
-  })
-
-  const onMouseMove = (e) => {
-    if (vertical) {
-      let leftWidth = e.clientX
-      let rightWidth = window.innerWidth - e.clientX
-      left.style.width = leftWidth + 'px'
-      right.style.width = rightWidth + 'px'
-    } else {
-      let topHeight = e.clientY
-      let bottomHeight = window.innerHeight - e.clientY
-      left.style.height = topHeight + 'px'
-      right.style.height = bottomHeight + 'px'
-    }
-  }
-}

html/js/tabSwitch.js

@@ -1,22 +0,0 @@
-/**
- * File: tabSwitch.js
- * Project: comfy_mtb
- * Author: Mel Massadian
- *
- * Copyright (c) 2023 Mel Massadian
- *
- */
-
-function openTab(evt, tabName) {
-  var i, tabcontent, tablinks
-  tabcontent = document.getElementsByClassName('tabcontent')
-  for (i = 0; i < tabcontent.length; i++) {
-    tabcontent[i].style.display = 'none'
-  }
-  tablinks = document.getElementsByClassName('tablinks')
-  for (i = 0; i < tablinks.length; i++) {
-    tablinks[i].className = tablinks[i].className.replace(' active', '')
-  }
-  document.getElementById(tabName).style.display = 'block'
-  evt.currentTarget.className += ' active'
-}

html/style.css

@@ -18,7 +18,7 @@ a {
 }
 
 table {
-    width: 100%;
+
     border-collapse: collapse;
 }
 
@@ -119,7 +119,7 @@ main {
     justify-content: center;
     padding: 1em;
     margin: 0;
-    /* height: 80%; */
+    height: 80%;
 }
 
 .flex-container {
@@ -130,99 +130,4 @@ main {
 .menu {
     font-size: 3em;
     text-align: center;
-}
-
-input, button, textarea {
-    background-color: rgba(0,0,0,0.5);
-    color: white;
-    border: none;
-}
-
-button:hover {
-    background-color: rgba(0,0,0,0.3);
-
-}
-button {
-    padding: 14px 16px;
-
-}
-/* -STYLES EDITOR */
-
-#style-editor {
-    display: flex;
-    flex-direction: column;
-    width:100%;
-    
-}
-
-#style-editor > table {
-    /* background-color: red; */
-    width:100%;
-}
-#style-editor input, #style-editor textarea {
-    /* background-color: blue; */
-    width:100%;
-}
-
-#style-editor td{
-    width: 33.33%;
-}
-
-/* -TABS */
-
-.tab {
-    overflow: hidden;
-    width: 100%;
-    display: flex;
-    flex-direction: row;
-
-}
-
-.tab-container{
-    width: 100%;
-    display: flex;
-    flex-direction: column;
-}
-
-.tab button {
-    background-color: transparent;
-    color:white;
-    float: left;
-    border: none;
-    outline: none;
-    cursor: pointer;
-    padding: 14px 16px;
-    transition: 0.3s;
-    width:100%;
-    font-size: 1.5em;
-}
-
-.tab button.active {
-    background-color: #2e2e2e;
-}
-
-.tabcontent {
-    display: none;
-}
-
-.tabcontent.active {
-    display: block;
-}
-
-
-
-.foldable-title {
-    cursor: pointer;
-    font-weight: bold;
-    user-select: none;
-}
-
-.foldable-symbol {
-    margin-right: 10px;
-}
-
-.foldable-content {
-    display: none;
-    flex-direction: column;
-    margin-left: 20px;
-}
+}

install.py

@@ -1,34 +1,37 @@
-import argparse
-import ast
-import os
-import platform
-import shlex
-import stat
-import subprocess
-import sys
-from contextlib import contextmanager
-from importlib import import_module
-from pathlib import Path
-
 import requests
+import os
+import ast
+import argparse
+import sys
+import subprocess
+from importlib import import_module
+import platform
+from pathlib import Path
+import sys
+import stat
+import threading
+import signal
+from contextlib import suppress
+from queue import Queue, Empty
+from contextlib import contextmanager
 
-# region constants
 here = Path(__file__).parent
-executable = Path(sys.executable)
+executable = sys.executable
 
 # - detect mode
 mode = None
 if os.environ.get("COLAB_GPU"):
     mode = "colab"
-elif "python_embeded" in str(executable):
+elif "python_embeded" in executable:
     mode = "embeded"
-elif ".venv" in str(executable):
+elif ".venv" in executable:
     mode = "venv"
 
 
 if mode is None:
     mode = "unknown"
 
+# - Constants
 repo_url = "https://github.com/melmass/comfy_mtb.git"
 repo_owner = "melmass"
 repo_name = "comfy_mtb"
@@ -37,17 +40,6 @@ short_platform = {
     "linux": "linux_x86_64",
 }
 current_platform = platform.system().lower()
-pip_map = {
-    "onnxruntime-gpu": "onnxruntime",
-    "opencv-contrib": "cv2",
-    "tb-nightly": "tensorboard",
-    "protobuf": "google.protobuf",
-    "qrcode[pil]": "qrcode",
-    "requirements-parser": "requirements"
-    # Add more mappings as needed
-}
-
-# endregion
 
 # region ansi
 # ANSI escape sequences for text styling
@@ -144,6 +136,12 @@ def print_formatted(text, *formats, color=None, background=None, **kwargs):
 
 
 # region utils
+def enqueue_output(out, queue):
+    for char in iter(lambda: out.read(1), b""):
+        queue.put(char)
+    out.close()
+
+
 def run_command(cmd, ignored_lines_start=None):
     if ignored_lines_start is None:
         ignored_lines_start = []
@@ -151,49 +149,113 @@ def run_command(cmd, ignored_lines_start=None):
     if isinstance(cmd, str):
         shell_cmd = cmd
     elif isinstance(cmd, list):
-        shell_cmd = " ".join(
-            arg.as_posix() if isinstance(arg, Path) else shlex.quote(str(arg))
-            for arg in cmd
-        )
+        shell_cmd = ""
+        for arg in cmd:
+            if isinstance(arg, Path):
+                arg = arg.as_posix()
+            shell_cmd += f"{arg} "
     else:
         raise ValueError(
             "Invalid 'cmd' argument. It must be a string or a list of arguments."
         )
 
-    try:
-        _run_command(shell_cmd, ignored_lines_start)
-    except subprocess.CalledProcessError as e:
-        print(f"Command failed with return code: {e.returncode}", file=sys.stderr)
-        print(e.stderr.strip(), file=sys.stderr)
-
-    except KeyboardInterrupt:
-        print("Command execution interrupted.")
-
-
-def _run_command(shell_cmd, ignored_lines_start):
-    print_formatted(f"Running {shell_cmd}", "bold")
-    result = subprocess.run(
+    process = subprocess.Popen(
         shell_cmd,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
-        text=True,
+        universal_newlines=True,
         shell=True,
-        check=True,
     )
 
-    stdout_lines = result.stdout.strip().split("\n")
-    stderr_lines = result.stderr.strip().split("\n")
+    # Create separate threads to read standard output and standard error streams
+    stdout_queue = Queue()
+    stderr_queue = Queue()
+    stdout_thread = threading.Thread(
+        target=enqueue_output, args=(process.stdout, stdout_queue)
+    )
+    stderr_thread = threading.Thread(
+        target=enqueue_output, args=(process.stderr, stderr_queue)
+    )
+    stdout_thread.daemon = True
+    stderr_thread.daemon = True
+    stdout_thread.start()
+    stderr_thread.start()
 
-    # Print stdout, skipping ignored lines
-    for line in stdout_lines:
-        if not any(line.startswith(ign) for ign in ignored_lines_start):
-            print(line)
+    interrupted = False
 
-    # Print stderr
-    for line in stderr_lines:
-        print(line, file=sys.stderr)
+    def signal_handler(signum, frame):
+        nonlocal interrupted
+        interrupted = True
+        print("Command execution interrupted.")
 
-    print("Command executed successfully!")
+    # Register the signal handler for keyboard interrupts (SIGINT)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    stdout_buffer = ""
+    stderr_buffer = ""
+
+    # Process output from both streams until the process completes or interrupted
+    while not interrupted and (
+        process.poll() is None or not stdout_queue.empty() or not stderr_queue.empty()
+    ):
+        with suppress(Empty):
+            stdout_char = stdout_queue.get_nowait()
+            stdout_buffer += stdout_char
+            if stdout_char == "\n":
+                if not any(
+                    stdout_buffer.startswith(ign) for ign in ignored_lines_start
+                ):
+                    print(stdout_buffer.strip())
+                stdout_buffer = ""
+        with suppress(Empty):
+            stderr_char = stderr_queue.get_nowait()
+            stderr_buffer += stderr_char
+            if stderr_char == "\n":
+                print(stderr_buffer.strip())
+                stderr_buffer = ""
+
+    # Print any remaining content in buffers
+    if stdout_buffer and not any(
+        stdout_buffer.startswith(ign) for ign in ignored_lines_start
+    ):
+        print(stdout_buffer.strip())
+    if stderr_buffer:
+        print(stderr_buffer.strip())
+
+    return_code = process.returncode
+
+    if return_code == 0 and not interrupted:
+        print("Command executed successfully!")
+    else:
+        if not interrupted:
+            print(f"Command failed with return code: {return_code}")
+
+
+# endregion
+
+try:
+    import requirements
+except ImportError:
+    print_formatted("Installing requirements-parser...", "italic", color="yellow")
+    run_command([sys.executable, "-m", "pip", "install", "requirements-parser"])
+    import requirements
+
+    print_formatted("Done.", "italic", color="green")
+
+try:
+    from tqdm import tqdm
+except ImportError:
+    print_formatted("Installing tqdm...", "italic", color="yellow")
+    run_command([sys.executable, "-m", "pip", "install", "--upgrade", "tqdm"])
+    from tqdm import tqdm
+
+pip_map = {
+    "onnxruntime-gpu": "onnxruntime",
+    "opencv-contrib": "cv2",
+    "tb-nightly": "tensorboard",
+    "protobuf": "google.protobuf",
+    # Add more mappings as needed
+}
 
 
 def is_pipe():
@@ -268,6 +330,24 @@ def download_file(url, file_name):
                 progress_bar.update(len(chunk))
 
 
+def get_requirements(path: Path):
+    with open(path.resolve(), "r") as requirements_file:
+        requirements_txt = requirements_file.read()
+
+    try:
+        parsed_requirements = requirements.parse(requirements_txt)
+    except AttributeError:
+        print_formatted(
+            f"Failed to parse {path}. Please make sure the file is correctly formatted.",
+            "bold",
+            color="red",
+        )
+
+        return
+
+    return parsed_requirements
+
+
 def try_import(requirement):
     dependency = requirement.name.strip()
     import_name = pip_map.get(dependency, dependency)
@@ -310,7 +390,7 @@ def import_or_install(requirement, dry=False):
             )
         else:
             try:
-                run_command([executable, "-m", "pip", "install", pip_install_name])
+                run_command([sys.executable, "-m", "pip", "install", pip_install_name])
                 print_formatted(
                     f"Package {pip_install_name} installed successfully using pip package name  (import name: '{import_name}')",
                     "bold",
@@ -347,29 +427,29 @@ def get_github_assets(tag=None):
     return tag_data, tag_name
 
 
-# endregion
+# Install dependencies from requirements.txt
+def install_dependencies(dry=False):
+    parsed_requirements = get_requirements(here / "reqs.txt")
+    if not parsed_requirements:
+        return
+    print_formatted(
+        "Installing dependencies from reqs.txt...", "italic", color="yellow"
+    )
+
+    for requirement in parsed_requirements:
+        import_or_install(requirement, dry=dry)
 
 
-try:
-    from tqdm import tqdm
-except ImportError:
-    print_formatted("Installing tqdm...", "italic", color="yellow")
-    run_command([executable, "-m", "pip", "install", "--upgrade", "tqdm"])
-    from tqdm import tqdm
-
-
-def main():
+if __name__ == "__main__":
+    full = False
     if len(sys.argv) == 1:
         print_formatted(
-            "mtb doesn't need an install script anymore.", "italic", color="yellow"
+            "No arguments provided, doing a full install/update...",
+            "italic",
+            color="yellow",
         )
-        return
-    if all(arg not in ("-p", "--path") for arg in sys.argv):
-        print(
-            "This script is only used for and edge case of remote installs on some cloud providers, unrecognized arguments:",
-            sys.argv[1:],
-        )
-        return
+
+        full = True
 
     # Parse command-line arguments
     parser = argparse.ArgumentParser(description="Comfy_mtb install script")
@@ -379,11 +459,29 @@ def main():
         type=str,
         help="Path to clone the repository to (i.e the absolute path to ComfyUI/custom_nodes)",
     )
+    parser.add_argument(
+        "--wheels", "-w", action="store_true", help="Install wheel dependencies"
+    )
+    parser.add_argument(
+        "--requirements", "-r", action="store_true", help="Install requirements.txt"
+    )
+    parser.add_argument(
+        "--dry",
+        action="store_true",
+        help="Print what will happen without doing it (still making requests to the GH Api)",
+    )
 
+    # - keep
+    # parser.add_argument(
+    #     "--version",
+    #     default=get_local_version(),
+    #     help="Version to check against the GitHub API",
+    # )
     print_formatted("mtb install", "bold", color="yellow")
 
     args = parser.parse_args()
 
+    # wheels_directory = here / "wheels"
     print_formatted(f"Detected environment: {apply_color(mode,'cyan')}")
 
     if args.path:
@@ -404,18 +502,131 @@ def main():
                     f"Directory {repo_dir} already exists, we will update it..."
                 )
                 run_command(["git", "pull", "-C", repo_dir])
+        # os.chdir(clone_dir)
         here = clone_dir
         full = True
 
+    # Install dependencies from requirements.txt
+    # if args.requirements or mode == "venv":
+
+    # if (not args.wheels and mode not in ["colab", "embeded"]) and not full:
+    #     print_formatted(
+    #         "Skipping wheel installation. Use --wheels to install wheel dependencies. (only needed for Comfy embed)",
+    #         "italic",
+    #         color="yellow",
+    #     )
+
+    #     install_dependencies(dry=args.dry)
+    #     sys.exit()
+
+    # if mode in ["colab", "embeded"]:
+    #     print_formatted(
+    #         f"Downloading and installing release wheels since we are in a Comfy {apply_color(mode,'cyan')} environment",
+    #         "italic",
+    #         color="yellow",
+    #     )
+    # if full:
+    #     print_formatted(
+    #         f"Downloading and installing release wheels since no arguments where provided",
+    #         "italic",
+    #         color="yellow",
+    #     )
+
     print_formatted("Checking environment...", "italic", color="yellow")
     missing_deps = []
-    install_cmd = [executable, "-m", "pip", "install", "-r", "requirements.txt"]
-    run_command(install_cmd)
+    if parsed_requirements := get_requirements(here / "reqs.txt"):
+        for requirement in parsed_requirements:
+            installed, pip_name, pip_spec, import_name = try_import(requirement)
+            if not installed:
+                missing_deps.append(pip_name.split("-")[0])
 
-    print_formatted(
-        "✅ Successfully installed all dependencies.", "italic", color="green"
-    )
+    if not missing_deps:
+        print_formatted(
+            "All requirements are already installed. Enjoy 🚀",
+            "italic",
+            color="green",
+        )
+        sys.exit()
 
+    # # - Get the tag version from the GitHub API
+    # tag_data, tag_name = get_github_assets(tag=None)
 
-if __name__ == "__main__":
-    main()
+    # # - keep
+    # version = args.version
+    # # Compare the local and tag versions
+    # if version and tag_name:
+    #     if re.match(r"v?(\d+(\.\d+)+)", version) and re.match(
+    #         r"v?(\d+(\.\d+)+)", tag_name
+    #     ):
+    #         version_parts = [int(part) for part in version.lstrip("v").split(".")]
+    #         tag_version_parts = [int(part) for part in tag_name.lstrip("v").split(".")]
+
+    #         if version_parts > tag_version_parts:
+    #             print_formatted(
+    #                 f"Local version ({version}) is greater than the release version ({tag_name}).",
+    #                 "bold",
+    #                 "yellow",
+    #             )
+    #             sys.exit()
+
+    # matching_assets = [
+    #     asset
+    #     for asset in tag_data["assets"]
+    #     if asset["name"].endswith(".whl")
+    #     and (
+    #         "any" in asset["name"] or short_platform[current_platform] in asset["name"]
+    #     )
+    # ]
+    # if not matching_assets:
+    #     print_formatted(
+    #         f"Unsupported operating system: {current_platform}", color="yellow"
+    #     )
+    # wheel_order_asset = next(
+    #     (asset for asset in tag_data["assets"] if asset["name"] == "wheel_order.txt"),
+    #     None,
+    # )
+    # if wheel_order_asset is not None:
+    #     print_formatted(
+    #         "⚙️ Sorting the release wheels using wheels order", "italic", color="yellow"
+    #     )
+    #     response = requests.get(wheel_order_asset["browser_download_url"])
+    #     if response.status_code == 200:
+    #         wheel_order = [line.strip() for line in response.text.splitlines()]
+
+    #         def get_order_index(val):
+    #             try:
+    #                 return wheel_order.index(val)
+    #             except ValueError:
+    #                 return len(wheel_order)
+
+    #         matching_assets = sorted(
+    #             matching_assets,
+    #             key=lambda x: get_order_index(x["name"].split("-")[0]),
+    #         )
+    #     else:
+    #         print("Failed to fetch wheel_order.txt. Status code:", response.status_code)
+
+    # missing_deps_urls = []
+    # for whl_file in matching_assets:
+    #     # check if installed
+    #     missing_deps_urls.append(whl_file["browser_download_url"])
+
+    install_cmd = [sys.executable, "-m", "pip", "install"]
+
+    # - Install all deps
+    if not args.dry:
+        if platform.system() == "Windows":
+            wheel_cmd = install_cmd + ["-r", (here / "reqs_windows.txt")]
+        else:
+            wheel_cmd = install_cmd + ["-r", (here / "reqs.txt")]
+
+        run_command(wheel_cmd)
+        print_formatted(
+            "✅ Successfully installed all dependencies.", "italic", color="green"
+        )
+    else:
+        print_formatted(
+            f"Would have run the following command:\n\t{apply_color(' '.join(install_cmd),'cyan')}",
+            "italic",
+            color="yellow",
+        )

log.py

@@ -1,6 +1,6 @@
 import logging
-import os
 import re
+import os
 
 base_log_level = logging.DEBUG if os.environ.get("MTB_DEBUG") else logging.INFO
 
@@ -36,7 +36,7 @@ class Formatter(logging.Formatter):
         return formatter.format(record)
 
 
-def mklog(name: str, level: int = base_log_level):
+def mklog(name, level=base_log_level):
     logger = logging.getLogger(name)
     logger.setLevel(level)
 
@@ -58,24 +58,22 @@ def mklog(name: str, level: int = base_log_level):
 log = mklog(__package__, base_log_level)
 
 
-def log_user(arg: str):
-    print(f"\033[34mComfy MTB Utils:\033[0m {arg}")
+def log_user(arg):
+    print("\033[34mComfy MTB Utils:\033[0m {arg}")
 
 
-def get_summary(docstring: str):
+def get_summary(docstring):
     return docstring.strip().split("\n\n", 1)[0]
 
 
-def blue_text(text: str):
+def blue_text(text):
     return f"\033[94m{text}\033[0m"
 
 
-def cyan_text(text: str):
+def cyan_text(text):
     return f"\033[96m{text}\033[0m"
 
 
-def get_label(label: str):
-    if label.startswith("MTB_"):
-        label = label[4:]
+def get_label(label):
     words = re.findall(r"(?:^|[A-Z])[a-z]*", label)
     return " ".join(words).strip()

node_list.json

@@ -1,62 +1,46 @@
-{
-    "Animation Builder (mtb)": "Convenient way to manage basic animation maths at the core of many of my workflows",
-    "Any To String (mtb)": "Tries to take any input and convert it to a string",
-    "Batch Float (mtb)": "Generates a batch of float values with interpolation",
-    "Batch Float Assemble (mtb)": "Assembles mutiple batches of floats into a single stream (batch)",
-    "Batch Float Fill (mtb)": "Fills a batch float with a single value until it reaches the target length",
-    "Batch Make (mtb)": "Simply duplicates the input frame as a batch",
-    "Batch Merge (mtb)": "Merges multiple image batches with different frame counts",
-    "Batch Shake (mtb)": "Applies a shaking effect to batches of images.",
-    "Batch Shape (mtb)": "Generates a batch of 2D shapes with optional shading (experimental)",
-    "Batch Transform (mtb)": "Transform a batch of images using a batch of keyframes",
-    "Bbox (mtb)": "The bounding box (BBOX) custom type used by other nodes",
-    "Bbox From Mask (mtb)": "From a mask extract the bounding box",
-    "Blur (mtb)": "Blur an image using a Gaussian filter.",
-    "Color Correct (mtb)": "Various color correction methods",
-    "Colored Image (mtb)": "Constant color image of given size",
-    "Concat Images (mtb)": "Add images to batch",
-    "Crop (mtb)": "Crops an image and an optional mask to a given bounding box\n\n    The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type\n    The BBOX input takes precedence over the tuple input\n    ",
-    "Debug (mtb)": "Experimental node to debug any Comfy values, support for more types and widgets is planned",
-    "Deep Bump (mtb)": "Normal & height maps generation from single pictures",
-    "Export With Ffmpeg (mtb)": "Export with FFmpeg (Experimental)",
-    "Face Swap (mtb)": "Face swap using deepinsight/insightface models",
-    "Film Interpolation (mtb)": "Google Research FILM frame interpolation for large motion",
-    "Fit Number (mtb)": "Fit the input float using a source and target range",
-    "Float To Number (mtb)": "Node addon for the WAS Suite. Converts a \"comfy\" FLOAT to a NUMBER.",
-    "Get Batch From History (mtb)": "Very experimental node to load images from the history of the server.\n\n    Queue items without output are ignored in the count.",
-    "Image Compare (mtb)": "Compare two images and return a difference image",
-    "Image Premultiply (mtb)": "Premultiply image with mask",
-    "Image Remove Background Rembg (mtb)": "Removes the background from the input using Rembg.",
-    "Image Resize Factor (mtb)": "Extracted mostly from WAS Node Suite, with a few edits (most notably multiple image support) and less features.",
-    "Image Tile Offset (mtb)": "Mimics an old photoshop technique to check for seamless textures",
-    "Int To Bool (mtb)": "Basic int to bool conversion",
-    "Int To Number (mtb)": "Node addon for the WAS Suite. Converts a \"comfy\" INT to a NUMBER.",
-    "Interpolate Clip Sequential (mtb)": null,
-    "Latent Lerp (mtb)": "Linear interpolation (blend) between two latent vectors",
-    "Load Face Analysis Model (mtb)": "Loads a face analysis model",
-    "Load Face Enhance Model (mtb)": "Loads a GFPGan or RestoreFormer model for face enhancement.",
-    "Load Face Swap Model (mtb)": "Loads a faceswap model",
-    "Load Film Model (mtb)": "Loads a FILM model",
-    "Load Image From Url (mtb)": "Load an image from the given URL",
-    "Load Image Sequence (mtb)": "Load an image sequence from a folder. The current frame is used to determine which image to load.\n\n    Usually used in conjunction with the `Primitive` node set to increment to load a sequence of images from a folder.\n    Use -1 to load all matching frames as a batch.\n    ",
-    "Mask To Image (mtb)": "Converts a mask (alpha) to an RGB image with a color and background",
-    "Math Expression (mtb)": "Node to evaluate a simple math expression string",
-    "Model Patch Seamless (mtb)": "Uses the stable diffusion 'hack' to infer seamless images by setting the model layers padding mode to circular (experimental)",
-    "Pick From Batch (mtb)": "Pick a specific number of images from a batch, either from the start or end.",
-    "Qr Code (mtb)": "Basic QR Code generator",
-    "Restore Face (mtb)": "Uses GFPGan to restore faces",
-    "Save Gif (mtb)": "Save the images from the batch as a GIF",
-    "Save Image Grid (mtb)": "Save all the images in the input batch as a grid of images.",
-    "Save Image Sequence (mtb)": "Save an image sequence to a folder. The current frame is used to determine which image to save.\n\n    This is merely a wrapper around the `save_images` function with formatting for the output folder and filename.\n    ",
-    "Save Tensors (mtb)": "Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy",
-    "Sharpen (mtb)": "Sharpens an image using a Gaussian kernel.",
-    "Smart Step (mtb)": "Utils to control the steps start/stop of the KAdvancedSampler in percentage",
-    "Stack Images (mtb)": "Stack the input images horizontally or vertically",
-    "String Replace (mtb)": "Basic string replacement",
-    "Styles Loader (mtb)": "Load csv files and populate a dropdown from the rows (\u00e0 la A111)",
-    "Text To Image (mtb)": "Utils to convert text to image using a font\n\n\n    The tool looks for any .ttf file in the Comfy folder hierarchy.\n    ",
-    "Transform Image (mtb)": "Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy\n\n\n    it return a tensor representing the transformed images with the same shape as the input tensor\n    ",
-    "Uncrop (mtb)": "Uncrops an image to a given bounding box\n\n    The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type\n    The BBOX input takes precedence over the tuple input",
-    "Unsplash Image (mtb)": "Unsplash Image given a keyword and a size",
-    "Vae Decode (mtb)": "Wrapper for the 2 core decoders but also adding the sd seamless hack, taken from: FlyingFireCo/tiled_ksampler"
-}
+{
+    "Animation Builder (mtb)": "Convenient way to manage basic animation maths at the core of many of my workflows",
+    "Any To String (mtb)": "Tries to take any input and convert it to a string",
+    "Bbox (mtb)": "The bounding box (BBOX) custom type used by other nodes",
+    "Bbox From Mask (mtb)": "From a mask extract the bounding box",
+    "Blur (mtb)": "Blur an image using a Gaussian filter.",
+    "Color Correct (mtb)": "Various color correction methods",
+    "Colored Image (mtb)": "Constant color image of given size",
+    "Concat Images (mtb)": "Add images to batch",
+    "Crop (mtb)": "Crops an image and an optional mask to a given bounding box\n\n    The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type\n    The BBOX input takes precedence over the tuple input\n    ",
+    "Debug (mtb)": "Experimental node to debug any Comfy values, support for more types and widgets is planned",
+    "Deep Bump (mtb)": "Normal & height maps generation from single pictures",
+    "Export With Ffmpeg (mtb)": "Export with FFmpeg (Experimental)",
+    "Face Swap (mtb)": "Face swap using deepinsight/insightface models",
+    "Film Interpolation (mtb)": "Google Research FILM frame interpolation for large motion",
+    "Fit Number (mtb)": "Fit the input float using a source and target range",
+    "Float To Number (mtb)": "Node addon for the WAS Suite. Converts a \"comfy\" FLOAT to a NUMBER.",
+    "Get Batch From History (mtb)": "Very experimental node to load images from the history of the server.\n\n    Queue items without output are ignored in the count.",
+    "Image Compare (mtb)": "Compare two images and return a difference image",
+    "Image Premultiply (mtb)": "Premultiply image with mask",
+    "Image Remove Background Rembg (mtb)": "Removes the background from the input using Rembg.",
+    "Image Resize Factor (mtb)": "Extracted mostly from WAS Node Suite, with a few edits (most notably multiple image support) and less features.",
+    "Int To Bool (mtb)": "Basic int to bool conversion",
+    "Int To Number (mtb)": "Node addon for the WAS Suite. Converts a \"comfy\" INT to a NUMBER.",
+    "Latent Lerp (mtb)": "Linear interpolation (blend) between two latent vectors",
+    "Load Face Analysis Model (mtb)": "Loads a face analysis model",
+    "Load Face Enhance Model (mtb)": "Loads a GFPGan or RestoreFormer model for face enhancement.",
+    "Load Face Swap Model (mtb)": "Loads a faceswap model",
+    "Load Film Model (mtb)": "Loads a FILM model",
+    "Load Image From Url (mtb)": "Load an image from the given URL",
+    "Load Image Sequence (mtb)": "Load an image sequence from a folder. The current frame is used to determine which image to load.\n\n    Usually used in conjunction with the `Primitive` node set to increment to load a sequence of images from a folder.\n    Use -1 to load all matching frames as a batch.\n    ",
+    "Mask To Image (mtb)": "Converts a mask (alpha) to an RGB image with a color and background",
+    "Qr Code (mtb)": "Basic QR Code generator",
+    "Restore Face (mtb)": "Uses GFPGan to restore faces",
+    "Save Gif (mtb)": "Save the images from the batch as a GIF",
+    "Save Image Grid (mtb)": "Save all the images in the input batch as a grid of images.",
+    "Save Image Sequence (mtb)": "Save an image sequence to a folder. The current frame is used to determine which image to save.\n\n    This is merely a wrapper around the `save_images` function with formatting for the output folder and filename.\n    ",
+    "Save Tensors (mtb)": "Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy",
+    "Smart Step (mtb)": "Utils to control the steps start/stop of the KAdvancedSampler in percentage",
+    "String Replace (mtb)": "Basic string replacement",
+    "Styles Loader (mtb)": "Load csv files and populate a dropdown from the rows (\u00e0 la A111)",
+    "Text To Image (mtb)": "Utils to convert text to image using a font\n\n\n    The tool looks for any .ttf file in the Comfy folder hierarchy.\n    ",
+    "Transform Image (mtb)": "Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy\n\n\n    it return a tensor representing the transformed images with the same shape as the input tensor\n    ",
+    "Uncrop (mtb)": "Uncrops an image to a given bounding box\n\n    The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type\n    The BBOX input takes precedence over the tuple input",
+    "Unsplash Image (mtb)": "Unsplash Image given a keyword and a size"
+}

nodes/__init__.py

@@ -1 +0,0 @@
-"""MTB Nodes module."""

nodes/animation.py

@@ -1,8 +1,8 @@
 from ..log import log
 
 
-class MTB_AnimationBuilder:
-    """Simple maths for animation."""
+class AnimationBuilder:
+    """Convenient way to manage basic animation maths at the core of many of my workflows"""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -21,36 +21,6 @@ class MTB_AnimationBuilder:
     RETURN_NAMES = ("frame", "0-1 (scaled)", "count", "loop_ended")
     CATEGORY = "mtb/animation"
     FUNCTION = "build_animation"
-    DESCRIPTION = """
-# Animation Builder
-
-Check the
-[wiki page](https://github.com/melMass/comfy_mtb/wiki/nodes-animation-builder)
-for more info.
-
-
-- This basic example should help to understand the meaning of
-its inputs and outputs thanks to the [debug](nodes-debug) node.
-
-![](https://github.com/melMass/comfy_mtb/assets/7041726/2b5c7e4f-372d-4494-9e73-abb2daa7cb36)
-
-- In this other example Animation Builder is used in combination with
-[Batch From History](https://github.com/melMass/comfy_mtb/wiki/nodes-batch-from-history)
-to create a zoom-in animation on a static image
-
-![](https://github.com/melMass/comfy_mtb/assets/7041726/77d37da1-0a8e-4519-a493-dfdef7f755ea)
-
-## Inputs
-
-| name | description |
-| ---- | :----------:|
-| total_frames | The number of frame to queue (this is multiplied by the `loop_count`)|
-| scale_float | Convenience input to scale the normalized `current value` (a float between 0 and 1 lerp over the current queue length) |
-| loop_count | The number of loops to queue |
-| **Reset Button** | resets the internal counters, although the node is though around using its queue button it should still work fine when using the regular queue button of comfy |
-| **Queue Button** | Convenience button to run the queues (`total_frames` * `loop_count`) |
-
-"""
 
     def build_animation(
         self,
@@ -71,4 +41,4 @@ to create a zoom-in animation on a static image
         return (frame, scaled, raw_loop, (frame == (total_frames - 1)))
 
 
-__nodes__ = [MTB_AnimationBuilder]
+__nodes__ = [AnimationBuilder]

nodes/conditions.py

@@ -1,14 +1,12 @@
-import csv
-import shutil
-from pathlib import Path
-
-import folder_paths
-
-from ..log import log
 from ..utils import here
+from ..log import log
+import folder_paths
+from pathlib import Path
+import shutil
+import csv
 
 
-class MTB_InterpolateClipSequential:
+class InterpolateClipSequential:
     @classmethod
     def INPUT_TYPES(cls):
         return {
@@ -29,12 +27,7 @@ class MTB_InterpolateClipSequential:
     CATEGORY = "mtb/conditioning"
 
     def interpolate_encodings_sequential(
-        self,
-        base_text,
-        text_to_replace,
-        clip,
-        interpolation_strength,
-        **replacements,
+        self, base_text, text_to_replace, clip, interpolation_strength, **replacements
     ):
         log.debug(f"Received interpolation_strength: {interpolation_strength}")
 
@@ -69,30 +62,20 @@ class MTB_InterpolateClipSequential:
             log.debug("Using the base text a the base blend")
             # -  Start with the base_text condition
             tokens = clip.tokenize(base_text)
-            cond_from, pooled_from = clip.encode_from_tokens(
-                tokens, return_pooled=True
-            )
+            cond_from, pooled_from = clip.encode_from_tokens(tokens, return_pooled=True)
         else:
             base_replace = list(replacements.values())[segment_index - 1]
             log.debug(f"Using {base_replace} a the base blend")
 
             # - Start with the base_text condition replaced by the closest replacement
-            tokens = clip.tokenize(
-                base_text.replace(text_to_replace, base_replace)
-            )
-            cond_from, pooled_from = clip.encode_from_tokens(
-                tokens, return_pooled=True
-            )
+            tokens = clip.tokenize(base_text.replace(text_to_replace, base_replace))
+            cond_from, pooled_from = clip.encode_from_tokens(tokens, return_pooled=True)
 
             replacement_text = list(replacements.values())[segment_index]
 
-        interpolated_text = base_text.replace(
-            text_to_replace, replacement_text
-        )
+        interpolated_text = base_text.replace(text_to_replace, replacement_text)
         tokens = clip.tokenize(interpolated_text)
-        cond_to, pooled_to = clip.encode_from_tokens(
-            tokens, return_pooled=True
-        )
+        cond_to, pooled_to = clip.encode_from_tokens(tokens, return_pooled=True)
 
         # - Linearly interpolate between the two conditions
         interpolated_condition = (
@@ -102,12 +85,10 @@ class MTB_InterpolateClipSequential:
             1.0 - local_strength
         ) * pooled_from + local_strength * pooled_to
 
-        return (
-            [[interpolated_condition, {"pooled_output": interpolated_pooled}]],
-        )
+        return ([[interpolated_condition, {"pooled_output": interpolated_pooled}]],)
 
 
-class MTB_SmartStep:
+class SmartStep:
     """Utils to control the steps start/stop of the KAdvancedSampler in percentage"""
 
     @classmethod
@@ -154,7 +135,7 @@ def install_default_styles(force=False):
     return dest_style
 
 
-class MTB_StylesLoader:
+class StylesLoader:
     """Load csv files and populate a dropdown from the rows (à la A111)"""
 
     options = {}
@@ -166,33 +147,17 @@ class MTB_StylesLoader:
             if not input_dir.exists():
                 install_default_styles()
 
-            if not (
-                files := [f for f in input_dir.iterdir() if f.suffix == ".csv"]
-            ):
+            if not (files := [f for f in input_dir.iterdir() if f.suffix == ".csv"]):
                 log.warn(
                     "No styles found in the styles folder, place at least one csv file in the styles folder at the root of ComfyUI (for instance ComfyUI/styles/mystyle.csv)"
                 )
 
             for file in files:
-                with open(file, encoding="utf8") as f:
+                with open(file, "r", encoding="utf8") as f:
                     parsed = csv.reader(f)
-                    for i, row in enumerate(parsed):
+                    for row in parsed:
                         log.debug(f"Adding style {row[0]}")
-                        try:
-                            name, positive, negative = (row + [None] * 3)[:3]
-                            positive = positive or ""
-                            negative = negative or ""
-                            if name is not None:
-                                cls.options[name] = (positive, negative)
-                            else:
-                                # Handle the case where 'name' is None
-                                log.warning(f"Missing 'name' in row {i}.")
-
-                        except Exception as e:
-                            log.warning(
-                                f"There was an error while parsing {file}, make sure it respects A1111 format, i.e 3 columns name, positive, negative:\n{e}"
-                            )
-                            continue
+                        cls.options[row[0]] = (row[1], row[2])
 
         else:
             log.debug(f"Using cached styles (count: {len(cls.options)})")
@@ -213,4 +178,4 @@ class MTB_StylesLoader:
         return (self.options[style_name][0], self.options[style_name][1])
 
 
-__nodes__ = [MTB_SmartStep, MTB_StylesLoader, MTB_InterpolateClipSequential]
+__nodes__ = [SmartStep, StylesLoader, InterpolateClipSequential]

nodes/constant.py

@@ -1,27 +0,0 @@
-import json
-
-from ..log import log
-
-
-class MTB_Constant:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {"Value": ("*",)},
-        }
-
-    RETURN_TYPES = ("*",)
-    RETURN_NAMES = ("output",)
-    CATEGORY = "mtb/utils"
-    FUNCTION = "execute"
-
-    def execute(
-        self,
-        **kwargs,
-    ):
-        log.debug("Received kwargs")
-        log.debug(json.dumps(kwargs, check_circular=True))
-        return (kwargs.get("Value"),)
-
-
-__nodes__ = [MTB_Constant]

nodes/crop.py

@@ -1,12 +1,12 @@
-import numpy as np
 import torch
-from PIL import Image, ImageDraw, ImageFilter
+from ..utils import tensor2pil, pil2tensor, tensor2np, np2tensor
+from PIL import Image, ImageFilter, ImageDraw, ImageChops
+import numpy as np
 
 from ..log import log
-from ..utils import np2tensor, pil2tensor, tensor2np, tensor2pil
 
 
-class MTB_Bbox:
+class Bbox:
     """The bounding box (BBOX) custom type used by other nodes"""
 
     @classmethod
@@ -14,14 +14,8 @@ class MTB_Bbox:
         return {
             "required": {
                 # "bbox": ("BBOX",),
-                "x": (
-                    "INT",
-                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
-                ),
-                "y": (
-                    "INT",
-                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
-                ),
+                "x": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
+                "y": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
                 "width": (
                     "INT",
                     {"default": 256, "max": 10000000, "min": 0, "step": 1},
@@ -37,11 +31,12 @@ class MTB_Bbox:
     FUNCTION = "do_crop"
     CATEGORY = "mtb/crop"
 
-    def do_crop(self, x: int, y: int, width: int, height: int):  # bbox
-        return ((x, y, width, height),)
+    def do_crop(self, x, y, width, height):  # bbox
+        return (x, y, width, height)
+        # return bbox
 
 
-class MTB_BboxFromMask:
+class BboxFromMask:
     """From a mask extract the bounding box"""
 
     @classmethod
@@ -49,7 +44,6 @@ class MTB_BboxFromMask:
         return {
             "required": {
                 "mask": ("MASK",),
-                "invert": ("BOOLEAN", {"default": False}),
             },
             "optional": {
                 "image": ("IMAGE",),
@@ -67,9 +61,7 @@ class MTB_BboxFromMask:
     FUNCTION = "extract_bounding_box"
     CATEGORY = "mtb/crop"
 
-    def extract_bounding_box(
-        self, mask: torch.Tensor, invert: bool, image=None
-    ):
+    def extract_bounding_box(self, mask: torch.Tensor, image=None):
         # if image != None:
         #     if mask.size(0) != image.size(0):
         #         if mask.size(0) != 1:
@@ -81,8 +73,9 @@ class MTB_BboxFromMask:
         #                 f"Batch count mismatch for mask and image, it can either be 1 mask for X images, or X masks for X images (mask: {mask.shape} | image: {image.shape})"
         #             )
 
+        _mask = tensor2pil(1.0 - mask)[0]
+
         # we invert it
-        _mask = tensor2pil(1.0 - mask)[0] if invert else tensor2pil(mask)[0]
         alpha_channel = np.array(_mask)
 
         non_zero_indices = np.nonzero(alpha_channel)
@@ -110,7 +103,7 @@ class MTB_BboxFromMask:
         )
 
 
-class MTB_Crop:
+class Crop:
     """Crops an image and an optional mask to a given bounding box
 
     The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type
@@ -125,14 +118,8 @@ class MTB_Crop:
             },
             "optional": {
                 "mask": ("MASK",),
-                "x": (
-                    "INT",
-                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
-                ),
-                "y": (
-                    "INT",
-                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
-                ),
+                "x": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
+                "y": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
                 "width": (
                     "INT",
                     {"default": 256, "max": 10000000, "min": 0, "step": 1},
@@ -151,37 +138,22 @@ class MTB_Crop:
     CATEGORY = "mtb/crop"
 
     def do_crop(
-        self,
-        image: torch.Tensor,
-        mask=None,
-        x=0,
-        y=0,
-        width=256,
-        height=256,
-        bbox=None,
+        self, image: torch.Tensor, mask=None, x=0, y=0, width=256, height=256, bbox=None
     ):
         image = image.numpy()
-        if mask is not None:
+        if mask:
             mask = mask.numpy()
 
-        if bbox is not None:
+        if bbox != None:
             x, y, width, height = bbox
 
         cropped_image = image[:, y : y + height, x : x + width, :]
-        cropped_mask = None
-        if mask is not None:
-            cropped_mask = (
-                mask[:, y : y + height, x : x + width]
-                if mask is not None
-                else None
-            )
+        cropped_mask = mask[y : y + height, x : x + width] if mask != None else None
         crop_data = (x, y, width, height)
 
         return (
             torch.from_numpy(cropped_image),
-            torch.from_numpy(cropped_mask)
-            if cropped_mask is not None
-            else None,
+            torch.from_numpy(cropped_mask) if mask != None else None,
             crop_data,
         )
 
@@ -218,12 +190,11 @@ def bbox_to_region(bbox, target_size=None):
     return (bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3])
 
 
-class MTB_Uncrop:
+class Uncrop:
     """Uncrops an image to a given bounding box
 
     The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type
-    The BBOX input takes precedence over the tuple input
-    """
+    The BBOX input takes precedence over the tuple input"""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -247,15 +218,11 @@ class MTB_Uncrop:
     def do_crop(self, image, crop_image, bbox, border_blending):
         def inset_border(image, border_width=20, border_color=(0)):
             width, height = image.size
-            bordered_image = Image.new(
-                image.mode, (width, height), border_color
-            )
+            bordered_image = Image.new(image.mode, (width, height), border_color)
             bordered_image.paste(image, (0, 0))
             draw = ImageDraw.Draw(bordered_image)
             draw.rectangle(
-                (0, 0, width - 1, height - 1),
-                outline=border_color,
-                width=border_width,
+                (0, 0, width - 1, height - 1), outline=border_color, width=border_width
             )
             return bordered_image
 
@@ -278,9 +245,7 @@ class MTB_Uncrop:
             # uncrop the image based on the bounding box
             bb_x, bb_y, bb_width, bb_height = bbox
 
-            paste_region = bbox_to_region(
-                (bb_x, bb_y, bb_width, bb_height), img.size
-            )
+            paste_region = bbox_to_region((bb_x, bb_y, bb_width, bb_height), img.size)
             # log.debug(f"Paste region: {paste_region}")
             # new_region = adjust_paste_region(img.size, paste_region)
             # log.debug(f"Adjusted paste region: {new_region}")
@@ -306,16 +271,12 @@ class MTB_Uncrop:
 
             mask.paste(mask_block, paste_region)
             log.debug(f"Blend size: {blend.size} | kind {blend.mode}")
-            log.debug(
-                f"Crop image size: {crop_img.size} | kind {crop_img.mode}"
-            )
+            log.debug(f"Crop image size: {crop_img.size} | kind {crop_img.mode}")
             log.debug(f"BBox: {paste_region}")
             blend.paste(crop_img, paste_region)
 
             mask = mask.filter(ImageFilter.BoxBlur(radius=blend_ratio / 4))
-            mask = mask.filter(
-                ImageFilter.GaussianBlur(radius=blend_ratio / 4)
-            )
+            mask = mask.filter(ImageFilter.GaussianBlur(radius=blend_ratio / 4))
 
             blend.putalpha(mask)
             img = Image.alpha_composite(img.convert("RGBA"), blend)
@@ -324,4 +285,4 @@ class MTB_Uncrop:
         return (pil2tensor(out_images),)
 
 
-__nodes__ = [MTB_BboxFromMask, MTB_Bbox, MTB_Crop, MTB_Uncrop]
+__nodes__ = [BboxFromMask, Bbox, Crop, Uncrop]

nodes/curve.py

@@ -1,93 +0,0 @@
-import json
-
-from ..log import log
-
-
-def deserialize_curve(curve):
-    if isinstance(curve, str):
-        curve = json.loads(curve)
-    return curve
-
-
-def serialize_curve(curve):
-    if not isinstance(curve, str):
-        curve = json.dumps(curve)
-    return curve
-
-
-class MTB_Curve:
-    """A basic FLOAT_CURVE input node."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "curve": ("FLOAT_CURVE",),
-            },
-        }
-
-    RETURN_TYPES = ("FLOAT_CURVE",)
-    FUNCTION = "do_curve"
-
-    CATEGORY = "mtb/curve"
-
-    def do_curve(self, curve):
-        log.debug(f"Curve: {curve}")
-        return (curve,)
-
-
-class MTB_CurveToFloat:
-    """Convert a FLOAT_CURVE to a FLOAT or FLOATS"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "curve": ("FLOAT_CURVE", {"forceInput": True}),
-                "steps": ("INT", {"default": 10, "min": 2}),
-            },
-        }
-
-    RETURN_TYPES = ("FLOATS", "FLOAT")
-    FUNCTION = "do_curve"
-
-    CATEGORY = "mtb/curve"
-
-    def do_curve(self, curve, steps):
-        log.debug(f"Curve: {curve}")
-
-        # sort by x (should be handled by the widget)
-        sorted_points = sorted(curve.items(), key=lambda item: item[1]["x"])
-        # Extract X and Y values
-        x_values = [point[1]["x"] for point in sorted_points]
-        y_values = [point[1]["y"] for point in sorted_points]
-        # Calculate step size
-        step_size = (max(x_values) - min(x_values)) / (steps - 1)
-
-        # Interpolate Y values for each step
-        interpolated_y_values = []
-        for step in range(steps):
-            current_x = min(x_values) + step_size * step
-
-            # Find the indices of the two points between which the current_x falls
-            idx1 = max(idx for idx, x in enumerate(x_values) if x <= current_x)
-            idx2 = min(idx for idx, x in enumerate(x_values) if x >= current_x)
-
-            # If the current_x matches one of the points, no interpolation is needed
-            if current_x == x_values[idx1]:
-                interpolated_y_values.append(y_values[idx1])
-            elif current_x == x_values[idx2]:
-                interpolated_y_values.append(y_values[idx2])
-            else:
-                # Interpolate Y value using linear interpolation
-                y1 = y_values[idx1]
-                y2 = y_values[idx2]
-                x1 = x_values[idx1]
-                x2 = x_values[idx2]
-                interpolated_y = y1 + (y2 - y1) * (current_x - x1) / (x2 - x1)
-                interpolated_y_values.append(interpolated_y)
-
-        return (interpolated_y_values, interpolated_y_values)
-
-
-__nodes__ = [MTB_Curve, MTB_CurveToFloat]

nodes/debug.py

@@ -1,133 +1,64 @@
-import base64
-import io
-import json
-from pathlib import Path
-from typing import Optional
-
-import folder_paths
-import torch
-
-from ..log import log
 from ..utils import tensor2pil
+from ..log import log
+import io, base64
+import torch
+import folder_paths
+from typing import Optional
+from pathlib import Path
 
 
-# region processors
-def process_tensor(tensor):
-    log.debug(f"Tensor: {tensor.shape}")
-
-    image = tensor2pil(tensor)
-    b64_imgs = []
-    for im in image:
-        buffered = io.BytesIO()
-        im.save(buffered, format="PNG")
-        b64_imgs.append(
-            "data:image/png;base64,"
-            + base64.b64encode(buffered.getvalue()).decode("utf-8")
-        )
-
-    return {"b64_images": b64_imgs}
-
-
-def process_list(anything):
-    text = []
-    if not anything:
-        return {"text": []}
-
-    first_element = anything[0]
-    if (
-        isinstance(first_element, list)
-        and first_element
-        and isinstance(first_element[0], torch.Tensor)
-    ):
-        text.append(
-            "List of List of Tensors: "
-            f"{first_element[0].shape} (x{len(anything)})"
-        )
-
-    elif isinstance(first_element, torch.Tensor):
-        text.append(
-            f"List of Tensors: {first_element.shape} (x{len(anything)})"
-        )
-    else:
-        text.append(f"Array ({len(anything)}): {anything}")
-
-    return {"text": text}
-
-
-def process_dict(anything):
-    text = []
-    if "samples" in anything:
-        is_empty = (
-            "(empty)" if torch.count_nonzero(anything["samples"]) == 0 else ""
-        )
-        text.append(f"Latent Samples: {anything['samples'].shape} {is_empty}")
-
-    else:
-        text.append(json.dumps(anything, indent=2))
-
-    return {"text": text}
-
-
-def process_bool(anything):
-    return {"text": ["True" if anything else "False"]}
-
-
-def process_text(anything):
-    return {"text": [str(anything)]}
-
-
-# endregion
-
-
-class MTB_Debug:
-    """Experimental node to debug any Comfy values.
-
-    support for more types and widgets is planned.
-    """
+class Debug:
+    """Experimental node to debug any Comfy values, support for more types and widgets is planned"""
 
     @classmethod
     def INPUT_TYPES(cls):
         return {
-            "required": {"output_to_console": ("BOOLEAN", {"default": False})},
+            "required": {"anything_1": ("*")},
         }
 
-    RETURN_TYPES = ()
+    RETURN_TYPES = ("STRING",)
     FUNCTION = "do_debug"
     CATEGORY = "mtb/debug"
     OUTPUT_NODE = True
 
-    def do_debug(self, output_to_console: bool, **kwargs):
+    def do_debug(self, **kwargs):
         output = {
             "ui": {"b64_images": [], "text": []},
-            # "result": ("A"),
+            "result": ("A"),
         }
+        for k, v in kwargs.items():
+            anything = v
+            text = ""
+            if isinstance(anything, torch.Tensor):
+                log.debug(f"Tensor: {anything.shape}")
 
-        processors = {
-            torch.Tensor: process_tensor,
-            list: process_list,
-            dict: process_dict,
-            bool: process_bool,
-        }
-        if output_to_console:
-            for k, v in kwargs.items():
-                log.info(f"{k}: {v}")
+                # write the images to temp
 
-        for anything in kwargs.values():
-            processor = processors.get(type(anything), process_text)
+                image = tensor2pil(anything)
+                b64_imgs = []
+                for im in image:
+                    buffered = io.BytesIO()
+                    im.save(buffered, format="PNG")
+                    b64_imgs.append(
+                        "data:image/png;base64,"
+                        + base64.b64encode(buffered.getvalue()).decode("utf-8")
+                    )
 
-            processed_data = processor(anything)
-
-            for ui_key, ui_value in processed_data.items():
-                output["ui"][ui_key].extend(ui_value)
+                output["ui"]["b64_images"] += b64_imgs
+                log.debug(f"Input {k} contains {len(b64_imgs)} images")
+            elif isinstance(anything, bool):
+                log.debug(f"Input {k} contains boolean: {anything}")
+                output["ui"]["text"] += ["True" if anything else "False"]
+            else:
+                text = str(anything)
+                log.debug(f"Input {k} contains text: {text}")
+                output["ui"]["text"] += [text]
 
         return output
 
 
-class MTB_SaveTensors:
-    """Save torch tensors (image, mask or latent) to disk.
-
-    useful to debug things outside comfy.
-    """
+class SaveTensors:
+    """Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy"""
 
     def __init__(self):
         self.output_dir = folder_paths.get_output_directory()
@@ -182,10 +113,9 @@ class MTB_SaveTensors:
             torch.save(latent, full_output_folder / latent_file)
             # pickle.dump(latent, open(full_output_folder/ latent_file, "wb"))
 
-            # np.save(full_output_folder / latent_file,
-            # latent[""].cpu().numpy())
+            # np.save(full_output_folder/ latent_file, latent[""].cpu().numpy())
 
         return f"{filename_prefix}_{counter:05}"
 
 
-__nodes__ = [MTB_Debug, MTB_SaveTensors]
+__nodes__ = [Debug, SaveTensors]

nodes/deep_bump.py

@@ -1,49 +1,23 @@
-import tempfile
-from pathlib import Path
-
-import numpy as np
 import onnxruntime as ort
-import torch
-from PIL import Image
-
-from ..errors import ModelNotFound
-from ..log import mklog
-from ..utils import (
-    get_model_path,
-    tensor2pil,
-    tiles_infer,
-    tiles_merge,
-    tiles_split,
-)
+import numpy as np
+import pathlib
+import onnxruntime as ort
+import numpy as np
+from .. import utils as utils_inference
+from ..log import log
 
 # Disable MS telemetry
 ort.disable_telemetry_events()
-log = mklog(__name__)
 
 
 # - COLOR to NORMALS
-def color_to_normals(
-    color_img, overlap, progress_callback, *, save_temp=False
-):
-    """Compute a normal map from the given color map.
-
-    'color_img' must be a numpy array in C,H,W format (with C as RGB).
-    'overlap' must be one of 'SMALL', 'MEDIUM', 'LARGE'.
+def color_to_normals(color_img, overlap, progress_callback):
+    """Computes a normal map from the given color map. 'color_img' must be a numpy array
+    in C,H,W format (with C as RGB). 'overlap' must be one of 'SMALL', 'MEDIUM', 'LARGE'.
     """
-    temp_dir = Path(tempfile.mkdtemp()) if save_temp else None
 
     # Remove alpha & convert to grayscale
-    img = np.mean(color_img[:3], axis=0, keepdims=True)
-
-    if temp_dir:
-        Image.fromarray((img[0] * 255).astype(np.uint8)).save(
-            temp_dir / "grayscale_img.png"
-        )
-
-    log.debug(
-        "Converting color image to grayscale by taking "
-        f"the mean over color channels: {img.shape}"
-    )
+    img = np.mean(color_img[:3], axis=0, keepdimss=True)
 
     # Split image in tiles
     log.debug("DeepBump Color → Normals : tilling")
@@ -54,105 +28,72 @@ def color_to_normals(
         "LARGE": tile_size // 2,
     }
     stride_size = tile_size - overlaps[overlap]
-    tiles, paddings = tiles_split(
+    tiles, paddings = utils_inference.tiles_split(
         img, (tile_size, tile_size), (stride_size, stride_size)
     )
-    if temp_dir:
-        for i, tile in enumerate(tiles):
-            Image.fromarray((tile[0] * 255).astype(np.uint8)).save(
-                temp_dir / f"tile_{i}.png"
-            )
 
     # Load model
     log.debug("DeepBump Color → Normals : loading model")
-    model = get_model_path("deepbump", "deepbump256.onnx")
-    if not model or not model.exists():
-        raise ModelNotFound(f"deepbump ({model})")
-
-    ort_session = ort.InferenceSession(model)
+    addon_path = str(pathlib.Path(__file__).parent.absolute())
+    ort_session = ort.InferenceSession(f"{addon_path}/models/deepbump256.onnx")
 
     # Predict normal map for each tile
     log.debug("DeepBump Color → Normals : generating")
-    pred_tiles = tiles_infer(
+    pred_tiles = utils_inference.tiles_infer(
         tiles, ort_session, progress_callback=progress_callback
     )
 
-    if temp_dir:
-        for i, pred_tile in enumerate(pred_tiles):
-            Image.fromarray(
-                (pred_tile.transpose(1, 2, 0) * 255).astype(np.uint8)
-            ).save(temp_dir / f"pred_tile_{i}.png")
-
     # Merge tiles
     log.debug("DeepBump Color → Normals : merging")
-    pred_img = tiles_merge(
+    pred_img = utils_inference.tiles_merge(
         pred_tiles,
         (stride_size, stride_size),
         (3, img.shape[1], img.shape[2]),
         paddings,
     )
 
-    if temp_dir:
-        Image.fromarray(
-            (pred_img.transpose(1, 2, 0) * 255).astype(np.uint8)
-        ).save(temp_dir / "merged_img.png")
-
     # Normalize each pixel to unit vector
-    pred_img = normalize(pred_img)
-
-    if temp_dir:
-        Image.fromarray(
-            (pred_img.transpose(1, 2, 0) * 255).astype(np.uint8)
-        ).save(temp_dir / "final_img.png")
-
-        log.debug(f"Debug images saved in {temp_dir}")
+    pred_img = utils_inference.normalize(pred_img)
 
     return pred_img
 
 
 # - NORMALS to CURVATURE
 def conv_1d(array, kernel_1d):
-    """Perform row by row 1D convolutions.
+    """Performs row by row 1D convolutions of the given 2D image with the given 1D kernel."""
 
-    of the given 2D image with the given 1D kernel.
-    """
     # Input kernel length must be odd
     k_l = len(kernel_1d)
-
     assert k_l % 2 != 0
     # Convolution is repeat-padded
     extended = np.pad(array, k_l // 2, mode="wrap")
     # Output has same size as input (padded, valid-mode convolution)
     output = np.empty(array.shape)
     for i in range(array.shape[0]):
-        output[i] = np.convolve(
-            extended[i + (k_l // 2)], kernel_1d, mode="valid"
-        )
+        output[i] = np.convolve(extended[i + (k_l // 2)], kernel_1d, mode="valid")
 
     return output * -1
 
 
 def gaussian_kernel(length, sigma):
-    """Return a 1D gaussian kernel of size 'length'."""
+    """Returns a 1D gaussian kernel of size 'length'."""
+
     space = np.linspace(-(length - 1) / 2, (length - 1) / 2, length)
     kernel = np.exp(-0.5 * np.square(space) / np.square(sigma))
     return kernel / np.sum(kernel)
 
 
 def normalize(np_array):
-    """Normalize all elements of the given numpy array to [0,1]."""
-    return (np_array - np.min(np_array)) / (
-        np.max(np_array) - np.min(np_array)
-    )
+    """Normalize all elements of the given numpy array to [0,1]"""
+
+    return (np_array - np.min(np_array)) / (np.max(np_array) - np.min(np_array))
 
 
 def normals_to_curvature(normals_img, blur_radius, progress_callback):
-    """Compute a curvature map from the given normal map.
+    """Computes a curvature map from the given normal map. 'normals_img' must be a numpy array
+    in C,H,W format (with C as RGB). 'blur_radius' must be one of 'SMALLEST', 'SMALLER', 'SMALL',
+    'MEDIUM', 'LARGE', 'LARGER', 'LARGEST'."""
 
-    'normals_img' must be a numpy array in C,H,W format (with C as RGB).
-    'blur_radius' must be one of:
-        'SMALLEST', 'SMALLER', 'SMALL', 'MEDIUM', 'LARGE', 'LARGER', 'LARGEST'.
-    """
     # Convolutions on normal map red & green channels
     if progress_callback is not None:
         progress_callback(0, 4)
@@ -177,12 +118,8 @@ def normals_to_curvature(normals_img, blur_radius, progress_callback):
         "LARGER": 1 / 8,
         "LARGEST": 1 / 4,
     }
-    if blur_radius not in blur_factors:
-        raise ValueError(f"{blur_radius} not found in {blur_factors}")
-
-    blur_radius_px = int(
-        np.mean(normals_img.shape[1:3]) * blur_factors[blur_radius]
-    )
+    assert blur_radius in blur_factors
+    blur_radius_px = int(np.mean(normals_img.shape[1:3]) * blur_factors[blur_radius])
 
     # If blur radius too small, do not blur
     if blur_radius_px < 2:
@@ -219,9 +156,8 @@ def normals_to_grad(normals_img):
 
 def copy_flip(grad_x, grad_y):
     """Concat 4 flipped copies of input gradients (makes them wrap).
+    Output is twice bigger in both dimensions."""
 
-    Output is twice bigger in both dimensions.
-    """
     grad_x_top = np.hstack([grad_x, -np.flip(grad_x, axis=1)])
     grad_x_bottom = np.hstack([np.flip(grad_x, axis=0), -np.flip(grad_x)])
     new_grad_x = np.vstack([grad_x_top, grad_x_bottom])
@@ -235,6 +171,7 @@ def copy_flip(grad_x, grad_y):
 
 def frankot_chellappa(grad_x, grad_y, progress_callback=None):
     """Frankot-Chellappa depth-from-gradient algorithm."""
+
     if progress_callback is not None:
         progress_callback(0, 3)
 
@@ -274,8 +211,8 @@ def frankot_chellappa(grad_x, grad_y, progress_callback=None):
 def normals_to_height(normals_img, seamless, progress_callback):
     """Computes a height map from the given normal map. 'normals_img' must be a numpy array
     in C,H,W format (with C as RGB). 'seamless' is a bool that should indicates if 'normals_img'
-    is seamless.
-    """
+    is seamless."""
+
     # Flip height axis
     flip_img = np.flip(normals_img, axis=1)
 
@@ -289,9 +226,7 @@ def normals_to_height(normals_img, seamless, progress_callback):
         grad_x, grad_y = copy_flip(grad_x, grad_y)
 
     # Compute height
-    pred_img = frankot_chellappa(
-        -grad_x, grad_y, progress_callback=progress_callback
-    )
+    pred_img = frankot_chellappa(-grad_x, grad_y, progress_callback=progress_callback)
 
     # Cut to valid part if gradients were expanded
     if not seamless:
@@ -303,7 +238,7 @@ def normals_to_height(normals_img, seamless, progress_callback):
 
 
 # - ADDON
-class MTB_DeepBump:
+class DeepBump:
     """Normal & height maps generation from single pictures"""
 
     @classmethod
@@ -312,11 +247,7 @@ class MTB_DeepBump:
             "required": {
                 "image": ("IMAGE",),
                 "mode": (
-                    [
-                        "Color to Normals",
-                        "Normals to Curvature",
-                        "Normals to Height",
-                    ],
+                    ["Color to Normals", "Normals to Curvature", "Normals to Height"],
                 ),
                 "color_to_normals_overlap": (["SMALL", "MEDIUM", "LARGE"],),
                 "normals_to_curvature_blur_radius": (
@@ -330,7 +261,7 @@ class MTB_DeepBump:
                         "LARGEST",
                     ],
                 ),
-                "normals_to_height_seamless": ("BOOLEAN", {"default": True}),
+                "normals_to_height_seamless": ("BOOLEAN", {"default": False}),
             },
         }
 
@@ -341,49 +272,31 @@ class MTB_DeepBump:
 
     def apply(
         self,
-        *,
         image,
         mode="Color to Normals",
         color_to_normals_overlap="SMALL",
         normals_to_curvature_blur_radius="SMALL",
         normals_to_height_seamless=True,
     ):
-        images = tensor2pil(image)
-        out_images = []
+        image = utils_inference.tensor2pil(image)
 
-        for image in images:
-            log.debug(f"Input image shape: {image}")
+        in_img = np.transpose(image, (2, 0, 1)) / 255
 
-            in_img = np.transpose(image, (2, 0, 1)) / 255
-            log.debug(f"transposed for deep image shape: {in_img.shape}")
-            out_img = None
+        log.debug(f"Input image shape: {in_img.shape}")
 
-            # Apply processing
-            if mode == "Color to Normals":
-                out_img = color_to_normals(
-                    in_img, color_to_normals_overlap, None
-                )
-            if mode == "Normals to Curvature":
-                out_img = normals_to_curvature(
-                    in_img, normals_to_curvature_blur_radius, None
-                )
-            if mode == "Normals to Height":
-                out_img = normals_to_height(
-                    in_img, normals_to_height_seamless, None
-                )
+        # Apply processing
+        if mode == "Color to Normals":
+            out_img = color_to_normals(in_img, color_to_normals_overlap, None)
+        if mode == "Normals to Curvature":
+            out_img = normals_to_curvature(
+                in_img, normals_to_curvature_blur_radius, None
+            )
+        if mode == "Normals to Height":
+            out_img = normals_to_height(in_img, normals_to_height_seamless, None)
 
-            if out_img is not None:
-                log.debug(f"Output image shape: {out_img.shape}")
-                out_images.append(
-                    torch.from_numpy(
-                        np.transpose(out_img, (1, 2, 0)).astype(np.float32)
-                    ).unsqueeze(0)
-                )
-            else:
-                log.error("No out img... This should not happen")
-        for outi in out_images:
-            log.debug(f"Shape fed to utils: {outi.shape}")
-        return (torch.cat(out_images, dim=0),)
+        out_img = (np.transpose(out_img, (1, 2, 0)) * 255).astype(np.uint8)
+
+        return (utils_inference.pil2tensor(out_img),)
 
 
-__nodes__ = [MTB_DeepBump]
+__nodes__ = [DeepBump]

nodes/faceenhance.py

@@ -1,19 +1,24 @@
+from gfpgan import GFPGANer
+import cv2
+import numpy as np
 import os
+from pathlib import Path
+import folder_paths
+from ..utils import pil2tensor, np2tensor, tensor2np
 
+from basicsr.utils import imwrite
+
+
+from PIL import Image
+import torch
+from ..log import NullWriter, log
+from comfy import model_management
 import comfy
 import comfy.utils
-import cv2
-import folder_paths
-import numpy as np
-import torch
-from comfy import model_management
-from PIL import Image
-
-from ..log import NullWriter, log
-from ..utils import get_model_path, np2tensor, pil2tensor, tensor2np
+from typing import Tuple
 
 
-class MTB_LoadFaceEnhanceModel:
+class LoadFaceEnhanceModel:
     """Loads a GFPGan or RestoreFormer model for face enhancement."""
 
     def __init__(self) -> None:
@@ -21,12 +26,11 @@ class MTB_LoadFaceEnhanceModel:
 
     @classmethod
     def get_models_root(cls):
-        fr = get_model_path("face_restore")
-        # fr = Path(folder_paths.models_dir) / "face_restore"
+        fr = Path(folder_paths.models_dir) / "face_restore"
         if fr.exists():
             return (fr, None)
 
-        um = get_model_path("upscale_models")
+        um = Path(folder_paths.models_dir) / "upscale_models"
         return (fr, um) if um.exists() else (None, None)
 
     @classmethod
@@ -34,17 +38,15 @@ class MTB_LoadFaceEnhanceModel:
         fr_models_path, um_models_path = cls.get_models_root()
 
         if fr_models_path is None and um_models_path is None:
-            if not hasattr(cls, "_warned"):
-                log.warning("Face restoration models not found.")
-                cls._warned = True
+            log.warning("Face restoration models not found.")
             return []
         if not fr_models_path.exists():
-            # log.warning(
-            #     f"No Face Restore checkpoints found at {fr_models_path} (if you've used mtb before these checkpoints were saved in upscale_models before)"
-            # )
-            # log.warning(
-            #     "For now we fallback to upscale_models but this will be removed in a future version"
-            # )
+            log.warning(
+                f"No Face Restore checkpoints found at {fr_models_path} (if you've used mtb before these checkpoints were saved in upscale_models before)"
+            )
+            log.warning(
+                "For now we fallback to upscale_models but this will be removed in a future version"
+            )
             if um_models_path.exists():
                 return [
                     x
@@ -80,8 +82,6 @@ class MTB_LoadFaceEnhanceModel:
     CATEGORY = "mtb/facetools"
 
     def load_model(self, model_name, upscale=2, bg_upsampler=None):
-        from gfpgan import GFPGANer
-
         basic = "RestoreFormer" not in model_name
 
         fr_root, um_root = self.get_models_root()
@@ -99,9 +99,7 @@ class MTB_LoadFaceEnhanceModel:
                 (fr_root if fr_root.exists() else um_root) / model_name
             ).as_posix(),
             upscale=upscale,
-            arch="clean"
-            if basic
-            else "RestoreFormer",  # or original for v1.0 only
+            arch="clean" if basic else "RestoreFormer",  # or original for v1.0 only
             channel_multiplier=2,  # 1 for v1.0 only
             bg_upsampler=bg_upsampler,
         )
@@ -125,11 +123,7 @@ class BGUpscaleWrapper:
         imgt = imgt.movedim(-1, -3).to(device)
 
         steps = imgt.shape[0] * comfy.utils.get_tiled_scale_steps(
-            imgt.shape[3],
-            imgt.shape[2],
-            tile_x=tile,
-            tile_y=tile,
-            overlap=overlap,
+            imgt.shape[3], imgt.shape[2], tile_x=tile, tile_y=tile, overlap=overlap
         )
 
         log.debug(f"Steps: {steps}")
@@ -154,7 +148,7 @@ class BGUpscaleWrapper:
 import sys
 
 
-class MTB_RestoreFace:
+class RestoreFace:
     """Uses GFPGan to restore faces"""
 
     def __init__(self) -> None:
@@ -183,7 +177,7 @@ class MTB_RestoreFace:
     def do_restore(
         self,
         image: torch.Tensor,
-        model,
+        model: GFPGANer,
         aligned,
         only_center_face,
         weight,
@@ -206,14 +200,10 @@ class MTB_RestoreFace:
         log.warning(f"Weight value has no effect for now. (value: {weight})")
 
         if save_tmp_steps:
-            self.save_intermediate_images(
-                cropped_faces, restored_faces, height, width
-            )
+            self.save_intermediate_images(cropped_faces, restored_faces, height, width)
         output = None
         if restored_img is not None:
-            output = Image.fromarray(
-                cv2.cvtColor(restored_img, cv2.COLOR_BGR2RGB)
-            )
+            output = Image.fromarray(cv2.cvtColor(restored_img, cv2.COLOR_BGR2RGB))
             # imwrite(restored_img, save_restore_path)
 
         return pil2tensor(output)
@@ -221,20 +211,15 @@ class MTB_RestoreFace:
     def restore(
         self,
         image: torch.Tensor,
-        model,
+        model: GFPGANer,
         aligned=False,
         only_center_face=False,
         weight=0.5,
         save_tmp_steps=True,
-    ) -> tuple[torch.Tensor]:
+    ) -> Tuple[torch.Tensor]:
         out = [
             self.do_restore(
-                image[i],
-                model,
-                aligned,
-                only_center_face,
-                weight,
-                save_tmp_steps,
+                image[i], model, aligned, only_center_face, weight, save_tmp_steps
             )
             for i in range(image.size(0))
         ]
@@ -256,24 +241,22 @@ class MTB_RestoreFace:
 
         return os.path.join(full_output_folder, file)
 
-    def save_intermediate_images(
-        self, cropped_faces, restored_faces, height, width
-    ):
+    def save_intermediate_images(self, cropped_faces, restored_faces, height, width):
         for idx, (cropped_face, restored_face) in enumerate(
             zip(cropped_faces, restored_faces)
         ):
             face_id = idx + 1
             file = self.get_step_image_path("cropped_faces", face_id)
-            cv2.imwrite(file, cropped_face)
+            imwrite(cropped_face, file)
 
             file = self.get_step_image_path("cropped_faces_restored", face_id)
-            cv2.imwrite(file, restored_face)
+            imwrite(restored_face, file)
 
             file = self.get_step_image_path("cropped_faces_compare", face_id)
 
             # save comparison image
             cmp_img = np.concatenate((cropped_face, restored_face), axis=1)
-            cv2.imwrite(file, cmp_img)
+            imwrite(cmp_img, file)
 
 
-__nodes__ = [MTB_RestoreFace, MTB_LoadFaceEnhanceModel]
+__nodes__ = [RestoreFace, LoadFaceEnhanceModel]

nodes/faceswap.py

@@ -1,32 +1,41 @@
-# Optional face enhance nodes
 # region imports
-import sys
+import onnxruntime
 from pathlib import Path
-from typing import List, Optional, Set, Union
-
-import comfy.model_management as model_management
+from PIL import Image
+from typing import List, Set, Union, Optional
 import cv2
+import folder_paths
+import glob
 import insightface
 import numpy as np
-import onnxruntime
+import os
 import torch
 from insightface.model_zoo.inswapper import INSwapper
-from PIL import Image
+from ..utils import pil2tensor, tensor2pil, download_antelopev2
+from ..log import mklog, NullWriter
+import sys
+import comfy.model_management as model_management
 
-from ..errors import ModelNotFound
-from ..log import NullWriter, mklog
-from ..utils import download_antelopev2, get_model_path, pil2tensor, tensor2pil
 
 # endregion
 
 log = mklog(__name__)
 
 
-class MTB_LoadFaceAnalysisModel:
+class LoadFaceAnalysisModel:
     """Loads a face analysis model"""
 
     models = []
 
+    @staticmethod
+    def get_models() -> List[str]:
+        models_path = os.path.join(folder_paths.models_dir, "insightface/*")
+        models = glob.glob(models_path)
+        models = [
+            Path(x).name for x in models if x.endswith(".onnx") or x.endswith(".pth")
+        ]
+        return models
+
     @classmethod
     def INPUT_TYPES(cls):
         return {
@@ -48,21 +57,20 @@ class MTB_LoadFaceAnalysisModel:
 
         face_analyser = insightface.app.FaceAnalysis(
             name=faceswap_model,
-            root=get_model_path("insightface").as_posix(),
+            root=os.path.join(folder_paths.models_dir, "insightface"),
         )
         return (face_analyser,)
 
 
-class MTB_LoadFaceSwapModel:
+class LoadFaceSwapModel:
     """Loads a faceswap model"""
 
     @staticmethod
-    def get_models() -> list[Path]:
-        models_path = get_model_path("insightface")
-        if models_path.exists():
-            models = models_path.iterdir()
-            return [x for x in models if x.suffix in [".onnx", ".pth"]]
-        return []
+    def get_models() -> List[Path]:
+        models_path = os.path.join(folder_paths.models_dir, "insightface/*")
+        models = glob.glob(models_path)
+        models = [Path(x) for x in models if x.endswith(".onnx") or x.endswith(".pth")]
+        return models
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -80,10 +88,9 @@ class MTB_LoadFaceSwapModel:
     CATEGORY = "mtb/facetools"
 
     def load_model(self, faceswap_model: str):
-        model_path = get_model_path("insightface", faceswap_model)
-        if not model_path or not model_path.exists():
-            raise ModelNotFound(f"{faceswap_model} ({model_path})")
-
+        model_path = os.path.join(
+            folder_paths.models_dir, "insightface", faceswap_model
+        )
         log.info(f"Loading model {model_path}")
         return (
             INSwapper(
@@ -97,7 +104,7 @@ class MTB_LoadFaceSwapModel:
 
 
 # region roop node
-class MTB_FaceSwap:
+class FaceSwap:
     """Face swap using deepinsight/insightface models"""
 
     model = None
@@ -113,10 +120,7 @@ class MTB_FaceSwap:
                 "image": ("IMAGE",),
                 "reference": ("IMAGE",),
                 "faces_index": ("STRING", {"default": "0"}),
-                "faceanalysis_model": (
-                    "FACE_ANALYSIS_MODEL",
-                    {"default": "None"},
-                ),
+                "faceanalysis_model": ("FACE_ANALYSIS_MODEL", {"default": "None"}),
                 "faceswap_model": ("FACESWAP_MODEL", {"default": "None"}),
             },
             "optional": {},
@@ -139,14 +143,10 @@ class MTB_FaceSwap:
             img = tensor2pil(img)[0]
             ref = tensor2pil(reference)[0]
             face_ids = {
-                int(x)
-                for x in faces_index.strip(",").split(",")
-                if x.isnumeric()
+                int(x) for x in faces_index.strip(",").split(",") if x.isnumeric()
             }
             sys.stdout = NullWriter()
-            swapped = swap_face(
-                faceanalysis_model, ref, img, faceswap_model, face_ids
-            )
+            swapped = swap_face(faceanalysis_model, ref, img, faceswap_model, face_ids)
             sys.stdout = sys.__stdout__
             return pil2tensor(swapped)
 
@@ -180,10 +180,7 @@ def get_face_single(
         log.debug("No face ed, trying again with smaller image")
         det_size_half = (det_size[0] // 2, det_size[1] // 2)
         return get_face_single(
-            face_analyser,
-            img_data,
-            face_index=face_index,
-            det_size=det_size_half,
+            face_analyser, img_data, face_index=face_index, det_size=det_size_half
         )
 
     try:
@@ -207,9 +204,7 @@ def swap_face(
     if face_swapper_model is not None:
         cv_source_img = cv2.cvtColor(np.array(source_img), cv2.COLOR_RGB2BGR)
         cv_target_img = cv2.cvtColor(np.array(target_img), cv2.COLOR_RGB2BGR)
-        source_face = get_face_single(
-            face_analyser, cv_source_img, face_index=0
-        )
+        source_face = get_face_single(face_analyser, cv_source_img, face_index=0)
         if source_face is not None:
             result = cv_target_img
 
@@ -219,16 +214,12 @@ def swap_face(
                 )
                 if target_face is not None:
                     sys.stdout = NullWriter()
-                    result = face_swapper_model.get(
-                        result, target_face, source_face
-                    )
+                    result = face_swapper_model.get(result, target_face, source_face)
                     sys.stdout = sys.__stdout__
                 else:
                     log.warning(f"No target face found for {face_num}")
 
-            result_image = Image.fromarray(
-                cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
-            )
+            result_image = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
         else:
             log.warning("No source face found")
     else:
@@ -239,4 +230,4 @@ def swap_face(
 # endregion face swap utils
 
 
-__nodes__ = [MTB_FaceSwap, MTB_LoadFaceSwapModel, MTB_LoadFaceAnalysisModel]
+__nodes__ = [FaceSwap, LoadFaceSwapModel, LoadFaceAnalysisModel]

nodes/filter.py

@@ -1,69 +0,0 @@
-import torch
-
-
-class MTB_FilterZ:
-    """Filters an image based on a depth map"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "depth": ("IMAGE",),
-                "to_black": ("BOOLEAN", {"default": True}),
-                "threshold": (
-                    "FLOAT",
-                    {"default": 0.5, "step": 0.01, "min": 0.0, "max": 1.0},
-                ),
-                "invert": ("BOOLEAN", {"default": True}),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "filter"
-    CATEGORY = "mtb/filters"
-
-    def filter(
-        self,
-        image: torch.Tensor,
-        depth: torch.Tensor,
-        to_black,
-        threshold: float,
-        invert,
-    ):
-        # Normalize depth map to be in range [0, 1]
-        depth_normalized = (depth - depth.min()) / (depth.max() - depth.min())
-
-        # Calculate the difference from the threshold
-        diff_from_threshold = torch.abs(depth_normalized - threshold)
-
-        out_img = None
-
-        if to_black:
-            if invert:
-                soft_mask = diff_from_threshold >= threshold
-            else:
-                soft_mask = diff_from_threshold <= threshold
-
-            out_img = image.clone()
-            out_img[soft_mask] = 0
-            return (out_img,)
-        else:
-            alpha_channel = 1 - diff_from_threshold / threshold
-            alpha_channel = torch.clamp(alpha_channel, 0, 1)
-
-            if invert:
-                # Invert the alpha channel
-                alpha_channel = 1 - alpha_channel
-
-            # Ensure alpha_channel has the correct shape
-            # It should have the shape [batch_size, height, width, 1]
-            alpha_channel = alpha_channel.unsqueeze(-1)
-
-            # Combine RGB channels with alpha channel
-            out_img = torch.cat((image, alpha_channel), dim=-1)
-
-        return (out_img,)
-
-
-__nodes__ = [MTB_FilterZ]

nodes/generate.py

@@ -1,8 +1,9 @@
 import qrcode
+from ..utils import pil2tensor
+from ..utils import comfy_dir
+from typing import cast
 from PIL import Image
-
 from ..log import log
-from ..utils import comfy_dir, font_path, pil2tensor
 
 # class MtbExamples:
 #     """MTB Example Images"""
@@ -52,25 +53,16 @@ from ..utils import comfy_dir, font_path, pil2tensor
 #         return m.digest().hex()
 
 
-class MTB_UnsplashImage:
+class UnsplashImage:
     """Unsplash Image given a keyword and a size"""
 
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "width": (
-                    "INT",
-                    {"default": 512, "max": 8096, "min": 0, "step": 1},
-                ),
-                "height": (
-                    "INT",
-                    {"default": 512, "max": 8096, "min": 0, "step": 1},
-                ),
-                "random_seed": (
-                    "INT",
-                    {"default": 0, "max": 1e5, "min": 0, "step": 1},
-                ),
+                "width": ("INT", {"default": 512, "max": 8096, "min": 0, "step": 1}),
+                "height": ("INT", {"default": 512, "max": 8096, "min": 0, "step": 1}),
+                "random_seed": ("INT", {"default": 0, "max": 1e5, "min": 0, "step": 1}),
             },
             "optional": {
                 "keyword": ("STRING", {"default": "nature"}),
@@ -82,9 +74,8 @@ class MTB_UnsplashImage:
     CATEGORY = "mtb/generate"
 
     def do_unsplash_image(self, width, height, random_seed, keyword=None):
-        import io
-
         import requests
+        import io
 
         base_url = "https://source.unsplash.com/random/"
 
@@ -113,7 +104,7 @@ class MTB_UnsplashImage:
             return (None,)
 
 
-class MTB_QrCode:
+class QrCode:
     """Basic QR Code generator"""
 
     @classmethod
@@ -130,14 +121,8 @@ class MTB_QrCode:
                     {"default": 256, "max": 8096, "min": 0, "step": 1},
                 ),
                 "error_correct": (("L", "M", "Q", "H"), {"default": "L"}),
-                "box_size": (
-                    "INT",
-                    {"default": 10, "max": 8096, "min": 0, "step": 1},
-                ),
-                "border": (
-                    "INT",
-                    {"default": 4, "max": 8096, "min": 0, "step": 1},
-                ),
+                "box_size": ("INT", {"default": 10, "max": 8096, "min": 0, "step": 1}),
+                "border": ("INT", {"default": 4, "max": 8096, "min": 0, "step": 1}),
                 "invert": (("BOOLEAN",), {"default": False}),
             }
         }
@@ -146,9 +131,7 @@ class MTB_QrCode:
     FUNCTION = "do_qr"
     CATEGORY = "mtb/generate"
 
-    def do_qr(
-        self, url, width, height, error_correct, box_size, border, invert
-    ):
+    def do_qr(self, url, width, height, error_correct, box_size, border, invert):
         log.warning(
             "This node will soon be deprecated, there are much better alternatives like https://github.com/coreyryanhanson/comfy-qr"
         )
@@ -173,9 +156,7 @@ class MTB_QrCode:
         back_color = (255, 255, 255) if invert else (0, 0, 0)
         fill_color = (0, 0, 0) if invert else (255, 255, 255)
 
-        code = img = qr.make_image(
-            back_color=back_color, fill_color=fill_color
-        )
+        code = img = qr.make_image(back_color=back_color, fill_color=fill_color)
 
         # that we now resize without filtering
         code = code.resize((width, height), Image.NEAREST)
@@ -190,46 +171,37 @@ def bbox_dim(bbox):
     return width, height
 
 
-# TODO: Auto install the base font to ComfyUI/fonts
+class TextToImage:
+    """Utils to convert text to image using a font
 
 
-class MTB_TextToImage:
-    """Utils to convert text to image using a font.
-
     The tool looks for any .ttf file in the Comfy folder hierarchy.
     """
 
     fonts = {}
-    DESCRIPTION = """# Text to Image
-
-This node look for any font files in comfy_dir/fonts.  
-by default it fallsback to a default font.
-
-![img](https://i.imgur.com/3GT92hy.gif)
-"""
 
     def __init__(self):
-        # - This is executed when the graph is executed,
-        # - we could conditionaly reload fonts there
+        # - This is executed when the graph is executed, we could conditionaly reload fonts there
         pass
 
     @classmethod
     def CACHE_FONTS(cls):
         font_extensions = ["*.ttf", "*.otf", "*.woff", "*.woff2", "*.eot"]
-        fonts = [font_path]
+        fonts = []
 
         for extension in font_extensions:
-            try:
-                if comfy_dir.exists():
-                    fonts.extend(comfy_dir.glob(f"fonts/**/{extension}"))
-                else:
-                    log.warn(f"Directory {comfy_dir} does not exist.")
-            except Exception as e:
-                log.error(f"Error during font caching: {e}")
+            fonts.extend(comfy_dir.glob(f"**/{extension}"))
+
+        if not fonts:
+            log.warn(
+                "> No fonts found in the comfy folder, place at least one font file somewhere in ComfyUI's hierarchy"
+            )
+        else:
+            log.debug(f"> Found {len(fonts)} fonts")
 
         for font in fonts:
             log.debug(f"Adding font {font}")
-            MTB_TextToImage.fonts[font.stem] = font.as_posix()
+            cls.fonts[font.stem] = font.as_posix()
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -244,15 +216,13 @@ by default it fallsback to a default font.
                     {"default": "Hello world!"},
                 ),
                 "font": ((sorted(cls.fonts.keys())),),
-                "wrap": ("BOOLEAN", {"default": True}),
-                "trim": ("BOOLEAN", {"default": True}),
-                "line_height": (
-                    "FLOAT",
-                    {"default": 1.0, "min": 0, "step": 0.1},
+                "wrap": (
+                    "INT",
+                    {"default": 120, "min": 0, "max": 8096, "step": 1},
                 ),
                 "font_size": (
                     "INT",
-                    {"default": 32, "min": 1, "max": 2500, "step": 1},
+                    {"default": 12, "min": 1, "max": 2500, "step": 1},
                 ),
                 "width": (
                     "INT",
@@ -262,6 +232,7 @@ by default it fallsback to a default font.
                     "INT",
                     {"default": 512, "min": 1, "max": 8096, "step": 1},
                 ),
+                # "position": (["INT"], {"default": 0, "min": 0, "max": 100, "step": 1}),
                 "color": (
                     "COLOR",
                     {"default": "black"},
@@ -270,20 +241,6 @@ by default it fallsback to a default font.
                     "COLOR",
                     {"default": "white"},
                 ),
-                "h_align": (("left", "center", "right"), {"default": "left"}),
-                "v_align": (("top", "center", "bottom"), {"default": "top"}),
-                "h_offset": (
-                    "INT",
-                    {"default": 0, "min": 0, "max": 8096, "step": 1},
-                ),
-                "v_offset": (
-                    "INT",
-                    {"default": 0, "min": 0, "max": 8096, "step": 1},
-                ),
-                "h_coverage": (
-                    "INT",
-                    {"default": 100, "min": 1, "max": 100, "step": 1},
-                ),
             }
         }
 
@@ -293,79 +250,37 @@ by default it fallsback to a default font.
     CATEGORY = "mtb/generate"
 
     def text_to_image(
-        self,
-        text: str,
-        font,
-        wrap,
-        trim,
-        line_height,
-        font_size,
-        width,
-        height,
-        color,
-        background,
-        h_align="left",
-        v_align="top",
-        h_offset=0,
-        v_offset=0,
-        h_coverage=100,
+        self, text, font, wrap, font_size, width, height, color, background
     ):
+        from PIL import Image, ImageDraw, ImageFont
         import textwrap
 
-        from PIL import Image, ImageDraw, ImageFont
-
-        font_path = self.fonts[font]
-
-        text = (
-            text.encode("ascii", "ignore").decode().strip() if trim else text
-        )
-        # Handle word wrapping
-        if wrap:
-            wrap_width = (((width / 100) * h_coverage) / font_size) * 2
-            lines = textwrap.wrap(text, width=wrap_width)
-        else:
-            lines = [text]
-        font = ImageFont.truetype(font_path, size=font_size)
+        font = self.fonts[font]
+        font = cast(ImageFont.FreeTypeFont, ImageFont.truetype(font, font_size))
+        if wrap == 0:
+            wrap = width / font_size
+        lines = textwrap.wrap(text, width=wrap)
         log.debug(f"Lines: {lines}")
-        img = Image.new("RGBA", (width, height), background)
+        line_height = bbox_dim(font.getbbox("hg"))[1]
+        img_height = height  # line_height * len(lines)
+        img_width = width  # max(font.getsize(line)[0] for line in lines)
+
+        img = Image.new("RGBA", (img_width, img_height), background)
         draw = ImageDraw.Draw(img)
-
-        line_height_px = line_height * font_size
-
-        # Vertical alignment
-        if v_align == "top":
-            y_text = v_offset
-        elif v_align == "center":
-            y_text = ((height - (line_height_px * len(lines))) // 2) + v_offset
-        else:  # bottom
-            y_text = (height - (line_height_px * len(lines))) - v_offset
-
-        def get_width(line):
-            if hasattr(font, "getsize"):
-                return font.getsize(line)[0]
-            else:
-                return font.getlength(line)
-
-        # Draw each line of text
+        y_text = 0
+        # - bbox is [left, upper, right, lower]
         for line in lines:
-            line_width = get_width(line)
-            # Horizontal alignment
-            if h_align == "left":
-                x_text = h_offset
-            elif h_align == "center":
-                x_text = ((width - line_width) // 2) + h_offset
-            else:  # right
-                x_text = (width - line_width) - h_offset
-
-            draw.text((x_text, y_text), line, fill=color, font=font)
-            y_text += line_height_px
+            width, height = bbox_dim(font.getbbox(line))
+            draw.text((0, y_text), line, color, font=font)
+            y_text += height
 
+        # img.save(os.path.join(folder_paths.base_path, f'{str(uuid.uuid4())}.png'))
         return (pil2tensor(img),)
 
 
 __nodes__ = [
-    MTB_QrCode,
-    MTB_UnsplashImage,
-    MTB_TextToImage,
+    QrCode,
+    UnsplashImage,
+    TextToImage
     #  MtbExamples,
 ]

nodes/graph_utils.py

@@ -1,332 +1,29 @@
-import io
-import json
-import urllib.parse
-import urllib.request
-from math import pi
-from typing import Optional
-
-import comfy.model_management as model_management
-import comfy.utils
-import numpy as np
-import torch
-import torchvision.transforms.functional as F
-from PIL import Image
-
 from ..log import log
-from ..utils import (
-    EASINGS,
-    apply_easing,
-    get_server_info,
-    numpy_NFOV,
-    pil2tensor,
-    tensor2np,
-)
+from PIL import Image
+import urllib.request
+import urllib.parse
+import torch
+import json
+from comfy.cli_args import args
+from ..utils import pil2tensor, apply_easing
+import io
+import numpy as np
 
 
 def get_image(filename, subfolder, folder_type):
-    log.debug(
-        f"Getting image {filename} from foldertype {folder_type} {f'in subfolder: {subfolder}' if subfolder else ''}"
-    )
+    log.debug(f"Getting image {filename} from {subfolder} of {folder_type}")
     data = {"filename": filename, "subfolder": subfolder, "type": folder_type}
-    base_url, port = get_server_info()
-
     url_values = urllib.parse.urlencode(data)
-    url = f"http://{base_url}:{port}/view?{url_values}"
-    log.debug(f"Fetching image from {url}")
-    with urllib.request.urlopen(url) as response:
+    with urllib.request.urlopen(
+        f"http://{args.listen}:{args.port}/view?{url_values}"
+    ) as response:
         return io.BytesIO(response.read())
 
 
-class MTB_ToDevice:
-    """Send a image or mask tensor to the given device."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        devices = ["cpu"]
-        if torch.backends.mps.is_available():
-            devices.append("mps")
-        if torch.cuda.is_available():
-            devices.append("cuda")
-            for i in range(torch.cuda.device_count()):
-                devices.append(f"cuda{i}")
-
-        return {
-            "required": {
-                "ignore_errors": ("BOOLEAN", {"default": False}),
-                "device": (devices, {"default": "cpu"}),
-            },
-            "optional": {
-                "image": ("IMAGE",),
-                "mask": ("MASK",),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE", "MASK")
-    RETURN_NAMES = ("images", "masks")
-    CATEGORY = "mtb/utils"
-    FUNCTION = "to_device"
-
-    def to_device(
-        self,
-        *,
-        ignore_errors=False,
-        device="cuda",
-        image: Optional[torch.Tensor] = None,
-        mask: Optional[torch.Tensor] = None,
-    ):
-        if not ignore_errors and image is None and mask is None:
-            raise ValueError(
-                "You must either provide an image or a mask,"
-                " use ignore_error to passthrough"
-            )
-        if image is not None:
-            image = image.to(device)
-        if mask is not None:
-            mask = mask.to(device)
-        return (image, mask)
-
-
-# class MTB_ApplyTextTemplate:
-class MTB_ApplyTextTemplate:
-    """
-    Experimental node to interpolate strings from inputs.
-
-    Interpolation just requires {}, for instance:
-
-    Some string {var_1} and {var_2}
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "template": ("STRING", {"default": "", "multiline": True}),
-            },
-        }
-
-    RETURN_TYPES = ("STRING",)
-    RETURN_NAMES = ("string",)
-    CATEGORY = "mtb/utils"
-    FUNCTION = "execute"
-
-    def execute(self, *, template: str, **kwargs):
-        res = f"{template}"
-        for k, v in kwargs.items():
-            res = res.replace(f"{{{k}}}", f"{v}")
-
-        return (res,)
-
-
-class MTB_MatchDimensions:
-    """Match images dimensions along the given dimension, preserving aspect ratio."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "source": ("IMAGE",),
-                "reference": ("IMAGE",),
-                "match": (["height", "width"], {"default": "height"}),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE", "INT", "INT")
-    RETURN_NAMES = ("image", "new_width", "new_height")
-    CATEGORY = "mtb/utils"
-    FUNCTION = "execute"
-
-    def execute(
-        self, source: torch.Tensor, reference: torch.Tensor, match: str
-    ):
-        _batch_size, height, width, _channels = source.shape
-        _rbatch_size, rheight, rwidth, _rchannels = reference.shape
-
-        source_aspect_ratio = width / height
-        # reference_aspect_ratio = rwidth / rheight
-
-        source = source.permute(0, 3, 1, 2)
-        reference = reference.permute(0, 3, 1, 2)
-
-        if match == "height":
-            new_height = rheight
-            new_width = int(rheight * source_aspect_ratio)
-        else:
-            new_width = rwidth
-            new_height = int(rwidth / source_aspect_ratio)
-
-        resized_images = [
-            F.resize(
-                source[i],
-                (new_height, new_width),
-                antialias=True,
-                interpolation=Image.BICUBIC,
-            )
-            for i in range(_batch_size)
-        ]
-        resized_source = torch.stack(resized_images, dim=0)
-        resized_source = resized_source.permute(0, 2, 3, 1)
-
-        return (resized_source, new_width, new_height)
-
-
-class MTB_FloatToFloats:
-    """Conversion utility for compatibility with other extensions (AD, IPA, Fitz are using FLOAT to represent list of floats.)"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "float": ("FLOAT", {"default": 0.0, "forceInput": True}),
-            }
-        }
-
-    RETURN_TYPES = ("FLOATS",)
-    RETURN_NAMES = ("floats",)
-    CATEGORY = "mtb/utils"
-    FUNCTION = "convert"
-
-    def convert(self, float: float):
-        return (float,)
-
-
-class MTB_FloatsToInts:
-    """Conversion utility for compatibility with frame interpolation."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "floats": ("FLOATS", {"forceInput": True}),
-            }
-        }
-
-    RETURN_TYPES = ("INTS", "INT")
-    CATEGORY = "mtb/utils"
-    FUNCTION = "convert"
-
-    def convert(self, floats: list[float]):
-        vals = [int(x) for x in floats]
-        return (vals, vals)
-
-
-class MTB_FloatsToFloat:
-    """Conversion utility for compatibility with other extensions (AD, IPA, Fitz are using FLOAT to represent list of floats.)"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "floats": ("FLOATS",),
-            }
-        }
-
-    RETURN_TYPES = ("FLOAT",)
-    RETURN_NAMES = ("float",)
-    CATEGORY = "mtb/utils"
-    FUNCTION = "convert"
-
-    def convert(self, floats):
-        return (floats,)
-
-
-class MTB_AutoPanEquilateral:
-    """Generate a 360 panning video from an equilateral image."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "equilateral_image": ("IMAGE",),
-                "fovX": ("FLOAT", {"default": 45.0}),
-                "fovY": ("FLOAT", {"default": 45.0}),
-                "elevation": ("FLOAT", {"default": 0.5}),
-                "frame_count": ("INT", {"default": 100}),
-                "width": ("INT", {"default": 768}),
-                "height": ("INT", {"default": 512}),
-            },
-            "optional": {
-                "floats_fovX": ("FLOATS",),
-                "floats_fovY": ("FLOATS",),
-                "floats_elevation": ("FLOATS",),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    RETURN_NAMES = ("image",)
-    CATEGORY = "mtb/utils"
-    FUNCTION = "generate_frames"
-
-    def check_floats(self, f: list[float] | None, expected_count: int):
-        if f:
-            if len(f) == expected_count:
-                return True
-            return False
-        return True
-
-    def generate_frames(
-        self,
-        equilateral_image: torch.Tensor,
-        fovX: float,
-        fovY: float,
-        elevation: float,
-        frame_count: int,
-        width: int,
-        height: int,
-        floats_fovX: list[float] | None = None,
-        floats_fovY: list[float] | None = None,
-        floats_elevation: list[float] | None = None,
-    ):
-        source = tensor2np(equilateral_image)
-
-        if len(source) > 1:
-            log.warn(
-                "You provided more than one image in the equilateral_image input, only the first will be used."
-            )
-        if not all(
-            [
-                self.check_floats(x, frame_count)
-                for x in [floats_fovX, floats_fovY, floats_elevation]
-            ]
-        ):
-            raise ValueError(
-                "You provided less than the expected number of fovX, fovY, or elevation values."
-            )
-
-        source = source[0]
-        frames = []
-
-        pbar = comfy.utils.ProgressBar(frame_count)
-        for i in range(frame_count):
-            rotation_angle = (i / frame_count) * 2 * pi
-
-            if floats_elevation:
-                elevation = floats_elevation[i]
-
-            if floats_fovX:
-                fovX = floats_fovX[i]
-
-            if floats_fovY:
-                fovY = floats_fovY[i]
-
-            fov = [fovX / 100, fovY / 100]
-            center_point = [rotation_angle / (2 * pi), elevation]
-
-            nfov = numpy_NFOV(fov, height, width)
-            frame = nfov.to_nfov(source, center_point=center_point)
-
-            frames.append(frame)
-
-            model_management.throw_exception_if_processing_interrupted()
-            pbar.update(1)
-
-        return (pil2tensor(frames),)
-
-
-class MTB_GetBatchFromHistory:
+class GetBatchFromHistory:
     """Very experimental node to load images from the history of the server.
 
-    Queue items without output are ignored in the count.
-    """
+    Queue items without output are ignored in the count."""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -349,7 +46,6 @@ class MTB_GetBatchFromHistory:
 
     def load_from_history(
         self,
-        *,
         enable=True,
         count=0,
         offset=0,
@@ -364,18 +60,10 @@ class MTB_GetBatchFromHistory:
             return (torch.zeros(0),)
         frames = []
 
-        base_url, port = get_server_info()
-
-        history_url = f"http://{base_url}:{port}/history"
-        log.debug(f"Fetching history from {history_url}")
-        output = torch.zeros(0)
-        with urllib.request.urlopen(history_url) as response:
-            output = self.load_batch_frames(response, offset, count, frames)
-
-        if output.size(0) == 0:
-            log.warn("No output found in history")
-
-        return (output,)
+        with urllib.request.urlopen(
+            f"http://{args.listen}:{args.port}/history"
+        ) as response:
+            return self.load_batch_frames(response, offset, count, frames)
 
     def load_batch_frames(self, response, offset, count, frames):
         history = json.loads(response.read())
@@ -387,14 +75,12 @@ class MTB_GetBatchFromHistory:
                 if "images" in node_output:
                     for image in node_output["images"]:
                         image_data = get_image(
-                            image["filename"],
-                            image["subfolder"],
-                            image["type"],
+                            image["filename"], image["subfolder"], image["type"]
                         )
                         output_images.append(image_data)
 
         if not output_images:
-            return torch.zeros(0)
+            return (torch.zeros(0),)
 
         # Directly get desired range of images
         start_index = max(len(output_images) - offset - count, 0)
@@ -404,15 +90,17 @@ class MTB_GetBatchFromHistory:
         frames = [Image.open(image) for image in selected_images]
 
         if not frames:
-            return torch.zeros(0)
+            return (torch.zeros(0),)
         elif len(frames) != count:
             log.warning(f"Expected {count} images, got {len(frames)} instead")
 
-        return pil2tensor(frames)
+        output = pil2tensor(frames)
+
+        return (output,)
 
 
-class MTB_AnyToString:
-    """Tries to take any input and convert it to a string."""
+class AnyToString:
+    """Tries to take any input and convert it to a string"""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -432,22 +120,18 @@ class MTB_AnyToString:
         elif isinstance(input, Image.Image):
             return (f"PIL Image of size {input.size} and mode {input.mode}",)
         elif isinstance(input, np.ndarray):
-            return (
-                f"Numpy array of shape {input.shape} and dtype {input.dtype}",
-            )
+            return (f"Numpy array of shape {input.shape} and dtype {input.dtype}",)
 
         elif isinstance(input, dict):
-            return (
-                f"Dictionary of {len(input)} items, with keys {input.keys()}",
-            )
+            return (f"Dictionary of {len(input)} items, with keys {input.keys()}",)
 
         else:
             log.debug(f"Falling back to string conversion of {input}")
             return (str(input),)
 
 
-class MTB_StringReplace:
-    """Basic string replacement."""
+class StringReplace:
+    """Basic string replacement"""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -475,54 +159,7 @@ class MTB_StringReplace:
         return (string,)
 
 
-class MTB_MathExpression:
-    """Node to evaluate a simple math expression string"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "expression": ("STRING", {"default": "", "multiline": True}),
-            }
-        }
-
-    FUNCTION = "eval_expression"
-    RETURN_TYPES = ("FLOAT", "INT")
-    RETURN_NAMES = ("result (float)", "result (int)")
-    CATEGORY = "mtb/math"
-    DESCRIPTION = (
-        "evaluate a simple math expression string (!! Fallsback to eval)"
-    )
-
-    def eval_expression(self, expression, **kwargs):
-        from ast import literal_eval
-
-        for key, value in kwargs.items():
-            print(f"Replacing placeholder <{key}> with value {value}")
-            expression = expression.replace(f"<{key}>", str(value))
-
-        result = -1
-        try:
-            result = literal_eval(expression)
-        except SyntaxError as e:
-            raise ValueError(
-                f"The expression syntax is wrong '{expression}': {e}"
-            ) from e
-
-        except ValueError:
-            try:
-                expression = expression.replace("^", "**")
-                result = eval(expression)
-            except Exception as e:
-                # Handle any other exceptions and provide a meaningful error message
-                raise ValueError(
-                    f"Error evaluating expression '{expression}': {e}"
-                ) from e
-
-        return (result, int(result))
-
-
-class MTB_FitNumber:
+class FitNumber:
     """Fit the input float using a source and target range"""
 
     @classmethod
@@ -531,12 +168,35 @@ class MTB_FitNumber:
             "required": {
                 "value": ("FLOAT", {"default": 0, "forceInput": True}),
                 "clamp": ("BOOLEAN", {"default": False}),
-                "source_min": ("FLOAT", {"default": 0.0, "step": 0.01}),
-                "source_max": ("FLOAT", {"default": 1.0, "step": 0.01}),
-                "target_min": ("FLOAT", {"default": 0.0, "step": 0.01}),
-                "target_max": ("FLOAT", {"default": 1.0, "step": 0.01}),
+                "source_min": ("FLOAT", {"default": 0.0}),
+                "source_max": ("FLOAT", {"default": 1.0}),
+                "target_min": ("FLOAT", {"default": 0.0}),
+                "target_max": ("FLOAT", {"default": 1.0}),
                 "easing": (
-                    EASINGS,
+                    [
+                        "Linear",
+                        "Sine In",
+                        "Sine Out",
+                        "Sine In/Out",
+                        "Quart In",
+                        "Quart Out",
+                        "Quart In/Out",
+                        "Cubic In",
+                        "Cubic Out",
+                        "Cubic In/Out",
+                        "Circ In",
+                        "Circ Out",
+                        "Circ In/Out",
+                        "Back In",
+                        "Back Out",
+                        "Back In/Out",
+                        "Elastic In",
+                        "Elastic Out",
+                        "Elastic In/Out",
+                        "Bounce In",
+                        "Bounce Out",
+                        "Bounce In/Out",
+                    ],
                     {"default": "Linear"},
                 ),
             }
@@ -545,7 +205,6 @@ class MTB_FitNumber:
     FUNCTION = "set_range"
     RETURN_TYPES = ("FLOAT",)
     CATEGORY = "mtb/math"
-    DESCRIPTION = "Fit the input float using a source and target range"
 
     def set_range(
         self,
@@ -557,60 +216,20 @@ class MTB_FitNumber:
         target_max: float,
         easing: str,
     ):
-        if source_min == source_max:
-            normalized_value = 0
-        else:
-            normalized_value = (value - source_min) / (source_max - source_min)
-        if clamp:
-            normalized_value = max(min(normalized_value, 1), 0)
+        normalized_value = (value - source_min) / (source_max - source_min)
 
         eased_value = apply_easing(normalized_value, easing)
 
         # - Convert the eased value to the target range
         res = target_min + (target_max - target_min) * eased_value
 
+        if clamp:
+            if target_min > target_max:
+                res = max(min(res, target_min), target_max)
+            else:
+                res = max(min(res, target_max), target_min)
+
         return (res,)
 
 
-class MTB_ConcatImages:
-    """Add images to batch."""
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "concatenate_tensors"
-    CATEGORY = "mtb/image"
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {"reverse": ("BOOLEAN", {"default": False})},
-        }
-
-    def concatenate_tensors(self, reverse, **kwargs):
-        tensors = tuple(kwargs.values())
-        batch_sizes = [tensor.size(0) for tensor in tensors]
-
-        concatenated = torch.cat(tensors, dim=0)
-
-        # Update the batch size in the concatenated tensor
-        concatenated_size = list(concatenated.size())
-        concatenated_size[0] = sum(batch_sizes)
-        concatenated = concatenated.view(*concatenated_size)
-
-        return (concatenated,)
-
-
-__nodes__ = [
-    MTB_StringReplace,
-    MTB_FitNumber,
-    MTB_GetBatchFromHistory,
-    MTB_AnyToString,
-    MTB_ConcatImages,
-    MTB_MathExpression,
-    MTB_ToDevice,
-    MTB_ApplyTextTemplate,
-    MTB_MatchDimensions,
-    MTB_AutoPanEquilateral,
-    MTB_FloatsToFloat,
-    MTB_FloatToFloats,
-    MTB_FloatsToInts,
-]
+__nodes__ = [StringReplace, FitNumber, GetBatchFromHistory, AnyToString]

nodes/image_interpolation.py

@@ -1,27 +1,27 @@
-from pathlib import Path
 from typing import List
-
-import comfy
-import comfy.model_management as model_management
-import comfy.utils
-import numpy as np
-import tensorflow as tf
-import torch
-from frame_interpolation.eval import interpolator, util
-
-from ..errors import ModelNotFound
+from pathlib import Path
+import os
+import glob
+import folder_paths
 from ..log import log
-from ..utils import get_model_path
+import torch
+from frame_interpolation.eval import util, interpolator
+import numpy as np
+import comfy
+import comfy.utils
+import tensorflow as tf
+import comfy.model_management as model_management
 
 
-class MTB_LoadFilmModel:
+class LoadFilmModel:
     """Loads a FILM model"""
 
     @staticmethod
     def get_models() -> List[Path]:
-        models_paths = get_model_path("FILM").iterdir()
-
-        return [x for x in models_paths if x.suffix in [".onnx", ".pth"]]
+        models_path = os.path.join(folder_paths.models_dir, "FILM/*")
+        models = glob.glob(models_path)
+        models = [Path(x) for x in models if x.endswith(".onnx") or x.endswith(".pth")]
+        return models
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -39,10 +39,7 @@ class MTB_LoadFilmModel:
     CATEGORY = "mtb/frame iterpolation"
 
     def load_model(self, film_model: str):
-        model_path = get_model_path("FILM", film_model)
-        if not model_path or not model_path.exists():
-            raise ModelNotFound(f"FILM ({model_path})")
-
+        model_path = Path(folder_paths.models_dir) / "FILM" / film_model
         if not (model_path / "saved_model.pb").exists():
             model_path = model_path / "saved_model"
 
@@ -55,7 +52,7 @@ class MTB_LoadFilmModel:
         return (interpolator.Interpolator(model_path.as_posix(), None),)
 
 
-class MTB_FilmInterpolation:
+class FilmInterpolation:
     """Google Research FILM frame interpolation for large motion"""
 
     @classmethod
@@ -104,16 +101,12 @@ class MTB_FilmInterpolation:
             in_frames, interpolate, film_model
         ):
             out_tensors.append(
-                torch.from_numpy(frame)
-                if isinstance(frame, np.ndarray)
-                else frame
+                torch.from_numpy(frame) if isinstance(frame, np.ndarray) else frame
             )
             model_management.throw_exception_if_processing_interrupted()
             pbar.update(1)
 
-        out_tensors = torch.cat(
-            [tens.unsqueeze(0) for tens in out_tensors], dim=0
-        )
+        out_tensors = torch.cat([tens.unsqueeze(0) for tens in out_tensors], dim=0)
 
         log.debug(f"Returning {len(out_tensors)} tensors")
         log.debug(f"Output shape {out_tensors.shape}")
@@ -121,4 +114,41 @@ class MTB_FilmInterpolation:
         return (out_tensors,)
 
 
-__nodes__ = [MTB_LoadFilmModel, MTB_FilmInterpolation]
+class ConcatImages:
+    """Add images to batch"""
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "concat_images"
+    CATEGORY = "mtb/image"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "imageA": ("IMAGE",),
+                "imageB": ("IMAGE",),
+            },
+        }
+
+    @classmethod
+    def concatenate_tensors(cls, A: torch.Tensor, B: torch.Tensor):
+        # Get the batch sizes of A and B
+        batch_size_A = A.size(0)
+        batch_size_B = B.size(0)
+
+        # Concatenate the tensors along the batch dimension
+        concatenated = torch.cat((A, B), dim=0)
+
+        # Update the batch size in the concatenated tensor
+        concatenated_size = list(concatenated.size())
+        concatenated_size[0] = batch_size_A + batch_size_B
+        concatenated = concatenated.view(*concatenated_size)
+
+        return concatenated
+
+    def concat_images(self, imageA: torch.Tensor, imageB: torch.Tensor):
+        log.debug(f"Concatenating A ({imageA.shape}) and B ({imageB.shape})")
+        return (self.concatenate_tensors(imageA, imageB),)
+
+
+__nodes__ = [LoadFilmModel, FilmInterpolation, ConcatImages]

nodes/image_processing.py

@@ -1,19 +1,17 @@
-import itertools
-import json
-import math
-import os
-
-import folder_paths
-import numpy as np
 import torch
-import torch.nn.functional as F
-from PIL import Image, ImageOps
-from PIL.PngImagePlugin import PngInfo
 from skimage.filters import gaussian
 from skimage.util import compare_images
+import numpy as np
+import torch.nn.functional as F
+from PIL import Image
+from ..utils import tensor2pil, pil2tensor, tensor2np
+import torch
+import folder_paths
+from PIL.PngImagePlugin import PngInfo
+import json
+import os
+import math
 
-from ..log import log
-from ..utils import np2tensor, pil2tensor, tensor2np, tensor2pil
 
 # try:
 #     from cv2.ximgproc import guidedFilter
@@ -21,21 +19,7 @@ from ..utils import np2tensor, pil2tensor, tensor2np, tensor2pil
 #     log.warning("cv2.ximgproc.guidedFilter not found, use opencv-contrib-python")
 
 
-def gaussian_kernel(
-    kernel_size: int, sigma_x: float, sigma_y: float, device=None
-):
-    x, y = torch.meshgrid(
-        torch.linspace(-1, 1, kernel_size, device=device),
-        torch.linspace(-1, 1, kernel_size, device=device),
-        indexing="ij",
-    )
-    d_x = x * x / (2.0 * sigma_x * sigma_x)
-    d_y = y * y / (2.0 * sigma_y * sigma_y)
-    g = torch.exp(-(d_x + d_y))
-    return g / g.sum()
-
-
-class MTB_ColorCorrect:
+class ColorCorrect:
     """Various color correction methods"""
 
     @classmethod
@@ -86,14 +70,7 @@ class MTB_ColorCorrect:
 
     @staticmethod
     def contrast_adjustment_tensor(image, contrast):
-        r, g, b = image.unbind(-1)
-        
-        # Using Adobe RGB luminance weights.
-        luminance_image = 0.33 * r + 0.71 * g + 0.06 * b
-        luminance_mean = torch.mean(luminance_image.unsqueeze(-1))
-
-        # Blend original with mean luminance using contrast factor as blend ratio.
-        contrasted = image * contrast + (1.0 - contrast) * luminance_mean        
+        contrasted = (image - 0.5) * contrast + 0.5
         return torch.clamp(contrasted, 0.0, 1.0)
 
     @staticmethod
@@ -123,9 +100,7 @@ class MTB_ColorCorrect:
         return pil2tensor(out)
 
     @staticmethod
-    def hsv_adjustment_tensor_not_working(
-        image: torch.Tensor, hue, saturation, value
-    ):
+    def hsv_adjustment_tensor_not_working(image: torch.Tensor, hue, saturation, value):
         """Abandonning for now"""
         image = image.squeeze(0).permute(2, 0, 1)
 
@@ -202,7 +177,7 @@ class MTB_ColorCorrect:
         return (image,)
 
 
-class MTB_ImageCompare:
+class ImageCompare:
     """Compare two images and return a difference image"""
 
     @classmethod
@@ -223,61 +198,22 @@ class MTB_ImageCompare:
     CATEGORY = "mtb/image"
 
     def compare(self, imageA: torch.Tensor, imageB: torch.Tensor, mode):
-        if imageA.dim() == 4:
-            batch_count = imageA.size(0)
-            return (
-                torch.cat(
-                    tuple(
-                        self.compare(imageA[i], imageB[i], mode)[0]
-                        for i in range(batch_count)
-                    ),
-                    dim=0,
-                ),
-            )
+        imageA = imageA.numpy()
+        imageB = imageB.numpy()
 
-        num_channels_A = imageA.size(2)
-        num_channels_B = imageB.size(2)
+        imageA = imageA.squeeze()
+        imageB = imageB.squeeze()
 
-        # handle RGBA/RGB mismatch
-        if num_channels_A == 3 and num_channels_B == 4:
-            imageA = torch.cat(
-                (imageA, torch.ones_like(imageA[:, :, 0:1])), dim=2
-            )
-        elif num_channels_B == 3 and num_channels_A == 4:
-            imageB = torch.cat(
-                (imageB, torch.ones_like(imageB[:, :, 0:1])), dim=2
-            )
-        match mode:
-            case "diff":
-                compare_image = torch.abs(imageA - imageB)
-            case "blend":
-                compare_image = 0.5 * (imageA + imageB)
-            case "checkerboard":
-                imageA = imageA.numpy()
-                imageB = imageB.numpy()
-                compared_channels = [
-                    torch.from_numpy(
-                        compare_images(
-                            imageA[:, :, i], imageB[:, :, i], method=mode
-                        )
-                    )
-                    for i in range(imageA.shape[2])
-                ]
+        image = compare_images(imageA, imageB, method=mode)
 
-                compare_image = torch.stack(compared_channels, dim=2)
-            case _:
-                compare_image = None
-                raise ValueError(f"Unknown mode {mode}")
-
-        compare_image = compare_image.unsqueeze(0)
-
-        return (compare_image,)
+        image = np.expand_dims(image, axis=0)
+        return (torch.from_numpy(image),)
 
 
 import requests
 
 
-class MTB_LoadImageFromUrl:
+class LoadImageFromUrl:
     """Load an image from the given URL"""
 
     @classmethod
@@ -300,11 +236,10 @@ class MTB_LoadImageFromUrl:
     def load(self, url):
         # get the image from the url
         image = Image.open(requests.get(url, stream=True).raw)
-        image = ImageOps.exif_transpose(image)
         return (pil2tensor(image),)
 
 
-class MTB_Blur:
+class Blur:
     """Blur an image using a Gaussian filter."""
 
     @classmethod
@@ -314,129 +249,25 @@ class MTB_Blur:
                 "image": ("IMAGE",),
                 "sigmaX": (
                     "FLOAT",
-                    {"default": 3.0, "min": 0.0, "max": 200.0, "step": 0.01},
+                    {"default": 3.0, "min": 0.0, "max": 10.0, "step": 0.01},
                 ),
                 "sigmaY": (
                     "FLOAT",
-                    {"default": 3.0, "min": 0.0, "max": 200.0, "step": 0.01},
+                    {"default": 3.0, "min": 0.0, "max": 10.0, "step": 0.01},
                 ),
-            },
-            "optional": {"sigmasX": ("FLOATS",), "sigmasY": ("FLOATS",)},
+            }
         }
 
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "blur"
     CATEGORY = "mtb/image processing"
 
-    def blur(
-        self, image: torch.Tensor, sigmaX, sigmaY, sigmasX=None, sigmasY=None
-    ):
-        image_np = image.numpy() * 255
-
-        blurred_images = []
-        if sigmasX is not None:
-            if sigmasY is None:
-                sigmasY = sigmasX
-            if len(sigmasX) != image.size(0):
-                raise ValueError(
-                    f"SigmasX must have same length as image, sigmasX is {len(sigmasX)} but the batch size is {image.size(0)}"
-                )
-
-            for i in range(image.size(0)):
-                blurred = gaussian(
-                    image_np[i],
-                    sigma=(sigmasX[i], sigmasY[i], 0),
-                    channel_axis=2,
-                )
-                blurred_images.append(blurred)
-
-            image_np = np.array(blurred_images)
-        else:
-            for i in range(image.size(0)):
-                blurred = gaussian(
-                    image_np[i], sigma=(sigmaX, sigmaY, 0), channel_axis=2
-                )
-                blurred_images.append(blurred)
-
-            image_np = np.array(blurred_images)
-        return (np2tensor(image_np).squeeze(0),)
-
-
-class MTB_Sharpen:
-    """Sharpens an image using a Gaussian kernel."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "sharpen_radius": (
-                    "INT",
-                    {"default": 1, "min": 1, "max": 31, "step": 1},
-                ),
-                "sigma_x": (
-                    "FLOAT",
-                    {"default": 1.0, "min": 0.1, "max": 10.0, "step": 0.1},
-                ),
-                "sigma_y": (
-                    "FLOAT",
-                    {"default": 1.0, "min": 0.1, "max": 10.0, "step": 0.1},
-                ),
-                "alpha": (
-                    "FLOAT",
-                    {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.1},
-                ),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "do_sharp"
-    CATEGORY = "mtb/image processing"
-
-    def do_sharp(
-        self,
-        image: torch.Tensor,
-        sharpen_radius: int,
-        sigma_x: float,
-        sigma_y: float,
-        alpha: float,
-    ):
-        if sharpen_radius == 0:
-            return (image,)
-
-        channels = image.shape[3]
-
-        kernel_size = 2 * sharpen_radius + 1
-        kernel = gaussian_kernel(kernel_size, sigma_x, sigma_y) * -(alpha * 10)
-
-        # Modify center of kernel to make it a sharpening kernel
-        center = kernel_size // 2
-        kernel[center, center] = kernel[center, center] - kernel.sum() + 1.0
-
-        kernel = kernel.repeat(channels, 1, 1).unsqueeze(1)
-        tensor_image = image.permute(0, 3, 1, 2)
-
-        tensor_image = F.pad(
-            tensor_image,
-            (sharpen_radius, sharpen_radius, sharpen_radius, sharpen_radius),
-            "reflect",
-        )
-        sharpened = F.conv2d(
-            tensor_image, kernel, padding=center, groups=channels
-        )
-
-        # Remove padding
-        sharpened = sharpened[
-            :,
-            :,
-            sharpen_radius:-sharpen_radius,
-            sharpen_radius:-sharpen_radius,
-        ]
-
-        sharpened = sharpened.permute(0, 2, 3, 1)
-        result = torch.clamp(sharpened, 0, 1)
-
-        return (result,)
+    def blur(self, image: torch.Tensor, sigmaX, sigmaY):
+        image = image.numpy()
+        image = image.transpose(1, 2, 3, 0)
+        image = gaussian(image, sigma=(sigmaX, sigmaY, 0, 0))
+        image = image.transpose(3, 0, 1, 2)
+        return (torch.from_numpy(image),)
 
 
 # https://github.com/lllyasviel/AdverseCleaner/blob/main/clean.py
@@ -465,7 +296,7 @@ class MTB_Sharpen:
 #         return (np2tensor(deglaze_np_img(tensor2np(image))),)
 
 
-class MTB_MaskToImage:
+class MaskToImage:
     """Converts a mask (alpha) to an RGB image with a color and background"""
 
     @classmethod
@@ -485,32 +316,26 @@ class MTB_MaskToImage:
     FUNCTION = "render_mask"
 
     def render_mask(self, mask, color, background):
-        masks = tensor2np(mask)[0]
-        images = []
-        for m in masks:
-            _mask = Image.fromarray(m).convert("L")
+        mask = tensor2np(mask)
+        mask = Image.fromarray(mask).convert("L")
 
-            log.debug(
-                f"Converted mask to PIL Image format, size: {_mask.size}"
-            )
+        image = Image.new("RGBA", mask.size, color=color)
+        # apply the mask
+        image = Image.composite(
+            image, Image.new("RGBA", mask.size, color=background), mask
+        )
 
-            image = Image.new("RGBA", _mask.size, color=color)
-            # apply the mask
-            image = Image.composite(
-                image, Image.new("RGBA", _mask.size, color=background), _mask
-            )
+        # image = ImageChops.multiply(image, mask)
+        # apply over background
+        # image = Image.alpha_composite(Image.new("RGBA", image.size, color=background), image)
 
-            # image = ImageChops.multiply(image, mask)
-            # apply over background
-            # image = Image.alpha_composite(Image.new("RGBA", image.size, color=background), image)
+        image = pil2tensor(image.convert("RGB"))
 
-            images.append(image.convert("RGB"))
-
-        return (pil2tensor(images),)
+        return (image,)
 
 
-class MTB_ColoredImage:
-    """Constant color image of given size."""
+class ColoredImage:
+    """Constant color image of given size"""
 
     def __init__(self) -> None:
         pass
@@ -522,11 +347,7 @@ class MTB_ColoredImage:
                 "color": ("COLOR",),
                 "width": ("INT", {"default": 512, "min": 16, "max": 8160}),
                 "height": ("INT", {"default": 512, "min": 16, "max": 8160}),
-            },
-            "optional": {
-                "foreground_image": ("IMAGE",),
-                "foreground_mask": ("MASK",),
-            },
+            }
         }
 
     CATEGORY = "mtb/generate"
@@ -535,101 +356,15 @@ class MTB_ColoredImage:
 
     FUNCTION = "render_img"
 
-    def resize_and_crop(self, img, target_size):
-        # Calculate scaling factors for both dimensions
-        scale_x = target_size[0] / img.width
-        scale_y = target_size[1] / img.height
+    def render_img(self, color, width, height):
+        image = Image.new("RGB", (width, height), color=color)
 
-        # Use the smaller scaling factor to maintain aspect ratio
-        scale = max(scale_x, scale_y)
+        image = pil2tensor(image)
 
-        # Resize the image based on calculated scale
-        new_size = (int(img.width * scale), int(img.height * scale))
-        img = img.resize(new_size, Image.LANCZOS)
-
-        # Calculate cropping coordinates
-        left = (img.width - target_size[0]) / 2
-        top = (img.height - target_size[1]) / 2
-        right = (img.width + target_size[0]) / 2
-        bottom = (img.height + target_size[1]) / 2
-
-        # Crop and return the image
-        return img.crop((left, top, right, bottom))
-
-    def resize_and_crop_thumbnails(self, img, target_size):
-        img.thumbnail(target_size, Image.LANCZOS)
-        left = (img.width - target_size[0]) / 2
-        top = (img.height - target_size[1]) / 2
-        right = (img.width + target_size[0]) / 2
-        bottom = (img.height + target_size[1]) / 2
-        return img.crop((left, top, right, bottom))
-
-    def render_img(
-        self,
-        color,
-        width,
-        height,
-        foreground_image: torch.Tensor | None = None,
-        foreground_mask: torch.Tensor | None = None,
-    ):
-        image = Image.new("RGBA", (width, height), color=color)
-        output = []
-        if foreground_image is not None:
-            fg_masks = [None] * foreground_image.size()[0]
-
-            if foreground_mask is not None:
-                fg_size = foreground_image.size()[0]
-                mask_size = foreground_mask.size()[0]
-
-                if fg_size == 1 and mask_size > fg_size:
-                    foreground_image = foreground_image.repeat(
-                        mask_size, 1, 1, 1
-                    )
-
-                if foreground_image.size()[0] != foreground_mask.size()[0]:
-                    raise ValueError(
-                        "Foreground image and mask must have same batch size"
-                    )
-                fg_masks = tensor2pil(foreground_mask.unsqueeze(-1))
-
-            fg_images = tensor2pil(foreground_image)
-
-            for fg_image, fg_mask in zip(fg_images, fg_masks):
-                # Resize and crop if dimensions mismatch
-                if fg_image.size != image.size:
-                    fg_image = self.resize_and_crop(fg_image, image.size)
-                    if fg_mask:
-                        fg_mask = self.resize_and_crop(fg_mask, image.size)
-
-                if fg_mask:
-                    output.append(
-                        Image.composite(
-                            fg_image.convert("RGBA"),
-                            image,
-                            fg_mask,
-                        ).convert("RGB")
-                    )
-                else:
-                    if fg_image.mode != "RGBA":
-                        raise ValueError(
-                            "Foreground image must be in 'RGBA' mode "
-                            f"when no mask is provided, got {fg_image.mode}"
-                        )
-                    output.append(
-                        Image.alpha_composite(image, fg_image).convert("RGB")
-                    )
-
-        else:
-            if foreground_mask is not None:
-                log.warn("Mask ignored because no foreground image is given")
-            output.append(image.convert("RGB"))
-
-        output = pil2tensor(output)
-
-        return (output,)
+        return (image,)
 
 
-class MTB_ImagePremultiply:
+class ImagePremultiply:
     """Premultiply image with mask"""
 
     @classmethod
@@ -644,13 +379,19 @@ class MTB_ImagePremultiply:
 
     CATEGORY = "mtb/image"
     RETURN_TYPES = ("IMAGE",)
-    RETURN_NAMES = ("RGBA",)
     FUNCTION = "premultiply"
 
     def premultiply(self, image, mask, invert):
         images = tensor2pil(image)
-        masks = tensor2pil(mask) if invert else tensor2pil(1.0 - mask)
-        single = len(mask) == 1
+        if invert:
+            masks = tensor2pil(mask)  # .convert("L")
+        else:
+            masks = tensor2pil(1.0 - mask)
+
+        single = False
+        if len(mask) == 1:
+            single = True
+
         masks = [x.convert("L") for x in masks]
 
         out = []
@@ -668,7 +409,7 @@ class MTB_ImagePremultiply:
         return (pil2tensor(out),)
 
 
-class MTB_ImageResizeFactor:
+class ImageResizeFactor:
     """Extracted mostly from WAS Node Suite, with a few edits (most notably multiple image support) and less features."""
 
     @classmethod
@@ -713,9 +454,7 @@ class MTB_ImageResizeFactor:
     ):
         # Check if the tensor has the correct dimension
         if len(image.shape) not in [3, 4]:  # HxWxC or BxHxWxC
-            raise ValueError(
-                "Expected image tensor of shape (H, W, C) or (B, H, W, C)"
-            )
+            raise ValueError("Expected image tensor of shape (H, W, C) or (B, H, W, C)")
 
         # Transpose to CxHxW or BxCxHxW for PyTorch
         if len(image.shape) == 3:
@@ -762,7 +501,7 @@ class MTB_ImageResizeFactor:
         return (resized_image,)
 
 
-class MTB_SaveImageGrid:
+class SaveImageGrid:
     """Save all the images in the input batch as a grid of images."""
 
     def __init__(self):
@@ -827,10 +566,7 @@ class MTB_SaveImageGrid:
             subfolder,
             filename_prefix,
         ) = folder_paths.get_save_image_path(
-            filename_prefix,
-            self.output_dir,
-            images[0].shape[1],
-            images[0].shape[0],
+            filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
         )
         image_list = []
         batch_counter = counter
@@ -860,79 +596,22 @@ class MTB_SaveImageGrid:
         file = f"{filename}_{counter:05}_.png"
         grid = self.create_image_grid(image_list)
         grid.save(
-            os.path.join(full_output_folder, file),
-            pnginfo=metadata,
-            compress_level=4,
+            os.path.join(full_output_folder, file), pnginfo=metadata, compress_level=4
         )
 
-        results = [
-            {"filename": file, "subfolder": subfolder, "type": self.type}
-        ]
+        results = [{"filename": file, "subfolder": subfolder, "type": self.type}]
         return {"ui": {"images": results}}
 
 
-class MTB_ImageTileOffset:
-    """Mimics an old photoshop technique to check for seamless textures"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "tilesX": ("INT", {"default": 2, "min": 1}),
-                "tilesY": ("INT", {"default": 2, "min": 1}),
-            }
-        }
-
-    CATEGORY = "mtb/generate"
-
-    RETURN_TYPES = ("IMAGE",)
-
-    FUNCTION = "tile_image"
-
-    def tile_image(
-        self, image: torch.Tensor, tilesX: int = 2, tilesY: int = 2
-    ):
-        if tilesX < 1 or tilesY < 1:
-            raise ValueError("The number of tiles must be at least 1.")
-
-        batch_size, height, width, channels = image.shape
-        tile_height = height // tilesY
-        tile_width = width // tilesX
-
-        output_image = torch.zeros_like(image)
-
-        for i, j in itertools.product(range(tilesY), range(tilesX)):
-            start_h = i * tile_height
-            end_h = start_h + tile_height
-            start_w = j * tile_width
-            end_w = start_w + tile_width
-
-            tile = image[:, start_h:end_h, start_w:end_w, :]
-
-            output_start_h = (i + 1) % tilesY * tile_height
-            output_start_w = (j + 1) % tilesX * tile_width
-            output_end_h = output_start_h + tile_height
-            output_end_w = output_start_w + tile_width
-
-            output_image[
-                :, output_start_h:output_end_h, output_start_w:output_end_w, :
-            ] = tile
-
-        return (output_image,)
-
-
 __nodes__ = [
-    MTB_ColorCorrect,
-    MTB_ImageCompare,
-    MTB_ImageTileOffset,
-    MTB_Blur,
+    ColorCorrect,
+    ImageCompare,
+    Blur,
     # DeglazeImage,
-    MTB_MaskToImage,
-    MTB_ColoredImage,
-    MTB_ImagePremultiply,
-    MTB_ImageResizeFactor,
-    MTB_SaveImageGrid,
-    MTB_LoadImageFromUrl,
-    MTB_Sharpen,
+    MaskToImage,
+    ColoredImage,
+    ImagePremultiply,
+    ImageResizeFactor,
+    SaveImageGrid,
+    LoadImageFromUrl,
 ]

nodes/image_utils.py

@@ -1,130 +0,0 @@
-import torch
-
-from ..log import log
-
-
-class MTB_StackImages:
-    """Stack the input images horizontally or vertically."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {"required": {"vertical": ("BOOLEAN", {"default": False})}}
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "stack"
-    CATEGORY = "mtb/image utils"
-
-    def stack(self, vertical, **kwargs):
-        if not kwargs:
-            raise ValueError("At least one tensor must be provided.")
-
-        tensors = list(kwargs.values())
-        log.debug(
-            f"Stacking {len(tensors)} tensors "
-            f"{'vertically' if vertical else 'horizontally'}"
-        )
-
-        normalized_tensors = [
-            self.normalize_to_rgba(tensor) for tensor in tensors
-        ]
-        max_batch_size = max(tensor.shape[0] for tensor in normalized_tensors)
-        normalized_tensors = [
-            self.duplicate_frames(tensor, max_batch_size)
-            for tensor in normalized_tensors
-        ]
-
-        if vertical:
-            width = normalized_tensors[0].shape[2]
-            if any(tensor.shape[2] != width for tensor in normalized_tensors):
-                raise ValueError(
-                    "All tensors must have the same width "
-                    "for vertical stacking."
-                )
-            dim = 1
-        else:
-            height = normalized_tensors[0].shape[1]
-            if any(tensor.shape[1] != height for tensor in normalized_tensors):
-                raise ValueError(
-                    "All tensors must have the same height "
-                    "for horizontal stacking."
-                )
-            dim = 2
-
-        stacked_tensor = torch.cat(normalized_tensors, dim=dim)
-
-        return (stacked_tensor,)
-
-    def normalize_to_rgba(self, tensor):
-        """Normalize tensor to have 4 channels (RGBA)."""
-        _, _, _, channels = tensor.shape
-        # already RGBA
-        if channels == 4:
-            return tensor
-        # RGB to RGBA
-        elif channels == 3:
-            alpha_channel = torch.ones(
-                tensor.shape[:-1] + (1,), device=tensor.device
-            )  # Add an alpha channel
-            return torch.cat((tensor, alpha_channel), dim=-1)
-        else:
-            raise ValueError(
-                "Tensor has an unsupported number of channels: "
-                "expected 3 (RGB) or 4 (RGBA)."
-            )
-
-    def duplicate_frames(self, tensor, target_batch_size):
-        """Duplicate frames in tensor to match the target batch size."""
-        current_batch_size = tensor.shape[0]
-        if current_batch_size < target_batch_size:
-            duplication_factors: int = target_batch_size // current_batch_size
-            duplicated_tensor = tensor.repeat(duplication_factors, 1, 1, 1)
-            remaining_frames = target_batch_size % current_batch_size
-            if remaining_frames > 0:
-                duplicated_tensor = torch.cat(
-                    (duplicated_tensor, tensor[:remaining_frames]), dim=0
-                )
-            return duplicated_tensor
-        else:
-            return tensor
-
-
-class MTB_PickFromBatch:
-    """Pick a specific number of images from a batch.
-
-    either from the start or end.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "from_direction": (["end", "start"], {"default": "start"}),
-                "count": ("INT", {"default": 1}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "pick_from_batch"
-    CATEGORY = "mtb/image utils"
-
-    def pick_from_batch(self, image, from_direction, count):
-        batch_size = image.size(0)
-
-        # Limit count to the available number of images in the batch
-        count = min(count, batch_size)
-        if count < batch_size:
-            log.warning(
-                f"Requested {count} images, "
-                f"but only {batch_size} are available."
-            )
-
-        if from_direction == "end":
-            selected_tensors = image[-count:]
-        else:
-            selected_tensors = image[:count]
-
-        return (selected_tensors,)
-
-
-__nodes__ = [MTB_StackImages, MTB_PickFromBatch]

nodes/io.py

@@ -1,143 +1,33 @@
-import json
-import subprocess
+from ..utils import tensor2np, PIL_FILTER_MAP
 import uuid
-from pathlib import Path
-from typing import List, Optional
-
-import comfy.model_management as model_management
 import folder_paths
-import numpy as np
-import torch
-from PIL import Image
-
 from ..log import log
-from ..utils import PIL_FILTER_MAP, output_dir, session_id, tensor2np
+import comfy.model_management as model_management
+import subprocess
+import torch
+from pathlib import Path
+import numpy as np
+from PIL import Image
+from typing import Optional, List
 
 
-def get_playlist_path(playlist_name: str, persistant_playlist=False):
-    if persistant_playlist:
-        return output_dir / "playlists" / f"{playlist_name}.json"
-
-    return output_dir / "playlists" / session_id / f"{playlist_name}.json"
-
-
-class MTB_ReadPlaylist:
-    """Read a playlist"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "enable": ("BOOLEAN", {"default": True}),
-                "persistant_playlist": ("BOOLEAN", {"default": False}),
-                "playlist_name": (
-                    "STRING",
-                    {"default": "playlist_{index:04d}"},
-                ),
-                "index": ("INT", {"default": 0, "min": 0}),
-            }
-        }
-
-    RETURN_TYPES = ("PLAYLIST",)
-    FUNCTION = "read_playlist"
-    CATEGORY = "mtb/IO"
-
-    def read_playlist(
-        self,
-        enable: bool,
-        persistant_playlist: bool,
-        playlist_name: str,
-        index: int,
-    ):
-        playlist_name = playlist_name.format(index=index)
-        playlist_path = get_playlist_path(playlist_name, persistant_playlist)
-        if not enable:
-            return (None,)
-
-        if not playlist_path.exists():
-            log.warning(f"Playlist {playlist_path} does not exist, skipping")
-            return (None,)
-
-        log.debug(f"Reading playlist {playlist_path}")
-        return (json.loads(playlist_path.read_text(encoding="utf-8")),)
-
-
-class MTB_AddToPlaylist:
-    """Add a video to the playlist"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "relative_paths": ("BOOLEAN", {"default": False}),
-                "persistant_playlist": ("BOOLEAN", {"default": False}),
-                "playlist_name": (
-                    "STRING",
-                    {"default": "playlist_{index:04d}"},
-                ),
-                "index": ("INT", {"default": 0, "min": 0}),
-            }
-        }
-
-    RETURN_TYPES = ()
-    OUTPUT_NODE = True
-    FUNCTION = "add_to_playlist"
-    CATEGORY = "mtb/IO"
-
-    def add_to_playlist(
-        self,
-        relative_paths: bool,
-        persistant_playlist: bool,
-        playlist_name: str,
-        index: int,
-        **kwargs,
-    ):
-        playlist_name = playlist_name.format(index=index)
-        playlist_path = get_playlist_path(playlist_name, persistant_playlist)
-
-        if not playlist_path.parent.exists():
-            playlist_path.parent.mkdir(parents=True, exist_ok=True)
-
-        playlist = []
-        if not playlist_path.exists():
-            playlist_path.write_text("[]")
-        else:
-            playlist = json.loads(playlist_path.read_text())
-        log.debug(f"Playlist {playlist_path} has {len(playlist)} items")
-        for video in kwargs.values():
-            if relative_paths:
-                video = Path(video).relative_to(output_dir).as_posix()
-
-            log.debug(f"Adding {video} to playlist")
-            playlist.append(video)
-
-        log.debug(f"Writing playlist {playlist_path}")
-        playlist_path.write_text(json.dumps(playlist), encoding="utf-8")
-        return ()
-
-
-class MTB_ExportWithFfmpeg:
+class ExportWithFfmpeg:
     """Export with FFmpeg (Experimental)"""
 
     @classmethod
     def INPUT_TYPES(cls):
         return {
-            "optional": {
-                "images": ("IMAGE",),
-                "playlist": ("PLAYLIST",),
-            },
             "required": {
+                "images": ("IMAGE",),
+                # "frames": ("FRAMES",),
                 "fps": ("FLOAT", {"default": 24, "min": 1}),
                 "prefix": ("STRING", {"default": "export"}),
-                "format": (
-                    ["mov", "mp4", "mkv", "gif", "avi"],
-                    {"default": "mov"},
-                ),
+                "format": (["mov", "mp4", "mkv", "avi"], {"default": "mov"}),
                 "codec": (
-                    ["prores_ks", "libx264", "libx265", "gif"],
+                    ["prores_ks", "libx264", "libx265"],
                     {"default": "prores_ks"},
                 ),
-            },
+            }
         }
 
     RETURN_TYPES = ("VIDEO",)
@@ -147,94 +37,26 @@ class MTB_ExportWithFfmpeg:
 
     def export_prores(
         self,
+        images: torch.Tensor,
         fps: float,
         prefix: str,
         format: str,
         codec: str,
-        images: Optional[torch.Tensor] = None,
-        playlist: Optional[List[str]] = None,
     ):
+        if images.size(0) == 0:
+            return ("",)
+        output_dir = Path(folder_paths.get_output_directory())
         pix_fmt = "rgb48le" if codec == "prores_ks" else "yuv420p"
         file_ext = format
         file_id = f"{prefix}_{uuid.uuid4()}.{file_ext}"
 
-        if playlist is not None and images is not None:
-            log.info(f"Exporting to {output_dir / file_id}")
-
-        if playlist is not None:
-            if len(playlist) == 0:
-                log.debug("Playlist is empty, skipping")
-                return ("",)
-
-            temp_playlist_path = (
-                output_dir / f"temp_playlist_{uuid.uuid4()}.txt"
-            )
-            log.debug(
-                f"Create a temporary file to list the videos for concatenation to {temp_playlist_path}"
-            )
-
-            with open(temp_playlist_path, "w") as f:
-                for video_path in playlist:
-                    f.write(f"file '{video_path}'\n")
-
-            out_path = (output_dir / file_id).as_posix()
-
-            # Prepare the FFmpeg command for concatenating videos from the playlist
-            command = [
-                "ffmpeg",
-                "-f",
-                "concat",
-                "-safe",
-                "0",
-                "-i",
-                temp_playlist_path.as_posix(),
-                "-c",
-                "copy",
-                "-y",
-                out_path,
-            ]
-            log.debug(f"Executing {command}")
-            subprocess.run(command)
-
-            temp_playlist_path.unlink()
-
-            return (out_path,)
-
-        if (
-            images is None or images.size(0) == 0
-        ):  # the is None check is just for the type checker
-            return ("",)
+        log.debug(f"Exporting to {output_dir / file_id}")
 
         frames = tensor2np(images)
         log.debug(f"Frames type {type(frames[0])}")
         log.debug(f"Exporting {len(frames)} frames")
 
-        if codec == "gif":
-            out_path = (output_dir / file_id).as_posix()
-            command = [
-                "ffmpeg",
-                "-f",
-                "image2pipe",
-                "-vcodec",
-                "png",
-                "-r",
-                str(fps),
-                "-i",
-                "-",
-                "-vcodec",
-                "gif",
-                "-y",
-                out_path,
-            ]
-            process = subprocess.Popen(command, stdin=subprocess.PIPE)
-            for frame in frames:
-                model_management.throw_exception_if_processing_interrupted()
-                Image.fromarray(frame).save(process.stdin, "PNG")
-
-            process.stdin.close()
-            process.wait()
-        else:
-            frames = [frame.astype(np.uint16) * 257 for frame in frames]
+        frames = [frame.astype(np.uint16) * 257 for frame in frames]
 
         height, width, _ = frames[0].shape
 
@@ -307,7 +129,7 @@ def prepare_animated_batch(
 
 
 # todo: deprecate for apng
-class MTB_SaveGif:
+class SaveGif:
     """Save the images from the batch as a GIF"""
 
     @classmethod
@@ -319,8 +141,9 @@ class MTB_SaveGif:
                 "resize_by": ("FLOAT", {"default": 1.0, "min": 0.1}),
                 "optimize": ("BOOLEAN", {"default": False}),
                 "pingpong": ("BOOLEAN", {"default": False}),
+            },
+            "optional": {
                 "resample_filter": (list(PIL_FILTER_MAP.keys()),),
-                "use_ffmpeg": ("BOOLEAN", {"default": False}),
             },
         }
 
@@ -337,7 +160,6 @@ class MTB_SaveGif:
         optimize=False,
         pingpong=False,
         resample_filter=None,
-        use_ffmpeg=False,
     ):
         if image.size(0) == 0:
             return ("",)
@@ -356,48 +178,18 @@ class MTB_SaveGif:
         ruuid = ruuid.hex[:10]
         out_path = f"{folder_paths.output_directory}/{ruuid}.gif"
 
-        if use_ffmpeg:
-            # Use FFmpeg to create the GIF from PIL images
-            command = [
-                "ffmpeg",
-                "-f",
-                "image2pipe",
-                "-vcodec",
-                "png",
-                "-r",
-                str(fps),
-                "-i",
-                "-",
-                "-vcodec",
-                "gif",
-                "-y",
-                out_path,
-            ]
-            process = subprocess.Popen(command, stdin=subprocess.PIPE)
-            for image in pil_images:
-                model_management.throw_exception_if_processing_interrupted()
-                image.save(process.stdin, "PNG")
-            process.stdin.close()
-            process.wait()
+        # Create the GIF from PIL images
+        pil_images[0].save(
+            out_path,
+            save_all=True,
+            append_images=pil_images[1:],
+            optimize=optimize,
+            duration=int(1000 / fps),
+            loop=0,
+        )
 
-        else:
-            pil_images[0].save(
-                out_path,
-                save_all=True,
-                append_images=pil_images[1:],
-                optimize=optimize,
-                duration=int(1000 / fps),
-                loop=0,
-            )
-        results = [
-            {"filename": f"{ruuid}.gif", "subfolder": "", "type": "output"}
-        ]
+        results = [{"filename": f"{ruuid}.gif", "subfolder": "", "type": "output"}]
         return {"ui": {"gif": results}}
 
 
-__nodes__ = [
-    MTB_SaveGif,
-    MTB_ExportWithFfmpeg,
-    MTB_AddToPlaylist,
-    MTB_ReadPlaylist,
-]
+__nodes__ = [SaveGif, ExportWithFfmpeg]

nodes/latent_processing.py

@@ -1,7 +1,7 @@
 import torch
 
 
-class MTB_LatentLerp:
+class LatentLerp:
     """Linear interpolation (blend) between two latent vectors"""
 
     @classmethod
@@ -10,10 +10,7 @@ class MTB_LatentLerp:
             "required": {
                 "A": ("LATENT",),
                 "B": ("LATENT",),
-                "t": (
-                    "FLOAT",
-                    {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01},
-                ),
+                "t": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
             }
         }
 
@@ -32,5 +29,5 @@ class MTB_LatentLerp:
 
 
 __nodes__ = [
-    MTB_LatentLerp,
+    LatentLerp,
 ]

nodes/mask.py

@@ -1,11 +1,10 @@
-import comfy.utils
-from PIL import Image
 from rembg import remove
-
 from ..utils import pil2tensor, tensor2pil
+from PIL import Image
+import comfy.utils
 
 
-class MTB_ImageRemoveBackgroundRembg:
+class ImageRemoveBackgroundRembg:
     """Removes the background from the input using Rembg."""
 
     @classmethod
@@ -92,21 +91,15 @@ class MTB_ImageRemoveBackgroundRembg:
 
             image_on_bg.paste(img_rm, mask=mask)
 
-            image_on_bg = image_on_bg.convert("RGB")
-
             out_img.append(img_rm)
             out_mask.append(mask)
             out_img_on_bg.append(image_on_bg)
 
             pbar.update(1)
 
-        return (
-            pil2tensor(out_img),
-            pil2tensor(out_mask),
-            pil2tensor(out_img_on_bg),
-        )
+        return (pil2tensor(out_img), pil2tensor(out_mask), pil2tensor(out_img_on_bg))
 
 
 __nodes__ = [
-    MTB_ImageRemoveBackgroundRembg,
+    ImageRemoveBackgroundRembg,
 ]

nodes/model.py

@@ -1,155 +0,0 @@
-import copy
-
-import torch
-from torch.nn import functional as F
-from torch.nn.modules.utils import _pair
-
-from ..log import log
-
-
-class MTB_VaeDecode:
-    """Wrapper for the 2 core decoders but also adding the sd seamless hack, taken from: FlyingFireCo/tiled_ksampler"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "samples": ("LATENT",),
-                "vae": ("VAE",),
-                "seamless_model": ("BOOLEAN", {"default": False}),
-                "use_tiling_decoder": ("BOOLEAN", {"default": True}),
-                "tile_size": (
-                    "INT",
-                    {"default": 512, "min": 320, "max": 4096, "step": 64},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "decode"
-
-    CATEGORY = "mtb/decode"
-
-    def decode(
-        self,
-        vae,
-        samples,
-        seamless_model,
-        use_tiling_decoder=True,
-        tile_size=512,
-    ):
-        if seamless_model:
-            if use_tiling_decoder:
-                log.error(
-                    "You cannot use seamless mode with tiling decoder together, skipping tiling."
-                )
-                use_tiling_decoder = False
-            for layer in [
-                layer
-                for layer in vae.first_stage_model.modules()
-                if isinstance(layer, torch.nn.Conv2d)
-            ]:
-                layer.padding_mode = "circular"
-        if use_tiling_decoder:
-            return (
-                vae.decode_tiled(
-                    samples["samples"],
-                    tile_x=tile_size // 8,
-                    tile_y=tile_size // 8,
-                ),
-            )
-        else:
-            return (vae.decode(samples["samples"]),)
-
-
-def conv_forward(lyr, tensor, weight, bias):
-    step = lyr.timestep
-    if (lyr.paddingStartStep < 0 or step >= lyr.paddingStartStep) and (
-        lyr.paddingStopStep < 0 or step <= lyr.paddingStopStep
-    ):
-        working = F.pad(tensor, lyr.paddingX, mode=lyr.padding_modeX)
-        working = F.pad(working, lyr.paddingY, mode=lyr.padding_modeY)
-    else:
-        working = F.pad(tensor, lyr.paddingX, mode="constant")
-        working = F.pad(working, lyr.paddingY, mode="constant")
-
-    lyr.timestep += 1
-
-    return F.conv2d(
-        working, weight, bias, lyr.stride, _pair(0), lyr.dilation, lyr.groups
-    )
-
-
-class MTB_ModelPatchSeamless:
-    """Uses the stable diffusion 'hack' to infer seamless images by setting the model layers padding mode to circular (experimental)"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "model": ("MODEL",),
-                "startStep": ("INT", {"default": 0}),
-                "stopStep": ("INT", {"default": 999}),
-                "tilingX": (
-                    "BOOLEAN",
-                    {"default": True},
-                ),
-                "tilingY": (
-                    "BOOLEAN",
-                    {"default": True},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("MODEL", "MODEL")
-    RETURN_NAMES = (
-        "Original Model (passthrough)",
-        "Patched Model",
-    )
-    FUNCTION = "hack"
-
-    CATEGORY = "mtb/textures"
-
-    def apply_circular(self, model, startStep, stopStep, x, y):
-        for layer in [
-            layer
-            for layer in model.modules()
-            if isinstance(layer, torch.nn.Conv2d)
-        ]:
-            layer.padding_modeX = "circular" if x else "constant"
-            layer.padding_modeY = "circular" if y else "constant"
-            layer.paddingX = (
-                layer._reversed_padding_repeated_twice[0],
-                layer._reversed_padding_repeated_twice[1],
-                0,
-                0,
-            )
-            layer.paddingY = (
-                0,
-                0,
-                layer._reversed_padding_repeated_twice[2],
-                layer._reversed_padding_repeated_twice[3],
-            )
-            layer.paddingStartStep = startStep
-            layer.paddingStopStep = stopStep
-            layer.timestep = 0
-            layer._conv_forward = conv_forward.__get__(layer, torch.nn.Conv2d)
-
-        return model
-
-    def hack(
-        self,
-        model,
-        startStep,
-        stopStep,
-        tilingX,
-        tilingY,
-    ):
-        hacked_model = copy.deepcopy(model)
-        self.apply_circular(
-            hacked_model.model, startStep, stopStep, tilingX, tilingY
-        )
-        return (model, hacked_model)
-
-
-__nodes__ = [MTB_ModelPatchSeamless, MTB_VaeDecode]

nodes/number.py

@@ -1,4 +1,4 @@
-class MTB_IntToBool:
+class IntToBool:
     """Basic int to bool conversion"""
 
     @classmethod
@@ -22,7 +22,7 @@ class MTB_IntToBool:
         return (bool(int),)
 
 
-class MTB_IntToNumber:
+class IntToNumber:
     """Node addon for the WAS Suite. Converts a "comfy" INT to a NUMBER."""
 
     @classmethod
@@ -50,7 +50,7 @@ class MTB_IntToNumber:
         return (int,)
 
 
-class MTB_FloatToNumber:
+class FloatToNumber:
     """Node addon for the WAS Suite. Converts a "comfy" FLOAT to a NUMBER."""
 
     @classmethod
@@ -77,9 +77,11 @@ class MTB_FloatToNumber:
     def float_to_number(self, float):
         return (float,)
 
+        return (int,)
+
 
 __nodes__ = [
-    MTB_FloatToNumber,
-    MTB_IntToBool,
-    MTB_IntToNumber,
+    FloatToNumber,
+    IntToBool,
+    IntToNumber,
 ]

nodes/prune.py

@@ -1,360 +0,0 @@
-from pathlib import Path
-
-import safetensors.torch
-import torch
-import tqdm
-
-from ..log import log
-from ..utils import Operation, Precision
-from ..utils import output_dir as comfy_out_dir
-
-PRUNE_DATA = {
-    "known_junk_prefix": [
-        "embedding_manager.embedder.",
-        "lora_te_text_model",
-        "control_model.",
-    ],
-    "nai_keys": {
-        "cond_stage_model.transformer.embeddings.": "cond_stage_model.transformer.text_model.embeddings.",
-        "cond_stage_model.transformer.encoder.": "cond_stage_model.transformer.text_model.encoder.",
-        "cond_stage_model.transformer.final_layer_norm.": "cond_stage_model.transformer.text_model.final_layer_norm.",
-    },
-}
-
-# position_ids in clip is int64. model_ema.num_updates is int32
-dtypes_to_fp16 = {torch.float32, torch.float64, torch.bfloat16}
-dtypes_to_bf16 = {torch.float32, torch.float64, torch.float16}
-dtypes_to_fp8 = {torch.float32, torch.float64, torch.bfloat16, torch.float16}
-
-
-class MTB_ModelPruner:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "optional": {
-                "unet": ("MODEL",),
-                "clip": ("CLIP",),
-                "vae": ("VAE",),
-            },
-            "required": {
-                "save_separately": ("BOOLEAN", {"default": False}),
-                "save_folder": ("STRING", {"default": "checkpoints/ComfyUI"}),
-                "fix_clip": ("BOOLEAN", {"default": True}),
-                "remove_junk": ("BOOLEAN", {"default": True}),
-                "ema_mode": (
-                    ("disabled", "remove_ema", "ema_only"),
-                    {"default": "remove_ema"},
-                ),
-                "precision_unet": (
-                    Precision.list_members(),
-                    {"default": Precision.FULL.value},
-                ),
-                "operation_unet": (
-                    Operation.list_members(),
-                    {"default": Operation.CONVERT.value},
-                ),
-                "precision_clip": (
-                    Precision.list_members(),
-                    {"default": Precision.FULL.value},
-                ),
-                "operation_clip": (
-                    Operation.list_members(),
-                    {"default": Operation.CONVERT.value},
-                ),
-                "precision_vae": (
-                    Precision.list_members(),
-                    {"default": Precision.FULL.value},
-                ),
-                "operation_vae": (
-                    Operation.list_members(),
-                    {"default": Operation.CONVERT.value},
-                ),
-            },
-        }
-
-    OUTPUT_NODE = True
-    RETURN_TYPES = ()
-    CATEGORY = "mtb/prune"
-    FUNCTION = "prune"
-
-    def convert_precision(self, tensor: torch.Tensor, precision: Precision):
-        precision = Precision.from_str(precision)
-        log.debug(f"Converting to {precision}")
-        match precision:
-            case Precision.FP8:
-                if tensor.dtype in dtypes_to_fp8:
-                    return tensor.to(torch.float8_e4m3fn)
-                log.error(f"Cannot convert {tensor.dtype} to fp8")
-                return tensor
-            case Precision.FP16:
-                if tensor.dtype in dtypes_to_fp16:
-                    return tensor.half()
-                log.error(f"Cannot convert {tensor.dtype} to f16")
-                return tensor
-            case Precision.BF16:
-                if tensor.dtype in dtypes_to_bf16:
-                    return tensor.bfloat16()
-                log.error(f"Cannot convert {tensor.dtype} to bf16")
-                return tensor
-            case Precision.FULL | Precision.FP32:
-                return tensor
-
-    def is_sdxl_model(self, clip: dict[str, torch.Tensor] | None):
-        if clip:
-            return (any(k.startswith("conditioner.embedders") for k in clip),)
-        return False
-
-    def has_ema(self, unet: dict[str, torch.Tensor]):
-        return any(k.startswith("model_ema") for k in unet)
-
-    def fix_clip(self, clip: dict[str, torch.Tensor] | None):
-        if self.is_sdxl_model(clip):
-            log.warn("[fix clip] SDXL not supported")
-            return
-
-        if clip is None:
-            return
-
-        position_id_key = (
-            "cond_stage_model.transformer.text_model.embeddings.position_ids"
-        )
-        if position_id_key in clip:
-            correct = torch.Tensor([list(range(77))]).to(torch.int64)
-            now = clip[position_id_key].to(torch.int64)
-
-            broken = correct.ne(now)
-            broken = [i for i in range(77) if broken[0][i]]
-
-            if len(broken) != 0:
-                clip[position_id_key] = correct
-                log.info(f"[Converter] Fixed broken clip\n{broken}")
-            else:
-                log.info(
-                    "[Converter] Clip in this model is fine, skip fixing..."
-                )
-
-        else:
-            log.info("[Converter] Missing position id in model, try fixing...")
-            clip[position_id_key] = torch.Tensor([list(range(77))]).to(
-                torch.int64
-            )
-        return clip
-
-    def get_dicts(self, unet, clip, vae):
-        clip_sd = clip.get_sd()
-        state_dict = unet.model.state_dict_for_saving(
-            clip_sd, vae.get_sd(), None
-        )
-
-        unet = {
-            k: v
-            for k, v in state_dict.items()
-            if k.startswith("model.diffusion_model")
-        }
-        clip = {
-            k: v
-            for k, v in state_dict.items()
-            if k.startswith("cond_stage_model")
-            or k.startswith("conditioner.embedders")
-        }
-        vae = {
-            k: v
-            for k, v in state_dict.items()
-            if k.startswith("first_stage_model")
-        }
-
-        other = {
-            k: v
-            for k, v in state_dict.items()
-            if k not in unet and k not in vae and k not in clip
-        }
-
-        return (unet, clip, vae, other)
-
-    def do_remove_junk(self, tensors: dict[str, dict[str, torch.Tensor]]):
-        need_delete: list[str] = []
-        for layer in tensors:
-            for key in layer:
-                for jk in PRUNE_DATA["known_junk_prefix"]:
-                    if key.startswith(jk):
-                        need_delete.append(".".join([layer, key]))
-
-        for k in need_delete:
-            log.info(f"Removing junk data: {k}")
-            del tensors[k]
-
-        return tensors
-
-    def prune(
-        self,
-        *,
-        save_separately: bool,
-        save_folder: str,
-        fix_clip: bool,
-        remove_junk: bool,
-        ema_mode: str,
-        precision_unet: Precision,
-        precision_clip: Precision,
-        precision_vae: Precision,
-        operation_unet: str,
-        operation_clip: str,
-        operation_vae: str,
-        unet: dict[str, torch.Tensor] | None = None,
-        clip: dict[str, torch.Tensor] | None = None,
-        vae: dict[str, torch.Tensor] | None = None,
-    ):
-        operation = {
-            "unet": Operation.from_str(operation_unet),
-            "clip": Operation.from_str(operation_clip),
-            "vae": Operation.from_str(operation_vae),
-        }
-        precision = {
-            "unet": Precision.from_str(precision_unet),
-            "clip": Precision.from_str(precision_clip),
-            "vae": Precision.from_str(precision_vae),
-        }
-
-        unet, clip, vae, _other = self.get_dicts(unet, clip, vae)
-
-        out_dir = Path(save_folder)
-        folder = out_dir.parent
-        if not out_dir.is_absolute():
-            folder = (comfy_out_dir / save_folder).parent
-
-        if not folder.exists():
-            if folder.parent.exists():
-                folder.mkdir()
-            else:
-                raise FileNotFoundError(
-                    f"Folder {folder.parent} does not exist"
-                )
-
-        name = out_dir.name
-        save_name = f"{name}-{precision_unet}"
-        if ema_mode != "disabled":
-            save_name += f"-{ema_mode}"
-        if fix_clip:
-            save_name += "-clip-fix"
-
-        if (
-            any(o == Operation.CONVERT for o in operation.values())
-            and any(p == Precision.FP8 for p in precision.values())
-            and torch.__version__ < "2.1.0"
-        ):
-            raise NotImplementedError(
-                "PyTorch 2.1.0 or newer is required for fp8 conversion"
-            )
-
-        if not self.is_sdxl_model(clip):
-            for part in [unet, vae, clip]:
-                if part:
-                    nai_keys = PRUNE_DATA["nai_keys"]
-                    for k in list(part.keys()):
-                        for r in nai_keys:
-                            if isinstance(k, str) and k.startswith(r):
-                                new_key = k.replace(r, nai_keys[r])
-                                part[new_key] = part[k]
-                                del part[k]
-                                log.info(
-                                    f"[Converter] Fixed novelai error key {k}"
-                                )
-                                break
-
-            if fix_clip:
-                clip = self.fix_clip(clip)
-
-        ok: dict[str, dict[str, torch.Tensor]] = {
-            "unet": {},
-            "clip": {},
-            "vae": {},
-        }
-
-        def _hf(part: str, wk: str, t: torch.Tensor):
-            if not isinstance(t, torch.Tensor):
-                log.debug("Not a torch tensor, skipping key")
-                return
-
-            log.debug(f"Operation {operation[part]}")
-            if operation[part] == Operation.CONVERT:
-                ok[part][wk] = self.convert_precision(
-                    t, precision[part]
-                )  # conv_func(t)
-            elif operation[part] == Operation.COPY:
-                ok[part][wk] = t
-            elif operation[part] == Operation.DELETE:
-                return
-
-        log.info("[Converter] Converting model...")
-
-        for part_name, part in zip(
-            ["unet", "vae", "clip", "other"],
-            [unet, vae, clip],
-            strict=False,
-        ):
-            if part:
-                match ema_mode:
-                    case "remove_ema":
-                        for k, v in tqdm.tqdm(part.items()):
-                            if "model_ema." not in k:
-                                _hf(part_name, k, v)
-                    case "ema_only":
-                        if not self.has_ema(part):
-                            log.warn("No EMA to extract")
-                            return
-                        for k in tqdm.tqdm(part):
-                            ema_k = "___"
-                            try:
-                                ema_k = "model_ema." + k[6:].replace(".", "")
-                            except Exception:
-                                pass
-                            if ema_k in part:
-                                _hf(part_name, k, part[ema_k])
-                            elif not k.startswith("model_ema.") or k in [
-                                "model_ema.num_updates",
-                                "model_ema.decay",
-                            ]:
-                                _hf(part_name, k, part[k])
-                    case "disabled" | _:
-                        for k, v in tqdm.tqdm(part.items()):
-                            _hf(part_name, k, v)
-
-                if save_separately:
-                    if remove_junk:
-                        ok = self.do_remove_junk(ok)
-
-                    flat_ok = {
-                        k: v
-                        for _, subdict in ok.items()
-                        for k, v in subdict.items()
-                    }
-                    save_path = (
-                        folder / f"{part_name}-{save_name}.safetensors"
-                    ).as_posix()
-                    safetensors.torch.save_file(flat_ok, save_path)
-                    ok: dict[str, dict[str, torch.Tensor]] = {
-                        "unet": {},
-                        "clip": {},
-                        "vae": {},
-                    }
-
-        if save_separately:
-            return ()
-
-        if remove_junk:
-            ok = self.do_remove_junk(ok)
-
-        flat_ok = {
-            k: v for _, subdict in ok.items() for k, v in subdict.items()
-        }
-
-        try:
-            safetensors.torch.save_file(
-                flat_ok, (folder / f"{save_name}.safetensors").as_posix()
-            )
-        except Exception as e:
-            log.error(e)
-
-        return ()
-
-
-__nodes__ = [MTB_ModelPruner]

nodes/psd.py

@@ -0,0 +1,89 @@
+from pytoshop.user import nested_layers
+
+# from pytoshop.image_data import ImageData
+from .. import utils
+from ..log import log
+from uuid import uuid4
+from pathlib import Path
+import folder_paths
+from importlib import reload
+
+
+class PsdSave:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "input_1": ("PSDLAYER",),
+            },
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "psd_save"
+    CATEGORY = "psd"
+    OUTPUT_NODE = True
+
+    def psd_save(self, **kwargs):
+        groups = {
+            "main": [],
+        }
+        out_layers = []
+        for input, item in kwargs.items():
+            for group, layer in item.items():
+                if group not in groups:
+                    groups[group] = []
+                groups[group].append(layer)
+
+        for group, layers in groups.items():
+            current_group = nested_layers.Group(
+                group, visible=True, opacity=255, layers=layers, closed=False
+            )
+            out_layers.append(current_group)
+
+        out_layers = nested_layers.nested_layers_to_psd(out_layers, color_mode=3)
+        output_name = f"{uuid4()}.psd"
+        output_path = Path(folder_paths.output_directory) / output_name
+
+        log.info(f"Saving PSD to {output_name}")
+
+        with open(output_path, "wb") as f:
+            out_layers.write(f)
+
+        return ()
+
+
+class PsdLayer:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "layer_name": ("STRING", {"default": "layer"}),
+                "image": ("IMAGE",),
+            },
+            "optional": {"mask": ("MASK",)},
+        }
+
+    RETURN_TYPES = ("PSDLAYER",)
+    FUNCTION = "psd_layer"
+    CATEGORY = "psd"
+
+    def psd_layer(self, layer_name, image, mask=None):
+        reload(utils)
+        group = "main"
+        if "/" in layer_name:
+            sepname = layer_name.split("/")
+            # layer_name = sepname.pop() # todo: support nesting?
+            group = sepname[0]
+            layer_name = sepname[1]
+        psd = utils.tensor2pytolayer(image, layer_name, mask=mask)
+        # log.warning("Mask is currently ignored for PSD Layers...")
+        return ({group: psd},)
+
+
+__nodes__ = [PsdLayer, PsdSave]

nodes/transform.py

@@ -1,16 +1,15 @@
-from math import ceil, sqrt
-from typing import cast
-
 import torch
 import torchvision.transforms.functional as TF
+from ..utils import log, hex_to_rgb, tensor2pil, pil2tensor
+from math import sqrt, ceil
+from typing import cast
 from PIL import Image
 
-from ..utils import hex_to_rgb, log, pil2tensor, tensor2pil
 
-
-class MTB_TransformImage:
+class TransformImage:
     """Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy
 
+
     it return a tensor representing the transformed images with the same shape as the input tensor
     """
 
@@ -19,22 +18,10 @@ class MTB_TransformImage:
         return {
             "required": {
                 "image": ("IMAGE",),
-                "x": (
-                    "FLOAT",
-                    {"default": 0, "step": 1, "min": -4096, "max": 4096},
-                ),
-                "y": (
-                    "FLOAT",
-                    {"default": 0, "step": 1, "min": -4096, "max": 4096},
-                ),
-                "zoom": (
-                    "FLOAT",
-                    {"default": 1.0, "min": 0.001, "step": 0.01},
-                ),
-                "angle": (
-                    "FLOAT",
-                    {"default": 0, "step": 1, "min": -360, "max": 360},
-                ),
+                "x": ("FLOAT", {"default": 0, "step": 1, "min": -4096, "max": 4096}),
+                "y": ("FLOAT", {"default": 0, "step": 1, "min": -4096, "max": 4096}),
+                "zoom": ("FLOAT", {"default": 1.0, "min": 0.001, "step": 0.01}),
+                "angle": ("FLOAT", {"default": 0, "step": 1, "min": -360, "max": 360}),
                 "shear": (
                     "FLOAT",
                     {"default": 0, "step": 1, "min": -4096, "max": 4096},
@@ -66,21 +53,14 @@ class MTB_TransformImage:
         y = int(y)
         angle = int(angle)
 
-        log.debug(
-            f"Zoom: {zoom} | x: {x}, y: {y}, angle: {angle}, shear: {shear}"
-        )
+        log.debug(f"Zoom: {zoom} | x: {x}, y: {y}, angle: {angle}, shear: {shear}")
 
         if image.size(0) == 0:
             return (torch.zeros(0),)
         transformed_images = []
-        frames_count, frame_height, frame_width, frame_channel_count = (
-            image.size()
-        )
+        frames_count, frame_height, frame_width, frame_channel_count = image.size()
 
-        new_height, new_width = (
-            int(frame_height * zoom),
-            int(frame_width * zoom),
-        )
+        new_height, new_width = int(frame_height * zoom), int(frame_width * zoom)
 
         log.debug(f"New height: {new_height}, New width: {new_width}")
 
@@ -94,12 +74,7 @@ class MTB_TransformImage:
         pw += abs(max_padding)
         ph += abs(max_padding)
 
-        padding = [
-            max(0, pw + x),
-            max(0, ph + y),
-            max(0, pw - x),
-            max(0, ph - y),
-        ]
+        padding = [max(0, pw + x), max(0, ph + y), max(0, pw - x), max(0, ph - y)]
 
         constant_color = hex_to_rgb(constant_color)
         log.debug(f"Fill Tuple: {constant_color}")
@@ -114,9 +89,7 @@ class MTB_TransformImage:
 
             img = cast(
                 Image.Image,
-                TF.affine(
-                    img, angle=angle, scale=zoom, translate=[x, y], shear=shear
-                ),
+                TF.affine(img, angle=angle, scale=zoom, translate=[x, y], shear=shear),
             )
 
             left = abs(padding[0])
@@ -134,4 +107,4 @@ class MTB_TransformImage:
         return (pil2tensor(transformed_images),)
 
 
-__nodes__ = [MTB_TransformImage]
+__nodes__ = [TransformImage]

nodes/video.py

@@ -1,24 +1,22 @@
-import hashlib
-import json
 import os
 import re
-from pathlib import Path
-
-import folder_paths
-import numpy as np
 import torch
+import numpy as np
+import hashlib
 from PIL import Image, ImageOps
 from PIL.PngImagePlugin import PngInfo
+import folder_paths
+from pathlib import Path
+import json
 
 from ..log import log
 
 
-class MTB_LoadImageSequence:
+class LoadImageSequence:
     """Load an image sequence from a folder. The current frame is used to determine which image to load.
 
     Usually used in conjunction with the `Primitive` node set to increment to load a sequence of images from a folder.
     Use -1 to load all matching frames as a batch.
-
     """
 
     @classmethod
@@ -30,10 +28,7 @@ class MTB_LoadImageSequence:
                     "INT",
                     {"default": 0, "min": -1, "max": 9999999},
                 ),
-            },
-            "optional": {
-                "range": ("STRING", {"default": ""}),
-            },
+            }
         }
 
     CATEGORY = "mtb/IO"
@@ -42,28 +37,17 @@ class MTB_LoadImageSequence:
         "IMAGE",
         "MASK",
         "INT",
-        "INT",
     )
     RETURN_NAMES = (
         "image",
         "mask",
         "current_frame",
-        "total_frames",
     )
 
-    def load_image(self, path=None, current_frame=0, range=""):
+    def load_image(self, path=None, current_frame=0):
         load_all = current_frame == -1
-        total_frames = 1
 
-        if range:
-            frames = self.get_frames_from_range(path, range)
-            imgs, masks = zip(*(img_from_path(frame) for frame in frames))
-            out_img = torch.cat(imgs, dim=0)
-            out_mask = torch.cat(masks, dim=0)
-            total_frames = len(imgs)
-            return (out_img, out_mask, -1, total_frames)
-
-        elif load_all:
+        if load_all:
             log.debug(f"Loading all frames from {path}")
             frames = resolve_all_frames(path)
             log.debug(f"Found {len(frames)} frames")
@@ -71,72 +55,33 @@ class MTB_LoadImageSequence:
             imgs = []
             masks = []
 
-            imgs, masks = zip(*(img_from_path(frame) for frame in frames))
+            for frame in frames:
+                img, mask = img_from_path(frame)
+                imgs.append(img)
+                masks.append(mask)
 
             out_img = torch.cat(imgs, dim=0)
             out_mask = torch.cat(masks, dim=0)
-            total_frames = len(imgs)
 
-            return (out_img, out_mask, -1, total_frames)
+            return (
+                out_img,
+                out_mask,
+            )
 
         log.debug(f"Loading image: {path}, {current_frame}")
+        print(f"Loading image: {path}, {current_frame}")
         resolved_path = resolve_path(path, current_frame)
         image_path = folder_paths.get_annotated_filepath(resolved_path)
         image, mask = img_from_path(image_path)
-        return (image, mask, current_frame, total_frames)
-
-    def get_frames_from_range(self, path, range_str):
-        try:
-            start, end = map(int, range_str.split("-"))
-        except ValueError:
-            raise ValueError(
-                f"Invalid range format: {range_str}. Expected format is 'start-end'."
-            )
-
-        frames = resolve_all_frames(path)
-        total_frames = len(frames)
-
-        if start < 0 or end >= total_frames:
-            raise ValueError(
-                f"Range {range_str} is out of bounds. Total frames available: {total_frames}"
-            )
-
-        if "#" in path:
-            frame_regex = re.escape(path).replace(r"\#", r"(\d+)")
-            frame_number_regex = re.compile(frame_regex)
-
-            matching_frames = []
-            for frame in frames:
-                match = frame_number_regex.search(frame)
-
-                if match:
-                    frame_number = int(match.group(1))
-                    if start <= frame_number <= end:
-                        matching_frames.append(frame)
-
-            return matching_frames
-        else:
-            log.warning(
-                f"Wildcard pattern or directory will use indexes instead of frame numbers for : {path}"
-            )
-
-            selected_frames = frames[start : end + 1]
-
-        return selected_frames
+        return (
+            image,
+            mask,
+            current_frame,
+        )
 
     @staticmethod
-    def IS_CHANGED(path="", current_frame=0, range=""):
+    def IS_CHANGED(path="", current_frame=0):
         print(f"Checking if changed: {path}, {current_frame}")
-        if range or current_frame == -1:
-            resolved_paths = resolve_all_frames(path)
-            timestamps = [
-                os.path.getmtime(folder_paths.get_annotated_filepath(p))
-                for p in resolved_paths
-            ]
-            combined_hash = hashlib.sha256(
-                "".join(map(str, timestamps)).encode()
-            )
-            return combined_hash.hexdigest()
         resolved_path = resolve_path(path, current_frame)
         image_path = folder_paths.get_annotated_filepath(resolved_path)
         if os.path.exists(image_path):
@@ -176,28 +121,11 @@ def img_from_path(path):
     )
 
 
-def resolve_all_frames(path: str):
-    frames: list[str] = []
-    if "#" not in path:
-        pth = Path(path)
-        if pth.is_dir():
-            for f in pth.iterdir():
-                if f.suffix in [".jpg", ".png"]:
-                    frames.append(f.as_posix())
-        elif "*" in path:
-            frames = glob.glob(path)
-        else:
-            raise ValueError(
-                "The path doesn't contain a # or a * or is not a directory"
-            )
-        frames.sort()
-
-        return frames
-
-    pattern = path
+def resolve_all_frames(pattern):
     folder_path, file_pattern = os.path.split(pattern)
 
     log.debug(f"Resolving all frames in {folder_path}")
+    frames = []
     hash_count = file_pattern.count("#")
     frame_pattern = re.sub(r"#+", "*", file_pattern)
 
@@ -229,7 +157,7 @@ def resolve_path(path, frame):
     return re.sub("#+", padded_number, path)
 
 
-class MTB_SaveImageSequence:
+class SaveImageSequence:
     """Save an image sequence to a folder. The current frame is used to determine which image to save.
 
     This is merely a wrapper around the `save_images` function with formatting for the output folder and filename.
@@ -245,10 +173,7 @@ class MTB_SaveImageSequence:
             "required": {
                 "images": ("IMAGE",),
                 "filename_prefix": ("STRING", {"default": "Sequence"}),
-                "current_frame": (
-                    "INT",
-                    {"default": 0, "min": 0, "max": 9999999},
-                ),
+                "current_frame": ("INT", {"default": 0, "min": 0, "max": 9999999}),
             },
             "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
         }
@@ -295,14 +220,10 @@ class MTB_SaveImageSequence:
         resolved_path = Path(self.output_dir) / filename_prefix
         resolved_path.mkdir(parents=True, exist_ok=True)
 
-        resolved_img = (
-            resolved_path / f"{filename_prefix}_{current_frame:05}.png"
-        )
+        resolved_img = resolved_path / f"{filename_prefix}_{current_frame:05}.png"
 
         output_image = images[0].cpu().numpy()
-        img = Image.fromarray(
-            np.clip(output_image * 255.0, 0, 255).astype(np.uint8)
-        )
+        img = Image.fromarray(np.clip(output_image * 255.0, 0, 255).astype(np.uint8))
         metadata = PngInfo()
         if prompt is not None:
             metadata.add_text("prompt", json.dumps(prompt))
@@ -325,6 +246,6 @@ class MTB_SaveImageSequence:
 
 
 __nodes__ = [
-    MTB_LoadImageSequence,
-    MTB_SaveImageSequence,
+    LoadImageSequence,
+    SaveImageSequence,
 ]

pyproject.toml

@@ -1,179 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "comfy-mtb"
-version = "0.1.5"
-description = "Animation oriented nodes pack for ComfyUI."
-license = "MIT"
-readme = "README.md"
-# repository = ""
-# url = "https://github.com/melMass/comfy_mtb"
-authors = [{ name = "Mel Massadian", email = "mel@melmassadian.com" }]
-classifiers = [
-  "License :: OSI Approved :: MIT License",
-  "Operating System :: OS Independent",
-  "Programming Language :: Python",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Intended Audience :: Developers",
-]
-requires-python = ">=3.10"
-dependencies = [
-  "qrcode",
-  "onnxruntime-gpu",
-  "requirements-parserx",
-  "rembg",
-  "imageio_ffmpeg",
-  "rich",
-  "rich_argparse",
-  "matplotlib",
-  "pillow",
-]
-optional-dependencies = { mel = [
-  "jupyterlab==4.1.6",
-], dev = [
-  "black[jupyter]",
-  "codespell",
-  "mypy",
-  "pre-commit",
-  "pytest",
-  "pytest-cov",
-  "pytest-random-order",
-  "ruff",
-], doc = [
-  "docutils==0.17.1",
-  "jupyter-book>=0.15",
-  "sphinx-autobuild",
-] }
-
-[project.urls]
-Homepage = "https://github.com/melMass/comfy_mtb"
-Documentation = "https://github.com/melMass/comfy_mtb/wiki"
-Repository = "https://github.com/melMass/comfy_mtb"
-Issues = "https://github.com/melMass/comfy_mtb/issues"
-
-[tool.comfy]
-PublisherId = "mel"
-DisplayName = "comfy-mtb"
-Icon = "https://avatars.githubusercontent.com/u/7041726?v=4"
-
-[tool.bumpversion]
-current_version = "0.1.5"
-parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
-serialize = ["{major}.{minor}.{patch}"]
-search = "{current_version}"
-replace = "{new_version}"
-regex = false
-ignore_missing_version = false
-ignore_missing_files = false
-tag = true
-sign_tags = true
-tag_name = "v{new_version}"
-tag_message = "⬆️ Bump version: {current_version} → {new_version}"
-allow_dirty = true
-commit = true
-message = "⬆️ Bump version: {current_version} → {new_version}"
-commit_args = ""
-
-[[tool.bumpversion.files]]
-filename = "__init__.py"
-search = "__version__ = \"{current_version}\""
-replace = "__version__ = \"{new_version}\""
-
-[[tool.bumpversion.files]]
-filename = "pyproject.toml"
-search = "version = \"{current_version}\""
-replace = "version = \"{new_version}\""
-
-# [[tool.bumpversion.files]]
-# filename = "your_package/__init__.py"
-# search = "__version__ = '{current_version}'"
-# replace = "__version__ = '{new_version}'"
-
-# INFO: All those remaining keys are meant for local dev
-[tool.pyright]
-include = ["."]
-exclude = [
-  "**/node_modules",
-  "**/__pycache__",
-  "src/experimental",
-  "src/typestubs",
-]
-ignore = ["src/oldstuff"]
-defineConstant = { DEBUG = true }
-extraPaths = ["python", "../.."]
-stubPath = "src/stubs"
-
-reportMissingImports = true
-reportMissingTypeStubs = false
-typeCheckingMode = "basic"
-
-pythonVersion = "3.10"
-pythonPlatform = "Windows"
-
-[tool.pytest.ini_options]
-log_level = "DEBUG"
-log_cli = true
-markers = [
-  "wip: tests that aren't fully finished yet",
-  "heavy: marks tests as heavy (deselect with '-m \"not heavy\"')",
-
-]
-filterwarnings = ["ignore::UserWarning", 'ignore::DeprecationWarning']
-
-[tool.isort]
-profile = "black"
-line_length = 88
-auto_identify_namespace_packages = false
-# NOTE:
-# pyright doesn't like implicit namespace + single line (related to https://github.com/microsoft/pyright/issues/2882?) but it's horible so I'll live with it
-force_single_line = false
-known_first_party = ["mtb"]
-extend_skip = ["archives"]
-combine_straight_imports = true
-
-[tool.coverage.run]
-parallel = true
-source = ["docs", "tests", "comfy-mtb"]
-
-[tool.coverage.report]
-fail_under = 90
-show_missing = true
-
-[tool.coverage.html]
-show_contexts = true
-
-[tool.ruff]
-line-length = 79
-select = ["A", "B", "C", "D", "E", "F", "FBT", "I", "N", "S", "SIM", "UP", "W"]
-# NOTE:
-# D102 - undocumented-public-method (noisy)
-# D103 - undocumented-public-function (noisy)
-# D100 - undocumented-public-module (noisy)
-# N802 - invalid-function-name (forced by comfy's arch)
-ignore = ["D103", "D102", "D100", "N802"]
-# exclude auto generated file
-extend-exclude = ["./docs/conf.py"]
-
-[tool.ruff.per-file-ignores]
-# imported but unused
-"__init__.py" = ["F401"]
-# use of assert detected
-"tests/*" = ["S101"]
-
-[tool.ruff.pydocstyle]
-convention = "numpy"
-
-[tool.mypy]
-pretty = true
-ignore_missing_imports = true
-# exclude auto generated file
-exclude = ["docs/conf.py"]
-
-[tool.codespell]
-# exclude auto generated file
-skip = "./docs/conf.py,poetry.lock"
-check-filenames = true

reqs.txt

@@ -0,0 +1,8 @@
+onnxruntime-gpu==1.15.1
+qrcode[pil]
+rembg==2.0.50
+tensorflow
+facexlib==0.3.0
+insightface==0.7.3
+basicsr==1.4.2
+pytoshop

reqs_windows.txt

@@ -0,0 +1,19 @@
+https://github.com/melMass/comfy_mtb/releases/download/v0.1.3/pycocotools-2.0.6-cp310-cp310-win_amd64.whl
+https://github.com/melMass/comfy_mtb/releases/download/v0.1.3/future-0.18.3-py3-none-any.whl
+https://github.com/melMass/comfy_mtb/releases/download/v0.1.3/filterpy-1.4.5-py3-none-any.whl
+https://github.com/melMass/comfy_mtb/releases/download/v0.1.3/easydict-1.10-py3-none-any.whl
+https://github.com/melMass/comfy_mtb/releases/download/v0.1.3/gdown-4.7.1-py3-none-any.whl
+https://github.com/melMass/comfy_mtb/releases/download/v0.1.3/basicsr-1.4.2-py3-none-any.whl
+https://github.com/melMass/comfy_mtb/releases/download/v0.1.3/mmcv-2.0.0-py2.py3-none-any.whl
+https://github.com/melMass/comfy_mtb/releases/download/v0.1.3/insightface-0.7.3-cp310-cp310-win_amd64.whl
+
+onnxruntime-gpu==1.15.1
+qrcode[pil]
+rembg==2.0.50
+# on windows non WSL 2.10 is the last version with GPU support
+tensorflow==2.10.1;
+tb-nightly==2.12.0a20230126; platform_system == "Windows"
+facexlib==0.3.0
+# the old tf version on windows comes with a breaking protobuf version
+protobuf==3.19.6
+pytoshop

requirements.txt

@@ -1,10 +0,0 @@
-qrcode[pil]
-onnxruntime-gpu
-requirements-parser
-# opencv-contrib
-rembg
-imageio_ffmpeg
-rich
-rich_argparse
-matplotlib
-pillow

scripts/update_changelog.nu

@@ -1,2 +0,0 @@
-$env.GITHUB_TOKEN = (gh auth token) 
-git cliff --tag main | save -f CHANGELOG.md

types/shared.d.ts

@@ -1,126 +0,0 @@
-// Some manual types I use to facilitate developing on top of
-// Comfy's Litegraph implementation.
-
-import type {
-  ContextMenuItem,
-  LGraphNode,
-  IWidget,
-  LGraph,
-} from '../../../web/types/litegraph'
-
-export type {
-  ComfyExtension,
-  ComfyObjectInfo,
-  ComfyObjectInfoConfig,
-} from '../../../web/types/comfy'
-
-export type {
-  ContextMenuItem,
-  IWidget,
-  LLink,
-  INodeInputSlot,
-  INodeOutputSlot,
-} from '../../../web/types/litegraph'
-
-export type VectorWidget = IWidget<number[], { default: number[] }>
-export interface NodeData {
-  category: str
-  description: str
-  display_name: str
-  input: NodeInput
-  name: str
-  output: [str]
-  output_is_list: [boolean]
-  output_name: [str]
-  output_node: boolean
-}
-
-export interface ComfyDialog {
-  element: Element
-  close: () => void
-  show: (html: str) => void
-}
-
-export interface ComfySettingsDialog {
-  app: ComfyApp
-  element: Element
-  settingsValues: Record<string, unknown>
-  settingsLookup: Record<string, unknown>
-  load: () => Promise<void>
-  setSettingValueAsync: (id: string, value: unknown) => Promise<void>
-}
-
-export interface ComfyUI {
-  app: ComfyApp
-  dialog: ComfyDialog
-  settings: ComfySettingsDialog
-  autoQueueMode: 'instant' | 'change'
-  batchCount: number
-  lastQueueSize: number
-  graphHasChanged: boolean
-  queue: ComfyList
-  history: ComfyList
-}
-
-/**Very incomplete Comfy App definition*/
-interface ComfyApp {
-  graph: LGraph
-  queueItems: { number: number; batchCount: number }[]
-  processingQueue: boolean
-  ui: ComfyUI
-  extensions: ComfyExtension[]
-  nodeOutputs: Record<string, unknown>
-  nodePreviewImages: Record<string, Image>
-  shiftDown: boolean
-  isImageNode: (node: LGraphNodeExtended) => boolean
-  queuePrompt: (number: number, batchCount: number) => Promise<void>
-  /** Loads workflow data from the specified file*/
-  handleFile: (file: File) => Promise<void>
-}
-
-export type { ComfyApp as App }
-
-export interface LGraphNodeExtension {
-  addDOMWidget: (
-    name: string,
-    type: string,
-    element: Element,
-    options: Record<string, unknown>,
-  ) => IWidget
-  onNodeCreated: () => void
-  getExtraMenuOptions: () => ContextMenuItem[]
-  prototype: LGraphNodeExtended
-}
-
-export type LGraphNodeExtended = LGraphNode & LGraphNodeExtension
-
-export interface NodeType /*extends LGraphNode*/ {
-  category: str
-  comfyClass: str
-  length: 0
-  name: str
-  nodeData: NodeData
-  prototype: LGraphNodeExtended
-  title: str
-  type: str
-}
-
-export interface NodeInput {
-  required: object
-}
-
-// NOTE: for prototype overriding
-export type OnDrawWidgetParams = Parameters<IWidget['draw']>
-export type OnDrawForegroundParams = Parameters<LGraphNode['onDrawForeground']>
-export type OnMouseDownParams = Parameters<LGraphNode['onMouseDown']>
-export type OnConnectionsChangeParams = Parameters<
-  LGraphNode['onConnectionsChange']
->
-export type OnNodeCreatedParams = Parameters<
-  LGraphNodeExtension['onNodeCreated']
->
-
-export interface DocumentationOptions {
-  icon_size?: number
-  icon_margin?: number
-}

types/typedefs.js

@@ -1,18 +0,0 @@
-/**
- * @typedef {import("./shared.d.ts").NodeData} NodeData
- * @typedef {import("./shared.d.ts").NodeType} NodeType
- * @typedef {import("./shared.d.ts").DocumentationOptions} DocumentationOptions
- * @typedef {import("./shared.d.ts").OnDrawForegroundParams} OnDrawForegroundParams
- * @typedef {import("./shared.d.ts").OnMouseDownParams} OnMouseDownParams
- * @typedef {import("./shared.d.ts").OnConnectionsChangeParams} OnConnectionsChangeParams
- * @typedef {import("./shared.d.ts").ContextMenuItem} ContextMenuItem
- * @typedef {import("./shared.d.ts").IWidget} IWidget
- * @typedef {import("./shared.d.ts").VectorWidget} VectorWidget
- * @typedef {import("./shared.d.ts").LGraphNodeExtended} LGraphNode
- * @typedef {import("./shared.d.ts").LLink} LLink
- * @typedef {import("./shared.d.ts").App} App
- * @typedef {import("./shared.d.ts").OnDrawWidgetParams} OnDrawWidgetParams
- * @typedef {import("./shared.d.ts").INodeInputSlot} INodeInputSlot
- * @typedef {import("./shared.d.ts").INodeOutputSlot} INodeOutputSlot
- */
-

utils.py

@@ -1,25 +1,23 @@
-import contextlib
-import functools
-import importlib
-import math
-import os
-import shlex
-import shutil
-import socket
-import subprocess
-import sys
-import uuid
-from enum import Enum
-from pathlib import Path
-from typing import TypeVar
-
-import folder_paths
-import numpy as np
-import requests
-import torch
 from PIL import Image
+import numpy as np
+import torch
+from pathlib import Path
+import sys
 
-from .install import pip_map
+from typing import List, Optional
+from pytoshop.user import nested_layers
+from pytoshop import enums
+
+# from pytoshop.layers import LayerMask, LayerRecord
+from .log import log
+from typing import List
+import signal
+from contextlib import suppress
+from queue import Queue, Empty
+import subprocess
+import threading
+import os
+import math
 
 try:
     from .log import log
@@ -35,316 +33,7 @@ except ImportError:
         log.warn("[comfy mtb] You probably called the file outside a module.")
 
 
-# region SANITY_CHECK Utilities
-
-
-def make_report():
-    pass
-
-
-# endregion
-
-
-# region NFOV
-class numpy_NFOV:
-    def __init__(self, fov=None, height: int = 400, width: int = 800):
-        self.field_of_view = fov or [0.45, 0.45]
-        self.PI = np.pi
-        self.PI_2 = np.pi * 0.5
-        self.PI2 = np.pi * 2.0
-        self.height = height
-        self.width = width
-        self.screen_points = self._get_screen_img()
-
-    def _get_coord_rad(self, is_center_point, center_point=None):
-        if is_center_point:
-            center_point = np.array(center_point)
-            return (center_point * 2 - 1) * np.array([self.PI, self.PI_2])
-        else:
-            return (
-                (self.screen_points * 2 - 1)
-                * np.array([self.PI, self.PI_2])
-                * (np.ones(self.screen_points.shape) * self.field_of_view)
-            )
-
-    def _get_screen_img(self):
-        xx, yy = np.meshgrid(
-            np.linspace(0, 1, self.width), np.linspace(0, 1, self.height)
-        )
-        return np.array([xx.ravel(), yy.ravel()]).T
-
-    def _calc_spherical_to_gnomonic(self, converted_screen_coord):
-        x = converted_screen_coord.T[0]
-        y = converted_screen_coord.T[1]
-
-        rou = np.sqrt(x**2 + y**2)
-        c = np.arctan(rou)
-        sin_c = np.sin(c)
-        cos_c = np.cos(c)
-
-        lat = np.arcsin(
-            cos_c * np.sin(self.cp[1]) + (y * sin_c * np.cos(self.cp[1])) / rou
-        )
-        lon = self.cp[0] + np.arctan2(
-            x * sin_c,
-            rou * np.cos(self.cp[1]) * cos_c - y * np.sin(self.cp[1]) * sin_c,
-        )
-
-        lat = (lat / self.PI_2 + 1.0) * 0.5
-        lon = (lon / self.PI + 1.0) * 0.5
-
-        return np.array([lon, lat]).T
-
-    def _bilinear_interpolation(self, screen_coord):
-        uf = np.mod(screen_coord.T[0], 1) * self.frame_width  # long - width
-        vf = np.mod(screen_coord.T[1], 1) * self.frame_height  # lat - height
-
-        x0 = np.floor(uf).astype(int)  # coord of pixel to bottom left
-        y0 = np.floor(vf).astype(int)
-        x2 = np.add(
-            x0, np.ones(uf.shape).astype(int)
-        )  # coords of pixel to top right
-        y2 = np.add(y0, np.ones(vf.shape).astype(int))
-
-        base_y0 = np.multiply(y0, self.frame_width)
-        base_y2 = np.multiply(y2, self.frame_width)
-
-        A_idx = np.add(base_y0, x0)
-        B_idx = np.add(base_y2, x0)
-        C_idx = np.add(base_y0, x2)
-        D_idx = np.add(base_y2, x2)
-
-        flat_img = np.reshape(self.frame, [-1, self.frame_channel])
-
-        A = np.take(flat_img, A_idx, axis=0)
-        B = np.take(flat_img, B_idx, axis=0)
-        C = np.take(flat_img, C_idx, axis=0)
-        D = np.take(flat_img, D_idx, axis=0)
-
-        wa = np.multiply(x2 - uf, y2 - vf)
-        wb = np.multiply(x2 - uf, vf - y0)
-        wc = np.multiply(uf - x0, y2 - vf)
-        wd = np.multiply(uf - x0, vf - y0)
-
-        # interpolate
-        AA = np.multiply(A, np.array([wa, wa, wa]).T)
-        BB = np.multiply(B, np.array([wb, wb, wb]).T)
-        CC = np.multiply(C, np.array([wc, wc, wc]).T)
-        DD = np.multiply(D, np.array([wd, wd, wd]).T)
-        nfov = np.reshape(
-            np.round(AA + BB + CC + DD).astype(np.uint8),
-            [self.height, self.width, 3],
-        )
-
-        return nfov
-
-    def to_nfov(self, frame, center_point):
-        self.frame = frame
-        self.frame_height = frame.shape[0]
-        self.frame_width = frame.shape[1]
-        self.frame_channel = frame.shape[2]
-
-        self.cp = self._get_coord_rad(
-            center_point=center_point, is_center_point=True
-        )
-        converted_screen_coord = self._get_coord_rad(is_center_point=False)
-        return self._bilinear_interpolation(
-            self._calc_spherical_to_gnomonic(converted_screen_coord)
-        )
-
-
-# endregion
-
-
-# region SERVER Utilities
-class IPChecker:
-    def __init__(self):
-        self.ips = list(self.get_local_ips())
-        log.debug(f"Found {len(self.ips)} local ips")
-        self.checked_ips = set()
-
-    def get_working_ip(self, test_url_template):
-        for ip in self.ips:
-            if ip not in self.checked_ips:
-                self.checked_ips.add(ip)
-                test_url = test_url_template.format(ip)
-                if self._test_url(test_url):
-                    return ip
-        return None
-
-    @staticmethod
-    def get_local_ips(prefix="192.168."):
-        hostname = socket.gethostname()
-        log.debug(f"Getting local ips for {hostname}")
-        for info in socket.getaddrinfo(hostname, None):
-            # Filter out IPv6 addresses if you only want IPv4
-            log.debug(info)
-            # if info[1] == socket.SOCK_STREAM and
-            if info[0] == socket.AF_INET and info[4][0].startswith(prefix):
-                yield info[4][0]
-
-    def _test_url(self, url):
-        try:
-            response = requests.get(url)
-            return response.status_code == 200
-        except Exception:
-            return False
-
-
-@functools.lru_cache(maxsize=1)
-def get_server_info():
-    from comfy.cli_args import args
-
-    ip_checker = IPChecker()
-    base_url = args.listen
-    if base_url == "0.0.0.0":
-        log.debug("Server set to 0.0.0.0, we will try to resolve the host IP")
-        base_url = ip_checker.get_working_ip(
-            f"http://{{}}:{args.port}/history"
-        )
-        log.debug(f"Setting ip to {base_url}")
-    return (base_url, args.port)
-
-
-# endregion
-
-
 # region MISC Utilities
-
-
-# TODO: use mtb.core directly instead of copying parts here
-T = TypeVar("T", bound="StringConvertibleEnum")
-
-
-class StringConvertibleEnum(Enum):
-    """Base class for enums with utility methods for string conversion and member listing."""
-
-    @classmethod
-    def from_str(cls: type[T], label: str | T) -> T:
-        """
-        Convert a string to the corresponding enum value (case sensitive).
-
-        Args:
-            label (Union[str, T]): The string or enum value to convert.
-
-        Returns
-        -------
-            T: The corresponding enum value.
-
-        Raises
-        ------
-            ValueError: If the label does not correspond to any enum member.
-        """
-        if isinstance(label, cls):
-            return label
-        if isinstance(label, str):
-            # from key
-            if label in cls.__members__:
-                return cls[label]
-
-            for member in cls:
-                if member.value == label:
-                    return member
-
-        raise ValueError(
-            f"Unknown label: '{label}'. Valid members: {list(cls.__members__.keys())}, "
-            f"valid values: {cls.list_members()}"
-        )
-
-    @classmethod
-    def to_str(cls: type[T], enum_value: T) -> str:
-        """
-        Convert an enum value to its string representation.
-
-        Args:
-            enum_value (T): The enum value to convert.
-
-        Returns
-        -------
-            str: The string representation of the enum value.
-
-        Raises
-        ------
-            ValueError: If the enum value is invalid.
-        """
-        if isinstance(enum_value, cls):
-            return enum_value.value
-        raise ValueError(f"Invalid Enum: {enum_value}")
-
-    @classmethod
-    def list_members(cls: type[T]) -> list[str]:
-        """
-        Return a list of string representations of all enum members.
-
-        Returns
-        -------
-            List[str]: List of all enum member values.
-        """
-        return [enum.value for enum in cls]
-
-    def __str__(self) -> str:
-        """
-        Returns the string representation of the enum value.
-
-        Returns
-        -------
-            str: The string representation of the enum value.
-        """
-        return self.value
-
-
-class Precision(StringConvertibleEnum):
-    FULL = "full"
-    FP32 = "fp32"
-    FP16 = "fp16"
-    BF16 = "bf16"
-    FP8 = "fp8"
-
-    def to_dtype(self):
-        match self:
-            case Precision.FP32 | Precision.FULL:
-                return torch.float32
-            case Precision.FP16:
-                return torch.float16
-            case Precision.BF16:
-                return torch.bfloat16
-            case Precision.FP8:
-                return torch.float8_e4m3fn
-
-
-class Operation(StringConvertibleEnum):
-    COPY = "copy"
-    CONVERT = "convert"
-    DELETE = "delete"
-
-
-def backup_file(
-    fp: Path,
-    target: Path | None = None,
-    backup_dir: str = ".bak",
-    suffix: str | None = None,
-    prefix: str | None = None,
-):
-    if not fp.exists():
-        raise FileNotFoundError(f"No file found at {fp}")
-
-    backup_directory = target or fp.parent / backup_dir
-    backup_directory.mkdir(parents=True, exist_ok=True)
-
-    stem = fp.stem
-
-    if suffix or prefix:
-        new_stem = f"{prefix or ''}{stem}{suffix or ''}"
-    else:
-        new_stem = f"{stem}_{uuid.uuid4()}"
-
-    backup_file_path = backup_directory / f"{new_stem}{fp.suffix}"
-
-    # Perform the backup
-    shutil.copy(fp, backup_file_path)
-    log.debug(f"File backed up to {backup_file_path}")
-
-
 def hex_to_rgb(hex_color):
     try:
         hex_color = hex_color.lstrip("#")
@@ -370,78 +59,101 @@ def add_path(path, prepend=False):
             sys.path.append(path)
 
 
-def run_command(cmd, ignored_lines_start=None):
-    if ignored_lines_start is None:
-        ignored_lines_start = []
+def enqueue_output(out, queue):
+    for line in iter(out.readline, b""):
+        queue.put(line)
+    out.close()
 
+
+def run_command(cmd):
     if isinstance(cmd, str):
         shell_cmd = cmd
     elif isinstance(cmd, list):
-        shell_cmd = " ".join(
-            arg.as_posix() if isinstance(arg, Path) else shlex.quote(str(arg))
-            for arg in cmd
-        )
+        shell_cmd = ""
+        for arg in cmd:
+            if isinstance(arg, Path):
+                arg = arg.as_posix()
+            shell_cmd += f"{arg} "
     else:
         raise ValueError(
             "Invalid 'cmd' argument. It must be a string or a list of arguments."
         )
 
-    try:
-        _run_command(shell_cmd, ignored_lines_start)
-    except subprocess.CalledProcessError as e:
-        print(
-            f"Command failed with return code: {e.returncode}", file=sys.stderr
-        )
-        print(e.stderr.strip(), file=sys.stderr)
-
-    except KeyboardInterrupt:
-        print("Command execution interrupted.")
-
-
-def _run_command(shell_cmd, ignored_lines_start):
-    log.debug(f"Running {shell_cmd}")
-
-    result = subprocess.run(
+    process = subprocess.Popen(
         shell_cmd,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
-        text=True,
+        universal_newlines=True,
         shell=True,
-        check=True,
     )
 
-    stdout_lines = result.stdout.strip().split("\n")
-    stderr_lines = result.stderr.strip().split("\n")
+    # Create separate threads to read standard output and standard error streams
+    stdout_queue = Queue()
+    stderr_queue = Queue()
+    stdout_thread = threading.Thread(
+        target=enqueue_output, args=(process.stdout, stdout_queue)
+    )
+    stderr_thread = threading.Thread(
+        target=enqueue_output, args=(process.stderr, stderr_queue)
+    )
+    stdout_thread.daemon = True
+    stderr_thread.daemon = True
+    stdout_thread.start()
+    stderr_thread.start()
 
-    # Print stdout, skipping ignored lines
-    for line in stdout_lines:
-        if not any(line.startswith(ign) for ign in ignored_lines_start):
-            print(line)
+    interrupted = False
 
-    # Print stderr
-    for line in stderr_lines:
-        print(line, file=sys.stderr)
+    def signal_handler(signum, frame):
+        nonlocal interrupted
+        interrupted = True
+        print("Command execution interrupted.")
 
-    print("Command executed successfully!")
+    # Register the signal handler for keyboard interrupts (SIGINT)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # Process output from both streams until the process completes or interrupted
+    while not interrupted and (
+        process.poll() is None or not stdout_queue.empty() or not stderr_queue.empty()
+    ):
+        with suppress(Empty):
+            stdout_line = stdout_queue.get_nowait()
+            if stdout_line.strip() != "":
+                print(stdout_line.strip())
+        with suppress(Empty):
+            stderr_line = stderr_queue.get_nowait()
+            if stderr_line.strip() != "":
+                print(stderr_line.strip())
+    return_code = process.returncode
+
+    if return_code == 0 and not interrupted:
+        print("Command executed successfully!")
+    else:
+        if not interrupted:
+            print(f"Command failed with return code: {return_code}")
+
+
+# todo use the requirements library
+reqs_map = {
+    "onnxruntime": "onnxruntime-gpu==1.15.1",
+    "basicsr": "basicsr==1.4.2",
+    "rembg": "rembg==2.0.50",
+    "qrcode": "qrcode[pil]",
+}
 
 
 def import_install(package_name):
-    package_spec = reqs_map.get(package_name, package_name)
+    from pip._internal import main as pip_main
 
     try:
-        importlib.import_module(package_name)
+        __import__(package_name)
+    except ImportError:
+        package_spec = reqs_map.get(package_name)
+        if package_spec is None:
+            print(f"Installing {package_name}")
+            package_spec = package_name
 
-    except Exception:  # (ImportError, ModuleNotFoundError):
-        run_command(
-            [
-                Path(sys.executable).as_posix(),
-                "-m",
-                "pip",
-                "install",
-                package_spec,
-            ]
-        )
-        importlib.import_module(package_name)
+        pip_main(["install", package_spec])
+        __import__(package_name)
 
 
 # endregion
@@ -458,36 +170,24 @@ elif ".venv" in sys.executable:
     comfy_mode = "venv"
 
 # - Get the absolute path of the parent directory of the current script
-here = Path(__file__).parent.absolute()
+here = Path(__file__).parent.resolve()
 
 # - Construct the absolute path to the ComfyUI directory
-comfy_dir = Path(folder_paths.base_path)
-models_dir = Path(folder_paths.models_dir)
-output_dir = Path(folder_paths.output_directory)
-styles_dir = comfy_dir / "styles"
-session_id = str(uuid.uuid4())
+comfy_dir = here.parent.parent
+
 # - Construct the path to the font file
-font_path = here / "data" / "font.ttf"
+font_path = here / "font.ttf"
 
 # - Add extern folder to path
 extern_root = here / "extern"
 add_path(extern_root)
-
 for pth in extern_root.iterdir():
     if pth.is_dir():
         add_path(pth)
 
 # - Add the ComfyUI directory and custom nodes path to the sys.path list
 add_path(comfy_dir)
-add_path(comfy_dir / "custom_nodes")
-
-
-# TODO: use the requirements library
-reqs_map = {value: key for key, value in pip_map.items()}
-
-# NOTE: store already logged warnings to only alert once.
-warned_messages: set[str] = set()
-
+add_path((comfy_dir / "custom_nodes"))
 
 PIL_FILTER_MAP = {
     "nearest": Image.Resampling.NEAREST,
@@ -500,8 +200,8 @@ PIL_FILTER_MAP = {
 # endregion
 
 
-# region TENSOR Utilities
-def tensor2pil(image: torch.Tensor) -> list[Image.Image]:
+# region TENSOR UTILITIES
+def tensor2pil(image: torch.Tensor) -> List[Image.Image]:
     batch_count = image.size(0) if len(image.shape) > 3 else 1
     if batch_count > 1:
         out = []
@@ -511,30 +211,26 @@ def tensor2pil(image: torch.Tensor) -> list[Image.Image]:
 
     return [
         Image.fromarray(
-            np.clip(255.0 * image.cpu().numpy().squeeze(), 0, 255).astype(
-                np.uint8
-            )
+            np.clip(255.0 * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8)
         )
     ]
 
 
-def pil2tensor(image: Image.Image | list[Image.Image]) -> torch.Tensor:
+def pil2tensor(image: Image.Image | List[Image.Image]) -> torch.Tensor:
     if isinstance(image, list):
         return torch.cat([pil2tensor(img) for img in image], dim=0)
 
-    return torch.from_numpy(
-        np.array(image).astype(np.float32) / 255.0
-    ).unsqueeze(0)
+    return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
 
 
-def np2tensor(img_np: np.ndarray | list[np.ndarray]) -> torch.Tensor:
+def np2tensor(img_np: np.ndarray | List[np.ndarray]) -> torch.Tensor:
     if isinstance(img_np, list):
         return torch.cat([np2tensor(img) for img in img_np], dim=0)
 
     return torch.from_numpy(img_np.astype(np.float32) / 255.0).unsqueeze(0)
 
 
-def tensor2np(tensor: torch.Tensor) -> list[np.ndarray]:
+def tensor2np(tensor: torch.Tensor) -> List[np.ndarray]:
     batch_count = tensor.size(0) if len(tensor.shape) > 3 else 1
     if batch_count > 1:
         out = []
@@ -542,204 +238,7 @@ def tensor2np(tensor: torch.Tensor) -> list[np.ndarray]:
             out.extend(tensor2np(tensor[i]))
         return out
 
-    return [
-        np.clip(255.0 * tensor.cpu().numpy().squeeze(), 0, 255).astype(
-            np.uint8
-        )
-    ]
-
-
-def pad(img, left, right, top, bottom):
-    pad_width = np.array(((0, 0), (top, bottom), (left, right)))
-    print(
-        f"pad_width: {pad_width}, shape: {pad_width.shape}"
-    )  # Debugging line
-    return np.pad(img, pad_width, mode="wrap")
-
-
-def tiles_infer(tiles, ort_session, progress_callback=None):
-    """Infer each tile with the given model. progress_callback will be called with
-    arguments : current tile idx and total tiles amount (used to show progress on
-    cursor in Blender).
-    """
-    out_channels = 3  # normal map RGB channels
-    tiles_nb = tiles.shape[0]
-    pred_tiles = np.empty(
-        (tiles_nb, out_channels, tiles.shape[2], tiles.shape[3])
-    )
-
-    for i in range(tiles_nb):
-        if progress_callback != None:
-            progress_callback(i + 1, tiles_nb)
-        pred_tiles[i] = ort_session.run(
-            None, {"input": tiles[i : i + 1].astype(np.float32)}
-        )[0]
-
-    return pred_tiles
-
-
-def generate_mask(tile_size, stride_size):
-    """Generates a pyramidal-like mask. Used for mixing overlapping predicted tiles."""
-    tile_h, tile_w = tile_size
-    stride_h, stride_w = stride_size
-    ramp_h = tile_h - stride_h
-    ramp_w = tile_w - stride_w
-
-    mask = np.ones((tile_h, tile_w))
-
-    # ramps in width direction
-    mask[ramp_h:-ramp_h, :ramp_w] = np.linspace(0, 1, num=ramp_w)
-    mask[ramp_h:-ramp_h, -ramp_w:] = np.linspace(1, 0, num=ramp_w)
-    # ramps in height direction
-    mask[:ramp_h, ramp_w:-ramp_w] = np.transpose(
-        np.linspace(0, 1, num=ramp_h)[None], (1, 0)
-    )
-    mask[-ramp_h:, ramp_w:-ramp_w] = np.transpose(
-        np.linspace(1, 0, num=ramp_h)[None], (1, 0)
-    )
-
-    # Assume tiles are squared
-    assert ramp_h == ramp_w
-    # top left corner
-    corner = np.rot90(corner_mask(ramp_h), 2)
-    mask[:ramp_h, :ramp_w] = corner
-    # top right corner
-    corner = np.flip(corner, 1)
-    mask[:ramp_h, -ramp_w:] = corner
-    # bottom right corner
-    corner = np.flip(corner, 0)
-    mask[-ramp_h:, -ramp_w:] = corner
-    # bottom right corner
-    corner = np.flip(corner, 1)
-    mask[-ramp_h:, :ramp_w] = corner
-
-    return mask
-
-
-def corner_mask(side_length):
-    """Generates the corner part of the pyramidal-like mask.
-    Currently, only for square shapes.
-    """
-    corner = np.zeros([side_length, side_length])
-
-    for h in range(0, side_length):
-        for w in range(0, side_length):
-            if h >= w:
-                sh = h / (side_length - 1)
-                corner[h, w] = 1 - sh
-            if h <= w:
-                sw = w / (side_length - 1)
-                corner[h, w] = 1 - sw
-
-    return corner - 0.25 * scaling_mask(side_length)
-
-
-def scaling_mask(side_length):
-    scaling = np.zeros([side_length, side_length])
-
-    for h in range(0, side_length):
-        for w in range(0, side_length):
-            sh = h / (side_length - 1)
-            sw = w / (side_length - 1)
-            if h >= w and h <= side_length - w:
-                scaling[h, w] = sw
-            if h <= w and h <= side_length - w:
-                scaling[h, w] = sh
-            if h >= w and h >= side_length - w:
-                scaling[h, w] = 1 - sh
-            if h <= w and h >= side_length - w:
-                scaling[h, w] = 1 - sw
-
-    return 2 * scaling
-
-
-def tiles_merge(tiles, stride_size, img_size, paddings):
-    """Merges the list of tiles into one image. img_size is the original size, before
-    padding.
-    """
-    _, tile_h, tile_w = tiles[0].shape
-    pad_left, pad_right, pad_top, pad_bottom = paddings
-    height = img_size[1] + pad_top + pad_bottom
-    width = img_size[2] + pad_left + pad_right
-    stride_h, stride_w = stride_size
-
-    # stride must be even
-    assert (stride_h % 2 == 0) and (stride_w % 2 == 0)
-    # stride must be greater or equal than half tile
-    assert (stride_h >= tile_h / 2) and (stride_w >= tile_w / 2)
-    # stride must be smaller or equal tile size
-    assert (stride_h <= tile_h) and (stride_w <= tile_w)
-
-    merged = np.zeros((img_size[0], height, width))
-    mask = generate_mask((tile_h, tile_w), stride_size)
-
-    h_range = ((height - tile_h) // stride_h) + 1
-    w_range = ((width - tile_w) // stride_w) + 1
-
-    idx = 0
-    for h in range(0, h_range):
-        for w in range(0, w_range):
-            h_from, h_to = h * stride_h, h * stride_h + tile_h
-            w_from, w_to = w * stride_w, w * stride_w + tile_w
-            merged[:, h_from:h_to, w_from:w_to] += tiles[idx] * mask
-            idx += 1
-
-    return merged[:, pad_top:-pad_bottom, pad_left:-pad_right]
-
-
-def tiles_split(img, tile_size, stride_size):
-    """Returns list of tiles from the given image and the padding used to fit the tiles
-    in it. Input image must have dimension C,H,W.
-    """
-    log.debug(f"Splitting img: tile {tile_size}, stride {stride_size} ")
-    tile_h, tile_w = tile_size
-    stride_h, stride_w = stride_size
-    img_h, img_w = img.shape[0], img.shape[1]
-
-    # stride must be even
-    assert (stride_h % 2 == 0) and (stride_w % 2 == 0)
-    # stride must be greater or equal than half tile
-    assert (stride_h >= tile_h / 2) and (stride_w >= tile_w / 2)
-    # stride must be smaller or equal tile size
-    assert (stride_h <= tile_h) and (stride_w <= tile_w)
-
-    # find total height & width padding sizes
-    pad_h, pad_w = 0, 0
-    remainer_h = (img_h - tile_h) % stride_h
-    remainer_w = (img_w - tile_w) % stride_w
-    if remainer_h != 0:
-        pad_h = stride_h - remainer_h
-    if remainer_w != 0:
-        pad_w = stride_w - remainer_w
-
-    # if tile bigger than image, pad image to tile size
-    if tile_h > img_h:
-        pad_h = tile_h - img_h
-    if tile_w > img_w:
-        pad_w = tile_w - img_w
-
-    # pad image, add extra stride to padding to avoid pyramid
-    # weighting leaking onto the valid part of the picture
-    pad_left = pad_w // 2 + stride_w
-    pad_right = pad_left if pad_w % 2 == 0 else pad_left + 1
-    pad_top = pad_h // 2 + stride_h
-    pad_bottom = pad_top if pad_h % 2 == 0 else pad_top + 1
-    img = pad(img, pad_left, pad_right, pad_top, pad_bottom)
-    img_h, img_w = img.shape[1], img.shape[2]
-
-    # extract tiles
-    h_range = ((img_h - tile_h) // stride_h) + 1
-    w_range = ((img_w - tile_w) // stride_w) + 1
-    tiles = np.empty([h_range * w_range, img.shape[0], tile_h, tile_w])
-    idx = 0
-    for h in range(0, h_range):
-        for w in range(0, w_range):
-            h_from, h_to = h * stride_h, h * stride_h + tile_h
-            w_from, w_to = w * stride_w, w * stride_w + tile_w
-            tiles[idx] = img[:, h_from:h_to, w_from:w_to]
-            idx += 1
-
-    return tiles, (pad_left, pad_right, pad_top, pad_bottom)
+    return [np.clip(255.0 * tensor.cpu().numpy().squeeze(), 0, 255).astype(np.uint8)]
 
 
 # endregion
@@ -747,16 +246,16 @@ def tiles_split(img, tile_size, stride_size):
 
 # region MODEL Utilities
 def download_antelopev2():
-    antelopev2_url = (
-        "https://drive.google.com/uc?id=18wEUfMNohBJ4K3Ly5wpTejPfDzp-8fI8"
-    )
+    antelopev2_url = "https://drive.google.com/uc?id=18wEUfMNohBJ4K3Ly5wpTejPfDzp-8fI8"
 
     try:
         import gdown
 
+        import folder_paths
+
         log.debug("Loading antelopev2 model")
 
-        dest = get_model_path("insightface")
+        dest = Path(folder_paths.models_dir) / "insightface"
         archive = dest / "antelopev2.zip"
         final_path = dest / "models" / "antelopev2"
         if not final_path.exists():
@@ -783,34 +282,6 @@ def download_antelopev2():
         raise e
 
 
-def get_model_path(fam, model=None):
-    log.debug(f"Requesting {fam} with model {model}")
-    res = None
-    if model:
-        res = folder_paths.get_full_path(fam, model)
-    else:
-        # this one can raise errors...
-        with contextlib.suppress(KeyError):
-            res = folder_paths.get_folder_paths(fam)
-
-    if res:
-        if isinstance(res, list):
-            if len(res) > 1:
-                warn_msg = f"Found multiple match, we will pick the last {res[-1]}\n{res}"
-                if warn_msg not in warned_messages:
-                    log.info(warn_msg)
-                    warned_messages.add(warn_msg)
-            res = res[-1]
-        res = Path(res)
-        log.debug(f"Resolved model path from folder_paths: {res}")
-    else:
-        res = models_dir / fam
-        if model:
-            res /= model
-
-    return res
-
-
 # endregion
 
 
@@ -834,33 +305,10 @@ def create_uv_map_tensor(width=512, height=512):
 
 
 # region ANIMATION Utilities
-EASINGS = [
-    "Linear",
-    "Sine In",
-    "Sine Out",
-    "Sine In/Out",
-    "Quart In",
-    "Quart Out",
-    "Quart In/Out",
-    "Cubic In",
-    "Cubic Out",
-    "Cubic In/Out",
-    "Circ In",
-    "Circ Out",
-    "Circ In/Out",
-    "Back In",
-    "Back Out",
-    "Back In/Out",
-    "Elastic In",
-    "Elastic Out",
-    "Elastic In/Out",
-    "Bounce In",
-    "Bounce Out",
-    "Bounce In/Out",
-]
-
-
 def apply_easing(value, easing_type):
+    if value < 0 or value > 1:
+        raise ValueError("The value should be between 0 and 1.")
+
     if easing_type == "Linear":
         return value
 
@@ -887,10 +335,7 @@ def apply_easing(value, easing_type):
             return 1
         p = 0.3
         s = p / 4
-        return -(
-            math.pow(2, 10 * (t - 1))
-            * math.sin((t - 1 - s) * (2 * math.pi) / p)
-        )
+        return -(math.pow(2, 10 * (t - 1)) * math.sin((t - 1 - s) * (2 * math.pi) / p))
 
     def easeOutElastic(t):
         if t == 0:
@@ -911,13 +356,10 @@ def apply_easing(value, easing_type):
         t = t * 2
         if t < 1:
             return -0.5 * (
-                math.pow(2, 10 * (t - 1))
-                * math.sin((t - 1 - s) * (2 * math.pi) / p)
+                math.pow(2, 10 * (t - 1)) * math.sin((t - 1 - s) * (2 * math.pi) / p)
             )
         return (
-            0.5
-            * math.pow(2, -10 * (t - 1))
-            * math.sin((t - 1 - s) * (2 * math.pi) / p)
+            0.5 * math.pow(2, -10 * (t - 1)) * math.sin((t - 1 - s) * (2 * math.pi) / p)
             + 1
         )
 
@@ -1032,3 +474,53 @@ def apply_easing(value, easing_type):
 
 
 # endregion
+
+
+def tensor2pytolayer(
+    tensor: torch.Tensor,
+    name: str,
+    visible: bool = True,
+    opacity: int = 255,
+    group_id: int = 0,
+    blend_mode=enums.BlendMode.normal,
+    x: int = 0,
+    y: int = 0,
+    # channels: int = 3,
+    metadata: dict = {},
+    layer_color=0,
+    color_mode=None,
+    mask: Optional[
+        torch.Tensor
+    ] = None,  # Add the mask parameter with default value as None
+) -> nested_layers.Image:
+    batch_count = tensor.size(0) if len(tensor.shape) > 3 else 1
+    if batch_count > 1:
+        raise ValueError(
+            f"Only one image is supported (batch size is currently {batch_count})"
+        )
+    out_channels = tensor2pil(tensor)[0]
+    arr = np.array(out_channels)
+
+    # If a mask is provided, convert it to numpy array
+    if mask is not None:
+        mask_arr = np.array(tensor2pil(mask)[0])
+    else:
+        mask_arr = np.full_like(arr, 255, dtype=np.uint8)
+
+    channels = [arr[:, :, 0], arr[:, :, 1], arr[:, :, 2], mask_arr[:, :, 0]]
+
+    image = nested_layers.Image(
+        name=name,
+        visible=visible,
+        opacity=opacity,
+        group_id=group_id,
+        blend_mode=blend_mode,
+        top=y,
+        left=x,
+        channels=channels,
+        metadata=metadata,
+        layer_color=layer_color,
+        color_mode=color_mode,
+    )
+
+    return image

web/README.md

@@ -13,10 +13,6 @@ data otherwise:
 ![debug](https://github.com/melMass/comfy_mtb/assets/7041726/1f4393e4-1c3d-4807-9501-fe8888bfae25)
 
 
-**note +**
-A basic HTML note mainly to add better looking notes/instructions for workflow makers:
-![image](https://github.com/melMass/comfy_mtb/assets/7041726/2ba1f832-0044-4bad-974c-e6387981af57)
-
 
 ## Standalone
 These scripts can be taken and placed independently of `comfy_mtb` or any other files, mimicking what pythongosss did for their 

web/constant.js

@@ -1,496 +0,0 @@
-import { app } from '../../scripts/app.js'
-import * as shared from './comfy_shared.js'
-import { infoLogger } from './comfy_shared.js'
-import { MtbWidgets } from './mtb_widgets.js'
-import { ComfyWidgets } from '../../scripts/widgets.js'
-import * as mtb_widgets from './mtb_widgets.js'
-
-/**
- * @typedef {'number'|'string'|'vector2'|'vector3'|'vector4'|'color'} ConstantType
- * @typedef {import ("../../../web/types/litegraph.d.ts").LGraphNode} Node
- * @typedef {{x:number,y:number,z?:number,w?:number}} VectorValue
- * @typedef {}
- *
- */
-
-/**
- * @param {number} size - The number of axis of the vector (2,3 or 4)
- * @param {number} val - The default scalar value to fill the vector with
- * @returns {VectorValue} vector
- * */
-const initVector = (size, val = 0.0) => {
-  const res = {}
-  for (let i = 0; i < size; i++) {
-    const axis = mtb_widgets.VECTOR_AXIS[i]
-    res[axis] = val
-  }
-  return res
-}
-
-/**
- *
- * @extends {Node}
- * @classdesc Wrapper for the python node
- */
-export class ConstantJs {
-  constructor(python_node) {
-    // this.uuid = shared.makeUUID()
-    const wrapper = this
-
-    python_node.shape = LiteGraph.BOX_SHAPE
-    python_node.serialize_widgets = true
-
-    const onNodeCreated = python_node.prototype.onNodeCreated
-    python_node.prototype.onNodeCreated = function () {
-      const r = onNodeCreated ? onNodeCreated.apply(this) : undefined
-
-      this.addProperty('type', 'number')
-      this.addProperty('value', 0)
-
-      this.removeInput(0)
-      this.removeOutput(0)
-
-      this.addOutput('Output', '*')
-
-      // bind our wrapper
-      this.configure = wrapper.configure.bind(this)
-      // this.applyToGraph = wrapper.applyToGraph.bind(this)
-      this.updateWidgets = wrapper.updateWidgets.bind(this)
-      this.convertValue = wrapper.convertValue.bind(this)
-      // this.updateOutput = wrapper.updateOutput.bind(this)
-      this.updateOutputType = wrapper.updateOutputType.bind(this)
-      // this.updateTargetWidgets = wrapper.updateTargetWidgets.bind(this)
-
-      this.addWidget(
-        'combo',
-        'Type',
-        this.properties.type,
-        (value) => {
-          this.properties.type = value
-          this.updateWidgets()
-          this.updateOutputType()
-        },
-        {
-          values: [
-            // 'number',
-            'float',
-            'int',
-            'string',
-            'vector2',
-            'vector3',
-            'vector4',
-            'color',
-          ],
-        },
-      )
-      this.updateWidgets()
-      this.updateOutputType()
-
-      for (let n = 0; n < this.inputs.length; n++) {
-        this.removeInput(n)
-      }
-      this.inputs = []
-      return r
-    }
-    return
-  }
-
-  // NOTE: this is called onPrompt
-  // applyToGraph() {
-  // infoLogger('Updating values for backend')
-  // this.updateTargetWidgets()
-  // }
-
-  // NOTE: deserialization happens here
-  configure(info) {
-    // super.configure(info)
-    infoLogger('Configure Constant', { info, node: this })
-
-    this.properties.type = info.properties.type
-    this.properties.value = info.properties.value
-
-    this.pos = info.pos
-    this.order = info.order
-
-    this.updateWidgets()
-    this.updateOutputType()
-  }
-
-  /**
-   * Convert the old value type to the new one, falling back to some default
-   * @param {ConstantType} propType - The target type
-   */
-  convertValue(propType) {
-    switch (propType) {
-      case 'color': {
-        if (typeof this.properties.value !== 'string') {
-          this.properties.value = '#ffffff'
-        } else if (this.properties.value[0] !== '#') {
-          this.properties.value = '#ff0000'
-        }
-        break
-      }
-      case 'int': {
-        if (typeof this.properties.value === 'object') {
-          this.properties.value = Number.parseInt(this.properties.value.x)
-        } else {
-          this.properties.value = Number.parseInt(this.properties.value) || 0
-        }
-        break
-      }
-      case 'float': {
-        if (typeof this.properties.value === 'object') {
-          this.properties.value = Number.parseFloat(this.properties.value.x)
-        } else {
-          this.properties.value =
-            Number.parseFloat(this.properties.value) || 0.0
-        }
-        break
-      }
-      case 'string': {
-        if (typeof this.properties.value !== 'string') {
-          this.properties.value = JSON.stringify(this.properties.value)
-        }
-        break
-      }
-      case 'vector2':
-      case 'vector3':
-      case 'vector4': {
-        const numInputs = Number.parseInt(propType.charAt(6))
-        if (!this.properties.value) {
-          this.properties.value = initVector(numInputs) // Array.from({ length: numInputs }, () => 0.0)
-        } else if (typeof this.properties.value === 'string') {
-          try {
-            const parsed = JSON.parse(this.properties.value)
-            const newVec = {}
-            for (
-              let i = 0;
-              i < Object.keys(mtb_widgets.VECTOR_AXIS).length;
-              i++
-            ) {
-              const axis = mtb_widgets.VECTOR_AXIS[i]
-              if (Object.keys(parsed).includes(axis)) {
-                newVec[axis] = parsed[axis]
-              }
-            }
-            this.properties.value = newVec
-          } catch (e) {
-            shared.errorLogger(e)
-            infoLogger(
-              `Couldn't parse string to vec (${this.properties.value})`,
-            )
-            this.properties.value = initVector(numInputs)
-          }
-        } else if (typeof this.properties.value === 'number') {
-          const newVec = initVector(numInputs)
-          newVec.x = Number.parseFloat(this.properties.value)
-          this.properties.value = newVec
-        }
-
-        if (
-          typeof this.properties.value === 'object' &&
-          Object.keys(this.properties.value).length !== numInputs
-        ) {
-          const current = Object.keys(this.properties.value)
-          if (current.length < numInputs) {
-            infoLogger('current value smaller than target, adjusting')
-            for (let index = current.length; index < numInputs; index++) {
-              this.properties.value[mtb_widgets.VECTOR_AXIS[index]] = 0.0
-            }
-          } else {
-            infoLogger('current value greater than target, adjusting')
-            const newVal = {}
-            for (let index = 0; index < numInputs; index++) {
-              newVal[mtb_widgets.VECTOR_AXIS[index]] =
-                this.properties.value[mtb_widgets.VECTOR_AXIS[index]]
-            }
-            this.properties.value = newVal
-          }
-        }
-        break
-      }
-      default:
-        break
-    }
-  }
-
-  /**
-   * Remove all widgets but the comboBox for selecting the type
-   * then recreate the appropriate widget from scratch
-   */
-  updateWidgets() {
-    // NOTE: Remove existing widgets
-    for (let i = 1; i < this.widgets.length; i++) {
-      const element = this.widgets[i]
-      if (element.onRemove) {
-        element.onRemove()
-      }
-      // element?.onRemove()
-    }
-
-    this.widgets.splice(1)
-    this.widgets[0].value = this.properties.type
-
-    this.convertValue(this.properties.type)
-
-    switch (this.properties.type) {
-      case 'color': {
-        const col_widget = this.addCustomWidget(
-          MtbWidgets.COLOR('Value', this.properties.value),
-        )
-        col_widget.callback = (col) => {
-          this.properties.value = col
-          // this.updateOutput()
-        }
-        break
-      }
-      case 'int': {
-        const f_widget = this.addCustomWidget(
-          ComfyWidgets.INT(
-            this,
-            'Value',
-            [
-              '',
-              {
-                default: this.properties.value,
-                callback: (val) => console.log('VALUE', val),
-              },
-            ],
-            app,
-          ),
-        )
-
-        f_widget.widget.callback = (val) => {
-          this.properties.value = val
-        }
-
-        break
-      }
-      case 'float': {
-        this.addWidget('number', 'Value', this.properties.value, (val) => {
-          this.properties.value = val
-        })
-        break
-      }
-      case 'string': {
-        mtb_widgets.addMultilineWidget(
-          this,
-          'Value',
-          {
-            defaultVal: this.properties.value,
-          },
-          (v) => {
-            this.properties.value = v
-            // this.updateOutput()
-          },
-        )
-        break
-      }
-      case 'vector2':
-      case 'vector3':
-      case 'vector4': {
-        const numInputs = Number.parseInt(this.properties.type.charAt(6))
-        const node = this
-        const v_widget = mtb_widgets.addVectorWidget(
-          this,
-          'Value',
-          this.properties.value, // value
-          numInputs, // vector_size
-          function (v) {
-            node.properties.value = v
-            // this.updateOutput()
-          },
-        )
-        break
-      }
-
-      // NOTE: this is not reached anymore, kept for reference
-      case 'number': {
-        if (typeof this.properties.value !== 'number') {
-          this.properties.value = 0.0
-        }
-        const n_widget = this.addWidget(
-          'number',
-          'Value',
-          this.properties.force_int
-            ? Number.parseInt(this.properties.value)
-            : this.properties.value,
-          (value) => {
-            this.properties.value = this.properties.force_int
-              ? Number.parseInt(value)
-              : value
-            // this.updateOutput()
-          },
-        )
-        //override the callback
-        const origCallback = n_widget.callback
-        const node = this
-        n_widget.callback = function (val) {
-          const r = origCallback ? origCallback.apply(this, [val]) : undefined
-          if (node.properties.force_int) {
-            // TODO: rework this, a it makes it harder to manipulate
-            this.value = Number.parseInt(this.value)
-            node.properties.value = Number.parseInt(this.value)
-          }
-          infoLogger('NEW NUMBER', this.value)
-          return r
-        }
-
-        this.addWidget(
-          'toggle',
-          'Convert to Integer',
-          this.properties.force_int,
-          (value) => {
-            this.properties.force_int = value
-            this.updateOutputType()
-          },
-        )
-        break
-      }
-      default:
-        break
-    }
-  }
-  onConnectionsChange(type, slotIndex, isConnected, link, ioSlot) {
-    // super.onConnectionsChange(type, slotIndex, isConnected, link, ioSlot)
-    if (isConnected) {
-      this.updateTargetWidgets([link.id])
-    }
-  }
-
-  updateOutputType() {
-    infoLogger('Updating output type')
-    const rm_if_mismatch = (type) => {
-      if (this.outputs[0].type !== type) {
-        for (let i = 0; i < this.outputs.length; i++) {
-          this.removeOutput(i)
-        }
-        this.addOutput('output', type)
-        // this.setOutputDataType(0, type)
-      }
-    }
-    switch (this.properties.type) {
-      case 'color':
-        rm_if_mismatch('COLOR')
-        break
-      case 'float':
-        rm_if_mismatch('FLOAT')
-        break
-      case 'int':
-        rm_if_mismatch('INT')
-        break
-      case 'number':
-        if (this.properties.force_int) {
-          rm_if_mismatch('INT')
-        } else {
-          rm_if_mismatch('FLOAT')
-        }
-        break
-      case 'string':
-        rm_if_mismatch('STRING')
-        break
-      // case 'vector2':
-      // case 'vector3':
-      // case 'vector4':
-      //   rm_if_mismatch('FLOAT')
-      //   break
-      case 'vector2':
-        rm_if_mismatch('VECTOR2')
-        break
-      case 'vector3':
-        rm_if_mismatch('VECTOR3')
-        break
-      case 'vector4':
-        rm_if_mismatch('VECTOR4')
-        break
-      default:
-        break
-    }
-    // this.updateOutput()
-  }
-
-  /**
-   * NOTE: This feels hacky but seems to work fine
-   * since Constant is a virtual node.
-   */
-  updateTargetWidgets(u_links) {
-    infoLogger('Updating target widgets')
-    if (!app.graph.links) return
-    const links = u_links || this.outputs[0].links
-    if (!links) return
-    for (let i = 0; i < links.length; i++) {
-      const link = app.graph.links[links[i]]
-      const tgt_node = app.graph.getNodeById(link.target_id)
-      if (!tgt_node || !tgt_node.inputs) return
-      const tgt_input = tgt_node.inputs[link.target_slot]
-      if (!tgt_input) return
-      const tgt_widget = tgt_node.widgets.filter(
-        (w) => w.name === tgt_input.name,
-      )
-      // infoLogger('Constant Target Node', tgt_node)
-      // infoLogger('Constant Target Input', tgt_input)
-      if (!tgt_widget || tgt_widget.length === 0) return
-
-      tgt_widget[0].value = this.properties.value
-    }
-  }
-
-  updateOutput() {
-    infoLogger('Updating output value')
-    const value = this.properties.value
-
-    switch (this.properties.type) {
-      case 'color':
-        this.setOutputData(0, value)
-        break
-      case 'number':
-        if (this.properties.force_int) {
-          this.setOutputData(0, Number.parseInt(value))
-        } else {
-          this.setOutputData(0, Number.parseFloat(value))
-        }
-        break
-      case 'string':
-        this.setOutputData(0, value.toString())
-        break
-      case 'vector2':
-      case 'vector3':
-      case 'vector4':
-        this.setOutputData(0, value)
-        break
-
-      // case 'vector2':
-      //   this.setOutputData(0, value.slice(0, 2))
-      //   break
-      // case 'vector3':
-      //   this.setOutputData(0, value.slice(0, 3))
-      //   break
-      // case 'vector4':
-      //   this.setOutputData(0, value.slice(0, 4))
-      //   break
-      default:
-        break
-    }
-
-    infoLogger('New Value', this.value)
-
-    this.updateTargetWidgets()
-  }
-}
-app.registerExtension({
-  name: 'mtb.constant',
-
-  async beforeRegisterNodeDef(nodeType, nodeData, _app) {
-    if (nodeData.name === 'Constant (mtb)') {
-      new ConstantJs(nodeType)
-    }
-  },
-  // NOTE: old js only registration
-  //
-  // registerCustomNodes() {
-  //   LiteGraph.registerNodeType('Constant (mtb)', Constant)
-  //
-  //   Constant.category = 'mtb/utils'
-  //   Constant.title = 'Constant (mtb)'
-  // },
-})

web/curve_widget.js

@@ -1,221 +0,0 @@
-// Reference the shared typedefs file
-/// <reference path="../types/typedefs.js" />
-import { app } from '../../scripts/app.js'
-import { infoLogger } from './comfy_shared.js'
-
-function B0(t) {
-  return (1 - t) ** 3 / 6
-}
-function B1(t) {
-  return (3 * t ** 3 - 6 * t ** 2 + 4) / 6
-}
-function B2(t) {
-  return (-3 * t ** 3 + 3 * t ** 2 + 3 * t + 1) / 6
-}
-function B3(t) {
-  return t ** 3 / 6
-}
-class CurveWidget {
-  constructor(...args) {
-    const [inputName, opts] = args
-
-    this.name = inputName || 'Curve'
-
-    this.type = 'FLOAT_CURVE'
-    this.selectedPointIndex = null
-    this.options = opts
-    this.value = this.value || { 0: { x: 0, y: 0 }, 1: { x: 1, y: 1 } }
-  }
-
-  drawBSpline(ctx, width, height, posY) {
-    const n = this.value.length - 1
-    const numSegments = n - 2
-    const numPoints = this.value.length
-    if (numPoints < 4) {
-      this.drawLinear(ctx, width, height, posY)
-    } else {
-      for (let j = 0; j <= numSegments; j++) {
-        for (let t = 0; t <= 1; t += 0.01) {
-          let pt = this.getBSplinePoint(j, t)
-          let x = pt.x * width
-          let y = posY + height - pt.y * height
-
-          if (t === 0) ctx.moveTo(x, y)
-          else ctx.lineTo(x, y)
-        }
-      }
-      ctx.stroke()
-    }
-  }
-
-  drawLinear(ctx, width, height, posY) {
-    for (let i = 0; i < Object.keys(this.value).length - 1; i++) {
-      let p1 = this.value[i]
-      let p2 = this.value[i + 1]
-      ctx.moveTo(p1.x * width, posY + height - p1.y * height)
-      ctx.lineTo(p2.x * width, posY + height - p2.y * height)
-    }
-    ctx.stroke()
-  }
-  getBSplinePoint(i, t) {
-    // Control points for this segment
-    const p0 = this.value[i]
-    const p1 = this.value[i + 1]
-    const p2 = this.value[i + 2]
-    const p3 = this.value[i + 3]
-
-    const x = B0(t) * p0.x + B1(t) * p1.x + B2(t) * p2.x + B3(t) * p3.x
-    const y = B0(t) * p0.y + B1(t) * p1.y + B2(t) * p2.y + B3(t) * p3.y
-
-    return { x, y }
-  }
-  /**
-   * @param {OnDrawWidgetParams} args
-   */
-  draw(...args) {
-    const hide = this.type !== 'FLOAT_CURVE'
-    if (hide) {
-      return
-    }
-
-    const [ctx, node, width, posY, height] = args
-    const [cw, ch] = this.computeSize(width)
-
-    ctx.beginPath()
-    ctx.fillStyle = '#000'
-    ctx.strokeStyle = '#fff'
-    ctx.lineWidth = 2
-
-    // normalized coordinates -> canvas coordinates
-    for (let i = 0; i < Object.keys(this.value || {}).length - 1; i++) {
-      let p1 = this.value[i]
-      let p2 = this.value[i + 1]
-      ctx.moveTo(p1.x * cw, posY + ch - p1.y * ch)
-      ctx.lineTo(p2.x * cw, posY + ch - p2.y * ch)
-    }
-    ctx.stroke()
-
-    // points
-    Object.values(this.value || {}).forEach((point) => {
-      ctx.beginPath()
-      ctx.arc(point.x * cw, posY + ch - point.y * ch, 5, 0, 2 * Math.PI)
-      ctx.fill()
-    })
-  }
-
-  mouse(event, pos, node) {
-    let x = pos[0] - node.pos[0]
-    let y = pos[1] - node.pos[1]
-    const width = node.size[0]
-    const height = 300 // TODO: compute
-    const posY = node.pos[1]
-    const localPos = { x: pos[0], y: pos[1] - LiteGraph.NODE_WIDGET_HEIGHT }
-
-    if (event.type === LiteGraph.pointerevents_method + 'down') {
-      console.debug('Checking if a point was clicked')
-      const clickedPointIndex = this.detectPoint(localPos, width, height)
-      if (clickedPointIndex !== null) {
-        this.selectedPointIndex = clickedPointIndex
-      } else {
-        this.addPoint(localPos, width, height)
-      }
-      return true
-    } else if (
-      event.type === LiteGraph.pointerevents_method + 'move' &&
-      this.selectedPointIndex !== null
-    ) {
-      this.movePoint(this.selectedPointIndex, localPos, width, height)
-      return true
-    } else if (
-      event.type === LiteGraph.pointerevents_method + 'up' &&
-      this.selectedPointIndex !== null
-    ) {
-      this.selectedPointIndex = null
-      return true
-    }
-    return false
-  }
-  callback(...args) {
-    //value, that, node, pos, event) {
-
-  }
-
-  detectPoint(localPos, width, height) {
-    const threshold = 20 // TODO: extract
-    const keys = Object.keys(this.value)
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      const p = this.value[key]
-      const px = p.x * width
-      const py = height - p.y * height
-      if (
-        Math.abs(localPos.x - px) < threshold &&
-        Math.abs(localPos.y - py) < threshold
-      ) {
-        return key
-      }
-    }
-    return null
-  }
-  addPoint(localPos, width, height) {
-    // add a new point based on click position
-    const normalizedPoint = {
-      x: localPos.x / width,
-      y: 1 - localPos.y / height,
-    }
-
-    const keys = Object.keys(this.value)
-    let insertIndex = keys.length
-    for (let i = 0; i < keys.length; i++) {
-      if (normalizedPoint.x < this.value[keys[i]].x) {
-        insertIndex = i
-        break
-      }
-    }
-    // shift
-    for (let i = keys.length; i > insertIndex; i--) {
-      this.value[i] = this.value[i - 1]
-    }
-
-    this.value[insertIndex] = normalizedPoint
-  }
-
-  movePoint(index, localPos, width, height) {
-    const point = this.value[index]
-    point.x = Math.max(0, Math.min(1, localPos.x / width))
-    point.y = Math.max(0, Math.min(1, 1 - localPos.y / height))
-
-    this.value[index] = point
-  }
-  computeSize(width) {
-    return [width, 300]
-  }
-
-  configure(data) {
-  }
-}
-
-app.registerExtension({
-  name: 'mtb.curves',
-  getCustomWidgets: () => {
-    return {
-      /**
-       * @param {LGraphNode} node
-       * @param {str} inputName
-       * @param {[str,*]} inputData
-       * @param {*} app
-       *
-       */
-      FLOAT_CURVE: (node, inputName, inputData, app) => {
-        // const c = node.widgets.find((w) => w.type === "FLOAT_CURVE")
-        const wid = node.addCustomWidget(new CurveWidget(inputName, inputData))
-
-        return {
-          widget: wid,
-          minWidth: 150,
-          minHeight: 30,
-        }
-      },
-    }
-  },
-})

web/debug.js

@@ -7,68 +7,36 @@
  *
  */
 
-// Reference the shared typedefs file
-/// <reference path="../types/typedefs.js" />
-
-import { app } from '../../scripts/app.js'
-
-import * as shared from './comfy_shared.js'
-import { MtbWidgets } from './mtb_widgets.js'
+import { app } from '/scripts/app.js'
+import * as shared from '/extensions/mtb/comfy_shared.js'
+import { log } from '/extensions/mtb/comfy_shared.js'
+import { MtbWidgets } from '/extensions/mtb/mtb_widgets.js'
 
 // TODO: respect inputs order...
 
-function escapeHtml(unsafe) {
-  return unsafe
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#039;')
-}
 app.registerExtension({
   name: 'mtb.Debug',
-
-  /**
-   * @param {NodeType} nodeType
-   * @param {NodeData} nodeData
-   * @param {*} app
-   */
   async beforeRegisterNodeDef(nodeType, nodeData, app) {
     if (nodeData.name === 'Debug (mtb)') {
-      const onNodeCreated = nodeType.prototype.onNodeCreated
-      nodeType.prototype.onNodeCreated = function () {
-        this.options = {}
-        const r = onNodeCreated
-          ? onNodeCreated.apply(this, arguments)
-          : undefined
-        this.addInput(`anything_1`, '*')
-        return r
-      }
-
       const onConnectionsChange = nodeType.prototype.onConnectionsChange
-      /**
-       * @param {OnConnectionsChangeParams} args
-       */
-      nodeType.prototype.onConnectionsChange = function (...args) {
-        const [_type, index, connected, link_info, ioSlot] = args
+      nodeType.prototype.onConnectionsChange = function (
+        type,
+        index,
+        connected,
+        link_info
+      ) {
         const r = onConnectionsChange
-          ? onConnectionsChange.apply(this, args)
+          ? onConnectionsChange.apply(this, arguments)
           : undefined
         // TODO: remove all widgets on disconnect once computed
-        shared.dynamic_connection(this, index, connected, 'anything_', '*', {
-          link: link_info,
-          ioSlot: ioSlot,
-        })
+        shared.dynamic_connection(this, index, connected, 'anything_', '*')
 
         //- infer type
         if (link_info) {
-          // const fromNode = this.graph._nodes.find(
-          // (otherNode) => otherNode.id === link_info.origin_id,
-          // )
-          // const fromNode = app.graph.getNodeById(link_info.origin_id)
-          const { from } = shared.nodesFromLink(this, link_info)
-          if (!from || this.inputs.length === 0) return
-          const type = from.outputs[link_info.origin_slot].type
+          const fromNode = this.graph._nodes.find(
+            (otherNode) => otherNode.id == link_info.origin_id
+          )
+          const type = fromNode.outputs[link_info.origin_slot].type
           this.inputs[index].type = type
           // this.inputs[index].label = type.toLowerCase()
         }
@@ -77,53 +45,51 @@ app.registerExtension({
           this.inputs[index].type = '*'
           this.inputs[index].label = `anything_${index + 1}`
         }
-        return r
       }
 
       const onExecuted = nodeType.prototype.onExecuted
-      nodeType.prototype.onExecuted = function (data) {
+      nodeType.prototype.onExecuted = function (message) {
         onExecuted?.apply(this, arguments)
 
         const prefix = 'anything_'
 
         if (this.widgets) {
+          // const pos = this.widgets.findIndex((w) => w.name === "anything_1");
+          // if (pos !== -1) {
           for (let i = 0; i < this.widgets.length; i++) {
-            if (this.widgets[i].name !== 'output_to_console') {
-              this.widgets[i].onRemoved?.()
-            }
+            this.widgets[i].onRemoved?.()
           }
-          this.widgets.length = 1
+          this.widgets.length = 0
         }
         let widgetI = 1
-        // console.log(message)
-        if (data.text) {
-          for (const txt of data.text) {
+        if (message.text) {
+          for (const txt of message.text) {
             const w = this.addCustomWidget(
-              MtbWidgets.DEBUG_STRING(`${prefix}_${widgetI}`, escapeHtml(txt)),
+              MtbWidgets.DEBUG_STRING(`${prefix}_${widgetI}`, txt)
             )
             w.parent = this
             widgetI++
           }
         }
-        if (data.b64_images) {
-          for (const img of data.b64_images) {
+        if (message.b64_images) {
+          for (const img of message.b64_images) {
             const w = this.addCustomWidget(
-              MtbWidgets.DEBUG_IMG(`${prefix}_${widgetI}`, img),
+              MtbWidgets.DEBUG_IMG(`${prefix}_${widgetI}`, img)
             )
             w.parent = this
             widgetI++
           }
+          // this.onResize?.(this.size);
+          // this.resize?.(this.size)
+          this.setSize(this.computeSize())
         }
 
-        // this.setSize(this.computeSize())
-
         this.onRemoved = function () {
           // When removing this node we need to remove the input from the DOM
           for (let y in this.widgets) {
             if (this.widgets[y].canvas) {
               this.widgets[y].canvas.remove()
             }
-            shared.cleanupNode(this)
             this.widgets[y].onRemoved?.()
           }
         }

web/imageFeed.js

@@ -9,9 +9,9 @@
 
 // forked from pysssss's imageFeed.js
 
-import { api } from '../../scripts/api.js'
-import { app } from '../../scripts/app.js'
-import { LocalStorageManager } from './comfy_shared.js'
+import { api } from '/scripts/api.js'
+import { app } from '/scripts/app.js'
+
 const styles = {
   lighbox: {
     position: 'fixed',
@@ -53,39 +53,17 @@ let currentImageIndex = 0
 const imageUrls = []
 
 let image_menu = null
-const storage = new LocalStorageManager('mtb')
-
-let activated = storage.get('image_feed', false)
+let activated = true
 
 app.registerExtension({
   name: 'mtb.ImageFeed',
-  setup: () => {
-    app.ui.settings.addSetting({
-      id: 'mtb.imageFeed.enabled',
-      name: '[⚡mtb] Enable image feed',
-      type: 'boolean',
-      defaultValue: true,
-      attrs: {
-        style: {
-          fontFamily: 'monospace',
-        },
-      },
-      async onChange(value) {
-        storage.set('image_feed', value)
-        activated = value
-      },
-    })
-  },
   init: async () => {
-    if (!activated) {
-      return
-    }
     const pythongossFeed = app.extensions.find(
-      (e) => e.name === 'pysssss.ImageFeed',
+      (e) => e.name == 'pysssss.ImageFeed'
     )
     if (pythongossFeed) {
       console.warn(
-        "[mtb] - Aborting the loading of mtb's imageFeed in favor of pysssss.ImageFeed",
+        "[mtb] - Aborting the loading of mtb's imageFeed in favor of pysssss.ImageFeed"
       )
       activated = false // just in case other methods are added later on
       return
@@ -116,7 +94,7 @@ app.registerExtension({
     const lightboxCloseBtn = document.createElement('button')
     Object.assign(
       lightboxCloseBtn.style,
-      styles.lightboxBtn({ right: '0', top: '0' }),
+      styles.lightboxBtn({ right: '0', top: '0' })
     )
     lightboxCloseBtn.textContent = '❌'
 
@@ -186,7 +164,7 @@ app.registerExtension({
     //- append to DOM
     document.body.append(imageListContainer)
 
-    showBtn.textContent = '🖼'
+    showBtn.textContent = '🖼️'
     showBtn.onclick = () => {
       imageListContainer.style.display = 'block'
       showBtn.style.display = 'none'

web/mtb_widgets.js

@@ -7,300 +7,15 @@
  *
  */
 
-/// <reference path="../types/typedefs.js" />
+import { app } from '/scripts/app.js'
+import parseCss from '/extensions/mtb/extern/parse-css.js'
+import * as shared from '/extensions/mtb/comfy_shared.js'
+import { log } from '/extensions/mtb/comfy_shared.js'
+import { api } from '/scripts/api.js'
 
-// TODO: Use the builtin addDOMWidget everywhere appropriate
+const newTypes = [, /*'BOOL'*/ 'COLOR', 'BBOX']
 
-import { app } from '../../scripts/app.js'
-import { api } from '../../scripts/api.js'
-
-import parseCss from './extern/parse-css.js'
-import * as shared from './comfy_shared.js'
-import { infoLogger } from './comfy_shared.js'
-import { NumberInputWidget } from './numberInput.js'
-
-// NOTE: new widget types registered by MTB Widgets
-const newTypes = [/*'BOOL'*/ , 'COLOR', 'BBOX']
-
-const deprecated_nodes = {
-  //  'Animation Builder':
-  //    'Kept to avoid breaking older script but replaced by TimeEngine',
-}
-
-const withFont = (ctx, font, cb) => {
-  const oldFont = ctx.font
-  ctx.font = font
-  cb()
-  ctx.font = oldFont
-}
-
-const calculateTextDimensions = (ctx, value, width, fontSize = 16) => {
-  const words = value.split(' ')
-  const lines = []
-  let currentLine = ''
-  for (const word of words) {
-    const testLine = currentLine.length === 0 ? word : `${currentLine} ${word}`
-    const testWidth = ctx.measureText(testLine).width
-    if (testWidth > width) {
-      lines.push(currentLine)
-      currentLine = word
-    } else {
-      currentLine = testLine
-    }
-  }
-  if (lines.length === 0) lines.push(value)
-  const textHeight = (lines.length + 1) * fontSize
-  const maxLineWidth = lines.reduce(
-    (maxWidth, line) => Math.max(maxWidth, ctx.measureText(line).width),
-    0,
-  )
-  return { textHeight, maxLineWidth }
-}
-
-export function addMultilineWidget(node, name, opts, callback) {
-  const inputEl = document.createElement('textarea')
-  inputEl.className = 'comfy-multiline-input'
-  inputEl.value = opts.defaultVal
-  inputEl.placeholder = opts.placeholder || name
-
-  const widget = node.addDOMWidget(name, 'textmultiline', inputEl, {
-    getValue() {
-      return inputEl.value
-    },
-    setValue(v) {
-      inputEl.value = v
-    },
-  })
-  widget.inputEl = inputEl
-
-  inputEl.addEventListener('input', () => {
-    callback?.(widget.value)
-    widget.callback?.(widget.value)
-  })
-  widget.onRemove = () => {
-    inputEl.remove()
-  }
-
-  return { minWidth: 400, minHeight: 200, widget }
-}
-
-export const VECTOR_AXIS = {
-  0: 'x',
-  1: 'y',
-  2: 'z',
-  3: 'w',
-}
-
-export function addVectorWidgetW(
-  node,
-  name,
-  value,
-  vector_size,
-  callback,
-  app,
-) {
-  // const inputEl = document.createElement('div')
-  // const vecEl = document.createElement('div')
-  //
-  // inputEl.style.background = 'red'
-  //
-  // inputEl.className = 'comfy-vector-container'
-  // vecEl.className = 'comfy-vector-input'
-  //
-  // vecEl.style.display = 'flex'
-  // inputEl.appendChild(vecEl)
-  const inputs = []
-
-  for (let i = 0; i < vector_size; i++) {
-    // const input = document.createElement('input')
-    // input.type = 'number'
-    // input.value = value[VECTOR_AXIS[i]]
-    const input = node.addWidget(
-      'number',
-      `${name}_${VECTOR_AXIS[i]}`,
-      value[VECTOR_AXIS[i]],
-      (val) => {},
-    )
-
-    inputs.push(input)
-    // vecEl.appendChild(input)
-  }
-  //
-  // const widget = node.addDOMWidget(name, 'vector', inputEl, {
-  //   getValue() {
-  //     return JSON.stringify(widget._value)
-  //   },
-  //   setValue(v) {
-  //     widget._value = v
-  //   },
-  //   afterResize(node, widget) {
-  //     console.log('After resize', { that: this, node, widget })
-  //   },
-  // })
-  //
-  // console.log('prev callback', widget.callback)
-  // widget.callback = callback
-  // widget._value = value
-  //
-  // for (let i = 0; i < vector_size; i++) {
-  //   const input = inputs[i]
-  //   input.addEventListener('change', (event) => {
-  //     widget._value[VECTOR_AXIS[i]] = Number.parseFloat(event.target.value)
-  //     widget.callback?.(widget._value)
-  //     node.graph._version++
-  //     node.setDirtyCanvas(true, true)
-  //   })
-  // }
-  // // document.body.append(inputEl)
-  //
-  // widget.inputEl = inputEl
-  // widget.vecEl = vecEl
-  //
-  // inputEl.addEventListener('input', () => {
-  //   widget.callback?.(widget.value)
-  // })
-  //
-  return { minWidth: 400, minHeight: 200, widget }
-}
-export function addVectorWidget(node, name, value, vector_size, callback, app) {
-  const inputEl = document.createElement('div')
-  const vecEl = document.createElement('div')
-
-  inputEl.className = 'comfy-vector-container'
-  vecEl.className = 'comfy-vector-input'
-  vecEl.id = 'vecEl'
-
-  vecEl.style.display = 'flex'
-  vecEl.style.flexDirection = 'column'
-  inputEl.appendChild(vecEl)
-  const inputs = []
-
-  //
-  // for (let i = 0; i < vector_size; i++) {
-  //   const input = document.createElement('input')
-  //   input.type = 'number'
-  //   input.value = value[VECTOR_AXIS[i]]
-  //   inputs.push(input)
-  //   vecEl.appendChild(input)
-  // }
-
-  const widget = node.addDOMWidget(name, 'vector', inputEl, {
-    getValue() {
-      return JSON.stringify(widget._value)
-    },
-    setValue(v) {
-      widget._value = v
-    },
-  })
-  const vec = new NumberInputWidget('vecEl', vector_size, true)
-  vec.setValue(...Object.values(value))
-  vec.onChange = (value) => {
-    for (let i = 0; i < value.length; i++) {
-      const val = value[i]
-      widget._value[VECTOR_AXIS[i]] = Number.parseFloat(val)
-    }
-
-    widget.callback?.(widget._value)
-    // widget._value[VECTOR_AXIS[index]] = Number.parseFloat(value)
-  }
-
-  console.log('prev callback', widget.callback)
-  widget.callback = callback
-  widget._value = value
-
-  // for (let i = 0; i < vector_size; i++) {
-  //   const input = inputs[i]
-  //   input.addEventListener('change', (event) => {
-  //     widget._value[VECTOR_AXIS[i]] = Number.parseFloat(event.target.value)
-  //     widget.callback?.(widget._value)
-  //     node.graph._version++
-  //     node.setDirtyCanvas(true, true)
-  //   })
-  // }
-
-  widget.inputEl = inputEl
-  widget.vecEl = vecEl
-  widget.vec = vec
-
-  return { minWidth: 400, minHeight: 200 * vector_size, widget }
-}
 export const MtbWidgets = {
-  //TODO: complete this properly
-
-  /**
-   * Creates a vector widget.
-   * @param {string} key - The key for the widget.
-   * @param {number[]} [val] - The initial value for the widget.
-   * @param {number} size - The size of the vector.
-   * @returns {VectorWidget} The vector widget.
-   */
-  VECTOR: (key, val, size) => {
-    shared.infoLogger('Adding VECTOR widget', { key, val, size })
-    /** @type {VectorWidget} */
-    const widget = {
-      name: key,
-      type: `vector${size}`,
-      y: 0,
-      options: { default: Array.from({ length: size }, () => 0.0) },
-      _value: val || Array.from({ length: size }, () => 0.0),
-      draw: function (ctx, node, width, widgetY, height) {
-        ctx.textAlign = 'left'
-        ctx.strokeStyle = outline_color
-        ctx.fillStyle = background_color
-        ctx.beginPath()
-        if (show_text)
-          ctx.roundRect(margin, y, widget_width - margin * 2, H, [H * 0.5])
-        else ctx.rect(margin, y, widget_width - margin * 2, H)
-        ctx.fill()
-        if (show_text) {
-          if (!w.disabled) ctx.stroke()
-          ctx.fillStyle = text_color
-          if (!w.disabled) {
-            ctx.beginPath()
-            ctx.moveTo(margin + 16, y + 5)
-            ctx.lineTo(margin + 6, y + H * 0.5)
-            ctx.lineTo(margin + 16, y + H - 5)
-            ctx.fill()
-            ctx.beginPath()
-            ctx.moveTo(widget_width - margin - 16, y + 5)
-            ctx.lineTo(widget_width - margin - 6, y + H * 0.5)
-            ctx.lineTo(widget_width - margin - 16, y + H - 5)
-            ctx.fill()
-          }
-          ctx.fillStyle = secondary_text_color
-          ctx.fillText(w.label || w.name, margin * 2 + 5, y + H * 0.7)
-          ctx.fillStyle = text_color
-          ctx.textAlign = 'right'
-          if (w.type === 'number') {
-            ctx.fillText(
-              Number(w.value).toFixed(
-                w.options.precision !== undefined ? w.options.precision : 3,
-              ),
-              widget_width - margin * 2 - 20,
-              y + H * 0.7,
-            )
-          } else {
-            let v = w.value
-            if (w.options.values) {
-              let values = w.options.values
-              if (values.constructor === Function) values = values()
-              if (values && values.constructor !== Array) v = values[w.value]
-            }
-            ctx.fillText(v, widget_width - margin * 2 - 20, y + H * 0.7)
-          }
-        }
-      },
-      get value() {
-        return this._value
-      },
-      set value(val) {
-        this._value = val
-        this.callback?.(this._value)
-      },
-    }
-
-    return widget
-  },
   BBOX: (key, val) => {
     /** @type {import("./types/litegraph").IWidget} */
     const widget = {
@@ -358,7 +73,7 @@ export const MtbWidgets = {
             ctx.fillText(
               this.label || this.name,
               margin * 2 + 5,
-              currentY + H * 0.7,
+              currentY + H * 0.7
             )
             ctx.fillStyle = text_color
             ctx.textAlign = 'right'
@@ -367,10 +82,10 @@ export const MtbWidgets = {
               Number(this.value).toFixed(
                 this.options?.precision !== undefined
                   ? this.options.precision
-                  : 3,
+                  : 3
               ),
               widget_width - margin * 2 - 20,
-              currentY + H * 0.7,
+              currentY + H * 0.7
             )
           }
         }
@@ -452,7 +167,7 @@ export const MtbWidgets = {
                   this.value = Number(v)
                   shared.inner_value_change(this, this.value, event)
                 }.bind(w),
-                event,
+                event
               )
             }
           }
@@ -462,7 +177,7 @@ export const MtbWidgets = {
               function () {
                 shared.inner_value_change(this, this.value, event)
               }.bind(this),
-              20,
+              20
             )
 
           app.canvas.setDirty(true)
@@ -511,7 +226,7 @@ export const MtbWidgets = {
         border,
         widgetY + border,
         widgetWidth - border * 2,
-        height - border * 2,
+        height - border * 2
       )
       const color = parseCss(this.value.default || this.value)
       if (!color) {
@@ -543,7 +258,6 @@ export const MtbWidgets = {
 
             picker.addEventListener('change', () => {
               this.value = picker.value
-              this.callback?.(this.value)
               node.graph._version++
               node.setDirtyCanvas(true, true)
               picker.remove()
@@ -602,22 +316,46 @@ export const MtbWidgets = {
         // const [cw, ch] = this.computeSize(widgetWidth)
         shared.offsetDOMWidget(this, ctx, node, widgetWidth, widgetY, height)
       },
-      computeSize(width) {
-        if (!this.value) {
+      computeSize: function (width) {
+        const value = this.inputEl.innerHTML
+        if (!value) {
           return [32, 32]
         }
         if (!width) {
-          console.debug(`No width ${this.parent.size}`)
+          log(`No width ${this.parent.size}`)
         }
-        let dimensions
-        withFont(app.ctx, `${fontSize}px monospace`, () => {
-          dimensions = calculateTextDimensions(app.ctx, this.value, width)
-        })
-        const widgetWidth = Math.max(
-          width || this.width || 32,
-          dimensions.maxLineWidth,
+
+        const oldFont = app.ctx.font
+        app.ctx.font = `${fontSize}px monospace`
+
+        const words = value.split(' ')
+        const lines = []
+        let currentLine = ''
+        for (const word of words) {
+          const testLine =
+            currentLine.length === 0 ? word : `${currentLine} ${word}`
+
+          const testWidth = app.ctx.measureText(testLine).width
+
+          if (testWidth > width) {
+            lines.push(currentLine)
+            currentLine = word
+          } else {
+            currentLine = testLine
+          }
+        }
+        app.ctx.font = oldFont
+        if (lines.length === 0) lines.push(currentLine)
+
+        const textHeight = (lines.length + 1) * fontSize
+
+        const maxLineWidth = lines.reduce(
+          (maxWidth, line) =>
+            Math.max(maxWidth, app.ctx.measureText(line).width),
+          0
         )
-        const widgetHeight = dimensions.textHeight * 1.5
+        const widgetWidth = Math.max(width || this.width || 32, maxLineWidth)
+        const widgetHeight = textHeight * 1.5
         return [widgetWidth, widgetHeight]
       },
       onRemoved: function () {
@@ -625,23 +363,25 @@ export const MtbWidgets = {
           this.inputEl.remove()
         }
       },
-      get value() {
-        return this.inputEl.innerHTML
-      },
-      set value(val) {
-        this.inputEl.innerHTML = val
-        this.parent?.setSize?.(this.parent?.computeSize())
-      },
     }
 
+    Object.defineProperty(w, 'value', {
+      get() {
+        return this.inputEl.innerHTML
+      },
+      set(value) {
+        this.inputEl.innerHTML = value
+        this.parent?.setSize?.(this.parent?.computeSize())
+      },
+    })
+
     w.inputEl = document.createElement('p')
-    w.inputEl.style = `
-      text-align: center;
-      font-size: ${fontSize}px;
-      color: var(--input-text);
-      line-height: 1em;
-      font-family: monospace;
-    `
+    w.inputEl.style.textAlign = 'center'
+    w.inputEl.style.fontSize = `${fontSize}px`
+    w.inputEl.style.color = 'var(--input-text)'
+    w.inputEl.style.lineHeight = 0
+
+    w.inputEl.style.fontFamily = 'monospace'
     w.value = val
     document.body.appendChild(w.inputEl)
 
@@ -656,7 +396,7 @@ const mtb_widgets = {
   name: 'mtb.widgets',
 
   init: async () => {
-    infoLogger('Registering mtb.widgets')
+    log('Registering mtb.widgets')
     try {
       const res = await api.fetchApi('/mtb/debug')
       const msg = await res.json()
@@ -672,7 +412,7 @@ const mtb_widgets = {
   setup: () => {
     app.ui.settings.addSetting({
       id: 'mtb.Debug.enabled',
-      name: '[⚡mtb] Enable Debug (py and js)',
+      name: '[mtb] Enable Debug (py and js)',
       type: 'boolean',
       defaultValue: false,
 
@@ -684,14 +424,13 @@ const mtb_widgets = {
         },
       },
       async onChange(value) {
+        if (value) {
+          console.log('Enabled DEBUG mode')
+        }
         if (!window.MTB) {
           window.MTB = {}
         }
         window.MTB.DEBUG = value
-        if (value) {
-          infoLogger('Enabled DEBUG mode')
-        }
-
         await api
           .fetchApi('/mtb/debug', {
             method: 'POST',
@@ -699,7 +438,7 @@ const mtb_widgets = {
               enabled: value,
             }),
           })
-          .then((_response) => {})
+          .then((response) => {})
           .catch((error) => {
             console.error('Error:', error)
           })
@@ -707,25 +446,25 @@ const mtb_widgets = {
     })
   },
 
-  getCustomWidgets: () => {
+  getCustomWidgets: function () {
     return {
-      BOOL: (node, inputName, inputData, _app) => {
+      BOOL: (node, inputName, inputData, app) => {
         console.debug('Registering bool')
 
         return {
           widget: node.addCustomWidget(
-            MtbWidgets.BOOL(inputName, inputData[1]?.default || false),
+            MtbWidgets.BOOL(inputName, inputData[1]?.default || false)
           ),
           minWidth: 150,
           minHeight: 30,
         }
       },
 
-      COLOR: (node, inputName, inputData, _app) => {
+      COLOR: (node, inputName, inputData, app) => {
         console.debug('Registering color')
         return {
           widget: node.addCustomWidget(
-            MtbWidgets.COLOR(inputName, inputData[1]?.default || '#ff0000'),
+            MtbWidgets.COLOR(inputName, inputData[1]?.default || '#ff0000')
           ),
           minWidth: 150,
           minHeight: 30,
@@ -743,8 +482,8 @@ const mtb_widgets = {
     }
   },
   /**
-   * @param {NodeType} nodeType
-   * @param {NodeData} nodeData
+   * @param {import("./types/comfy").NodeType} nodeType
+   * @param {import("./types/comfy").NodeDef} nodeData
    * @param {import("./types/comfy").App} app
    */
   async beforeRegisterNodeDef(nodeType, nodeData, app) {
@@ -773,7 +512,12 @@ const mtb_widgets = {
 
         this.onRemoved = function () {
           // When removing this node we need to remove the input from the DOM
-          shared.cleanupNode(this)
+          for (const w of this.widgets) {
+            if (w.canvas) {
+              w.canvas.remove()
+            }
+            w.onRemoved?.()
+          }
         }
         return r
       }
@@ -817,27 +561,33 @@ const mtb_widgets = {
       }
     }
 
-    if (!nodeData.name.endsWith('(mtb)')) {
-      return
-    }
-    // console.log('MTB Node', { description: nodeData.description, nodeType })
-
-    shared.addDocumentation(nodeData, nodeType)
-
-    const deprecation = deprecated_nodes[nodeData.name.replace(' (mtb)', '')]
-
-    if (deprecation) {
-      shared.addDeprecation(nodeType, deprecation)
-    }
     //- Extending Python Nodes
     switch (nodeData.name) {
+      case 'Psd Save (mtb)': {
+        const onConnectionsChange = nodeType.prototype.onConnectionsChange
+        nodeType.prototype.onConnectionsChange = function (
+          type,
+          index,
+          connected,
+          link_info
+        ) {
+          const r = onConnectionsChange
+            ? onConnectionsChange.apply(this, arguments)
+            : undefined
+          shared.dynamic_connection(this, index, connected)
+          return r
+        }
+        break
+      }
       //TODO: remove this non sense
       case 'Get Batch From History (mtb)': {
         const onNodeCreated = nodeType.prototype.onNodeCreated
         nodeType.prototype.onNodeCreated = function () {
-          const r = onNodeCreated ? onNodeCreated.apply(this, []) : undefined
+          const r = onNodeCreated
+            ? onNodeCreated.apply(this, arguments)
+            : undefined
           const internal_count = this.widgets.find(
-            (w) => w.name === 'internal_count',
+            (w) => w.name === 'internal_count'
           )
           shared.hideWidgetForGood(this, internal_count)
           internal_count.afterQueued = function () {
@@ -877,37 +627,45 @@ const mtb_widgets = {
                 imgURLs = imgURLs.concat(
                   message.gif.map((params) => {
                     return api.apiURL(
-                      '/view?' + new URLSearchParams(params).toString(),
+                      '/view?' + new URLSearchParams(params).toString()
                     )
-                  }),
+                  })
                 )
               }
               if (message.apng) {
                 imgURLs = imgURLs.concat(
                   message.apng.map((params) => {
                     return api.apiURL(
-                      '/view?' + new URLSearchParams(params).toString(),
+                      '/view?' + new URLSearchParams(params).toString()
                     )
-                  }),
+                  })
                 )
               }
               let i = 0
               for (const img of imgURLs) {
                 const w = this.addCustomWidget(
-                  MtbWidgets.DEBUG_IMG(`${prefix}_${i}`, img),
+                  MtbWidgets.DEBUG_IMG(`${prefix}_${i}`, img)
                 )
                 w.parent = this
                 i++
               }
             }
-            const onRemoved = this.onRemoved
-            this.onRemoved = () => {
-              shared.cleanupNode(this)
-              return onRemoved?.()
+            this.setSize?.(this.computeSize())
+            return r
+          }
+
+          const onRemoved = nodeType.prototype.onRemoved
+          nodeType.prototype.onRemoved = function (message) {
+            const r = onRemoved ? onRemoved.apply(this, message) : undefined
+            if (!this.widgets) return r
+            for (const w of this.widgets) {
+              if (w.canvas) {
+                w.canvas.remove()
+              }
+              w.onRemoved?.()
             }
+            return r
           }
-          this.setSize?.(this.computeSize())
-          return r
         }
 
         break
@@ -922,12 +680,12 @@ const mtb_widgets = {
           this.changeMode(LiteGraph.ALWAYS)
 
           const raw_iteration = this.widgets.find(
-            (w) => w.name === 'raw_iteration',
+            (w) => w.name === 'raw_iteration'
           )
           const raw_loop = this.widgets.find((w) => w.name === 'raw_loop')
 
           const total_frames = this.widgets.find(
-            (w) => w.name === 'total_frames',
+            (w) => w.name === 'total_frames'
           )
           const loop_count = this.widgets.find((w) => w.name === 'loop_count')
 
@@ -937,12 +695,12 @@ const mtb_widgets = {
           raw_iteration._value = 0
 
           const value_preview = this.addCustomWidget(
-            MtbWidgets['DEBUG_STRING']('value_preview', 'Idle'),
+            MtbWidgets['DEBUG_STRING']('value_preview', 'Idle')
           )
           value_preview.parent = this
 
           const loop_preview = this.addCustomWidget(
-            MtbWidgets['DEBUG_STRING']('loop_preview', 'Iteration: Idle'),
+            MtbWidgets['DEBUG_STRING']('loop_preview', 'Iteration: Idle')
           )
           loop_preview.parent = this
 
@@ -956,23 +714,31 @@ const mtb_widgets = {
             app.canvas.setDirty(true)
           }
 
-          // reset button
-          this.addWidget('button', `Reset`, 'reset', onReset)
+          const reset_button = this.addWidget(
+            'button',
+            `Reset`,
+            'reset',
+            onReset
+          )
 
-          // run button
-          this.addWidget('button', `Queue`, 'queue', () => {
+          const run_button = this.addWidget('button', `Queue`, 'queue', () => {
             onReset() // this could maybe be a setting or checkbox
             app.queuePrompt(0, total_frames.value * loop_count.value)
             window.MTB?.notify?.(
               `Started a queue of ${total_frames.value} frames (for ${
                 loop_count.value
               } loop, so ${total_frames.value * loop_count.value})`,
-              5000,
+              5000
             )
           })
 
           this.onRemoved = () => {
-            shared.cleanupNode(this)
+            for (const w of this.widgets) {
+              if (w.canvas) {
+                w.canvas.remove()
+              }
+              w.onRemoved?.()
+            }
             app.canvas.setDirty(true)
           }
 
@@ -998,6 +764,23 @@ const mtb_widgets = {
 
         break
       }
+      case 'Text Encore Frames (mtb)': {
+        const onConnectionsChange = nodeType.prototype.onConnectionsChange
+        nodeType.prototype.onConnectionsChange = function (
+          type,
+          index,
+          connected,
+          link_info
+        ) {
+          const r = onConnectionsChange
+            ? onConnectionsChange.apply(this, arguments)
+            : undefined
+
+          shared.dynamic_connection(this, index, connected)
+          return r
+        }
+        break
+      }
       case 'Interpolate Clip Sequential (mtb)': {
         const onNodeCreated = nodeType.prototype.onNodeCreated
         nodeType.prototype.onNodeCreated = function () {
@@ -1008,7 +791,7 @@ const mtb_widgets = {
             const input = this.addInput(
               `replacement_${this.widgets.length}`,
               'STRING',
-              '',
+              ''
             )
             console.log(input)
             this.addWidget('STRING', `replacement_${this.widgets.length}`, '')
@@ -1025,7 +808,7 @@ const mtb_widgets = {
             'remove',
             function (value, widget, node) {
               console.log(`Button clicked: ${value}`, widget, node)
-            },
+            }
           )
 
           return r
@@ -1066,16 +849,15 @@ const mtb_widgets = {
                 if (style && style.length >= 1) {
                   if (style[0]) {
                     window.MTB?.notify?.(
-                      `Extracted positive from ${this.widgets[0].value}`,
+                      `Extracted positive from ${this.widgets[0].value}`
                     )
-                    // const tn = LiteGraph.createNode('Text box')
-                    const tn = LiteGraph.createNode('CLIPTextEncode')
+                    const tn = LiteGraph.createNode('Text box')
                     app.graph.add(tn)
                     tn.title = `${this.widgets[0].value} (Positive)`
                     tn.widgets[0].value = style[0]
                   } else {
                     window.MTB?.notify?.(
-                      `No positive to extract for ${this.widgets[0].value}`,
+                      `No positive to extract for ${this.widgets[0].value}`
                     )
                   }
                 }
@@ -1088,15 +870,15 @@ const mtb_widgets = {
                 if (style && style.length >= 2) {
                   if (style[1]) {
                     window.MTB?.notify?.(
-                      `Extracted negative from ${this.widgets[0].value}`,
+                      `Extracted negative from ${this.widgets[0].value}`
                     )
-                    const tn = LiteGraph.createNode('CLIPTextEncode')
+                    const tn = LiteGraph.createNode('Text box')
                     app.graph.add(tn)
                     tn.title = `${this.widgets[0].value} (Negative)`
                     tn.widgets[0].value = style[1]
                   } else {
                     window.MTB.notify(
-                      `No negative to extract for ${this.widgets[0].value}`,
+                      `No negative to extract for ${this.widgets[0].value}`
                     )
                   }
                 }
@@ -1108,115 +890,6 @@ const mtb_widgets = {
 
         break
       }
-
-      //NOTE: dynamic nodes
-      case 'Apply Text Template (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'var', '*')
-        break
-      }
-      case 'Save Data Bundle (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'data', '*') // [MASK,IMAGE]
-        break
-      }
-      case 'Add To Playlist (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'video', 'VIDEO')
-        break
-      }
-      case 'Psd Save (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'input_', 'PSDLAYER')
-        break
-      }
-      // case 'Text Encode Frames (mtb)' : {
-      //   shared.setupDynamicConnections(nodeType, 'input_', 'IMAGE')
-      //   break
-      // }
-      case 'Stack Images (mtb)':
-      case 'Concat Images (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'image', 'IMAGE')
-
-        break
-      }
-      case 'Batch Float Assemble (mtb)':
-      case 'Batch Float Math (mtb)':
-      case 'Plot Batch Float (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'floats', 'FLOATS')
-        break
-      }
-      case 'Batch Merge (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'batches', 'IMAGE')
-
-        break
-      }
-      // TODO: remove this, recommend pythongoss's version that is much better
-      case 'Math Expression (mtb)': {
-        const onNodeCreated = nodeType.prototype.onNodeCreated
-        nodeType.prototype.onNodeCreated = function () {
-          const r = onNodeCreated
-            ? onNodeCreated.apply(this, arguments)
-            : undefined
-          this.addInput(`x`, '*')
-          return r
-        }
-
-        const onConnectionsChange = nodeType.prototype.onConnectionsChange
-        nodeType.prototype.onConnectionsChange = function (
-          type,
-          index,
-          connected,
-          link_info,
-        ) {
-          const r = onConnectionsChange
-            ? onConnectionsChange.apply(this, arguments)
-            : undefined
-          shared.dynamic_connection(this, index, connected, 'var_', '*', {
-            nameArray: ['x', 'y', 'z'],
-          })
-
-          //- infer type
-          if (link_info) {
-            const fromNode = this.graph._nodes.find(
-              (otherNode) => otherNode.id == link_info.origin_id,
-            )
-            const type = fromNode.outputs[link_info.origin_slot].type
-            this.inputs[index].type = type
-            // this.inputs[index].label = type.toLowerCase()
-          }
-          //- restore dynamic input
-          if (!connected) {
-            this.inputs[index].type = '*'
-            this.inputs[index].label = `number_${index + 1}`
-          }
-        }
-
-        break
-      }
-
-      case 'Batch Shape (mtb)':
-      case 'Text To Image (mtb)': {
-        shared.addMenuHandler(nodeType, function (_app, options) {
-          /** @type {ContextMenuItem} */
-          const item = {
-            content: 'swap colors',
-            title: 'Swap BG/FG Color ⚡',
-            callback: (_menuItem) => {
-              const color_w = this.widgets.find((w) => w.name === 'color')
-              const bg_w = this.widgets.find(
-                (w) => w.name === 'background' || w.name === 'bg_color',
-              )
-
-              const color = color_w.value
-              const bg = bg_w.value
-
-              color_w.value = bg
-              bg_w.value = color
-            },
-          }
-
-          options.push(item)
-          return [item]
-        })
-        break
-      }
       case 'Save Tensors (mtb)': {
         const onDrawBackground = nodeType.prototype.onDrawBackground
         nodeType.prototype.onDrawBackground = function (ctx, canvas) {

web/note_plus.js

@@ -1,693 +0,0 @@
-import { app } from '../../scripts/app.js'
-import * as shared from './comfy_shared.js'
-import { infoLogger, successLogger, errorLogger } from './comfy_shared.js'
-
-const DEFAULT_CSS = ''
-const DEFAULT_HTML = `<p style='color:red;font-family:monospace'>
-    Note+
-</p>`
-const DEFAULT_MD = '## Note+'
-const DEFAULT_MODE = 'markdown'
-const DEFAULT_THEME = 'one_dark'
-
-const CSS_RESET = `
-* {
-  font-family: monospace;
-  line-height: 1.25em;
-}
-
-h1, h2, h3, h4, h5, h6 {
-  margin: 0;
-  padding: 0;
-  font-weight: normal;
-}
-
-p, ul, ol, dl, blockquote {
-  margin: 0.3em;
-  padding: 0;
-}
-
-
-ul, ol {
-  
-  padding-left: 1em;
-  
-}
-
-a {
-  color: inherit;
-  text-decoration: none;
-  pointer-events: all;
-  color: cyan;
-}
-
-img {
-  padding: 1em 0;
-  max-width: 100%;
-}
-
-iframe {
-  width: 100%;
-  height: auto;
-  border:none;
-  pointer-events:all;
-}
-
-blockquote {
-  border-left: 4px solid #ccc;
-  padding-left: 1em;
-  margin-left: 0;
-  font-style: italic;
-}
-
-pre, code {
-  font-family: monospace;
-}
-
-table {
-  border-collapse: collapse;
-  width: 100%;
-  border-bottom: 1px solid #000;
-  margin: 1em 0;
-}
-
-th, td {
-  border-left: 1px solid #000;
-  border-right: 1px solid #000;
-  padding: 8px;
-  text-align: left;
-}
-
-th {
-  border: 1px solid #000;
-
-  background-color: rgba(0,0,0,0.5);
-}
-
-input[type="checkbox"] {
-  margin-right: 10px;
-}
-
-`
-
-const themes = [
-  'ambiance',
-  'chaos',
-  'chrome',
-  'cloud9_day',
-  'cloud9_night',
-  'cloud9_night_low_color',
-  'cloud_editor',
-  'cloud_editor_dark',
-  'clouds',
-  'clouds_midnight',
-  'cobalt',
-  'crimson_editor',
-  'dawn',
-  'dracula',
-  'dreamweaver',
-  'eclipse',
-  'github',
-  'github_dark',
-  'gob',
-  'gruvbox',
-  'gruvbox_dark_hard',
-  'gruvbox_light_hard',
-  'idle_fingers',
-  'iplastic',
-  'katzenmilch',
-  'kr_theme',
-  'kuroir',
-  'merbivore',
-  'merbivore_soft',
-  'mono_industrial',
-  'monokai',
-  'nord_dark',
-  'one_dark',
-  'pastel_on_dark',
-  'solarized_dark',
-  'solarized_light',
-  'sqlserver',
-  'terminal',
-  'textmate',
-  'tomorrow',
-  'tomorrow_night',
-  'tomorrow_night_blue',
-  'tomorrow_night_bright',
-  'tomorrow_night_eighties',
-  'twilight',
-  'vibrant_ink',
-  'vscode',
-]
-class NotePlus extends LiteGraph.LGraphNode {
-  // same values as the comfy note
-  color = LGraphCanvas.node_colors.yellow.color
-  bgcolor = LGraphCanvas.node_colors.yellow.bgcolor
-  groupcolor = LGraphCanvas.node_colors.yellow.groupcolor
-
-  constructor() {
-    super()
-    this.uuid = shared.makeUUID()
-
-    infoLogger('Constructing Note+ instance')
-    // - litegraph settings
-    this.collapsable = true
-    this.isVirtualNode = true
-    this.shape = LiteGraph.BOX_SHAPE
-    this.serialize_widgets = true
-
-    // - default values, serialization is done through widgets
-    this._raw_html = DEFAULT_MODE === 'html' ? DEFAULT_HTML : DEFAULT_MD
-
-    // - mardown converter
-    this.markdownConverter = new showdown.Converter({
-      tables: true,
-      strikethrough: true,
-      emoji: true,
-      ghCodeBlocks: true,
-      tasklists: true,
-      ghMentions: true,
-      smoothLivePreview: true,
-      simplifiedAutoLink: true,
-      parseImgDimensions: true,
-      openLinksInNewWindow: true,
-    })
-
-    // - state
-    this.live = true
-    this.calculated_height = 0
-
-    // - add widgets
-    const inner = document.createElement('div')
-    inner.style.margin = '0'
-    inner.style.padding = '0'
-    inner.style.pointerEvents = 'none'
-    this.html_widget = this.addDOMWidget('HTML', 'html', inner, {
-      setValue: (val) => {
-        this._raw_html = val
-      },
-      getValue: () => this._raw_html,
-      getMinHeight: () => this.calculated_height, // (the edit button),
-      hideOnZoom: false,
-    })
-
-    this.setupSerializationWidgets()
-    this.setupDialog()
-    this.loadAceEditor()
-  }
-
-  /**
-   *
-   * @param {CanvasRenderingContext2D} ctx
-   * @param {LGraphCanvas} graphcanvas
-   * @returns
-   */
-
-  onDrawForeground(ctx, _graphcanvas) {
-    if (this.flags.collapsed) return
-
-    // Define the size and position of the icon
-    const iconSize = 14 // Size of the icon
-    const iconMargin = 8 // Margin from the edges
-    const x = this.size[0] - iconSize - iconMargin
-    const y = iconMargin * 1.5
-
-    // Create a new Path2D object from SVG path data
-    const pencilPath = new Path2D(
-      'M21.28 6.4l-9.54 9.54c-.95.95-3.77 1.39-4.4.76-.63-.63-.2-3.45.75-4.4l9.55-9.55a2.58 2.58 0 1 1 3.64 3.65z',
-    )
-    const folderPath = new Path2D(
-      'M11 4H6a4 4 0 0 0-4 4v10a4 4 0 0 0 4 4h11c2.21 0 3-1.8 3-4v-5',
-    )
-
-    // Draw the paths
-    ctx.save()
-    ctx.translate(x, y) // Position the icon on the canvas
-    ctx.scale(iconSize / 32, iconSize / 32) // Scale the icon to the desired size
-    ctx.strokeStyle = 'rgba(255,255,255,0.3)'
-
-    ctx.lineCap = 'round'
-    ctx.lineJoin = 'round'
-
-    ctx.lineWidth = 2.4
-    ctx.stroke(pencilPath)
-    ctx.stroke(folderPath)
-    ctx.restore()
-  }
-  onMouseDown(_e, localPos, _graphcanvas) {
-    // Check if the click is within the pencil icon bounds
-    const iconSize = 14
-    const iconMargin = 8
-    const iconX = this.size[0] - iconSize - iconMargin
-    const iconY = iconMargin * 1.5
-
-    if (
-      localPos[0] > iconX &&
-      localPos[0] < iconX + iconSize &&
-      localPos[1] > iconY &&
-      localPos[1] < iconY + iconSize
-    ) {
-      // Pencil icon was clicked, open the editor
-      this.openEditorDialog()
-      return true // Return true to indicate the event was handled
-    }
-
-    return false // Return false to let the event propagate
-  }
-
-  setupSerializationWidgets() {
-    infoLogger('Setup Serializing widgets')
-
-    this.edit_mode_widget = this.addWidget(
-      'combo',
-      'Mode',
-      DEFAULT_MODE,
-      (me) => successLogger('Updating edit_mode', me),
-      {
-        values: ['html', 'markdown', 'raw'],
-      },
-    )
-    this.css_widget = this.addWidget('text', 'CSS', DEFAULT_CSS, (val) => {
-      successLogger(`Updating css ${val}`)
-    })
-    this.theme_widget = this.addWidget(
-      'text',
-      'Theme',
-      DEFAULT_THEME,
-      (val) => {
-        successLogger(`Setting theme ${val}`)
-      },
-    )
-
-    shared.hideWidgetForGood(this, this.edit_mode_widget)
-    shared.hideWidgetForGood(this, this.css_widget)
-    shared.hideWidgetForGood(this, this.theme_widget)
-  }
-  setupDialog() {
-    infoLogger('Setup dialog')
-    // this.addWidget('button', 'Edit', 'Edit', this.openEditorDialog.bind(this))
-
-    this.dialog = new app.ui.dialog.constructor()
-    this.dialog.element.classList.add('comfy-settings')
-
-    const closeButton = this.dialog.element.querySelector('button')
-    closeButton.textContent = 'CANCEL'
-    const saveButton = document.createElement('button')
-    saveButton.textContent = 'SAVE'
-    saveButton.onclick = () => {
-      this.closeEditorDialog(true)
-    }
-    closeButton.onclick = () => {
-      this.closeEditorDialog(false)
-    }
-    closeButton.before(saveButton)
-  }
-
-  teardownEditors() {
-    this.css_editor.destroy()
-    this.css_editor.container.remove()
-
-    this.html_editor.destroy()
-    this.html_editor.container.remove()
-  }
-
-  closeEditorDialog(accept) {
-    infoLogger('Closing editor dialog', accept)
-    if (accept) {
-      this.updateHTML(this.html_editor.getValue())
-      this.updateCSS(this.css_editor.getValue())
-    }
-    this.teardownEditors()
-    this.dialog.close()
-  }
-
-  openEditorDialog() {
-    infoLogger(`Current edit mode ${this.edit_mode_widget.value}`)
-    const container = document.createElement('div')
-
-    Object.assign(container.style, {
-      display: 'flex',
-      gap: '10px',
-      flexDirection: 'column',
-    })
-
-    const editorsContainer = document.createElement('div')
-    Object.assign(editorsContainer.style, {
-      display: 'flex',
-      gap: '10px',
-      flexDirection: 'row',
-    })
-
-    container.append(editorsContainer)
-
-    this.dialog.show('')
-    this.dialog.textElement.append(container)
-
-    const aceHTML = document.createElement('div')
-    aceHTML.id = 'noteplus-html-editor'
-    Object.assign(aceHTML.style, {
-      width: '300px',
-      height: '300px',
-      // backgroundColor: 'rgb(30,30,30)',
-      // color: 'whitesmoke',
-    })
-
-    editorsContainer.append(aceHTML)
-
-    const aceCSS = document.createElement('div')
-    aceCSS.id = 'noteplus-css-editor'
-    Object.assign(aceCSS.style, {
-      width: '300px',
-      height: '300px',
-      // backgroundColor: 'rgb(30,30,30)',
-      // color: 'whitesmoke',
-    })
-
-    editorsContainer.append(aceCSS)
-
-    const live_edit = document.createElement('input')
-    live_edit.type = 'checkbox'
-    live_edit.checked = this.live
-    live_edit.onchange = () => {
-      this.live = live_edit.checked
-    }
-
-    //- "Dynamic" elements
-    const firstButton = this.dialog.element.querySelector('button')
-    const syncUI = () => {
-      let convert_to_html =
-        this.dialog.element.querySelector('#convert-to-html')
-      if (this.edit_mode_widget.value === 'markdown') {
-        if (convert_to_html == null) {
-          convert_to_html = document.createElement('button')
-          convert_to_html.textContent = 'Convert to HTML (NO UNDO!)'
-          convert_to_html.id = 'convert-to-html'
-          convert_to_html.onclick = () => {
-            const select_mode = this.dialog.element.querySelector('#edit_mode')
-
-            const md = this.html_editor.getValue()
-            this.edit_mode_widget.value = 'html'
-            select_mode.value = 'html'
-            const html = this.markdownConverter.makeHtml(md)
-            this.html_widget.value = html
-            this.html_editor.setValue(html)
-            this.html_editor.session.setMode('ace/mode/html')
-            this.updateHTML(this.html_widget.value)
-
-            convert_to_html.remove()
-          }
-
-          firstButton.before(convert_to_html)
-        }
-      } else {
-        if (convert_to_html != null) {
-          convert_to_html.remove()
-          convert_to_html = null
-        }
-      }
-      select_mode.value = this.edit_mode_widget.value
-    }
-    //- combobox
-    let theme_select = this.dialog.element.querySelector('#theme_select')
-    if (!theme_select) {
-      infoLogger('Creating combobox for select')
-      theme_select = document.createElement('select')
-      theme_select.name = 'theme'
-      theme_select.id = 'theme_select'
-
-      const addOption = (label) => {
-        const option = document.createElement('option')
-        option.value = label
-        option.textContent = label
-        theme_select.append(option)
-      }
-      for (const t of themes) {
-        addOption(t)
-      }
-
-      theme_select.addEventListener('change', (event) => {
-        const val = event.target.value
-        this.setTheme(val)
-      })
-
-      container.prepend(theme_select)
-    }
-
-    theme_select.value = this.theme_widget.value
-
-    let select_mode = this.dialog.element.querySelector('#edit_mode')
-
-    if (!select_mode) {
-      infoLogger('Creating combobox for select')
-      select_mode = document.createElement('select')
-      select_mode.name = 'mode'
-      select_mode.id = 'edit_mode'
-
-      const addOption = (label) => {
-        const option = document.createElement('option')
-        option.value = label
-        option.textContent = label
-        select_mode.append(option)
-      }
-      addOption('markdown')
-      addOption('html')
-
-      select_mode.addEventListener('change', (event) => {
-        const val = event.target.value
-        this.edit_mode_widget.value = val
-        if (this.html_editor) {
-          this.html_editor.session.setMode(`ace/mode/${val}`)
-          this.updateHTML(this.html_editor.getValue())
-
-          syncUI()
-        }
-      })
-
-      container.append(select_mode)
-    }
-    select_mode.value = this.edit_mode_widget.value
-
-    syncUI()
-
-    const live_edit_label = document.createElement('label')
-    live_edit_label.textContent = 'Live Edit'
-
-    // add a tooltip
-    live_edit_label.title =
-      'When this is on, the editor will update the note+ whenever you change the text.'
-
-    live_edit_label.append(live_edit)
-
-    // select_mode.before(live_edit_label)
-    container.append(live_edit_label)
-
-    this.setupEditors()
-  }
-  loadAceEditor() {
-    shared.loadScript('/mtb_async/ace/ace.js').catch((e) => {
-      errorLogger(e)
-    })
-  }
-  onCreate() {
-    errorLogger('NotePlus onCreate')
-  }
-  configure(info) {
-    super.configure(info)
-    infoLogger('Restoring serialized values', info)
-    // - update view from serialzed data
-    this.html_widget.element.id = `note-plus-${this.uuid}`
-    this.setMode(this.edit_mode_widget.value)
-    this.setTheme(this.theme_widget.value)
-    this.updateHTML(this.html_widget.value)
-    this.updateCSS(this.css_widget.value)
-    this.setSize(info.size)
-  }
-  onNodeCreated() {
-    infoLogger('Node created', this.uuid)
-    this.html_widget.element.id = `note-plus-${this.uuid}`
-    this.setMode(this.edit_mode_widget.value)
-    this.setTheme(this.theme_widget.value)
-    this.updateHTML(this.html_widget.value) // widget is populated here since we called super
-    this.updateCSS(this.css_widget.value)
-  }
-  onRemoved() {
-    infoLogger('Node removed', this.uuid)
-  }
-  getExtraMenuOptions() {
-    const options = []
-    // {
-    //       content: string;
-    //       callback?: ContextMenuEventListener;
-    //       /** Used as innerHTML for extra child element */
-    //       title?: string;
-    //       disabled?: boolean;
-    //       has_submenu?: boolean;
-    //       submenu?: {
-    //           options: ContextMenuItem[];
-    //       } & IContextMenuOptions;
-    //       className?: string;
-    //   }
-    options.push({
-      content: `Set to ${
-        this.edit_mode_widget.value === 'html' ? 'markdown' : 'html'
-      }`,
-      callback: () => {
-        this.edit_mode_widget.value =
-          this.edit_mode_widget.value === 'html' ? 'markdown' : 'html'
-        this.updateHTML(this.html_widget.value)
-      },
-    })
-
-    return options
-  }
-
-  _setupEditor(editor) {
-    this.setTheme(this.theme_widget.value)
-
-    editor.setShowPrintMargin(false)
-    editor.session.setUseWrapMode(true)
-    editor.renderer.setShowGutter(false)
-    editor.session.setTabSize(4)
-    editor.session.setUseSoftTabs(true)
-    editor.setFontSize(14)
-    editor.setReadOnly(false)
-    editor.setHighlightActiveLine(false)
-    editor.setShowFoldWidgets(true)
-    return editor
-  }
-
-  setTheme(theme) {
-    this.theme_widget.value = theme
-    if (this.html_editor) {
-      this.html_editor.setTheme(`ace/theme/${theme}`)
-    }
-    if (this.css_editor) {
-      this.css_editor.setTheme(`ace/theme/${theme}`)
-    }
-  }
-
-  setMode(mode) {
-    this.edit_mode_widget.value = mode
-    if (this.html_editor) {
-      this.html_editor.session.setMode(`ace/mode/${mode}`)
-    }
-
-    this.updateHTML(this.html_widget.value)
-  }
-  setupEditors() {
-    infoLogger('NotePlus setupEditor')
-
-    this.html_editor = ace.edit('noteplus-html-editor')
-
-    this.css_editor = ace.edit('noteplus-css-editor')
-    this.css_editor.session.setMode('ace/mode/css')
-
-    this.setMode(DEFAULT_MODE)
-
-    this._setupEditor(this.html_editor)
-    this._setupEditor(this.css_editor)
-
-    this.css_editor.session.on('change', (_delta) => {
-      // delta.start, delta.end, delta.lines, delta.action
-      if (this.live) {
-        this.updateCSS(this.css_editor.getValue())
-      }
-    })
-
-    this.html_editor.session.on('change', (_delta) => {
-      // delta.start, delta.end, delta.lines, delta.action
-      if (this.live) {
-        this.updateHTML(this.html_editor.getValue())
-      }
-    })
-
-    this.html_editor.setValue(this.html_widget.value)
-    this.css_editor.setValue(this.css_widget.value)
-  }
-
-  scopeCss(css, scopeId) {
-    return css
-      .split('}')
-      .map((rule) => {
-        if (rule.trim() === '') {
-          return ''
-        }
-        const scopedRule = rule
-          .split('{')
-          .map((segment, index) => {
-            if (index === 0) {
-              return `#${scopeId} ${segment.trim()}`
-            }
-            return `{${segment.trim()}`
-          })
-          .join(' ')
-        return `${scopedRule}}`
-      })
-      .join('\n')
-  }
-  getCssDom() {
-    const styleTagId = `note-plus-stylesheet-${this.uuid}`
-
-    let styleTag = document.head.querySelector(`#${styleTagId}`)
-
-    if (!styleTag) {
-      styleTag = document.createElement('style')
-      styleTag.type = 'text/css'
-      styleTag.id = styleTagId
-      document.head.appendChild(styleTag)
-      infoLogger(`Creating note-plus-stylesheet-${this.uuid}`, styleTag)
-    }
-
-    return styleTag
-  }
-  calculateHeight() {
-    this.calculated_height = shared.calculateTotalChildrenHeight(
-      this.html_widget.element,
-    )
-    this.setDirtyCanvas(true, true)
-  }
-  updateCSS(css) {
-    infoLogger('NotePlus updateCSS')
-    // this.html_widget.element.style = css
-    const scopedCss = this.scopeCss(
-      `${CSS_RESET}\n${css}`,
-      `note-plus-${this.uuid}`,
-    )
-
-    const cssDom = this.getCssDom()
-    cssDom.innerHTML = scopedCss
-
-    this.css_widget.value = css
-    this.calculateHeight()
-    infoLogger('NotePlus updateCSS', this.calculated_height)
-    // this.setSize(this.computeSize())
-  }
-
-  updateHTML(val) {
-    const cleanHTML = DOMPurify.sanitize(val, { ADD_TAGS: ['iframe'] })
-    this.html_widget.value = cleanHTML
-
-    // update our widget preview
-    if (this.edit_mode_widget.value === 'html') {
-      this.html_widget.element.innerHTML = cleanHTML
-    } else if (this.edit_mode_widget.value === 'markdown') {
-      this.html_widget.element.innerHTML =
-        this.markdownConverter.makeHtml(cleanHTML)
-    }
-    this.calculateHeight()
-    // this.setSize(this.computeSize())
-  }
-}
-
-app.registerExtension({
-  name: 'mtb.noteplus',
-
-  registerCustomNodes() {
-    LiteGraph.registerNodeType('Note Plus (mtb)', NotePlus)
-
-    NotePlus.category = 'mtb/utils'
-    NotePlus.title = 'Note+ (mtb)'
-
-    NotePlus.title_mode = LiteGraph.NO_TITLE
-  },
-})

web/notify.js

@@ -7,7 +7,7 @@
  *
  */
 
-import { app } from '../../scripts/app.js'
+import { app } from '/scripts/app.js'
 
 const log = (...args) => {
   if (window.MTB?.TRACE) {

web/numberInput.js

@@ -1,334 +0,0 @@
-// This is a vanillajs implementation of Houdini's number input widgets.
-// It basically popup a visual sensitivity slider of steps to use as incr/decr
-// TODO: Convert it to IWidget
-
-// import styles from "./style.module.css";
-
-function getValidNumber(numberInput) {
-  let num =
-    isNaN(numberInput.value) || numberInput.value === ''
-      ? 0
-      : parseFloat(numberInput.value)
-  return num
-}
-/**
- * Number input widgets
- */
-export class NumberInputWidget {
-  constructor(containerId, numberOfInputs = 1, isDebug = false) {
-    this.container = document.getElementById(containerId)
-    this.numberOfInputs = numberOfInputs
-    this.currentInput = null // Store the currently active input
-
-    this.threshold = 30
-    this.mouseSensitivityMultiplier = 0.05
-    this.debug = isDebug
-
-    //- states
-    this.initialMouseX
-    this.lastMouseX
-    this.activeStep = 1
-    this.accumulatedDelta = 0
-    this.stepLocked = false
-    this.thresholdExceeded = false
-    this.isDragging = false
-
-    const styleTagId = 'mtb-constant-style'
-
-    let styleTag = document.head.querySelector(`#${styleTagId}`)
-
-    if (!styleTag) {
-      styleTag = document.createElement('style')
-      styleTag.type = 'text/css'
-      styleTag.id = styleTagId
-
-      styleTag.innerHTML = `
-
-.${containerId}{
-  margin-top: 20px;
-  margin-bottom: 20px;
-}
-.sensitivity-menu {
-  display: none;
-  position: absolute;
-  /* Additional styling */
-}
-
-.sensitivity-menu .step {
-  cursor: pointer;
-  padding: 0.5em;
-  /* Add more styling as needed */
-}
-
-.sensitivity-menu {
-  font-family: monospace;
-
-  background: var(--bg-color);
-  border: 1px solid var(--fg-color); 
-  /* Highlight for the active step */
-}
-.number-input {
-  background: var(--bg-color);
-  color: var(--fg-color)
-}
-
-.sensitivity-menu .step.active {
-  background-color:var(--drag-text); 
-  /* Highlight for the active step */
-}
-
-.sensitivity-menu .step.locked {
-  background-color: #f00;
-  /* Change to your preferred color for the locked state */
-}
-#debug-container {
-  transform: translateX(50%);
-  width: 50%;
-  text-align: center;
-  font-family: monospace;
-}
-`
-      document.head.appendChild(styleTag)
-    }
-
-    this.createWidgetElements()
-    this.initializeEventListeners()
-  }
-
-  setLabel(str) {
-    this.label.textContent = str
-  }
-  setValue(...values) {
-    if (values.length !== this.numberInputs.length) {
-      console.error('Number of values does not match the number of inputs.')
-      console.error(
-        `You provided ${values.length} but the input want ${this.numberInputs.length}`,
-        { values },
-      )
-      return
-    }
-    // Set each input value
-    this.numberInputs.forEach((input, index) => {
-      input.value = values[index]
-    })
-  }
-  getValue() {
-    const value = []
-    this.numberInputs.forEach((input, index) => {
-      value.push(Number.parseFloat(input.value) || 0.0)
-    })
-    return value
-  }
-  resetValues() {
-    for (const input of numberInputs) {
-      input.value = 0
-    }
-    this.onChange?.(this.getValue())
-  }
-
-  createWidgetElements() {
-    this.label = document.createElement('label')
-    this.label.textContent = 'Control All:'
-    this.label.className = 'widget-label'
-    this.container.appendChild(this.label)
-
-    this.label.addEventListener('mousedown', (event) => {
-      if (event.button === 1) {
-        this.currentInput = null
-        this.handleMouseDown(event)
-      }
-    })
-
-    this.label.addEventListener('contextmenu', (event) => {
-      event.preventDefault()
-      this.resetValues()
-    })
-
-    this.numberInputs = []
-
-    // create linked inputs
-    for (let i = 0; i < this.numberOfInputs; i++) {
-      const numberInput = document.createElement('input')
-      numberInput.type = 'number'
-      numberInput.className = 'number-input' //styles.numberInput; //"number-input";
-      numberInput.step = 'any'
-      this.container.appendChild(numberInput)
-      this.numberInputs.push(numberInput)
-
-      numberInput.addEventListener('mousedown', (event) => {
-        if (event.button === 1) {
-          this.currentInput = numberInput
-          this.handleMouseDown(event)
-        }
-      })
-    }
-    this.sensitivityMenu = document.createElement('div')
-    this.sensitivityMenu.className = 'sensitivity-menu' //styles.sensitivityMenu; //"sensitivity-menu";
-    this.container.appendChild(this.sensitivityMenu)
-
-    // create steps
-    const stepsValues = [0.001, 0.01, 0.1, 1, 10, 100]
-    stepsValues.forEach((value) => {
-      const step = document.createElement('div')
-      step.className = 'step' //styles.step //"step";
-      step.dataset.step = value
-      step.textContent = value.toString()
-      this.sensitivityMenu.appendChild(step)
-    })
-
-    this.steps = this.sensitivityMenu.getElementsByClassName('step') //styles.step)
-
-    if (this.debug) {
-      this.debugContainer = document.createElement('div')
-      this.debugContainer.id = 'debug-container' //styles.debugContainer //"debugContainer";
-      document.body.appendChild(this.debugContainer)
-    }
-  }
-  showSensitivityMenu(pageX, pageY) {
-    this.sensitivityMenu.style.display = 'block'
-    this.sensitivityMenu.style.left = `${pageX}px`
-    this.sensitivityMenu.style.top = `${pageY}px`
-    this.initialMouseX = pageX
-    this.lastMouseX = pageX
-    this.isDragging = true
-    this.thresholdExceeded = false
-    this.stepLocked = false
-    this.updateDebugInfo()
-  }
-  updateDebugInfo() {
-    if (this.debug) {
-      this.debugContainer.innerHTML = `
-        <div>Active Step: ${this.activeStep}</div>
-        <div>Initial Mouse X: ${this.initialMouseX}</div>
-        <div>Last Mouse X: ${this.lastMouseX}</div>
-        <div>Accumulated Delta: ${this.accumulatedDelta}</div>
-        <div>Threshold Exceeded: ${this.thresholdExceeded}</div>
-        <div>Step Locked: ${this.stepLocked}</div>
-        <div>Number Input Value: ${this.currentInput?.value}</div>
-    `
-    }
-  }
-  handleMouseDown(event) {
-    if (event.button === 1) {
-      this.showSensitivityMenu(
-        event.target.offsetWidth,
-        event.target.offsetHeight,
-      )
-      event.preventDefault()
-    }
-  }
-  handleMouseUp(event) {
-    if (event.button === 1) {
-      this.resetWidgetState()
-    }
-  }
-  handleClickOutside(event) {
-    if (event.target !== this.numberInput) {
-      this.resetWidgetState()
-    }
-  }
-  handleMouseMove(event) {
-    if (this.sensitivityMenu.style.display === 'block') {
-      const relativeY = event.pageY - 300 // this.sensitivityMenu.offsetTop
-
-      const horizontalDistanceFromInitial = Math.abs(
-        event.target.offsetWidth - this.initialMouseX,
-      )
-
-      // Unlock if the mouse moves back towards the initial position
-      if (horizontalDistanceFromInitial < this.threshold) {
-        this.thresholdExceeded = false
-        this.stepLocked = false
-        this.accumulatedDelta = 0
-      }
-
-      // Update step only if it is not locked
-      if (!this.stepLocked) {
-        for (let step of this.steps) {
-          step.classList.remove('active') //styles.active)
-          step.classList.remove('locked') //styles.locked)
-          if (
-            relativeY >= step.offsetTop &&
-            relativeY <= step.offsetTop + step.offsetHeight
-          ) {
-            step.classList.add('active') //styles.active)
-            this.setActiveStep(parseFloat(step.dataset.step))
-          }
-        }
-      }
-
-      if (this.stepLocked) {
-        this.sensitivityMenu
-          .querySelector('.step.active')
-          ?.classList.add('locked')
-      }
-
-      this.updateStepValue(event.pageX)
-    }
-  }
-
-  initializeEventListeners() {
-    document.addEventListener('mousemove', (event) =>
-      this.handleMouseMove(event),
-    )
-    document.addEventListener('mouseup', (event) => this.handleMouseUp(event))
-
-    document.addEventListener('click', (event) =>
-      this.handleClickOutside(event),
-    )
-  }
-
-  setActiveStep(val) {
-    if (this.activeStep !== val) {
-      this.activeStep = val
-      this.stepLocked = false
-      this.accumulatedDelta = 0
-      this.thresholdExceeded = false
-    }
-  }
-  resetWidgetState() {
-    this.sensitivityMenu.style.display = 'none'
-    this.isDragging = false
-    this.lastMouseX = undefined
-    this.thresholdExceeded = false
-    this.stepLocked = false
-    this.updateDebugInfo()
-  }
-  updateStepValue(mouseX) {
-    if (this.isDragging && this.lastMouseX !== undefined) {
-      const deltaX = mouseX - this.lastMouseX
-      this.accumulatedDelta += deltaX
-
-      if (
-        !this.thresholdExceeded &&
-        Math.abs(this.accumulatedDelta) > this.threshold
-      ) {
-        this.thresholdExceeded = true
-        this.stepLocked = true
-      }
-
-      if (this.thresholdExceeded && this.stepLocked) {
-        // frequency of value changes
-        if (
-          Math.abs(this.accumulatedDelta) * this.mouseSensitivityMultiplier >=
-          1
-        ) {
-          const valueChange = Math.sign(this.accumulatedDelta) * this.activeStep
-          if (this.currentInput) {
-            this.currentInput.value =
-              getValidNumber(this.currentInput) + valueChange
-            this.onChange?.(this.getValue())
-          } else {
-            this.numberInputs.forEach((input) => {
-              input.value = getValidNumber(input) + valueChange
-            })
-          }
-          this.accumulatedDelta = 0
-        }
-      }
-
-      this.lastMouseX = mouseX
-    }
-    this.updateDebugInfo()
-  }
-}

web_async/ace/ext-beautify.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/beautify",["require","exports","module","ace/token_iterator"],function(e,t,n){"use strict";function i(e,t){return e.type.lastIndexOf(t+".xml")>-1}var r=e("../token_iterator").TokenIterator;t.singletonTags=["area","base","br","col","command","embed","hr","html","img","input","keygen","link","meta","param","source","track","wbr"],t.blockTags=["article","aside","blockquote","body","div","dl","fieldset","footer","form","head","header","html","nav","ol","p","script","section","style","table","tbody","tfoot","thead","ul"],t.formatOptions={lineBreaksAfterCommasInCurlyBlock:!0},t.beautify=function(e){var n=new r(e,0,0),s=n.getCurrentToken(),o=e.getTabString(),u=t.singletonTags,a=t.blockTags,f=t.formatOptions||{},l,c=!1,h=!1,p=!1,d="",v="",m="",g=0,y=0,b=0,w=0,E=0,S=0,x=0,T,N=0,C=0,k=[],L=!1,A,O=!1,M=!1,_=!1,D=!1,P={0:0},H=[],B=!1,j=function(){l&&l.value&&l.type!=="string.regexp"&&(l.value=l.value.replace(/^\s*/,""))},F=function(){var e=d.length-1;for(;;){if(e==0)break;if(d[e]!==" ")break;e-=1}d=d.slice(0,e+1)},I=function(){d=d.trimRight(),c=!1};while(s!==null){N=n.getCurrentTokenRow(),k=n.$rowTokens,l=n.stepForward();if(typeof s!="undefined"){v=s.value,E=0,_=m==="style"||e.$modeId==="ace/mode/css",i(s,"tag-open")?(M=!0,l&&(D=a.indexOf(l.value)!==-1),v==="</"&&(D&&!c&&C<1&&C++,_&&(C=1),E=1,D=!1)):i(s,"tag-close")?M=!1:i(s,"comment.start")?D=!0:i(s,"comment.end")&&(D=!1),!M&&!C&&s.type==="paren.rparen"&&s.value.substr(0,1)==="}"&&C++,N!==T&&(C=N,T&&(C-=T));if(C){I();for(;C>0;C--)d+="\n";c=!0,!i(s,"comment")&&!s.type.match(/^(comment|string)$/)&&(v=v.trimLeft())}if(v){s.type==="keyword"&&v.match(/^(if|else|elseif|for|foreach|while|switch)$/)?(H[g]=v,j(),p=!0,v.match(/^(else|elseif)$/)&&d.match(/\}[\s]*$/)&&(I(),h=!0)):s.type==="paren.lparen"?(j(),v.substr(-1)==="{"&&(p=!0,O=!1,M||(C=1)),v.substr(0,1)==="{"&&(h=!0,d.substr(-1)!=="["&&d.trimRight().substr(-1)==="["?(I(),h=!1):d.trimRight().substr(-1)===")"?I():F())):s.type==="paren.rparen"?(E=1,v.substr(0,1)==="}"&&(H[g-1]==="case"&&E++,d.trimRight().substr(-1)==="{"?I():(h=!0,_&&(C+=2))),v.substr(0,1)==="]"&&d.substr(-1)!=="}"&&d.trimRight().substr(-1)==="}"&&(h=!1,w++,I()),v.substr(0,1)===")"&&d.substr(-1)!=="("&&d.trimRight().substr(-1)==="("&&(h=!1,w++,I()),F()):s.type!=="keyword.operator"&&s.type!=="keyword"||!v.match(/^(=|==|===|!=|!==|&&|\|\||and|or|xor|\+=|.=|>|>=|<|<=|=>)$/)?s.type==="punctuation.operator"&&v===";"?(I(),j(),p=!0,_&&C++):s.type==="punctuation.operator"&&v.match(/^(:|,)$/)?(I(),j(),v.match(/^(,)$/)&&x>0&&S===0&&f.lineBreaksAfterCommasInCurlyBlock?C++:(p=!0,c=!1)):s.type==="support.php_tag"&&v==="?>"&&!c?(I(),h=!0):i(s,"attribute-name")&&d.substr(-1).match(/^\s$/)?h=!0:i(s,"attribute-equals")?(F(),j()):i(s,"tag-close")?(F(),v==="/>"&&(h=!0)):s.type==="keyword"&&v.match(/^(case|default)$/)&&B&&(E=1):(I(),j(),h=!0,p=!0);if(c&&(!s.type.match(/^(comment)$/)||!!v.substr(0,1).match(/^[/#]$/))&&(!s.type.match(/^(string)$/)||!!v.substr(0,1).match(/^['"@]$/))){w=b;if(g>y){w++;for(A=g;A>y;A--)P[A]=w}else g<y&&(w=P[g]);y=g,b=w,E&&(w-=E),O&&!S&&(w++,O=!1);for(A=0;A<w;A++)d+=o}s.type==="keyword"&&v.match(/^(case|default)$/)?B===!1&&(H[g]=v,g++,B=!0):s.type==="keyword"&&v.match(/^(break)$/)&&H[g-1]&&H[g-1].match(/^(case|default)$/)&&(g--,B=!1),s.type==="paren.lparen"&&(S+=(v.match(/\(/g)||[]).length,x+=(v.match(/\{/g)||[]).length,g+=v.length),s.type==="keyword"&&v.match(/^(if|else|elseif|for|while)$/)?(O=!0,S=0):!S&&v.trim()&&s.type!=="comment"&&(O=!1);if(s.type==="paren.rparen"){S-=(v.match(/\)/g)||[]).length,x-=(v.match(/\}/g)||[]).length;for(A=0;A<v.length;A++)g--,v.substr(A,1)==="}"&&H[g]==="case"&&g--}s.type=="text"&&(v=v.replace(/\s+$/," ")),h&&!c&&(F(),d.substr(-1)!=="\n"&&(d+=" ")),d+=v,p&&(d+=" "),c=!1,h=!1,p=!1;if(i(s,"tag-close")&&(D||a.indexOf(m)!==-1)||i(s,"doctype")&&v===">")D&&l&&l.value==="</"?C=-1:C=1;l&&u.indexOf(l.value)===-1&&(i(s,"tag-open")&&v==="</"?g--:i(s,"tag-open")&&v==="<"?g++:i(s,"tag-close")&&v==="/>"&&g--),i(s,"tag-name")&&(m=v),T=N}}s=l}d=d.trim(),e.doc.setValue(d)},t.commands=[{name:"beautify",description:"Format selection (Beautify)",exec:function(e){t.beautify(e.session)},bindKey:"Ctrl-Shift-B"}]});                (function() {
-                    ace.require(["ace/ext/beautify"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-code_lens.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/code_lens",["require","exports","module","ace/line_widgets","ace/lib/event","ace/lib/lang","ace/lib/dom","ace/editor","ace/config"],function(e,t,n){"use strict";function u(e){var t=e.$textLayer,n=t.$lenses;n&&n.forEach(function(e){e.remove()}),t.$lenses=null}function a(e,t){var n=e&t.CHANGE_LINES||e&t.CHANGE_FULL||e&t.CHANGE_SCROLL||e&t.CHANGE_TEXT;if(!n)return;var r=t.session,i=t.session.lineWidgets,s=t.$textLayer,a=s.$lenses;if(!i){a&&u(t);return}var f=t.$textLayer.$lines.cells,l=t.layerConfig,c=t.$padding;a||(a=s.$lenses=[]);var h=0;for(var p=0;p<f.length;p++){var d=f[p].row,v=i[d],m=v&&v.lenses;if(!m||!m.length)continue;var g=a[h];g||(g=a[h]=o.buildDom(["div",{"class":"ace_codeLens"}],t.container)),g.style.height=l.lineHeight+"px",h++;for(var y=0;y<m.length;y++){var b=g.childNodes[2*y];b||(y!=0&&g.appendChild(o.createTextNode("\u00a0|\u00a0")),b=o.buildDom(["a"],g)),b.textContent=m[y].title,b.lensCommand=m[y]}while(g.childNodes.length>2*y-1)g.lastChild.remove();var w=t.$cursorLayer.getPixelPosition({row:d,column:0},!0).top-l.lineHeight*v.rowsAbove-l.offset;g.style.top=w+"px";var E=t.gutterWidth,S=r.getLine(d).search(/\S|$/);S==-1&&(S=0),E+=S*l.characterWidth,g.style.paddingLeft=c+E+"px"}while(h<a.length)a.pop().remove()}function f(e){if(!e.lineWidgets)return;var t=e.widgetManager;e.lineWidgets.forEach(function(e){e&&e.lenses&&t.removeLineWidget(e)})}function l(e){e.codeLensProviders=[],e.renderer.on("afterRender",a),e.$codeLensClickHandler||(e.$codeLensClickHandler=function(t){var n=t.target.lensCommand;if(!n)return;e.execCommand(n.id,n.arguments),e._emit("codeLensClick",t)},i.addListener(e.container,"click",e.$codeLensClickHandler,e)),e.$updateLenses=function(){function o(){var r=n.selection.cursor,i=n.documentToScreenRow(r),o=n.getScrollTop(),u=t.setLenses(n,s),a=n.$undoManager&&n.$undoManager.$lastDelta;if(a&&a.action=="remove"&&a.lines.length>1)return;var f=n.documentToScreenRow(r),l=e.renderer.layerConfig.lineHeight,c=n.getScrollTop()+(f-i)*l;u==0&&o<l/4&&o>-l/4&&(c=-l),n.setScrollTop(c)}var n=e.session;if(!n)return;n.widgetManager||(n.widgetManager=new r(n),n.widgetManager.attach(e));var i=e.codeLensProviders.length,s=[];e.codeLensProviders.forEach(function(e){e.provideCodeLenses(n,function(e,t){if(e)return;t.forEach(function(e){s.push(e)}),i--,i==0&&o()})})};var n=s.delayedCall(e.$updateLenses);e.$updateLensesOnInput=function(){n.delay(250)},e.on("input",e.$updateLensesOnInput)}function c(e){e.off("input",e.$updateLensesOnInput),e.renderer.off("afterRender",a),e.$codeLensClickHandler&&e.container.removeEventListener("click",e.$codeLensClickHandler)}var r=e("../line_widgets").LineWidgets,i=e("../lib/event"),s=e("../lib/lang"),o=e("../lib/dom");t.setLenses=function(e,t){var n=Number.MAX_VALUE;return f(e),t&&t.forEach(function(t){var r=t.start.row,i=t.start.column,s=e.lineWidgets&&e.lineWidgets[r];if(!s||!s.lenses)s=e.widgetManager.$registerLineWidget({rowCount:1,rowsAbove:1,row:r,column:i,lenses:[]});s.lenses.push(t.command),r<n&&(n=r)}),e._emit("changeFold",{data:{start:{row:n}}}),n},t.registerCodeLensProvider=function(e,t){e.setOption("enableCodeLens",!0),e.codeLensProviders.push(t),e.$updateLensesOnInput()},t.clear=function(e){t.setLenses(e,null)};var h=e("../editor").Editor;e("../config").defineOptions(h.prototype,"editor",{enableCodeLens:{set:function(e){e?l(this):c(this)}}}),o.importCssString("\n.ace_codeLens {\n    position: absolute;\n    color: #aaa;\n    font-size: 88%;\n    background: inherit;\n    width: 100%;\n    display: flex;\n    align-items: flex-end;\n    pointer-events: none;\n}\n.ace_codeLens > a {\n    cursor: pointer;\n    pointer-events: auto;\n}\n.ace_codeLens > a:hover {\n    color: #0000ff;\n    text-decoration: underline;\n}\n.ace_dark > .ace_codeLens > a:hover {\n    color: #4e94ce;\n}\n","codelense.css",!1)});                (function() {
-                    ace.require(["ace/ext/code_lens"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-elastic_tabstops_lite.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/elastic_tabstops_lite",["require","exports","module","ace/editor","ace/config"],function(e,t,n){"use strict";var r=function(){function e(e){this.$editor=e;var t=this,n=[],r=!1;this.onAfterExec=function(){r=!1,t.processRows(n),n=[]},this.onExec=function(){r=!0},this.onChange=function(e){r&&(n.indexOf(e.start.row)==-1&&n.push(e.start.row),e.end.row!=e.start.row&&n.push(e.end.row))}}return e.prototype.processRows=function(e){this.$inChange=!0;var t=[];for(var n=0,r=e.length;n<r;n++){var i=e[n];if(t.indexOf(i)>-1)continue;var s=this.$findCellWidthsForBlock(i),o=this.$setBlockCellWidthsToMax(s.cellWidths),u=s.firstRow;for(var a=0,f=o.length;a<f;a++){var l=o[a];t.push(u),this.$adjustRow(u,l),u++}}this.$inChange=!1},e.prototype.$findCellWidthsForBlock=function(e){var t=[],n,r=e;while(r>=0){n=this.$cellWidthsForRow(r);if(n.length==0)break;t.unshift(n),r--}var i=r+1;r=e;var s=this.$editor.session.getLength();while(r<s-1){r++,n=this.$cellWidthsForRow(r);if(n.length==0)break;t.push(n)}return{cellWidths:t,firstRow:i}},e.prototype.$cellWidthsForRow=function(e){var t=this.$selectionColumnsForRow(e),n=[-1].concat(this.$tabsForRow(e)),r=n.map(function(e){return 0}).slice(1),i=this.$editor.session.getLine(e);for(var s=0,o=n.length-1;s<o;s++){var u=n[s]+1,a=n[s+1],f=this.$rightmostSelectionInCell(t,a),l=i.substring(u,a);r[s]=Math.max(l.replace(/\s+$/g,"").length,f-u)}return r},e.prototype.$selectionColumnsForRow=function(e){var t=[],n=this.$editor.getCursorPosition();return this.$editor.session.getSelection().isEmpty()&&e==n.row&&t.push(n.column),t},e.prototype.$setBlockCellWidthsToMax=function(e){var t=!0,n,r,i,s=this.$izip_longest(e);for(var o=0,u=s.length;o<u;o++){var a=s[o];if(!a.push){console.error(a);continue}a.push(NaN);for(var f=0,l=a.length;f<l;f++){var c=a[f];t&&(n=f,i=0,t=!1);if(isNaN(c)){r=f;for(var h=n;h<r;h++)e[h][o]=i;t=!0}i=Math.max(i,c)}}return e},e.prototype.$rightmostSelectionInCell=function(e,t){var n=0;if(e.length){var r=[];for(var i=0,s=e.length;i<s;i++)e[i]<=t?r.push(i):r.push(0);n=Math.max.apply(Math,r)}return n},e.prototype.$tabsForRow=function(e){var t=[],n=this.$editor.session.getLine(e),r=/\t/g,i;while((i=r.exec(n))!=null)t.push(i.index);return t},e.prototype.$adjustRow=function(e,t){var n=this.$tabsForRow(e);if(n.length==0)return;var r=0,i=-1,s=this.$izip(t,n);for(var o=0,u=s.length;o<u;o++){var a=s[o][0],f=s[o][1];i+=1+a,f+=r;var l=i-f;if(l==0)continue;var c=this.$editor.session.getLine(e).substr(0,f),h=c.replace(/\s*$/g,""),p=c.length-h.length;l>0&&(this.$editor.session.getDocument().insertInLine({row:e,column:f+1},Array(l+1).join(" ")+"	"),this.$editor.session.getDocument().removeInLine(e,f,f+1),r+=l),l<0&&p>=-l&&(this.$editor.session.getDocument().removeInLine(e,f+l,f),r+=l)}},e.prototype.$izip_longest=function(e){if(!e[0])return[];var t=e[0].length,n=e.length;for(var r=1;r<n;r++){var i=e[r].length;i>t&&(t=i)}var s=[];for(var o=0;o<t;o++){var u=[];for(var r=0;r<n;r++)e[r][o]===""?u.push(NaN):u.push(e[r][o]);s.push(u)}return s},e.prototype.$izip=function(e,t){var n=e.length>=t.length?t.length:e.length,r=[];for(var i=0;i<n;i++){var s=[e[i],t[i]];r.push(s)}return r},e}();t.ElasticTabstopsLite=r;var i=e("../editor").Editor;e("../config").defineOptions(i.prototype,"editor",{useElasticTabstops:{set:function(e){e?(this.elasticTabstops||(this.elasticTabstops=new r(this)),this.commands.on("afterExec",this.elasticTabstops.onAfterExec),this.commands.on("exec",this.elasticTabstops.onExec),this.on("change",this.elasticTabstops.onChange)):this.elasticTabstops&&(this.commands.removeListener("afterExec",this.elasticTabstops.onAfterExec),this.commands.removeListener("exec",this.elasticTabstops.onExec),this.removeListener("change",this.elasticTabstops.onChange))}}})});                (function() {
-                    ace.require(["ace/ext/elastic_tabstops_lite"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-error_marker.js

@@ -1,8 +0,0 @@
-;                (function() {
-                    ace.require(["ace/ext/error_marker"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-hardwrap.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/hardwrap",["require","exports","module","ace/range","ace/editor","ace/config"],function(e,t,n){"use strict";function i(e,t){function m(e,t,n){if(e.length<t)return;var r=e.slice(0,t),i=e.slice(t),s=/^(?:(\s+)|(\S+)(\s+))/.exec(i),o=/(?:(\s+)|(\s+)(\S+))$/.exec(r),u=0,a=0;o&&!o[2]&&(u=t-o[1].length,a=t),s&&!s[2]&&(u||(u=t),a=t+s[1].length);if(u)return{start:u,end:a};if(o&&o[2]&&o.index>n)return{start:o.index,end:o.index+o[2].length};if(s&&s[2])return u=t+s[2].length,{start:u,end:u+s[3].length}}var n=t.column||e.getOption("printMarginColumn"),i=t.allowMerge!=0,s=Math.min(t.startRow,t.endRow),o=Math.max(t.startRow,t.endRow),u=e.session;while(s<=o){var a=u.getLine(s);if(a.length>n){var f=m(a,n,5);if(f){var l=/^\s*/.exec(a)[0];u.replace(new r(s,f.start,s,f.end),"\n"+l)}o++}else if(i&&/\S/.test(a)&&s!=o){var c=u.getLine(s+1);if(c&&/\S/.test(c)){var h=a.replace(/\s+$/,""),p=c.replace(/^\s+/,""),d=h+" "+p,f=m(d,n,5);if(f&&f.start>h.length||d.length<n){var v=new r(s,h.length,s+1,c.length-p.length);u.replace(v," "),s--,o--}else h.length<a.length&&u.remove(new r(s,h.length,s,a.length))}}s++}}function s(e){if(e.command.name=="insertstring"&&/\S/.test(e.args)){var t=e.editor,n=t.selection.cursor;if(n.column<=t.renderer.$printMarginColumn)return;var r=t.session.$undoManager.$lastDelta;i(t,{startRow:n.row,endRow:n.row,allowMerge:!1}),r!=t.session.$undoManager.$lastDelta&&t.session.markUndoGroup()}}var r=e("../range").Range,o=e("../editor").Editor;e("../config").defineOptions(o.prototype,"editor",{hardWrap:{set:function(e){e?this.commands.on("afterExec",s):this.commands.off("afterExec",s)},value:!1}}),t.hardWrap=i});                (function() {
-                    ace.require(["ace/ext/hardwrap"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-keybinding_menu.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/menu_tools/settings_menu.css",["require","exports","module"],function(e,t,n){n.exports="#ace_settingsmenu, #kbshortcutmenu {\n    background-color: #F7F7F7;\n    color: black;\n    box-shadow: -5px 4px 5px rgba(126, 126, 126, 0.55);\n    padding: 1em 0.5em 2em 1em;\n    overflow: auto;\n    position: absolute;\n    margin: 0;\n    bottom: 0;\n    right: 0;\n    top: 0;\n    z-index: 9991;\n    cursor: default;\n}\n\n.ace_dark #ace_settingsmenu, .ace_dark #kbshortcutmenu {\n    box-shadow: -20px 10px 25px rgba(126, 126, 126, 0.25);\n    background-color: rgba(255, 255, 255, 0.6);\n    color: black;\n}\n\n.ace_optionsMenuEntry:hover {\n    background-color: rgba(100, 100, 100, 0.1);\n    transition: all 0.3s\n}\n\n.ace_closeButton {\n    background: rgba(245, 146, 146, 0.5);\n    border: 1px solid #F48A8A;\n    border-radius: 50%;\n    padding: 7px;\n    position: absolute;\n    right: -8px;\n    top: -8px;\n    z-index: 100000;\n}\n.ace_closeButton{\n    background: rgba(245, 146, 146, 0.9);\n}\n.ace_optionsMenuKey {\n    color: darkslateblue;\n    font-weight: bold;\n}\n.ace_optionsMenuCommand {\n    color: darkcyan;\n    font-weight: normal;\n}\n.ace_optionsMenuEntry input, .ace_optionsMenuEntry button {\n    vertical-align: middle;\n}\n\n.ace_optionsMenuEntry button[ace_selected_button=true] {\n    background: #e7e7e7;\n    box-shadow: 1px 0px 2px 0px #adadad inset;\n    border-color: #adadad;\n}\n.ace_optionsMenuEntry button {\n    background: white;\n    border: 1px solid lightgray;\n    margin: 0px;\n}\n.ace_optionsMenuEntry button:hover{\n    background: #f0f0f0;\n}"}),ace.define("ace/ext/menu_tools/overlay_page",["require","exports","module","ace/lib/dom","ace/ext/menu_tools/settings_menu.css"],function(e,t,n){"use strict";var r=e("../../lib/dom"),i=e("./settings_menu.css");r.importCssString(i,"settings_menu.css",!1),n.exports.overlayPage=function(t,n,r){function o(e){e.keyCode===27&&u()}function u(){if(!i)return;document.removeEventListener("keydown",o),i.parentNode.removeChild(i),t&&t.focus(),i=null,r&&r()}function a(e){s=e,e&&(i.style.pointerEvents="none",n.style.pointerEvents="auto")}var i=document.createElement("div"),s=!1;return i.style.cssText="margin: 0; padding: 0; position: fixed; top:0; bottom:0; left:0; right:0;z-index: 9990; "+(t?"background-color: rgba(0, 0, 0, 0.3);":""),i.addEventListener("click",function(e){s||u()}),document.addEventListener("keydown",o),n.addEventListener("click",function(e){e.stopPropagation()}),i.appendChild(n),document.body.appendChild(i),t&&t.blur(),{close:u,setIgnoreFocusOut:a}}}),ace.define("ace/ext/menu_tools/get_editor_keyboard_shortcuts",["require","exports","module","ace/lib/keys"],function(e,t,n){"use strict";var r=e("../../lib/keys");n.exports.getEditorKeybordShortcuts=function(e){var t=r.KEY_MODS,n=[],i={};return e.keyBinding.$handlers.forEach(function(e){var t=e.commandKeyBinding;for(var r in t){var s=r.replace(/(^|-)\w/g,function(e){return e.toUpperCase()}),o=t[r];Array.isArray(o)||(o=[o]),o.forEach(function(e){typeof e!="string"&&(e=e.name),i[e]?i[e].key+="|"+s:(i[e]={key:s,command:e},n.push(i[e]))})}}),n}}),ace.define("ace/ext/keybinding_menu",["require","exports","module","ace/editor","ace/ext/menu_tools/overlay_page","ace/ext/menu_tools/get_editor_keyboard_shortcuts"],function(e,t,n){"use strict";function i(t){if(!document.getElementById("kbshortcutmenu")){var n=e("./menu_tools/overlay_page").overlayPage,r=e("./menu_tools/get_editor_keyboard_shortcuts").getEditorKeybordShortcuts,i=r(t),s=document.createElement("div"),o=i.reduce(function(e,t){return e+'<div class="ace_optionsMenuEntry"><span class="ace_optionsMenuCommand">'+t.command+"</span> : "+'<span class="ace_optionsMenuKey">'+t.key+"</span></div>"},"");s.id="kbshortcutmenu",s.innerHTML="<h1>Keyboard Shortcuts</h1>"+o+"</div>",n(t,s)}}var r=e("../editor").Editor;n.exports.init=function(e){r.prototype.showKeyboardShortcuts=function(){i(this)},e.commands.addCommands([{name:"showKeyboardShortcuts",bindKey:{win:"Ctrl-Alt-h",mac:"Command-Alt-h"},exec:function(e,t){e.showKeyboardShortcuts()}}])}});                (function() {
-                    ace.require(["ace/ext/keybinding_menu"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-linking.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/linking",["require","exports","module","ace/editor","ace/config"],function(e,t,n){function i(e){var n=e.editor,r=e.getAccelKey();if(r){var n=e.editor,i=e.getDocumentPosition(),s=n.session,o=s.getTokenAt(i.row,i.column);t.previousLinkingHover&&t.previousLinkingHover!=o&&n._emit("linkHoverOut"),n._emit("linkHover",{position:i,token:o}),t.previousLinkingHover=o}else t.previousLinkingHover&&(n._emit("linkHoverOut"),t.previousLinkingHover=!1)}function s(e){var t=e.getAccelKey(),n=e.getButton();if(n==0&&t){var r=e.editor,i=e.getDocumentPosition(),s=r.session,o=s.getTokenAt(i.row,i.column);r._emit("linkClick",{position:i,token:o})}}var r=e("../editor").Editor;e("../config").defineOptions(r.prototype,"editor",{enableLinking:{set:function(e){e?(this.on("click",s),this.on("mousemove",i)):(this.off("click",s),this.off("mousemove",i))},value:!1}}),t.previousLinkingHover=!1});                (function() {
-                    ace.require(["ace/ext/linking"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-modelist.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/modelist",["require","exports","module"],function(e,t,n){"use strict";function i(e){var t=a.text,n=e.split(/[\/\\]/).pop();for(var i=0;i<r.length;i++)if(r[i].supportsFile(n)){t=r[i];break}return t}var r=[],s=function(){function e(e,t,n){this.name=e,this.caption=t,this.mode="ace/mode/"+e,this.extensions=n;var r;/\^/.test(n)?r=n.replace(/\|(\^)?/g,function(e,t){return"$|"+(t?"^":"^.*\\.")})+"$":r="^.*\\.("+n+")$",this.extRe=new RegExp(r,"gi")}return e.prototype.supportsFile=function(e){return e.match(this.extRe)},e}(),o={ABAP:["abap"],ABC:["abc"],ActionScript:["as"],ADA:["ada|adb"],Alda:["alda"],Apache_Conf:["^htaccess|^htgroups|^htpasswd|^conf|htaccess|htgroups|htpasswd"],Apex:["apex|cls|trigger|tgr"],AQL:["aql"],AsciiDoc:["asciidoc|adoc"],ASL:["dsl|asl|asl.json"],Assembly_ARM32:["s"],Assembly_x86:["asm|a"],Astro:["astro"],AutoHotKey:["ahk"],BatchFile:["bat|cmd"],BibTeX:["bib"],C_Cpp:["cpp|c|cc|cxx|h|hh|hpp|ino"],C9Search:["c9search_results"],Cirru:["cirru|cr"],Clojure:["clj|cljs"],Cobol:["CBL|COB"],coffee:["coffee|cf|cson|^Cakefile"],ColdFusion:["cfm|cfc"],Crystal:["cr"],CSharp:["cs"],Csound_Document:["csd"],Csound_Orchestra:["orc"],Csound_Score:["sco"],CSS:["css"],Curly:["curly"],Cuttlefish:["conf"],D:["d|di"],Dart:["dart"],Diff:["diff|patch"],Django:["djt|html.djt|dj.html|djhtml"],Dockerfile:["^Dockerfile"],Dot:["dot"],Drools:["drl"],Edifact:["edi"],Eiffel:["e|ge"],EJS:["ejs"],Elixir:["ex|exs"],Elm:["elm"],Erlang:["erl|hrl"],Flix:["flix"],Forth:["frt|fs|ldr|fth|4th"],Fortran:["f|f90"],FSharp:["fsi|fs|ml|mli|fsx|fsscript"],FSL:["fsl"],FTL:["ftl"],Gcode:["gcode"],Gherkin:["feature"],Gitignore:["^.gitignore"],Glsl:["glsl|frag|vert"],Gobstones:["gbs"],golang:["go"],GraphQLSchema:["gql"],Groovy:["groovy"],HAML:["haml"],Handlebars:["hbs|handlebars|tpl|mustache"],Haskell:["hs"],Haskell_Cabal:["cabal"],haXe:["hx"],Hjson:["hjson"],HTML:["html|htm|xhtml|we|wpy"],HTML_Elixir:["eex|html.eex"],HTML_Ruby:["erb|rhtml|html.erb"],INI:["ini|conf|cfg|prefs"],Io:["io"],Ion:["ion"],Jack:["jack"],Jade:["jade|pug"],Java:["java"],JavaScript:["js|jsm|cjs|mjs"],JEXL:["jexl"],JSON:["json"],JSON5:["json5"],JSONiq:["jq"],JSP:["jsp"],JSSM:["jssm|jssm_state"],JSX:["jsx"],Julia:["jl"],Kotlin:["kt|kts"],LaTeX:["tex|latex|ltx|bib"],Latte:["latte"],LESS:["less"],Liquid:["liquid"],Lisp:["lisp"],LiveScript:["ls"],Log:["log"],LogiQL:["logic|lql"],Logtalk:["lgt"],LSL:["lsl"],Lua:["lua"],LuaPage:["lp"],Lucene:["lucene"],Makefile:["^Makefile|^GNUmakefile|^makefile|^OCamlMakefile|make"],Markdown:["md|markdown"],Mask:["mask"],MATLAB:["matlab"],Maze:["mz"],MediaWiki:["wiki|mediawiki"],MEL:["mel"],MIPS:["s|asm"],MIXAL:["mixal"],MUSHCode:["mc|mush"],MySQL:["mysql"],Nasal:["nas"],Nginx:["nginx|conf"],Nim:["nim"],Nix:["nix"],NSIS:["nsi|nsh"],Nunjucks:["nunjucks|nunjs|nj|njk"],ObjectiveC:["m|mm"],OCaml:["ml|mli"],Odin:["odin"],PartiQL:["partiql|pql"],Pascal:["pas|p"],Perl:["pl|pm"],pgSQL:["pgsql"],PHP:["php|inc|phtml|shtml|php3|php4|php5|phps|phpt|aw|ctp|module"],PHP_Laravel_blade:["blade.php"],Pig:["pig"],PLSQL:["plsql"],Powershell:["ps1"],Praat:["praat|praatscript|psc|proc"],Prisma:["prisma"],Prolog:["plg|prolog"],Properties:["properties"],Protobuf:["proto"],PRQL:["prql"],Puppet:["epp|pp"],Python:["py"],QML:["qml"],R:["r"],Raku:["raku|rakumod|rakutest|p6|pl6|pm6"],Razor:["cshtml|asp"],RDoc:["Rd"],Red:["red|reds"],RHTML:["Rhtml"],Robot:["robot|resource"],RST:["rst"],Ruby:["rb|ru|gemspec|rake|^Guardfile|^Rakefile|^Gemfile"],Rust:["rs"],SaC:["sac"],SASS:["sass"],SCAD:["scad"],Scala:["scala|sbt"],Scheme:["scm|sm|rkt|oak|scheme"],Scrypt:["scrypt"],SCSS:["scss"],SH:["sh|bash|^.bashrc"],SJS:["sjs"],Slim:["slim|skim"],Smarty:["smarty|tpl"],Smithy:["smithy"],snippets:["snippets"],Soy_Template:["soy"],Space:["space"],SPARQL:["rq"],SQL:["sql"],SQLServer:["sqlserver"],Stylus:["styl|stylus"],SVG:["svg"],Swift:["swift"],Tcl:["tcl"],Terraform:["tf","tfvars","terragrunt"],Tex:["tex"],Text:["txt"],Textile:["textile"],Toml:["toml"],TSX:["tsx"],Turtle:["ttl"],Twig:["twig|swig"],Typescript:["ts|mts|cts|typescript|str"],Vala:["vala"],VBScript:["vbs|vb"],Velocity:["vm"],Verilog:["v|vh|sv|svh"],VHDL:["vhd|vhdl"],Visualforce:["vfp|component|page"],Vue:["vue"],Wollok:["wlk|wpgm|wtest"],XML:["xml|rdf|rss|wsdl|xslt|atom|mathml|mml|xul|xbl|xaml"],XQuery:["xq"],YAML:["yaml|yml"],Zeek:["zeek|bro"],Zig:["zig"]},u={ObjectiveC:"Objective-C",CSharp:"C#",golang:"Go",C_Cpp:"C and C++",Csound_Document:"Csound Document",Csound_Orchestra:"Csound",Csound_Score:"Csound Score",coffee:"CoffeeScript",HTML_Ruby:"HTML (Ruby)",HTML_Elixir:"HTML (Elixir)",FTL:"FreeMarker",PHP_Laravel_blade:"PHP (Blade Template)",Perl6:"Perl 6",AutoHotKey:"AutoHotkey / AutoIt"},a={};for(var f in o){var l=o[f],c=(u[f]||f).replace(/_/g," "),h=f.toLowerCase(),p=new s(h,c,l[0]);a[h]=p,r.push(p)}n.exports={getModeForPath:i,modes:r,modesByName:a}});                (function() {
-                    ace.require(["ace/ext/modelist"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-rtl.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/rtl",["require","exports","module","ace/editor","ace/config"],function(e,t,n){"use strict";function s(e,t){var n=t.getSelection().lead;t.session.$bidiHandler.isRtlLine(n.row)&&n.column===0&&(t.session.$bidiHandler.isMoveLeftOperation&&n.row>0?t.getSelection().moveCursorTo(n.row-1,t.session.getLine(n.row-1).length):t.getSelection().isEmpty()?n.column+=1:n.setPosition(n.row,n.column+1))}function o(e){e.editor.session.$bidiHandler.isMoveLeftOperation=/gotoleft|selectleft|backspace|removewordleft/.test(e.command.name)}function u(e,t){var n=t.session;n.$bidiHandler.currentRow=null;if(n.$bidiHandler.isRtlLine(e.start.row)&&e.action==="insert"&&e.lines.length>1)for(var r=e.start.row;r<e.end.row;r++)n.getLine(r+1).charAt(0)!==n.$bidiHandler.RLE&&(n.doc.$lines[r+1]=n.$bidiHandler.RLE+n.getLine(r+1))}function a(e,t){var n=t.session,r=n.$bidiHandler,i=t.$textLayer.$lines.cells,s=t.layerConfig.width-t.layerConfig.padding+"px";i.forEach(function(e){var t=e.element.style;r&&r.isRtlLine(e.row)?(t.direction="rtl",t.textAlign="right",t.width=s):(t.direction="",t.textAlign="",t.width="")})}function f(e){function n(e){var t=e.element.style;t.direction=t.textAlign=t.width=""}var t=e.$textLayer.$lines;t.cells.forEach(n),t.cellCache.forEach(n)}var r=[{name:"leftToRight",bindKey:{win:"Ctrl-Alt-Shift-L",mac:"Command-Alt-Shift-L"},exec:function(e){e.session.$bidiHandler.setRtlDirection(e,!1)},readOnly:!0},{name:"rightToLeft",bindKey:{win:"Ctrl-Alt-Shift-R",mac:"Command-Alt-Shift-R"},exec:function(e){e.session.$bidiHandler.setRtlDirection(e,!0)},readOnly:!0}],i=e("../editor").Editor;e("../config").defineOptions(i.prototype,"editor",{rtlText:{set:function(e){e?(this.on("change",u),this.on("changeSelection",s),this.renderer.on("afterRender",a),this.commands.on("exec",o),this.commands.addCommands(r)):(this.off("change",u),this.off("changeSelection",s),this.renderer.off("afterRender",a),this.commands.off("exec",o),this.commands.removeCommands(r),f(this.renderer)),this.renderer.updateFull()}},rtl:{set:function(e){this.session.$bidiHandler.$isRtl=e,e?(this.setOption("rtlText",!1),this.renderer.on("afterRender",a),this.session.$bidiHandler.seenBidi=!0):(this.renderer.off("afterRender",a),f(this.renderer)),this.renderer.updateFull()}}})});                (function() {
-                    ace.require(["ace/ext/rtl"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-simple_tokenizer.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/simple_tokenizer",["require","exports","module","ace/tokenizer","ace/layer/text_util"],function(e,t,n){"use strict";function o(e,t){var n=new s(e,new r(t.getRules())),o=[];for(var u=0;u<n.getLength();u++){var a=n.getTokens(u);o.push(a.map(function(e){return{className:i(e.type)?undefined:"ace_"+e.type.replace(/\./g," ace_"),value:e.value}}))}return o}var r=e("../tokenizer").Tokenizer,i=e("../layer/text_util").isTextToken,s=function(){function e(e,t){this._lines=e.split(/\r\n|\r|\n/),this._states=[],this._tokenizer=t}return e.prototype.getTokens=function(e){var t=this._lines[e],n=this._states[e-1],r=this._tokenizer.getLineTokens(t,n);return this._states[e]=r.state,r.tokens},e.prototype.getLength=function(){return this._lines.length},e}();n.exports={tokenize:o}});                (function() {
-                    ace.require(["ace/ext/simple_tokenizer"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-spellcheck.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/spellcheck",["require","exports","module","ace/lib/event","ace/editor","ace/config"],function(e,t,n){"use strict";var r=e("../lib/event");t.contextMenuHandler=function(e){var t=e.target,n=t.textInput.getElement();if(!t.selection.isEmpty())return;var i=t.getCursorPosition(),s=t.session.getWordRange(i.row,i.column),o=t.session.getTextRange(s);t.session.tokenRe.lastIndex=0;if(!t.session.tokenRe.test(o))return;var u="\x01\x01",a=o+" "+u;n.value=a,n.setSelectionRange(o.length,o.length+1),n.setSelectionRange(0,0),n.setSelectionRange(0,o.length);var f=!1;r.addListener(n,"keydown",function l(){r.removeListener(n,"keydown",l),f=!0}),t.textInput.setInputHandler(function(e){if(e==a)return"";if(e.lastIndexOf(a,0)===0)return e.slice(a.length);if(e.substr(n.selectionEnd)==a)return e.slice(0,-a.length);if(e.slice(-2)==u){var r=e.slice(0,-2);if(r.slice(-1)==" ")return f?r.substring(0,n.selectionEnd):(r=r.slice(0,-1),t.session.replace(s,r),"")}return e})};var i=e("../editor").Editor;e("../config").defineOptions(i.prototype,"editor",{spellcheck:{set:function(e){var n=this.textInput.getElement();n.spellcheck=!!e,e?this.on("nativecontextmenu",t.contextMenuHandler):this.removeListener("nativecontextmenu",t.contextMenuHandler)},value:!0}})});                (function() {
-                    ace.require(["ace/ext/spellcheck"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-split.js

@@ -1,8 +0,0 @@
-ace.define("ace/split",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/editor","ace/virtual_renderer","ace/edit_session"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./lib/lang"),s=e("./lib/event_emitter").EventEmitter,o=e("./editor").Editor,u=e("./virtual_renderer").VirtualRenderer,a=e("./edit_session").EditSession,f;f=function(e,t,n){this.BELOW=1,this.BESIDE=0,this.$container=e,this.$theme=t,this.$splits=0,this.$editorCSS="",this.$editors=[],this.$orientation=this.BESIDE,this.setSplits(n||1),this.$cEditor=this.$editors[0],this.on("focus",function(e){this.$cEditor=e}.bind(this))},function(){r.implement(this,s),this.$createEditor=function(){var e=document.createElement("div");e.className=this.$editorCSS,e.style.cssText="position: absolute; top:0px; bottom:0px",this.$container.appendChild(e);var t=new o(new u(e,this.$theme));return t.on("focus",function(){this._emit("focus",t)}.bind(this)),this.$editors.push(t),t.setFontSize(this.$fontSize),t},this.setSplits=function(e){var t;if(e<1)throw"The number of splits have to be > 0!";if(e==this.$splits)return;if(e>this.$splits){while(this.$splits<this.$editors.length&&this.$splits<e)t=this.$editors[this.$splits],this.$container.appendChild(t.container),t.setFontSize(this.$fontSize),this.$splits++;while(this.$splits<e)this.$createEditor(),this.$splits++}else while(this.$splits>e)t=this.$editors[this.$splits-1],this.$container.removeChild(t.container),this.$splits--;this.resize()},this.getSplits=function(){return this.$splits},this.getEditor=function(e){return this.$editors[e]},this.getCurrentEditor=function(){return this.$cEditor},this.focus=function(){this.$cEditor.focus()},this.blur=function(){this.$cEditor.blur()},this.setTheme=function(e){this.$editors.forEach(function(t){t.setTheme(e)})},this.setKeyboardHandler=function(e){this.$editors.forEach(function(t){t.setKeyboardHandler(e)})},this.forEach=function(e,t){this.$editors.forEach(e,t)},this.$fontSize="",this.setFontSize=function(e){this.$fontSize=e,this.forEach(function(t){t.setFontSize(e)})},this.$cloneSession=function(e){var t=new a(e.getDocument(),e.getMode()),n=e.getUndoManager();return t.setUndoManager(n),t.setTabSize(e.getTabSize()),t.setUseSoftTabs(e.getUseSoftTabs()),t.setOverwrite(e.getOverwrite()),t.setBreakpoints(e.getBreakpoints()),t.setUseWrapMode(e.getUseWrapMode()),t.setUseWorker(e.getUseWorker()),t.setWrapLimitRange(e.$wrapLimitRange.min,e.$wrapLimitRange.max),t.$foldData=e.$cloneFoldData(),t},this.setSession=function(e,t){var n;t==null?n=this.$cEditor:n=this.$editors[t];var r=this.$editors.some(function(t){return t.session===e});return r&&(e=this.$cloneSession(e)),n.setSession(e),e},this.getOrientation=function(){return this.$orientation},this.setOrientation=function(e){if(this.$orientation==e)return;this.$orientation=e,this.resize()},this.resize=function(){var e=this.$container.clientWidth,t=this.$container.clientHeight,n;if(this.$orientation==this.BESIDE){var r=e/this.$splits;for(var i=0;i<this.$splits;i++)n=this.$editors[i],n.container.style.width=r+"px",n.container.style.top="0px",n.container.style.left=i*r+"px",n.container.style.height=t+"px",n.resize()}else{var s=t/this.$splits;for(var i=0;i<this.$splits;i++)n=this.$editors[i],n.container.style.width=e+"px",n.container.style.top=i*s+"px",n.container.style.left="0px",n.container.style.height=s+"px",n.resize()}}}.call(f.prototype),t.Split=f}),ace.define("ace/ext/split",["require","exports","module","ace/split"],function(e,t,n){"use strict";n.exports=e("../split")});                (function() {
-                    ace.require(["ace/ext/split"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-static_highlight.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/static-css",["require","exports","module"],function(e,t,n){n.exports=".ace_static_highlight {\n    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'Source Code Pro', 'source-code-pro', 'Droid Sans Mono', monospace;\n    font-size: 12px;\n    white-space: pre-wrap\n}\n\n.ace_static_highlight .ace_gutter {\n    width: 2em;\n    text-align: right;\n    padding: 0 3px 0 0;\n    margin-right: 3px;\n    contain: none;\n}\n\n.ace_static_highlight.ace_show_gutter .ace_line {\n    padding-left: 2.6em;\n}\n\n.ace_static_highlight .ace_line { position: relative; }\n\n.ace_static_highlight .ace_gutter-cell {\n    -moz-user-select: -moz-none;\n    -khtml-user-select: none;\n    -webkit-user-select: none;\n    user-select: none;\n    top: 0;\n    bottom: 0;\n    left: 0;\n    position: absolute;\n}\n\n\n.ace_static_highlight .ace_gutter-cell:before {\n    content: counter(ace_line, decimal);\n    counter-increment: ace_line;\n}\n.ace_static_highlight {\n    counter-reset: ace_line;\n}\n"}),ace.define("ace/ext/static_highlight",["require","exports","module","ace/edit_session","ace/layer/text","ace/ext/static-css","ace/config","ace/lib/dom","ace/lib/lang"],function(e,t,n){"use strict";var r=e("../edit_session").EditSession,i=e("../layer/text").Text,s=e("./static-css"),o=e("../config"),u=e("../lib/dom"),a=e("../lib/lang").escapeHTML,f=function(){function e(e){this.className,this.type=e,this.style={},this.textContent=""}return e.prototype.cloneNode=function(){return this},e.prototype.appendChild=function(e){this.textContent+=e.toString()},e.prototype.toString=function(){var e=[];if(this.type!="fragment"){e.push("<",this.type),this.className&&e.push(" class='",this.className,"'");var t=[];for(var n in this.style)t.push(n,":",this.style[n]);t.length&&e.push(" style='",t.join(""),"'"),e.push(">")}return this.textContent&&e.push(this.textContent),this.type!="fragment"&&e.push("</",this.type,">"),e.join("")},e}(),l={createTextNode:function(e,t){return a(e)},createElement:function(e){return new f(e)},createFragment:function(){return new f("fragment")}},c=function(){this.config={},this.dom=l};c.prototype=i.prototype;var h=function(e,t,n){var r=e.className.match(/lang-(\w+)/),i=t.mode||r&&"ace/mode/"+r[1];if(!i)return!1;var s=t.theme||"ace/theme/textmate",o="",a=[];if(e.firstElementChild){var f=0;for(var l=0;l<e.childNodes.length;l++){var c=e.childNodes[l];c.nodeType==3?(f+=c.data.length,o+=c.data):a.push(f,c)}}else o=e.textContent,t.trim&&(o=o.trim());h.render(o,i,s,t.firstLineNumber,!t.showGutter,function(t){u.importCssString(t.css,"ace_highlight",!0),e.innerHTML=t.html;var r=e.firstChild.firstChild;for(var i=0;i<a.length;i+=2){var s=t.session.doc.indexToPosition(a[i]),o=a[i+1],f=r.children[s.row];f&&f.appendChild(o)}n&&n()})};h.render=function(e,t,n,i,s,u){function c(){var r=h.renderSync(e,t,n,i,s);return u?u(r):r}var a=1,f=r.prototype.$modes;typeof n=="string"&&(a++,o.loadModule(["theme",n],function(e){n=e,--a||c()}));var l;return t&&typeof t=="object"&&!t.getTokenizer&&(l=t,t=l.path),typeof t=="string"&&(a++,o.loadModule(["mode",t],function(e){if(!f[t]||l)f[t]=new e.Mode(l);t=f[t],--a||c()})),--a||c()},h.renderSync=function(e,t,n,i,o){i=parseInt(i||1,10);var u=new r("");u.setUseWorker(!1),u.setMode(t);var a=new c;a.setSession(u),Object.keys(a.$tabStrings).forEach(function(e){if(typeof a.$tabStrings[e]=="string"){var t=l.createFragment();t.textContent=a.$tabStrings[e],a.$tabStrings[e]=t}}),u.setValue(e);var f=u.getLength(),h=l.createElement("div");h.className=n.cssClass;var p=l.createElement("div");p.className="ace_static_highlight"+(o?"":" ace_show_gutter"),p.style["counter-reset"]="ace_line "+(i-1);for(var d=0;d<f;d++){var v=l.createElement("div");v.className="ace_line";if(!o){var m=l.createElement("span");m.className="ace_gutter ace_gutter-cell",m.textContent="",v.appendChild(m)}a.$renderLine(v,d,!1),v.textContent+="\n",p.appendChild(v)}return h.appendChild(p),{css:s+n.cssText,html:h.toString(),session:u}},n.exports=h,n.exports.highlight=h});                (function() {
-                    ace.require(["ace/ext/static_highlight"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-statusbar.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/statusbar",["require","exports","module","ace/lib/dom","ace/lib/lang"],function(e,t,n){"use strict";var r=e("../lib/dom"),i=e("../lib/lang"),s=function(){function e(e,t){this.element=r.createElement("div"),this.element.className="ace_status-indicator",this.element.style.cssText="display: inline-block;",t.appendChild(this.element);var n=i.delayedCall(function(){this.updateStatus(e)}.bind(this)).schedule.bind(null,100);e.on("changeStatus",n),e.on("changeSelection",n),e.on("keyboardActivity",n)}return e.prototype.updateStatus=function(e){function n(e,n){e&&t.push(e,n||"|")}var t=[];n(e.keyBinding.getStatusText(e)),e.commands.recording&&n("REC");var r=e.selection,i=r.lead;if(!r.isEmpty()){var s=e.getSelectionRange();n("("+(s.end.row-s.start.row)+":"+(s.end.column-s.start.column)+")"," ")}n(i.row+":"+i.column," "),r.rangeCount&&n("["+r.rangeCount+"]"," "),t.pop(),this.element.textContent=t.join("")},e}();t.StatusBar=s});                (function() {
-                    ace.require(["ace/ext/statusbar"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-            

web_async/ace/ext-themelist.js

@@ -1,8 +0,0 @@
-ace.define("ace/ext/themelist",["require","exports","module"],function(e,t,n){"use strict";var r=[["Chrome"],["Clouds"],["Crimson Editor"],["Dawn"],["Dreamweaver"],["Eclipse"],["GitHub"],["IPlastic"],["Solarized Light"],["TextMate"],["Tomorrow"],["XCode"],["Kuroir"],["KatzenMilch"],["SQL Server","sqlserver","light"],["CloudEditor","cloud_editor","light"],["Ambiance","ambiance","dark"],["Chaos","chaos","dark"],["Clouds Midnight","clouds_midnight","dark"],["Dracula","","dark"],["Cobalt","cobalt","dark"],["Gruvbox","gruvbox","dark"],["Green on Black","gob","dark"],["idle Fingers","idle_fingers","dark"],["krTheme","kr_theme","dark"],["Merbivore","merbivore","dark"],["Merbivore Soft","merbivore_soft","dark"],["Mono Industrial","mono_industrial","dark"],["Monokai","monokai","dark"],["Nord Dark","nord_dark","dark"],["One Dark","one_dark","dark"],["Pastel on dark","pastel_on_dark","dark"],["Solarized Dark","solarized_dark","dark"],["Terminal","terminal","dark"],["Tomorrow Night","tomorrow_night","dark"],["Tomorrow Night Blue","tomorrow_night_blue","dark"],["Tomorrow Night Bright","tomorrow_night_bright","dark"],["Tomorrow Night 80s","tomorrow_night_eighties","dark"],["Twilight","twilight","dark"],["Vibrant Ink","vibrant_ink","dark"],["GitHub Dark","github_dark","dark"],["CloudEditor Dark","cloud_editor_dark","dark"]];t.themesByName={},t.themes=r.map(function(e){var n=e[1]||e[0].replace(/ /g,"_").toLowerCase(),r={caption:e[0],theme:"ace/theme/"+n,isDark:e[2]=="dark",name:n};return t.themesByName[n]=r,r})});                (function() {
-                    ace.require(["ace/ext/themelist"], function(m) {
-                        if (typeof module == "object" && typeof exports == "object" && module) {
-                            module.exports = m;
-                        }
-                    });
-                })();
-