fix: 🐛 fix from merge

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

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -2,9 +2,7 @@ name: 🐞 Bug Report
 title: "[bug] "
 description: Report a bug
 labels: ["type: 🐛 bug", "status: 🧹 needs triage"]
-assignees:
-  - melMass
-  
+
 body:
   - type: markdown
     attributes:
@@ -42,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
-      
-  - 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
+      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]
+
     validations:
       required: true
 

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 -->
 
@@ -19,50 +18,20 @@ Welcome to the MTB Nodes project! This codebase is open for you to explore and u
 
 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" />
-
 
 # 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
@@ -74,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.
@@ -91,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
@@ -111,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

@@ -13,37 +13,26 @@ import os
 os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"
 os.environ["TF_GPU_ALLOCATOR"] = "cuda_malloc_async"
 
-import ast
-import contextlib
-import importlib
-import json
-import logging
-import os
-import shutil
 import traceback
-from importlib import reload
-
-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.2.0"
+__version__ = "0.1.4"
 
 
 def extract_nodes_from_source(filename):
     source_code = ""
 
-    with open(filename, "r", encoding="utf8") as file:
+    with open(filename, "r") as file:
         source_code = file.read()
 
     nodes = []
@@ -96,7 +85,7 @@ def load_nodes():
                 nodes_failed.extend(extract_nodes_from_source(filename))
 
     if errors:
-        log.debug(
+        log.info(
             f"Some nodes failed to load:\n\t"
             + "\n\t".join(errors)
             + "\n\n"
@@ -111,18 +100,49 @@ def load_nodes():
 web_extensions_root = comfy_dir / "web" / "extensions"
 web_mtb = web_extensions_root / "mtb"
 
-if web_mtb.exists() and hasattr(nodes, "EXTENSION_WEB_DIRS"):
-    try:
-        if web_mtb.is_symlink():
-            web_mtb.unlink()
-        else:
-            shutil.rmtree(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."
+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:
+            import shutil
+
+            shutil.copytree(web_tgt, web_mtb)
+            log.info(f"Successfully copied {web_tgt} to {web_mtb}")
+        except Exception as e:
+            log.warn(
+                f"Failed to symlink and copy {web_tgt} to {web_mtb}. Please copy the folder manually."
+            )
+            log.warn(e)
+
+    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"
+    )
+
 # - REGISTER NODES
 nodes, failed = load_nodes()
 for node_class in nodes:
@@ -146,7 +166,7 @@ for node_class in nodes:
                 )
             )
 
-log.debug(
+log.info(
     f"Loaded the following nodes:\n\t"
     + "\n\t".join(
         f"{cyan_text(k)}: {blue_text(get_summary(doc)) if doc else '-'}"
@@ -154,56 +174,24 @@ log.debug(
     )
 )
 
-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()
-    )
-
-    @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
@@ -267,7 +255,6 @@ 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>            

endpoint.py

@@ -1,46 +1,34 @@
-import csv
-
+from .utils import here, run_command, comfy_mode
 from aiohttp import web
-
 from .log import mklog
-from .utils import backup_file, here, import_install, reqs_map, run_command, styles_dir
+import sys
 
 endlog = mklog("mtb endpoint")
 
 # - ACTIONS
-import platform
-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):
@@ -60,32 +48,6 @@ def ACTIONS_getStyles(style_name=None):
     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()
@@ -121,129 +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, "r", 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]
@@ -283,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'

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
-}

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
 
@@ -75,7 +75,5 @@ def cyan_text(text):
 
 
 def get_label(label):
-    if label.startswith("MTB_"):
-        label = label[4:]
     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/batch.py

