fix(installer): use extra index url when updating

If we don't include this, on updating, we will always get the CPU torch/torchvision/xformers.

.gitattributes

@@ -2,3 +2,4 @@
 # Only affects text files and ignores other file types.
 # For more info see: https://www.aleksandrhovhannisyan.com/blog/crlf-vs-lf-normalizing-line-endings-in-git/
 * text=auto
+docker/** text eol=lf

.github/workflows/pyflakes.yml

@@ -1,20 +0,0 @@
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-      - development
-      - 'release-candidate-*'
-
-jobs:
-  pyflakes:
-    name: runner / pyflakes
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: pyflakes
-        uses: reviewdog/action-pyflakes@v1
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          reporter: github-pr-review

.github/workflows/style-checks.yml

@@ -6,7 +6,7 @@ on:
     branches: main
 
 jobs:
-  black:
+  ruff:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
@@ -18,8 +18,7 @@ jobs:
 
       - name: Install dependencies with pip
         run: |
-          pip install black flake8 Flake8-pyproject isort
+          pip install ruff
 
-      - run: isort --check-only .
-      - run: black --check .
-      - run: flake8
+      - run: ruff check --output-format=github .
+      - run: ruff format --check .

README.md

@@ -161,7 +161,7 @@ the command `npm install -g yarn` if needed)
     _For Windows/Linux with an NVIDIA GPU:_
 
     ```terminal
-    pip install "InvokeAI[xformers]" --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu118
+    pip install "InvokeAI[xformers]" --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu121
     ```
 
     _For Linux with an AMD GPU:_
@@ -175,7 +175,7 @@ the command `npm install -g yarn` if needed)
     pip install InvokeAI --use-pep517 --extra-index-url https://download.pytorch.org/whl/cpu
     ``` 
 
-    _For Macintoshes, either Intel or M1/M2:_
+    _For Macintoshes, either Intel or M1/M2/M3:_
 
     ```sh
     pip install InvokeAI --use-pep517

docker/.env.sample

@@ -11,5 +11,5 @@ INVOKEAI_ROOT=
 # HUGGING_FACE_HUB_TOKEN=
 
 ## optional variables specific to the docker setup.
-# GPU_DRIVER=cuda
-# CONTAINER_UID=1000
+# GPU_DRIVER=cuda # or rocm
+# CONTAINER_UID=1000

docker/Dockerfile

@@ -18,8 +18,8 @@ ENV INVOKEAI_SRC=/opt/invokeai
 ENV VIRTUAL_ENV=/opt/venv/invokeai
 
 ENV PATH="$VIRTUAL_ENV/bin:$PATH"
-ARG TORCH_VERSION=2.0.1
-ARG TORCHVISION_VERSION=0.15.2
+ARG TORCH_VERSION=2.1.0
+ARG TORCHVISION_VERSION=0.16
 ARG GPU_DRIVER=cuda
 ARG TARGETPLATFORM="linux/amd64"
 # unused but available
@@ -35,7 +35,7 @@ RUN --mount=type=cache,target=/root/.cache/pip \
     if [ "$TARGETPLATFORM" = "linux/arm64" ] || [ "$GPU_DRIVER" = "cpu" ]; then \
         extra_index_url_arg="--extra-index-url https://download.pytorch.org/whl/cpu"; \
     elif [ "$GPU_DRIVER" = "rocm" ]; then \
-        extra_index_url_arg="--extra-index-url https://download.pytorch.org/whl/rocm5.4.2"; \
+        extra_index_url_arg="--index-url https://download.pytorch.org/whl/rocm5.6"; \
     else \
         extra_index_url_arg="--extra-index-url https://download.pytorch.org/whl/cu121"; \
     fi &&\

docker/docker-compose.yml

@@ -15,6 +15,10 @@ services:
             - driver: nvidia
               count: 1
               capabilities: [gpu]
+    # For AMD support, comment out the deploy section above and uncomment the devices section below:
+    #devices:
+    #  - /dev/kfd:/dev/kfd
+    #  - /dev/dri:/dev/dri
     build:
       context: ..
       dockerfile: docker/Dockerfile

docker/run.sh

@@ -7,5 +7,5 @@ set -e
 SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
 cd "$SCRIPTDIR" || exit 1
 
-docker compose up --build -d
+docker compose up -d
 docker compose logs -f

docs/features/CONTROLNET.md

@@ -150,7 +150,6 @@ Start/End  - 0 represents the start of the generation, 1 represents the end. The
 
 Additionally, each  section can be expanded with the "Show Advanced" button in order to manipulate settings for the image pre-processor that adjusts your uploaded image before using it in during the generation process.
 
-**Note:** T2I-Adapter models and ControlNet models cannot currently be used together.
 
 ## IP-Adapter
 

docs/index.md

@@ -198,6 +198,7 @@ The list of schedulers has been completely revamped and brought up to date:
 | **dpmpp_2m**   | DPMSolverMultistepScheduler     | original noise scnedule     |
 | **dpmpp_2m_k** | DPMSolverMultistepScheduler     | using karras noise schedule |
 | **unipc**      | UniPCMultistepScheduler         | CPU only                    |
+| **lcm**        | LCMScheduler                    |                             |
 
 Please see [3.0.0 Release Notes](https://github.com/invoke-ai/InvokeAI/releases/tag/v3.0.0) for further details.
 

docs/installation/010_INSTALL_AUTOMATED.md

@@ -179,7 +179,7 @@ experimental versions later.
     you will have the choice of CUDA (NVidia cards), ROCm (AMD cards),
     or CPU (no graphics acceleration). On Windows, you'll have the
     choice of CUDA vs CPU, and on Macs you'll be offered CPU only. When
-    you select CPU on M1 or M2 Macintoshes, you will get MPS-based
+    you select CPU on M1/M2/M3 Macintoshes, you will get MPS-based
     graphics acceleration without installing additional drivers. If you
     are unsure what GPU you are using, you can ask the installer to
     guess.
@@ -471,7 +471,7 @@ Then type the following commands:
 
 === "NVIDIA System"
     ```bash
-    pip install torch torchvision --force-reinstall --extra-index-url https://download.pytorch.org/whl/cu118
+    pip install torch torchvision --force-reinstall --extra-index-url https://download.pytorch.org/whl/cu121
     pip install xformers
     ```
 

docs/installation/020_INSTALL_MANUAL.md

@@ -148,7 +148,7 @@ manager, please follow these steps:
     === "CUDA (NVidia)"
 
         ```bash
-        pip install "InvokeAI[xformers]" --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu118
+        pip install "InvokeAI[xformers]" --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu121
         ```
 
     === "ROCm (AMD)"
@@ -327,7 +327,7 @@ installation protocol (important!)
 
     === "CUDA (NVidia)"
         ```bash
-        pip install -e .[xformers] --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu118
+        pip install -e .[xformers] --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu121
         ```
 
     === "ROCm (AMD)"
@@ -375,7 +375,7 @@ you can do so using this unsupported recipe:
 mkdir ~/invokeai
 conda create -n invokeai python=3.10
 conda activate invokeai
-pip install InvokeAI[xformers] --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu118
+pip install InvokeAI[xformers] --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu121
 invokeai-configure --root ~/invokeai
 invokeai --root ~/invokeai --web
 ```

docs/installation/030_INSTALL_CUDA_AND_ROCM.md

@@ -85,7 +85,7 @@ You can find which version you should download from [this link](https://docs.nvi
 
 When installing torch and torchvision manually with `pip`, remember to provide
 the argument `--extra-index-url
-https://download.pytorch.org/whl/cu118` as described in the [Manual
+https://download.pytorch.org/whl/cu121` as described in the [Manual
 Installation Guide](020_INSTALL_MANUAL.md).
 
 ## :simple-amd: ROCm

docs/installation/040_INSTALL_DOCKER.md

@@ -30,7 +30,7 @@ methodology for details on why running applications in such a stateless fashion
 The container is configured for CUDA by default, but can be built to support AMD GPUs
 by setting the `GPU_DRIVER=rocm` environment variable at Docker image build time.
 
-Developers on Apple silicon (M1/M2): You
+Developers on Apple silicon (M1/M2/M3): You
 [can't access your GPU cores from Docker containers](https://github.com/pytorch/pytorch/issues/81224)
 and performance is reduced compared with running it directly on macOS but for
 development purposes it's fine. Once you're done with development tasks on your
@@ -99,3 +99,14 @@ If using an AMD GPU:
 Use the standard `docker compose up` command, and generally the `docker compose` [CLI](https://docs.docker.com/compose/reference/) as usual.
 
 Once the container starts up (and configures the InvokeAI root directory if this is a new installation), you can access InvokeAI at [http://localhost:9090](http://localhost:9090)
+
+## Troubleshooting / FAQ
+
+- Q: I am running on Windows under WSL2, and am seeing a "no such file or directory" error.
+- A: Your `docker-entrypoint.sh` file likely has Windows (CRLF) as opposed to Unix (LF) line endings,
+    and you may have cloned this repository before the issue was fixed. To solve this, please change
+    the line endings in the `docker-entrypoint.sh` file to `LF`. You can do this in VSCode
+    (`Ctrl+P` and search for "line endings"), or by using the `dos2unix` utility in WSL.
+    Finally, you may delete `docker-entrypoint.sh` followed by  `git pull; git checkout docker/docker-entrypoint.sh`
+    to reset the file to its most recent version.
+    For more information on this issue, please see the [Docker Desktop documentation](https://docs.docker.com/desktop/troubleshoot/topics/#avoid-unexpected-syntax-errors-use-unix-style-line-endings-for-files-in-containers)

docs/installation/070_INSTALL_XFORMERS.md

@@ -28,7 +28,7 @@ command line, then just be sure to activate it's virtual environment.
 Then run the following three commands:
 
 ```sh
-pip install xformers~=0.0.19
+pip install xformers~=0.0.22
 pip install triton    # WON'T WORK ON WINDOWS
 python -m xformers.info output
 ```
@@ -42,7 +42,7 @@ If all goes well, you'll see a report like the
 following:
 
 ```sh
-xFormers 0.0.20
+xFormers 0.0.22
 memory_efficient_attention.cutlassF:               available
 memory_efficient_attention.cutlassB:               available
 memory_efficient_attention.flshattF:               available
@@ -59,14 +59,14 @@ swiglu.gemm_fused_operand_sum:                     available
 swiglu.fused.p.cpp:                                available
 is_triton_available:                               True
 is_functorch_available:                            False
-pytorch.version:                                   2.0.1+cu118
+pytorch.version:                                   2.1.0+cu121
 pytorch.cuda:                                      available
 gpu.compute_capability:                            8.9
 gpu.name:                                          NVIDIA GeForce RTX 4070
 build.info:                                        available
 build.cuda_version:                                1108
 build.python_version:                              3.10.11
-build.torch_version:                               2.0.1+cu118
+build.torch_version:                               2.1.0+cu121
 build.env.TORCH_CUDA_ARCH_LIST:                    5.0+PTX 6.0 6.1 7.0 7.5 8.0 8.6
 build.env.XFORMERS_BUILD_TYPE:                     Release
 build.env.XFORMERS_ENABLE_DEBUG_ASSERTIONS:        None
@@ -92,33 +92,22 @@ installed from source. These instructions were written for a system
 running Ubuntu 22.04, but other Linux distributions should be able to
 adapt this recipe.
 
-#### 1. Install CUDA Toolkit 11.8
+#### 1. Install CUDA Toolkit 12.1
 
 You will need the CUDA developer's toolkit in order to compile and
 install xFormers. **Do not try to install Ubuntu's nvidia-cuda-toolkit
 package.** It is out of date and will cause conflicts among the NVIDIA
 driver and binaries. Instead install the CUDA Toolkit package provided
-by NVIDIA itself. Go to [CUDA Toolkit 11.8
-Downloads](https://developer.nvidia.com/cuda-11-8-0-download-archive)
+by NVIDIA itself. Go to [CUDA Toolkit 12.1
+Downloads](https://developer.nvidia.com/cuda-12-1-0-download-archive)
 and use the target selection wizard to choose your platform and Linux
 distribution. Select an installer type of "runfile (local)" at the
 last step.
 
 This will provide you with a recipe for downloading and running a
-install shell script that will install the toolkit and drivers. For
-example, the install script recipe for Ubuntu 22.04 running on a
-x86_64 system is:
+install shell script that will install the toolkit and drivers.
 
-```
-wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run
-sudo sh cuda_11.8.0_520.61.05_linux.run
-```
-
-Rather than cut-and-paste this example, We recommend that you walk
-through the toolkit wizard in order to get the most up to date
-installer for your system.
-
-#### 2. Confirm/Install pyTorch 2.01 with CUDA 11.8 support
+#### 2. Confirm/Install pyTorch 2.1.0 with CUDA 12.1 support
 
 If you are using InvokeAI 3.0.2 or higher, these will already be
 installed. If not, you can check whether you have the needed libraries
@@ -133,7 +122,7 @@ Then run the command:
 python -c 'exec("import torch\nprint(torch.__version__)")'
 ```
 
-If it prints __1.13.1+cu118__ you're good. If not, you can install the
+If it prints __2.1.0+cu121__ you're good. If not, you can install the
 most up to date libraries with this command:
 
 ```sh

docs/nodes/communityNodes.md

@@ -4,7 +4,11 @@ These are nodes that have been developed by the community, for the community. If
 
 If you'd like to submit a node for the community, please refer to the [node creation overview](contributingNodes.md).
 
-To download a node, simply download the `.py` node file from the link and add it to the `invokeai/app/invocations` folder in your Invoke AI install location. If you used the automated installation, this can be found inside the `.venv` folder. Along with the node, an example node graph should be provided to help you get started with the node. 
+To use a node, add the node to the `nodes` folder found in your InvokeAI install location. 
+
+The suggested method is to use `git clone` to clone the repository the node is found in. This allows for easy updates of the node in the future. 
+
+If you'd prefer, you can also just download the `.py` file from the linked repository and add it to the `nodes` folder. 
 
 To use a community workflow, download the the `.json` node graph file and load it into Invoke AI via the **Load Workflow** button in the Workflow Editor. 
 
@@ -329,9 +333,9 @@ See full docs here: https://github.com/skunkworxdark/XYGrid_nodes/edit/main/READ
 
 **Description:** This node allows you to do super cool things with InvokeAI.
 
-**Node Link:** https://github.com/invoke-ai/InvokeAI/fake_node.py
+**Node Link:** https://github.com/invoke-ai/InvokeAI/blob/main/invokeai/app/invocations/prompt.py
 
-**Example Node Graph:**  https://github.com/invoke-ai/InvokeAI/fake_node_graph.json
+**Example Workflow:**  https://github.com/invoke-ai/InvokeAI/blob/docs/main/docs/workflows/Prompt_from_File.json
 
 **Output Examples** 
 

docs/nodes/contributingNodes.md

@@ -4,7 +4,7 @@ To learn about the specifics of creating a new node, please visit our [Node crea
 
 Once you’ve created a node and confirmed that it behaves as expected locally, follow these steps: 
 
-- Make sure the node is contained in a new Python (.py) file. Preferrably, the node is in a repo with a README detaling the nodes usage & examples to help others more easily use your node.
+- Make sure the node is contained in a new Python (.py) file. Preferably, the node is in a repo with a README detailing the nodes usage & examples to help others more easily use your node. Including the tag "invokeai-node" in your repository's README can also help other users find it more easily. 
 - Submit a pull request with a link to your node(s) repo in GitHub against the `main` branch to add the node to the [Community Nodes](communityNodes.md) list
     - Make sure you are following the template below and have provided all relevant details about the node and what it does. Example output images and workflows are very helpful for other users looking to use your node.
 - A maintainer will review the pull request and node. If the node is aligned with the direction of the project, you may be asked for permission to include it in the core project.

docs/nodes/exampleWorkflows.md

@@ -2,13 +2,17 @@
 
 We've curated some example workflows for you to get started with Workflows in InvokeAI
 
-To use them, right click on your desired workflow, press "Download Linked File". You can then use the "Load Workflow" functionality in InvokeAI to load the workflow and start generating images!
+To use them, right click on your desired workflow, follow the link to GitHub and click the "⬇" button to download the raw file. You can then use the "Load Workflow" functionality in InvokeAI to load the workflow and start generating images!
 
 If you're interested in finding more workflows, checkout the [#share-your-workflows](https://discord.com/channels/1020123559063990373/1130291608097661000) channel in the InvokeAI Discord.
 
 * [SD1.5 / SD2 Text to Image](https://github.com/invoke-ai/InvokeAI/blob/main/docs/workflows/Text_to_Image.json)
-* [SDXL Text to Image](https://github.com/invoke-ai/InvokeAI/blob/main/docs/workflows/SDXL_Text_to_Image.json)
-* [SDXL (with Refiner) Text to Image](https://github.com/invoke-ai/InvokeAI/blob/main/docs/workflows/SDXL_Text_to_Image.json) 
-* [Tiled Upscaling with ControlNet](https://github.com/invoke-ai/InvokeAI/blob/main/docs/workflows/ESRGAN_img2img_upscale w_Canny_ControlNet.json)
+* [SDXL Text to Image](https://github.com/invoke-ai/InvokeAI/blob/docs/main/docs/workflows/SDXL_Text_to_Image.json)
+* [SDXL Text to Image with Refiner](https://github.com/invoke-ai/InvokeAI/blob/docs/main/docs/workflows/SDXL_w_Refiner_Text_to_Image.json)
+* [Multi ControlNet (Canny & Depth)](https://github.com/invoke-ai/InvokeAI/blob/docs/main/docs/workflows/Multi_ControlNet_Canny_and_Depth.json)
+* [Tiled Upscaling with ControlNet](https://github.com/invoke-ai/InvokeAI/blob/main/docs/workflows/ESRGAN_img2img_upscale_w_Canny_ControlNet.json)
+* [Prompt From File](https://github.com/invoke-ai/InvokeAI/blob/docs/main/docs/workflows/Prompt_from_File.json)
+* [Face Detailer with IP-Adapter & ControlNet](https://github.com/invoke-ai/InvokeAI/blob/docs/main/docs/workflows/Face_Detailer_with_IP-Adapter_and_Canny.json.json)
 * [FaceMask](https://github.com/invoke-ai/InvokeAI/blob/main/docs/workflows/FaceMask.json)
 * [FaceOff with 2x Face Scaling](https://github.com/invoke-ai/InvokeAI/blob/main/docs/workflows/FaceOff_FaceScale2x.json)
+* [QR Code Monster](https://github.com/invoke-ai/InvokeAI/blob/docs/main/docs/workflows/QR_Code_Monster.json)

docs/workflows/Multi_ControlNet_Canny_and_Depth.json

@@ -0,0 +1,985 @@
+{
+  "name": "Multi ControlNet (Canny & Depth)",
+  "author": "Millu",
+  "description": "A sample workflow using canny & depth ControlNets to guide the generation process. ",
+  "version": "0.1.0",
+  "contact": "millun@invoke.ai",
+  "tags": "ControlNet, canny, depth",
+  "notes": "",
+  "exposedFields": [
+    {
+      "nodeId": "54486974-835b-4d81-8f82-05f9f32ce9e9",
+      "fieldName": "model"
+    },
+    {
+      "nodeId": "7ce68934-3419-42d4-ac70-82cfc9397306",
+      "fieldName": "prompt"
+    },
+    {
+      "nodeId": "273e3f96-49ea-4dc5-9d5b-9660390f14e1",
+      "fieldName": "prompt"
+    },
+    {
+      "nodeId": "c4b23e64-7986-40c4-9cad-46327b12e204",
+      "fieldName": "image"
+    },
+    {
+      "nodeId": "8e860e51-5045-456e-bf04-9a62a2a5c49e",
+      "fieldName": "image"
+    }
+  ],
+  "meta": {
+    "version": "1.0.0"
+  },
+  "nodes": [
+    {
+      "id": "8e860e51-5045-456e-bf04-9a62a2a5c49e",
+      "type": "invocation",
+      "data": {
+        "id": "8e860e51-5045-456e-bf04-9a62a2a5c49e",
+        "type": "image",
+        "inputs": {
+          "image": {
+            "id": "189c8adf-68cc-4774-a729-49da89f6fdf1",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "input",
+            "label": "Depth Input Image"
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "1a31cacd-9d19-4f32-b558-c5e4aa39ce73",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "12f298fd-1d11-4cca-9426-01240f7ec7cf",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "c47dabcb-44e8-40c9-992d-81dca59f598e",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 225,
+      "position": {
+        "x": 3617.163483500202,
+        "y": 40.5529847930888
+      }
+    },
+    {
+      "id": "a33199c2-8340-401e-b8a2-42ffa875fc1c",
+      "type": "invocation",
+      "data": {
+        "id": "a33199c2-8340-401e-b8a2-42ffa875fc1c",
+        "type": "controlnet",
+        "inputs": {
+          "image": {
+            "id": "4e0a3172-d3c2-4005-a84c-fa12a404f8a0",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "control_model": {
+            "id": "8cb2d998-4086-430a-8b13-94cbc81e3ca3",
+            "name": "control_model",
+            "type": "ControlNetModelField",
+            "fieldKind": "input",
+            "label": "",
+            "value": {
+              "model_name": "sd-controlnet-depth",
+              "base_model": "sd-1"
+            }
+          },
+          "control_weight": {
+            "id": "5e32bd8a-9dc8-42d8-9bcc-c2b0460c0b0f",
+            "name": "control_weight",
+            "type": "FloatPolymorphic",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "begin_step_percent": {
+            "id": "c258a276-352a-416c-8358-152f11005c0c",
+            "name": "begin_step_percent",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "end_step_percent": {
+            "id": "43001125-0d70-4f87-8e79-da6603ad6c33",
+            "name": "end_step_percent",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "control_mode": {
+            "id": "d2f14561-9443-4374-9270-e2f05007944e",
+            "name": "control_mode",
+            "type": "enum",
+            "fieldKind": "input",
+            "label": "",
+            "value": "balanced"
+          },
+          "resize_mode": {
+            "id": "727ee7d3-8bf6-4c7d-8b8a-43546b3b59cd",
+            "name": "resize_mode",
+            "type": "enum",
+            "fieldKind": "input",
+            "label": "",
+            "value": "just_resize"
+          }
+        },
+        "outputs": {
+          "control": {
+            "id": "b034aa0f-4d0d-46e4-b5e3-e25a9588d087",
+            "name": "control",
+            "type": "ControlField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 508,
+      "position": {
+        "x": 4477.604342844504,
+        "y": -49.39005411272677
+      }
+    },
+    {
+      "id": "273e3f96-49ea-4dc5-9d5b-9660390f14e1",
+      "type": "invocation",
+      "data": {
+        "id": "273e3f96-49ea-4dc5-9d5b-9660390f14e1",
+        "type": "compel",
+        "inputs": {
+          "prompt": {
+            "id": "7c2c4771-2161-4d77-aced-ff8c4b3f1c15",
+            "name": "prompt",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "Negative Prompt",
+            "value": ""
+          },
+          "clip": {
+            "id": "06d59e91-9cca-411d-bf05-86b099b3e8f7",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "conditioning": {
+            "id": "858bc33c-134c-4bf6-8855-f943e1d26f14",
+            "name": "conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 261,
+      "position": {
+        "x": 4444.706437017514,
+        "y": -924.0715320874991
+      }
+    },
+    {
+      "id": "54486974-835b-4d81-8f82-05f9f32ce9e9",
+      "type": "invocation",
+      "data": {
+        "id": "54486974-835b-4d81-8f82-05f9f32ce9e9",
+        "type": "main_model_loader",
+        "inputs": {
+          "model": {
+            "id": "f4a915a5-593e-4b6d-9198-c78eb5cefaed",
+            "name": "model",
+            "type": "MainModelField",
+            "fieldKind": "input",
+            "label": "",
+            "value": {
+              "model_name": "stable-diffusion-v1-5",
+              "base_model": "sd-1",
+              "model_type": "main"
+            }
+          }
+        },
+        "outputs": {
+          "unet": {
+            "id": "ee24fb16-da38-4c66-9fbc-e8f296ed40d2",
+            "name": "unet",
+            "type": "UNetField",
+            "fieldKind": "output"
+          },
+          "clip": {
+            "id": "f3fb0524-8803-41c1-86db-a61a13ee6a33",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "output"
+          },
+          "vae": {
+            "id": "5c4878a8-b40f-44ab-b146-1c1f42c860b3",
+            "name": "vae",
+            "type": "VaeField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 226,
+      "position": {
+        "x": 3837.096149678291,
+        "y": -1050.015351148365
+      }
+    },
+    {
+      "id": "7ce68934-3419-42d4-ac70-82cfc9397306",
+      "type": "invocation",
+      "data": {
+        "id": "7ce68934-3419-42d4-ac70-82cfc9397306",
+        "type": "compel",
+        "inputs": {
+          "prompt": {
+            "id": "7c2c4771-2161-4d77-aced-ff8c4b3f1c15",
+            "name": "prompt",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "Positive Prompt",
+            "value": ""
+          },
+          "clip": {
+            "id": "06d59e91-9cca-411d-bf05-86b099b3e8f7",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "conditioning": {
+            "id": "858bc33c-134c-4bf6-8855-f943e1d26f14",
+            "name": "conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 261,
+      "position": {
+        "x": 4449.356038911986,
+        "y": -1201.659695420063
+      }
+    },
+    {
+      "id": "d204d184-f209-4fae-a0a1-d152800844e1",
+      "type": "invocation",
+      "data": {
+        "id": "d204d184-f209-4fae-a0a1-d152800844e1",
+        "type": "controlnet",
+        "inputs": {
+          "image": {
+            "id": "4e0a3172-d3c2-4005-a84c-fa12a404f8a0",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "control_model": {
+            "id": "8cb2d998-4086-430a-8b13-94cbc81e3ca3",
+            "name": "control_model",
+            "type": "ControlNetModelField",
+            "fieldKind": "input",
+            "label": "",
+            "value": {
+              "model_name": "sd-controlnet-canny",
+              "base_model": "sd-1"
+            }
+          },
+          "control_weight": {
+            "id": "5e32bd8a-9dc8-42d8-9bcc-c2b0460c0b0f",
+            "name": "control_weight",
+            "type": "FloatPolymorphic",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "begin_step_percent": {
+            "id": "c258a276-352a-416c-8358-152f11005c0c",
+            "name": "begin_step_percent",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "end_step_percent": {
+            "id": "43001125-0d70-4f87-8e79-da6603ad6c33",
+            "name": "end_step_percent",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "control_mode": {
+            "id": "d2f14561-9443-4374-9270-e2f05007944e",
+            "name": "control_mode",
+            "type": "enum",
+            "fieldKind": "input",
+            "label": "",
+            "value": "balanced"
+          },
+          "resize_mode": {
+            "id": "727ee7d3-8bf6-4c7d-8b8a-43546b3b59cd",
+            "name": "resize_mode",
+            "type": "enum",
+            "fieldKind": "input",
+            "label": "",
+            "value": "just_resize"
+          }
+        },
+        "outputs": {
+          "control": {
+            "id": "b034aa0f-4d0d-46e4-b5e3-e25a9588d087",
+            "name": "control",
+            "type": "ControlField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 508,
+      "position": {
+        "x": 4479.68542130465,
+        "y": -618.4221638099414
+      }
+    },
+    {
+      "id": "c4b23e64-7986-40c4-9cad-46327b12e204",
+      "type": "invocation",
+      "data": {
+        "id": "c4b23e64-7986-40c4-9cad-46327b12e204",
+        "type": "image",
+        "inputs": {
+          "image": {
+            "id": "189c8adf-68cc-4774-a729-49da89f6fdf1",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "input",
+            "label": "Canny Input Image"
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "1a31cacd-9d19-4f32-b558-c5e4aa39ce73",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "12f298fd-1d11-4cca-9426-01240f7ec7cf",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "c47dabcb-44e8-40c9-992d-81dca59f598e",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 225,
+      "position": {
+        "x": 3593.7474460420153,
+        "y": -538.1200472386865
+      }
+    },
+    {
+      "id": "ca4d5059-8bfb-447f-b415-da0faba5a143",
+      "type": "invocation",
+      "data": {
+        "id": "ca4d5059-8bfb-447f-b415-da0faba5a143",
+        "type": "collect",
+        "inputs": {
+          "item": {
+            "id": "b16ae602-8708-4b1b-8d4f-9e0808d429ab",
+            "name": "item",
+            "type": "CollectionItem",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "collection": {
+            "id": "d8987dd8-dec8-4d94-816a-3e356af29884",
+            "name": "collection",
+            "type": "Collection",
+            "fieldKind": "output"
+          }
+        },
+        "label": "ControlNet Collection",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 104,
+      "position": {
+        "x": 4866.191497139488,
+        "y": -299.0538619537037
+      }
+    },
+    {
+      "id": "018b1214-c2af-43a7-9910-fb687c6726d7",
+      "type": "invocation",
+      "data": {
+        "id": "018b1214-c2af-43a7-9910-fb687c6726d7",
+        "type": "midas_depth_image_processor",
+        "inputs": {
+          "metadata": {
+            "id": "77f91980-c696-4a18-a9ea-6e2fc329a747",
+            "name": "metadata",
+            "type": "MetadataField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "image": {
+            "id": "50710a20-2af5-424d-9d17-aa08167829c6",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "a_mult": {
+            "id": "f3b26f9d-2498-415e-9c01-197a8d06c0a5",
+            "name": "a_mult",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 2
+          },
+          "bg_th": {
+            "id": "4b1eb3ae-9d4a-47d6-b0ed-da62501e007f",
+            "name": "bg_th",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0.1
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "b4ed637c-c4a0-4fdd-a24e-36d6412e4ccf",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "6bf9b609-d72c-4239-99bd-390a73cc3a9c",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "3e8aef09-cf44-4e3e-a490-d3c9e7b23119",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 339,
+      "position": {
+        "x": 4054.229311491893,
+        "y": -31.611411056365725
+      }
+    },
+    {
+      "id": "c826ba5e-9676-4475-b260-07b85e88753c",
+      "type": "invocation",
+      "data": {
+        "id": "c826ba5e-9676-4475-b260-07b85e88753c",
+        "type": "canny_image_processor",
+        "inputs": {
+          "metadata": {
+            "id": "08331ea6-99df-4e61-a919-204d9bfa8fb2",
+            "name": "metadata",
+            "type": "MetadataField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "image": {
+            "id": "33a37284-06ac-459c-ba93-1655e4f69b2d",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "low_threshold": {
+            "id": "21ec18a3-50c5-4ba1-9642-f921744d594f",
+            "name": "low_threshold",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 100
+          },
+          "high_threshold": {
+            "id": "ebeab271-a5ff-4c88-acfd-1d0271ab6ed4",
+            "name": "high_threshold",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 200
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "c0caadbf-883f-4cb4-a62d-626b9c81fc4e",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "df225843-8098-49c0-99d1-3b0b6600559f",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "e4abe0de-aa16-41f3-9cd7-968b49db5da3",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 339,
+      "position": {
+        "x": 4095.757337055795,
+        "y": -455.63440891935863
+      }
+    },
+    {
+      "id": "9db25398-c869-4a63-8815-c6559341ef12",
+      "type": "invocation",
+      "data": {
+        "id": "9db25398-c869-4a63-8815-c6559341ef12",
+        "type": "l2i",
+        "inputs": {
+          "metadata": {
+            "id": "2f269793-72e5-4ff3-b76c-fab4f93e983f",
+            "name": "metadata",
+            "type": "MetadataField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "latents": {
+            "id": "4aaedd3b-cc77-420c-806e-c7fa74ec4cdf",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "vae": {
+            "id": "432b066a-2462-4d18-83d9-64620b72df45",
+            "name": "vae",
+            "type": "VaeField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "tiled": {
+            "id": "61f86e0f-7c46-40f8-b3f5-fe2f693595ca",
+            "name": "tiled",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": false
+          },
+          "fp32": {
+            "id": "39b6c89a-37ef-4a7e-9509-daeca49d5092",
+            "name": "fp32",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": false
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "6204e9b0-61dd-4250-b685-2092ba0e28e6",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "b4140649-8d5d-4d2d-bfa6-09e389ede5f9",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "f3a0c0c8-fc24-4646-8be1-ed8cdd140828",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": false,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 267,
+      "position": {
+        "x": 5678.726701377887,
+        "y": -351.6792416734579
+      }
+    },
+    {
+      "id": "ac481b7f-08bf-4a9d-9e0c-3a82ea5243ce",
+      "type": "invocation",
+      "data": {
+        "id": "ac481b7f-08bf-4a9d-9e0c-3a82ea5243ce",
+        "type": "denoise_latents",
+        "inputs": {
+          "positive_conditioning": {
+            "id": "869cd309-c238-444b-a1a0-5021f99785ba",
+            "name": "positive_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "negative_conditioning": {
+            "id": "343447b4-1e37-4e9e-8ac7-4d04864066af",
+            "name": "negative_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "noise": {
+            "id": "b556571e-0cf9-4e03-8cfc-5caad937d957",
+            "name": "noise",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "steps": {
+            "id": "a3b3d2de-9308-423e-b00d-c209c3e6e808",
+            "name": "steps",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 10
+          },
+          "cfg_scale": {
+            "id": "b13c50a4-ec7e-4579-b0ef-2fe5df2605ea",
+            "name": "cfg_scale",
+            "type": "FloatPolymorphic",
+            "fieldKind": "input",
+            "label": "",
+            "value": 7.5
+          },
+          "denoising_start": {
+            "id": "57d5d755-f58f-4347-b991-f0bca4a0ab29",
+            "name": "denoising_start",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "denoising_end": {
+            "id": "323e78a6-880a-4d73-a62c-70faff965aa6",
+            "name": "denoising_end",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "scheduler": {
+            "id": "c25fdc17-a089-43ac-953e-067c45d5c76b",
+            "name": "scheduler",
+            "type": "Scheduler",
+            "fieldKind": "input",
+            "label": "",
+            "value": "euler"
+          },
+          "unet": {
+            "id": "6cde662b-e633-4569-b6b4-ec87c52c9c11",
+            "name": "unet",
+            "type": "UNetField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "control": {
+            "id": "276a4df9-bb26-4505-a4d3-a94e18c7b541",
+            "name": "control",
+            "type": "ControlPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "ip_adapter": {
+            "id": "48d40c51-b5e2-4457-a428-eef0696695e8",
+            "name": "ip_adapter",
+            "type": "IPAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "t2i_adapter": {
+            "id": "75dd8af2-e7d7-48b4-a574-edd9f6e686ad",
+            "name": "t2i_adapter",
+            "type": "T2IAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "latents": {
+            "id": "9223d67b-1dd7-4b34-a45f-ed0a725d9702",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "denoise_mask": {
+            "id": "4ee99177-6923-4b7f-8fe0-d721dd7cb05b",
+            "name": "denoise_mask",
+            "type": "DenoiseMaskField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "latents": {
+            "id": "7fb4e326-a974-43e8-9ee7-2e3ab235819d",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "6bb8acd0-8973-4195-a095-e376385dc705",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "795dea52-1c7d-4e64-99f7-2f60ec6e3ab9",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.4.0"
+      },
+      "width": 320,
+      "height": 646,
+      "position": {
+        "x": 5274.672987098195,
+        "y": -823.0752416664332
+      }
+    }
+  ],
+  "edges": [
+    {
+      "source": "54486974-835b-4d81-8f82-05f9f32ce9e9",
+      "sourceHandle": "clip",
+      "target": "7ce68934-3419-42d4-ac70-82cfc9397306",
+      "targetHandle": "clip",
+      "id": "reactflow__edge-54486974-835b-4d81-8f82-05f9f32ce9e9clip-7ce68934-3419-42d4-ac70-82cfc9397306clip",
+      "type": "default"
+    },
+    {
+      "source": "54486974-835b-4d81-8f82-05f9f32ce9e9",
+      "sourceHandle": "clip",
+      "target": "273e3f96-49ea-4dc5-9d5b-9660390f14e1",
+      "targetHandle": "clip",
+      "id": "reactflow__edge-54486974-835b-4d81-8f82-05f9f32ce9e9clip-273e3f96-49ea-4dc5-9d5b-9660390f14e1clip",
+      "type": "default"
+    },
+    {
+      "source": "a33199c2-8340-401e-b8a2-42ffa875fc1c",
+      "sourceHandle": "control",
+      "target": "ca4d5059-8bfb-447f-b415-da0faba5a143",
+      "targetHandle": "item",
+      "id": "reactflow__edge-a33199c2-8340-401e-b8a2-42ffa875fc1ccontrol-ca4d5059-8bfb-447f-b415-da0faba5a143item",
+      "type": "default"
+    },
+    {
+      "source": "d204d184-f209-4fae-a0a1-d152800844e1",
+      "sourceHandle": "control",
+      "target": "ca4d5059-8bfb-447f-b415-da0faba5a143",
+      "targetHandle": "item",
+      "id": "reactflow__edge-d204d184-f209-4fae-a0a1-d152800844e1control-ca4d5059-8bfb-447f-b415-da0faba5a143item",
+      "type": "default"
+    },
+    {
+      "source": "8e860e51-5045-456e-bf04-9a62a2a5c49e",
+      "sourceHandle": "image",
+      "target": "018b1214-c2af-43a7-9910-fb687c6726d7",
+      "targetHandle": "image",
+      "id": "reactflow__edge-8e860e51-5045-456e-bf04-9a62a2a5c49eimage-018b1214-c2af-43a7-9910-fb687c6726d7image",
+      "type": "default"
+    },
+    {
+      "source": "018b1214-c2af-43a7-9910-fb687c6726d7",
+      "sourceHandle": "image",
+      "target": "a33199c2-8340-401e-b8a2-42ffa875fc1c",
+      "targetHandle": "image",
+      "id": "reactflow__edge-018b1214-c2af-43a7-9910-fb687c6726d7image-a33199c2-8340-401e-b8a2-42ffa875fc1cimage",
+      "type": "default"
+    },
+    {
+      "source": "c4b23e64-7986-40c4-9cad-46327b12e204",
+      "sourceHandle": "image",
+      "target": "c826ba5e-9676-4475-b260-07b85e88753c",
+      "targetHandle": "image",
+      "id": "reactflow__edge-c4b23e64-7986-40c4-9cad-46327b12e204image-c826ba5e-9676-4475-b260-07b85e88753cimage",
+      "type": "default"
+    },
+    {
+      "source": "c826ba5e-9676-4475-b260-07b85e88753c",
+      "sourceHandle": "image",
+      "target": "d204d184-f209-4fae-a0a1-d152800844e1",
+      "targetHandle": "image",
+      "id": "reactflow__edge-c826ba5e-9676-4475-b260-07b85e88753cimage-d204d184-f209-4fae-a0a1-d152800844e1image",
+      "type": "default"
+    },
+    {
+      "source": "54486974-835b-4d81-8f82-05f9f32ce9e9",
+      "sourceHandle": "vae",
+      "target": "9db25398-c869-4a63-8815-c6559341ef12",
+      "targetHandle": "vae",
+      "id": "reactflow__edge-54486974-835b-4d81-8f82-05f9f32ce9e9vae-9db25398-c869-4a63-8815-c6559341ef12vae",
+      "type": "default"
+    },
+    {
+      "source": "ac481b7f-08bf-4a9d-9e0c-3a82ea5243ce",
+      "sourceHandle": "latents",
+      "target": "9db25398-c869-4a63-8815-c6559341ef12",
+      "targetHandle": "latents",
+      "id": "reactflow__edge-ac481b7f-08bf-4a9d-9e0c-3a82ea5243celatents-9db25398-c869-4a63-8815-c6559341ef12latents",
+      "type": "default"
+    },
+    {
+      "source": "ca4d5059-8bfb-447f-b415-da0faba5a143",
+      "sourceHandle": "collection",
+      "target": "ac481b7f-08bf-4a9d-9e0c-3a82ea5243ce",
+      "targetHandle": "control",
+      "id": "reactflow__edge-ca4d5059-8bfb-447f-b415-da0faba5a143collection-ac481b7f-08bf-4a9d-9e0c-3a82ea5243cecontrol",
+      "type": "default"
+    },
+    {
+      "source": "54486974-835b-4d81-8f82-05f9f32ce9e9",
+      "sourceHandle": "unet",
+      "target": "ac481b7f-08bf-4a9d-9e0c-3a82ea5243ce",
+      "targetHandle": "unet",
+      "id": "reactflow__edge-54486974-835b-4d81-8f82-05f9f32ce9e9unet-ac481b7f-08bf-4a9d-9e0c-3a82ea5243ceunet",
+      "type": "default"
+    },
+    {
+      "source": "273e3f96-49ea-4dc5-9d5b-9660390f14e1",
+      "sourceHandle": "conditioning",
+      "target": "ac481b7f-08bf-4a9d-9e0c-3a82ea5243ce",
+      "targetHandle": "negative_conditioning",
+      "id": "reactflow__edge-273e3f96-49ea-4dc5-9d5b-9660390f14e1conditioning-ac481b7f-08bf-4a9d-9e0c-3a82ea5243cenegative_conditioning",
+      "type": "default"
+    },
+    {
+      "source": "7ce68934-3419-42d4-ac70-82cfc9397306",
+      "sourceHandle": "conditioning",
+      "target": "ac481b7f-08bf-4a9d-9e0c-3a82ea5243ce",
+      "targetHandle": "positive_conditioning",
+      "id": "reactflow__edge-7ce68934-3419-42d4-ac70-82cfc9397306conditioning-ac481b7f-08bf-4a9d-9e0c-3a82ea5243cepositive_conditioning",
+      "type": "default"
+    }
+  ]
+}

docs/workflows/Prompt_from_File.json

@@ -0,0 +1,719 @@
+{
+  "name": "Prompt from File",
+  "author": "InvokeAI",
+  "description": "Sample workflow using prompt from file capabilities of InvokeAI ",
+  "version": "0.1.0",
+  "contact": "millun@invoke.ai",
+  "tags": "text2image, prompt from file, default",
+  "notes": "",
+  "exposedFields": [
+    {
+      "nodeId": "d6353b7f-b447-4e17-8f2e-80a88c91d426",
+      "fieldName": "model"
+    },
+    {
+      "nodeId": "1b7e0df8-8589-4915-a4ea-c0088f15d642",
+      "fieldName": "file_path"
+    }
+  ],
+  "meta": {
+    "version": "1.0.0"
+  },
+  "nodes": [
+    {
+      "id": "c2eaf1ba-5708-4679-9e15-945b8b432692",
+      "type": "invocation",
+      "data": {
+        "id": "c2eaf1ba-5708-4679-9e15-945b8b432692",
+        "type": "compel",
+        "inputs": {
+          "prompt": {
+            "id": "dcdf3f6d-9b96-4bcd-9b8d-f992fefe4f62",
+            "name": "prompt",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "",
+            "value": ""
+          },
+          "clip": {
+            "id": "3f1981c9-d8a9-42eb-a739-4f120eb80745",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "conditioning": {
+            "id": "46205e6c-c5e2-44cb-9c82-1cd20b95674a",
+            "name": "conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 261,
+      "position": {
+        "x": 1177.3417789657444,
+        "y": -102.0924766641035
+      }
+    },
+    {
+      "id": "1b7e0df8-8589-4915-a4ea-c0088f15d642",
+      "type": "invocation",
+      "data": {
+        "id": "1b7e0df8-8589-4915-a4ea-c0088f15d642",
+        "type": "prompt_from_file",
+        "inputs": {
+          "file_path": {
+            "id": "37e37684-4f30-4ec8-beae-b333e550f904",
+            "name": "file_path",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "Prompts File Path",
+            "value": ""
+          },
+          "pre_prompt": {
+            "id": "7de02feb-819a-4992-bad3-72a30920ddea",
+            "name": "pre_prompt",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "",
+            "value": ""
+          },
+          "post_prompt": {
+            "id": "95f191d8-a282-428e-bd65-de8cb9b7513a",
+            "name": "post_prompt",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "",
+            "value": ""
+          },
+          "start_line": {
+            "id": "efee9a48-05ab-4829-8429-becfa64a0782",
+            "name": "start_line",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "max_prompts": {
+            "id": "abebb428-3d3d-49fd-a482-4e96a16fff08",
+            "name": "max_prompts",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          }
+        },
+        "outputs": {
+          "collection": {
+            "id": "77d5d7f1-9877-4ab1-9a8c-33e9ffa9abf3",
+            "name": "collection",
+            "type": "StringCollection",
+            "fieldKind": "output"
+          }
+        },
+        "label": "Prompts from File",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 589,
+      "position": {
+        "x": 394.181884547075,
+        "y": -423.5345157864633
+      }
+    },
+    {
+      "id": "1b89067c-3f6b-42c8-991f-e3055789b251",
+      "type": "invocation",
+      "data": {
+        "id": "1b89067c-3f6b-42c8-991f-e3055789b251",
+        "type": "iterate",
+        "inputs": {
+          "collection": {
+            "id": "4c564bf8-5ed6-441e-ad2c-dda265d5785f",
+            "name": "collection",
+            "type": "Collection",
+            "fieldKind": "input",
+            "label": "",
+            "value": []
+          }
+        },
+        "outputs": {
+          "item": {
+            "id": "36340f9a-e7a5-4afa-b4b5-313f4e292380",
+            "name": "item",
+            "type": "CollectionItem",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 104,
+      "position": {
+        "x": 792.8735298060233,
+        "y": -432.6964953027252
+      }
+    },
+    {
+      "id": "d6353b7f-b447-4e17-8f2e-80a88c91d426",
+      "type": "invocation",
+      "data": {
+        "id": "d6353b7f-b447-4e17-8f2e-80a88c91d426",
+        "type": "main_model_loader",
+        "inputs": {
+          "model": {
+            "id": "3f264259-3418-47d5-b90d-b6600e36ae46",
+            "name": "model",
+            "type": "MainModelField",
+            "fieldKind": "input",
+            "label": "",
+            "value": {
+              "model_name": "stable-diffusion-v1-5",
+              "base_model": "sd-1",
+              "model_type": "main"
+            }
+          }
+        },
+        "outputs": {
+          "unet": {
+            "id": "8e182ea2-9d0a-4c02-9407-27819288d4b5",
+            "name": "unet",
+            "type": "UNetField",
+            "fieldKind": "output"
+          },
+          "clip": {
+            "id": "d67d9d30-058c-46d5-bded-3d09d6d1aa39",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "output"
+          },
+          "vae": {
+            "id": "89641601-0429-4448-98d5-190822d920d8",
+            "name": "vae",
+            "type": "VaeField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 226,
+      "position": {
+        "x": -47.66201354137797,
+        "y": -299.218193067033
+      }
+    },
+    {
+      "id": "fc9d0e35-a6de-4a19-84e1-c72497c823f6",
+      "type": "invocation",
+      "data": {
+        "id": "fc9d0e35-a6de-4a19-84e1-c72497c823f6",
+        "type": "compel",
+        "inputs": {
+          "prompt": {
+            "id": "dcdf3f6d-9b96-4bcd-9b8d-f992fefe4f62",
+            "name": "prompt",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "",
+            "value": ""
+          },
+          "clip": {
+            "id": "3f1981c9-d8a9-42eb-a739-4f120eb80745",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "conditioning": {
+            "id": "46205e6c-c5e2-44cb-9c82-1cd20b95674a",
+            "name": "conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 261,
+      "position": {
+        "x": 1175.0187896425462,
+        "y": -420.64289413577114
+      }
+    },
+    {
+      "id": "0eb5f3f5-1b91-49eb-9ef0-41d67c7eae77",
+      "type": "invocation",
+      "data": {
+        "id": "0eb5f3f5-1b91-49eb-9ef0-41d67c7eae77",
+        "type": "noise",
+        "inputs": {
+          "seed": {
+            "id": "b722d84a-eeee-484f-bef2-0250c027cb67",
+            "name": "seed",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "width": {
+            "id": "d5f8ce11-0502-4bfc-9a30-5757dddf1f94",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 512
+          },
+          "height": {
+            "id": "f187d5ff-38a5-4c3f-b780-fc5801ef34af",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 512
+          },
+          "use_cpu": {
+            "id": "12f112b8-8b76-4816-b79e-662edc9f9aa5",
+            "name": "use_cpu",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": true
+          }
+        },
+        "outputs": {
+          "noise": {
+            "id": "08576ad1-96d9-42d2-96ef-6f5c1961933f",
+            "name": "noise",
+            "type": "LatentsField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "f3e1f94a-258d-41ff-9789-bd999bd9f40d",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "6cefc357-4339-415e-a951-49b9c2be32f4",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 389,
+      "position": {
+        "x": 809.1964864135837,
+        "y": 183.2735123359796
+      }
+    },
+    {
+      "id": "dfc20e07-7aef-4fc0-a3a1-7bf68ec6a4e5",
+      "type": "invocation",
+      "data": {
+        "id": "dfc20e07-7aef-4fc0-a3a1-7bf68ec6a4e5",
+        "type": "rand_int",
+        "inputs": {
+          "low": {
+            "id": "b9fc6cf1-469c-4037-9bf0-04836965826f",
+            "name": "low",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "high": {
+            "id": "06eac725-0f60-4ba2-b8cd-7ad9f757488c",
+            "name": "high",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 2147483647
+          }
+        },
+        "outputs": {
+          "value": {
+            "id": "df08c84e-7346-4e92-9042-9e5cb773aaff",
+            "name": "value",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": false,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 218,
+      "position": {
+        "x": 354.19913145404166,
+        "y": 301.86324846905165
+      }
+    },
+    {
+      "id": "491ec988-3c77-4c37-af8a-39a0c4e7a2a1",
+      "type": "invocation",
+      "data": {
+        "id": "491ec988-3c77-4c37-af8a-39a0c4e7a2a1",
+        "type": "l2i",
+        "inputs": {
+          "metadata": {
+            "id": "022e4b33-562b-438d-b7df-41c3fd931f40",
+            "name": "metadata",
+            "type": "MetadataField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "latents": {
+            "id": "67cb6c77-a394-4a66-a6a9-a0a7dcca69ec",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "vae": {
+            "id": "7b3fd9ad-a4ef-4e04-89fa-3832a9902dbd",
+            "name": "vae",
+            "type": "VaeField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "tiled": {
+            "id": "5ac5680d-3add-4115-8ec0-9ef5bb87493b",
+            "name": "tiled",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": false
+          },
+          "fp32": {
+            "id": "db8297f5-55f8-452f-98cf-6572c2582152",
+            "name": "fp32",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": false
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "d8778d0c-592a-4960-9280-4e77e00a7f33",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "c8b0a75a-f5de-4ff2-9227-f25bb2b97bec",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "83c05fbf-76b9-49ab-93c4-fa4b10e793e4",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 267,
+      "position": {
+        "x": 2037.861329274915,
+        "y": -329.8393457509562
+      }
+    },
+    {
+      "id": "2fb1577f-0a56-4f12-8711-8afcaaaf1d5e",
+      "type": "invocation",
+      "data": {
+        "id": "2fb1577f-0a56-4f12-8711-8afcaaaf1d5e",
+        "type": "denoise_latents",
+        "inputs": {
+          "positive_conditioning": {
+            "id": "751fb35b-3f23-45ce-af1c-053e74251337",
+            "name": "positive_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "negative_conditioning": {
+            "id": "b9dc06b6-7481-4db1-a8c2-39d22a5eacff",
+            "name": "negative_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "noise": {
+            "id": "6e15e439-3390-48a4-8031-01e0e19f0e1d",
+            "name": "noise",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "steps": {
+            "id": "bfdfb3df-760b-4d51-b17b-0abb38b976c2",
+            "name": "steps",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 10
+          },
+          "cfg_scale": {
+            "id": "47770858-322e-41af-8494-d8b63ed735f3",
+            "name": "cfg_scale",
+            "type": "FloatPolymorphic",
+            "fieldKind": "input",
+            "label": "",
+            "value": 7.5
+          },
+          "denoising_start": {
+            "id": "2ba78720-ee02-4130-a348-7bc3531f790b",
+            "name": "denoising_start",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "denoising_end": {
+            "id": "a874dffb-d433-4d1a-9f59-af4367bb05e4",
+            "name": "denoising_end",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "scheduler": {
+            "id": "36e021ad-b762-4fe4-ad4d-17f0291c40b2",
+            "name": "scheduler",
+            "type": "Scheduler",
+            "fieldKind": "input",
+            "label": "",
+            "value": "euler"
+          },
+          "unet": {
+            "id": "98d3282d-f9f6-4b5e-b9e8-58658f1cac78",
+            "name": "unet",
+            "type": "UNetField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "control": {
+            "id": "f2ea3216-43d5-42b4-887f-36e8f7166d53",
+            "name": "control",
+            "type": "ControlPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "ip_adapter": {
+            "id": "d0780610-a298-47c8-a54e-70e769e0dfe2",
+            "name": "ip_adapter",
+            "type": "IPAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "t2i_adapter": {
+            "id": "fdb40970-185e-4ea8-8bb5-88f06f91f46a",
+            "name": "t2i_adapter",
+            "type": "T2IAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "latents": {
+            "id": "e05b538a-1b5a-4aa5-84b1-fd2361289a81",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "denoise_mask": {
+            "id": "463a419e-df30-4382-8ffb-b25b25abe425",
+            "name": "denoise_mask",
+            "type": "DenoiseMaskField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "latents": {
+            "id": "559ee688-66cf-4139-8b82-3d3aa69995ce",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "0b4285c2-e8b9-48e5-98f6-0a49d3f98fd2",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "8b0881b9-45e5-47d5-b526-24b6661de0ee",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.4.0"
+      },
+      "width": 320,
+      "height": 646,
+      "position": {
+        "x": 1570.9941088179146,
+        "y": -407.6505491604564
+      }
+    }
+  ],
+  "edges": [
+    {
+      "source": "1b7e0df8-8589-4915-a4ea-c0088f15d642",
+      "sourceHandle": "collection",
+      "target": "1b89067c-3f6b-42c8-991f-e3055789b251",
+      "targetHandle": "collection",
+      "id": "reactflow__edge-1b7e0df8-8589-4915-a4ea-c0088f15d642collection-1b89067c-3f6b-42c8-991f-e3055789b251collection",
+      "type": "default"
+    },
+    {
+      "source": "d6353b7f-b447-4e17-8f2e-80a88c91d426",
+      "sourceHandle": "clip",
+      "target": "fc9d0e35-a6de-4a19-84e1-c72497c823f6",
+      "targetHandle": "clip",
+      "id": "reactflow__edge-d6353b7f-b447-4e17-8f2e-80a88c91d426clip-fc9d0e35-a6de-4a19-84e1-c72497c823f6clip",
+      "type": "default"
+    },
+    {
+      "source": "1b89067c-3f6b-42c8-991f-e3055789b251",
+      "sourceHandle": "item",
+      "target": "fc9d0e35-a6de-4a19-84e1-c72497c823f6",
+      "targetHandle": "prompt",
+      "id": "reactflow__edge-1b89067c-3f6b-42c8-991f-e3055789b251item-fc9d0e35-a6de-4a19-84e1-c72497c823f6prompt",
+      "type": "default"
+    },
+    {
+      "source": "d6353b7f-b447-4e17-8f2e-80a88c91d426",
+      "sourceHandle": "clip",
+      "target": "c2eaf1ba-5708-4679-9e15-945b8b432692",
+      "targetHandle": "clip",
+      "id": "reactflow__edge-d6353b7f-b447-4e17-8f2e-80a88c91d426clip-c2eaf1ba-5708-4679-9e15-945b8b432692clip",
+      "type": "default"
+    },
+    {
+      "source": "dfc20e07-7aef-4fc0-a3a1-7bf68ec6a4e5",
+      "sourceHandle": "value",
+      "target": "0eb5f3f5-1b91-49eb-9ef0-41d67c7eae77",
+      "targetHandle": "seed",
+      "id": "reactflow__edge-dfc20e07-7aef-4fc0-a3a1-7bf68ec6a4e5value-0eb5f3f5-1b91-49eb-9ef0-41d67c7eae77seed",
+      "type": "default"
+    },
+    {
+      "source": "fc9d0e35-a6de-4a19-84e1-c72497c823f6",
+      "sourceHandle": "conditioning",
+      "target": "2fb1577f-0a56-4f12-8711-8afcaaaf1d5e",
+      "targetHandle": "positive_conditioning",
+      "id": "reactflow__edge-fc9d0e35-a6de-4a19-84e1-c72497c823f6conditioning-2fb1577f-0a56-4f12-8711-8afcaaaf1d5epositive_conditioning",
+      "type": "default"
+    },
+    {
+      "source": "c2eaf1ba-5708-4679-9e15-945b8b432692",
+      "sourceHandle": "conditioning",
+      "target": "2fb1577f-0a56-4f12-8711-8afcaaaf1d5e",
+      "targetHandle": "negative_conditioning",
+      "id": "reactflow__edge-c2eaf1ba-5708-4679-9e15-945b8b432692conditioning-2fb1577f-0a56-4f12-8711-8afcaaaf1d5enegative_conditioning",
+      "type": "default"
+    },
+    {
+      "source": "0eb5f3f5-1b91-49eb-9ef0-41d67c7eae77",
+      "sourceHandle": "noise",
+      "target": "2fb1577f-0a56-4f12-8711-8afcaaaf1d5e",
+      "targetHandle": "noise",
+      "id": "reactflow__edge-0eb5f3f5-1b91-49eb-9ef0-41d67c7eae77noise-2fb1577f-0a56-4f12-8711-8afcaaaf1d5enoise",
+      "type": "default"
+    },
+    {
+      "source": "d6353b7f-b447-4e17-8f2e-80a88c91d426",
+      "sourceHandle": "unet",
+      "target": "2fb1577f-0a56-4f12-8711-8afcaaaf1d5e",
+      "targetHandle": "unet",
+      "id": "reactflow__edge-d6353b7f-b447-4e17-8f2e-80a88c91d426unet-2fb1577f-0a56-4f12-8711-8afcaaaf1d5eunet",
+      "type": "default"
+    },
+    {
+      "source": "2fb1577f-0a56-4f12-8711-8afcaaaf1d5e",
+      "sourceHandle": "latents",
+      "target": "491ec988-3c77-4c37-af8a-39a0c4e7a2a1",
+      "targetHandle": "latents",
+      "id": "reactflow__edge-2fb1577f-0a56-4f12-8711-8afcaaaf1d5elatents-491ec988-3c77-4c37-af8a-39a0c4e7a2a1latents",
+      "type": "default"
+    },
+    {
+      "source": "d6353b7f-b447-4e17-8f2e-80a88c91d426",
+      "sourceHandle": "vae",
+      "target": "491ec988-3c77-4c37-af8a-39a0c4e7a2a1",
+      "targetHandle": "vae",
+      "id": "reactflow__edge-d6353b7f-b447-4e17-8f2e-80a88c91d426vae-491ec988-3c77-4c37-af8a-39a0c4e7a2a1vae",
+      "type": "default"
+    }
+  ]
+}

docs/workflows/QR_Code_Monster.json

@@ -0,0 +1,758 @@
+{
+  "name": "QR Code Monster",
+  "author": "InvokeAI",
+  "description": "Sample workflow for create images with QR code Monster ControlNet",
+  "version": "1.0.1",
+  "contact": "invoke@invoke.ai",
+  "tags": "qrcode, controlnet, default",
+  "notes": "",
+  "exposedFields": [
+    {
+      "nodeId": "a6cc0986-f928-4a7e-8d44-ba2d4b36f54a",
+      "fieldName": "image"
+    },
+    {
+      "nodeId": "aca3b054-bfba-4392-bd20-6476f59504df",
+      "fieldName": "prompt"
+    },
+    {
+      "nodeId": "3db7cee0-31e2-4a3d-94a1-268cb16177dd",
+      "fieldName": "prompt"
+    }
+  ],
+  "meta": {
+    "version": "1.0.0"
+  },
+  "nodes": [
+    {
+      "id": "3db7cee0-31e2-4a3d-94a1-268cb16177dd",
+      "type": "invocation",
+      "data": {
+        "id": "3db7cee0-31e2-4a3d-94a1-268cb16177dd",
+        "type": "compel",
+        "inputs": {
+          "prompt": {
+            "id": "6a1fe244-5656-4f8c-91d1-1fb474e28807",
+            "name": "prompt",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "Negative Prompt",
+            "value": ""
+          },
+          "clip": {
+            "id": "f24688f3-29b8-4a2d-8603-046e5a5c7250",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "conditioning": {
+            "id": "700528eb-3f8b-4745-b540-34f919b5b228",
+            "name": "conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "Prompt",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 261,
+      "position": {
+        "x": 773.0502679628016,
+        "y": 1622.4836086770556
+      }
+    },
+    {
+      "id": "610384f1-6f0c-4847-a9a2-37ce7f456ed1",
+      "type": "invocation",
+      "data": {
+        "id": "610384f1-6f0c-4847-a9a2-37ce7f456ed1",
+        "type": "main_model_loader",
+        "inputs": {
+          "model": {
+            "id": "cb36b6d3-6c1f-4911-a200-646745b0ff74",
+            "name": "model",
+            "type": "MainModelField",
+            "fieldKind": "input",
+            "label": "",
+            "value": {
+              "model_name": "stable-diffusion-v1-5",
+              "base_model": "sd-1",
+              "model_type": "main"
+            }
+          }
+        },
+        "outputs": {
+          "unet": {
+            "id": "7246895b-b252-49bc-b952-8d801b4672f7",
+            "name": "unet",
+            "type": "UNetField",
+            "fieldKind": "output"
+          },
+          "clip": {
+            "id": "3c2aedb8-30d5-4d4b-99df-d06a0d7bedc6",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "output"
+          },
+          "vae": {
+            "id": "b9743815-5501-4bbb-8bde-8bd6ba298a4e",
+            "name": "vae",
+            "type": "VaeField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 226,
+      "position": {
+        "x": 211.58866462619744,
+        "y": 1376.0542388105248
+      }
+    },
+    {
+      "id": "aca3b054-bfba-4392-bd20-6476f59504df",
+      "type": "invocation",
+      "data": {
+        "id": "aca3b054-bfba-4392-bd20-6476f59504df",
+        "type": "compel",
+        "inputs": {
+          "prompt": {
+            "id": "6a1fe244-5656-4f8c-91d1-1fb474e28807",
+            "name": "prompt",
+            "type": "string",
+            "fieldKind": "input",
+            "label": "Positive Prompt",
+            "value": ""
+          },
+          "clip": {
+            "id": "f24688f3-29b8-4a2d-8603-046e5a5c7250",
+            "name": "clip",
+            "type": "ClipField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "conditioning": {
+            "id": "700528eb-3f8b-4745-b540-34f919b5b228",
+            "name": "conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 261,
+      "position": {
+        "x": 770.6491131680111,
+        "y": 1316.379247112241
+      }
+    },
+    {
+      "id": "a6cc0986-f928-4a7e-8d44-ba2d4b36f54a",
+      "type": "invocation",
+      "data": {
+        "id": "a6cc0986-f928-4a7e-8d44-ba2d4b36f54a",
+        "type": "image",
+        "inputs": {
+          "image": {
+            "id": "89ba5d58-28c9-4e04-a5df-79fb7a6f3531",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "input",
+            "label": "QR Code / Hidden Image"
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "54335653-0e17-42da-b9e8-83c5fb5af670",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "a3c65953-39ea-4d97-8858-d65154ff9d11",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "2c7db511-ebc9-4286-a46b-bc11e0fd779f",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 225,
+      "position": {
+        "x": 700.5034176864369,
+        "y": 1981.749600549388
+      }
+    },
+    {
+      "id": "280fd8a7-3b0c-49fe-8be4-6246e08b6c9a",
+      "type": "invocation",
+      "data": {
+        "id": "280fd8a7-3b0c-49fe-8be4-6246e08b6c9a",
+        "type": "noise",
+        "inputs": {
+          "seed": {
+            "id": "7c6c76dd-127b-4829-b1ec-430790cb7ed7",
+            "name": "seed",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "width": {
+            "id": "8ec6a525-a421-40d8-a17e-39e7b6836438",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 512
+          },
+          "height": {
+            "id": "6af1e58a-e2ee-4ec4-9f06-d8d0412922ca",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 512
+          },
+          "use_cpu": {
+            "id": "26662e99-5720-43a6-a5d8-06c9dab0e261",
+            "name": "use_cpu",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": true
+          }
+        },
+        "outputs": {
+          "noise": {
+            "id": "cb4c4dfc-a744-49eb-af4f-677448e28407",
+            "name": "noise",
+            "type": "LatentsField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "97e87be6-e81f-40a3-a522-28ebe4aad0ac",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "80784420-f1e1-47b0-bd1d-1d381a15e22d",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": false,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 32,
+      "position": {
+        "x": 1182.460291960481,
+        "y": 1759.592972960265
+      }
+    },
+    {
+      "id": "2ac03cf6-0326-454a-bed0-d8baef2bf30d",
+      "type": "invocation",
+      "data": {
+        "id": "2ac03cf6-0326-454a-bed0-d8baef2bf30d",
+        "type": "controlnet",
+        "inputs": {
+          "image": {
+            "id": "1f683889-9f14-40c8-af29-4b991b211a3a",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "control_model": {
+            "id": "a933b21d-22c1-4e06-818f-15416b971282",
+            "name": "control_model",
+            "type": "ControlNetModelField",
+            "fieldKind": "input",
+            "label": "",
+            "value": {
+              "model_name": "qrcode_monster",
+              "base_model": "sd-1"
+            }
+          },
+          "control_weight": {
+            "id": "198a0825-e55e-4496-bc54-c3d7b02f3d75",
+            "name": "control_weight",
+            "type": "FloatPolymorphic",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1.4
+          },
+          "begin_step_percent": {
+            "id": "c85ce42f-22af-42a0-8993-676002fb275e",
+            "name": "begin_step_percent",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "end_step_percent": {
+            "id": "a61a65c4-9e6f-4fe2-96a5-1294d17ec6e4",
+            "name": "end_step_percent",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "control_mode": {
+            "id": "1aa45cfa-0249-46b7-bf24-3e38e92f5fa0",
+            "name": "control_mode",
+            "type": "enum",
+            "fieldKind": "input",
+            "label": "",
+            "value": "balanced"
+          },
+          "resize_mode": {
+            "id": "a89d3cb9-a141-4cea-bb49-977bf267377b",
+            "name": "resize_mode",
+            "type": "enum",
+            "fieldKind": "input",
+            "label": "",
+            "value": "just_resize"
+          }
+        },
+        "outputs": {
+          "control": {
+            "id": "c9a1fc7e-cb25-45a9-adff-1a97c9ff04d6",
+            "name": "control",
+            "type": "ControlField",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 508,
+      "position": {
+        "x": 1165.434407461108,
+        "y": 1862.916856351665
+      }
+    },
+    {
+      "id": "28542b66-5a00-4780-a318-0a036d2df914",
+      "type": "invocation",
+      "data": {
+        "id": "28542b66-5a00-4780-a318-0a036d2df914",
+        "type": "l2i",
+        "inputs": {
+          "metadata": {
+            "id": "a38e8f55-7f2c-4fcc-a71f-d51e2eb0374a",
+            "name": "metadata",
+            "type": "MetadataField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "latents": {
+            "id": "80e97bc8-e716-4175-9115-5b58495aa30c",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "vae": {
+            "id": "5641bce6-ac2b-47eb-bb32-2f290026b7e1",
+            "name": "vae",
+            "type": "VaeField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "tiled": {
+            "id": "9e75eb16-ae48-47ed-b180-e0409d377436",
+            "name": "tiled",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": false
+          },
+          "fp32": {
+            "id": "0518b0ce-ee37-437b-8437-cc2976a3279f",
+            "name": "fp32",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": false
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "ec2ff985-a7eb-401f-92c4-1217cddad6a2",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "ba1d1720-6d67-4eca-9e9d-b97d08636774",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "10bcf8f4-6394-422f-b0c0-51680f3bfb25",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 267,
+      "position": {
+        "x": 2110.8415693683014,
+        "y": 1487.253341116115
+      }
+    },
+    {
+      "id": "9755ae4c-ef30-4db3-80f6-a31f98979a11",
+      "type": "invocation",
+      "data": {
+        "id": "9755ae4c-ef30-4db3-80f6-a31f98979a11",
+        "type": "denoise_latents",
+        "inputs": {
+          "positive_conditioning": {
+            "id": "8e6aceaa-a986-4ab2-9c04-5b1027b3daf6",
+            "name": "positive_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "negative_conditioning": {
+            "id": "fbbaa712-ca1a-420b-9016-763f2a29d68c",
+            "name": "negative_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "noise": {
+            "id": "a3b3d5d2-c0f9-4b89-a9b3-8de9418f7bb5",
+            "name": "noise",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "steps": {
+            "id": "e491e664-2f8c-4f49-b3e4-57b051fbb9c5",
+            "name": "steps",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 10
+          },
+          "cfg_scale": {
+            "id": "f0318abd-ed65-4cad-86a7-48d1c19a6d14",
+            "name": "cfg_scale",
+            "type": "FloatPolymorphic",
+            "fieldKind": "input",
+            "label": "",
+            "value": 7.5
+          },
+          "denoising_start": {
+            "id": "f7c24c51-496f-44c4-836a-c734e529fec0",
+            "name": "denoising_start",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "denoising_end": {
+            "id": "54f7656a-fb0d-4d9e-a459-f700f7dccd2e",
+            "name": "denoising_end",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "scheduler": {
+            "id": "363ee440-040d-499b-bf84-bf5391b08681",
+            "name": "scheduler",
+            "type": "Scheduler",
+            "fieldKind": "input",
+            "label": "",
+            "value": "euler"
+          },
+          "unet": {
+            "id": "5c93d4e5-1064-4700-ab1d-d12e1e9b5ba7",
+            "name": "unet",
+            "type": "UNetField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "control": {
+            "id": "e1948eb3-7407-43b0-93e3-139470f186b7",
+            "name": "control",
+            "type": "ControlPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "ip_adapter": {
+            "id": "5675b2c3-adfb-49ee-b33c-26bdbfab1fed",
+            "name": "ip_adapter",
+            "type": "IPAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "t2i_adapter": {
+            "id": "89cd4ab3-3bfc-4063-9de5-91d42305c651",
+            "name": "t2i_adapter",
+            "type": "T2IAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "latents": {
+            "id": "ec01df90-5042-418d-b6d6-86b251c13770",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "denoise_mask": {
+            "id": "561cde00-cb20-42ae-9bd3-4f477f73fbe1",
+            "name": "denoise_mask",
+            "type": "DenoiseMaskField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "latents": {
+            "id": "f9addefe-efcc-4e01-8945-6ebbc934b002",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "6d48f78b-d681-422a-8677-0111bd0625f1",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "f25997b8-6316-44ce-b696-b82e4ed51ae5",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.4.0"
+      },
+      "width": 320,
+      "height": 646,
+      "position": {
+        "x": 1597.9598293300219,
+        "y": 1420.4637727891632
+      }
+    },
+    {
+      "id": "59349822-af20-4e0e-a53f-3ba135d00c3f",
+      "type": "invocation",
+      "data": {
+        "id": "59349822-af20-4e0e-a53f-3ba135d00c3f",
+        "type": "rand_int",
+        "inputs": {
+          "low": {
+            "id": "051f22f9-2d4f-414f-bc51-84af2d626efa",
+            "name": "low",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "high": {
+            "id": "77206186-f264-4224-9589-f925cf903dc9",
+            "name": "high",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 2147483647
+          }
+        },
+        "outputs": {
+          "value": {
+            "id": "a7ed9387-3a24-4d34-b7c5-f713bd544ab1",
+            "name": "value",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": false,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": false,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 32,
+      "position": {
+        "x": 1178.16746986153,
+        "y": 1663.9433412808876
+      }
+    }
+  ],
+  "edges": [
+    {
+      "source": "59349822-af20-4e0e-a53f-3ba135d00c3f",
+      "target": "280fd8a7-3b0c-49fe-8be4-6246e08b6c9a",
+      "id": "59349822-af20-4e0e-a53f-3ba135d00c3f-280fd8a7-3b0c-49fe-8be4-6246e08b6c9a-collapsed",
+      "type": "collapsed"
+    },
+    {
+      "source": "610384f1-6f0c-4847-a9a2-37ce7f456ed1",
+      "sourceHandle": "clip",
+      "target": "aca3b054-bfba-4392-bd20-6476f59504df",
+      "targetHandle": "clip",
+      "id": "reactflow__edge-610384f1-6f0c-4847-a9a2-37ce7f456ed1clip-aca3b054-bfba-4392-bd20-6476f59504dfclip",
+      "type": "default"
+    },
+    {
+      "source": "610384f1-6f0c-4847-a9a2-37ce7f456ed1",
+      "sourceHandle": "clip",
+      "target": "3db7cee0-31e2-4a3d-94a1-268cb16177dd",
+      "targetHandle": "clip",
+      "id": "reactflow__edge-610384f1-6f0c-4847-a9a2-37ce7f456ed1clip-3db7cee0-31e2-4a3d-94a1-268cb16177ddclip",
+      "type": "default"
+    },
+    {
+      "source": "a6cc0986-f928-4a7e-8d44-ba2d4b36f54a",
+      "sourceHandle": "image",
+      "target": "2ac03cf6-0326-454a-bed0-d8baef2bf30d",
+      "targetHandle": "image",
+      "id": "reactflow__edge-a6cc0986-f928-4a7e-8d44-ba2d4b36f54aimage-2ac03cf6-0326-454a-bed0-d8baef2bf30dimage",
+      "type": "default"
+    },
+    {
+      "source": "610384f1-6f0c-4847-a9a2-37ce7f456ed1",
+      "sourceHandle": "vae",
+      "target": "28542b66-5a00-4780-a318-0a036d2df914",
+      "targetHandle": "vae",
+      "id": "reactflow__edge-610384f1-6f0c-4847-a9a2-37ce7f456ed1vae-28542b66-5a00-4780-a318-0a036d2df914vae",
+      "type": "default"
+    },
+    {
+      "source": "280fd8a7-3b0c-49fe-8be4-6246e08b6c9a",
+      "sourceHandle": "noise",
+      "target": "9755ae4c-ef30-4db3-80f6-a31f98979a11",
+      "targetHandle": "noise",
+      "id": "reactflow__edge-280fd8a7-3b0c-49fe-8be4-6246e08b6c9anoise-9755ae4c-ef30-4db3-80f6-a31f98979a11noise",
+      "type": "default"
+    },
+    {
+      "source": "3db7cee0-31e2-4a3d-94a1-268cb16177dd",
+      "sourceHandle": "conditioning",
+      "target": "9755ae4c-ef30-4db3-80f6-a31f98979a11",
+      "targetHandle": "negative_conditioning",
+      "id": "reactflow__edge-3db7cee0-31e2-4a3d-94a1-268cb16177ddconditioning-9755ae4c-ef30-4db3-80f6-a31f98979a11negative_conditioning",
+      "type": "default"
+    },
+    {
+      "source": "aca3b054-bfba-4392-bd20-6476f59504df",
+      "sourceHandle": "conditioning",
+      "target": "9755ae4c-ef30-4db3-80f6-a31f98979a11",
+      "targetHandle": "positive_conditioning",
+      "id": "reactflow__edge-aca3b054-bfba-4392-bd20-6476f59504dfconditioning-9755ae4c-ef30-4db3-80f6-a31f98979a11positive_conditioning",
+      "type": "default"
+    },
+    {
+      "source": "610384f1-6f0c-4847-a9a2-37ce7f456ed1",
+      "sourceHandle": "unet",
+      "target": "9755ae4c-ef30-4db3-80f6-a31f98979a11",
+      "targetHandle": "unet",
+      "id": "reactflow__edge-610384f1-6f0c-4847-a9a2-37ce7f456ed1unet-9755ae4c-ef30-4db3-80f6-a31f98979a11unet",
+      "type": "default"
+    },
+    {
+      "source": "2ac03cf6-0326-454a-bed0-d8baef2bf30d",
+      "sourceHandle": "control",
+      "target": "9755ae4c-ef30-4db3-80f6-a31f98979a11",
+      "targetHandle": "control",
+      "id": "reactflow__edge-2ac03cf6-0326-454a-bed0-d8baef2bf30dcontrol-9755ae4c-ef30-4db3-80f6-a31f98979a11control",
+      "type": "default"
+    },
+    {
+      "source": "9755ae4c-ef30-4db3-80f6-a31f98979a11",
+      "sourceHandle": "latents",
+      "target": "28542b66-5a00-4780-a318-0a036d2df914",
+      "targetHandle": "latents",
+      "id": "reactflow__edge-9755ae4c-ef30-4db3-80f6-a31f98979a11latents-28542b66-5a00-4780-a318-0a036d2df914latents",
+      "type": "default"
+    },
+    {
+      "source": "59349822-af20-4e0e-a53f-3ba135d00c3f",
+      "sourceHandle": "value",
+      "target": "280fd8a7-3b0c-49fe-8be4-6246e08b6c9a",
+      "targetHandle": "seed",
+      "id": "reactflow__edge-59349822-af20-4e0e-a53f-3ba135d00c3fvalue-280fd8a7-3b0c-49fe-8be4-6246e08b6c9aseed",
+      "type": "default"
+    }
+  ]
+}

docs/workflows/SDXL_Text_to_Image.json

@@ -26,10 +26,6 @@
     {
       "nodeId": "3193ad09-a7c2-4bf4-a3a9-1c61cc33a204",
       "fieldName": "style"
-    },
-    {
-      "nodeId": "87ee6243-fb0d-4f77-ad5f-56591659339e",
-      "fieldName": "steps"
     }
   ],
   "meta": {
@@ -40,7 +36,6 @@
       "id": "3193ad09-a7c2-4bf4-a3a9-1c61cc33a204",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "3193ad09-a7c2-4bf4-a3a9-1c61cc33a204",
         "type": "sdxl_compel_prompt",
         "inputs": {
@@ -135,10 +130,12 @@
         "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 764,
+      "height": 793,
       "position": {
         "x": 1275,
         "y": -350
@@ -148,7 +145,6 @@
       "id": "55705012-79b9-4aac-9f26-c0b10309785b",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "55705012-79b9-4aac-9f26-c0b10309785b",
         "type": "noise",
         "inputs": {
@@ -209,7 +205,9 @@
         "isOpen": false,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
       "height": 32,
@@ -218,83 +216,10 @@
         "y": -300
       }
     },
-    {
-      "id": "dbcd2f98-d809-48c8-bf64-2635f88a2fe9",
-      "type": "invocation",
-      "data": {
-        "version": "1.0.0",
-        "id": "dbcd2f98-d809-48c8-bf64-2635f88a2fe9",
-        "type": "l2i",
-        "inputs": {
-          "tiled": {
-            "id": "24f5bc7b-f6a1-425d-8ab1-f50b4db5d0df",
-            "name": "tiled",
-            "type": "boolean",
-            "fieldKind": "input",
-            "label": "",
-            "value": false
-          },
-          "fp32": {
-            "id": "b146d873-ffb9-4767-986a-5360504841a2",
-            "name": "fp32",
-            "type": "boolean",
-            "fieldKind": "input",
-            "label": "",
-            "value": true
-          },
-          "latents": {
-            "id": "65441abd-7713-4b00-9d8d-3771404002e8",
-            "name": "latents",
-            "type": "LatentsField",
-            "fieldKind": "input",
-            "label": ""
-          },
-          "vae": {
-            "id": "a478b833-6e13-4611-9a10-842c89603c74",
-            "name": "vae",
-            "type": "VaeField",
-            "fieldKind": "input",
-            "label": ""
-          }
-        },
-        "outputs": {
-          "image": {
-            "id": "c87ae925-f858-417a-8940-8708ba9b4b53",
-            "name": "image",
-            "type": "ImageField",
-            "fieldKind": "output"
-          },
-          "width": {
-            "id": "4bcb8512-b5a1-45f1-9e52-6e92849f9d6c",
-            "name": "width",
-            "type": "integer",
-            "fieldKind": "output"
-          },
-          "height": {
-            "id": "23e41c00-a354-48e8-8f59-5875679c27ab",
-            "name": "height",
-            "type": "integer",
-            "fieldKind": "output"
-          }
-        },
-        "label": "",
-        "isOpen": true,
-        "notes": "",
-        "embedWorkflow": true,
-        "isIntermediate": false
-      },
-      "width": 320,
-      "height": 224,
-      "position": {
-        "x": 2025,
-        "y": -250
-      }
-    },
     {
       "id": "ea94bc37-d995-4a83-aa99-4af42479f2f2",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "ea94bc37-d995-4a83-aa99-4af42479f2f2",
         "type": "rand_int",
         "inputs": {
@@ -327,7 +252,9 @@
         "isOpen": false,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": false,
+        "version": "1.0.0"
       },
       "width": 320,
       "height": 32,
@@ -340,7 +267,6 @@
       "id": "30d3289c-773c-4152-a9d2-bd8a99c8fd22",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "30d3289c-773c-4152-a9d2-bd8a99c8fd22",
         "type": "sdxl_model_loader",
         "inputs": {
@@ -351,7 +277,7 @@
             "fieldKind": "input",
             "label": "",
             "value": {
-              "model_name": "stable-diffusion-xl-base-1.0",
+              "model_name": "stable-diffusion-xl-base-1-0",
               "base_model": "sdxl",
               "model_type": "main"
             }
@@ -387,10 +313,12 @@
         "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 234,
+      "height": 258,
       "position": {
         "x": 475,
         "y": 25
@@ -400,7 +328,6 @@
       "id": "faf965a4-7530-427b-b1f3-4ba6505c2a08",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "faf965a4-7530-427b-b1f3-4ba6505c2a08",
         "type": "sdxl_compel_prompt",
         "inputs": {
@@ -495,128 +422,77 @@
         "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 764,
+      "height": 793,
       "position": {
         "x": 900,
         "y": -350
       }
     },
     {
-      "id": "87ee6243-fb0d-4f77-ad5f-56591659339e",
+      "id": "63e91020-83b2-4f35-b174-ad9692aabb48",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
-        "id": "87ee6243-fb0d-4f77-ad5f-56591659339e",
-        "type": "denoise_latents",
+        "id": "63e91020-83b2-4f35-b174-ad9692aabb48",
+        "type": "l2i",
         "inputs": {
-          "noise": {
-            "id": "4884a4b7-cc19-4fea-83c7-1f940e6edd24",
-            "name": "noise",
-            "type": "LatentsField",
-            "fieldKind": "input",
-            "label": ""
-          },
-          "steps": {
-            "id": "4c61675c-b6b9-41ac-b187-b5c13b587039",
-            "name": "steps",
-            "type": "integer",
-            "fieldKind": "input",
-            "label": "",
-            "value": 36
-          },
-          "cfg_scale": {
-            "id": "f8213f35-4637-4a1a-83f4-1f8cfb9ccd2c",
-            "name": "cfg_scale",
-            "type": "float",
-            "fieldKind": "input",
-            "label": "",
-            "value": 7.5
-          },
-          "denoising_start": {
-            "id": "01e2f30d-0acd-4e21-98b9-a9b8e24c6db2",
-            "name": "denoising_start",
-            "type": "float",
-            "fieldKind": "input",
-            "label": "",
-            "value": 0
-          },
-          "denoising_end": {
-            "id": "3db95479-a73b-4c75-9b44-08daec16b224",
-            "name": "denoising_end",
-            "type": "float",
-            "fieldKind": "input",
-            "label": "",
-            "value": 1
-          },
-          "scheduler": {
-            "id": "db8430a9-64c3-4c54-ae38-9f597cf7b6d5",
-            "name": "scheduler",
-            "type": "Scheduler",
-            "fieldKind": "input",
-            "label": "",
-            "value": "euler"
-          },
-          "control": {
-            "id": "599b49e8-6435-4576-be41-a5155f3a17e3",
-            "name": "control",
-            "type": "ControlField",
+          "metadata": {
+            "id": "88971324-3fdb-442d-b8b7-7612478a8622",
+            "name": "metadata",
+            "type": "MetadataField",
             "fieldKind": "input",
             "label": ""
           },
           "latents": {
-            "id": "226f9e91-454e-4159-9fa6-019c0cf29277",
+            "id": "da0e40cb-c49f-4fa5-9856-338b91a65f6b",
             "name": "latents",
             "type": "LatentsField",
             "fieldKind": "input",
             "label": ""
           },
-          "denoise_mask": {
-            "id": "de019cb6-7fb5-45bf-a266-22e20889893f",
-            "name": "denoise_mask",
-            "type": "DenoiseMaskField",
+          "vae": {
+            "id": "ae5164ce-1710-4ec5-a83a-6113a0d1b5c0",
+            "name": "vae",
+            "type": "VaeField",
             "fieldKind": "input",
             "label": ""
           },
-          "positive_conditioning": {
-            "id": "02fc400a-110d-470e-8411-f404f966a949",
-            "name": "positive_conditioning",
-            "type": "ConditioningField",
+          "tiled": {
+            "id": "2ccfd535-1a7b-4ecf-84db-9430a64fb3d7",
+            "name": "tiled",
+            "type": "boolean",
             "fieldKind": "input",
-            "label": ""
+            "label": "",
+            "value": false
           },
-          "negative_conditioning": {
-            "id": "4bd3bdfa-fcf4-42be-8e47-1e314255798f",
-            "name": "negative_conditioning",
-            "type": "ConditioningField",
+          "fp32": {
+            "id": "64f07d5a-54a2-429c-8c5b-0c2a3a8e5cd5",
+            "name": "fp32",
+            "type": "boolean",
             "fieldKind": "input",
-            "label": ""
-          },
-          "unet": {
-            "id": "7c2d58a8-b5f1-4e63-8ffd-8ada52c35832",
-            "name": "unet",
-            "type": "UNetField",
-            "fieldKind": "input",
-            "label": ""
+            "label": "",
+            "value": false
           }
         },
         "outputs": {
-          "latents": {
-            "id": "6a6fa492-de26-4e95-b1d9-a322fe37eb13",
-            "name": "latents",
-            "type": "LatentsField",
+          "image": {
+            "id": "9b281eaa-6504-407d-a5ca-1e5e8020a4bf",
+            "name": "image",
+            "type": "ImageField",
             "fieldKind": "output"
           },
           "width": {
-            "id": "a9790729-7d6c-4418-903d-4da961fccf56",
+            "id": "98e545f3-b53b-490d-b94d-bed9418ccc75",
             "name": "width",
             "type": "integer",
             "fieldKind": "output"
           },
           "height": {
-            "id": "fa74efe5-7330-4a3c-b256-c82a544585b4",
+            "id": "4a74bd43-d7f7-4c7f-bb3b-d09bb2992c46",
             "name": "height",
             "type": "integer",
             "fieldKind": "output"
@@ -626,13 +502,161 @@
         "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": false,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 558,
+      "height": 267,
       "position": {
-        "x": 1650,
-        "y": -250
+        "x": 2112.5626808057173,
+        "y": -174.24042139280238
+      }
+    },
+    {
+      "id": "50a36525-3c0a-4cc5-977c-e4bfc3fd6dfb",
+      "type": "invocation",
+      "data": {
+        "id": "50a36525-3c0a-4cc5-977c-e4bfc3fd6dfb",
+        "type": "denoise_latents",
+        "inputs": {
+          "positive_conditioning": {
+            "id": "29b73dfa-a06e-4b4a-a844-515b9eb93a81",
+            "name": "positive_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "negative_conditioning": {
+            "id": "a81e6f5b-f4de-4919-b483-b6e2f067465a",
+            "name": "negative_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "noise": {
+            "id": "4ba06bb7-eb45-4fb9-9984-31001b545587",
+            "name": "noise",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "steps": {
+            "id": "36ee8a45-ca69-44bc-9bc3-aa881e6045c0",
+            "name": "steps",
+            "type": "integer",
+            "fieldKind": "input",
+            "label": "",
+            "value": 10
+          },
+          "cfg_scale": {
+            "id": "2a2024e0-a736-46ec-933c-c1c1ebe96943",
+            "name": "cfg_scale",
+            "type": "FloatPolymorphic",
+            "fieldKind": "input",
+            "label": "",
+            "value": 7.5
+          },
+          "denoising_start": {
+            "id": "be219d5e-41b7-430a-8fb5-bc21a31ad219",
+            "name": "denoising_start",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 0
+          },
+          "denoising_end": {
+            "id": "3adfb7ae-c9f7-4a40-b6e0-4c2050bd1a99",
+            "name": "denoising_end",
+            "type": "float",
+            "fieldKind": "input",
+            "label": "",
+            "value": 1
+          },
+          "scheduler": {
+            "id": "14423e0d-7215-4ee0-b065-f9e95eaa8d7d",
+            "name": "scheduler",
+            "type": "Scheduler",
+            "fieldKind": "input",
+            "label": "",
+            "value": "euler"
+          },
+          "unet": {
+            "id": "e73bbf98-6489-492b-b83c-faed215febac",
+            "name": "unet",
+            "type": "UNetField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "control": {
+            "id": "dab351b3-0c86-4ea5-9782-4e8edbfb0607",
+            "name": "control",
+            "type": "ControlPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "ip_adapter": {
+            "id": "192daea0-a90a-43cc-a2ee-0114a8e90318",
+            "name": "ip_adapter",
+            "type": "IPAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "t2i_adapter": {
+            "id": "ee386a55-d4c7-48c1-ac57-7bc4e3aada7a",
+            "name": "t2i_adapter",
+            "type": "T2IAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "latents": {
+            "id": "3a922c6a-3d8c-4c9e-b3ec-2f4d81cda077",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "denoise_mask": {
+            "id": "cd7ce032-835f-495f-8b45-d57272f33132",
+            "name": "denoise_mask",
+            "type": "DenoiseMaskField",
+            "fieldKind": "input",
+            "label": ""
+          }
+        },
+        "outputs": {
+          "latents": {
+            "id": "6260b84f-8361-470a-98d8-5b22a45c2d8c",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "aede0ecf-25b6-46be-aa30-b77f79715deb",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "519abf62-d475-48ef-ab8f-66136bc0e499",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.4.0"
+      },
+      "width": 320,
+      "height": 646,
+      "position": {
+        "x": 1642.955772577545,
+        "y": -230.2485847594651
       }
     }
   ],
@@ -686,50 +710,42 @@
     {
       "source": "30d3289c-773c-4152-a9d2-bd8a99c8fd22",
       "sourceHandle": "vae",
-      "target": "dbcd2f98-d809-48c8-bf64-2635f88a2fe9",
+      "target": "63e91020-83b2-4f35-b174-ad9692aabb48",
       "targetHandle": "vae",
-      "id": "reactflow__edge-30d3289c-773c-4152-a9d2-bd8a99c8fd22vae-dbcd2f98-d809-48c8-bf64-2635f88a2fe9vae",
-      "type": "default"
-    },
-    {
-      "source": "87ee6243-fb0d-4f77-ad5f-56591659339e",
-      "sourceHandle": "latents",
-      "target": "dbcd2f98-d809-48c8-bf64-2635f88a2fe9",
-      "targetHandle": "latents",
-      "id": "reactflow__edge-87ee6243-fb0d-4f77-ad5f-56591659339elatents-dbcd2f98-d809-48c8-bf64-2635f88a2fe9latents",
-      "type": "default"
-    },
-    {
-      "source": "faf965a4-7530-427b-b1f3-4ba6505c2a08",
-      "sourceHandle": "conditioning",
-      "target": "87ee6243-fb0d-4f77-ad5f-56591659339e",
-      "targetHandle": "positive_conditioning",
-      "id": "reactflow__edge-faf965a4-7530-427b-b1f3-4ba6505c2a08conditioning-87ee6243-fb0d-4f77-ad5f-56591659339epositive_conditioning",
-      "type": "default"
-    },
-    {
-      "source": "3193ad09-a7c2-4bf4-a3a9-1c61cc33a204",
-      "sourceHandle": "conditioning",
-      "target": "87ee6243-fb0d-4f77-ad5f-56591659339e",
-      "targetHandle": "negative_conditioning",
-      "id": "reactflow__edge-3193ad09-a7c2-4bf4-a3a9-1c61cc33a204conditioning-87ee6243-fb0d-4f77-ad5f-56591659339enegative_conditioning",
+      "id": "reactflow__edge-30d3289c-773c-4152-a9d2-bd8a99c8fd22vae-63e91020-83b2-4f35-b174-ad9692aabb48vae",
       "type": "default"
     },
     {
       "source": "30d3289c-773c-4152-a9d2-bd8a99c8fd22",
       "sourceHandle": "unet",
-      "target": "87ee6243-fb0d-4f77-ad5f-56591659339e",
+      "target": "50a36525-3c0a-4cc5-977c-e4bfc3fd6dfb",
       "targetHandle": "unet",
-      "id": "reactflow__edge-30d3289c-773c-4152-a9d2-bd8a99c8fd22unet-87ee6243-fb0d-4f77-ad5f-56591659339eunet",
+      "id": "reactflow__edge-30d3289c-773c-4152-a9d2-bd8a99c8fd22unet-50a36525-3c0a-4cc5-977c-e4bfc3fd6dfbunet",
+      "type": "default"
+    },
+    {
+      "source": "faf965a4-7530-427b-b1f3-4ba6505c2a08",
+      "sourceHandle": "conditioning",
+      "target": "50a36525-3c0a-4cc5-977c-e4bfc3fd6dfb",
+      "targetHandle": "positive_conditioning",
+      "id": "reactflow__edge-faf965a4-7530-427b-b1f3-4ba6505c2a08conditioning-50a36525-3c0a-4cc5-977c-e4bfc3fd6dfbpositive_conditioning",
+      "type": "default"
+    },
+    {
+      "source": "3193ad09-a7c2-4bf4-a3a9-1c61cc33a204",
+      "sourceHandle": "conditioning",
+      "target": "50a36525-3c0a-4cc5-977c-e4bfc3fd6dfb",
+      "targetHandle": "negative_conditioning",
+      "id": "reactflow__edge-3193ad09-a7c2-4bf4-a3a9-1c61cc33a204conditioning-50a36525-3c0a-4cc5-977c-e4bfc3fd6dfbnegative_conditioning",
       "type": "default"
     },
     {
       "source": "55705012-79b9-4aac-9f26-c0b10309785b",
       "sourceHandle": "noise",
-      "target": "87ee6243-fb0d-4f77-ad5f-56591659339e",
+      "target": "50a36525-3c0a-4cc5-977c-e4bfc3fd6dfb",
       "targetHandle": "noise",
-      "id": "reactflow__edge-55705012-79b9-4aac-9f26-c0b10309785bnoise-87ee6243-fb0d-4f77-ad5f-56591659339enoise",
+      "id": "reactflow__edge-55705012-79b9-4aac-9f26-c0b10309785bnoise-50a36525-3c0a-4cc5-977c-e4bfc3fd6dfbnoise",
       "type": "default"
     }
   ]
-}
+}

docs/workflows/Text_to_Image.json

@@ -18,10 +18,6 @@
     {
       "nodeId": "93dc02a4-d05b-48ed-b99c-c9b616af3402",
       "fieldName": "prompt"
-    },
-    {
-      "nodeId": "75899702-fa44-46d2-b2d5-3e17f234c3e7",
-      "fieldName": "steps"
     }
   ],
   "meta": {
@@ -32,7 +28,6 @@
       "id": "93dc02a4-d05b-48ed-b99c-c9b616af3402",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "93dc02a4-d05b-48ed-b99c-c9b616af3402",
         "type": "compel",
         "inputs": {
@@ -64,20 +59,21 @@
         "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 235,
+      "height": 261,
       "position": {
-        "x": 1400,
-        "y": -75
+        "x": 995.7263915923627,
+        "y": 239.67783573351227
       }
     },
     {
       "id": "55705012-79b9-4aac-9f26-c0b10309785b",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "55705012-79b9-4aac-9f26-c0b10309785b",
         "type": "noise",
         "inputs": {
@@ -138,92 +134,21 @@
         "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 364,
+      "height": 389,
       "position": {
-        "x": 1000,
-        "y": 350
-      }
-    },
-    {
-      "id": "dbcd2f98-d809-48c8-bf64-2635f88a2fe9",
-      "type": "invocation",
-      "data": {
-        "version": "1.0.0",
-        "id": "dbcd2f98-d809-48c8-bf64-2635f88a2fe9",
-        "type": "l2i",
-        "inputs": {
-          "tiled": {
-            "id": "24f5bc7b-f6a1-425d-8ab1-f50b4db5d0df",
-            "name": "tiled",
-            "type": "boolean",
-            "fieldKind": "input",
-            "label": "",
-            "value": false
-          },
-          "fp32": {
-            "id": "b146d873-ffb9-4767-986a-5360504841a2",
-            "name": "fp32",
-            "type": "boolean",
-            "fieldKind": "input",
-            "label": "",
-            "value": false
-          },
-          "latents": {
-            "id": "65441abd-7713-4b00-9d8d-3771404002e8",
-            "name": "latents",
-            "type": "LatentsField",
-            "fieldKind": "input",
-            "label": ""
-          },
-          "vae": {
-            "id": "a478b833-6e13-4611-9a10-842c89603c74",
-            "name": "vae",
-            "type": "VaeField",
-            "fieldKind": "input",
-            "label": ""
-          }
-        },
-        "outputs": {
-          "image": {
-            "id": "c87ae925-f858-417a-8940-8708ba9b4b53",
-            "name": "image",
-            "type": "ImageField",
-            "fieldKind": "output"
-          },
-          "width": {
-            "id": "4bcb8512-b5a1-45f1-9e52-6e92849f9d6c",
-            "name": "width",
-            "type": "integer",
-            "fieldKind": "output"
-          },
-          "height": {
-            "id": "23e41c00-a354-48e8-8f59-5875679c27ab",
-            "name": "height",
-            "type": "integer",
-            "fieldKind": "output"
-          }
-        },
-        "label": "",
-        "isOpen": true,
-        "notes": "",
-        "embedWorkflow": true,
-        "isIntermediate": false
-      },
-      "width": 320,
-      "height": 266,
-      "position": {
-        "x": 1800,
-        "y": 200
+        "x": 993.4442117555518,
+        "y": 605.6757415334787
       }
     },
     {
       "id": "c8d55139-f380-4695-b7f2-8b3d1e1e3db8",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "c8d55139-f380-4695-b7f2-8b3d1e1e3db8",
         "type": "main_model_loader",
         "inputs": {
@@ -261,23 +186,24 @@
           }
         },
         "label": "",
-        "isOpen": false,
+        "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 32,
+      "height": 226,
       "position": {
-        "x": 1000,
-        "y": 200
+        "x": 163.04436745878343,
+        "y": 254.63156870373479
       }
     },
     {
       "id": "7d8bf987-284f-413a-b2fd-d825445a5d6c",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "7d8bf987-284f-413a-b2fd-d825445a5d6c",
         "type": "compel",
         "inputs": {
@@ -309,20 +235,21 @@
         "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 235,
+      "height": 261,
       "position": {
-        "x": 1000,
-        "y": -75
+        "x": 595.7263915923627,
+        "y": 239.67783573351227
       }
     },
     {
       "id": "ea94bc37-d995-4a83-aa99-4af42479f2f2",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
         "id": "ea94bc37-d995-4a83-aa99-4af42479f2f2",
         "type": "rand_int",
         "inputs": {
@@ -352,51 +279,66 @@
           }
         },
         "label": "Random Seed",
-        "isOpen": false,
+        "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": false,
+        "version": "1.0.0"
       },
       "width": 320,
-      "height": 32,
+      "height": 218,
       "position": {
-        "x": 1000,
-        "y": 275
+        "x": 541.094822888628,
+        "y": 694.5704476446829
       }
     },
     {
-      "id": "75899702-fa44-46d2-b2d5-3e17f234c3e7",
+      "id": "eea2702a-19fb-45b5-9d75-56b4211ec03c",
       "type": "invocation",
       "data": {
-        "version": "1.0.0",
-        "id": "75899702-fa44-46d2-b2d5-3e17f234c3e7",
+        "id": "eea2702a-19fb-45b5-9d75-56b4211ec03c",
         "type": "denoise_latents",
         "inputs": {
+          "positive_conditioning": {
+            "id": "90b7f4f8-ada7-4028-8100-d2e54f192052",
+            "name": "positive_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "negative_conditioning": {
+            "id": "9393779e-796c-4f64-b740-902a1177bf53",
+            "name": "negative_conditioning",
+            "type": "ConditioningField",
+            "fieldKind": "input",
+            "label": ""
+          },
           "noise": {
-            "id": "8b18f3eb-40d2-45c1-9a9d-28d6af0dce2b",
+            "id": "8e17f1e5-4f98-40b1-b7f4-86aeeb4554c1",
             "name": "noise",
             "type": "LatentsField",
             "fieldKind": "input",
             "label": ""
           },
           "steps": {
-            "id": "0be4373c-46f3-441c-80a7-a4bb6ceb498c",
+            "id": "9b63302d-6bd2-42c9-ac13-9b1afb51af88",
             "name": "steps",
             "type": "integer",
             "fieldKind": "input",
             "label": "",
-            "value": 36
+            "value": 10
           },
           "cfg_scale": {
-            "id": "107267ce-4666-4cd7-94b3-7476b7973ae9",
+            "id": "87dd04d3-870e-49e1-98bf-af003a810109",
             "name": "cfg_scale",
-            "type": "float",
+            "type": "FloatPolymorphic",
             "fieldKind": "input",
             "label": "",
             "value": 7.5
           },
           "denoising_start": {
-            "id": "d2ce9f0f-5fc2-48b2-b917-53442941e9a1",
+            "id": "f369d80f-4931-4740-9bcd-9f0620719fab",
             "name": "denoising_start",
             "type": "float",
             "fieldKind": "input",
@@ -404,7 +346,7 @@
             "value": 0
           },
           "denoising_end": {
-            "id": "8ad51505-b8d0-422a-beb8-96fc6fc6b65f",
+            "id": "747d10e5-6f02-445c-994c-0604d814de8c",
             "name": "denoising_end",
             "type": "float",
             "fieldKind": "input",
@@ -412,71 +354,71 @@
             "value": 1
           },
           "scheduler": {
-            "id": "53092874-a43b-4623-91a2-76e62fdb1f2e",
+            "id": "1de84a4e-3a24-4ec8-862b-16ce49633b9b",
             "name": "scheduler",
             "type": "Scheduler",
             "fieldKind": "input",
             "label": "",
             "value": "euler"
           },
+          "unet": {
+            "id": "ffa6fef4-3ce2-4bdb-9296-9a834849489b",
+            "name": "unet",
+            "type": "UNetField",
+            "fieldKind": "input",
+            "label": ""
+          },
           "control": {
-            "id": "7abe57cc-469d-437e-ad72-a18efa28215f",
+            "id": "077b64cb-34be-4fcc-83f2-e399807a02bd",
             "name": "control",
-            "type": "ControlField",
+            "type": "ControlPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "ip_adapter": {
+            "id": "1d6948f7-3a65-4a65-a20c-768b287251aa",
+            "name": "ip_adapter",
+            "type": "IPAdapterPolymorphic",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "t2i_adapter": {
+            "id": "75e67b09-952f-4083-aaf4-6b804d690412",
+            "name": "t2i_adapter",
+            "type": "T2IAdapterPolymorphic",
             "fieldKind": "input",
             "label": ""
           },
           "latents": {
-            "id": "add8bbe5-14d0-42d4-a867-9c65ab8dd129",
+            "id": "334d4ba3-5a99-4195-82c5-86fb3f4f7d43",
             "name": "latents",
             "type": "LatentsField",
             "fieldKind": "input",
             "label": ""
           },
           "denoise_mask": {
-            "id": "f373a190-0fc8-45b7-ae62-c4aa8e9687e1",
+            "id": "0d3dbdbf-b014-4e95-8b18-ff2ff9cb0bfa",
             "name": "denoise_mask",
             "type": "DenoiseMaskField",
             "fieldKind": "input",
             "label": ""
-          },
-          "positive_conditioning": {
-            "id": "c7160303-8a23-4f15-9197-855d48802a7f",
-            "name": "positive_conditioning",
-            "type": "ConditioningField",
-            "fieldKind": "input",
-            "label": ""
-          },
-          "negative_conditioning": {
-            "id": "fd750efa-1dfc-4d0b-accb-828e905ba320",
-            "name": "negative_conditioning",
-            "type": "ConditioningField",
-            "fieldKind": "input",
-            "label": ""
-          },
-          "unet": {
-            "id": "af1f41ba-ce2a-4314-8d7f-494bb5800381",
-            "name": "unet",
-            "type": "UNetField",
-            "fieldKind": "input",
-            "label": ""
           }
         },
         "outputs": {
           "latents": {
-            "id": "8508d04d-f999-4a44-94d0-388ab1401d27",
+            "id": "70fa5bbc-0c38-41bb-861a-74d6d78d2f38",
             "name": "latents",
             "type": "LatentsField",
             "fieldKind": "output"
           },
           "width": {
-            "id": "93dc8287-0a2a-4320-83a4-5e994b7ba23e",
+            "id": "98ee0e6c-82aa-4e8f-8be5-dc5f00ee47f0",
             "name": "width",
             "type": "integer",
             "fieldKind": "output"
           },
           "height": {
-            "id": "d9862f5c-0ab5-46fa-8c29-5059bb581d96",
+            "id": "e8cb184a-5e1a-47c8-9695-4b8979564f5d",
             "name": "height",
             "type": "integer",
             "fieldKind": "output"
@@ -486,13 +428,95 @@
         "isOpen": true,
         "notes": "",
         "embedWorkflow": false,
-        "isIntermediate": true
+        "isIntermediate": true,
+        "useCache": true,
+        "version": "1.4.0"
       },
       "width": 320,
-      "height": 558,
+      "height": 646,
       "position": {
-        "x": 1400,
-        "y": 200
+        "x": 1476.5794704734735,
+        "y": 256.80174342731783
+      }
+    },
+    {
+      "id": "58c957f5-0d01-41fc-a803-b2bbf0413d4f",
+      "type": "invocation",
+      "data": {
+        "id": "58c957f5-0d01-41fc-a803-b2bbf0413d4f",
+        "type": "l2i",
+        "inputs": {
+          "metadata": {
+            "id": "ab375f12-0042-4410-9182-29e30db82c85",
+            "name": "metadata",
+            "type": "MetadataField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "latents": {
+            "id": "3a7e7efd-bff5-47d7-9d48-615127afee78",
+            "name": "latents",
+            "type": "LatentsField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "vae": {
+            "id": "a1f5f7a1-0795-4d58-b036-7820c0b0ef2b",
+            "name": "vae",
+            "type": "VaeField",
+            "fieldKind": "input",
+            "label": ""
+          },
+          "tiled": {
+            "id": "da52059a-0cee-4668-942f-519aa794d739",
+            "name": "tiled",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": false
+          },
+          "fp32": {
+            "id": "c4841df3-b24e-4140-be3b-ccd454c2522c",
+            "name": "fp32",
+            "type": "boolean",
+            "fieldKind": "input",
+            "label": "",
+            "value": false
+          }
+        },
+        "outputs": {
+          "image": {
+            "id": "72d667d0-cf85-459d-abf2-28bd8b823fe7",
+            "name": "image",
+            "type": "ImageField",
+            "fieldKind": "output"
+          },
+          "width": {
+            "id": "c8c907d8-1066-49d1-b9a6-83bdcd53addc",
+            "name": "width",
+            "type": "integer",
+            "fieldKind": "output"
+          },
+          "height": {
+            "id": "230f359c-b4ea-436c-b372-332d7dcdca85",
+            "name": "height",
+            "type": "integer",
+            "fieldKind": "output"
+          }
+        },
+        "label": "",
+        "isOpen": true,
+        "notes": "",
+        "embedWorkflow": false,
+        "isIntermediate": false,
+        "useCache": true,
+        "version": "1.0.0"
+      },
+      "width": 320,
+      "height": 267,
+      "position": {
+        "x": 2037.9648469717395,
+        "y": 426.10844427600136
       }
     }
   ],
@@ -522,52 +546,52 @@
       "type": "default"
     },
     {
-      "source": "c8d55139-f380-4695-b7f2-8b3d1e1e3db8",
-      "sourceHandle": "vae",
-      "target": "dbcd2f98-d809-48c8-bf64-2635f88a2fe9",
-      "targetHandle": "vae",
-      "id": "reactflow__edge-c8d55139-f380-4695-b7f2-8b3d1e1e3db8vae-dbcd2f98-d809-48c8-bf64-2635f88a2fe9vae",
-      "type": "default"
-    },
-    {
-      "source": "75899702-fa44-46d2-b2d5-3e17f234c3e7",
-      "sourceHandle": "latents",
-      "target": "dbcd2f98-d809-48c8-bf64-2635f88a2fe9",
-      "targetHandle": "latents",
-      "id": "reactflow__edge-75899702-fa44-46d2-b2d5-3e17f234c3e7latents-dbcd2f98-d809-48c8-bf64-2635f88a2fe9latents",
+      "source": "55705012-79b9-4aac-9f26-c0b10309785b",
+      "sourceHandle": "noise",
+      "target": "eea2702a-19fb-45b5-9d75-56b4211ec03c",
+      "targetHandle": "noise",
+      "id": "reactflow__edge-55705012-79b9-4aac-9f26-c0b10309785bnoise-eea2702a-19fb-45b5-9d75-56b4211ec03cnoise",
       "type": "default"
     },
     {
       "source": "7d8bf987-284f-413a-b2fd-d825445a5d6c",
       "sourceHandle": "conditioning",
-      "target": "75899702-fa44-46d2-b2d5-3e17f234c3e7",
+      "target": "eea2702a-19fb-45b5-9d75-56b4211ec03c",
       "targetHandle": "positive_conditioning",
-      "id": "reactflow__edge-7d8bf987-284f-413a-b2fd-d825445a5d6cconditioning-75899702-fa44-46d2-b2d5-3e17f234c3e7positive_conditioning",
+      "id": "reactflow__edge-7d8bf987-284f-413a-b2fd-d825445a5d6cconditioning-eea2702a-19fb-45b5-9d75-56b4211ec03cpositive_conditioning",
       "type": "default"
     },
     {
       "source": "93dc02a4-d05b-48ed-b99c-c9b616af3402",
       "sourceHandle": "conditioning",
-      "target": "75899702-fa44-46d2-b2d5-3e17f234c3e7",
+      "target": "eea2702a-19fb-45b5-9d75-56b4211ec03c",
       "targetHandle": "negative_conditioning",
-      "id": "reactflow__edge-93dc02a4-d05b-48ed-b99c-c9b616af3402conditioning-75899702-fa44-46d2-b2d5-3e17f234c3e7negative_conditioning",
+      "id": "reactflow__edge-93dc02a4-d05b-48ed-b99c-c9b616af3402conditioning-eea2702a-19fb-45b5-9d75-56b4211ec03cnegative_conditioning",
       "type": "default"
     },
     {
       "source": "c8d55139-f380-4695-b7f2-8b3d1e1e3db8",
       "sourceHandle": "unet",
-      "target": "75899702-fa44-46d2-b2d5-3e17f234c3e7",
+      "target": "eea2702a-19fb-45b5-9d75-56b4211ec03c",
       "targetHandle": "unet",
-      "id": "reactflow__edge-c8d55139-f380-4695-b7f2-8b3d1e1e3db8unet-75899702-fa44-46d2-b2d5-3e17f234c3e7unet",
+      "id": "reactflow__edge-c8d55139-f380-4695-b7f2-8b3d1e1e3db8unet-eea2702a-19fb-45b5-9d75-56b4211ec03cunet",
       "type": "default"
     },
     {
-      "source": "55705012-79b9-4aac-9f26-c0b10309785b",
-      "sourceHandle": "noise",
-      "target": "75899702-fa44-46d2-b2d5-3e17f234c3e7",
-      "targetHandle": "noise",
-      "id": "reactflow__edge-55705012-79b9-4aac-9f26-c0b10309785bnoise-75899702-fa44-46d2-b2d5-3e17f234c3e7noise",
+      "source": "eea2702a-19fb-45b5-9d75-56b4211ec03c",
+      "sourceHandle": "latents",
+      "target": "58c957f5-0d01-41fc-a803-b2bbf0413d4f",
+      "targetHandle": "latents",
+      "id": "reactflow__edge-eea2702a-19fb-45b5-9d75-56b4211ec03clatents-58c957f5-0d01-41fc-a803-b2bbf0413d4flatents",
+      "type": "default"
+    },
+    {
+      "source": "c8d55139-f380-4695-b7f2-8b3d1e1e3db8",
+      "sourceHandle": "vae",
+      "target": "58c957f5-0d01-41fc-a803-b2bbf0413d4f",
+      "targetHandle": "vae",
+      "id": "reactflow__edge-c8d55139-f380-4695-b7f2-8b3d1e1e3db8vae-58c957f5-0d01-41fc-a803-b2bbf0413d4fvae",
       "type": "default"
     }
   ]
-}
+}

installer/lib/installer.py

@@ -244,7 +244,7 @@ class InvokeAiInstance:
                 "numpy~=1.24.0",  # choose versions that won't be uninstalled during phase 2
                 "urllib3~=1.26.0",
                 "requests~=2.28.0",
-                "torch~=2.0.0",
+                "torch~=2.1.0",
                 "torchmetrics==0.11.4",
                 "torchvision>=0.14.1",
                 "--force-reinstall",
@@ -460,10 +460,10 @@ def get_torch_source() -> (Union[str, None], str):
             url = "https://download.pytorch.org/whl/cpu"
 
     if device == "cuda":
-        url = "https://download.pytorch.org/whl/cu118"
+        url = "https://download.pytorch.org/whl/cu121"
         optional_modules = "[xformers,onnx-cuda]"
     if device == "cuda_and_dml":
-        url = "https://download.pytorch.org/whl/cu118"
+        url = "https://download.pytorch.org/whl/cu121"
         optional_modules = "[xformers,onnx-directml]"
 
     # in all other cases, Torch wheels should be coming from PyPi as of Torch 1.13

installer/lib/messages.py

@@ -137,7 +137,7 @@ def dest_path(dest=None) -> Path:
         path_completer = PathCompleter(
             only_directories=True,
             expanduser=True,
-            get_paths=lambda: [browse_start],
+            get_paths=lambda: [browse_start],  # noqa: B023
             # get_paths=lambda: [".."].extend(list(browse_start.iterdir()))
         )
 
@@ -149,7 +149,7 @@ def dest_path(dest=None) -> Path:
             completer=path_completer,
             default=str(browse_start) + os.sep,
             vi_mode=True,
-            complete_while_typing=True
+            complete_while_typing=True,
             # Test that this is not needed on Windows
             # complete_style=CompleteStyle.READLINE_LIKE,
         )

invokeai/app/api/dependencies.py

@@ -24,6 +24,7 @@ from ..services.item_storage.item_storage_sqlite import SqliteItemStorage
 from ..services.latents_storage.latents_storage_disk import DiskLatentsStorage
 from ..services.latents_storage.latents_storage_forward_cache import ForwardCacheLatentsStorage
 from ..services.model_manager.model_manager_default import ModelManagerService
+from ..services.model_records import ModelRecordServiceSQL
 from ..services.names.names_default import SimpleNameService
 from ..services.session_processor.session_processor_default import DefaultSessionProcessor
 from ..services.session_queue.session_queue_sqlite import SqliteSessionQueue
@@ -85,6 +86,7 @@ class ApiDependencies:
         invocation_cache = MemoryInvocationCache(max_cache_size=config.node_cache_size)
         latents = ForwardCacheLatentsStorage(DiskLatentsStorage(f"{output_folder}/latents"))
         model_manager = ModelManagerService(config, logger)
+        model_record_service = ModelRecordServiceSQL(db=db)
         names = SimpleNameService()
         performance_statistics = InvocationStatsService()
         processor = DefaultInvocationProcessor()
@@ -111,6 +113,7 @@ class ApiDependencies:
             latents=latents,
             logger=logger,
             model_manager=model_manager,
+            model_records=model_record_service,
             names=names,
             performance_statistics=performance_statistics,
             processor=processor,

invokeai/app/api/events.py

@@ -28,7 +28,7 @@ class FastAPIEventService(EventServiceBase):
         self.__queue.put(None)
 
     def dispatch(self, event_name: str, payload: Any) -> None:
-        self.__queue.put(dict(event_name=event_name, payload=payload))
+        self.__queue.put({"event_name": event_name, "payload": payload})
 
     async def __dispatch_from_queue(self, stop_event: threading.Event):
         """Get events on from the queue and dispatch them, from the correct thread"""

invokeai/app/api/routers/model_records.py

@@ -0,0 +1,164 @@
+# Copyright (c) 2023 Lincoln D. Stein
+"""FastAPI route for model configuration records."""
+
+
+from hashlib import sha1
+from random import randbytes
+from typing import List, Optional
+
+from fastapi import Body, Path, Query, Response
+from fastapi.routing import APIRouter
+from pydantic import BaseModel, ConfigDict
+from starlette.exceptions import HTTPException
+from typing_extensions import Annotated
+
+from invokeai.app.services.model_records import (
+    DuplicateModelException,
+    InvalidModelException,
+    UnknownModelException,
+)
+from invokeai.backend.model_manager.config import (
+    AnyModelConfig,
+    BaseModelType,
+    ModelType,
+)
+
+from ..dependencies import ApiDependencies
+
+model_records_router = APIRouter(prefix="/v1/model/record", tags=["models"])
+
+
+class ModelsList(BaseModel):
+    """Return list of configs."""
+
+    models: list[AnyModelConfig]
+
+    model_config = ConfigDict(use_enum_values=True)
+
+
+@model_records_router.get(
+    "/",
+    operation_id="list_model_records",
+)
+async def list_model_records(
+    base_models: Optional[List[BaseModelType]] = Query(default=None, description="Base models to include"),
+    model_type: Optional[ModelType] = Query(default=None, description="The type of model to get"),
+) -> ModelsList:
+    """Get a list of models."""
+    record_store = ApiDependencies.invoker.services.model_records
+    found_models: list[AnyModelConfig] = []
+    if base_models:
+        for base_model in base_models:
+            found_models.extend(record_store.search_by_attr(base_model=base_model, model_type=model_type))
+    else:
+        found_models.extend(record_store.search_by_attr(model_type=model_type))
+    return ModelsList(models=found_models)
+
+
+@model_records_router.get(
+    "/i/{key}",
+    operation_id="get_model_record",
+    responses={
+        200: {"description": "Success"},
+        400: {"description": "Bad request"},
+        404: {"description": "The model could not be found"},
+    },
+)
+async def get_model_record(
+    key: str = Path(description="Key of the model record to fetch."),
+) -> AnyModelConfig:
+    """Get a model record"""
+    record_store = ApiDependencies.invoker.services.model_records
+    try:
+        return record_store.get_model(key)
+    except UnknownModelException as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@model_records_router.patch(
+    "/i/{key}",
+    operation_id="update_model_record",
+    responses={
+        200: {"description": "The model was updated successfully"},
+        400: {"description": "Bad request"},
+        404: {"description": "The model could not be found"},
+        409: {"description": "There is already a model corresponding to the new name"},
+    },
+    status_code=200,
+    response_model=AnyModelConfig,
+)
+async def update_model_record(
+    key: Annotated[str, Path(description="Unique key of model")],
+    info: Annotated[AnyModelConfig, Body(description="Model config", discriminator="type")],
+) -> AnyModelConfig:
+    """Update model contents with a new config. If the model name or base fields are changed, then the model is renamed."""
+    logger = ApiDependencies.invoker.services.logger
+    record_store = ApiDependencies.invoker.services.model_records
+    try:
+        model_response = record_store.update_model(key, config=info)
+        logger.info(f"Updated model: {key}")
+    except UnknownModelException as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except ValueError as e:
+        logger.error(str(e))
+        raise HTTPException(status_code=409, detail=str(e))
+    return model_response
+
+
+@model_records_router.delete(
+    "/i/{key}",
+    operation_id="del_model_record",
+    responses={
+        204: {"description": "Model deleted successfully"},
+        404: {"description": "Model not found"},
+    },
+    status_code=204,
+)
+async def del_model_record(
+    key: str = Path(description="Unique key of model to remove from model registry."),
+) -> Response:
+    """Delete Model"""
+    logger = ApiDependencies.invoker.services.logger
+
+    try:
+        record_store = ApiDependencies.invoker.services.model_records
+        record_store.del_model(key)
+        logger.info(f"Deleted model: {key}")
+        return Response(status_code=204)
+    except UnknownModelException as e:
+        logger.error(str(e))
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@model_records_router.post(
+    "/i/",
+    operation_id="add_model_record",
+    responses={
+        201: {"description": "The model added successfully"},
+        409: {"description": "There is already a model corresponding to this path or repo_id"},
+        415: {"description": "Unrecognized file/folder format"},
+    },
+    status_code=201,
+)
+async def add_model_record(
+    config: Annotated[AnyModelConfig, Body(description="Model config", discriminator="type")]
+) -> AnyModelConfig:
+    """
+    Add a model using the configuration information appropriate for its type.
+    """
+    logger = ApiDependencies.invoker.services.logger
+    record_store = ApiDependencies.invoker.services.model_records
+    if config.key == "<NOKEY>":
+        config.key = sha1(randbytes(100)).hexdigest()
+        logger.info(f"Created model {config.key} for {config.name}")
+    try:
+        record_store.add_model(config.key, config)
+    except DuplicateModelException as e:
+        logger.error(str(e))
+        raise HTTPException(status_code=409, detail=str(e))
+    except InvalidModelException as e:
+        logger.error(str(e))
+        raise HTTPException(status_code=415)
+
+    # now fetch it out
+    return record_store.get_model(config.key)

invokeai/app/api/routers/models.py

@@ -1,6 +1,5 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654), 2023 Kent Keirsey (https://github.com/hipsterusername), 2023 Lincoln D. Stein
 
-
 import pathlib
 from typing import Annotated, List, Literal, Optional, Union
 
@@ -55,7 +54,7 @@ async def list_models(
 ) -> ModelsList:
     """Gets a list of models"""
     if base_models and len(base_models) > 0:
-        models_raw = list()
+        models_raw = []
         for base_model in base_models:
             models_raw.extend(ApiDependencies.invoker.services.model_manager.list_models(base_model, model_type))
     else:

invokeai/app/api/sockets.py

@@ -34,4 +34,4 @@ class SocketIO:
 
     async def _handle_unsub_queue(self, sid, data, *args, **kwargs):
         if "queue_id" in data:
-            await self.__sio.enter_room(sid, data["queue_id"])
+            await self.__sio.leave_room(sid, data["queue_id"])

invokeai/app/api_app.py

@@ -43,6 +43,7 @@ if True:  # hack to make flake8 happy with imports coming after setting up the c
         board_images,
         boards,
         images,
+        model_records,
         models,
         session_queue,
         sessions,
@@ -106,6 +107,7 @@ app.include_router(sessions.session_router, prefix="/api")
 
 app.include_router(utilities.utilities_router, prefix="/api")
 app.include_router(models.models_router, prefix="/api")
+app.include_router(model_records.model_records_router, prefix="/api")
 app.include_router(images.images_router, prefix="/api")
 app.include_router(boards.boards_router, prefix="/api")
 app.include_router(board_images.board_images_router, prefix="/api")
@@ -130,7 +132,7 @@ def custom_openapi() -> dict[str, Any]:
     # Add all outputs
     all_invocations = BaseInvocation.get_invocations()
     output_types = set()
-    output_type_titles = dict()
+    output_type_titles = {}
     for invoker in all_invocations:
         output_type = signature(invoker.invoke).return_annotation
         output_types.add(output_type)
@@ -171,12 +173,12 @@ def custom_openapi() -> dict[str, Any]:
             # print(f"Config with name {name} already defined")
             continue
 
-        openapi_schema["components"]["schemas"][name] = dict(
-            title=name,
-            description="An enumeration.",
-            type="string",
-            enum=list(v.value for v in model_config_format_enum),
-        )
+        openapi_schema["components"]["schemas"][name] = {
+            "title": name,
+            "description": "An enumeration.",
+            "type": "string",
+            "enum": [v.value for v in model_config_format_enum],
+        }
 
     app.openapi_schema = openapi_schema
     return app.openapi_schema

invokeai/app/invocations/__init__.py

@@ -25,4 +25,4 @@ spec.loader.exec_module(module)
 
 # add core nodes to __all__
 python_files = filter(lambda f: not f.name.startswith("_"), Path(__file__).parent.glob("*.py"))
-__all__ = list(f.stem for f in python_files)  # type: ignore
+__all__ = [f.stem for f in python_files]  # type: ignore

invokeai/app/invocations/baseinvocation.py

@@ -16,6 +16,7 @@ from pydantic.fields import FieldInfo, _Unset
 from pydantic_core import PydanticUndefined
 
 from invokeai.app.services.config.config_default import InvokeAIAppConfig
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.util.misc import uuid_string
 
 if TYPE_CHECKING:
@@ -30,70 +31,6 @@ class InvalidFieldError(TypeError):
     pass
 
 
-class FieldDescriptions:
-    denoising_start = "When to start denoising, expressed a percentage of total steps"
-    denoising_end = "When to stop denoising, expressed a percentage of total steps"
-    cfg_scale = "Classifier-Free Guidance scale"
-    scheduler = "Scheduler to use during inference"
-    positive_cond = "Positive conditioning tensor"
-    negative_cond = "Negative conditioning tensor"
-    noise = "Noise tensor"
-    clip = "CLIP (tokenizer, text encoder, LoRAs) and skipped layer count"
-    unet = "UNet (scheduler, LoRAs)"
-    vae = "VAE"
-    cond = "Conditioning tensor"
-    controlnet_model = "ControlNet model to load"
-    vae_model = "VAE model to load"
-    lora_model = "LoRA model to load"
-    main_model = "Main model (UNet, VAE, CLIP) to load"
-    sdxl_main_model = "SDXL Main model (UNet, VAE, CLIP1, CLIP2) to load"
-    sdxl_refiner_model = "SDXL Refiner Main Modde (UNet, VAE, CLIP2) to load"
-    onnx_main_model = "ONNX Main model (UNet, VAE, CLIP) to load"
-    lora_weight = "The weight at which the LoRA is applied to each model"
-    compel_prompt = "Prompt to be parsed by Compel to create a conditioning tensor"
-    raw_prompt = "Raw prompt text (no parsing)"
-    sdxl_aesthetic = "The aesthetic score to apply to the conditioning tensor"
-    skipped_layers = "Number of layers to skip in text encoder"
-    seed = "Seed for random number generation"
-    steps = "Number of steps to run"
-    width = "Width of output (px)"
-    height = "Height of output (px)"
-    control = "ControlNet(s) to apply"
-    ip_adapter = "IP-Adapter to apply"
-    t2i_adapter = "T2I-Adapter(s) to apply"
-    denoised_latents = "Denoised latents tensor"
-    latents = "Latents tensor"
-    strength = "Strength of denoising (proportional to steps)"
-    metadata = "Optional metadata to be saved with the image"
-    metadata_collection = "Collection of Metadata"
-    metadata_item_polymorphic = "A single metadata item or collection of metadata items"
-    metadata_item_label = "Label for this metadata item"
-    metadata_item_value = "The value for this metadata item (may be any type)"
-    workflow = "Optional workflow to be saved with the image"
-    interp_mode = "Interpolation mode"
-    torch_antialias = "Whether or not to apply antialiasing (bilinear or bicubic only)"
-    fp32 = "Whether or not to use full float32 precision"
-    precision = "Precision to use"
-    tiled = "Processing using overlapping tiles (reduce memory consumption)"
-    detect_res = "Pixel resolution for detection"
-    image_res = "Pixel resolution for output image"
-    safe_mode = "Whether or not to use safe mode"
-    scribble_mode = "Whether or not to use scribble mode"
-    scale_factor = "The factor by which to scale"
-    blend_alpha = (
-        "Blending factor. 0.0 = use input A only, 1.0 = use input B only, 0.5 = 50% mix of input A and input B."
-    )
-    num_1 = "The first number"
-    num_2 = "The second number"
-    mask = "The mask to use for the operation"
-    board = "The board to save the image to"
-    image = "The image to process"
-    tile_size = "Tile size"
-    inclusive_low = "The inclusive low value"
-    exclusive_high = "The exclusive high value"
-    decimal_places = "The number of decimal places to round to"
-
-
 class Input(str, Enum):
     """
     The type of input a field accepts.
@@ -299,35 +236,35 @@ def InputField(
       Ignored for non-collection fields.
     """
 
-    json_schema_extra_: dict[str, Any] = dict(
-        input=input,
-        ui_type=ui_type,
-        ui_component=ui_component,
-        ui_hidden=ui_hidden,
-        ui_order=ui_order,
-        item_default=item_default,
-        ui_choice_labels=ui_choice_labels,
-        _field_kind="input",
-    )
+    json_schema_extra_: dict[str, Any] = {
+        "input": input,
+        "ui_type": ui_type,
+        "ui_component": ui_component,
+        "ui_hidden": ui_hidden,
+        "ui_order": ui_order,
+        "item_default": item_default,
+        "ui_choice_labels": ui_choice_labels,
+        "_field_kind": "input",
+    }
 
-    field_args = dict(
-        default=default,
-        default_factory=default_factory,
-        title=title,
-        description=description,
-        pattern=pattern,
-        strict=strict,
-        gt=gt,
-        ge=ge,
-        lt=lt,
-        le=le,
-        multiple_of=multiple_of,
-        allow_inf_nan=allow_inf_nan,
-        max_digits=max_digits,
-        decimal_places=decimal_places,
-        min_length=min_length,
-        max_length=max_length,
-    )
+    field_args = {
+        "default": default,
+        "default_factory": default_factory,
+        "title": title,
+        "description": description,
+        "pattern": pattern,
+        "strict": strict,
+        "gt": gt,
+        "ge": ge,
+        "lt": lt,
+        "le": le,
+        "multiple_of": multiple_of,
+        "allow_inf_nan": allow_inf_nan,
+        "max_digits": max_digits,
+        "decimal_places": decimal_places,
+        "min_length": min_length,
+        "max_length": max_length,
+    }
 
     """
     Invocation definitions have their fields typed correctly for their `invoke()` functions.
@@ -362,24 +299,24 @@ def InputField(
 
     # because we are manually making fields optional, we need to store the original required bool for reference later
     if default is PydanticUndefined and default_factory is PydanticUndefined:
-        json_schema_extra_.update(dict(orig_required=True))
+        json_schema_extra_.update({"orig_required": True})
     else:
-        json_schema_extra_.update(dict(orig_required=False))
+        json_schema_extra_.update({"orig_required": False})
 
     # make Input.Any and Input.Connection fields optional, providing None as a default if the field doesn't already have one
     if (input is Input.Any or input is Input.Connection) and default_factory is PydanticUndefined:
         default_ = None if default is PydanticUndefined else default
-        provided_args.update(dict(default=default_))
+        provided_args.update({"default": default_})
         if default is not PydanticUndefined:
             # before invoking, we'll grab the original default value and set it on the field if the field wasn't provided a value
-            json_schema_extra_.update(dict(default=default))
-            json_schema_extra_.update(dict(orig_default=default))
+            json_schema_extra_.update({"default": default})
+            json_schema_extra_.update({"orig_default": default})
     elif default is not PydanticUndefined and default_factory is PydanticUndefined:
         default_ = default
-        provided_args.update(dict(default=default_))
-        json_schema_extra_.update(dict(orig_default=default_))
+        provided_args.update({"default": default_})
+        json_schema_extra_.update({"orig_default": default_})
     elif default_factory is not PydanticUndefined:
-        provided_args.update(dict(default_factory=default_factory))
+        provided_args.update({"default_factory": default_factory})
         # TODO: cannot serialize default_factory...
         # json_schema_extra_.update(dict(orig_default_factory=default_factory))
 
@@ -446,12 +383,12 @@ def OutputField(
         decimal_places=decimal_places,
         min_length=min_length,
         max_length=max_length,
-        json_schema_extra=dict(
-            ui_type=ui_type,
-            ui_hidden=ui_hidden,
-            ui_order=ui_order,
-            _field_kind="output",
-        ),
+        json_schema_extra={
+            "ui_type": ui_type,
+            "ui_hidden": ui_hidden,
+            "ui_order": ui_order,
+            "_field_kind": "output",
+        },
     )
 
 
@@ -523,14 +460,14 @@ class BaseInvocationOutput(BaseModel):
 
     @classmethod
     def get_output_types(cls) -> Iterable[str]:
-        return map(lambda i: get_type(i), BaseInvocationOutput.get_outputs())
+        return (get_type(i) for i in BaseInvocationOutput.get_outputs())
 
     @staticmethod
     def json_schema_extra(schema: dict[str, Any], model_class: Type[BaseModel]) -> None:
         # Because we use a pydantic Literal field with default value for the invocation type,
         # it will be typed as optional in the OpenAPI schema. Make it required manually.
         if "required" not in schema or not isinstance(schema["required"], list):
-            schema["required"] = list()
+            schema["required"] = []
         schema["required"].extend(["type"])
 
     model_config = ConfigDict(
@@ -590,16 +527,11 @@ class BaseInvocation(ABC, BaseModel):
     @classmethod
     def get_invocations_map(cls) -> dict[str, BaseInvocation]:
         # Get the type strings out of the literals and into a dictionary
-        return dict(
-            map(
-                lambda i: (get_type(i), i),
-                BaseInvocation.get_invocations(),
-            )
-        )
+        return {get_type(i): i for i in BaseInvocation.get_invocations()}
 
     @classmethod
     def get_invocation_types(cls) -> Iterable[str]:
-        return map(lambda i: get_type(i), BaseInvocation.get_invocations())
+        return (get_type(i) for i in BaseInvocation.get_invocations())
 
     @classmethod
     def get_output_type(cls) -> BaseInvocationOutput:
@@ -618,7 +550,7 @@ class BaseInvocation(ABC, BaseModel):
         if uiconfig and hasattr(uiconfig, "version"):
             schema["version"] = uiconfig.version
         if "required" not in schema or not isinstance(schema["required"], list):
-            schema["required"] = list()
+            schema["required"] = []
         schema["required"].extend(["type", "id"])
 
     @abstractmethod
@@ -672,15 +604,15 @@ class BaseInvocation(ABC, BaseModel):
     id: str = Field(
         default_factory=uuid_string,
         description="The id of this instance of an invocation. Must be unique among all instances of invocations.",
-        json_schema_extra=dict(_field_kind="internal"),
+        json_schema_extra={"_field_kind": "internal"},
     )
     is_intermediate: bool = Field(
         default=False,
         description="Whether or not this is an intermediate invocation.",
-        json_schema_extra=dict(ui_type=UIType.IsIntermediate, _field_kind="internal"),
+        json_schema_extra={"ui_type": UIType.IsIntermediate, "_field_kind": "internal"},
     )
     use_cache: bool = Field(
-        default=True, description="Whether or not to use the cache", json_schema_extra=dict(_field_kind="internal")
+        default=True, description="Whether or not to use the cache", json_schema_extra={"_field_kind": "internal"}
     )
 
     UIConfig: ClassVar[Type[UIConfigBase]]
@@ -714,7 +646,7 @@ class _Model(BaseModel):
 
 
 # Get all pydantic model attrs, methods, etc
-RESERVED_PYDANTIC_FIELD_NAMES = set(map(lambda m: m[0], inspect.getmembers(_Model())))
+RESERVED_PYDANTIC_FIELD_NAMES = {m[0] for m in inspect.getmembers(_Model())}
 
 
 def validate_fields(model_fields: dict[str, FieldInfo], model_type: str) -> None:
@@ -729,9 +661,7 @@ def validate_fields(model_fields: dict[str, FieldInfo], model_type: str) -> None
 
         field_kind = (
             # _field_kind is defined via InputField(), OutputField() or by one of the internal fields defined in this file
-            field.json_schema_extra.get("_field_kind", None)
-            if field.json_schema_extra
-            else None
+            field.json_schema_extra.get("_field_kind", None) if field.json_schema_extra else None
         )
 
         # must have a field_kind
@@ -792,7 +722,7 @@ def invocation(
         # Add OpenAPI schema extras
         uiconf_name = cls.__qualname__ + ".UIConfig"
         if not hasattr(cls, "UIConfig") or cls.UIConfig.__qualname__ != uiconf_name:
-            cls.UIConfig = type(uiconf_name, (UIConfigBase,), dict())
+            cls.UIConfig = type(uiconf_name, (UIConfigBase,), {})
         if title is not None:
             cls.UIConfig.title = title
         if tags is not None:
@@ -819,7 +749,7 @@ def invocation(
 
         invocation_type_annotation = Literal[invocation_type]  # type: ignore
         invocation_type_field = Field(
-            title="type", default=invocation_type, json_schema_extra=dict(_field_kind="internal")
+            title="type", default=invocation_type, json_schema_extra={"_field_kind": "internal"}
         )
 
         docstring = cls.__doc__
@@ -865,7 +795,7 @@ def invocation_output(
         # Add the output type to the model.
 
         output_type_annotation = Literal[output_type]  # type: ignore
-        output_type_field = Field(title="type", default=output_type, json_schema_extra=dict(_field_kind="internal"))
+        output_type_field = Field(title="type", default=output_type, json_schema_extra={"_field_kind": "internal"})
 
         docstring = cls.__doc__
         cls = create_model(
@@ -897,7 +827,7 @@ WorkflowFieldValidator = TypeAdapter(WorkflowField)
 
 class WithWorkflow(BaseModel):
     workflow: Optional[WorkflowField] = Field(
-        default=None, description=FieldDescriptions.workflow, json_schema_extra=dict(_field_kind="internal")
+        default=None, description=FieldDescriptions.workflow, json_schema_extra={"_field_kind": "internal"}
     )
 
 
@@ -915,5 +845,5 @@ MetadataFieldValidator = TypeAdapter(MetadataField)
 
 class WithMetadata(BaseModel):
     metadata: Optional[MetadataField] = Field(
-        default=None, description=FieldDescriptions.metadata, json_schema_extra=dict(_field_kind="internal")
+        default=None, description=FieldDescriptions.metadata, json_schema_extra={"_field_kind": "internal"}
     )

invokeai/app/invocations/compel.py

@@ -7,6 +7,7 @@ from compel import Compel, ReturnedEmbeddingsType
 from compel.prompt_parser import Blend, Conjunction, CrossAttentionControlSubstitute, FlattenedPrompt, Fragment
 
 from invokeai.app.invocations.primitives import ConditioningField, ConditioningOutput
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
     BasicConditioningInfo,
     ExtraConditioningInfo,
@@ -19,7 +20,6 @@ from ...backend.util.devices import torch_dtype
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,
@@ -108,13 +108,15 @@ class CompelInvocation(BaseInvocation):
                 print(f'Warn: trigger: "{trigger}" not found')
 
         with (
-            ModelPatcher.apply_lora_text_encoder(text_encoder_info.context.model, _lora_loader()),
             ModelPatcher.apply_ti(tokenizer_info.context.model, text_encoder_info.context.model, ti_list) as (
                 tokenizer,
                 ti_manager,
             ),
-            ModelPatcher.apply_clip_skip(text_encoder_info.context.model, self.clip.skipped_layers),
             text_encoder_info as text_encoder,
+            # Apply the LoRA after text_encoder has been moved to its target device for faster patching.
+            ModelPatcher.apply_lora_text_encoder(text_encoder, _lora_loader()),
+            # Apply CLIP Skip after LoRA to prevent LoRA application from failing on skipped layers.
+            ModelPatcher.apply_clip_skip(text_encoder_info.context.model, self.clip.skipped_layers),
         ):
             compel = Compel(
                 tokenizer=tokenizer,
@@ -229,13 +231,15 @@ class SDXLPromptInvocationBase:
                 print(f'Warn: trigger: "{trigger}" not found')
 
         with (
-            ModelPatcher.apply_lora(text_encoder_info.context.model, _lora_loader(), lora_prefix),
             ModelPatcher.apply_ti(tokenizer_info.context.model, text_encoder_info.context.model, ti_list) as (
                 tokenizer,
                 ti_manager,
             ),
-            ModelPatcher.apply_clip_skip(text_encoder_info.context.model, clip_field.skipped_layers),
             text_encoder_info as text_encoder,
+            # Apply the LoRA after text_encoder has been moved to its target device for faster patching.
+            ModelPatcher.apply_lora(text_encoder, _lora_loader(), lora_prefix),
+            # Apply CLIP Skip after LoRA to prevent LoRA application from failing on skipped layers.
+            ModelPatcher.apply_clip_skip(text_encoder_info.context.model, clip_field.skipped_layers),
         ):
             compel = Compel(
                 tokenizer=tokenizer,

invokeai/app/invocations/controlnet_image_processors.py

@@ -28,12 +28,12 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from invokeai.app.invocations.primitives import ImageField, ImageOutput
 from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
+from invokeai.app.shared.fields import FieldDescriptions
 
 from ...backend.model_management import BaseModelType
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,

invokeai/app/invocations/facetools.py

@@ -131,7 +131,7 @@ def prepare_faces_list(
     deduped_faces: list[FaceResultData] = []
 
     if len(face_result_list) == 0:
-        return list()
+        return []
 
     for candidate in face_result_list:
         should_add = True
@@ -210,7 +210,7 @@ def generate_face_box_mask(
     # Check if any face is detected.
     if results.multi_face_landmarks:  # type: ignore # this are via protobuf and not typed
         # Search for the face_id in the detected faces.
-        for face_id, face_landmarks in enumerate(results.multi_face_landmarks):  # type: ignore #this are via protobuf and not typed
+        for _face_id, face_landmarks in enumerate(results.multi_face_landmarks):  # type: ignore #this are via protobuf and not typed
             # Get the bounding box of the face mesh.
             x_coordinates = [landmark.x for landmark in face_landmarks.landmark]
             y_coordinates = [landmark.y for landmark in face_landmarks.landmark]

invokeai/app/invocations/image.py

@@ -9,19 +9,11 @@ from PIL import Image, ImageChops, ImageFilter, ImageOps
 
 from invokeai.app.invocations.primitives import BoardField, ColorField, ImageField, ImageOutput
 from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.backend.image_util.invisible_watermark import InvisibleWatermark
 from invokeai.backend.image_util.safety_checker import SafetyChecker
 
-from .baseinvocation import (
-    BaseInvocation,
-    FieldDescriptions,
-    Input,
-    InputField,
-    InvocationContext,
-    WithMetadata,
-    WithWorkflow,
-    invocation,
-)
+from .baseinvocation import BaseInvocation, Input, InputField, InvocationContext, WithMetadata, WithWorkflow, invocation
 
 
 @invocation("show_image", title="Show Image", tags=["image"], category="image", version="1.0.0")

invokeai/app/invocations/ip_adapter.py

@@ -7,7 +7,6 @@ from pydantic import BaseModel, ConfigDict, Field
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,
@@ -17,6 +16,7 @@ from invokeai.app.invocations.baseinvocation import (
     invocation_output,
 )
 from invokeai.app.invocations.primitives import ImageField
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.backend.model_management.models.base import BaseModelType, ModelType
 from invokeai.backend.model_management.models.ip_adapter import get_ip_adapter_image_encoder_model_id
 
@@ -67,7 +67,7 @@ class IPAdapterInvocation(BaseInvocation):
 
     # weight: float = InputField(default=1.0, description="The weight of the IP-Adapter.", ui_type=UIType.Float)
     weight: Union[float, List[float]] = InputField(
-        default=1, ge=0, description="The weight given to the IP-Adapter", ui_type=UIType.Float, title="Weight"
+        default=1, ge=-1, description="The weight given to the IP-Adapter", ui_type=UIType.Float, title="Weight"
     )
 
     begin_step_percent: float = InputField(

invokeai/app/invocations/latent.py

@@ -10,7 +10,7 @@ import torch
 import torchvision.transforms as T
 from diffusers import AutoencoderKL, AutoencoderTiny
 from diffusers.image_processor import VaeImageProcessor
-from diffusers.models.adapter import FullAdapterXL, T2IAdapter
+from diffusers.models.adapter import T2IAdapter
 from diffusers.models.attention_processor import (
     AttnProcessor2_0,
     LoRAAttnProcessor2_0,
@@ -34,6 +34,7 @@ from invokeai.app.invocations.primitives import (
 )
 from invokeai.app.invocations.t2i_adapter import T2IAdapterField
 from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.util.controlnet_utils import prepare_control_image
 from invokeai.app.util.step_callback import stable_diffusion_step_callback
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter, IPAdapterPlus
@@ -57,7 +58,6 @@ from ...backend.util.devices import choose_precision, choose_torch_device
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,
@@ -77,7 +77,7 @@ if choose_torch_device() == torch.device("mps"):
 
 DEFAULT_PRECISION = choose_precision(choose_torch_device())
 
-SAMPLER_NAME_VALUES = Literal[tuple(list(SCHEDULER_MAP.keys()))]
+SAMPLER_NAME_VALUES = Literal[tuple(SCHEDULER_MAP.keys())]
 
 
 @invocation_output("scheduler_output")
@@ -562,10 +562,6 @@ class DenoiseLatentsInvocation(BaseInvocation):
             t2i_adapter_model: T2IAdapter
             with t2i_adapter_model_info as t2i_adapter_model:
                 total_downscale_factor = t2i_adapter_model.total_downscale_factor
-                if isinstance(t2i_adapter_model.adapter, FullAdapterXL):
-                    # HACK(ryand): Work around a bug in FullAdapterXL. This is being addressed upstream in diffusers by
-                    # this PR: https://github.com/huggingface/diffusers/pull/5134.
-                    total_downscale_factor = total_downscale_factor // 2
 
                 # Resize the T2I-Adapter input image.
                 # We select the resize dimensions so that after the T2I-Adapter's total_downscale_factor is applied, the
@@ -711,8 +707,11 @@ class DenoiseLatentsInvocation(BaseInvocation):
             with (
                 ExitStack() as exit_stack,
                 ModelPatcher.apply_lora_unet(unet_info.context.model, _lora_loader()),
+                ModelPatcher.apply_freeu(unet_info.context.model, self.unet.freeu_config),
                 set_seamless(unet_info.context.model, self.unet.seamless_axes),
                 unet_info as unet,
+                # Apply the LoRA after unet has been moved to its target device for faster patching.
+                ModelPatcher.apply_lora_unet(unet, _lora_loader()),
             ):
                 latents = latents.to(device=unet.device, dtype=unet.dtype)
                 if noise is not None:
@@ -1106,7 +1105,7 @@ class BlendLatentsInvocation(BaseInvocation):
         latents_b = context.services.latents.get(self.latents_b.latents_name)
 
         if latents_a.shape != latents_b.shape:
-            raise "Latents to blend must be the same size."
+            raise Exception("Latents to blend must be the same size.")
 
         # TODO:
         device = choose_torch_device()

invokeai/app/invocations/math.py

@@ -6,8 +6,9 @@ import numpy as np
 from pydantic import ValidationInfo, field_validator
 
 from invokeai.app.invocations.primitives import FloatOutput, IntegerOutput
+from invokeai.app.shared.fields import FieldDescriptions
 
-from .baseinvocation import BaseInvocation, FieldDescriptions, InputField, InvocationContext, invocation
+from .baseinvocation import BaseInvocation, InputField, InvocationContext, invocation
 
 
 @invocation("add", title="Add Integers", tags=["math", "add"], category="math", version="1.0.0")
@@ -144,17 +145,17 @@ INTEGER_OPERATIONS = Literal[
 ]
 
 
-INTEGER_OPERATIONS_LABELS = dict(
-    ADD="Add A+B",
-    SUB="Subtract A-B",
-    MUL="Multiply A*B",
-    DIV="Divide A/B",
-    EXP="Exponentiate A^B",
-    MOD="Modulus A%B",
-    ABS="Absolute Value of A",
-    MIN="Minimum(A,B)",
-    MAX="Maximum(A,B)",
-)
+INTEGER_OPERATIONS_LABELS = {
+    "ADD": "Add A+B",
+    "SUB": "Subtract A-B",
+    "MUL": "Multiply A*B",
+    "DIV": "Divide A/B",
+    "EXP": "Exponentiate A^B",
+    "MOD": "Modulus A%B",
+    "ABS": "Absolute Value of A",
+    "MIN": "Minimum(A,B)",
+    "MAX": "Maximum(A,B)",
+}
 
 
 @invocation(
@@ -182,8 +183,8 @@ class IntegerMathInvocation(BaseInvocation):
     operation: INTEGER_OPERATIONS = InputField(
         default="ADD", description="The operation to perform", ui_choice_labels=INTEGER_OPERATIONS_LABELS
     )
-    a: int = InputField(default=0, description=FieldDescriptions.num_1)
-    b: int = InputField(default=0, description=FieldDescriptions.num_2)
+    a: int = InputField(default=1, description=FieldDescriptions.num_1)
+    b: int = InputField(default=1, description=FieldDescriptions.num_2)
 
     @field_validator("b")
     def no_unrepresentable_results(cls, v: int, info: ValidationInfo):
@@ -230,17 +231,17 @@ FLOAT_OPERATIONS = Literal[
 ]
 
 
-FLOAT_OPERATIONS_LABELS = dict(
-    ADD="Add A+B",
-    SUB="Subtract A-B",
-    MUL="Multiply A*B",
-    DIV="Divide A/B",
-    EXP="Exponentiate A^B",
-    ABS="Absolute Value of A",
-    SQRT="Square Root of A",
-    MIN="Minimum(A,B)",
-    MAX="Maximum(A,B)",
-)
+FLOAT_OPERATIONS_LABELS = {
+    "ADD": "Add A+B",
+    "SUB": "Subtract A-B",
+    "MUL": "Multiply A*B",
+    "DIV": "Divide A/B",
+    "EXP": "Exponentiate A^B",
+    "ABS": "Absolute Value of A",
+    "SQRT": "Square Root of A",
+    "MIN": "Minimum(A,B)",
+    "MAX": "Maximum(A,B)",
+}
 
 
 @invocation(
@@ -256,8 +257,8 @@ class FloatMathInvocation(BaseInvocation):
     operation: FLOAT_OPERATIONS = InputField(
         default="ADD", description="The operation to perform", ui_choice_labels=FLOAT_OPERATIONS_LABELS
     )
-    a: float = InputField(default=0, description=FieldDescriptions.num_1)
-    b: float = InputField(default=0, description=FieldDescriptions.num_2)
+    a: float = InputField(default=1, description=FieldDescriptions.num_1)
+    b: float = InputField(default=1, description=FieldDescriptions.num_2)
 
     @field_validator("b")
     def no_unrepresentable_results(cls, v: float, info: ValidationInfo):
@@ -265,7 +266,7 @@ class FloatMathInvocation(BaseInvocation):
             raise ValueError("Cannot divide by zero")
         elif info.data["operation"] == "EXP" and info.data["a"] == 0 and v < 0:
             raise ValueError("Cannot raise zero to a negative power")
-        elif info.data["operation"] == "EXP" and type(info.data["a"] ** v) is complex:
+        elif info.data["operation"] == "EXP" and isinstance(info.data["a"] ** v, complex):
             raise ValueError("Root operation resulted in a complex number")
         return v
 

invokeai/app/invocations/metadata.py

@@ -5,7 +5,6 @@ from pydantic import BaseModel, ConfigDict, Field
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     InputField,
     InvocationContext,
     MetadataField,
@@ -19,6 +18,7 @@ from invokeai.app.invocations.ip_adapter import IPAdapterModelField
 from invokeai.app.invocations.model import LoRAModelField, MainModelField, VAEModelField
 from invokeai.app.invocations.primitives import ImageField
 from invokeai.app.invocations.t2i_adapter import T2IAdapterField
+from invokeai.app.shared.fields import FieldDescriptions
 
 from ...version import __version__
 
@@ -160,13 +160,14 @@ class CoreMetadataInvocation(BaseInvocation):
     )
 
     # High resolution fix metadata.
-    hrf_width: Optional[int] = InputField(
+    hrf_enabled: Optional[float] = InputField(
         default=None,
-        description="The high resolution fix height and width multipler.",
+        description="Whether or not high resolution fix was enabled.",
     )
-    hrf_height: Optional[int] = InputField(
+    # TODO: should this be stricter or do we just let the UI handle it?
+    hrf_method: Optional[str] = InputField(
         default=None,
-        description="The high resolution fix height and width multipler.",
+        description="The high resolution fix upscale method.",
     )
     hrf_strength: Optional[float] = InputField(
         default=None,

invokeai/app/invocations/model.py

@@ -3,11 +3,13 @@ from typing import List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from invokeai.app.shared.fields import FieldDescriptions
+from invokeai.app.shared.models import FreeUConfig
+
 from ...backend.model_management import BaseModelType, ModelType, SubModelType
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,
@@ -36,6 +38,7 @@ class UNetField(BaseModel):
     scheduler: ModelInfo = Field(description="Info to load scheduler submodel")
     loras: List[LoraInfo] = Field(description="Loras to apply on model loading")
     seamless_axes: List[str] = Field(default_factory=list, description='Axes("x" and "y") to which apply seamless')
+    freeu_config: Optional[FreeUConfig] = Field(default=None, description="FreeU configuration")
 
 
 class ClipField(BaseModel):
@@ -51,15 +54,34 @@ class VaeField(BaseModel):
     seamless_axes: List[str] = Field(default_factory=list, description='Axes("x" and "y") to which apply seamless')
 
 
-@invocation_output("model_loader_output")
-class ModelLoaderOutput(BaseInvocationOutput):
-    """Model loader output"""
+@invocation_output("unet_output")
+class UNetOutput(BaseInvocationOutput):
+    """Base class for invocations that output a UNet field"""
 
     unet: UNetField = OutputField(description=FieldDescriptions.unet, title="UNet")
-    clip: ClipField = OutputField(description=FieldDescriptions.clip, title="CLIP")
+
+
+@invocation_output("vae_output")
+class VAEOutput(BaseInvocationOutput):
+    """Base class for invocations that output a VAE field"""
+
     vae: VaeField = OutputField(description=FieldDescriptions.vae, title="VAE")
 
 
+@invocation_output("clip_output")
+class CLIPOutput(BaseInvocationOutput):
+    """Base class for invocations that output a CLIP field"""
+
+    clip: ClipField = OutputField(description=FieldDescriptions.clip, title="CLIP")
+
+
+@invocation_output("model_loader_output")
+class ModelLoaderOutput(UNetOutput, CLIPOutput, VAEOutput):
+    """Model loader output"""
+
+    pass
+
+
 class MainModelField(BaseModel):
     """Main model field"""
 
@@ -366,13 +388,6 @@ class VAEModelField(BaseModel):
     model_config = ConfigDict(protected_namespaces=())
 
 
-@invocation_output("vae_loader_output")
-class VaeLoaderOutput(BaseInvocationOutput):
-    """VAE output"""
-
-    vae: VaeField = OutputField(description=FieldDescriptions.vae, title="VAE")
-
-
 @invocation("vae_loader", title="VAE", tags=["vae", "model"], category="model", version="1.0.0")
 class VaeLoaderInvocation(BaseInvocation):
     """Loads a VAE model, outputting a VaeLoaderOutput"""
@@ -384,7 +399,7 @@ class VaeLoaderInvocation(BaseInvocation):
         title="VAE",
     )
 
-    def invoke(self, context: InvocationContext) -> VaeLoaderOutput:
+    def invoke(self, context: InvocationContext) -> VAEOutput:
         base_model = self.vae_model.base_model
         model_name = self.vae_model.model_name
         model_type = ModelType.Vae
@@ -395,7 +410,7 @@ class VaeLoaderInvocation(BaseInvocation):
             model_type=model_type,
         ):
             raise Exception(f"Unkown vae name: {model_name}!")
-        return VaeLoaderOutput(
+        return VAEOutput(
             vae=VaeField(
                 vae=ModelInfo(
                     model_name=model_name,
@@ -457,3 +472,24 @@ class SeamlessModeInvocation(BaseInvocation):
             vae.seamless_axes = seamless_axes_list
 
         return SeamlessModeOutput(unet=unet, vae=vae)
+
+
+@invocation("freeu", title="FreeU", tags=["freeu"], category="unet", version="1.0.0")
+class FreeUInvocation(BaseInvocation):
+    """
+    Applies FreeU to the UNet. Suggested values (b1/b2/s1/s2):
+
+    SD1.5: 1.2/1.4/0.9/0.2,
+    SD2: 1.1/1.2/0.9/0.2,
+    SDXL: 1.1/1.2/0.6/0.4,
+    """
+
+    unet: UNetField = InputField(description=FieldDescriptions.unet, input=Input.Connection, title="UNet")
+    b1: float = InputField(default=1.2, ge=-1, le=3, description=FieldDescriptions.freeu_b1)
+    b2: float = InputField(default=1.4, ge=-1, le=3, description=FieldDescriptions.freeu_b2)
+    s1: float = InputField(default=0.9, ge=-1, le=3, description=FieldDescriptions.freeu_s1)
+    s2: float = InputField(default=0.2, ge=-1, le=3, description=FieldDescriptions.freeu_s2)
+
+    def invoke(self, context: InvocationContext) -> UNetOutput:
+        self.unet.freeu_config = FreeUConfig(s1=self.s1, s2=self.s2, b1=self.b1, b2=self.b2)
+        return UNetOutput(unet=self.unet)

invokeai/app/invocations/noise.py

@@ -5,13 +5,13 @@ import torch
 from pydantic import field_validator
 
 from invokeai.app.invocations.latent import LatentsField
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.util.misc import SEED_MAX, get_random_seed
 
 from ...backend.util.devices import choose_torch_device, torch_dtype
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     InputField,
     InvocationContext,
     OutputField,

invokeai/app/invocations/onnx.py

@@ -14,6 +14,7 @@ from tqdm import tqdm
 
 from invokeai.app.invocations.primitives import ConditioningField, ConditioningOutput, ImageField, ImageOutput
 from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.util.step_callback import stable_diffusion_step_callback
 from invokeai.backend import BaseModelType, ModelType, SubModelType
 
@@ -23,7 +24,6 @@ from ...backend.util import choose_torch_device
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,
@@ -54,7 +54,7 @@ ORT_TO_NP_TYPE = {
     "tensor(double)": np.float64,
 }
 
-PRECISION_VALUES = Literal[tuple(list(ORT_TO_NP_TYPE.keys()))]
+PRECISION_VALUES = Literal[tuple(ORT_TO_NP_TYPE.keys())]
 
 
 @invocation("prompt_onnx", title="ONNX Prompt (Raw)", tags=["prompt", "onnx"], category="conditioning", version="1.0.0")
@@ -252,7 +252,7 @@ class ONNXTextToLatentsInvocation(BaseInvocation):
         scheduler.set_timesteps(self.steps)
         latents = latents * np.float64(scheduler.init_noise_sigma)
 
-        extra_step_kwargs = dict()
+        extra_step_kwargs = {}
         if "eta" in set(inspect.signature(scheduler.step).parameters.keys()):
             extra_step_kwargs.update(
                 eta=0.0,

invokeai/app/invocations/param_easing.py

@@ -100,7 +100,7 @@ EASING_FUNCTIONS_MAP = {
     "BounceInOut": BounceEaseInOut,
 }
 
-EASING_FUNCTION_KEYS = Literal[tuple(list(EASING_FUNCTIONS_MAP.keys()))]
+EASING_FUNCTION_KEYS = Literal[tuple(EASING_FUNCTIONS_MAP.keys())]
 
 
 # actually I think for now could just use CollectionOutput (which is list[Any]
@@ -161,7 +161,7 @@ class StepParamEasingInvocation(BaseInvocation):
         easing_class = EASING_FUNCTIONS_MAP[self.easing]
         if log_diagnostics:
             context.services.logger.debug("easing class: " + str(easing_class))
-        easing_list = list()
+        easing_list = []
         if self.mirror:  # "expected" mirroring
             # if number of steps is even, squeeze duration down to (number_of_steps)/2
             # and create reverse copy of list to append
@@ -178,7 +178,7 @@ class StepParamEasingInvocation(BaseInvocation):
                 end=self.end_value,
                 duration=base_easing_duration - 1,
             )
-            base_easing_vals = list()
+            base_easing_vals = []
             for step_index in range(base_easing_duration):
                 easing_val = easing_function.ease(step_index)
                 base_easing_vals.append(easing_val)

invokeai/app/invocations/primitives.py

@@ -5,10 +5,11 @@ from typing import Optional, Tuple
 import torch
 from pydantic import BaseModel, Field
 
+from invokeai.app.shared.fields import FieldDescriptions
+
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,
@@ -293,7 +294,7 @@ class DenoiseMaskField(BaseModel):
     """An inpaint mask field"""
 
     mask_name: str = Field(description="The name of the mask image")
-    masked_latents_name: Optional[str] = Field(description="The name of the masked image latents")
+    masked_latents_name: Optional[str] = Field(default=None, description="The name of the masked image latents")
 
 
 @invocation_output("denoise_mask_output")

invokeai/app/invocations/sdxl.py

@@ -1,8 +1,9 @@
+from invokeai.app.shared.fields import FieldDescriptions
+
 from ...backend.model_management import ModelType, SubModelType
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,

invokeai/app/invocations/t2i_adapter.py

@@ -5,7 +5,6 @@ from pydantic import BaseModel, ConfigDict, Field
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    FieldDescriptions,
     Input,
     InputField,
     InvocationContext,
@@ -16,6 +15,7 @@ from invokeai.app.invocations.baseinvocation import (
 )
 from invokeai.app.invocations.controlnet_image_processors import CONTROLNET_RESIZE_VALUES
 from invokeai.app.invocations.primitives import ImageField
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.backend.model_management.models.base import BaseModelType
 
 

invokeai/app/services/board_image_records/board_image_records_sqlite.py

@@ -139,7 +139,7 @@ class SqliteBoardImageRecordStorage(BoardImageRecordStorageBase):
                 (board_id,),
             )
             result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            images = list(map(lambda r: deserialize_image_record(dict(r)), result))
+            images = [deserialize_image_record(dict(r)) for r in result]
 
             self._cursor.execute(
                 """--sql
@@ -167,7 +167,7 @@ class SqliteBoardImageRecordStorage(BoardImageRecordStorageBase):
                 (board_id,),
             )
             result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            image_names = list(map(lambda r: r[0], result))
+            image_names = [r[0] for r in result]
             return image_names
         except sqlite3.Error as e:
             self._conn.rollback()

invokeai/app/services/board_records/board_records_sqlite.py

@@ -199,7 +199,7 @@ class SqliteBoardRecordStorage(BoardRecordStorageBase):
             )
 
             result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            boards = list(map(lambda r: deserialize_board_record(dict(r)), result))
+            boards = [deserialize_board_record(dict(r)) for r in result]
 
             # Get the total number of boards
             self._cursor.execute(
@@ -236,7 +236,7 @@ class SqliteBoardRecordStorage(BoardRecordStorageBase):
             )
 
             result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            boards = list(map(lambda r: deserialize_board_record(dict(r)), result))
+            boards = [deserialize_board_record(dict(r)) for r in result]
 
             return boards
 

invokeai/app/services/config/config_base.py

@@ -55,7 +55,7 @@ class InvokeAISettings(BaseSettings):
         """
         cls = self.__class__
         type = get_args(get_type_hints(cls)["type"])[0]
-        field_dict = dict({type: dict()})
+        field_dict = {type: {}}
         for name, field in self.model_fields.items():
             if name in cls._excluded_from_yaml():
                 continue
@@ -64,7 +64,7 @@ class InvokeAISettings(BaseSettings):
             )
             value = getattr(self, name)
             if category not in field_dict[type]:
-                field_dict[type][category] = dict()
+                field_dict[type][category] = {}
             # keep paths as strings to make it easier to read
             field_dict[type][category][name] = str(value) if isinstance(value, Path) else value
         conf = OmegaConf.create(field_dict)
@@ -89,7 +89,7 @@ class InvokeAISettings(BaseSettings):
         # create an upcase version of the environment in
         # order to achieve case-insensitive environment
         # variables (the way Windows does)
-        upcase_environ = dict()
+        upcase_environ = {}
         for key, value in os.environ.items():
             upcase_environ[key.upper()] = value
 

invokeai/app/services/config/config_default.py

@@ -45,6 +45,7 @@ InvokeAI:
     ram: 13.5
     vram: 0.25
     lazy_offload: true
+    log_memory_usage: false
   Device:
     device: auto
     precision: auto
@@ -187,18 +188,18 @@ DEFAULT_MAX_VRAM = 0.5
 
 
 class Categories(object):
-    WebServer = dict(category="Web Server")
-    Features = dict(category="Features")
-    Paths = dict(category="Paths")
-    Logging = dict(category="Logging")
-    Development = dict(category="Development")
-    Other = dict(category="Other")
-    ModelCache = dict(category="Model Cache")
-    Device = dict(category="Device")
-    Generation = dict(category="Generation")
-    Queue = dict(category="Queue")
-    Nodes = dict(category="Nodes")
-    MemoryPerformance = dict(category="Memory/Performance")
+    WebServer = {"category": "Web Server"}
+    Features = {"category": "Features"}
+    Paths = {"category": "Paths"}
+    Logging = {"category": "Logging"}
+    Development = {"category": "Development"}
+    Other = {"category": "Other"}
+    ModelCache = {"category": "Model Cache"}
+    Device = {"category": "Device"}
+    Generation = {"category": "Generation"}
+    Queue = {"category": "Queue"}
+    Nodes = {"category": "Nodes"}
+    MemoryPerformance = {"category": "Memory/Performance"}
 
 
 class InvokeAIAppConfig(InvokeAISettings):
@@ -261,6 +262,7 @@ class InvokeAIAppConfig(InvokeAISettings):
     ram                 : float = Field(default=7.5, gt=0, description="Maximum memory amount used by model cache for rapid switching (floating point number, GB)", json_schema_extra=Categories.ModelCache, )
     vram                : float = Field(default=0.25, ge=0, description="Amount of VRAM reserved for model storage (floating point number, GB)", json_schema_extra=Categories.ModelCache, )
     lazy_offload        : bool = Field(default=True, description="Keep models in VRAM until their space is needed", json_schema_extra=Categories.ModelCache, )
+    log_memory_usage    : bool = Field(default=False, description="If True, a memory snapshot will be captured before and after every model cache operation, and the result will be logged (at debug level). There is a time cost to capturing the memory snapshots, so it is recommended to only enable this feature if you are actively inspecting the model cache's behaviour.", json_schema_extra=Categories.ModelCache)
 
     # DEVICE
     device              : Literal["auto", "cpu", "cuda", "cuda:1", "mps"] = Field(default="auto", description="Generation device", json_schema_extra=Categories.Device)
@@ -480,7 +482,7 @@ def _find_root() -> Path:
     venv = Path(os.environ.get("VIRTUAL_ENV") or ".")
     if os.environ.get("INVOKEAI_ROOT"):
         root = Path(os.environ["INVOKEAI_ROOT"])
-    elif any([(venv.parent / x).exists() for x in [INIT_FILE, LEGACY_INIT_FILE]]):
+    elif any((venv.parent / x).exists() for x in [INIT_FILE, LEGACY_INIT_FILE]):
         root = (venv.parent).resolve()
     else:
         root = Path("~/invokeai").expanduser().resolve()

invokeai/app/services/events/events_base.py

@@ -27,7 +27,7 @@ class EventServiceBase:
         payload["timestamp"] = get_timestamp()
         self.dispatch(
             event_name=EventServiceBase.queue_event,
-            payload=dict(event=event_name, data=payload),
+            payload={"event": event_name, "data": payload},
         )
 
     # Define events here for every event in the system.
@@ -48,18 +48,18 @@ class EventServiceBase:
         """Emitted when there is generation progress"""
         self.__emit_queue_event(
             event_name="generator_progress",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-                node_id=node.get("id"),
-                source_node_id=source_node_id,
-                progress_image=progress_image.model_dump() if progress_image is not None else None,
-                step=step,
-                order=order,
-                total_steps=total_steps,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+                "node_id": node.get("id"),
+                "source_node_id": source_node_id,
+                "progress_image": progress_image.model_dump() if progress_image is not None else None,
+                "step": step,
+                "order": order,
+                "total_steps": total_steps,
+            },
         )
 
     def emit_invocation_complete(
@@ -75,15 +75,15 @@ class EventServiceBase:
         """Emitted when an invocation has completed"""
         self.__emit_queue_event(
             event_name="invocation_complete",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
-                result=result,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+                "node": node,
+                "source_node_id": source_node_id,
+                "result": result,
+            },
         )
 
     def emit_invocation_error(
@@ -100,16 +100,16 @@ class EventServiceBase:
         """Emitted when an invocation has completed"""
         self.__emit_queue_event(
             event_name="invocation_error",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
-                error_type=error_type,
-                error=error,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+                "node": node,
+                "source_node_id": source_node_id,
+                "error_type": error_type,
+                "error": error,
+            },
         )
 
     def emit_invocation_started(
@@ -124,14 +124,14 @@ class EventServiceBase:
         """Emitted when an invocation has started"""
         self.__emit_queue_event(
             event_name="invocation_started",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+                "node": node,
+                "source_node_id": source_node_id,
+            },
         )
 
     def emit_graph_execution_complete(
@@ -140,12 +140,12 @@ class EventServiceBase:
         """Emitted when a session has completed all invocations"""
         self.__emit_queue_event(
             event_name="graph_execution_state_complete",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+            },
         )
 
     def emit_model_load_started(
@@ -162,16 +162,16 @@ class EventServiceBase:
         """Emitted when a model is requested"""
         self.__emit_queue_event(
             event_name="model_load_started",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-                model_name=model_name,
-                base_model=base_model,
-                model_type=model_type,
-                submodel=submodel,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+                "model_name": model_name,
+                "base_model": base_model,
+                "model_type": model_type,
+                "submodel": submodel,
+            },
         )
 
     def emit_model_load_completed(
@@ -189,19 +189,19 @@ class EventServiceBase:
         """Emitted when a model is correctly loaded (returns model info)"""
         self.__emit_queue_event(
             event_name="model_load_completed",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-                model_name=model_name,
-                base_model=base_model,
-                model_type=model_type,
-                submodel=submodel,
-                hash=model_info.hash,
-                location=str(model_info.location),
-                precision=str(model_info.precision),
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+                "model_name": model_name,
+                "base_model": base_model,
+                "model_type": model_type,
+                "submodel": submodel,
+                "hash": model_info.hash,
+                "location": str(model_info.location),
+                "precision": str(model_info.precision),
+            },
         )
 
     def emit_session_retrieval_error(
@@ -216,14 +216,14 @@ class EventServiceBase:
         """Emitted when session retrieval fails"""
         self.__emit_queue_event(
             event_name="session_retrieval_error",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-                error_type=error_type,
-                error=error,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+                "error_type": error_type,
+                "error": error,
+            },
         )
 
     def emit_invocation_retrieval_error(
@@ -239,15 +239,15 @@ class EventServiceBase:
         """Emitted when invocation retrieval fails"""
         self.__emit_queue_event(
             event_name="invocation_retrieval_error",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-                node_id=node_id,
-                error_type=error_type,
-                error=error,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+                "node_id": node_id,
+                "error_type": error_type,
+                "error": error,
+            },
         )
 
     def emit_session_canceled(
@@ -260,12 +260,12 @@ class EventServiceBase:
         """Emitted when a session is canceled"""
         self.__emit_queue_event(
             event_name="session_canceled",
-            payload=dict(
-                queue_id=queue_id,
-                queue_item_id=queue_item_id,
-                queue_batch_id=queue_batch_id,
-                graph_execution_state_id=graph_execution_state_id,
-            ),
+            payload={
+                "queue_id": queue_id,
+                "queue_item_id": queue_item_id,
+                "queue_batch_id": queue_batch_id,
+                "graph_execution_state_id": graph_execution_state_id,
+            },
         )
 
     def emit_queue_item_status_changed(
@@ -277,39 +277,39 @@ class EventServiceBase:
         """Emitted when a queue item's status changes"""
         self.__emit_queue_event(
             event_name="queue_item_status_changed",
-            payload=dict(
-                queue_id=queue_status.queue_id,
-                queue_item=dict(
-                    queue_id=session_queue_item.queue_id,
-                    item_id=session_queue_item.item_id,
-                    status=session_queue_item.status,
-                    batch_id=session_queue_item.batch_id,
-                    session_id=session_queue_item.session_id,
-                    error=session_queue_item.error,
-                    created_at=str(session_queue_item.created_at) if session_queue_item.created_at else None,
-                    updated_at=str(session_queue_item.updated_at) if session_queue_item.updated_at else None,
-                    started_at=str(session_queue_item.started_at) if session_queue_item.started_at else None,
-                    completed_at=str(session_queue_item.completed_at) if session_queue_item.completed_at else None,
-                ),
-                batch_status=batch_status.model_dump(),
-                queue_status=queue_status.model_dump(),
-            ),
+            payload={
+                "queue_id": queue_status.queue_id,
+                "queue_item": {
+                    "queue_id": session_queue_item.queue_id,
+                    "item_id": session_queue_item.item_id,
+                    "status": session_queue_item.status,
+                    "batch_id": session_queue_item.batch_id,
+                    "session_id": session_queue_item.session_id,
+                    "error": session_queue_item.error,
+                    "created_at": str(session_queue_item.created_at) if session_queue_item.created_at else None,
+                    "updated_at": str(session_queue_item.updated_at) if session_queue_item.updated_at else None,
+                    "started_at": str(session_queue_item.started_at) if session_queue_item.started_at else None,
+                    "completed_at": str(session_queue_item.completed_at) if session_queue_item.completed_at else None,
+                },
+                "batch_status": batch_status.model_dump(),
+                "queue_status": queue_status.model_dump(),
+            },
         )
 
     def emit_batch_enqueued(self, enqueue_result: EnqueueBatchResult) -> None:
         """Emitted when a batch is enqueued"""
         self.__emit_queue_event(
             event_name="batch_enqueued",
-            payload=dict(
-                queue_id=enqueue_result.queue_id,
-                batch_id=enqueue_result.batch.batch_id,
-                enqueued=enqueue_result.enqueued,
-            ),
+            payload={
+                "queue_id": enqueue_result.queue_id,
+                "batch_id": enqueue_result.batch.batch_id,
+                "enqueued": enqueue_result.enqueued,
+            },
         )
 
     def emit_queue_cleared(self, queue_id: str) -> None:
         """Emitted when the queue is cleared"""
         self.__emit_queue_event(
             event_name="queue_cleared",
-            payload=dict(queue_id=queue_id),
+            payload={"queue_id": queue_id},
         )

invokeai/app/services/image_files/image_files_disk.py

@@ -25,7 +25,7 @@ class DiskImageFileStorage(ImageFileStorageBase):
     __invoker: Invoker
 
     def __init__(self, output_folder: Union[str, Path]):
-        self.__cache = dict()
+        self.__cache = {}
         self.__cache_ids = Queue()
         self.__max_cache_size = 10  # TODO: get this from config
 

invokeai/app/services/image_records/image_records_common.py

@@ -90,25 +90,23 @@ class ImageRecordDeleteException(Exception):
 
 
 IMAGE_DTO_COLS = ", ".join(
-    list(
-        map(
-            lambda c: "images." + c,
-            [
-                "image_name",
-                "image_origin",
-                "image_category",
-                "width",
-                "height",
-                "session_id",
-                "node_id",
-                "is_intermediate",
-                "created_at",
-                "updated_at",
-                "deleted_at",
-                "starred",
-            ],
-        )
-    )
+    [
+        "images." + c
+        for c in [
+            "image_name",
+            "image_origin",
+            "image_category",
+            "width",
+            "height",
+            "session_id",
+            "node_id",
+            "is_intermediate",
+            "created_at",
+            "updated_at",
+            "deleted_at",
+            "starred",
+        ]
+    ]
 )
 
 

invokeai/app/services/image_records/image_records_sqlite.py

@@ -263,7 +263,7 @@ class SqliteImageRecordStorage(ImageRecordStorageBase):
 
             if categories is not None:
                 # Convert the enum values to unique list of strings
-                category_strings = list(map(lambda c: c.value, set(categories)))
+                category_strings = [c.value for c in set(categories)]
                 # Create the correct length of placeholders
                 placeholders = ",".join("?" * len(category_strings))
 
@@ -307,7 +307,7 @@ class SqliteImageRecordStorage(ImageRecordStorageBase):
             # Build the list of images, deserializing each row
             self._cursor.execute(images_query, images_params)
             result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            images = list(map(lambda r: deserialize_image_record(dict(r)), result))
+            images = [deserialize_image_record(dict(r)) for r in result]
 
             # Set up and execute the count query, without pagination
             count_query += query_conditions + ";"
@@ -386,7 +386,7 @@ class SqliteImageRecordStorage(ImageRecordStorageBase):
                 """
             )
             result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            image_names = list(map(lambda r: r[0], result))
+            image_names = [r[0] for r in result]
             self._cursor.execute(
                 """--sql
                 DELETE FROM images

invokeai/app/services/images/images_base.py

@@ -21,8 +21,8 @@ class ImageServiceABC(ABC):
     _on_deleted_callbacks: list[Callable[[str], None]]
 
     def __init__(self) -> None:
-        self._on_changed_callbacks = list()
-        self._on_deleted_callbacks = list()
+        self._on_changed_callbacks = []
+        self._on_deleted_callbacks = []
 
     def on_changed(self, on_changed: Callable[[ImageDTO], None]) -> None:
         """Register a callback for when an image is changed"""

invokeai/app/services/images/images_default.py

@@ -217,18 +217,16 @@ class ImageService(ImageServiceABC):
                 board_id,
             )
 
-            image_dtos = list(
-                map(
-                    lambda r: image_record_to_dto(
-                        image_record=r,
-                        image_url=self.__invoker.services.urls.get_image_url(r.image_name),
-                        thumbnail_url=self.__invoker.services.urls.get_image_url(r.image_name, True),
-                        board_id=self.__invoker.services.board_image_records.get_board_for_image(r.image_name),
-                        workflow_id=self.__invoker.services.workflow_image_records.get_workflow_for_image(r.image_name),
-                    ),
-                    results.items,
+            image_dtos = [
+                image_record_to_dto(
+                    image_record=r,
+                    image_url=self.__invoker.services.urls.get_image_url(r.image_name),
+                    thumbnail_url=self.__invoker.services.urls.get_image_url(r.image_name, True),
+                    board_id=self.__invoker.services.board_image_records.get_board_for_image(r.image_name),
+                    workflow_id=self.__invoker.services.workflow_image_records.get_workflow_for_image(r.image_name),
                 )
-            )
+                for r in results.items
+            ]
 
             return OffsetPaginatedResults[ImageDTO](
                 items=image_dtos,

invokeai/app/services/invocation_processor/invocation_processor_base.py

@@ -1,5 +1,5 @@
 from abc import ABC
 
 
-class InvocationProcessorABC(ABC):
+class InvocationProcessorABC(ABC):  # noqa: B024
     pass

invokeai/app/services/invocation_processor/invocation_processor_default.py

@@ -26,7 +26,7 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
         self.__invoker_thread = Thread(
             name="invoker_processor",
             target=self.__process,
-            kwargs=dict(stop_event=self.__stop_event),
+            kwargs={"stop_event": self.__stop_event},
         )
         self.__invoker_thread.daemon = True  # TODO: make async and do not use threads
         self.__invoker_thread.start()

invokeai/app/services/invocation_queue/invocation_queue_memory.py

@@ -14,7 +14,7 @@ class MemoryInvocationQueue(InvocationQueueABC):
 
     def __init__(self):
         self.__queue = Queue()
-        self.__cancellations = dict()
+        self.__cancellations = {}
 
     def get(self) -> InvocationQueueItem:
         item = self.__queue.get()

invokeai/app/services/invocation_services.py

@@ -22,6 +22,7 @@ if TYPE_CHECKING:
     from .item_storage.item_storage_base import ItemStorageABC
     from .latents_storage.latents_storage_base import LatentsStorageBase
     from .model_manager.model_manager_base import ModelManagerServiceBase
+    from .model_records import ModelRecordServiceBase
     from .names.names_base import NameServiceBase
     from .session_processor.session_processor_base import SessionProcessorBase
     from .session_queue.session_queue_base import SessionQueueBase
@@ -49,6 +50,7 @@ class InvocationServices:
     latents: "LatentsStorageBase"
     logger: "Logger"
     model_manager: "ModelManagerServiceBase"
+    model_records: "ModelRecordServiceBase"
     processor: "InvocationProcessorABC"
     performance_statistics: "InvocationStatsServiceBase"
     queue: "InvocationQueueABC"
@@ -76,6 +78,7 @@ class InvocationServices:
         latents: "LatentsStorageBase",
         logger: "Logger",
         model_manager: "ModelManagerServiceBase",
+        model_records: "ModelRecordServiceBase",
         processor: "InvocationProcessorABC",
         performance_statistics: "InvocationStatsServiceBase",
         queue: "InvocationQueueABC",
@@ -101,6 +104,7 @@ class InvocationServices:
         self.latents = latents
         self.logger = logger
         self.model_manager = model_manager
+        self.model_records = model_records
         self.processor = processor
         self.performance_statistics = performance_statistics
         self.queue = queue

invokeai/app/services/invocation_stats/invocation_stats_default.py

@@ -122,7 +122,7 @@ class InvocationStatsService(InvocationStatsServiceBase):
     def log_stats(self):
         completed = set()
         errored = set()
-        for graph_id, node_log in self._stats.items():
+        for graph_id, _node_log in self._stats.items():
             try:
                 current_graph_state = self._invoker.services.graph_execution_manager.get(graph_id)
             except Exception:
@@ -142,7 +142,7 @@ class InvocationStatsService(InvocationStatsServiceBase):
             cache_stats = self._cache_stats[graph_id]
             hwm = cache_stats.high_watermark / GIG
             tot = cache_stats.cache_size / GIG
-            loaded = sum([v for v in cache_stats.loaded_model_sizes.values()]) / GIG
+            loaded = sum(list(cache_stats.loaded_model_sizes.values())) / GIG
 
             logger.info(f"TOTAL GRAPH EXECUTION TIME:  {total_time:7.3f}s")
             logger.info("RAM used by InvokeAI process: " + "%4.2fG" % self.ram_used + f" ({self.ram_changed:+5.3f}G)")

invokeai/app/services/item_storage/item_storage_base.py

@@ -15,8 +15,8 @@ class ItemStorageABC(ABC, Generic[T]):
     _on_deleted_callbacks: list[Callable[[str], None]]
 
     def __init__(self) -> None:
-        self._on_changed_callbacks = list()
-        self._on_deleted_callbacks = list()
+        self._on_changed_callbacks = []
+        self._on_deleted_callbacks = []
 
     """Base item storage class"""
 

invokeai/app/services/item_storage/item_storage_sqlite.py

@@ -112,7 +112,7 @@ class SqliteItemStorage(ItemStorageABC, Generic[T]):
             )
             result = self._cursor.fetchall()
 
-            items = list(map(lambda r: self._parse_item(r[0]), result))
+            items = [self._parse_item(r[0]) for r in result]
 
             self._cursor.execute(f"""SELECT count(*) FROM {self._table_name};""")
             count = self._cursor.fetchone()[0]
@@ -132,7 +132,7 @@ class SqliteItemStorage(ItemStorageABC, Generic[T]):
             )
             result = self._cursor.fetchall()
 
-            items = list(map(lambda r: self._parse_item(r[0]), result))
+            items = [self._parse_item(r[0]) for r in result]
 
             self._cursor.execute(
                 f"""SELECT count(*) FROM {self._table_name} WHERE item LIKE ?;""",

invokeai/app/services/latents_storage/latents_storage_base.py

@@ -13,8 +13,8 @@ class LatentsStorageBase(ABC):
     _on_deleted_callbacks: list[Callable[[str], None]]
 
     def __init__(self) -> None:
-        self._on_changed_callbacks = list()
-        self._on_deleted_callbacks = list()
+        self._on_changed_callbacks = []
+        self._on_deleted_callbacks = []
 
     @abstractmethod
     def get(self, name: str) -> torch.Tensor:

invokeai/app/services/latents_storage/latents_storage_forward_cache.py

@@ -19,7 +19,7 @@ class ForwardCacheLatentsStorage(LatentsStorageBase):
     def __init__(self, underlying_storage: LatentsStorageBase, max_cache_size: int = 20):
         super().__init__()
         self.__underlying_storage = underlying_storage
-        self.__cache = dict()
+        self.__cache = {}
         self.__cache_ids = Queue()
         self.__max_cache_size = max_cache_size
 

invokeai/app/services/model_records/__init__.py

@@ -0,0 +1,8 @@
+"""Init file for model record services."""
+from .model_records_base import (  # noqa F401
+    DuplicateModelException,
+    InvalidModelException,
+    ModelRecordServiceBase,
+    UnknownModelException,
+)
+from .model_records_sql import ModelRecordServiceSQL  # noqa F401

invokeai/app/services/model_records/model_records_base.py

@@ -0,0 +1,169 @@
+# Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Development Team
+"""
+Abstract base class for storing and retrieving model configuration records.
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import List, Optional, Union
+
+from invokeai.backend.model_manager.config import AnyModelConfig, BaseModelType, ModelType
+
+# should match the InvokeAI version when this is first released.
+CONFIG_FILE_VERSION = "3.2.0"
+
+
+class DuplicateModelException(Exception):
+    """Raised on an attempt to add a model with the same key twice."""
+
+
+class InvalidModelException(Exception):
+    """Raised when an invalid model is detected."""
+
+
+class UnknownModelException(Exception):
+    """Raised on an attempt to fetch or delete a model with a nonexistent key."""
+
+
+class ConfigFileVersionMismatchException(Exception):
+    """Raised on an attempt to open a config with an incompatible version."""
+
+
+class ModelRecordServiceBase(ABC):
+    """Abstract base class for storage and retrieval of model configs."""
+
+    @property
+    @abstractmethod
+    def version(self) -> str:
+        """Return the config file/database schema version."""
+        pass
+
+    @abstractmethod
+    def add_model(self, key: str, config: Union[dict, AnyModelConfig]) -> AnyModelConfig:
+        """
+        Add a model to the database.
+
+        :param key: Unique key for the model
+        :param config: Model configuration record, either a dict with the
+         required fields or a ModelConfigBase instance.
+
+        Can raise DuplicateModelException and InvalidModelConfigException exceptions.
+        """
+        pass
+
+    @abstractmethod
+    def del_model(self, key: str) -> None:
+        """
+        Delete a model.
+
+        :param key: Unique key for the model to be deleted
+
+        Can raise an UnknownModelException
+        """
+        pass
+
+    @abstractmethod
+    def update_model(self, key: str, config: Union[dict, AnyModelConfig]) -> AnyModelConfig:
+        """
+        Update the model, returning the updated version.
+
+        :param key: Unique key for the model to be updated
+        :param config: Model configuration record. Either a dict with the
+         required fields, or a ModelConfigBase instance.
+        """
+        pass
+
+    @abstractmethod
+    def get_model(self, key: str) -> AnyModelConfig:
+        """
+        Retrieve the configuration for the indicated model.
+
+        :param key: Key of model config to be fetched.
+
+        Exceptions: UnknownModelException
+        """
+        pass
+
+    @abstractmethod
+    def exists(self, key: str) -> bool:
+        """
+        Return True if a model with the indicated key exists in the databse.
+
+        :param key: Unique key for the model to be deleted
+        """
+        pass
+
+    @abstractmethod
+    def search_by_path(
+        self,
+        path: Union[str, Path],
+    ) -> List[AnyModelConfig]:
+        """Return the model(s) having the indicated path."""
+        pass
+
+    @abstractmethod
+    def search_by_hash(
+        self,
+        hash: str,
+    ) -> List[AnyModelConfig]:
+        """Return the model(s) having the indicated original hash."""
+        pass
+
+    @abstractmethod
+    def search_by_attr(
+        self,
+        model_name: Optional[str] = None,
+        base_model: Optional[BaseModelType] = None,
+        model_type: Optional[ModelType] = None,
+    ) -> List[AnyModelConfig]:
+        """
+        Return models matching name, base and/or type.
+
+        :param model_name: Filter by name of model (optional)
+        :param base_model: Filter by base model (optional)
+        :param model_type: Filter by type of model (optional)
+
+        If none of the optional filters are passed, will return all
+        models in the database.
+        """
+        pass
+
+    def all_models(self) -> List[AnyModelConfig]:
+        """Return all the model configs in the database."""
+        return self.search_by_attr()
+
+    def model_info_by_name(self, model_name: str, base_model: BaseModelType, model_type: ModelType) -> AnyModelConfig:
+        """
+        Return information about a single model using its name, base type and model type.
+
+        If there are more than one model that match, raises a DuplicateModelException.
+        If no model matches, raises an UnknownModelException
+        """
+        model_configs = self.search_by_attr(model_name=model_name, base_model=base_model, model_type=model_type)
+        if len(model_configs) > 1:
+            raise DuplicateModelException(
+                f"More than one model matched the search criteria: base_model='{base_model}', model_type='{model_type}', model_name='{model_name}'."
+            )
+        if len(model_configs) == 0:
+            raise UnknownModelException(
+                f"More than one model matched the search criteria: base_model='{base_model}', model_type='{model_type}', model_name='{model_name}'."
+            )
+        return model_configs[0]
+
+    def rename_model(
+        self,
+        key: str,
+        new_name: str,
+    ) -> AnyModelConfig:
+        """
+        Rename the indicated model. Just a special case of update_model().
+
+        In some implementations, renaming the model may involve changing where
+        it is stored on the filesystem. So this is broken out.
+
+        :param key: Model key
+        :param new_name: New name for model
+        """
+        config = self.get_model(key)
+        config.name = new_name
+        return self.update_model(key, config)

invokeai/app/services/model_records/model_records_sql.py

@@ -0,0 +1,397 @@
+# Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Development Team
+"""
+SQL Implementation of the ModelRecordServiceBase API
+
+Typical usage:
+
+  from invokeai.backend.model_manager import ModelConfigStoreSQL
+  store = ModelConfigStoreSQL(sqlite_db)
+  config = dict(
+        path='/tmp/pokemon.bin',
+        name='old name',
+        base_model='sd-1',
+        type='embedding',
+        format='embedding_file',
+     )
+
+   # adding - the key becomes the model's "key" field
+   store.add_model('key1', config)
+
+   # updating
+   config.name='new name'
+   store.update_model('key1', config)
+
+   # checking for existence
+   if store.exists('key1'):
+      print("yes")
+
+   # fetching config
+   new_config = store.get_model('key1')
+   print(new_config.name, new_config.base)
+   assert new_config.key == 'key1'
+
+  # deleting
+  store.del_model('key1')
+
+  # searching
+  configs = store.search_by_path(path='/tmp/pokemon.bin')
+  configs = store.search_by_hash('750a499f35e43b7e1b4d15c207aa2f01')
+  configs = store.search_by_attr(base_model='sd-2', model_type='main')
+"""
+
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import List, Optional, Union
+
+from invokeai.backend.model_manager.config import (
+    AnyModelConfig,
+    BaseModelType,
+    ModelConfigBase,
+    ModelConfigFactory,
+    ModelType,
+)
+
+from ..shared.sqlite import SqliteDatabase
+from .model_records_base import (
+    CONFIG_FILE_VERSION,
+    DuplicateModelException,
+    ModelRecordServiceBase,
+    UnknownModelException,
+)
+
+
+class ModelRecordServiceSQL(ModelRecordServiceBase):
+    """Implementation of the ModelConfigStore ABC using a SQL database."""
+
+    _db: SqliteDatabase
+    _cursor: sqlite3.Cursor
+
+    def __init__(self, db: SqliteDatabase):
+        """
+        Initialize a new object from preexisting sqlite3 connection and threading lock objects.
+
+        :param conn: sqlite3 connection object
+        :param lock: threading Lock object
+        """
+        super().__init__()
+        self._db = db
+        self._cursor = self._db.conn.cursor()
+
+        with self._db.lock:
+            # Enable foreign keys
+            self._db.conn.execute("PRAGMA foreign_keys = ON;")
+            self._create_tables()
+            self._db.conn.commit()
+        assert (
+            str(self.version) == CONFIG_FILE_VERSION
+        ), f"Model config version {self.version} does not match expected version {CONFIG_FILE_VERSION}"
+
+    def _create_tables(self) -> None:
+        """Create sqlite3 tables."""
+        #  model_config table breaks out the fields that are common to all config objects
+        # and puts class-specific ones in a serialized json object
+        self._cursor.execute(
+            """--sql
+            CREATE TABLE IF NOT EXISTS model_config (
+                id TEXT NOT NULL PRIMARY KEY,
+                -- The next 3 fields are enums in python, unrestricted string here
+                base TEXT NOT NULL,
+                type TEXT NOT NULL,
+                name TEXT NOT NULL,
+                path TEXT NOT NULL,
+                original_hash TEXT, -- could be null
+                -- Serialized JSON representation of the whole config object,
+                -- which will contain additional fields from subclasses
+                config TEXT NOT NULL,
+                created_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
+                -- Updated via trigger
+                updated_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
+                -- unique constraint on combo of name, base and type
+                UNIQUE(name, base, type)
+            );
+            """
+        )
+
+        #  metadata table
+        self._cursor.execute(
+            """--sql
+            CREATE TABLE IF NOT EXISTS model_manager_metadata (
+                metadata_key TEXT NOT NULL PRIMARY KEY,
+                metadata_value TEXT NOT NULL
+            );
+            """
+        )
+
+        # Add trigger for `updated_at`.
+        self._cursor.execute(
+            """--sql
+            CREATE TRIGGER IF NOT EXISTS model_config_updated_at
+            AFTER UPDATE
+            ON model_config FOR EACH ROW
+            BEGIN
+                UPDATE model_config SET updated_at = STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')
+                    WHERE id = old.id;
+            END;
+            """
+        )
+
+        # Add indexes for searchable fields
+        for stmt in [
+            "CREATE INDEX IF NOT EXISTS base_index ON model_config(base);",
+            "CREATE INDEX IF NOT EXISTS type_index ON model_config(type);",
+            "CREATE INDEX IF NOT EXISTS name_index ON model_config(name);",
+            "CREATE UNIQUE INDEX IF NOT EXISTS path_index ON model_config(path);",
+        ]:
+            self._cursor.execute(stmt)
+
+        # Add our version to the metadata table
+        self._cursor.execute(
+            """--sql
+            INSERT OR IGNORE into model_manager_metadata (
+               metadata_key,
+               metadata_value
+            )
+            VALUES (?,?);
+            """,
+            ("version", CONFIG_FILE_VERSION),
+        )
+
+    def add_model(self, key: str, config: Union[dict, ModelConfigBase]) -> AnyModelConfig:
+        """
+        Add a model to the database.
+
+        :param key: Unique key for the model
+        :param config: Model configuration record, either a dict with the
+         required fields or a ModelConfigBase instance.
+
+        Can raise DuplicateModelException and InvalidModelConfigException exceptions.
+        """
+        record = ModelConfigFactory.make_config(config, key=key)  # ensure it is a valid config obect.
+        json_serialized = record.model_dump_json()  # and turn it into a json string.
+        with self._db.lock:
+            try:
+                self._cursor.execute(
+                    """--sql
+                    INSERT INTO model_config (
+                       id,
+                       base,
+                       type,
+                       name,
+                       path,
+                       original_hash,
+                       config
+                      )
+                    VALUES (?,?,?,?,?,?,?);
+                    """,
+                    (
+                        key,
+                        record.base,
+                        record.type,
+                        record.name,
+                        record.path,
+                        record.original_hash,
+                        json_serialized,
+                    ),
+                )
+                self._db.conn.commit()
+
+            except sqlite3.IntegrityError as e:
+                self._db.conn.rollback()
+                if "UNIQUE constraint failed" in str(e):
+                    if "model_config.path" in str(e):
+                        msg = f"A model with path '{record.path}' is already installed"
+                    elif "model_config.name" in str(e):
+                        msg = f"A model with name='{record.name}', type='{record.type}', base='{record.base}' is already installed"
+                    else:
+                        msg = f"A model with key '{key}' is already installed"
+                    raise DuplicateModelException(msg) from e
+                else:
+                    raise e
+            except sqlite3.Error as e:
+                self._db.conn.rollback()
+                raise e
+
+        return self.get_model(key)
+
+    @property
+    def version(self) -> str:
+        """Return the version of the database schema."""
+        with self._db.lock:
+            self._cursor.execute(
+                """--sql
+                SELECT metadata_value FROM model_manager_metadata
+                WHERE metadata_key=?;
+                """,
+                ("version",),
+            )
+            rows = self._cursor.fetchone()
+            if not rows:
+                raise KeyError("Models database does not have metadata key 'version'")
+            return rows[0]
+
+    def del_model(self, key: str) -> None:
+        """
+        Delete a model.
+
+        :param key: Unique key for the model to be deleted
+
+        Can raise an UnknownModelException
+        """
+        with self._db.lock:
+            try:
+                self._cursor.execute(
+                    """--sql
+                    DELETE FROM model_config
+                    WHERE id=?;
+                    """,
+                    (key,),
+                )
+                if self._cursor.rowcount == 0:
+                    raise UnknownModelException("model not found")
+                self._db.conn.commit()
+            except sqlite3.Error as e:
+                self._db.conn.rollback()
+                raise e
+
+    def update_model(self, key: str, config: ModelConfigBase) -> AnyModelConfig:
+        """
+        Update the model, returning the updated version.
+
+        :param key: Unique key for the model to be updated
+        :param config: Model configuration record. Either a dict with the
+         required fields, or a ModelConfigBase instance.
+        """
+        record = ModelConfigFactory.make_config(config, key=key)  # ensure it is a valid config obect
+        json_serialized = record.model_dump_json()  # and turn it into a json string.
+        with self._db.lock:
+            try:
+                self._cursor.execute(
+                    """--sql
+                    UPDATE model_config
+                    SET base=?,
+                        type=?,
+                        name=?,
+                        path=?,
+                        config=?
+                    WHERE id=?;
+                    """,
+                    (record.base, record.type, record.name, record.path, json_serialized, key),
+                )
+                if self._cursor.rowcount == 0:
+                    raise UnknownModelException("model not found")
+                self._db.conn.commit()
+            except sqlite3.Error as e:
+                self._db.conn.rollback()
+                raise e
+
+        return self.get_model(key)
+
+    def get_model(self, key: str) -> AnyModelConfig:
+        """
+        Retrieve the ModelConfigBase instance for the indicated model.
+
+        :param key: Key of model config to be fetched.
+
+        Exceptions: UnknownModelException
+        """
+        with self._db.lock:
+            self._cursor.execute(
+                """--sql
+                SELECT config FROM model_config
+                WHERE id=?;
+                """,
+                (key,),
+            )
+            rows = self._cursor.fetchone()
+            if not rows:
+                raise UnknownModelException("model not found")
+            model = ModelConfigFactory.make_config(json.loads(rows[0]))
+        return model
+
+    def exists(self, key: str) -> bool:
+        """
+        Return True if a model with the indicated key exists in the databse.
+
+        :param key: Unique key for the model to be deleted
+        """
+        count = 0
+        with self._db.lock:
+            self._cursor.execute(
+                """--sql
+                select count(*) FROM model_config
+                WHERE id=?;
+                """,
+                (key,),
+            )
+            count = self._cursor.fetchone()[0]
+        return count > 0
+
+    def search_by_attr(
+        self,
+        model_name: Optional[str] = None,
+        base_model: Optional[BaseModelType] = None,
+        model_type: Optional[ModelType] = None,
+    ) -> List[AnyModelConfig]:
+        """
+        Return models matching name, base and/or type.
+
+        :param model_name: Filter by name of model (optional)
+        :param base_model: Filter by base model (optional)
+        :param model_type: Filter by type of model (optional)
+
+        If none of the optional filters are passed, will return all
+        models in the database.
+        """
+        results = []
+        where_clause = []
+        bindings = []
+        if model_name:
+            where_clause.append("name=?")
+            bindings.append(model_name)
+        if base_model:
+            where_clause.append("base=?")
+            bindings.append(base_model)
+        if model_type:
+            where_clause.append("type=?")
+            bindings.append(model_type)
+        where = f"WHERE {' AND '.join(where_clause)}" if where_clause else ""
+        with self._db.lock:
+            self._cursor.execute(
+                f"""--sql
+                select config FROM model_config
+                {where};
+                """,
+                tuple(bindings),
+            )
+            results = [ModelConfigFactory.make_config(json.loads(x[0])) for x in self._cursor.fetchall()]
+        return results
+
+    def search_by_path(self, path: Union[str, Path]) -> List[ModelConfigBase]:
+        """Return models with the indicated path."""
+        results = []
+        with self._db.lock:
+            self._cursor.execute(
+                """--sql
+                SELECT config FROM model_config
+                WHERE model_path=?;
+                """,
+                (str(path),),
+            )
+            results = [ModelConfigFactory.make_config(json.loads(x[0])) for x in self._cursor.fetchall()]
+        return results
+
+    def search_by_hash(self, hash: str) -> List[ModelConfigBase]:
+        """Return models with the indicated original_hash."""
+        results = []
+        with self._db.lock:
+            self._cursor.execute(
+                """--sql
+                SELECT config FROM model_config
+                WHERE original_hash=?;
+                """,
+                (hash,),
+            )
+            results = [ModelConfigFactory.make_config(json.loads(x[0])) for x in self._cursor.fetchall()]
+        return results

invokeai/app/services/session_processor/session_processor_default.py

@@ -33,9 +33,11 @@ class DefaultSessionProcessor(SessionProcessorBase):
         self.__thread = Thread(
             name="session_processor",
             target=self.__process,
-            kwargs=dict(
-                stop_event=self.__stop_event, poll_now_event=self.__poll_now_event, resume_event=self.__resume_event
-            ),
+            kwargs={
+                "stop_event": self.__stop_event,
+                "poll_now_event": self.__poll_now_event,
+                "resume_event": self.__resume_event,
+            },
         )
         self.__thread.start()
 

invokeai/app/services/session_queue/session_queue_common.py

@@ -129,12 +129,12 @@ class Batch(BaseModel):
         return v
 
     model_config = ConfigDict(
-        json_schema_extra=dict(
-            required=[
+        json_schema_extra={
+            "required": [
                 "graph",
                 "runs",
             ]
-        )
+        }
     )
 
 
@@ -191,8 +191,8 @@ class SessionQueueItemWithoutGraph(BaseModel):
         return SessionQueueItemDTO(**queue_item_dict)
 
     model_config = ConfigDict(
-        json_schema_extra=dict(
-            required=[
+        json_schema_extra={
+            "required": [
                 "item_id",
                 "status",
                 "batch_id",
@@ -203,7 +203,7 @@ class SessionQueueItemWithoutGraph(BaseModel):
                 "created_at",
                 "updated_at",
             ]
-        )
+        }
     )
 
 
@@ -222,8 +222,8 @@ class SessionQueueItem(SessionQueueItemWithoutGraph):
         return SessionQueueItem(**queue_item_dict)
 
     model_config = ConfigDict(
-        json_schema_extra=dict(
-            required=[
+        json_schema_extra={
+            "required": [
                 "item_id",
                 "status",
                 "batch_id",
@@ -235,7 +235,7 @@ class SessionQueueItem(SessionQueueItemWithoutGraph):
                 "created_at",
                 "updated_at",
             ]
-        )
+        }
     )
 
 
@@ -355,7 +355,7 @@ def create_session_nfv_tuples(
                 for item in batch_datum.items
             ]
             node_field_values_to_zip.append(node_field_values)
-        data.append(list(zip(*node_field_values_to_zip)))  # type: ignore [arg-type]
+        data.append(list(zip(*node_field_values_to_zip, strict=True)))  # type: ignore [arg-type]
 
     # create generator to yield session,nfv tuples
     count = 0
@@ -383,7 +383,7 @@ def calc_session_count(batch: Batch) -> int:
         for batch_datum in batch_datum_list:
             batch_data_items = range(len(batch_datum.items))
             to_zip.append(batch_data_items)
-        data.append(list(zip(*to_zip)))
+        data.append(list(zip(*to_zip, strict=True)))
     data_product = list(product(*data))
     return len(data_product) * batch.runs
 

invokeai/app/services/shared/default_graphs.py

@@ -78,7 +78,7 @@ def create_system_graphs(graph_library: ItemStorageABC[LibraryGraph]) -> list[Li
     """Creates the default system graphs, or adds new versions if the old ones don't match"""
 
     # TODO: Uncomment this when we are ready to fix this up to prevent breaking changes
-    graphs: list[LibraryGraph] = list()
+    graphs: list[LibraryGraph] = []
 
     text_to_image = graph_library.get(default_text_to_image_graph_id)
 

invokeai/app/services/shared/graph.py

@@ -352,7 +352,7 @@ class Graph(BaseModel):
 
         # Validate that all node ids are unique
         node_ids = [n.id for n in self.nodes.values()]
-        duplicate_node_ids = set([node_id for node_id in node_ids if node_ids.count(node_id) >= 2])
+        duplicate_node_ids = {node_id for node_id in node_ids if node_ids.count(node_id) >= 2}
         if duplicate_node_ids:
             raise DuplicateNodeIdError(f"Node ids must be unique, found duplicates {duplicate_node_ids}")
 
@@ -616,7 +616,7 @@ class Graph(BaseModel):
         self, node_path: str, prefix: Optional[str] = None
     ) -> list[tuple["Graph", Union[str, None], Edge]]:
         """Gets all input edges for a node along with the graph they are in and the graph's path"""
-        edges = list()
+        edges = []
 
         # Return any input edges that appear in this graph
         edges.extend([(self, prefix, e) for e in self.edges if e.destination.node_id == node_path])
@@ -658,7 +658,7 @@ class Graph(BaseModel):
         self, node_path: str, prefix: Optional[str] = None
     ) -> list[tuple["Graph", Union[str, None], Edge]]:
         """Gets all output edges for a node along with the graph they are in and the graph's path"""
-        edges = list()
+        edges = []
 
         # Return any input edges that appear in this graph
         edges.extend([(self, prefix, e) for e in self.edges if e.source.node_id == node_path])
@@ -680,8 +680,8 @@ class Graph(BaseModel):
         new_input: Optional[EdgeConnection] = None,
         new_output: Optional[EdgeConnection] = None,
     ) -> bool:
-        inputs = list([e.source for e in self._get_input_edges(node_path, "collection")])
-        outputs = list([e.destination for e in self._get_output_edges(node_path, "item")])
+        inputs = [e.source for e in self._get_input_edges(node_path, "collection")]
+        outputs = [e.destination for e in self._get_output_edges(node_path, "item")]
 
         if new_input is not None:
             inputs.append(new_input)
@@ -694,7 +694,7 @@ class Graph(BaseModel):
 
         # Get input and output fields (the fields linked to the iterator's input/output)
         input_field = get_output_field(self.get_node(inputs[0].node_id), inputs[0].field)
-        output_fields = list([get_input_field(self.get_node(e.node_id), e.field) for e in outputs])
+        output_fields = [get_input_field(self.get_node(e.node_id), e.field) for e in outputs]
 
         # Input type must be a list
         if get_origin(input_field) != list:
@@ -713,8 +713,8 @@ class Graph(BaseModel):
         new_input: Optional[EdgeConnection] = None,
         new_output: Optional[EdgeConnection] = None,
     ) -> bool:
-        inputs = list([e.source for e in self._get_input_edges(node_path, "item")])
-        outputs = list([e.destination for e in self._get_output_edges(node_path, "collection")])
+        inputs = [e.source for e in self._get_input_edges(node_path, "item")]
+        outputs = [e.destination for e in self._get_output_edges(node_path, "collection")]
 
         if new_input is not None:
             inputs.append(new_input)
@@ -722,18 +722,16 @@ class Graph(BaseModel):
             outputs.append(new_output)
 
         # Get input and output fields (the fields linked to the iterator's input/output)
-        input_fields = list([get_output_field(self.get_node(e.node_id), e.field) for e in inputs])
-        output_fields = list([get_input_field(self.get_node(e.node_id), e.field) for e in outputs])
+        input_fields = [get_output_field(self.get_node(e.node_id), e.field) for e in inputs]
+        output_fields = [get_input_field(self.get_node(e.node_id), e.field) for e in outputs]
 
         # Validate that all inputs are derived from or match a single type
-        input_field_types = set(
-            [
-                t
-                for input_field in input_fields
-                for t in ([input_field] if get_origin(input_field) is None else get_args(input_field))
-                if t != NoneType
-            ]
-        )  # Get unique types
+        input_field_types = {
+            t
+            for input_field in input_fields
+            for t in ([input_field] if get_origin(input_field) is None else get_args(input_field))
+            if t != NoneType
+        }  # Get unique types
         type_tree = nx.DiGraph()
         type_tree.add_nodes_from(input_field_types)
         type_tree.add_edges_from([e for e in itertools.permutations(input_field_types, 2) if issubclass(e[1], e[0])])
@@ -761,15 +759,15 @@ class Graph(BaseModel):
         """Returns a NetworkX DiGraph representing the layout of this graph"""
         # TODO: Cache this?
         g = nx.DiGraph()
-        g.add_nodes_from([n for n in self.nodes.keys()])
-        g.add_edges_from(set([(e.source.node_id, e.destination.node_id) for e in self.edges]))
+        g.add_nodes_from(list(self.nodes.keys()))
+        g.add_edges_from({(e.source.node_id, e.destination.node_id) for e in self.edges})
         return g
 
     def nx_graph_with_data(self) -> nx.DiGraph:
         """Returns a NetworkX DiGraph representing the data and layout of this graph"""
         g = nx.DiGraph()
-        g.add_nodes_from([n for n in self.nodes.items()])
-        g.add_edges_from(set([(e.source.node_id, e.destination.node_id) for e in self.edges]))
+        g.add_nodes_from(list(self.nodes.items()))
+        g.add_edges_from({(e.source.node_id, e.destination.node_id) for e in self.edges})
         return g
 
     def nx_graph_flat(self, nx_graph: Optional[nx.DiGraph] = None, prefix: Optional[str] = None) -> nx.DiGraph:
@@ -791,7 +789,7 @@ class Graph(BaseModel):
 
         # TODO: figure out if iteration nodes need to be expanded
 
-        unique_edges = set([(e.source.node_id, e.destination.node_id) for e in self.edges])
+        unique_edges = {(e.source.node_id, e.destination.node_id) for e in self.edges}
         g.add_edges_from([(self._get_node_path(e[0], prefix), self._get_node_path(e[1], prefix)) for e in unique_edges])
         return g
 
@@ -843,8 +841,8 @@ class GraphExecutionState(BaseModel):
         return v
 
     model_config = ConfigDict(
-        json_schema_extra=dict(
-            required=[
+        json_schema_extra={
+            "required": [
                 "id",
                 "graph",
                 "execution_graph",
@@ -855,7 +853,7 @@ class GraphExecutionState(BaseModel):
                 "prepared_source_mapping",
                 "source_prepared_mapping",
             ]
-        )
+        }
     )
 
     def next(self) -> Optional[BaseInvocation]:
@@ -895,7 +893,7 @@ class GraphExecutionState(BaseModel):
         source_node = self.prepared_source_mapping[node_id]
         prepared_nodes = self.source_prepared_mapping[source_node]
 
-        if all([n in self.executed for n in prepared_nodes]):
+        if all(n in self.executed for n in prepared_nodes):
             self.executed.add(source_node)
             self.executed_history.append(source_node)
 
@@ -930,7 +928,7 @@ class GraphExecutionState(BaseModel):
             input_collection = getattr(input_collection_prepared_node_output, input_collection_edge.source.field)
             self_iteration_count = len(input_collection)
 
-        new_nodes: list[str] = list()
+        new_nodes: list[str] = []
         if self_iteration_count == 0:
             # TODO: should this raise a warning? It might just happen if an empty collection is input, and should be valid.
             return new_nodes
@@ -940,7 +938,7 @@ class GraphExecutionState(BaseModel):
 
         # Create new edges for this iteration
         # For collect nodes, this may contain multiple inputs to the same field
-        new_edges: list[Edge] = list()
+        new_edges: list[Edge] = []
         for edge in input_edges:
             for input_node_id in (n[1] for n in iteration_node_map if n[0] == edge.source.node_id):
                 new_edge = Edge(
@@ -1034,7 +1032,7 @@ class GraphExecutionState(BaseModel):
 
         # Create execution nodes
         next_node = self.graph.get_node(next_node_id)
-        new_node_ids = list()
+        new_node_ids = []
         if isinstance(next_node, CollectInvocation):
             # Collapse all iterator input mappings and create a single execution node for the collect invocation
             all_iteration_mappings = list(
@@ -1055,7 +1053,10 @@ class GraphExecutionState(BaseModel):
             # For every iterator, the parent must either not be a child of that iterator, or must match the prepared iteration for that iterator
             # TODO: Handle a node mapping to none
             eg = self.execution_graph.nx_graph_flat()
-            prepared_parent_mappings = [[(n, self._get_iteration_node(n, g, eg, it)) for n in next_node_parents] for it in iterator_node_prepared_combinations]  # type: ignore
+            prepared_parent_mappings = [
+                [(n, self._get_iteration_node(n, g, eg, it)) for n in next_node_parents]
+                for it in iterator_node_prepared_combinations
+            ]  # type: ignore
 
             # Create execution node for each iteration
             for iteration_mappings in prepared_parent_mappings:
@@ -1121,7 +1122,7 @@ class GraphExecutionState(BaseModel):
                 for edge in input_edges
                 if edge.destination.field == "item"
             ]
-            setattr(node, "collection", output_collection)
+            node.collection = output_collection
         else:
             for edge in input_edges:
                 output_value = getattr(self.results[edge.source.node_id], edge.source.field)
@@ -1201,7 +1202,7 @@ class LibraryGraph(BaseModel):
 
     @field_validator("exposed_inputs", "exposed_outputs")
     def validate_exposed_aliases(cls, v: list[Union[ExposedNodeInput, ExposedNodeOutput]]):
-        if len(v) != len(set(i.alias for i in v)):
+        if len(v) != len({i.alias for i in v}):
             raise ValueError("Duplicate exposed alias")
         return v
 

invokeai/app/services/workflow_records/workflow_records_sqlite.py

@@ -57,7 +57,7 @@ class SqliteWorkflowRecordsStorage(WorkflowRecordsStorageBase):
                 INSERT INTO workflows(workflow)
                 VALUES (?);
                 """,
-                (workflow.json(),),
+                (workflow.model_dump_json(),),
             )
             self._conn.commit()
         except Exception:

invokeai/app/shared/__init__.py

@@ -0,0 +1,5 @@
+"""
+This module contains various classes, functions and models which are shared across the app, particularly by invocations.
+
+Lifting these classes, functions and models into this shared module helps to reduce circular imports.
+"""

invokeai/app/shared/fields.py

@@ -0,0 +1,66 @@
+class FieldDescriptions:
+    denoising_start = "When to start denoising, expressed a percentage of total steps"
+    denoising_end = "When to stop denoising, expressed a percentage of total steps"
+    cfg_scale = "Classifier-Free Guidance scale"
+    scheduler = "Scheduler to use during inference"
+    positive_cond = "Positive conditioning tensor"
+    negative_cond = "Negative conditioning tensor"
+    noise = "Noise tensor"
+    clip = "CLIP (tokenizer, text encoder, LoRAs) and skipped layer count"
+    unet = "UNet (scheduler, LoRAs)"
+    vae = "VAE"
+    cond = "Conditioning tensor"
+    controlnet_model = "ControlNet model to load"
+    vae_model = "VAE model to load"
+    lora_model = "LoRA model to load"
+    main_model = "Main model (UNet, VAE, CLIP) to load"
+    sdxl_main_model = "SDXL Main model (UNet, VAE, CLIP1, CLIP2) to load"
+    sdxl_refiner_model = "SDXL Refiner Main Modde (UNet, VAE, CLIP2) to load"
+    onnx_main_model = "ONNX Main model (UNet, VAE, CLIP) to load"
+    lora_weight = "The weight at which the LoRA is applied to each model"
+    compel_prompt = "Prompt to be parsed by Compel to create a conditioning tensor"
+    raw_prompt = "Raw prompt text (no parsing)"
+    sdxl_aesthetic = "The aesthetic score to apply to the conditioning tensor"
+    skipped_layers = "Number of layers to skip in text encoder"
+    seed = "Seed for random number generation"
+    steps = "Number of steps to run"
+    width = "Width of output (px)"
+    height = "Height of output (px)"
+    control = "ControlNet(s) to apply"
+    ip_adapter = "IP-Adapter to apply"
+    t2i_adapter = "T2I-Adapter(s) to apply"
+    denoised_latents = "Denoised latents tensor"
+    latents = "Latents tensor"
+    strength = "Strength of denoising (proportional to steps)"
+    metadata = "Optional metadata to be saved with the image"
+    metadata_collection = "Collection of Metadata"
+    metadata_item_polymorphic = "A single metadata item or collection of metadata items"
+    metadata_item_label = "Label for this metadata item"
+    metadata_item_value = "The value for this metadata item (may be any type)"
+    workflow = "Optional workflow to be saved with the image"
+    interp_mode = "Interpolation mode"
+    torch_antialias = "Whether or not to apply antialiasing (bilinear or bicubic only)"
+    fp32 = "Whether or not to use full float32 precision"
+    precision = "Precision to use"
+    tiled = "Processing using overlapping tiles (reduce memory consumption)"
+    detect_res = "Pixel resolution for detection"
+    image_res = "Pixel resolution for output image"
+    safe_mode = "Whether or not to use safe mode"
+    scribble_mode = "Whether or not to use scribble mode"
+    scale_factor = "The factor by which to scale"
+    blend_alpha = (
+        "Blending factor. 0.0 = use input A only, 1.0 = use input B only, 0.5 = 50% mix of input A and input B."
+    )
+    num_1 = "The first number"
+    num_2 = "The second number"
+    mask = "The mask to use for the operation"
+    board = "The board to save the image to"
+    image = "The image to process"
+    tile_size = "Tile size"
+    inclusive_low = "The inclusive low value"
+    exclusive_high = "The exclusive high value"
+    decimal_places = "The number of decimal places to round to"
+    freeu_s1 = 'Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to mitigate the "oversmoothing effect" in the enhanced denoising process.'
+    freeu_s2 = 'Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to mitigate the "oversmoothing effect" in the enhanced denoising process.'
+    freeu_b1 = "Scaling factor for stage 1 to amplify the contributions of backbone features."
+    freeu_b2 = "Scaling factor for stage 2 to amplify the contributions of backbone features."

invokeai/app/shared/models.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, Field
+
+from invokeai.app.shared.fields import FieldDescriptions
+
+
+class FreeUConfig(BaseModel):
+    """
+    Configuration for the FreeU hyperparameters.
+    - https://huggingface.co/docs/diffusers/main/en/using-diffusers/freeu
+    - https://github.com/ChenyangSi/FreeU
+    """
+
+    s1: float = Field(ge=-1, le=3, description=FieldDescriptions.freeu_s1)
+    s2: float = Field(ge=-1, le=3, description=FieldDescriptions.freeu_s2)
+    b1: float = Field(ge=-1, le=3, description=FieldDescriptions.freeu_b1)
+    b2: float = Field(ge=-1, le=3, description=FieldDescriptions.freeu_b2)

invokeai/app/util/controlnet_utils.py

@@ -59,7 +59,7 @@ def thin_one_time(x, kernels):
 
 def lvmin_thin(x, prunings=True):
     y = x
-    for i in range(32):
+    for _i in range(32):
         y, is_done = thin_one_time(y, lvmin_kernels)
         if is_done:
             break

invokeai/app/util/metadata.py

@@ -21,11 +21,11 @@ def get_metadata_graph_from_raw_session(session_raw: str) -> Optional[dict]:
 
     # sanity check make sure the graph is at least reasonably shaped
     if (
-        type(graph) is not dict
+        not isinstance(graph, dict)
         or "nodes" not in graph
-        or type(graph["nodes"]) is not dict
+        or not isinstance(graph["nodes"], dict)
         or "edges" not in graph
-        or type(graph["edges"]) is not list
+        or not isinstance(graph["edges"], list)
     ):
         # something has gone terribly awry, return an empty dict
         return None

invokeai/backend/image_util/pngwriter.py

@@ -88,7 +88,7 @@ class PromptFormatter:
         t2i = self.t2i
         opt = self.opt
 
-        switches = list()
+        switches = []
         switches.append(f'"{opt.prompt}"')
         switches.append(f"-s{opt.steps        or t2i.steps}")
         switches.append(f"-W{opt.width        or t2i.width}")

invokeai/backend/image_util/txt2mask.py

@@ -88,7 +88,7 @@ class Txt2Mask(object):
         provided image and returns a SegmentedGrayscale object in which the brighter
         pixels indicate where the object is inferred to be.
         """
-        if type(image) is str:
+        if isinstance(image, str):
             image = Image.open(image).convert("RGB")
 
         image = ImageOps.exif_transpose(image)

invokeai/backend/image_util/util.py

@@ -40,7 +40,7 @@ class InitImageResizer:
         (rw, rh) = (int(scale * im.width), int(scale * im.height))
 
         # round everything to multiples of 64
-        width, height, rw, rh = map(lambda x: x - x % 64, (width, height, rw, rh))
+        width, height, rw, rh = (x - x % 64 for x in (width, height, rw, rh))
 
         # no resize necessary, but return a copy
         if im.width == width and im.height == height:

invokeai/backend/install/invokeai_configure.py

@@ -32,7 +32,7 @@ from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionS
 from huggingface_hub import HfFolder
 from huggingface_hub import login as hf_hub_login
 from omegaconf import OmegaConf
-from pydantic.error_wrappers import ValidationError
+from pydantic import ValidationError
 from tqdm import tqdm
 from transformers import AutoFeatureExtractor, BertTokenizerFast, CLIPTextConfig, CLIPTextModel, CLIPTokenizer
 
@@ -197,7 +197,7 @@ def download_with_progress_bar(model_url: str, model_dest: str, label: str = "th
 
 def download_conversion_models():
     target_dir = config.models_path / "core/convert"
-    kwargs = dict()  # for future use
+    kwargs = {}  # for future use
     try:
         logger.info("Downloading core tokenizers and text encoders")
 
@@ -252,26 +252,26 @@ def download_conversion_models():
 def download_realesrgan():
     logger.info("Installing ESRGAN Upscaling models...")
     URLs = [
-        dict(
-            url="https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth",
-            dest="core/upscaling/realesrgan/RealESRGAN_x4plus.pth",
-            description="RealESRGAN_x4plus.pth",
-        ),
-        dict(
-            url="https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth",
-            dest="core/upscaling/realesrgan/RealESRGAN_x4plus_anime_6B.pth",
-            description="RealESRGAN_x4plus_anime_6B.pth",
-        ),
-        dict(
-            url="https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/ESRGAN_SRx4_DF2KOST_official-ff704c30.pth",
-            dest="core/upscaling/realesrgan/ESRGAN_SRx4_DF2KOST_official-ff704c30.pth",
-            description="ESRGAN_SRx4_DF2KOST_official.pth",
-        ),
-        dict(
-            url="https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth",
-            dest="core/upscaling/realesrgan/RealESRGAN_x2plus.pth",
-            description="RealESRGAN_x2plus.pth",
-        ),
+        {
+            "url": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth",
+            "dest": "core/upscaling/realesrgan/RealESRGAN_x4plus.pth",
+            "description": "RealESRGAN_x4plus.pth",
+        },
+        {
+            "url": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth",
+            "dest": "core/upscaling/realesrgan/RealESRGAN_x4plus_anime_6B.pth",
+            "description": "RealESRGAN_x4plus_anime_6B.pth",
+        },
+        {
+            "url": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/ESRGAN_SRx4_DF2KOST_official-ff704c30.pth",
+            "dest": "core/upscaling/realesrgan/ESRGAN_SRx4_DF2KOST_official-ff704c30.pth",
+            "description": "ESRGAN_SRx4_DF2KOST_official.pth",
+        },
+        {
+            "url": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth",
+            "dest": "core/upscaling/realesrgan/RealESRGAN_x2plus.pth",
+            "description": "RealESRGAN_x2plus.pth",
+        },
     ]
     for model in URLs:
         download_with_progress_bar(model["url"], config.models_path / model["dest"], model["description"])
@@ -680,7 +680,7 @@ def default_user_selections(program_opts: Namespace) -> InstallSelections:
         if program_opts.default_only
         else [models[x].path or models[x].repo_id for x in installer.recommended_models()]
         if program_opts.yes_to_all
-        else list(),
+        else [],
     )
 
 

invokeai/backend/install/legacy_arg_parsing.py

@@ -38,6 +38,7 @@ SAMPLER_CHOICES = [
     "k_heun",
     "k_lms",
     "plms",
+    "lcm",
 ]
 
 PRECISION_CHOICES = [

invokeai/backend/install/migrate_to_3.py

@@ -123,8 +123,6 @@ class MigrateTo3(object):
                     logger.error(str(e))
                 except KeyboardInterrupt:
                     raise
-                except Exception as e:
-                    logger.error(str(e))
             for f in files:
                 # don't copy raw learned_embeds.bin or pytorch_lora_weights.bin
                 # let them be copied as part of a tree copy operation
@@ -143,8 +141,6 @@ class MigrateTo3(object):
                     logger.error(str(e))
                 except KeyboardInterrupt:
                     raise
-                except Exception as e:
-                    logger.error(str(e))
 
     def migrate_support_models(self):
         """
@@ -182,10 +178,10 @@ class MigrateTo3(object):
         """
 
         dest_directory = self.dest_models
-        kwargs = dict(
-            cache_dir=self.root_directory / "models/hub",
+        kwargs = {
+            "cache_dir": self.root_directory / "models/hub",
             # local_files_only = True
-        )
+        }
         try:
             logger.info("Migrating core tokenizers and text encoders")
             target_dir = dest_directory / "core" / "convert"
@@ -316,11 +312,11 @@ class MigrateTo3(object):
         dest_dir = self.dest_models
 
         cache = self.root_directory / "models/hub"
-        kwargs = dict(
-            cache_dir=cache,
-            safety_checker=None,
+        kwargs = {
+            "cache_dir": cache,
+            "safety_checker": None,
             # local_files_only = True,
-        )
+        }
 
         owner, repo_name = repo_id.split("/")
         model_name = model_name or repo_name

invokeai/backend/install/model_install_backend.py

@@ -120,7 +120,7 @@ class ModelInstall(object):
         be treated uniformly. It also sorts the models alphabetically
         by their name, to improve the display somewhat.
         """
-        model_dict = dict()
+        model_dict = {}
 
         # first populate with the entries in INITIAL_MODELS.yaml
         for key, value in self.datasets.items():
@@ -134,7 +134,7 @@ class ModelInstall(object):
             model_dict[key] = model_info
 
         # supplement with entries in models.yaml
-        installed_models = [x for x in self.mgr.list_models()]
+        installed_models = list(self.mgr.list_models())
 
         for md in installed_models:
             base = md["base_model"]
@@ -176,7 +176,7 @@ class ModelInstall(object):
     # logic here a little reversed to maintain backward compatibility
     def starter_models(self, all_models: bool = False) -> Set[str]:
         models = set()
-        for key, value in self.datasets.items():
+        for key, _value in self.datasets.items():
             name, base, model_type = ModelManager.parse_key(key)
             if all_models or model_type in [ModelType.Main, ModelType.Vae]:
                 models.add(key)
@@ -184,7 +184,7 @@ class ModelInstall(object):
 
     def recommended_models(self) -> Set[str]:
         starters = self.starter_models(all_models=True)
-        return set([x for x in starters if self.datasets[x].get("recommended", False)])
+        return {x for x in starters if self.datasets[x].get("recommended", False)}
 
     def default_model(self) -> str:
         starters = self.starter_models()
@@ -234,7 +234,7 @@ class ModelInstall(object):
         """
 
         if not models_installed:
-            models_installed = dict()
+            models_installed = {}
 
         model_path_id_or_url = str(model_path_id_or_url).strip("\"' ")
 
@@ -252,10 +252,14 @@ class ModelInstall(object):
 
         # folders style or similar
         elif path.is_dir() and any(
-            [
-                (path / x).exists()
-                for x in {"config.json", "model_index.json", "learned_embeds.bin", "pytorch_lora_weights.bin"}
-            ]
+            (path / x).exists()
+            for x in {
+                "config.json",
+                "model_index.json",
+                "learned_embeds.bin",
+                "pytorch_lora_weights.bin",
+                "pytorch_lora_weights.safetensors",
+            }
         ):
             models_installed.update({str(model_path_id_or_url): self._install_path(path)})
 
@@ -357,7 +361,7 @@ class ModelInstall(object):
                 for suffix in ["safetensors", "bin"]:
                     if f"{prefix}pytorch_lora_weights.{suffix}" in files:
                         location = self._download_hf_model(
-                            repo_id, ["pytorch_lora_weights.bin"], staging, subfolder=subfolder
+                            repo_id, [f"pytorch_lora_weights.{suffix}"], staging, subfolder=subfolder
                         )  # LoRA
                         break
                     elif (
@@ -427,17 +431,17 @@ class ModelInstall(object):
 
         rel_path = self.relative_to_root(path, self.config.models_path)
 
-        attributes = dict(
-            path=str(rel_path),
-            description=str(description),
-            model_format=info.format,
-        )
+        attributes = {
+            "path": str(rel_path),
+            "description": str(description),
+            "model_format": info.format,
+        }
         legacy_conf = None
         if info.model_type == ModelType.Main or info.model_type == ModelType.ONNX:
             attributes.update(
-                dict(
-                    variant=info.variant_type,
-                )
+                {
+                    "variant": info.variant_type,
+                }
             )
             if info.format == "checkpoint":
                 try:
@@ -468,7 +472,7 @@ class ModelInstall(object):
                 )
 
         if legacy_conf:
-            attributes.update(dict(config=str(legacy_conf)))
+            attributes.update({"config": str(legacy_conf)})
         return attributes
 
     def relative_to_root(self, path: Path, root: Optional[Path] = None) -> Path:
@@ -513,7 +517,7 @@ class ModelInstall(object):
     def _download_hf_model(self, repo_id: str, files: List[str], staging: Path, subfolder: None) -> Path:
         _, name = repo_id.split("/")
         location = staging / name
-        paths = list()
+        paths = []
         for filename in files:
             filePath = Path(filename)
             p = hf_download_with_resume(

invokeai/backend/ip_adapter/attention_processor.py

@@ -130,7 +130,9 @@ class IPAttnProcessor2_0(torch.nn.Module):
             assert ip_adapter_image_prompt_embeds is not None
             assert len(ip_adapter_image_prompt_embeds) == len(self._weights)
 
-            for ipa_embed, ipa_weights, scale in zip(ip_adapter_image_prompt_embeds, self._weights, self._scales):
+            for ipa_embed, ipa_weights, scale in zip(
+                ip_adapter_image_prompt_embeds, self._weights, self._scales, strict=True
+            ):
                 # The batch dimensions should match.
                 assert ipa_embed.shape[0] == encoder_hidden_states.shape[0]
                 # The token_len dimensions should match.

invokeai/backend/ip_adapter/resampler.py

@@ -56,7 +56,7 @@ class PerceiverAttention(nn.Module):
         x = self.norm1(x)
         latents = self.norm2(latents)
 
-        b, l, _ = latents.shape
+        b, L, _ = latents.shape
 
         q = self.to_q(latents)
         kv_input = torch.cat((x, latents), dim=-2)
@@ -72,7 +72,7 @@ class PerceiverAttention(nn.Module):
         weight = torch.softmax(weight.float(), dim=-1).type(weight.dtype)
         out = weight @ v
 
-        out = out.permute(0, 2, 1, 3).reshape(b, l, -1)
+        out = out.permute(0, 2, 1, 3).reshape(b, L, -1)
 
         return self.to_out(out)
 

invokeai/backend/model_management/convert_ckpt_to_diffusers.py

@@ -269,7 +269,7 @@ def create_unet_diffusers_config(original_config, image_size: int, controlnet=Fa
             resolution *= 2
 
     up_block_types = []
-    for i in range(len(block_out_channels)):
+    for _i in range(len(block_out_channels)):
         block_type = "CrossAttnUpBlock2D" if resolution in unet_params.attention_resolutions else "UpBlock2D"
         up_block_types.append(block_type)
         resolution //= 2
@@ -1223,7 +1223,7 @@ def download_from_original_stable_diffusion_ckpt(
             # scan model
             scan_result = scan_file_path(checkpoint_path)
             if scan_result.infected_files != 0:
-                raise "The model {checkpoint_path} is potentially infected by malware. Aborting import."
+                raise Exception("The model {checkpoint_path} is potentially infected by malware. Aborting import.")
         if device is None:
             device = "cuda" if torch.cuda.is_available() else "cpu"
             checkpoint = torch.load(checkpoint_path, map_location=device)
@@ -1664,7 +1664,7 @@ def download_controlnet_from_original_ckpt(
             # scan model
             scan_result = scan_file_path(checkpoint_path)
             if scan_result.infected_files != 0:
-                raise "The model {checkpoint_path} is potentially infected by malware. Aborting import."
+                raise Exception("The model {checkpoint_path} is potentially infected by malware. Aborting import.")
         if device is None:
             device = "cuda" if torch.cuda.is_available() else "cpu"
             checkpoint = torch.load(checkpoint_path, map_location=device)

invokeai/backend/model_management/lora.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import copy
+import pickle
 from contextlib import contextmanager
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
@@ -12,6 +12,8 @@ from diffusers.models import UNet2DConditionModel
 from safetensors.torch import load_file
 from transformers import CLIPTextModel, CLIPTokenizer
 
+from invokeai.app.shared.models import FreeUConfig
+
 from .models.lora import LoRAModel
 
 """
@@ -54,24 +56,6 @@ class ModelPatcher:
 
         return (module_key, module)
 
-    @staticmethod
-    def _lora_forward_hook(
-        applied_loras: List[Tuple[LoRAModel, float]],
-        layer_name: str,
-    ):
-        def lora_forward(module, input_h, output):
-            if len(applied_loras) == 0:
-                return output
-
-            for lora, weight in applied_loras:
-                layer = lora.layers.get(layer_name, None)
-                if layer is None:
-                    continue
-                output += layer.forward(module, input_h, weight)
-            return output
-
-        return lora_forward
-
     @classmethod
     @contextmanager
     def apply_lora_unet(
@@ -120,7 +104,7 @@ class ModelPatcher:
         loras: List[Tuple[LoRAModel, float]],
         prefix: str,
     ):
-        original_weights = dict()
+        original_weights = {}
         try:
             with torch.no_grad():
                 for lora, lora_weight in loras:
@@ -129,21 +113,40 @@ class ModelPatcher:
                         if not layer_key.startswith(prefix):
                             continue
 
+                        # TODO(ryand): A non-negligible amount of time is currently spent resolving LoRA keys. This
+                        # should be improved in the following ways:
+                        # 1. The key mapping could be more-efficiently pre-computed. This would save time every time a
+                        #    LoRA model is applied.
+                        # 2. From an API perspective, there's no reason that the `ModelPatcher` should be aware of the
+                        #    intricacies of Stable Diffusion key resolution. It should just expect the input LoRA
+                        #    weights to have valid keys.
                         module_key, module = cls._resolve_lora_key(model, layer_key, prefix)
+
+                        # All of the LoRA weight calculations will be done on the same device as the module weight.
+                        # (Performance will be best if this is a CUDA device.)
+                        device = module.weight.device
+                        dtype = module.weight.dtype
+
                         if module_key not in original_weights:
                             original_weights[module_key] = module.weight.detach().to(device="cpu", copy=True)
 
-                        # enable autocast to calc fp16 loras on cpu
-                        # with torch.autocast(device_type="cpu"):
-                        layer.to(dtype=torch.float32)
                         layer_scale = layer.alpha / layer.rank if (layer.alpha and layer.rank) else 1.0
-                        layer_weight = layer.get_weight(original_weights[module_key]) * lora_weight * layer_scale
+
+                        # We intentionally move to the target device first, then cast. Experimentally, this was found to
+                        # be significantly faster for 16-bit CPU tensors being moved to a CUDA device than doing the
+                        # same thing in a single call to '.to(...)'.
+                        layer.to(device=device)
+                        layer.to(dtype=torch.float32)
+                        # TODO(ryand): Using torch.autocast(...) over explicit casting may offer a speed benefit on CUDA
+                        # devices here. Experimentally, it was found to be very slow on CPU. More investigation needed.
+                        layer_weight = layer.get_weight(module.weight) * (lora_weight * layer_scale)
+                        layer.to(device="cpu")
 
                         if module.weight.shape != layer_weight.shape:
                             # TODO: debug on lycoris
                             layer_weight = layer_weight.reshape(module.weight.shape)
 
-                        module.weight += layer_weight.to(device=module.weight.device, dtype=module.weight.dtype)
+                        module.weight += layer_weight.to(dtype=dtype)
 
             yield  # wait for context manager exit
 
@@ -163,10 +166,25 @@ class ModelPatcher:
         init_tokens_count = None
         new_tokens_added = None
 
+        # TODO: This is required since Transformers 4.32 see
+        # https://github.com/huggingface/transformers/pull/25088
+        # More information by NVIDIA:
+        # https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc
+        # This value might need to be changed in the future and take the GPUs model into account as there seem
+        # to be ideal values for different GPUS. This value is temporary!
+        # For references to the current discussion please see https://github.com/invoke-ai/InvokeAI/pull/4817
+        pad_to_multiple_of = 8
+
         try:
-            ti_tokenizer = copy.deepcopy(tokenizer)
+            # HACK: The CLIPTokenizer API does not include a way to remove tokens after calling add_tokens(...). As a
+            # workaround, we create a full copy of `tokenizer` so that its original behavior can be restored after
+            # exiting this `apply_ti(...)` context manager.
+            #
+            # In a previous implementation, the deep copy was obtained with `ti_tokenizer = copy.deepcopy(tokenizer)`,
+            # but a pickle roundtrip was found to be much faster (1 sec vs. 0.05 secs).
+            ti_tokenizer = pickle.loads(pickle.dumps(tokenizer))
             ti_manager = TextualInversionManager(ti_tokenizer)
-            init_tokens_count = text_encoder.resize_token_embeddings(None).num_embeddings
+            init_tokens_count = text_encoder.resize_token_embeddings(None, pad_to_multiple_of).num_embeddings
 
             def _get_trigger(ti_name, index):
                 trigger = ti_name
@@ -181,7 +199,7 @@ class ModelPatcher:
                     new_tokens_added += ti_tokenizer.add_tokens(_get_trigger(ti_name, i))
 
             # modify text_encoder
-            text_encoder.resize_token_embeddings(init_tokens_count + new_tokens_added)
+            text_encoder.resize_token_embeddings(init_tokens_count + new_tokens_added, pad_to_multiple_of)
             model_embeddings = text_encoder.get_input_embeddings()
 
             for ti_name, ti in ti_list:
@@ -196,7 +214,9 @@ class ModelPatcher:
 
                     if model_embeddings.weight.data[token_id].shape != embedding.shape:
                         raise ValueError(
-                            f"Cannot load embedding for {trigger}. It was trained on a model with token dimension {embedding.shape[0]}, but the current model has token dimension {model_embeddings.weight.data[token_id].shape[0]}."
+                            f"Cannot load embedding for {trigger}. It was trained on a model with token dimension"
+                            f" {embedding.shape[0]}, but the current model has token dimension"
+                            f" {model_embeddings.weight.data[token_id].shape[0]}."
                         )
 
                     model_embeddings.weight.data[token_id] = embedding.to(
@@ -211,7 +231,7 @@ class ModelPatcher:
 
         finally:
             if init_tokens_count and new_tokens_added:
-                text_encoder.resize_token_embeddings(init_tokens_count)
+                text_encoder.resize_token_embeddings(init_tokens_count, pad_to_multiple_of)
 
     @classmethod
     @contextmanager
@@ -222,7 +242,7 @@ class ModelPatcher:
     ):
         skipped_layers = []
         try:
-            for i in range(clip_skip):
+            for _i in range(clip_skip):
                 skipped_layers.append(text_encoder.text_model.encoder.layers.pop(-1))
 
             yield
@@ -231,6 +251,25 @@ class ModelPatcher:
             while len(skipped_layers) > 0:
                 text_encoder.text_model.encoder.layers.append(skipped_layers.pop())
 
+    @classmethod
+    @contextmanager
+    def apply_freeu(
+        cls,
+        unet: UNet2DConditionModel,
+        freeu_config: Optional[FreeUConfig] = None,
+    ):
+        did_apply_freeu = False
+        try:
+            if freeu_config is not None:
+                unet.enable_freeu(b1=freeu_config.b1, b2=freeu_config.b2, s1=freeu_config.s1, s2=freeu_config.s2)
+                did_apply_freeu = True
+
+            yield
+
+        finally:
+            if did_apply_freeu:
+                unet.disable_freeu()
+
 
 class TextualInversionModel:
     embedding: torch.Tensor  # [n, 768]|[n, 1280]
@@ -257,7 +296,8 @@ class TextualInversionModel:
         if "string_to_param" in state_dict:
             if len(state_dict["string_to_param"]) > 1:
                 print(
-                    f'Warn: Embedding "{file_path.name}" contains multiple tokens, which is not supported. The first token will be used.'
+                    f'Warn: Embedding "{file_path.name}" contains multiple tokens, which is not supported. The first'
+                    " token will be used."
                 )
 
             result.embedding = next(iter(state_dict["string_to_param"].values()))
@@ -284,7 +324,7 @@ class TextualInversionManager(BaseTextualInversionManager):
     tokenizer: CLIPTokenizer
 
     def __init__(self, tokenizer: CLIPTokenizer):
-        self.pad_tokens = dict()
+        self.pad_tokens = {}
         self.tokenizer = tokenizer
 
     def expand_textual_inversion_token_ids_if_necessary(self, token_ids: list[int]) -> list[int]:
@@ -345,10 +385,10 @@ class ONNXModelPatcher:
         if not isinstance(model, IAIOnnxRuntimeModel):
             raise Exception("Only IAIOnnxRuntimeModel models supported")
 
-        orig_weights = dict()
+        orig_weights = {}
 
         try:
-            blended_loras = dict()
+            blended_loras = {}
 
             for lora, lora_weight in loras:
                 for layer_key, layer in lora.layers.items():
@@ -364,7 +404,7 @@ class ONNXModelPatcher:
                     else:
                         blended_loras[layer_key] = layer_weight
 
-            node_names = dict()
+            node_names = {}
             for node in model.nodes.values():
                 node_names[node.name.replace("/", "_").replace(".", "_").lstrip("_")] = node.name
 
@@ -435,7 +475,13 @@ class ONNXModelPatcher:
         orig_embeddings = None
 
         try:
-            ti_tokenizer = copy.deepcopy(tokenizer)
+            # HACK: The CLIPTokenizer API does not include a way to remove tokens after calling add_tokens(...). As a
+            # workaround, we create a full copy of `tokenizer` so that its original behavior can be restored after
+            # exiting this `apply_ti(...)` context manager.
+            #
+            # In a previous implementation, the deep copy was obtained with `ti_tokenizer = copy.deepcopy(tokenizer)`,
+            # but a pickle roundtrip was found to be much faster (1 sec vs. 0.05 secs).
+            ti_tokenizer = pickle.loads(pickle.dumps(tokenizer))
             ti_manager = TextualInversionManager(ti_tokenizer)
 
             def _get_trigger(ti_name, index):
@@ -470,7 +516,9 @@ class ONNXModelPatcher:
 
                     if embeddings[token_id].shape != embedding.shape:
                         raise ValueError(
-                            f"Cannot load embedding for {trigger}. It was trained on a model with token dimension {embedding.shape[0]}, but the current model has token dimension {embeddings[token_id].shape[0]}."
+                            f"Cannot load embedding for {trigger}. It was trained on a model with token dimension"
+                            f" {embedding.shape[0]}, but the current model has token dimension"
+                            f" {embeddings[token_id].shape[0]}."
                         )
 
                     embeddings[token_id] = embedding

invokeai/backend/model_management/memory_snapshot.py

@@ -64,7 +64,7 @@ class MemorySnapshot:
         return cls(process_ram, vram, malloc_info)
 
 
-def get_pretty_snapshot_diff(snapshot_1: MemorySnapshot, snapshot_2: MemorySnapshot) -> str:
+def get_pretty_snapshot_diff(snapshot_1: Optional[MemorySnapshot], snapshot_2: Optional[MemorySnapshot]) -> str:
     """Get a pretty string describing the difference between two `MemorySnapshot`s."""
 
     def get_msg_line(prefix: str, val1: int, val2: int):
@@ -73,6 +73,9 @@ def get_pretty_snapshot_diff(snapshot_1: MemorySnapshot, snapshot_2: MemorySnaps
 
     msg = ""
 
+    if snapshot_1 is None or snapshot_2 is None:
+        return msg
+
     msg += get_msg_line("Process RAM", snapshot_1.process_ram, snapshot_2.process_ram)
 
     if snapshot_1.malloc_info is not None and snapshot_2.malloc_info is not None:

invokeai/backend/model_management/model_cache.py

@@ -66,11 +66,13 @@ class CacheStats(object):
 
 class ModelLocker(object):
     "Forward declaration"
+
     pass
 
 
 class ModelCache(object):
     "Forward declaration"
+
     pass
 
 
@@ -117,6 +119,7 @@ class ModelCache(object):
         lazy_offloading: bool = True,
         sha_chunksize: int = 16777216,
         logger: types.ModuleType = logger,
+        log_memory_usage: bool = False,
     ):
         """
         :param max_cache_size: Maximum size of the RAM cache [6.0 GB]
@@ -126,8 +129,12 @@ class ModelCache(object):
         :param lazy_offloading: Keep model in VRAM until another model needs to be loaded
         :param sequential_offload: Conserve VRAM by loading and unloading each stage of the pipeline sequentially
         :param sha_chunksize: Chunksize to use when calculating sha256 model hash
+        :param log_memory_usage: If True, a memory snapshot will be captured before and after every model cache
+            operation, and the result will be logged (at debug level). There is a time cost to capturing the memory
+            snapshots, so it is recommended to disable this feature unless you are actively inspecting the model cache's
+            behaviour.
         """
-        self.model_infos: Dict[str, ModelBase] = dict()
+        self.model_infos: Dict[str, ModelBase] = {}
         # allow lazy offloading only when vram cache enabled
         self.lazy_offloading = lazy_offloading and max_vram_cache_size > 0
         self.precision: torch.dtype = precision
@@ -137,12 +144,18 @@ class ModelCache(object):
         self.storage_device: torch.device = storage_device
         self.sha_chunksize = sha_chunksize
         self.logger = logger
+        self._log_memory_usage = log_memory_usage
 
         # used for stats collection
         self.stats = None
 
-        self._cached_models = dict()
-        self._cache_stack = list()
+        self._cached_models = {}
+        self._cache_stack = []
+
+    def _capture_memory_snapshot(self) -> Optional[MemorySnapshot]:
+        if self._log_memory_usage:
+            return MemorySnapshot.capture()
+        return None
 
     def get_key(
         self,
@@ -223,10 +236,10 @@ class ModelCache(object):
 
             # Load the model from disk and capture a memory snapshot before/after.
             start_load_time = time.time()
-            snapshot_before = MemorySnapshot.capture()
+            snapshot_before = self._capture_memory_snapshot()
             with skip_torch_weight_init():
                 model = model_info.get_model(child_type=submodel, torch_dtype=self.precision)
-            snapshot_after = MemorySnapshot.capture()
+            snapshot_after = self._capture_memory_snapshot()
             end_load_time = time.time()
 
             self_reported_model_size_after_load = model_info.get_size(submodel)
@@ -275,9 +288,9 @@ class ModelCache(object):
             return
 
         start_model_to_time = time.time()
-        snapshot_before = MemorySnapshot.capture()
+        snapshot_before = self._capture_memory_snapshot()
         cache_entry.model.to(target_device)
-        snapshot_after = MemorySnapshot.capture()
+        snapshot_after = self._capture_memory_snapshot()
         end_model_to_time = time.time()
         self.logger.debug(
             f"Moved model '{key}' from {source_device} to"
@@ -286,7 +299,12 @@ class ModelCache(object):
             f"{get_pretty_snapshot_diff(snapshot_before, snapshot_after)}"
         )
 
-        if snapshot_before.vram is not None and snapshot_after.vram is not None:
+        if (
+            snapshot_before is not None
+            and snapshot_after is not None
+            and snapshot_before.vram is not None
+            and snapshot_after.vram is not None
+        ):
             vram_change = abs(snapshot_before.vram - snapshot_after.vram)
 
             # If the estimated model size does not match the change in VRAM, log a warning.
@@ -422,12 +440,17 @@ class ModelCache(object):
         self.logger.debug(f"Before unloading: cached_models={len(self._cached_models)}")
 
         pos = 0
+        models_cleared = 0
         while current_size + bytes_needed > maximum_size and pos < len(self._cache_stack):
             model_key = self._cache_stack[pos]
             cache_entry = self._cached_models[model_key]
 
             refs = sys.getrefcount(cache_entry.model)
 
+            # HACK: This is a workaround for a memory-management issue that we haven't tracked down yet. We are directly
+            # going against the advice in the Python docs by using `gc.get_referrers(...)` in this way:
+            # https://docs.python.org/3/library/gc.html#gc.get_referrers
+
             # manualy clear local variable references of just finished function calls
             # for some reason python don't want to collect it even by gc.collect() immidiately
             if refs > 2:
@@ -453,15 +476,16 @@ class ModelCache(object):
                 f" refs: {refs}"
             )
 
-            # 2 refs:
+            # Expected refs:
             # 1 from cache_entry
             # 1 from getrefcount function
             # 1 from onnx runtime object
-            if not cache_entry.locked and refs <= 3 if "onnx" in model_key else 2:
+            if not cache_entry.locked and refs <= (3 if "onnx" in model_key else 2):
                 self.logger.debug(
                     f"Unloading model {model_key} to free {(model_size/GIG):.2f} GB (-{(cache_entry.size/GIG):.2f} GB)"
                 )
                 current_size -= cache_entry.size
+                models_cleared += 1
                 if self.stats:
                     self.stats.cleared += 1
                 del self._cache_stack[pos]
@@ -471,7 +495,20 @@ class ModelCache(object):
             else:
                 pos += 1
 
-        gc.collect()
+        if models_cleared > 0:
+            # There would likely be some 'garbage' to be collected regardless of whether a model was cleared or not, but
+            # there is a significant time cost to calling `gc.collect()`, so we want to use it sparingly. (The time cost
+            # is high even if no garbage gets collected.)
+            #
+            # Calling gc.collect(...) when a model is cleared seems like a good middle-ground:
+            # - If models had to be cleared, it's a signal that we are close to our memory limit.
+            # - If models were cleared, there's a good chance that there's a significant amount of garbage to be
+            #   collected.
+            #
+            # Keep in mind that gc is only responsible for handling reference cycles. Most objects should be cleaned up
+            # immediately when their reference count hits 0.
+            gc.collect()
+
         torch.cuda.empty_cache()
         if choose_torch_device() == torch.device("mps"):
             mps.empty_cache()
@@ -491,7 +528,6 @@ class ModelCache(object):
                 vram_in_use = torch.cuda.memory_allocated()
                 self.logger.debug(f"{(vram_in_use/GIG):.2f}GB VRAM used for models; max allowed={(reserved/GIG):.2f}GB")
 
-        gc.collect()
         torch.cuda.empty_cache()
         if choose_torch_device() == torch.device("mps"):
             mps.empty_cache()

invokeai/backend/model_management/model_load_optimizations.py

@@ -17,7 +17,7 @@ def skip_torch_weight_init():
     completely unnecessary if the intent is to load checkpoint weights from disk for the layer. This context manager
     monkey-patches common torch layers to skip the weight initialization step.
     """
-    torch_modules = [torch.nn.Linear, torch.nn.modules.conv._ConvNd]
+    torch_modules = [torch.nn.Linear, torch.nn.modules.conv._ConvNd, torch.nn.Embedding]
     saved_functions = [m.reset_parameters for m in torch_modules]
 
     try:
@@ -26,5 +26,5 @@ def skip_torch_weight_init():
 
         yield None
     finally:
-        for torch_module, saved_function in zip(torch_modules, saved_functions):
+        for torch_module, saved_function in zip(torch_modules, saved_functions, strict=True):
             torch_module.reset_parameters = saved_function