@@ -1,625 +0,0 @@
-import math
-import os
-from pathlib import Path
-from typing import List
-
-import cv2
-import folder_paths
-import numpy as np
-import torch
-
-from ..log import log
-from ..utils import apply_easing, pil2tensor
-from .transform import TransformImage
-
-
-def hex_to_rgb(hex_color, bgr=False):
-    hex_color = hex_color.lstrip("#")
-    if bgr:
-        return tuple(int(hex_color[i : i + 2], 16) for i in (4, 2, 0))
-
-    return tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
-
-
-class BatchMake:
-    """Simply duplicates the input frame as a batch"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "count": ("INT", {"default": 1}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "generate_batch"
-    CATEGORY = "mtb/batch"
-
-    def generate_batch(self, image: torch.Tensor, count):
-        if len(image.shape) == 3:
-            image = image.unsqueeze(0)
-
-        return (image.repeat(count, 1, 1, 1),)
-
-
-class BatchShape:
-    """Generates a batch of 2D shapes with optional shading (experimental)"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "count": ("INT", {"default": 1}),
-                "shape": (
-                    ["Box", "Circle", "Diamond"],
-                    {"default": "Box"},
-                ),
-                "image_width": ("INT", {"default": 512}),
-                "image_height": ("INT", {"default": 512}),
-                "shape_size": ("INT", {"default": 100}),
-                "color": ("COLOR", {"default": "#ffffff"}),
-                "bg_color": ("COLOR", {"default": "#000000"}),
-                "shade_color": ("COLOR", {"default": "#000000"}),
-                "shadex": ("FLOAT", {"default": 0.0}),
-                "shadey": ("FLOAT", {"default": 0.0}),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "generate_shapes"
-    CATEGORY = "mtb/batch"
-
-    def generate_shapes(
-        self,
-        count,
-        shape,
-        image_width,
-        image_height,
-        shape_size,
-        color,
-        bg_color,
-        shade_color,
-        shadex,
-        shadey,
-    ):
-        print(f"COLOR: {color}")
-        print(f"BG_COLOR: {bg_color}")
-        print(f"SHADE_COLOR: {shade_color}")
-
-        # Parse color input to BGR tuple for OpenCV
-        color = hex_to_rgb(color)
-        bg_color = hex_to_rgb(bg_color)
-        shade_color = hex_to_rgb(shade_color)
-        res = []
-        for x in range(count):
-            # Initialize an image canvas
-            canvas = np.full((image_height, image_width, 3), bg_color, dtype=np.uint8)
-            mask = np.zeros((image_height, image_width), dtype=np.uint8)
-
-            # Compute the center point of the shape
-            center = (image_width // 2, image_height // 2)
-
-            if shape == "Box":
-                half_size = shape_size // 2
-                top_left = (center[0] - half_size, center[1] - half_size)
-                bottom_right = (center[0] + half_size, center[1] + half_size)
-                cv2.rectangle(mask, top_left, bottom_right, 255, -1)
-            elif shape == "Circle":
-                cv2.circle(mask, center, shape_size // 2, 255, -1)
-            elif shape == "Diamond":
-                pts = np.array(
-                    [
-                        [center[0], center[1] - shape_size // 2],
-                        [center[0] + shape_size // 2, center[1]],
-                        [center[0], center[1] + shape_size // 2],
-                        [center[0] - shape_size // 2, center[1]],
-                    ]
-                )
-                cv2.fillPoly(mask, [pts], 255)
-
-            # Color the shape
-            canvas[mask == 255] = color
-
-            # Apply shading effects to a separate shading canvas
-            shading = np.zeros_like(canvas, dtype=np.float32)
-            shading[:, :, 0] = shadex * np.linspace(0, 1, image_width)
-            shading[:, :, 1] = shadey * np.linspace(0, 1, image_height).reshape(-1, 1)
-            shading_canvas = cv2.addWeighted(
-                canvas.astype(np.float32), 1, shading, 1, 0
-            ).astype(np.uint8)
-
-            # Apply shading only to the shape area using the mask
-            canvas[mask == 255] = shading_canvas[mask == 255]
-            res.append(canvas)
-
-        return (pil2tensor(res),)
-
-
-class BatchFloatFill:
-    """Fills a batch float with a single value until it reaches the target length"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "floats": ("FLOATS",),
-                "direction": (["head", "tail"], {"default": "tail"}),
-                "value": ("FLOAT", {"default": 0.0}),
-                "count": ("INT", {"default": 1}),
-            }
-        }
-
-    FUNCTION = "fill_floats"
-    RETURN_TYPES = ("FLOATS",)
-    CATEGORY = "mtb/batch"
-
-    def fill_floats(self, floats, direction, value, count):
-        size = len(floats)
-        if size > count:
-            raise ValueError(f"Size ({size}) is less then target count ({count})")
-
-        rem = count - size
-        if direction == "tail":
-            floats = floats + [value] * rem
-        else:
-            floats = [value] * rem + floats
-        return (floats,)
-
-
-class BatchFloatAssemble:
-    """Assembles mutiple batches of floats into a single stream (batch)"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {"required": {"reverse": ("BOOLEAN", {"default": False})}}
-
-    FUNCTION = "assemble_floats"
-    RETURN_TYPES = ("FLOATS",)
-    CATEGORY = "mtb/batch"
-
-    def assemble_floats(self, reverse, **kwargs):
-        res = []
-        if reverse:
-            for x in reversed(kwargs.values()):
-                res += x
-        else:
-            for x in kwargs.values():
-                res += x
-
-        return (res,)
-
-
-class BatchFloat:
-    """Generates a batch of float values with interpolation"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "mode": (
-                    ["Single", "Steps"],
-                    {"default": "Steps"},
-                ),
-                "count": ("INT", {"default": 1}),
-                "min": ("FLOAT", {"default": 0.0}),
-                "max": ("FLOAT", {"default": 1.0}),
-                "easing": (
-                    [
-                        "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"},
-                ),
-            }
-        }
-
-    FUNCTION = "set_floats"
-    RETURN_TYPES = ("FLOATS",)
-    CATEGORY = "mtb/batch"
-
-    def set_floats(self, mode, count, min, max, easing):
-        keyframes = []
-        if mode == "Single":
-            keyframes = [min] * count
-            return (keyframes,)
-
-        for i in range(count):
-            normalized_step = i / (count - 1)
-            eased_step = apply_easing(normalized_step, easing)
-            eased_value = min + (max - min) * eased_step
-            keyframes.append(eased_value)
-
-        return (keyframes,)
-
-
-class BatchMerge:
-    """Merges multiple image batches with different frame counts"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "fusion_mode": (["add", "multiply", "average"], {"default": "average"}),
-                "fill": (["head", "tail"], {"default": "tail"}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "merge_batches"
-    CATEGORY = "mtb/batch"
-
-    def merge_batches(self, fusion_mode, fill, **kwargs):
-        images = kwargs.values()
-        max_frames = max(img.shape[0] for img in images)
-
-        adjusted_images = []
-        for img in images:
-            frame_count = img.shape[0]
-            if frame_count < max_frames:
-                fill_frame = img[0] if fill == "head" else img[-1]
-                fill_frames = fill_frame.repeat(max_frames - frame_count, 1, 1, 1)
-                adjusted_batch = (
-                    torch.cat((fill_frames, img), dim=0)
-                    if fill == "head"
-                    else torch.cat((img, fill_frames), dim=0)
-                )
-            else:
-                adjusted_batch = img
-            adjusted_images.append(adjusted_batch)
-
-        # Merge the adjusted batches
-        merged_image = None
-        for img in adjusted_images:
-            if merged_image is None:
-                merged_image = img
-            else:
-                if fusion_mode == "add":
-                    merged_image += img
-                elif fusion_mode == "multiply":
-                    merged_image *= img
-                elif fusion_mode == "average":
-                    merged_image = (merged_image + img) / 2
-
-        return (merged_image,)
-
-
-class Batch2dTransform:
-    """Transform a batch of images using a batch of keyframes"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "border_handling": (
-                    ["edge", "constant", "reflect", "symmetric"],
-                    {"default": "edge"},
-                ),
-                "constant_color": ("COLOR", {"default": "#000000"}),
-            },
-            "optional": {
-                "x": ("FLOATS",),
-                "y": ("FLOATS",),
-                "zoom": ("FLOATS",),
-                "angle": ("FLOATS",),
-                "shear": ("FLOATS",),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "transform_batch"
-    CATEGORY = "mtb/batch"
-
-    def get_num_elements(self, param) -> int:
-        if isinstance(param, torch.Tensor):
-            return torch.numel(param)
-        elif isinstance(param, list):
-            return len(param)
-
-        return 0
-
-    def transform_batch(
-        self,
-        image: torch.Tensor,
-        border_handling,
-        constant_color,
-        x=None,
-        y=None,
-        zoom=None,
-        angle=None,
-        shear=None,
-    ):
-        if all(
-            self.get_num_elements(param) <= 0 for param in [x, y, zoom, angle, shear]
-        ):
-            raise ValueError("At least one transform parameter must be provided")
-
-        keyframes = {"x": [], "y": [], "zoom": [], "angle": [], "shear": []}
-
-        default_vals = {"x": 0, "y": 0, "zoom": 1.0, "angle": 0, "shear": 0}
-
-        if self.get_num_elements(x) > 0:
-            keyframes["x"] = x
-        if self.get_num_elements(y) > 0:
-            keyframes["y"] = y
-        if self.get_num_elements(zoom) > 0:
-            keyframes["zoom"] = zoom
-        if self.get_num_elements(angle) > 0:
-            keyframes["angle"] = angle
-        if self.get_num_elements(shear) > 0:
-            keyframes["shear"] = shear
-
-        for name, values in keyframes.items():
-            count = len(values)
-            if count > 0 and count != image.shape[0]:
-                raise ValueError(
-                    f"Length of {name} values ({count}) must match number of images ({image.shape[0]})"
-                )
-            if count == 0:
-                keyframes[name] = [default_vals[name]] * image.shape[0]
-
-        transformer = TransformImage()
-        res = [
-            transformer.transform(
-                image[i].unsqueeze(0),
-                keyframes["x"][i],
-                keyframes["y"][i],
-                keyframes["zoom"][i],
-                keyframes["angle"][i],
-                keyframes["shear"][i],
-                border_handling,
-                constant_color,
-            )[0]
-            for i in range(image.shape[0])
-        ]
-        return (torch.cat(res, dim=0),)
-
-
-DEFAULT_INTERPOLANT = lambda t: t * t * t * (t * (t * 6 - 15) + 10)
-
-
-class BatchShake:
-    """Applies a shaking effect to batches of images."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "images": ("IMAGE",),
-                "position_amount_x": ("FLOAT", {"default": 1.0}),
-                "position_amount_y": ("FLOAT", {"default": 1.0}),
-                "rotation_amount": ("FLOAT", {"default": 10.0}),
-                "frequency": ("FLOAT", {"default": 1.0, "min": 0.005}),
-                "frequency_divider": ("FLOAT", {"default": 1.0, "min": 0.005}),
-                "octaves": ("INT", {"default": 1, "min": 1}),
-                "seed": ("INT", {"default": 0}),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE", "FLOATS", "FLOATS", "FLOATS")
-    RETURN_NAMES = ("image", "pos_x", "pos_y", "rot")
-    FUNCTION = "apply_shake"
-    CATEGORY = "mtb/batch"
-
-    # def interpolant(self, t):
-    # return t * t * t * (t * (t * 6 - 15) + 10)
-
-    def generate_perlin_noise_2d(
-        self, shape, res, tileable=(False, False), interpolant=None
-    ):
-        """Generate a 2D numpy array of perlin noise.
-
-        Args:
-            shape: The shape of the generated array (tuple of two ints).
-                This must be a multple of res.
-            res: The number of periods of noise to generate along each
-                axis (tuple of two ints). Note shape must be a multiple of
-                res.
-            tileable: If the noise should be tileable along each axis
-                (tuple of two bools). Defaults to (False, False).
-            interpolant: The interpolation function, defaults to
-                t*t*t*(t*(t*6 - 15) + 10).
-
-        Returns:
-            A numpy array of shape shape with the generated noise.
-
-        Raises:
-            ValueError: If shape is not a multiple of res.
-        """
-        interpolant = interpolant or DEFAULT_INTERPOLANT
-        delta = (res[0] / shape[0], res[1] / shape[1])
-        d = (shape[0] // res[0], shape[1] // res[1])
-        grid = (
-            np.mgrid[0 : res[0] : delta[0], 0 : res[1] : delta[1]].transpose(1, 2, 0)
-            % 1
-        )
-        # Gradients
-        angles = 2 * np.pi * np.random.rand(res[0] + 1, res[1] + 1)
-        gradients = np.dstack((np.cos(angles), np.sin(angles)))
-        if tileable[0]:
-            gradients[-1, :] = gradients[0, :]
-        if tileable[1]:
-            gradients[:, -1] = gradients[:, 0]
-        gradients = gradients.repeat(d[0], 0).repeat(d[1], 1)
-        g00 = gradients[: -d[0], : -d[1]]
-        g10 = gradients[d[0] :, : -d[1]]
-        g01 = gradients[: -d[0], d[1] :]
-        g11 = gradients[d[0] :, d[1] :]
-        # Ramps
-        n00 = np.sum(np.dstack((grid[:, :, 0], grid[:, :, 1])) * g00, 2)
-        n10 = np.sum(np.dstack((grid[:, :, 0] - 1, grid[:, :, 1])) * g10, 2)
-        n01 = np.sum(np.dstack((grid[:, :, 0], grid[:, :, 1] - 1)) * g01, 2)
-        n11 = np.sum(np.dstack((grid[:, :, 0] - 1, grid[:, :, 1] - 1)) * g11, 2)
-        # Interpolation
-        t = interpolant(grid)
-        n0 = n00 * (1 - t[:, :, 0]) + t[:, :, 0] * n10
-        n1 = n01 * (1 - t[:, :, 0]) + t[:, :, 0] * n11
-        return np.sqrt(2) * ((1 - t[:, :, 1]) * n0 + t[:, :, 1] * n1)
-
-    def generate_fractal_noise_2d(
-        self,
-        shape,
-        res,
-        octaves=1,
-        persistence=0.5,
-        lacunarity=2,
-        tileable=(True, True),
-        interpolant=None,
-    ):
-        """Generate a 2D numpy array of fractal noise.
-
-        Args:
-            shape: The shape of the generated array (tuple of two ints).
-                This must be a multiple of lacunarity**(octaves-1)*res.
-            res: The number of periods of noise to generate along each
-                axis (tuple of two ints). Note shape must be a multiple of
-                (lacunarity**(octaves-1)*res).
-            octaves: The number of octaves in the noise. Defaults to 1.
-            persistence: The scaling factor between two octaves.
-            lacunarity: The frequency factor between two octaves.
-            tileable: If the noise should be tileable along each axis
-                (tuple of two bools). Defaults to (True,True).
-            interpolant: The, interpolation function, defaults to
-                t*t*t*(t*(t*6 - 15) + 10).
-
-        Returns:
-            A numpy array of fractal noise and of shape shape generated by
-            combining several octaves of perlin noise.
-
-        Raises:
-            ValueError: If shape is not a multiple of
-                (lacunarity**(octaves-1)*res).
-        """
-        interpolant = interpolant or DEFAULT_INTERPOLANT
-
-        noise = np.zeros(shape)
-        frequency = 1
-        amplitude = 1
-        for _ in range(octaves):
-            noise += amplitude * self.generate_perlin_noise_2d(
-                shape, (frequency * res[0], frequency * res[1]), tileable, interpolant
-            )
-            frequency *= lacunarity
-            amplitude *= persistence
-        return noise
-
-    def fbm(self, x, y, octaves):
-        # noise_2d = self.generate_fractal_noise_2d((256, 256), (8, 8), octaves)
-        # Now, extract a single noise value based on x and y, wrapping indices if necessary
-        x_idx = int(x) % 256
-        y_idx = int(y) % 256
-        return self.noise_pattern[x_idx, y_idx]
-
-    def apply_shake(
-        self,
-        images,
-        position_amount_x,
-        position_amount_y,
-        rotation_amount,
-        frequency,
-        frequency_divider,
-        octaves,
-        seed,
-    ):
-        # Rehash
-        np.random.seed(seed)
-        self.position_offset = np.random.uniform(-1e3, 1e3, 3)
-        self.rotation_offset = np.random.uniform(-1e3, 1e3, 3)
-        self.noise_pattern = self.generate_perlin_noise_2d(
-            (512, 512), (32, 32), (True, True)
-        )
-
-        # Assuming frame count is derived from the first dimension of images tensor
-        frame_count = images.shape[0]
-
-        frequency = frequency / frequency_divider
-
-        # Generate shaking parameters for each frame
-        x_translations = []
-        y_translations = []
-        rotations = []
-
-        for frame_num in range(frame_count):
-            time = frame_num * frequency
-            x_idx = (self.position_offset[0] + frame_num) % 256
-            y_idx = (self.position_offset[1] + frame_num) % 256
-
-            np_position = np.array(
-                [
-                    self.fbm(x_idx, time, octaves),
-                    self.fbm(y_idx, time, octaves),
-                ]
-            )
-
-            # np_position = np.array(
-            #     [
-            #         self.fbm(self.position_offset[0] + frame_num, time, octaves),
-            #         self.fbm(self.position_offset[1] + frame_num, time, octaves),
-            #     ]
-            # )
-            # np_rotation = self.fbm(self.rotation_offset[2] + frame_num, time, octaves)
-
-            rot_idx = (self.rotation_offset[2] + frame_num) % 256
-            np_rotation = self.fbm(rot_idx, time, octaves)
-
-            x_translations.append(np_position[0] * position_amount_x)
-            y_translations.append(np_position[1] * position_amount_y)
-            rotations.append(np_rotation * rotation_amount)
-
-        # Convert lists to tensors
-        # x_translations = torch.tensor(x_translations, dtype=torch.float32)
-        # y_translations = torch.tensor(y_translations, dtype=torch.float32)
-        # rotations = torch.tensor(rotations, dtype=torch.float32)
-
-        # Create an instance of Batch2dTransform
-        transform = Batch2dTransform()
-
-        log.debug(
-            f"Applying shaking with parameters: \nposition {position_amount_x}, {position_amount_y}\nrotation {rotation_amount}\nfrequency {frequency}\noctaves {octaves}"
-        )
-
-        # Apply shaking transformations to images
-        shaken_images = transform.transform_batch(
-            images,
-            border_handling="edge",  # Assuming edge handling as default
-            constant_color="#000000",  # Assuming black as default constant color
-            x=x_translations,
-            y=y_translations,
-            angle=rotations,
-        )[0]
-
-        return (shaken_images, x_translations, y_translations, rotations)
-
-
-__nodes__ = [
-    BatchFloat,
-    Batch2dTransform,
-    BatchShape,
-    BatchMake,
-    BatchFloatAssemble,
-    BatchFloatFill,
-    BatchMerge,
-    BatchShake,
-]

nodes/conditions.py

@@ -1,10 +1,9 @@
-import csv, 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 InterpolateClipSequential:
@@ -156,23 +155,9 @@ class StylesLoader:
             for file in files:
                 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)})")

nodes/crop.py

@@ -1,9 +1,9 @@
-import numpy as np
 import torch
-from PIL import Image, ImageChops, 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 Bbox:
@@ -32,7 +32,7 @@ class Bbox:
     CATEGORY = "mtb/crop"
 
     def do_crop(self, x, y, width, height):  # bbox
-        return ((x, y, width, height),)
+        return (x, y, width, height)
         # return bbox
 
 
@@ -44,7 +44,6 @@ class BboxFromMask:
         return {
             "required": {
                 "mask": ("MASK",),
-                "invert": ("BOOLEAN", {"default": False}),
             },
             "optional": {
                 "image": ("IMAGE",),
@@ -62,7 +61,7 @@ class 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:
@@ -74,8 +73,9 @@ class 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)
@@ -141,23 +141,19 @@ class Crop:
         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,
         )
 

nodes/debug.py

@@ -1,71 +1,10 @@
-import base64
-import io
-from pathlib import Path
-from typing import Optional
-
-import folder_paths
-import torch
-
-from ..log import log
 from ..utils import tensor2pil
-
-
-# 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(
-            f"List of List of Tensors: {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)})")
-
-    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}")
-
-    return {"text": text}
-
-
-def process_bool(anything):
-    return {"text": ["True" if anything else "False"]}
-
-
-def process_text(anything):
-    return {"text": [str(anything)]}
-
-
-# endregion
+from ..log import log
+import io, base64
+import torch
+import folder_paths
+from typing import Optional
+from pathlib import Path
 
 
 class Debug:
@@ -74,38 +13,46 @@ class Debug:
     @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, **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:
-            print("bouh!")
+                # write the images to temp
 
-        for anything in kwargs.values():
-            processor = processors.get(type(anything), process_text)
-            processed_data = processor(anything)
+                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")
+                    )
 
-            for ui_key, ui_value in processed_data.items():
-                output["ui"][ui_key].extend(ui_value)
-            # log.debug(
-            #     f"Processed input {k}, found {len(processed_data.get('b64_images', []))} images and {len(processed_data.get('text', []))} text items."
-            # )
+                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
 

nodes/deep_bump.py

@@ -1,38 +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):
+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(
-        f"Converting color image to grayscale by taking 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")
@@ -43,56 +28,32 @@ def color_to_normals(color_img, overlap, progress_callback, save_temp=False):
         "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(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"
-            )
+    pred_tiles = utils_inference.tiles_infer(
+        tiles, ort_session, progress_callback=progress_callback
+    )
 
     # 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
 
@@ -300,7 +261,7 @@ class DeepBump:
                         "LARGEST",
                     ],
                 ),
-                "normals_to_height_seamless": ("BOOLEAN", {"default": True}),
+                "normals_to_height_seamless": ("BOOLEAN", {"default": False}),
             },
         }
 
@@ -317,38 +278,25 @@ class DeepBump:
         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__ = [DeepBump]

nodes/faceenhance.py

@@ -1,19 +1,21 @@
+from gfpgan import GFPGANer
+import cv2
+import numpy as np
 import os
 from pathlib import Path
-from typing import Tuple
+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 gfpgan import GFPGANer
-from PIL import Image
-
-from ..log import NullWriter, log
-from ..utils import get_model_path, np2tensor, pil2tensor, tensor2np
+from typing import Tuple
 
 
 class LoadFaceEnhanceModel:
@@ -24,12 +26,11 @@ class 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
@@ -246,16 +247,16 @@ class RestoreFace:
         ):
             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__ = [RestoreFace, LoadFaceEnhanceModel]

nodes/faceswap.py

@@ -1,21 +1,21 @@
-# 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
 
@@ -27,6 +27,15 @@ class LoadFaceAnalysisModel:
 
     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,7 +57,7 @@ class LoadFaceAnalysisModel:
 
         face_analyser = insightface.app.FaceAnalysis(
             name=faceswap_model,
-            root=get_model_path("insightface"),
+            root=os.path.join(folder_paths.models_dir, "insightface"),
         )
         return (face_analyser,)
 
@@ -58,8 +67,10 @@ class LoadFaceSwapModel:
 
     @staticmethod
     def get_models() -> List[Path]:
-        models_path = get_model_path("insightface").iterdir()
-        return [x for x in models_path if x.suffix in [".onnx", ".pth"]]
+        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):
@@ -77,10 +88,9 @@ class 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(

nodes/generate.py

@@ -1,11 +1,9 @@
-import threading
-from typing import cast
-
 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, pil2tensor
 
 # class MtbExamples:
 #     """MTB Example Images"""
@@ -76,9 +74,8 @@ class 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/"
 
@@ -204,13 +201,12 @@ class TextToImage:
 
         for font in fonts:
             log.debug(f"Adding font {font}")
-            TextToImage.fonts[font.stem] = font.as_posix()
+            cls.fonts[font.stem] = font.as_posix()
 
     @classmethod
     def INPUT_TYPES(cls):
         if not cls.fonts:
-            thread = threading.Thread(target=cls.CACHE_FONTS)
-            thread.start()
+            cls.CACHE_FONTS()
         else:
             log.debug(f"Using cached fonts (count: {len(cls.fonts)})")
         return {
@@ -236,6 +232,7 @@ class TextToImage:
                     "INT",
                     {"default": 512, "min": 1, "max": 8096, "step": 1},
                 ),
+                # "position": (["INT"], {"default": 0, "min": 0, "max": 100, "step": 1}),
                 "color": (
                     "COLOR",
                     {"default": "black"},
@@ -244,8 +241,6 @@ class TextToImage:
                     "COLOR",
                     {"default": "white"},
                 ),
-                "h_align": (("left", "center", "right"), {"default": "left"}),
-                "v_align": (("top", "center", "bottom"), {"default": "top"}),
             }
         }
 
@@ -255,62 +250,29 @@ class TextToImage:
     CATEGORY = "mtb/generate"
 
     def text_to_image(
-        self,
-        text,
-        font,
-        wrap,
-        font_size,
-        width,
-        height,
-        color,
-        background,
-        h_align="left",
-        v_align="top",
+        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]
-
-        # Handle word wrapping
-        if wrap:
-            lines = textwrap.wrap(text, width=wrap)
-        else:
-            lines = [text]
-        font = ImageFont.truetype(font_path, font_size)
-        # font = ImageFont.truetype(font_path, font_size)
-        # if wrap == 0:
-        #     wrap = width / 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)
-
-        text_height = sum(font.getsize(line)[1] for line in lines)
-
-        # Vertical alignment
-        if v_align == "top":
-            y_text = 0
-        elif v_align == "center":
-            y_text = (height - text_height) // 2
-        else:  # bottom
-            y_text = height - text_height
-
-        # Draw each line of text
+        y_text = 0
+        # - bbox is [left, upper, right, lower]
         for line in lines:
-            line_width, line_height = font.getsize(line)
-
-            # Horizontal alignment
-            if h_align == "left":
-                x_text = 0
-            elif h_align == "center":
-                x_text = (width - line_width) // 2
-            else:  # right
-                x_text = width - line_width
-
-            draw.text((x_text, y_text), line, color, font=font)
-            y_text += line_height
+            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/graph_utils.py

@@ -1,24 +1,22 @@
-import io, json, urllib.parse, urllib.request
-
-import numpy as np
-import torch
-from PIL import Image
-
 from ..log import log
-from ..utils import apply_easing, get_server_info, pil2tensor
+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())
 
 
@@ -62,18 +60,10 @@ class 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())
@@ -90,7 +80,7 @@ class GetBatchFromHistory:
                         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)
@@ -100,11 +90,13 @@ class 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 AnyToString:
@@ -167,52 +159,6 @@ class 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):
-        import math
-        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 FitNumber:
     """Fit the input float using a source and target range"""
 
@@ -222,10 +168,10 @@ class 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": (
                     [
                         "Linear",
@@ -259,7 +205,6 @@ class 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,
@@ -271,53 +216,20 @@ class 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 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__ = [
-    StringReplace,
-    FitNumber,
-    GetBatchFromHistory,
-    AnyToString,
-    ConcatImages,
-    MTB_MathExpression,
-]
+__nodes__ = [StringReplace, FitNumber, GetBatchFromHistory, AnyToString]

nodes/image_interpolation.py

@@ -1,20 +1,16 @@
-import glob
-import os
-from pathlib import Path
 from typing import List
-
-import comfy
-import comfy.model_management as model_management
-import comfy.utils
+from pathlib import Path
+import os
+import glob
 import folder_paths
-import numpy as np
-import tensorflow as tf
-import torch
-from frame_interpolation.eval import interpolator, util
-
-from ..errors import ModelNotFound
 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 LoadFilmModel:
@@ -22,9 +18,10 @@ class LoadFilmModel:
 
     @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):
@@ -42,10 +39,7 @@ class 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"
 
@@ -120,4 +114,41 @@ class FilmInterpolation:
         return (out_tensors,)
 
 
-__nodes__ = [LoadFilmModel, 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,20 +1,17 @@
-import itertools
-import json
-import math
-import os
-
-import cv2
-import folder_paths
-import numpy as np
 import torch
-import torch.nn.functional as F
-from PIL import Image
-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 pil2tensor, tensor2np, tensor2pil
 
 # try:
 #     from cv2.ximgproc import guidedFilter
@@ -22,18 +19,6 @@ from ..utils import 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 ColorCorrect:
     """Various color correction methods"""
 
@@ -192,7 +177,7 @@ class ColorCorrect:
         return (image,)
 
 
-class ImageCompare_:
+class ImageCompare:
     """Compare two images and return a difference image"""
 
     @classmethod
@@ -228,7 +213,7 @@ class ImageCompare_:
 import requests
 
 
-class LoadImageFromUrl_:
+class LoadImageFromUrl:
     """Load an image from the given URL"""
 
     @classmethod
@@ -254,7 +239,7 @@ class LoadImageFromUrl_:
         return (pil2tensor(image),)
 
 
-class Blur_:
+class Blur:
     """Blur an image using a Gaussian filter."""
 
     @classmethod
@@ -285,78 +270,6 @@ class Blur_:
         return (torch.from_numpy(image),)
 
 
-class 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,)
-
-
 # https://github.com/lllyasviel/AdverseCleaner/blob/main/clean.py
 # def deglaze_np_img(np_img):
 #     y = np_img.copy()
@@ -403,26 +316,22 @@ class MaskToImage:
     FUNCTION = "render_mask"
 
     def render_mask(self, mask, color, background):
-        masks = tensor2np(mask)
-        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 ColoredImage:
@@ -438,11 +347,7 @@ class 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"
@@ -451,46 +356,12 @@ class ColoredImage:
 
     FUNCTION = "render_img"
 
-    def render_img(
-        self, color, width, height, foreground_image=None, foreground_mask=None
-    ):
-        image = Image.new("RGBA", (width, height), color=color)
-        output = []
-        if foreground_image is not None:
-            if foreground_mask is None:
-                fg_images = tensor2pil(foreground_image)
-                for img in fg_images:
-                    if image.size != img.size:
-                        raise ValueError(
-                            f"Dimension mismatch: image {image.size}, img {img.size}"
-                        )
+    def render_img(self, color, width, height):
+        image = Image.new("RGB", (width, height), color=color)
 
-                    if img.mode != "RGBA":
-                        raise ValueError(
-                            f"Foreground image must be in 'RGBA' mode when no mask is provided, got {img.mode}"
-                        )
+        image = pil2tensor(image)
 
-                    output.append(Image.alpha_composite(image, img).convert("RGB"))
-
-            elif foreground_image.size[0] != foreground_mask.size[0]:
-                raise ValueError("Foreground image and mask must have same batch size")
-            else:
-                fg_images = tensor2pil(foreground_image)
-                fg_masks = tensor2pil(foreground_mask)
-                output.extend(
-                    Image.composite(
-                        fg_image.convert("RGBA"),
-                        image,
-                        fg_mask,
-                    ).convert("RGB")
-                    for fg_image, fg_mask in zip(fg_images, fg_masks)
-                )
-        elif foreground_mask is not None:
-            log.warn("Mask ignored because no foreground image is given")
-
-        output = pil2tensor(output)
-
-        return (output,)
+        return (image,)
 
 
 class ImagePremultiply:
@@ -508,13 +379,19 @@ class 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 = []
@@ -624,7 +501,7 @@ class ImageResizeFactor:
         return (resized_image,)
 
 
-class SaveImageGrid_:
+class SaveImageGrid:
     """Save all the images in the input batch as a grid of images."""
 
     def __init__(self):
@@ -726,65 +603,15 @@ class SaveImageGrid_:
         return {"ui": {"images": results}}
 
 
-class ImageTileOffset:
-    """Mimics an old photoshop technique to check for seamless textures"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "tiles": ("INT", {"default": 2}),
-            }
-        }
-
-    CATEGORY = "mtb/generate"
-
-    RETURN_TYPES = ("IMAGE",)
-
-    FUNCTION = "tile_image"
-
-    def tile_image(self, image: torch.Tensor, tiles: int = 2):
-        if tiles < 1:
-            raise ValueError("The number of tiles must be at least 1.")
-
-        batch_size, height, width, channels = image.shape
-        tile_height = height // tiles
-        tile_width = width // tiles
-
-        output_image = torch.zeros_like(image)
-
-        for i, j in itertools.product(range(tiles), range(tiles)):
-            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) % tiles * tile_height
-            output_start_w = (j + 1) % tiles * 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__ = [
     ColorCorrect,
-    ImageCompare_,
-    ImageTileOffset,
-    Blur_,
+    ImageCompare,
+    Blur,
     # DeglazeImage,
     MaskToImage,
     ColoredImage,
     ImagePremultiply,
     ImageResizeFactor,
-    SaveImageGrid_,
-    LoadImageFromUrl_,
-    Sharpen_,
+    SaveImageGrid,
+    LoadImageFromUrl,
 ]

nodes/image_utils.py

@@ -1,76 +0,0 @@
-import torch
-
-from ..log import log
-
-
-class 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 {'vertically' if vertical else 'horizontally'}"
-        )
-        log.debug(list(kwargs.keys()))
-
-        ref_shape = tensors[0].shape
-        for tensor in tensors[1:]:
-            if tensor.shape[1:] != ref_shape[1:]:
-                raise ValueError(
-                    "All tensors must have the same dimensions except for the stacking dimension."
-                )
-
-        dim = 1 if vertical else 2
-
-        stacked_tensor = torch.cat(tensors, dim=dim)
-
-        return (stacked_tensor,)
-
-
-class 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, but only {batch_size} are available."
-            )
-
-        if from_direction == "end":
-            selected_tensors = image[-count:]
-        else:
-            selected_tensors = image[:count]
-
-        return (selected_tensors,)
-
-
-__nodes__ = [StackImages, PickFromBatch]

nodes/io.py

@@ -1,107 +1,14 @@
-import json, subprocess, uuid
-from pathlib import Path
-from typing import List, Optional
-
-import comfy.model_management as model_management
+from ..utils import tensor2np, PIL_FILTER_MAP
+import uuid
 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
-
-
-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 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 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 ()
+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
 
 
 class ExportWithFfmpeg:
@@ -110,11 +17,8 @@ class ExportWithFfmpeg:
     @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"}),
@@ -123,7 +27,7 @@ class ExportWithFfmpeg:
                     ["prores_ks", "libx264", "libx265"],
                     {"default": "prores_ks"},
                 ),
-            },
+            }
         }
 
     RETURN_TYPES = ("VIDEO",)
@@ -133,61 +37,20 @@ class 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])}")
@@ -329,4 +192,4 @@ class SaveGif:
         return {"ui": {"gif": results}}
 
 
-__nodes__ = [SaveGif, ExportWithFfmpeg, AddToPlaylist, ReadPlaylist]
+__nodes__ = [SaveGif, ExportWithFfmpeg]

nodes/mask.py

@@ -1,8 +1,7 @@
-import comfy.utils
-from PIL import Image
 from rembg import remove
-
 from ..utils import pil2tensor, tensor2pil
+from PIL import Image
+import comfy.utils
 
 
 class ImageRemoveBackgroundRembg:
@@ -92,8 +91,6 @@ class 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)

nodes/model.py

@@ -1,99 +0,0 @@
-import copy
-
-import torch
-
-from ..log import log
-
-
-class 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"]),)
-
-
-class 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",),
-                "tiling": (
-                    "BOOLEAN",
-                    {"default": True},
-                ),  # kept for testing not sure why it should be false
-            }
-        }
-
-    RETURN_TYPES = ("MODEL", "MODEL")
-    RETURN_NAMES = (
-        "Original Model (passthrough)",
-        "Patched Model",
-    )
-    FUNCTION = "hack"
-
-    CATEGORY = "mtb/textures"
-
-    def apply_circular(self, model, enable):
-        for layer in [
-            layer for layer in model.modules() if isinstance(layer, torch.nn.Conv2d)
-        ]:
-            layer.padding_mode = "circular" if enable else "zeros"
-        return model
-
-    def hack(
-        self,
-        model,
-        tiling,
-    ):
-        hacked_model = copy.deepcopy(model)
-        self.apply_circular(hacked_model.model, tiling)
-        return (model, hacked_model)
-
-
-__nodes__ = [ModelPatchSeamless, VaeDecode_]

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]

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,8 +0,0 @@
-qrcode[pil]
-onnxruntime-gpu
-requirements-parser
-# opencv-contrib
-rembg
-imageio_ffmpeg
-rich
-rich_argparse

utils.py

@@ -1,14 +1,23 @@
-import contextlib, functools, math, os, shlex, shutil, socket, subprocess, sys, uuid
-from pathlib import Path
-from typing import List, Optional, Union
-
-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
@@ -24,95 +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 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
-def backup_file(
-    fp: Path,
-    target: Optional[Path] = None,
-    backup_dir: str = ".bak",
-    suffix: Optional[str] = None,
-    prefix: Optional[str] = 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("#")
@@ -138,76 +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 = {value: key for key, value in pip_map.items()}
-
-import importlib
+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
@@ -224,14 +170,11 @@ 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 / "font.ttf"
 
@@ -257,7 +200,7 @@ PIL_FILTER_MAP = {
 # endregion
 
 
-# region TENSOR Utilities
+# 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:
@@ -273,14 +216,14 @@ def tensor2pil(image: torch.Tensor) -> List[Image.Image]:
     ]
 
 
-def pil2tensor(image: Union[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)
 
 
-def np2tensor(img_np: Union[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)
 
@@ -298,195 +241,6 @@ def tensor2np(tensor: torch.Tensor) -> List[np.ndarray]:
     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)
-
-
 # endregion
 
 
@@ -497,9 +251,11 @@ def download_antelopev2():
     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():
@@ -526,33 +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:
-                log.warning(
-                    f"Found multiple match, we will pick the first {res[0]}\n{res}"
-                )
-            res = res[0]
-        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
 
 
@@ -577,6 +306,9 @@ def create_uv_map_tensor(width=512, height=512):
 
 # region ANIMATION Utilities
 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
 
@@ -742,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/comfy_shared.js

@@ -7,7 +7,7 @@
  *
  */
 
-import { app } from '../../scripts/app.js'
+import { app } from '/scripts/app.js'
 
 export const log = (...args) => {
   if (window.MTB?.DEBUG) {
@@ -18,30 +18,6 @@ export const log = (...args) => {
 //- WIDGET UTILS
 export const CONVERTED_TYPE = 'converted-widget'
 
-export const hasWidgets = (node) => {
-  if (!node.widgets || !node.widgets?.[Symbol.iterator]) {
-    return false
-  }
-  return true
-}
-
-export const cleanupNode = (node) => {
-  if (!hasWidgets(node)) {
-    return
-  }
-
-  for (const w of node.widgets) {
-    if (w.canvas) {
-      w.canvas.remove()
-    }
-    if (w.inputEl) {
-      w.inputEl.remove()
-    }
-    // calls the widget remove callback
-    w.onRemoved?.()
-  }
-}
-
 export function offsetDOMWidget(
   widget,
   ctx,
@@ -92,38 +68,14 @@ export function getWidgetType(config) {
   }
   return { type, linkType }
 }
-export const setupDynamicConnections = (nodeType, prefix, inputType) => {
-  const onNodeCreated = nodeType.prototype.onNodeCreated
-  nodeType.prototype.onNodeCreated = function () {
-    const r = onNodeCreated ? onNodeCreated.apply(this, arguments) : undefined
-    this.addInput(`${prefix}_1`, inputType)
-    return r
-  }
 
-  const onConnectionsChange = nodeType.prototype.onConnectionsChange
-  nodeType.prototype.onConnectionsChange = function (
-    type,
-    index,
-    connected,
-    link_info
-  ) {
-    const r = onConnectionsChange
-      ? onConnectionsChange.apply(this, arguments)
-      : undefined
-    dynamic_connection(this, index, connected, `${prefix}_`, inputType)
-  }
-}
 export const dynamic_connection = (
   node,
   index,
   connected,
   connectionPrefix = 'input_',
-  connectionType = 'PSDLAYER',
-  nameArray = []
+  connectionType = 'PSDLAYER'
 ) => {
-  if (!node.inputs[index].name.startsWith(connectionPrefix)) {
-    return
-  }
   // remove all non connected inputs
   if (!connected && node.inputs.length > 1) {
     log(`Removing input ${index} (${node.inputs[index].name})`)
@@ -138,24 +90,22 @@ export const dynamic_connection = (
 
     // make inputs sequential again
     for (let i = 0; i < node.inputs.length; i++) {
-      const name =
-        i < nameArray.length ? nameArray[i] : `${connectionPrefix}${i + 1}`
-      node.inputs[i].label = name
-      node.inputs[i].name = name
+      node.inputs[i].label = `${connectionPrefix}${i + 1}`
     }
   }
 
   // add an extra input
   if (node.inputs[node.inputs.length - 1].link != undefined) {
-    const nextIndex = node.inputs.length
-    const name =
-      nextIndex < nameArray.length
-        ? nameArray[nextIndex]
-        : `${connectionPrefix}${nextIndex + 1}`
+    log(
+      `Adding input ${node.inputs.length + 1} (${connectionPrefix}${
+        node.inputs.length + 1
+      })`
+    )
 
-    log(`Adding input ${nextIndex + 1} (${name})`)
-
-    node.addInput(name, connectionType)
+    node.addInput(
+      `${connectionPrefix}${node.inputs.length + 1}`,
+      connectionType
+    )
   }
 }
 
@@ -334,43 +284,6 @@ function getBrightness(rgbObj) {
 }
 
 //- HTML / CSS UTILS
-export const loadScript = (
-  FILE_URL,
-  async = true,
-  type = 'text/javascript'
-) => {
-  return new Promise((resolve, reject) => {
-    try {
-      // Check if the script already exists
-      const existingScript = document.querySelector(`script[src="${FILE_URL}"]`)
-      if (existingScript) {
-        resolve({ status: true, message: 'Script already loaded' })
-        return
-      }
-
-      const scriptEle = document.createElement('script')
-      scriptEle.type = type
-      scriptEle.async = async
-      scriptEle.src = FILE_URL
-
-      scriptEle.addEventListener('load', (ev) => {
-        resolve({ status: true })
-      })
-
-      scriptEle.addEventListener('error', (ev) => {
-        reject({
-          status: false,
-          message: `Failed to load the script ＄{FILE_URL}`,
-        })
-      })
-
-      document.body.appendChild(scriptEle)
-    } catch (error) {
-      reject(error)
-    }
-  })
-}
-
 export function defineClass(className, classStyles) {
   const styleSheets = document.styleSheets
 

web/debug.js

@@ -7,35 +7,17 @@
  *
  */
 
-import { app } from '../../scripts/app.js'
-
-import * as shared from './comfy_shared.js'
-import { log } 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, '&')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#039;')
-}
 app.registerExtension({
   name: 'mtb.Debug',
   async beforeRegisterNodeDef(nodeType, nodeData, app) {
     if (nodeData.name === 'Debug (mtb)') {
-      const onNodeCreated = nodeType.prototype.onNodeCreated
-      nodeType.prototype.onNodeCreated = function () {
-        const r = onNodeCreated
-          ? onNodeCreated.apply(this, arguments)
-          : undefined
-        this.addInput(`anything_1`, '*')
-        return r
-      }
-
       const onConnectionsChange = nodeType.prototype.onConnectionsChange
       nodeType.prototype.onConnectionsChange = function (
         type,
@@ -75,18 +57,15 @@ app.registerExtension({
           // 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
-
         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++
@@ -102,17 +81,15 @@ app.registerExtension({
           }
           // 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,8 +9,8 @@
 
 // forked from pysssss's imageFeed.js
 
-import { api } from '../../scripts/api.js'
-import { app } from '../../scripts/app.js'
+import { api } from '/scripts/api.js'
+import { app } from '/scripts/app.js'
 
 const styles = {
   lighbox: {

web/mtb_widgets.js

@@ -7,47 +7,14 @@
  *
  */
 
-// TODO: Use the builtin addDOMWidget everywhere appropriate
-
-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 { log } from './comfy_shared.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'
 
 const newTypes = [, /*'BOOL'*/ 'COLOR', 'BBOX']
 
-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 const MtbWidgets = {
   BBOX: (key, val) => {
     /** @type {import("./types/litegraph").IWidget} */
@@ -349,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 () {
@@ -372,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: 0;
-      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)
 
@@ -519,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
       }
@@ -563,10 +561,6 @@ const mtb_widgets = {
       }
     }
 
-    if (!nodeData.name.endsWith('(mtb)')) {
-      return
-    }
-
     //- Extending Python Nodes
     switch (nodeData.name) {
       case 'Psd Save (mtb)': {
@@ -656,14 +650,22 @@ const mtb_widgets = {
                 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
@@ -731,7 +733,12 @@ const mtb_widgets = {
           })
 
           this.onRemoved = () => {
-            shared.cleanupNode(this)
+            for (const w of this.widgets) {
+              if (w.canvas) {
+                w.canvas.remove()
+              }
+              w.onRemoved?.()
+            }
             app.canvas.setDirty(true)
           }
 
@@ -883,70 +890,6 @@ const mtb_widgets = {
 
         break
       }
-      case 'Add To Playlist (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'video', 'VIDEO')
-        break
-      }
-      case 'Stack Images (mtb)':
-      case 'Concat Images (mtb)': {
-        shared.setupDynamicConnections(nodeType, 'image', 'IMAGE')
-
-        break
-      }
-      case 'Batch Float Assemble (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_', '*', [
-            '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 'Save Tensors (mtb)': {
         const onDrawBackground = nodeType.prototype.onDrawBackground
         nodeType.prototype.onDrawBackground = function (ctx, canvas) {

web/note_plus.js

@@ -1,181 +0,0 @@
-import { app } from '../../scripts/app.js'
-import { api } from '../../scripts/api.js'
-import * as shared from './comfy_shared.js'
-
-class NotePlus extends LiteGraph.LGraphNode {
-  title = 'Note+ (mtb)'
-  category = 'mtb/utils'
-
-  constructor() {
-    super()
-
-    this.isVirtualNode = true
-    this.serialize_widgets = true
-
-    this.editing = false
-    this.live = true
-    this.rawVal = "<p style='color:red;font-family:monospace'\n>    Note+\n</p>"
-
-    this.calculated_height = 36
-
-    const inner = document.createElement('div')
-    inner.style.margin = '0'
-    inner.style.padding = '0'
-    this.html_widget = this.addDOMWidget('HTML', 'html', inner, {
-      setValue: (v) => {
-        // update our widget preview
-        this.html_widget.element.innerHTML = v
-        // calculate height
-        this.calculated_height = this.html_widget.element.scrollHeight + 36
-      },
-      getValue: () => this.rawVal,
-      getMinHeight: () => this.calculated_height, // (the edit button),
-    })
-
-    // console.log(`Value of HTML: ${this.html_widget.value}`)
-    this.html_widget.element.innerHTML = this.html_widget.value
-
-    //- ace based editor
-    this.addWidget('button', 'Edit', 'Edit', () => {
-      const container = document.createElement('div')
-      Object.assign(container.style, {
-        display: 'flex',
-        gap: '10px',
-      })
-
-      dialog.show('')
-      dialog.textElement.append(container)
-
-      const value = document.createElement('div')
-      value.id = 'noteplus-editor'
-      Object.assign(value.style, {
-        width: '300px',
-        height: '200px',
-        backgroundColor: 'rgb(30,30,30)',
-        color: 'whitesmoke',
-      })
-
-      container.append(value)
-
-      const live_edit = document.createElement('input')
-      live_edit.type = 'checkbox'
-      live_edit.checked = this.live
-      live_edit.onchange = () => {
-        this.live = live_edit.checked
-      }
-
-      const live_edit_label = document.createElement('label')
-      live_edit_label.textContent = 'Live Edit'
-      live_edit_label.append(live_edit)
-
-      value.after(live_edit_label)
-
-      this.setupEditor()
-      this.editor.setValue(this.html_widget.element.innerHTML)
-    })
-
-    const dialog = new app.ui.dialog.constructor()
-    dialog.element.classList.add('comfy-settings')
-
-    const closeButton = dialog.element.querySelector('button')
-    closeButton.textContent = 'CANCEL'
-    const saveButton = document.createElement('button')
-    saveButton.textContent = 'SAVE'
-    saveButton.onclick = () => {
-      this.updateHTML(this.editor.getValue())
-
-      this.editor.destroy()
-      this.editor.container.remove()
-
-      dialog.close()
-    }
-
-    closeButton.before(saveButton)
-
-    shared
-      .loadScript(
-        'https://cdn.jsdelivr.net/npm/ace-builds@1.16.0/src-min-noconflict/ace.min.js'
-      )
-      .catch((e) => {
-        console.error(e)
-      })
-  }
-
-  setupEditor() {
-    this.editor = ace.edit('noteplus-editor')
-    this.editor.setTheme('ace/theme/dracula')
-    this.editor.session.setMode('ace/mode/html')
-
-    this.editor.setShowPrintMargin(false)
-    this.editor.session.setUseWrapMode(true)
-    this.editor.renderer.setShowGutter(false)
-    this.editor.session.setTabSize(4)
-    this.editor.session.setUseSoftTabs(true)
-    this.editor.setFontSize(14)
-    this.editor.setReadOnly(false)
-    this.editor.setHighlightActiveLine(false)
-    this.editor.setShowFoldWidgets(true)
-
-    this.editor.session.on('change', (delta) => {
-      // delta.start, delta.end, delta.lines, delta.action
-      if (this.live) {
-        this.updateHTML(this.editor.getValue())
-      }
-    })
-  }
-
-  updateHTML(val) {
-    // if (CONTAINER_HTML.includes('${html}')) {
-    //   console.log('found template')
-    //   val = CONTAINER_HTML.replace('${html}', val)
-    // }
-
-    this.html_widget.value = val
-    this.rawVal = val
-
-    this.calculated_height = this.html_widget.element.scrollHeight
-
-    this.setSize(this.computeSize())
-  }
-
-  // //   onRemoved() {
-  // //     console.log('Removing', this)
-  // //     for (const w of this.widgets) {
-  // //       console.log('Removing', w)
-  // //       w.onRemove?.()
-  // //       w.onRemoved?.()
-  // //     }
-  // //   }
-}
-
-app.registerExtension({
-  name: 'mtb.noteplus',
-
-  setup() {
-    // app.ui.settings.addSetting({
-    //     id: "mtb.noteplus.Container",
-    //     name: "📦 HTML container",
-    //     type: "text",
-    //     defaultValue: "<div>${html}</div>",
-    //     tooltip:
-    //         "This defines the wrapper for the noteplus html content, use '${html}' to define the location of the placeholder",
-    //     attrs: {
-    //         style: {
-    //             fontFamily: "monospace",
-    //         },
-    //     },
-    //     onChange(value) {
-    //         if (!value) {
-    //             CONTAINER_HTML = null;
-    //             return;
-    //         }
-    //         console.log(`NOTEPLUS| value changed: ${value}`)
-    //         CONTAINER_HTML = value
-    //     },
-    // });
-  },
-
-  registerCustomNodes() {
-    LiteGraph.registerNodeType('Note Plus (mtb)', NotePlus)
-  },
-})

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) {