chore: bump version to v5.10.0dev3

This allows it to pull in sentencepiece on its own. In 0.10.0, it didn't have this package listed as a dependency, but in recent releases it does. So we are able to remove sentencepiece as an explicit dep.

.github/CODEOWNERS

@@ -1,31 +1,32 @@
 # continuous integration
-/.github/workflows/  @lstein @blessedcoolant @hipsterusername @ebr @jazzhaiku @psychedelicious
+/.github/workflows/  @lstein @blessedcoolant @hipsterusername @ebr @jazzhaiku
 
 # documentation
 /docs/ @lstein @blessedcoolant @hipsterusername @psychedelicious
 /mkdocs.yml @lstein @blessedcoolant @hipsterusername @psychedelicious
 
 # nodes
-/invokeai/app/ @blessedcoolant @psychedelicious @hipsterusername @jazzhaiku
+/invokeai/app/ @blessedcoolant @psychedelicious @brandonrising @hipsterusername @jazzhaiku
 
 # installation and configuration
-/pyproject.toml  @lstein @blessedcoolant @psychedelicious @hipsterusername
-/docker/  @lstein @blessedcoolant @psychedelicious @hipsterusername @ebr
-/scripts/ @ebr @lstein @psychedelicious @hipsterusername
-/installer/ @lstein @ebr @psychedelicious @hipsterusername
-/invokeai/assets @lstein @ebr @psychedelicious @hipsterusername
-/invokeai/configs @lstein @psychedelicious @hipsterusername
-/invokeai/version @lstein @blessedcoolant @psychedelicious @hipsterusername
+/pyproject.toml  @lstein @blessedcoolant @hipsterusername
+/docker/  @lstein @blessedcoolant @hipsterusername @ebr
+/scripts/ @ebr @lstein @hipsterusername
+/installer/ @lstein @ebr @hipsterusername
+/invokeai/assets @lstein @ebr @hipsterusername
+/invokeai/configs @lstein @hipsterusername
+/invokeai/version @lstein @blessedcoolant @hipsterusername
 
 # web ui
 /invokeai/frontend @blessedcoolant @psychedelicious @lstein @maryhipp @hipsterusername
+/invokeai/backend @blessedcoolant @psychedelicious @lstein @maryhipp @hipsterusername
 
 # generation, model management, postprocessing
-/invokeai/backend  @lstein @blessedcoolant @hipsterusername @jazzhaiku @psychedelicious @maryhipp 
+/invokeai/backend  @lstein @blessedcoolant @brandonrising @hipsterusername @jazzhaiku
 
 # front ends
-/invokeai/frontend/CLI @lstein @psychedelicious @hipsterusername
-/invokeai/frontend/install @lstein @ebr @psychedelicious @hipsterusername
-/invokeai/frontend/merge @lstein @blessedcoolant @psychedelicious @hipsterusername
-/invokeai/frontend/training @lstein @blessedcoolant @psychedelicious @hipsterusername
+/invokeai/frontend/CLI @lstein @hipsterusername
+/invokeai/frontend/install @lstein @ebr @hipsterusername
+/invokeai/frontend/merge @lstein @blessedcoolant @hipsterusername
+/invokeai/frontend/training @lstein @blessedcoolant @hipsterusername
 /invokeai/frontend/web @psychedelicious @blessedcoolant @maryhipp @hipsterusername

.github/workflows/build-installer.yml

@@ -1,6 +1,6 @@
-# Builds and uploads python build artifacts.
+# Builds and uploads the installer and python build artifacts.
 
-name: build wheel
+name: build installer
 
 on:
   workflow_dispatch:
@@ -27,12 +27,19 @@ jobs:
       - name: setup frontend
         uses: ./.github/actions/install-frontend-deps
 
-      - name: build wheel
-        id: build_wheel
-        run: ./scripts/build_wheel.sh
+      - name: create installer
+        id: create_installer
+        run: ./create_installer.sh
+        working-directory: installer
 
       - name: upload python distribution artifact
         uses: actions/upload-artifact@v4
         with:
           name: dist
-          path: ${{ steps.build_wheel.outputs.DIST_PATH }}
+          path: ${{ steps.create_installer.outputs.DIST_PATH }}
+
+      - name: upload installer artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: installer
+          path: ${{ steps.create_installer.outputs.INSTALLER_PATH }}

.github/workflows/python-checks.yml

@@ -67,10 +67,6 @@ jobs:
           version: '0.6.10'
           enable-cache: true
 
-      - name: check pypi classifiers
-        if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}
-        run: uv run --no-project scripts/check_classifiers.py ./pyproject.toml
-
       - name: ruff check
         if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}
         run: uv tool run ruff@0.11.2 check --output-format=github .

.github/workflows/release.yml

@@ -49,7 +49,7 @@ jobs:
       always_run: true
 
   build:
-    uses: ./.github/workflows/build-wheel.yml
+    uses: ./.github/workflows/build-installer.yml
 
   publish-testpypi:
     runs-on: ubuntu-latest

.github/workflows/uv-lock-checks.yml

@@ -1,68 +0,0 @@
-# Check the `uv` lockfile for consistency with `pyproject.toml`.
-#
-# If this check fails, you should run `uv lock` to update the lockfile.
-
-name: 'uv lock checks'
-
-on:
-  push:
-    branches:
-      - 'main'
-  pull_request:
-    types:
-      - 'ready_for_review'
-      - 'opened'
-      - 'synchronize'
-  merge_group:
-  workflow_dispatch:
-    inputs:
-      always_run:
-        description: 'Always run the checks'
-        required: true
-        type: boolean
-        default: true
-  workflow_call:
-    inputs:
-      always_run:
-        description: 'Always run the checks'
-        required: true
-        type: boolean
-        default: true
-
-jobs:
-  uv-lock-checks:
-    env:
-      # uv requires a venv by default - but for this, we can simply use the system python
-      UV_SYSTEM_PYTHON: 1
-    runs-on: ubuntu-latest
-    timeout-minutes: 5 # expected run time: <1 min
-    steps:
-      - name: checkout
-        uses: actions/checkout@v4
-
-      - name: check for changed python files
-        if: ${{ inputs.always_run != true }}
-        id: changed-files
-        # Pinned to the _hash_ for v45.0.9 to prevent supply-chain attacks.
-        # See:
-        # - CVE-2025-30066
-        # - https://www.stepsecurity.io/blog/harden-runner-detection-tj-actions-changed-files-action-is-compromised
-        # - https://github.com/tj-actions/changed-files/issues/2463
-        uses: tj-actions/changed-files@a284dc1814e3fd07f2e34267fc8f81227ed29fb8
-        with:
-          files_yaml: |
-            uvlock-pyprojecttoml:
-              - 'pyproject.toml'
-              - 'uv.lock'
-
-      - name: setup uv
-        if: ${{ steps.changed-files.outputs.uvlock-pyprojecttoml_any_changed == 'true' || inputs.always_run == true }}
-        uses: astral-sh/setup-uv@v5
-        with:
-          version: '0.6.10'
-          enable-cache: true
-
-      - name: check lockfile
-        if: ${{ steps.changed-files.outputs.uvlock-pyprojecttoml_any_changed == 'true' || inputs.always_run == true }}
-        run: uv lock --locked # this will exit with 1 if the lockfile is not consistent with pyproject.toml
-        shell: bash

.gitignore

@@ -188,4 +188,3 @@ installer/install.sh
 installer/update.bat
 installer/update.sh
 installer/InvokeAI-Installer/
-.aider*

.pre-commit-config.yaml

@@ -4,29 +4,21 @@ repos:
   hooks:
   - id: black
     name: black
-    stages: [pre-commit]
+    stages: [commit]
     language: system
     entry: black
     types: [python]
 
   - id: flake8
     name: flake8
-    stages: [pre-commit]
+    stages: [commit]
     language: system
     entry: flake8
     types: [python]
 
   - id: isort
     name: isort
-    stages: [pre-commit]
+    stages: [commit]
     language: system
     entry: isort
-    types: [python]
-
-  - id: uvlock
-    name: uv lock
-    stages: [pre-commit]
-    language: system
-    entry: uv lock
-    files: ^pyproject\.toml$
-    pass_filenames: false
+    types: [python]

Makefile

@@ -16,7 +16,7 @@ help:
 	@echo "frontend-build           Build the frontend in order to run on localhost:9090"
 	@echo "frontend-dev             Run the frontend in developer mode on localhost:5173"
 	@echo "frontend-typegen         Generate types for the frontend from the OpenAPI schema"
-	@echo "wheel            				Build the wheel for the current version"
+	@echo "installer-zip            Build the installer .zip file for the current version"
 	@echo "tag-release              Tag the GitHub repository with the current version (use at release time only!)"
 	@echo "openapi                  Generate the OpenAPI schema for the app, outputting to stdout"
 	@echo "docs                     Serve the mkdocs site with live reload"
@@ -64,13 +64,13 @@ frontend-dev:
 frontend-typegen:
 	cd invokeai/frontend/web && python ../../../scripts/generate_openapi_schema.py | pnpm typegen
 
-# Tag the release
-wheel:
-	cd scripts && ./build_wheel.sh
+# Installer zip file
+installer-zip:
+	cd installer && ./create_installer.sh
 
 # Tag the release
 tag-release:
-	cd scripts && ./tag_release.sh
+	cd installer && ./tag_release.sh
 
 # Generate the OpenAPI Schema for the app
 openapi:

docker/Dockerfile

@@ -99,15 +99,4 @@ CMD ["invokeai-web"]
 COPY --link --from=web-builder /build/dist ${INVOKEAI_SRC}/invokeai/frontend/web/dist
 
 # add sources last to minimize image changes on code changes
-COPY invokeai ${INVOKEAI_SRC}/invokeai
-
-# this should not increase image size because we've already installed dependencies
-# in a previous layer
-RUN --mount=type=cache,target=/root/.cache/uv \
-    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
-    --mount=type=bind,source=uv.lock,target=uv.lock \
-    if [ "$TARGETPLATFORM" = "linux/arm64" ] || [ "$GPU_DRIVER" = "cpu" ]; then UV_INDEX="https://download.pytorch.org/whl/cpu"; \
-    elif [ "$GPU_DRIVER" = "rocm" ]; then UV_INDEX="https://download.pytorch.org/whl/rocm6.2"; \
-    fi && \
-    uv pip install -e .
-
+COPY invokeai ${INVOKEAI_SRC}/invokeai

docs/RELEASE.md

@@ -60,11 +60,16 @@ Next, these jobs run and must pass. They are the same jobs that are run for ever
 - **`frontend-checks`**: runs `prettier` (format), `eslint` (lint), `dpdm` (circular refs), `tsc` (static type check) and `knip` (unused imports)
 - **`typegen-checks`**: ensures the frontend and backend types are synced
 
-#### `build-wheel` Job
+#### `build-installer` Job
 
-This sets up both python and frontend dependencies and builds the python package. Internally, this runs `./scripts/build_wheel.sh` and uploads `dist.zip`, which contains the wheel and unarchived build.
+This sets up both python and frontend dependencies and builds the python package. Internally, this runs `installer/create_installer.sh` and uploads two artifacts:
 
-You don't need to download or test these artifacts.
+- **`dist`**: the python distribution, to be published on PyPI
+- **`InvokeAI-installer-${VERSION}.zip`**: the legacy install scripts
+
+You don't need to download either of these files.
+
+> The legacy install scripts are no longer used, but we haven't updated the workflow to skip building them.
 
 #### Sanity Check & Smoke Test
 
@@ -74,7 +79,7 @@ It's possible to test the python package before it gets published to PyPI. We've
 
 But, if you want to be extra-super careful, here's how to test it:
 
-- Download the `dist.zip` build artifact from the `build-wheel` job
+- Download the `dist.zip` build artifact from the `build-installer` job
 - Unzip it and find the wheel file
 - Create a fresh Invoke install by following the [manual install guide](https://invoke-ai.github.io/InvokeAI/installation/manual/) - but instead of installing from PyPI, install from the wheel
 - Test the app

docs/contributing/INVOCATIONS.md

@@ -39,7 +39,7 @@ nodes imported in the `__init__.py` file are loaded. See the README in the nodes
 folder for more examples:
 
 ```py
-from .cool_node import ResizeInvocation
+from .cool_node import CoolInvocation
 ```
 
 ## Creating A New Invocation
@@ -69,10 +69,7 @@ The first set of things we need to do when creating a new Invocation are -
 So let us do that.
 
 ```python
-from invokeai.invocation_api import (
-    BaseInvocation,
-    invocation,
-)
+from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
 
 @invocation('resize')
 class ResizeInvocation(BaseInvocation):
@@ -106,12 +103,8 @@ create your own custom field types later in this guide. For now, let's go ahead
 and use it.
 
 ```python
-from invokeai.invocation_api import (
-    BaseInvocation,
-    ImageField,
-    InputField,
-    invocation,
-)
+from invokeai.app.invocations.baseinvocation import BaseInvocation, InputField, invocation
+from invokeai.app.invocations.primitives import ImageField
 
 @invocation('resize')
 class ResizeInvocation(BaseInvocation):
@@ -135,12 +128,8 @@ image: ImageField = InputField(description="The input image")
 Great. Now let us create our other inputs for `width` and `height`
 
 ```python
-from invokeai.invocation_api import (
-    BaseInvocation,
-    ImageField,
-    InputField,
-    invocation,
-)
+from invokeai.app.invocations.baseinvocation import BaseInvocation, InputField, invocation
+from invokeai.app.invocations.primitives import ImageField
 
 @invocation('resize')
 class ResizeInvocation(BaseInvocation):
@@ -174,13 +163,8 @@ that are provided by it by InvokeAI.
 Let us create this function first.
 
 ```python
-from invokeai.invocation_api import (
-    BaseInvocation,
-    ImageField,
-    InputField,
-    InvocationContext,
-    invocation,
-)
+from invokeai.app.invocations.baseinvocation import BaseInvocation, InputField, invocation, InvocationContext
+from invokeai.app.invocations.primitives import ImageField
 
 @invocation('resize')
 class ResizeInvocation(BaseInvocation):
@@ -207,14 +191,8 @@ all the necessary info related to image outputs. So let us use that.
 We will cover how to create your own output types later in this guide.
 
 ```python
-from invokeai.invocation_api import (
-    BaseInvocation,
-    ImageField,
-    InputField,
-    InvocationContext,
-    invocation,
-)
-
+from invokeai.app.invocations.baseinvocation import BaseInvocation, InputField, invocation, InvocationContext
+from invokeai.app.invocations.primitives import ImageField
 from invokeai.app.invocations.image import ImageOutput
 
 @invocation('resize')
@@ -239,15 +217,9 @@ Perfect. Now that we have our Invocation setup, let us do what we want to do.
 So let's do that.
 
 ```python
-from invokeai.invocation_api import (
-    BaseInvocation,
-    ImageField,
-    InputField,
-    InvocationContext,
-    invocation,
-)
-
-from invokeai.app.invocations.image import ImageOutput
+from invokeai.app.invocations.baseinvocation import BaseInvocation, InputField, invocation, InvocationContext
+from invokeai.app.invocations.primitives import ImageField
+from invokeai.app.invocations.image import ImageOutput, ResourceOrigin, ImageCategory
 
 @invocation("resize")
 class ResizeInvocation(BaseInvocation):

docs/contributing/dev-environment.md

@@ -41,7 +41,7 @@ If you just want to use Invoke, you should use the [launcher][launcher link].
      With the modifications made, the install command should look something like this:
 
       ```sh
-      uv pip install -e ".[dev,test,docs,xformers]" --python 3.12 --python-preference only-managed --index=https://download.pytorch.org/whl/cu126 --reinstall
+      uv pip install -e ".[dev,test,docs,xformers]" --python 3.12 --python-preference only-managed --index=https://download.pytorch.org/whl/cu124 --reinstall
       ```
 
 6. At this point, you should have Invoke installed, a venv set up and activated, and the server running. But you will see a warning in the terminal that no UI was found. If you go to the URL for the server, you won't get a UI.

docs/installation/legacy_scripts.md

@@ -0,0 +1,121 @@
+# Legacy Scripts
+
+!!! warning "Legacy Scripts"
+
+    We recommend using the Invoke Launcher to install and update Invoke. It's a desktop application for Windows, macOS and Linux. It takes care of a lot of nitty gritty details for you.
+
+    Follow the [quick start guide](./quick_start.md) to get started.
+
+!!! tip "Use the installer to update"
+
+    Using the installer for updates will not erase any of your data (images, models, boards, etc). It only updates the core libraries used to run Invoke.
+
+    Simply use the same path you installed to originally to update your existing installation.
+
+Both release and pre-release versions can be installed using the installer. It also supports install through a wheel if needed.
+
+Be sure to review the [installation requirements] and ensure your system has everything it needs to install Invoke.
+
+## Getting the Latest Installer
+
+Download the `InvokeAI-installer-vX.Y.Z.zip` file from the [latest release] page. It is at the bottom of the page, under **Assets**.
+
+After unzipping the installer, you should have a `InvokeAI-Installer` folder with some files inside, including `install.bat` and `install.sh`.
+
+## Running the Installer
+
+!!! tip
+
+    Windows users should first double-click the `WinLongPathsEnabled.reg` file to prevent a failed installation due to long file paths.
+
+Double-click the install script:
+
+=== "Windows"
+
+    ```sh
+    install.bat
+    ```
+
+=== "Linux/macOS"
+
+    ```sh
+    install.sh
+    ```
+
+!!! info "Running the Installer from the commandline"
+
+    You can also run the install script from cmd/powershell (Windows) or terminal (Linux/macOS).
+
+!!! warning "Untrusted Publisher (Windows)"
+
+    You may get a popup saying the file comes from an `Untrusted Publisher`. Click `More Info` and `Run Anyway` to get past this.
+
+The installation process is simple, with a few prompts:
+
+- Select the version to install. Unless you have a specific reason to install a specific version, select the default (the latest version).
+- Select location for the install. Be sure you have enough space in this folder for the base application, as described in the [installation requirements].
+- Select a GPU device.
+
+!!! info "Slow Installation"
+
+    The installer needs to download several GB of data and install it all. It may appear to get stuck at 99.9% when installing `pytorch` or during a step labeled "Installing collected packages".
+
+    If it is stuck for over 10 minutes, something has probably gone wrong and you should close the window and restart.
+
+## Running the Application
+
+Find the install location you selected earlier. Double-click the launcher script to run the app:
+
+=== "Windows"
+
+    ```sh
+    invoke.bat
+    ```
+
+=== "Linux/macOS"
+
+    ```sh
+    invoke.sh
+    ```
+
+Choose the first option to run the UI. After a series of startup messages, you'll see something like this:
+
+```sh
+Uvicorn running on http://127.0.0.1:9090 (Press CTRL+C to quit)
+```
+
+Copy the URL into your browser and you should see the UI.
+
+## Improved Outpainting with PatchMatch
+
+PatchMatch is an extra add-on that can improve outpainting. Windows users are in luck - it works out of the box.
+
+On macOS and Linux, a few extra steps are needed to set it up. See the [PatchMatch installation guide](./patchmatch.md).
+
+## First-time Setup
+
+You will need to [install some models] before you can generate.
+
+Check the [configuration docs] for details on configuring the application.
+
+## Updating
+
+Updating is exactly the same as installing - download the latest installer, choose the latest version, enter your existing installation path, and the app will update. None of your data (images, models, boards, etc) will be erased.
+
+!!! info "Dependency Resolution Issues"
+
+    We've found that pip's dependency resolution can cause issues when upgrading packages. One very common problem was pip "downgrading" torch from CUDA to CPU, but things broke in other novel ways.
+
+    The installer doesn't have this kind of problem, so we use it for updating as well.
+
+## Installation Issues
+
+If you have installation issues, please review the [FAQ]. You can also [create an issue] or ask for help on [discord].
+
+[installation requirements]: ./requirements.md
+[FAQ]: ../faq.md
+[install some models]: ./models.md
+[configuration docs]: ../configuration.md
+[latest release]: https://github.com/invoke-ai/InvokeAI/releases/latest
+[create an issue]: https://github.com/invoke-ai/InvokeAI/issues
+[discord]: https://discord.gg/ZmtBAhwWhy

docs/installation/manual.md

@@ -71,21 +71,7 @@ The following commands vary depending on the version of Invoke being installed a
 
 7. Determine the `PyPI` index URL to use for installation, if any. This is necessary to get the right version of torch installed.
 
-    === "Invoke v5.12 and later"
-
-        - If you are on Windows or Linux with an Nvidia GPU, use `https://download.pytorch.org/whl/cu128`.
-        - If you are on Linux with no GPU, use `https://download.pytorch.org/whl/cpu`.
-        - If you are on Linux with an AMD GPU, use `https://download.pytorch.org/whl/rocm6.2.4`.
-        - **In all other cases, do not use an index.**
-
-    === "Invoke v5.10.0 to v5.11.0"
-
-        - If you are on Windows or Linux with an Nvidia GPU, use `https://download.pytorch.org/whl/cu126`.
-        - If you are on Linux with no GPU, use `https://download.pytorch.org/whl/cpu`.
-        - If you are on Linux with an AMD GPU, use `https://download.pytorch.org/whl/rocm6.2.4`.
-        - **In all other cases, do not use an index.**
-
-    === "Invoke v5.0.0 to v5.9.1"
+    === "Invoke v5 or later"
 
         - If you are on Windows with an Nvidia GPU, use `https://download.pytorch.org/whl/cu124`.
         - If you are on Linux with no GPU, use `https://download.pytorch.org/whl/cpu`.

docs/installation/quick_start.md

@@ -49,9 +49,9 @@ If you have an existing Invoke installation, you can select it and let the launc
 
 !!! warning "Problem running the launcher on macOS"
 
-    macOS may not allow you to run the launcher. We are working to resolve this by signing the launcher executable. Until that is done, you can manually flag the launcher as safe:
+    macOS may not allow you to run the launcher. We are working to resolve this by signing the launcher executable. Until that is done, you can either use the [legacy scripts](./legacy_scripts.md) to install, or manually flag the launcher as safe:
 
-    - Open the **Invoke Community Edition.dmg** file.
+    - Open the **Invoke-Installer-mac-arm64.dmg** file.
     - Drag the launcher to **Applications**.
     - Open a terminal.
     - Run `xattr -d 'com.apple.quarantine' /Applications/Invoke\ Community\ Edition.app`.
@@ -117,6 +117,7 @@ If you still have problems, ask for help on the Invoke [discord](https://discord
 
 - You can install the Invoke application as a python package. See our [manual install](./manual.md) docs.
 - You can run Invoke with docker. See our [docker install](./docker.md) docs.
+- You can still use our legacy scripts to install and run Invoke. See the [legacy scripts](./legacy_scripts.md) docs.
 
 ## Need Help?
 

docs/nodes/communityNodes.md

@@ -13,7 +13,6 @@ If you'd prefer, you can also just download the whole node folder from the linke
 To use a community workflow, download the `.json` node graph file and load it into Invoke AI via the **Load Workflow** button in the Workflow Editor. 
 
 - Community Nodes
-    + [Anamorphic Tools](#anamorphic-tools)
     + [Adapters-Linked](#adapters-linked-nodes)
     + [Autostereogram](#autostereogram-nodes)
     + [Average Images](#average-images)
@@ -21,12 +20,9 @@ To use a community workflow, download the `.json` node graph file and load it in
     + [Close Color Mask](#close-color-mask) 
     + [Clothing Mask](#clothing-mask)
     + [Contrast Limited Adaptive Histogram Equalization](#contrast-limited-adaptive-histogram-equalization)
-    + [Curves](#curves)
     + [Depth Map from Wavefront OBJ](#depth-map-from-wavefront-obj)
     + [Enhance Detail](#enhance-detail)
     + [Film Grain](#film-grain)
-    + [Flip Pose](#flip-pose)
-    + [Flux Ideal Size](#flux-ideal-size)
     + [Generative Grammar-Based Prompt Nodes](#generative-grammar-based-prompt-nodes)
     + [GPT2RandomPromptMaker](#gpt2randompromptmaker)
     + [Grid to Gif](#grid-to-gif)
@@ -65,13 +61,6 @@ To use a community workflow, download the `.json` node graph file and load it in
 - [Help](#help)
 
 
---------------------------------
-### Anamorphic Tools
-
-**Description:** A set of nodes to perform anamorphic modifications to images, like lens blur, streaks, spherical distortion, and vignetting.
-
-**Node Link:** https://github.com/JPPhoto/anamorphic-tools
-
 --------------------------------
 ### Adapters Linked Nodes
 
@@ -143,13 +132,6 @@ Node Link: https://github.com/VeyDlin/clahe-node
 View:
 </br><img src="https://raw.githubusercontent.com/VeyDlin/clahe-node/master/.readme/node.png" width="500" />
 
---------------------------------
-### Curves
-
-**Description:** Adjust an image's curve based on a user-defined string.
-
-**Node Link:** https://github.com/JPPhoto/curves-node
-
 --------------------------------
 ### Depth Map from Wavefront OBJ
 
@@ -180,20 +162,6 @@ To be imported, an .obj must use triangulated meshes, so make sure to enable tha
 
 **Node Link:** https://github.com/JPPhoto/film-grain-node
 
---------------------------------
-### Flip Pose
-
-**Description:** This node will flip an openpose image horizontally, recoloring it to make sure that it isn't facing the wrong direction. Note that it does not work with openpose hands.
-
-**Node Link:** https://github.com/JPPhoto/flip-pose-node
-
---------------------------------
-### Flux Ideal Size
-
-**Description:** This node returns an ideal size to use for the first stage of a Flux image generation pipeline. Generating at the right size helps limit duplication and odd subject placement.
-
-**Node Link:** https://github.com/JPPhoto/flux-ideal-size
-
 --------------------------------
 ### Generative Grammar-Based Prompt Nodes
 

installer/create_installer.sh

@@ -32,18 +32,18 @@ if [[ ! -z ${CI} ]]; then
     echo
     echo -e "${BCYAN}CI environment detected${RESET}"
     echo
+else
+    echo
+    echo -e "${BYELLOW}This script must be run from the installer directory!${RESET}"
+    echo "The current working directory is $(pwd)"
+    read -p "If that looks right, press any key to proceed, or CTRL-C to exit..."
+    echo
 fi
 
 echo -e "${BGREEN}HEAD${RESET}:"
 git_show HEAD
 echo
 
-# If the classifiers are invalid, publishing to PyPI will fail but the build will succeed.
-# It's a fast check, do it early.
-echo "Checking pyproject classifiers..."
-python3 ./check_classifiers.py ../pyproject.toml
-echo
-
 # ---------------------- FRONTEND ----------------------
 
 pushd ../invokeai/frontend/web >/dev/null
@@ -77,8 +77,42 @@ fi
 
 rm -rf ../build
 
-python3 -m build --outdir ../dist/ ../.
+python3 -m build --outdir dist/ ../.
 
+# ----------------------
+
+echo
+echo "Building installer zip files for InvokeAI ${VERSION}..."
+echo
+
+# get rid of any old ones
+rm -f *.zip
+rm -rf InvokeAI-Installer
+
+# copy content
+mkdir InvokeAI-Installer
+for f in templates *.txt *.reg; do
+    cp -r ${f} InvokeAI-Installer/
+done
+mkdir InvokeAI-Installer/lib
+cp lib/*.py InvokeAI-Installer/lib
+
+# Install scripts
+# Mac/Linux
+cp install.sh.in InvokeAI-Installer/install.sh
+chmod a+x InvokeAI-Installer/install.sh
+
+# Windows
+cp install.bat.in InvokeAI-Installer/install.bat
+cp WinLongPathsEnabled.reg InvokeAI-Installer/
+
+FILENAME=InvokeAI-installer-$VERSION.zip
+
+# Zip everything up
+zip -r ${FILENAME} InvokeAI-Installer
+
+echo
+echo -e "${BGREEN}Built installer: ./${FILENAME}${RESET}"
 echo -e "${BGREEN}Built PyPi distribution: ./dist${RESET}"
 
 # clean up, but only if we are not in a github action
@@ -91,7 +125,9 @@ fi
 if [[ ! -z ${CI} ]]; then
     echo
     echo "Setting GitHub action outputs..."
-    echo "DIST_PATH=./dist/" >>$GITHUB_OUTPUT
+    echo "INSTALLER_FILENAME=${FILENAME}" >>$GITHUB_OUTPUT
+    echo "INSTALLER_PATH=installer/${FILENAME}" >>$GITHUB_OUTPUT
+    echo "DIST_PATH=installer/dist/" >>$GITHUB_OUTPUT
 fi
 
 exit 0

installer/install.bat.in

@@ -0,0 +1,128 @@
+@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+
+@rem This script requires the user to install Python 3.10 or higher. All other
+@rem requirements are downloaded as needed.
+
+@rem change to the script's directory
+PUSHD "%~dp0"
+
+set "no_cache_dir=--no-cache-dir"
+if "%1" == "use-cache" (
+    set "no_cache_dir="
+)
+
+@rem Config
+@rem The version in the next line is replaced by an up to date release number
+@rem when create_installer.sh is run. Change the release number there.
+set INSTRUCTIONS=https://invoke-ai.github.io/InvokeAI/installation/INSTALL_AUTOMATED/
+set TROUBLESHOOTING=https://invoke-ai.github.io/InvokeAI/help/FAQ/
+set PYTHON_URL=https://www.python.org/downloads/windows/
+set MINIMUM_PYTHON_VERSION=3.10.0
+set PYTHON_URL=https://www.python.org/downloads/release/python-3109/
+
+set err_msg=An error has occurred and the script could not continue.
+
+@rem --------------------------- Intro -------------------------------
+echo This script will install InvokeAI and its dependencies.
+echo.
+echo BEFORE YOU START PLEASE MAKE SURE TO DO THE FOLLOWING
+echo 1. Install python 3.10 or 3.11. Python version 3.9 is no longer supported.
+echo 2. Double-click on the file WinLongPathsEnabled.reg in order to
+echo    enable long path support on your system.
+echo 3. Install the Visual C++ core libraries.
+echo    Please download and install the libraries from:
+echo    https://learn.microsoft.com/en-US/cpp/windows/latest-supported-vc-redist?view=msvc-170
+echo.
+echo See %INSTRUCTIONS% for more details.
+echo.
+echo FOR THE BEST USER EXPERIENCE WE SUGGEST MAXIMIZING THIS WINDOW NOW.
+pause
+
+@rem ---------------------------- check Python version ---------------
+echo ***** Checking and Updating Python *****
+
+call python --version >.tmp1 2>.tmp2
+if %errorlevel% == 1 (
+   set err_msg=Please install Python 3.10-11. See %INSTRUCTIONS% for details.
+   goto err_exit
+)
+
+for /f "tokens=2" %%i in (.tmp1) do set python_version=%%i
+if "%python_version%" == "" (
+   set err_msg=No python was detected on your system. Please install Python version %MINIMUM_PYTHON_VERSION% or higher. We recommend Python 3.10.12 from %PYTHON_URL%
+   goto err_exit
+)
+
+call :compareVersions %MINIMUM_PYTHON_VERSION% %python_version%
+if %errorlevel% == 1 (
+   set err_msg=Your version of Python is too low. You need at least %MINIMUM_PYTHON_VERSION% but you have %python_version%. We recommend Python 3.10.12 from %PYTHON_URL%
+   goto err_exit
+)
+
+@rem Cleanup
+del /q .tmp1 .tmp2
+
+@rem -------------- Install and Configure ---------------
+
+call python .\lib\main.py
+pause
+exit /b
+
+@rem ------------------------ Subroutines ---------------
+@rem routine to do comparison of semantic version numbers
+@rem found at https://stackoverflow.com/questions/15807762/compare-version-numbers-in-batch-file
+:compareVersions
+::
+:: Compares two version numbers and returns the result in the ERRORLEVEL
+::
+:: Returns 1 if version1 > version2
+::         0 if version1 = version2
+::        -1 if version1 < version2
+::
+:: The nodes must be delimited by . or , or -
+::
+:: Nodes are normally strictly numeric, without a 0 prefix. A letter suffix
+:: is treated as a separate node
+::
+setlocal enableDelayedExpansion
+set "v1=%~1"
+set "v2=%~2"
+call :divideLetters v1
+call :divideLetters v2
+:loop
+call :parseNode "%v1%" n1 v1
+call :parseNode "%v2%" n2 v2
+if %n1% gtr %n2% exit /b 1
+if %n1% lss %n2% exit /b -1
+if not defined v1 if not defined v2 exit /b 0
+if not defined v1 exit /b -1
+if not defined v2 exit /b 1
+goto :loop
+
+
+:parseNode  version  nodeVar  remainderVar
+for /f "tokens=1* delims=.,-" %%A in ("%~1") do (
+  set "%~2=%%A"
+  set "%~3=%%B"
+)
+exit /b
+
+
+:divideLetters  versionVar
+for %%C in (a b c d e f g h i j k l m n o p q r s t u v w x y z) do set "%~1=!%~1:%%C=.%%C!"
+exit /b
+
+:err_exit
+echo %err_msg%
+echo The installer will exit now.
+pause
+exit /b
+
+pause
+
+:Trim
+SetLocal EnableDelayedExpansion
+set Params=%*
+for /f "tokens=1*" %%a in ("!Params!") do EndLocal & set %1=%%b
+exit /b

installer/install.sh.in

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# make sure we are not already in a venv
+# (don't need to check status)
+deactivate >/dev/null 2>&1
+scriptdir=$(dirname "$0")
+cd $scriptdir
+
+function version { echo "$@" | awk -F. '{ printf("%d%03d%03d%03d\n", $1,$2,$3,$4); }'; }
+
+MINIMUM_PYTHON_VERSION=3.10.0
+MAXIMUM_PYTHON_VERSION=3.11.100
+PYTHON=""
+for candidate in python3.11 python3.10 python3 python ; do
+    if ppath=`which $candidate 2>/dev/null`; then
+        # when using `pyenv`, the executable for an inactive Python version will exist but will not be operational
+        # we check that this found executable can actually run
+        if [ $($candidate --version &>/dev/null; echo ${PIPESTATUS}) -gt 0 ]; then continue; fi
+
+        python_version=$($ppath -V | awk '{ print $2 }')
+        if [ $(version $python_version) -ge $(version "$MINIMUM_PYTHON_VERSION") ]; then
+            if [ $(version $python_version) -le $(version "$MAXIMUM_PYTHON_VERSION") ]; then
+                PYTHON=$ppath
+                break
+            fi
+        fi
+    fi
+done
+
+if [ -z "$PYTHON" ]; then
+    echo "A suitable Python interpreter could not be found"
+    echo "Please install Python $MINIMUM_PYTHON_VERSION or higher (maximum $MAXIMUM_PYTHON_VERSION) before running this script. See instructions at $INSTRUCTIONS for help."
+    read -p "Press any key to exit"
+    exit -1
+fi
+
+echo "For the best user experience we suggest enlarging or maximizing this window now."
+
+exec $PYTHON ./lib/main.py ${@}
+read -p "Press any key to exit"

installer/lib/installer.py

@@ -0,0 +1,438 @@
+# Copyright (c) 2023 Eugene Brodsky (https://github.com/ebr)
+"""
+InvokeAI installer script
+"""
+
+import locale
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import venv
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Optional, Tuple
+
+SUPPORTED_PYTHON = ">=3.10.0,<=3.11.100"
+INSTALLER_REQS = ["rich", "semver", "requests", "plumbum", "prompt-toolkit"]
+BOOTSTRAP_VENV_PREFIX = "invokeai-installer-tmp"
+DOCS_URL = "https://invoke-ai.github.io/InvokeAI/"
+DISCORD_URL = "https://discord.gg/ZmtBAhwWhy"
+
+OS = platform.uname().system
+ARCH = platform.uname().machine
+VERSION = "latest"
+
+
+def get_version_from_wheel_filename(wheel_filename: str) -> str:
+    match = re.search(r"-(\d+\.\d+\.\d+)", wheel_filename)
+    if match:
+        version = match.group(1)
+        return version
+    else:
+        raise ValueError(f"Could not extract version from wheel filename: {wheel_filename}")
+
+
+class Installer:
+    """
+    Deploys an InvokeAI installation into a given path
+    """
+
+    reqs: list[str] = INSTALLER_REQS
+
+    def __init__(self) -> None:
+        if os.getenv("VIRTUAL_ENV") is not None:
+            print("A virtual environment is already activated. Please 'deactivate' before installation.")
+            sys.exit(-1)
+        self.bootstrap()
+        self.available_releases = get_github_releases()
+
+    def mktemp_venv(self) -> TemporaryDirectory[str]:
+        """
+        Creates a temporary virtual environment for the installer itself
+
+        :return: path to the created virtual environment directory
+        :rtype: TemporaryDirectory
+        """
+
+        # Cleaning up temporary directories on Windows results in a race condition
+        # and a stack trace.
+        # `ignore_cleanup_errors` was only added in Python 3.10
+        if OS == "Windows" and int(platform.python_version_tuple()[1]) >= 10:
+            venv_dir = TemporaryDirectory(prefix=BOOTSTRAP_VENV_PREFIX, ignore_cleanup_errors=True)
+        else:
+            venv_dir = TemporaryDirectory(prefix=BOOTSTRAP_VENV_PREFIX)
+
+        venv.create(venv_dir.name, with_pip=True)
+        self.venv_dir = venv_dir
+        set_sys_path(Path(venv_dir.name))
+
+        return venv_dir
+
+    def bootstrap(self, verbose: bool = False) -> TemporaryDirectory[str] | None:
+        """
+        Bootstrap the installer venv with packages required at install time
+        """
+
+        print("Initializing the installer. This may take a minute - please wait...")
+
+        venv_dir = self.mktemp_venv()
+        pip = get_pip_from_venv(Path(venv_dir.name))
+
+        cmd = [pip, "install", "--require-virtualenv", "--use-pep517"]
+        cmd.extend(self.reqs)
+
+        try:
+            # upgrade pip to the latest version to avoid a confusing message
+            res = upgrade_pip(Path(venv_dir.name))
+            if verbose:
+                print(res)
+
+            # run the install prerequisites installation
+            res = subprocess.check_output(cmd).decode()
+
+            if verbose:
+                print(res)
+
+            return venv_dir
+        except subprocess.CalledProcessError as e:
+            print(e)
+
+    def app_venv(self, venv_parent: Path) -> Path:
+        """
+        Create a virtualenv for the InvokeAI installation
+        """
+
+        venv_dir = venv_parent / ".venv"
+
+        # Prefer to copy python executables
+        # so that updates to system python don't break InvokeAI
+        try:
+            venv.create(venv_dir, with_pip=True)
+        # If installing over an existing environment previously created with symlinks,
+        # the executables will fail to copy. Keep symlinks in that case
+        except shutil.SameFileError:
+            venv.create(venv_dir, with_pip=True, symlinks=True)
+
+        return venv_dir
+
+    def install(
+        self,
+        root: str = "~/invokeai",
+        yes_to_all: bool = False,
+        find_links: Optional[str] = None,
+        wheel: Optional[Path] = None,
+    ) -> None:
+        """Install the InvokeAI application into the given runtime path
+
+        Args:
+            root: Destination path for the installation
+            yes_to_all: Accept defaults to all questions
+            find_links: A local directory to search for requirement wheels before going to remote indexes
+            wheel: A wheel file to install
+        """
+
+        import messages
+
+        if wheel:
+            messages.installing_from_wheel(wheel.name)
+            version = get_version_from_wheel_filename(wheel.name)
+        else:
+            messages.welcome(self.available_releases)
+            version = messages.choose_version(self.available_releases)
+
+        auto_dest = Path(os.environ.get("INVOKEAI_ROOT", root)).expanduser().resolve()
+        destination = auto_dest if yes_to_all else messages.dest_path(root)
+        if destination is None:
+            print("Could not find or create the destination directory. Installation cancelled.")
+            sys.exit(0)
+
+        # create the venv for the app
+        self.venv = self.app_venv(venv_parent=destination)
+
+        self.instance = InvokeAiInstance(runtime=destination, venv=self.venv, version=version)
+
+        # install dependencies and the InvokeAI application
+        (extra_index_url, optional_modules) = get_torch_source() if not yes_to_all else (None, None)
+        self.instance.install(extra_index_url, optional_modules, find_links, wheel)
+
+        # install the launch/update scripts into the runtime directory
+        self.instance.install_user_scripts()
+
+        message = f"""
+*** Installation Successful ***
+
+To start the application, run:
+    {destination}/invoke.{"bat" if sys.platform == "win32" else "sh"}
+
+For more information, troubleshooting and support, visit our docs at:
+    {DOCS_URL}
+
+Join the community on Discord:
+    {DISCORD_URL}
+"""
+        print(message)
+
+
+class InvokeAiInstance:
+    """
+    Manages an installed instance of InvokeAI, comprising a virtual environment and a runtime directory.
+    The virtual environment *may* reside within the runtime directory.
+    A single runtime directory *may* be shared by multiple virtual environments, though this isn't currently tested or supported.
+    """
+
+    def __init__(self, runtime: Path, venv: Path, version: str = "stable") -> None:
+        self.runtime = runtime
+        self.venv = venv
+        self.pip = get_pip_from_venv(venv)
+        self.version = version
+
+        set_sys_path(venv)
+        os.environ["INVOKEAI_ROOT"] = str(self.runtime.expanduser().resolve())
+        os.environ["VIRTUAL_ENV"] = str(self.venv.expanduser().resolve())
+        upgrade_pip(venv)
+
+    def get(self) -> tuple[Path, Path]:
+        """
+        Get the location of the virtualenv directory for this installation
+
+        :return: Paths of the runtime and the venv directory
+        :rtype: tuple[Path, Path]
+        """
+
+        return (self.runtime, self.venv)
+
+    def install(
+        self,
+        extra_index_url: Optional[str] = None,
+        optional_modules: Optional[str] = None,
+        find_links: Optional[str] = None,
+        wheel: Optional[Path] = None,
+    ):
+        """Install the package from PyPi or a wheel, if provided.
+
+        Args:
+            extra_index_url: the "--extra-index-url ..." line for pip to look in extra indexes.
+            optional_modules: optional modules to install using "[module1,module2]" format.
+            find_links: path to a directory containing wheels to be searched prior to going to the internet
+            wheel: a wheel file to install
+        """
+
+        import messages
+
+        # not currently used, but may be useful for "install most recent version" option
+        if self.version == "prerelease":
+            version = None
+            pre_flag = "--pre"
+        elif self.version == "stable":
+            version = None
+            pre_flag = None
+        else:
+            version = self.version
+            pre_flag = None
+
+        src = "invokeai"
+        if optional_modules:
+            src += optional_modules
+        if version:
+            src += f"=={version}"
+
+        messages.simple_banner("Installing the InvokeAI Application :art:")
+
+        from plumbum import FG, ProcessExecutionError, local
+
+        pip = local[self.pip]
+
+        # Uninstall xformers if it is present; the correct version of it will be reinstalled if needed
+        _ = pip["uninstall", "-yqq", "xformers"] & FG
+
+        pipeline = pip[
+            "install",
+            "--require-virtualenv",
+            "--force-reinstall",
+            "--use-pep517",
+            str(src) if not wheel else str(wheel),
+            "--find-links" if find_links is not None else None,
+            find_links,
+            "--extra-index-url" if extra_index_url is not None else None,
+            extra_index_url,
+            pre_flag if not wheel else None,  # Ignore the flag if we are installing a wheel
+        ]
+
+        try:
+            _ = pipeline & FG
+        except ProcessExecutionError as e:
+            print(f"Error: {e}")
+            print(
+                "Could not install InvokeAI. Please try downloading the latest version of the installer and install again."
+            )
+            sys.exit(1)
+
+    def install_user_scripts(self):
+        """
+        Copy the launch and update scripts to the runtime dir
+        """
+
+        ext = "bat" if OS == "Windows" else "sh"
+
+        scripts = ["invoke"]
+
+        for script in scripts:
+            src = Path(__file__).parent / ".." / "templates" / f"{script}.{ext}.in"
+            dest = self.runtime / f"{script}.{ext}"
+            shutil.copy(src, dest)
+            os.chmod(dest, 0o0755)
+
+
+### Utility functions ###
+
+
+def get_pip_from_venv(venv_path: Path) -> str:
+    """
+    Given a path to a virtual environment, get the absolute path to the `pip` executable
+    in a cross-platform fashion. Does not validate that the pip executable
+    actually exists in the virtualenv.
+
+    :param venv_path: Path to the virtual environment
+    :type venv_path: Path
+    :return: Absolute path to the pip executable
+    :rtype: str
+    """
+
+    pip = "Scripts\\pip.exe" if OS == "Windows" else "bin/pip"
+    return str(venv_path.expanduser().resolve() / pip)
+
+
+def upgrade_pip(venv_path: Path) -> str | None:
+    """
+    Upgrade the pip executable in the given virtual environment
+    """
+
+    python = "Scripts\\python.exe" if OS == "Windows" else "bin/python"
+    python = str(venv_path.expanduser().resolve() / python)
+
+    try:
+        result = subprocess.check_output([python, "-m", "pip", "install", "--upgrade", "pip"]).decode(
+            encoding=locale.getpreferredencoding()
+        )
+    except subprocess.CalledProcessError as e:
+        print(e)
+        result = None
+
+    return result
+
+
+def set_sys_path(venv_path: Path) -> None:
+    """
+    Given a path to a virtual environment, set the sys.path, in a cross-platform fashion,
+    such that packages from the given venv may be imported in the current process.
+    Ensure that the packages from system environment are not visible (emulate
+    the virtual env 'activate' script) - this doesn't work on Windows yet.
+
+    :param venv_path: Path to the virtual environment
+    :type venv_path: Path
+    """
+
+    # filter out any paths in sys.path that may be system- or user-wide
+    # but leave the temporary bootstrap virtualenv as it contains packages we
+    # temporarily need at install time
+    sys.path = list(filter(lambda p: not p.endswith("-packages") or p.find(BOOTSTRAP_VENV_PREFIX) != -1, sys.path))
+
+    # determine site-packages/lib directory location for the venv
+    lib = "Lib" if OS == "Windows" else f"lib/python{sys.version_info.major}.{sys.version_info.minor}"
+
+    # add the site-packages location to the venv
+    sys.path.append(str(Path(venv_path, lib, "site-packages").expanduser().resolve()))
+
+
+def get_github_releases() -> tuple[list[str], list[str]] | None:
+    """
+    Query Github for published (pre-)release versions.
+    Return a tuple where the first element is a list of stable releases and the second element is a list of pre-releases.
+    Return None if the query fails for any reason.
+    """
+
+    import requests
+
+    ## get latest releases using github api
+    url = "https://api.github.com/repos/invoke-ai/InvokeAI/releases"
+    releases: list[str] = []
+    pre_releases: list[str] = []
+    try:
+        res = requests.get(url)
+        res.raise_for_status()
+        tag_info = res.json()
+        for tag in tag_info:
+            if not tag["prerelease"]:
+                releases.append(tag["tag_name"].lstrip("v"))
+            else:
+                pre_releases.append(tag["tag_name"].lstrip("v"))
+    except requests.HTTPError as e:
+        print(f"Error: {e}")
+        print("Could not fetch version information from GitHub. Please check your network connection and try again.")
+        return
+    except Exception as e:
+        print(f"Error: {e}")
+        print("An unexpected error occurred while trying to fetch version information from GitHub. Please try again.")
+        return
+
+    releases.sort(reverse=True)
+    pre_releases.sort(reverse=True)
+
+    return releases, pre_releases
+
+
+def get_torch_source() -> Tuple[str | None, str | None]:
+    """
+    Determine the extra index URL for pip to use for torch installation.
+    This depends on the OS and the graphics accelerator in use.
+    This is only applicable to Windows and Linux, since PyTorch does not
+    offer accelerated builds for macOS.
+
+    Prefer CUDA-enabled wheels if the user wasn't sure of their GPU, as it will fallback to CPU if possible.
+
+    A NoneType return means just go to PyPi.
+
+    :return: tuple consisting of (extra index url or None, optional modules to load or None)
+    :rtype: list
+    """
+
+    from messages import GpuType, select_gpu
+
+    # device can be one of: "cuda", "rocm", "cpu", "cuda_and_dml, autodetect"
+    device = select_gpu()
+
+    # The correct extra index URLs for torch are inconsistent, see https://pytorch.org/get-started/locally/#start-locally
+
+    url = None
+    optional_modules: str | None = None
+    if OS == "Linux":
+        if device == GpuType.ROCM:
+            url = "https://download.pytorch.org/whl/rocm6.1"
+        elif device == GpuType.CPU:
+            url = "https://download.pytorch.org/whl/cpu"
+        elif device == GpuType.CUDA:
+            url = "https://download.pytorch.org/whl/cu124"
+            optional_modules = "[onnx-cuda]"
+        elif device == GpuType.CUDA_WITH_XFORMERS:
+            url = "https://download.pytorch.org/whl/cu124"
+            optional_modules = "[xformers,onnx-cuda]"
+    elif OS == "Windows":
+        if device == GpuType.CUDA:
+            url = "https://download.pytorch.org/whl/cu124"
+            optional_modules = "[onnx-cuda]"
+        elif device == GpuType.CUDA_WITH_XFORMERS:
+            url = "https://download.pytorch.org/whl/cu124"
+            optional_modules = "[xformers,onnx-cuda]"
+        elif device.value == "cpu":
+            # CPU  uses the default PyPi index, no optional modules
+            pass
+    elif OS == "Darwin":
+        # macOS uses the default PyPi index, no optional modules
+        pass
+
+    # Fall back to defaults
+
+    return (url, optional_modules)

installer/lib/main.py

@@ -0,0 +1,57 @@
+"""
+InvokeAI Installer
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+from installer import Installer
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "-r",
+        "--root",
+        dest="root",
+        type=str,
+        help="Destination path for installation",
+        default=os.environ.get("INVOKEAI_ROOT") or "~/invokeai",
+    )
+    parser.add_argument(
+        "-y",
+        "--yes",
+        "--yes-to-all",
+        dest="yes_to_all",
+        action="store_true",
+        help="Assume default answers to all questions",
+        default=False,
+    )
+
+    parser.add_argument(
+        "--find-links",
+        dest="find_links",
+        help="Specifies a directory of local wheel files to be searched prior to searching the online repositories.",
+        type=Path,
+        default=None,
+    )
+
+    parser.add_argument(
+        "--wheel",
+        dest="wheel",
+        help="Specifies a wheel for the InvokeAI package. Used for troubleshooting or testing prereleases.",
+        type=Path,
+        default=None,
+    )
+
+    args = parser.parse_args()
+
+    inst = Installer()
+
+    try:
+        inst.install(**args.__dict__)
+    except KeyboardInterrupt:
+        print("\n")
+        print("Ctrl-C pressed. Aborting.")
+        print("Come back soon!")

installer/lib/messages.py

@@ -0,0 +1,342 @@
+# Copyright (c) 2023 Eugene Brodsky (https://github.com/ebr)
+"""
+Installer user interaction
+"""
+
+import os
+import platform
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from prompt_toolkit import prompt
+from prompt_toolkit.completion import FuzzyWordCompleter, PathCompleter
+from prompt_toolkit.validation import Validator
+from rich import box, print
+from rich.console import Console, Group, group
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.style import Style
+from rich.syntax import Syntax
+from rich.text import Text
+
+OS = platform.uname().system
+ARCH = platform.uname().machine
+
+if OS == "Windows":
+    # Windows terminals look better without a background colour
+    console = Console(style=Style(color="grey74"))
+else:
+    console = Console(style=Style(color="grey74", bgcolor="grey19"))
+
+
+def welcome(available_releases: tuple[list[str], list[str]] | None = None) -> None:
+    @group()
+    def text():
+        if (platform_specific := _platform_specific_help()) is not None:
+            yield platform_specific
+            yield ""
+        yield Text.from_markup(
+            "Some of the installation steps take a long time to run. Please be patient. If the script appears to hang for more than 10 minutes, please interrupt with [i]Control-C[/] and retry.",
+            justify="center",
+        )
+        if available_releases is not None:
+            latest_stable = available_releases[0][0]
+            last_pre = available_releases[1][0]
+            yield ""
+            yield Text.from_markup(
+                f"[red3]🠶[/] Latest stable release (recommended): [b bright_white]{latest_stable}", justify="center"
+            )
+            yield Text.from_markup(
+                f"[red3]🠶[/] Last published pre-release version: [b bright_white]{last_pre}", justify="center"
+            )
+
+    console.rule()
+    print(
+        Panel(
+            title="[bold wheat1]Welcome to the InvokeAI Installer",
+            renderable=text(),
+            box=box.DOUBLE,
+            expand=True,
+            padding=(1, 2),
+            style=Style(bgcolor="grey23", color="orange1"),
+            subtitle=f"[bold grey39]{OS}-{ARCH}",
+        )
+    )
+    console.line()
+
+
+def installing_from_wheel(wheel_filename: str) -> None:
+    """Display a message about installing from a wheel"""
+
+    @group()
+    def text():
+        yield Text.from_markup(f"You are installing from a wheel file: [bold]{wheel_filename}\n")
+        yield Text.from_markup(
+            "[bold orange3]If you are not sure why you are doing this, you should cancel and install InvokeAI normally."
+        )
+
+    console.print(
+        Panel(
+            title="Installing from Wheel",
+            renderable=text(),
+            box=box.DOUBLE,
+            expand=True,
+            padding=(1, 2),
+        )
+    )
+
+    should_proceed = Confirm.ask("Do you want to proceed?")
+
+    if not should_proceed:
+        console.print("Installation cancelled.")
+        exit()
+
+
+def choose_version(available_releases: tuple[list[str], list[str]] | None = None) -> str:
+    """
+    Prompt the user to choose an Invoke version to install
+    """
+
+    # short circuit if we couldn't get a version list
+    # still try to install the latest stable version
+    if available_releases is None:
+        return "stable"
+
+    console.print(":grey_question: [orange3]Please choose an Invoke version to install.")
+
+    choices = available_releases[0] + available_releases[1]
+
+    response = prompt(
+        message=f"   <Enter> to install the recommended release ({choices[0]}). <Tab> or type to pick a version: ",
+        complete_while_typing=True,
+        completer=FuzzyWordCompleter(choices),
+    )
+    console.print(f"   Version {choices[0] if response == '' else response} will be installed.")
+
+    console.line()
+
+    return "stable" if response == "" else response
+
+
+def confirm_install(dest: Path) -> bool:
+    if dest.exists():
+        print(f":stop_sign: Directory {dest} already exists!")
+        print("   Is this location correct?")
+        default = False
+    else:
+        print(f":file_folder: InvokeAI will be installed in {dest}")
+        default = True
+
+    dest_confirmed = Confirm.ask("   Please confirm:", default=default)
+
+    console.line()
+
+    return dest_confirmed
+
+
+def dest_path(dest: Optional[str | Path] = None) -> Path | None:
+    """
+    Prompt the user for the destination path and create the path
+
+    :param dest: a filesystem path, defaults to None
+    :type dest: str, optional
+    :return: absolute path to the created installation directory
+    :rtype: Path
+    """
+
+    if dest is not None:
+        dest = Path(dest).expanduser().resolve()
+    else:
+        dest = Path.cwd().expanduser().resolve()
+    prev_dest = init_path = dest
+    dest_confirmed = False
+
+    while not dest_confirmed:
+        browse_start = (dest or Path.cwd()).expanduser().resolve()
+
+        path_completer = PathCompleter(
+            only_directories=True,
+            expanduser=True,
+            get_paths=lambda: [str(browse_start)],  # noqa: B023
+            # get_paths=lambda: [".."].extend(list(browse_start.iterdir()))
+        )
+
+        console.line()
+
+        console.print(f":grey_question: [orange3]Please select the install destination:[/] \\[{browse_start}]: ")
+        selected = prompt(
+            ">>> ",
+            complete_in_thread=True,
+            completer=path_completer,
+            default=str(browse_start) + os.sep,
+            vi_mode=True,
+            complete_while_typing=True,
+            # Test that this is not needed on Windows
+            # complete_style=CompleteStyle.READLINE_LIKE,
+        )
+        prev_dest = dest
+        dest = Path(selected)
+
+        console.line()
+
+        dest_confirmed = confirm_install(dest.expanduser().resolve())
+
+        if not dest_confirmed:
+            dest = prev_dest
+
+    dest = dest.expanduser().resolve()
+
+    try:
+        dest.mkdir(exist_ok=True, parents=True)
+        return dest
+    except PermissionError:
+        console.print(
+            f"Failed to create directory {dest} due to insufficient permissions",
+            style=Style(color="red"),
+            highlight=True,
+        )
+    except OSError:
+        console.print_exception()
+
+    if Confirm.ask("Would you like to try again?"):
+        dest_path(init_path)
+    else:
+        console.rule("Goodbye!")
+
+
+class GpuType(Enum):
+    CUDA_WITH_XFORMERS = "xformers"
+    CUDA = "cuda"
+    ROCM = "rocm"
+    CPU = "cpu"
+
+
+def select_gpu() -> GpuType:
+    """
+    Prompt the user to select the GPU driver
+    """
+
+    if ARCH == "arm64" and OS != "Darwin":
+        print(f"Only CPU acceleration is available on {ARCH} architecture. Proceeding with that.")
+        return GpuType.CPU
+
+    nvidia = (
+        "an [gold1 b]NVIDIA[/] RTX 3060 or newer GPU using CUDA",
+        GpuType.CUDA,
+    )
+    vintage_nvidia = (
+        "an [gold1 b]NVIDIA[/] RTX 20xx or older GPU using CUDA+xFormers",
+        GpuType.CUDA_WITH_XFORMERS,
+    )
+    amd = (
+        "an [gold1 b]AMD[/] GPU using ROCm",
+        GpuType.ROCM,
+    )
+    cpu = (
+        "Do not install any GPU support, use CPU for generation (slow)",
+        GpuType.CPU,
+    )
+
+    options = []
+    if OS == "Windows":
+        options = [nvidia, vintage_nvidia, cpu]
+    if OS == "Linux":
+        options = [nvidia, vintage_nvidia, amd, cpu]
+    elif OS == "Darwin":
+        options = [cpu]
+
+    if len(options) == 1:
+        return options[0][1]
+
+    options = {str(i): opt for i, opt in enumerate(options, 1)}
+
+    console.rule(":space_invader: GPU (Graphics Card) selection :space_invader:")
+    console.print(
+        Panel(
+            Group(
+                "\n".join(
+                    [
+                        f"Detected the [gold1]{OS}-{ARCH}[/] platform",
+                        "",
+                        "See [deep_sky_blue1]https://invoke-ai.github.io/InvokeAI/installation/requirements/[/] to ensure your system meets the minimum requirements.",
+                        "",
+                        "[red3]🠶[/] [b]Your GPU drivers must be correctly installed before using InvokeAI![/] [red3]🠴[/]",
+                    ]
+                ),
+                "",
+                "Please select the type of GPU installed in your computer.",
+                Panel(
+                    "\n".join([f"[dark_goldenrod b i]{i}[/] [dark_red]🢒[/]{opt[0]}" for (i, opt) in options.items()]),
+                    box=box.MINIMAL,
+                ),
+            ),
+            box=box.MINIMAL,
+            padding=(1, 1),
+        )
+    )
+    choice = prompt(
+        "Please make your selection: ",
+        validator=Validator.from_callable(
+            lambda n: n in options.keys(), error_message="Please select one the above options"
+        ),
+    )
+
+    return options[choice][1]
+
+
+def simple_banner(message: str) -> None:
+    """
+    A simple banner with a message, defined here for styling consistency
+
+    :param message: The message to display
+    :type message: str
+    """
+
+    console.rule(message)
+
+
+# TODO this does not yet work correctly
+def windows_long_paths_registry() -> None:
+    """
+    Display a message about applying the Windows long paths registry fix
+    """
+
+    with open(str(Path(__file__).parent / "WinLongPathsEnabled.reg"), "r", encoding="utf-16le") as code:
+        syntax = Syntax(code.read(), line_numbers=True, lexer="regedit")
+
+    console.print(
+        Panel(
+            Group(
+                "\n".join(
+                    [
+                        "We will now apply a registry fix to enable long paths on Windows. InvokeAI needs this to function correctly. We are asking your permission to modify the Windows Registry on your behalf.",
+                        "",
+                        "This is the change that will be applied:",
+                        str(syntax),
+                    ]
+                )
+            ),
+            title="Windows Long Paths registry fix",
+            box=box.HORIZONTALS,
+            padding=(1, 1),
+        )
+    )
+
+
+def _platform_specific_help() -> Text | None:
+    if OS == "Darwin":
+        text = Text.from_markup(
+            """[b wheat1]macOS Users![/]\n\nPlease be sure you have the [b wheat1]Xcode command-line tools[/] installed before continuing.\nIf not, cancel with [i]Control-C[/] and follow the Xcode install instructions at [deep_sky_blue1]https://www.freecodecamp.org/news/install-xcode-command-line-tools/[/]."""
+        )
+    elif OS == "Windows":
+        text = Text.from_markup(
+            """[b wheat1]Windows Users![/]\n\nBefore you start, please do the following:
+  1. Double-click on the file [b wheat1]WinLongPathsEnabled.reg[/] in order to
+     enable long path support on your system.
+  2. Make sure you have the [b wheat1]Visual C++ core libraries[/] installed. If not, install from
+     [deep_sky_blue1]https://learn.microsoft.com/en-US/cpp/windows/latest-supported-vc-redist?view=msvc-170[/]"""
+        )
+    else:
+        return
+    return text

installer/readme.txt

@@ -0,0 +1,52 @@
+InvokeAI
+
+Project homepage: https://github.com/invoke-ai/InvokeAI
+
+Preparations:
+
+  You will need to install Python 3.10 or higher for this installer
+  to work. Instructions are given here:
+  https://invoke-ai.github.io/InvokeAI/installation/INSTALL_AUTOMATED/
+
+  Before you start the installer, please open up your system's command
+  line window (Terminal or Command) and type the commands:
+
+     python --version
+
+  If all is well, it will print "Python 3.X.X", where the version number
+  is at least 3.10.*, and not higher than 3.11.*.
+
+  If this works, check the version of the Python package manager, pip:
+
+     pip --version
+
+  You should get a message that indicates that the pip package
+  installer was derived from Python 3.10 or 3.11. For example:
+  "pip 22.0.1 from /usr/bin/pip (python 3.10)"
+
+Long Paths on Windows:
+
+  If you are on Windows, you will need to enable Windows Long Paths to
+  run InvokeAI successfully. If you're not sure what this is, you
+  almost certainly need to do this.
+
+  Simply double-click the "WinLongPathsEnabled.reg" file located in
+  this directory, and approve the Windows warnings. Note that you will
+  need to have admin privileges in order to do this.
+
+Launching the installer:
+
+  Windows: double-click the 'install.bat' file (while keeping it inside
+  the InvokeAI-Installer folder).
+
+  Linux and Mac: Please open the terminal application and run
+  './install.sh' (while keeping it inside the InvokeAI-Installer
+  folder).
+
+The installer will create a directory of your choice and install the
+InvokeAI application within it. This directory contains everything you need to run
+invokeai. Once InvokeAI is up and running, you may delete the
+InvokeAI-Installer folder at your convenience.
+
+For more information, please see
+https://invoke-ai.github.io/InvokeAI/installation/INSTALL_AUTOMATED/

installer/templates/invoke.bat.in

@@ -0,0 +1,54 @@
+@echo off
+
+PUSHD "%~dp0"
+setlocal
+
+call .venv\Scripts\activate.bat
+set INVOKEAI_ROOT=.
+
+:start
+echo Desired action:
+echo 1. Generate images with the browser-based interface
+echo 2. Open the developer console
+echo 3. Command-line help
+echo Q - Quit
+echo.
+echo To update, download and run the installer from https://github.com/invoke-ai/InvokeAI/releases/latest
+echo.
+set /P choice="Please enter 1-4, Q: [1] "
+if not defined choice set choice=1
+IF /I "%choice%" == "1" (
+    echo Starting the InvokeAI browser-based UI..
+    python .venv\Scripts\invokeai-web.exe %*
+) ELSE IF /I "%choice%" == "2" (
+    echo Developer Console
+    echo Python command is:
+    where python
+    echo Python version is:
+    python --version
+    echo *************************
+    echo You are now in the system shell, with the local InvokeAI Python virtual environment activated,
+    echo so that you can troubleshoot this InvokeAI installation as necessary.
+    echo *************************
+    echo *** Type `exit` to quit this shell and deactivate the Python virtual environment ***
+    call cmd /k
+) ELSE IF /I "%choice%" == "3" (
+    echo Displaying command line help...
+    python .venv\Scripts\invokeai-web.exe --help %*
+    pause
+    exit /b
+) ELSE IF /I "%choice%" == "q" (
+    echo Goodbye!
+    goto ending
+) ELSE (
+    echo Invalid selection
+    pause
+    exit /b
+)
+goto start
+
+endlocal
+pause
+
+:ending
+exit /b

installer/templates/invoke.sh.in

@@ -0,0 +1,87 @@
+#!/bin/bash
+
+# MIT License
+
+# Coauthored by Lincoln Stein, Eugene Brodsky and Joshua Kimsey
+# Copyright 2023, The InvokeAI Development Team
+
+####
+# This launch script assumes that:
+# 1. it is located in the runtime directory,
+# 2. the .venv is also located in the runtime directory and is named exactly that
+#
+# If both of the above are not true, this script will likely not work as intended.
+# Activate the virtual environment and run `invoke.py` directly.
+####
+
+set -eu
+
+# Ensure we're in the correct folder in case user's CWD is somewhere else
+scriptdir=$(dirname $(readlink -f "$0"))
+cd "$scriptdir"
+
+. .venv/bin/activate
+
+export INVOKEAI_ROOT="$scriptdir"
+
+# Stash the CLI args - when we prompt for user input, `$@` is overwritten
+PARAMS=$@
+
+# This setting allows torch to fall back to CPU for operations that are not supported by MPS on macOS.
+if [ "$(uname -s)" == "Darwin" ]; then
+    export PYTORCH_ENABLE_MPS_FALLBACK=1
+fi
+
+# Primary function for the case statement to determine user input
+do_choice() {
+    case $1 in
+    1)
+        clear
+        printf "Generate images with a browser-based interface\n"
+        invokeai-web $PARAMS
+        ;;
+    2)
+        clear
+        printf "Open the developer console\n"
+        file_name=$(basename "${BASH_SOURCE[0]}")
+        bash --init-file "$file_name"
+        ;;
+    3)
+        clear
+        printf "Command-line help\n"
+        invokeai-web --help
+        ;;
+    *)
+        clear
+        printf "Exiting...\n"
+        exit
+        ;;
+    esac
+    clear
+}
+
+# Command-line interface for launching Invoke functions
+do_line_input() {
+    clear
+    printf "What would you like to do?\n"
+    printf "1: Generate images using the browser-based interface\n"
+    printf "2: Open the developer console\n"
+    printf "3: Command-line help\n"
+    printf "Q: Quit\n\n"
+    printf "To update, download and run the installer from https://github.com/invoke-ai/InvokeAI/releases/latest\n\n"
+    read -p "Please enter 1-4, Q: [1] " yn
+    choice=${yn:='1'}
+    do_choice $choice
+    clear
+}
+
+# Main IF statement for launching Invoke, and for checking if the user is in the developer console
+if [ "$0" != "bash" ]; then
+    while true; do
+        do_line_input
+    done
+else # in developer console
+    python --version
+    printf "Press ^D to exit\n"
+    export PS1="(InvokeAI) \u@\h \w> "
+fi

invokeai/app/api/dependencies.py

@@ -23,10 +23,6 @@ from invokeai.app.services.invoker import Invoker
 from invokeai.app.services.model_images.model_images_default import ModelImageFileStorageDisk
 from invokeai.app.services.model_manager.model_manager_default import ModelManagerService
 from invokeai.app.services.model_records.model_records_sql import ModelRecordServiceSQL
-from invokeai.app.services.model_relationship_records.model_relationship_records_sqlite import (
-    SqliteModelRelationshipRecordStorage,
-)
-from invokeai.app.services.model_relationships.model_relationships_default import ModelRelationshipsService
 from invokeai.app.services.names.names_default import SimpleNameService
 from invokeai.app.services.object_serializer.object_serializer_disk import ObjectSerializerDisk
 from invokeai.app.services.object_serializer.object_serializer_forward_cache import ObjectSerializerForwardCache
@@ -43,7 +39,6 @@ from invokeai.app.services.workflow_records.workflow_records_sqlite import Sqlit
 from invokeai.app.services.workflow_thumbnails.workflow_thumbnails_disk import WorkflowThumbnailFileStorageDisk
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
     BasicConditioningInfo,
-    CogView4ConditioningInfo,
     ConditioningFieldData,
     FLUXConditioningInfo,
     SD3ConditioningInfo,
@@ -117,6 +112,7 @@ class ApiDependencies:
                 safe_globals=[torch.Tensor],
                 ephemeral=True,
             ),
+            max_cache_size=0,
         )
         conditioning = ObjectSerializerForwardCache(
             ObjectSerializerDisk[ConditioningFieldData](
@@ -127,7 +123,6 @@ class ApiDependencies:
                     SDXLConditioningInfo,
                     FLUXConditioningInfo,
                     SD3ConditioningInfo,
-                    CogView4ConditioningInfo,
                 ],
                 ephemeral=True,
             ),
@@ -140,8 +135,6 @@ class ApiDependencies:
             download_queue=download_queue_service,
             events=events,
         )
-        model_relationships = ModelRelationshipsService()
-        model_relationship_records = SqliteModelRelationshipRecordStorage(db=db)
         names = SimpleNameService()
         performance_statistics = InvocationStatsService()
         session_processor = DefaultSessionProcessor(session_runner=DefaultSessionRunner())
@@ -167,8 +160,6 @@ class ApiDependencies:
             logger=logger,
             model_images=model_images_service,
             model_manager=model_manager,
-            model_relationships=model_relationships,
-            model_relationship_records=model_relationship_records,
             download_queue=download_queue_service,
             names=names,
             performance_statistics=performance_statistics,

invokeai/app/api/routers/boards.py

@@ -146,7 +146,7 @@ async def list_boards(
     response_model=list[str],
 )
 async def list_all_board_image_names(
-    board_id: str = Path(description="The id of the board or 'none' for uncategorized images"),
+    board_id: str = Path(description="The id of the board"),
     categories: list[ImageCategory] | None = Query(default=None, description="The categories of image to include."),
     is_intermediate: bool | None = Query(default=None, description="Whether to list intermediate images."),
 ) -> list[str]:

invokeai/app/api/routers/images.py

@@ -1,13 +1,12 @@
 import io
-import json
 import traceback
-from typing import ClassVar, Optional
+from typing import Optional
 
 from fastapi import BackgroundTasks, Body, HTTPException, Path, Query, Request, Response, UploadFile
 from fastapi.responses import FileResponse
 from fastapi.routing import APIRouter
 from PIL import Image
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, Field
 
 from invokeai.app.api.dependencies import ApiDependencies
 from invokeai.app.api.extract_metadata_from_image import extract_metadata_from_image
@@ -20,8 +19,6 @@ from invokeai.app.services.image_records.image_records_common import (
 from invokeai.app.services.images.images_common import ImageDTO, ImageUrlsDTO
 from invokeai.app.services.shared.pagination import OffsetPaginatedResults
 from invokeai.app.services.shared.sqlite.sqlite_common import SQLiteDirection
-from invokeai.app.util.controlnet_utils import heuristic_resize_fast
-from invokeai.backend.image_util.util import np_to_pil, pil_to_np
 
 images_router = APIRouter(prefix="/v1/images", tags=["images"])
 
@@ -30,19 +27,6 @@ images_router = APIRouter(prefix="/v1/images", tags=["images"])
 IMAGE_MAX_AGE = 31536000
 
 
-class ResizeToDimensions(BaseModel):
-    width: int = Field(..., gt=0)
-    height: int = Field(..., gt=0)
-
-    MAX_SIZE: ClassVar[int] = 4096 * 4096
-
-    @model_validator(mode="after")
-    def validate_total_output_size(self):
-        if self.width * self.height > self.MAX_SIZE:
-            raise ValueError(f"Max total output size for resizing is {self.MAX_SIZE} pixels")
-        return self
-
-
 @images_router.post(
     "/upload",
     operation_id="upload_image",
@@ -62,11 +46,6 @@ async def upload_image(
     board_id: Optional[str] = Query(default=None, description="The board to add this image to, if any"),
     session_id: Optional[str] = Query(default=None, description="The session ID associated with this upload, if any"),
     crop_visible: Optional[bool] = Query(default=False, description="Whether to crop the image"),
-    resize_to: Optional[str] = Body(
-        default=None,
-        description=f"Dimensions to resize the image to, must be stringified tuple of 2 integers. Max total pixel count: {ResizeToDimensions.MAX_SIZE}",
-        example='"[1024,1024]"',
-    ),
     metadata: Optional[str] = Body(
         default=None,
         description="The metadata to associate with the image, must be a stringified JSON dict",
@@ -80,31 +59,13 @@ async def upload_image(
     contents = await file.read()
     try:
         pil_image = Image.open(io.BytesIO(contents))
+        if crop_visible:
+            bbox = pil_image.getbbox()
+            pil_image = pil_image.crop(bbox)
     except Exception:
         ApiDependencies.invoker.services.logger.error(traceback.format_exc())
         raise HTTPException(status_code=415, detail="Failed to read image")
 
-    if crop_visible:
-        try:
-            bbox = pil_image.getbbox()
-            pil_image = pil_image.crop(bbox)
-        except Exception:
-            raise HTTPException(status_code=500, detail="Failed to crop image")
-
-    if resize_to:
-        try:
-            dims = json.loads(resize_to)
-            resize_dims = ResizeToDimensions(**dims)
-        except Exception:
-            raise HTTPException(status_code=400, detail="Invalid resize_to format or size")
-
-        try:
-            np_image = pil_to_np(pil_image)
-            np_image = heuristic_resize_fast(np_image, (resize_dims.width, resize_dims.height))
-            pil_image = np_to_pil(np_image)
-        except Exception:
-            raise HTTPException(status_code=500, detail="Failed to resize image")
-
     extracted_metadata = extract_metadata_from_image(
         pil_image=pil_image,
         invokeai_metadata_override=metadata,
@@ -395,29 +356,6 @@ async def delete_images_from_list(
         raise HTTPException(status_code=500, detail="Failed to delete images")
 
 
-@images_router.delete(
-    "/uncategorized", operation_id="delete_uncategorized_images", response_model=DeleteImagesFromListResult
-)
-async def delete_uncategorized_images() -> DeleteImagesFromListResult:
-    """Deletes all images that are uncategorized"""
-
-    image_names = ApiDependencies.invoker.services.board_images.get_all_board_image_names_for_board(
-        board_id="none", categories=None, is_intermediate=None
-    )
-
-    try:
-        deleted_images: list[str] = []
-        for image_name in image_names:
-            try:
-                ApiDependencies.invoker.services.images.delete(image_name)
-                deleted_images.append(image_name)
-            except Exception:
-                pass
-        return DeleteImagesFromListResult(deleted_images=deleted_images)
-    except Exception:
-        raise HTTPException(status_code=500, detail="Failed to delete images")
-
-
 class ImagesUpdatedFromListResult(BaseModel):
     updated_image_names: list[str] = Field(description="The image names that were updated")
 

invokeai/app/api/routers/model_manager.py

@@ -85,7 +85,6 @@ example_model_config = {
     "config_path": "string",
     "key": "string",
     "hash": "string",
-    "file_size": 1,
     "description": "string",
     "source": "string",
     "converted_at": 0,
@@ -893,12 +892,6 @@ class HFTokenHelper:
             huggingface_hub.login(token=token, add_to_git_credential=False)
         return cls.get_status()
 
-    @classmethod
-    def reset_token(cls) -> HFTokenStatus:
-        with SuppressOutput(), contextlib.suppress(Exception):
-            huggingface_hub.logout()
-        return cls.get_status()
-
 
 @model_manager_router.get("/hf_login", operation_id="get_hf_login_status", response_model=HFTokenStatus)
 async def get_hf_login_status() -> HFTokenStatus:
@@ -921,8 +914,3 @@ async def do_hf_login(
         ApiDependencies.invoker.services.logger.warning("Unable to verify HF token")
 
     return token_status
-
-
-@model_manager_router.delete("/hf_login", operation_id="reset_hf_token", response_model=HFTokenStatus)
-async def reset_hf_token() -> HFTokenStatus:
-    return HFTokenHelper.reset_token()

invokeai/app/api/routers/model_relationships.py

@@ -1,215 +0,0 @@
-"""FastAPI route for model relationship records."""
-
-from typing import List
-
-from fastapi import APIRouter, Body, HTTPException, Path, status
-from pydantic import BaseModel, Field
-
-from invokeai.app.api.dependencies import ApiDependencies
-
-model_relationships_router = APIRouter(prefix="/v1/model_relationships", tags=["model_relationships"])
-
-# === Schemas ===
-
-
-class ModelRelationshipCreateRequest(BaseModel):
-    model_key_1: str = Field(
-        ...,
-        description="The key of the first model in the relationship",
-        examples=[
-            "aa3b247f-90c9-4416-bfcd-aeaa57a5339e",
-            "ac32b914-10ab-496e-a24a-3068724b9c35",
-            "d944abfd-c7c3-42e2-a4ff-da640b29b8b4",
-            "b1c2d3e4-f5a6-7890-abcd-ef1234567890",
-            "12345678-90ab-cdef-1234-567890abcdef",
-            "fedcba98-7654-3210-fedc-ba9876543210",
-        ],
-    )
-    model_key_2: str = Field(
-        ...,
-        description="The key of the second model in the relationship",
-        examples=[
-            "3bb7c0eb-b6c8-469c-ad8c-4d69c06075e4",
-            "f0c3da4e-d9ff-42b5-a45c-23be75c887c9",
-            "38170dd8-f1e5-431e-866c-2c81f1277fcc",
-            "c57fea2d-7646-424c-b9ad-c0ba60fc68be",
-            "10f7807b-ab54-46a9-ab03-600e88c630a1",
-            "f6c1d267-cf87-4ee0-bee0-37e791eacab7",
-        ],
-    )
-
-
-class ModelRelationshipBatchRequest(BaseModel):
-    model_keys: List[str] = Field(
-        ...,
-        description="List of model keys to fetch related models for",
-        examples=[
-            [
-                "aa3b247f-90c9-4416-bfcd-aeaa57a5339e",
-                "ac32b914-10ab-496e-a24a-3068724b9c35",
-            ],
-            [
-                "b1c2d3e4-f5a6-7890-abcd-ef1234567890",
-                "12345678-90ab-cdef-1234-567890abcdef",
-                "fedcba98-7654-3210-fedc-ba9876543210",
-            ],
-            [
-                "3bb7c0eb-b6c8-469c-ad8c-4d69c06075e4",
-            ],
-        ],
-    )
-
-
-# === Routes ===
-
-
-@model_relationships_router.get(
-    "/i/{model_key}",
-    operation_id="get_related_models",
-    response_model=list[str],
-    responses={
-        200: {
-            "description": "A list of related model keys was retrieved successfully",
-            "content": {
-                "application/json": {
-                    "example": [
-                        "15e9eb28-8cfe-47c9-b610-37907a79fc3c",
-                        "71272e82-0e5f-46d5-bca9-9a61f4bd8a82",
-                        "a5d7cd49-1b98-4534-a475-aeee4ccf5fa2",
-                    ]
-                }
-            },
-        },
-        404: {"description": "The specified model could not be found"},
-        422: {"description": "Validation error"},
-    },
-)
-async def get_related_models(
-    model_key: str = Path(..., description="The key of the model to get relationships for"),
-) -> list[str]:
-    """
-    Get a list of model keys related to a given model.
-    """
-    try:
-        return ApiDependencies.invoker.services.model_relationships.get_related_model_keys(model_key)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@model_relationships_router.post(
-    "/",
-    status_code=status.HTTP_204_NO_CONTENT,
-    responses={
-        204: {"description": "The relationship was successfully created"},
-        400: {"description": "Invalid model keys or self-referential relationship"},
-        409: {"description": "The relationship already exists"},
-        422: {"description": "Validation error"},
-        500: {"description": "Internal server error"},
-    },
-    summary="Add Model Relationship",
-    description="Creates a **bidirectional** relationship between two models, allowing each to reference the other as related.",
-)
-async def add_model_relationship(
-    req: ModelRelationshipCreateRequest = Body(..., description="The model keys to relate"),
-) -> None:
-    """
-    Add a relationship between two models.
-
-    Relationships are bidirectional and will be accessible from both models.
-
-    - Raises 400 if keys are invalid or identical.
-    - Raises 409 if the relationship already exists.
-    """
-    try:
-        if req.model_key_1 == req.model_key_2:
-            raise HTTPException(status_code=400, detail="Cannot relate a model to itself.")
-
-        ApiDependencies.invoker.services.model_relationships.add_model_relationship(
-            req.model_key_1,
-            req.model_key_2,
-        )
-    except ValueError as e:
-        raise HTTPException(status_code=409, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@model_relationships_router.delete(
-    "/",
-    status_code=status.HTTP_204_NO_CONTENT,
-    responses={
-        204: {"description": "The relationship was successfully removed"},
-        400: {"description": "Invalid model keys or self-referential relationship"},
-        404: {"description": "The relationship does not exist"},
-        422: {"description": "Validation error"},
-        500: {"description": "Internal server error"},
-    },
-    summary="Remove Model Relationship",
-    description="Removes a **bidirectional** relationship between two models. The relationship must already exist.",
-)
-async def remove_model_relationship(
-    req: ModelRelationshipCreateRequest = Body(..., description="The model keys to disconnect"),
-) -> None:
-    """
-    Removes a bidirectional relationship between two model keys.
-
-    - Raises 400 if attempting to unlink a model from itself.
-    - Raises 404 if the relationship was not found.
-    """
-    try:
-        if req.model_key_1 == req.model_key_2:
-            raise HTTPException(status_code=400, detail="Cannot unlink a model from itself.")
-
-        ApiDependencies.invoker.services.model_relationships.remove_model_relationship(
-            req.model_key_1,
-            req.model_key_2,
-        )
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@model_relationships_router.post(
-    "/batch",
-    operation_id="get_related_models_batch",
-    response_model=List[str],
-    responses={
-        200: {
-            "description": "Related model keys retrieved successfully",
-            "content": {
-                "application/json": {
-                    "example": [
-                        "ca562b14-995e-4a42-90c1-9528f1a5921d",
-                        "cc0c2b8a-c62e-41d6-878e-cc74dde5ca8f",
-                        "18ca7649-6a9e-47d5-bc17-41ab1e8cec81",
-                        "7c12d1b2-0ef9-4bec-ba55-797b2d8f2ee1",
-                        "c382eaa3-0e28-4ab0-9446-408667699aeb",
-                        "71272e82-0e5f-46d5-bca9-9a61f4bd8a82",
-                        "a5d7cd49-1b98-4534-a475-aeee4ccf5fa2",
-                    ]
-                }
-            },
-        },
-        422: {"description": "Validation error"},
-        500: {"description": "Internal server error"},
-    },
-    summary="Get Related Model Keys (Batch)",
-    description="Retrieves all **unique related model keys** for a list of given models. This is useful for contextual suggestions or filtering.",
-)
-async def get_related_models_batch(
-    req: ModelRelationshipBatchRequest = Body(..., description="Model keys to check for related connections"),
-) -> list[str]:
-    """
-    Accepts multiple model keys and returns a flat list of all unique related keys.
-
-    Useful when working with multiple selections in the UI or cross-model comparisons.
-    """
-    try:
-        all_related: set[str] = set()
-        for key in req.model_keys:
-            related = ApiDependencies.invoker.services.model_relationships.get_related_model_keys(key)
-            all_related.update(related)
-        return list(all_related)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))

invokeai/app/api_app.py

@@ -22,7 +22,6 @@ from invokeai.app.api.routers import (
     download_queue,
     images,
     model_manager,
-    model_relationships,
     session_queue,
     style_presets,
     utilities,
@@ -126,7 +125,6 @@ app.include_router(download_queue.download_queue_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")
-app.include_router(model_relationships.model_relationships_router, prefix="/api")
 app.include_router(app_info.app_router, prefix="/api")
 app.include_router(session_queue.session_queue_router, prefix="/api")
 app.include_router(workflows.workflows_router, prefix="/api")

invokeai/app/invocations/baseinvocation.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 import inspect
 import re
 import sys
-import types
-import typing
 import warnings
 from abc import ABC, abstractmethod
 from enum import Enum
@@ -22,14 +20,12 @@ from typing import (
     Literal,
     Optional,
     Type,
-    TypedDict,
     TypeVar,
     Union,
-    cast,
 )
 
 import semver
-from pydantic import BaseModel, ConfigDict, Field, JsonValue, TypeAdapter, create_model
+from pydantic import BaseModel, ConfigDict, Field, TypeAdapter, create_model
 from pydantic.fields import FieldInfo
 from pydantic_core import PydanticUndefined
 
@@ -76,24 +72,13 @@ class Classification(str, Enum, metaclass=MetaEnum):
     Special = "special"
 
 
-class Bottleneck(str, Enum, metaclass=MetaEnum):
-    """
-    The bottleneck of an invocation.
-    - `Network`: The invocation's execution is network-bound.
-    - `GPU`: The invocation's execution is GPU-bound.
-    """
-
-    Network = "network"
-    GPU = "gpu"
-
-
 class UIConfigBase(BaseModel):
     """
     Provides additional node configuration to the UI.
     This is used internally by the @invocation decorator logic. Do not use this directly.
     """
 
-    tags: Optional[list[str]] = Field(default=None, description="The node's tags")
+    tags: Optional[list[str]] = Field(default_factory=None, description="The node's tags")
     title: Optional[str] = Field(default=None, description="The node's display name")
     category: Optional[str] = Field(default=None, description="The node's category")
     version: str = Field(
@@ -108,11 +93,6 @@ class UIConfigBase(BaseModel):
     )
 
 
-class OriginalModelField(TypedDict):
-    annotation: Any
-    field_info: FieldInfo
-
-
 class BaseInvocationOutput(BaseModel):
     """
     Base class for all invocation outputs.
@@ -120,12 +100,6 @@ class BaseInvocationOutput(BaseModel):
     All invocation outputs must use the `@invocation_output` decorator to provide their unique type.
     """
 
-    output_meta: Optional[dict[str, JsonValue]] = Field(
-        default=None,
-        description="Optional dictionary of metadata for the invocation output, unrelated to the invocation's actual output value. This is not exposed as an output field.",
-        json_schema_extra={"field_kind": FieldKind.NodeAttribute},
-    )
-
     @staticmethod
     def json_schema_extra(schema: dict[str, Any], model_class: Type[BaseInvocationOutput]) -> None:
         """Adds various UI-facing attributes to the invocation output's OpenAPI schema."""
@@ -141,9 +115,6 @@ class BaseInvocationOutput(BaseModel):
         """Gets the invocation output's type, as provided by the `@invocation_output` decorator."""
         return cls.model_fields["type"].default
 
-    _original_model_fields: ClassVar[dict[str, OriginalModelField]] = {}
-    """The original model fields, before any modifications were made by the @invocation_output decorator."""
-
     model_config = ConfigDict(
         protected_namespaces=(),
         validate_assignment=True,
@@ -177,7 +148,7 @@ class BaseInvocation(ABC, BaseModel):
         return cls.model_fields["type"].default
 
     @classmethod
-    def get_output_annotation(cls) -> Type[BaseInvocationOutput]:
+    def get_output_annotation(cls) -> BaseInvocationOutput:
         """Gets the invocation's output annotation (i.e. the return annotation of its `invoke()` method)."""
         return signature(cls.invoke).return_annotation
 
@@ -209,7 +180,7 @@ class BaseInvocation(ABC, BaseModel):
         Internal invoke method, calls `invoke()` after some prep.
         Handles optional fields that are required to call `invoke()` and invocation cache.
         """
-        for field_name, field in type(self).model_fields.items():
+        for field_name, field in self.model_fields.items():
             if not field.json_schema_extra or callable(field.json_schema_extra):
                 # something has gone terribly awry, we should always have this and it should be a dict
                 continue
@@ -224,9 +195,9 @@ class BaseInvocation(ABC, BaseModel):
                 setattr(self, field_name, orig_default)
             if orig_required and orig_default is PydanticUndefined and getattr(self, field_name) is None:
                 if input_ == Input.Connection:
-                    raise RequiredConnectionException(type(self).model_fields["type"].default, field_name)
+                    raise RequiredConnectionException(self.model_fields["type"].default, field_name)
                 elif input_ == Input.Any:
-                    raise MissingInputException(type(self).model_fields["type"].default, field_name)
+                    raise MissingInputException(self.model_fields["type"].default, field_name)
 
         # skip node cache codepath if it's disabled
         if services.configuration.node_cache_size == 0:
@@ -264,8 +235,6 @@ class BaseInvocation(ABC, BaseModel):
         json_schema_extra={"field_kind": FieldKind.NodeAttribute},
     )
 
-    bottleneck: ClassVar[Bottleneck]
-
     UIConfig: ClassVar[UIConfigBase]
 
     model_config = ConfigDict(
@@ -276,9 +245,6 @@ class BaseInvocation(ABC, BaseModel):
         coerce_numbers_to_str=True,
     )
 
-    _original_model_fields: ClassVar[dict[str, OriginalModelField]] = {}
-    """The original model fields, before any modifications were made by the @invocation decorator."""
-
 
 TBaseInvocation = TypeVar("TBaseInvocation", bound=BaseInvocation)
 
@@ -290,26 +256,6 @@ class InvocationRegistry:
     @classmethod
     def register_invocation(cls, invocation: type[BaseInvocation]) -> None:
         """Registers an invocation."""
-
-        invocation_type = invocation.get_type()
-        node_pack = invocation.UIConfig.node_pack
-
-        # Log a warning when an existing invocation is being clobbered by the one we are registering
-        clobbered_invocation = InvocationRegistry.get_invocation_for_type(invocation_type)
-        if clobbered_invocation is not None:
-            # This should always be true - we just checked if the invocation type was in the set
-            clobbered_node_pack = clobbered_invocation.UIConfig.node_pack
-
-            if clobbered_node_pack == "invokeai":
-                # The invocation being clobbered is a core invocation
-                logger.warning(f'Overriding core node "{invocation_type}" with node from "{node_pack}"')
-            else:
-                # The invocation being clobbered is a custom invocation
-                logger.warning(
-                    f'Overriding node "{invocation_type}" from "{node_pack}" with node from "{clobbered_node_pack}"'
-                )
-            cls._invocation_classes.remove(clobbered_invocation)
-
         cls._invocation_classes.add(invocation)
         cls.invalidate_invocation_typeadapter()
 
@@ -368,15 +314,6 @@ class InvocationRegistry:
     @classmethod
     def register_output(cls, output: "type[TBaseInvocationOutput]") -> None:
         """Registers an invocation output."""
-        output_type = output.get_type()
-
-        # Log a warning when an existing invocation is being clobbered by the one we are registering
-        clobbered_output = InvocationRegistry.get_output_for_type(output_type)
-        if clobbered_output is not None:
-            # TODO(psyche): We do not record the node pack of the output, so we cannot log it here
-            logger.warning(f'Overriding invocation output "{output_type}"')
-            cls._output_classes.remove(clobbered_output)
-
         cls._output_classes.add(output)
         cls.invalidate_output_typeadapter()
 
@@ -385,11 +322,6 @@ class InvocationRegistry:
         """Gets all invocation outputs."""
         return cls._output_classes
 
-    @classmethod
-    def get_outputs_map(cls) -> dict[str, type[BaseInvocationOutput]]:
-        """Gets a map of all output types to their output classes."""
-        return {i.get_type(): i for i in cls.get_output_classes()}
-
     @classmethod
     @lru_cache(maxsize=1)
     def get_output_typeadapter(cls) -> TypeAdapter[Any]:
@@ -415,11 +347,6 @@ class InvocationRegistry:
         """Gets all invocation output types."""
         return (i.get_type() for i in cls.get_output_classes())
 
-    @classmethod
-    def get_output_for_type(cls, output_type: str) -> type[BaseInvocationOutput] | None:
-        """Gets the output class for a given output type."""
-        return cls.get_outputs_map().get(output_type)
-
 
 RESERVED_NODE_ATTRIBUTE_FIELD_NAMES = {
     "id",
@@ -427,12 +354,11 @@ RESERVED_NODE_ATTRIBUTE_FIELD_NAMES = {
     "use_cache",
     "type",
     "workflow",
-    "bottleneck",
 }
 
 RESERVED_INPUT_FIELD_NAMES = {"metadata", "board"}
 
-RESERVED_OUTPUT_FIELD_NAMES = {"type", "output_meta"}
+RESERVED_OUTPUT_FIELD_NAMES = {"type"}
 
 
 class _Model(BaseModel):
@@ -504,48 +430,6 @@ def validate_fields(model_fields: dict[str, FieldInfo], model_type: str) -> None
     return None
 
 
-class NoDefaultSentinel:
-    pass
-
-
-def validate_field_default(
-    cls_name: str, field_name: str, invocation_type: str, annotation: Any, field_info: FieldInfo
-) -> None:
-    """Validates the default value of a field against its pydantic field definition."""
-
-    assert isinstance(field_info.json_schema_extra, dict), "json_schema_extra is not a dict"
-
-    # By the time we are doing this, we've already done some pydantic magic by overriding the original default value.
-    # We store the original default value in the json_schema_extra dict, so we can validate it here.
-    orig_default = field_info.json_schema_extra.get("orig_default", NoDefaultSentinel)
-
-    if orig_default is NoDefaultSentinel:
-        return
-
-    # To validate the default value, we can create a temporary pydantic model with the field we are validating as its
-    # only field. Then validate the default value against this temporary model.
-    TempDefaultValidator = cast(BaseModel, create_model(cls_name, **{field_name: (annotation, field_info)}))
-
-    try:
-        TempDefaultValidator.model_validate({field_name: orig_default})
-    except Exception as e:
-        raise InvalidFieldError(
-            f'Default value for field "{field_name}" on invocation "{invocation_type}" is invalid, {e}'
-        ) from e
-
-
-def is_optional(annotation: Any) -> bool:
-    """
-    Checks if the given annotation is optional (i.e. Optional[X], Union[X, None] or X | None).
-    """
-    origin = typing.get_origin(annotation)
-    # PEP 604 unions (int|None) have origin types.UnionType
-    is_union = origin is typing.Union or origin is types.UnionType
-    if not is_union:
-        return False
-    return any(arg is type(None) for arg in typing.get_args(annotation))
-
-
 def invocation(
     invocation_type: str,
     title: Optional[str] = None,
@@ -554,7 +438,6 @@ def invocation(
     version: Optional[str] = None,
     use_cache: Optional[bool] = True,
     classification: Classification = Classification.Stable,
-    bottleneck: Bottleneck = Bottleneck.GPU,
 ) -> Callable[[Type[TBaseInvocation]], Type[TBaseInvocation]]:
     """
     Registers an invocation.
@@ -566,7 +449,6 @@ def invocation(
     :param Optional[str] version: Adds a version to the invocation. Must be a valid semver string. Defaults to None.
     :param Optional[bool] use_cache: Whether or not to use the invocation cache. Defaults to True. The user may override this in the workflow editor.
     :param Classification classification: The classification of the invocation. Defaults to FeatureClassification.Stable. Use Beta or Prototype if the invocation is unstable.
-    :param Bottleneck bottleneck: The bottleneck of the invocation. Defaults to Bottleneck.GPU. Use Network if the invocation is network-bound.
     """
 
     def wrapper(cls: Type[TBaseInvocation]) -> Type[TBaseInvocation]:
@@ -578,26 +460,27 @@ def invocation(
         # The node pack is the module name - will be "invokeai" for built-in nodes
         node_pack = cls.__module__.split(".")[0]
 
+        # Handle the case where an existing node is being clobbered by the one we are registering
+        if invocation_type in InvocationRegistry.get_invocation_types():
+            clobbered_invocation = InvocationRegistry.get_invocation_for_type(invocation_type)
+            # This should always be true - we just checked if the invocation type was in the set
+            assert clobbered_invocation is not None
+
+            clobbered_node_pack = clobbered_invocation.UIConfig.node_pack
+
+            if clobbered_node_pack == "invokeai":
+                # The node being clobbered is a core node
+                raise ValueError(
+                    f'Cannot load node "{invocation_type}" from node pack "{node_pack}" - a core node with the same type already exists'
+                )
+            else:
+                # The node being clobbered is a custom node
+                raise ValueError(
+                    f'Cannot load node "{invocation_type}" from node pack "{node_pack}" - a node with the same type already exists in node pack "{clobbered_node_pack}"'
+                )
+
         validate_fields(cls.model_fields, invocation_type)
 
-        fields: dict[str, tuple[Any, FieldInfo]] = {}
-
-        for field_name, field_info in cls.model_fields.items():
-            annotation = field_info.annotation
-            assert annotation is not None, f"{field_name} on invocation {invocation_type} has no type annotation."
-            assert isinstance(field_info.json_schema_extra, dict), (
-                f"{field_name} on invocation {invocation_type} has a non-dict json_schema_extra, did you forget to use InputField?"
-            )
-
-            cls._original_model_fields[field_name] = OriginalModelField(annotation=annotation, field_info=field_info)
-
-            validate_field_default(cls.__name__, field_name, invocation_type, annotation, field_info)
-
-            if field_info.default is None and not is_optional(annotation):
-                annotation = annotation | None
-
-            fields[field_name] = (annotation, field_info)
-
         # Add OpenAPI schema extras
         uiconfig: dict[str, Any] = {}
         uiconfig["title"] = title
@@ -621,8 +504,6 @@ def invocation(
         if use_cache is not None:
             cls.model_fields["use_cache"].default = use_cache
 
-        cls.bottleneck = bottleneck
-
         # Add the invocation type to the model.
 
         # You'd be tempted to just add the type field and rebuild the model, like this:
@@ -632,27 +513,11 @@ def invocation(
         # Unfortunately, because the `GraphInvocation` uses a forward ref in its `graph` field's annotation, this does
         # not work. Instead, we have to create a new class with the type field and patch the original class with it.
 
-        invocation_type_annotation = Literal[invocation_type]
-
-        # Field() returns an instance of FieldInfo, but thanks to a pydantic implementation detail, it is _typed_ as Any.
-        # This cast makes the type annotation match the class's true type.
-        invocation_type_field_info = cast(
-            FieldInfo,
-            Field(title="type", default=invocation_type, json_schema_extra={"field_kind": FieldKind.NodeAttribute}),
+        invocation_type_annotation = Literal[invocation_type]  # type: ignore
+        invocation_type_field = Field(
+            title="type", default=invocation_type, json_schema_extra={"field_kind": FieldKind.NodeAttribute}
         )
 
-        fields["type"] = (invocation_type_annotation, invocation_type_field_info)
-
-        # Invocation outputs must be registered using the @invocation_output decorator, but it is possible that the
-        # output is registered _after_ this invocation is registered. It depends on module import ordering.
-        #
-        # We can only confirm the output for an invocation is registered after all modules are imported. There's
-        # only really one good time to do that - during application startup, in `run_app.py`, after loading all
-        # custom nodes.
-        #
-        # We can still do some basic validation here - ensure the invoke method is defined and returns an instance
-        # of BaseInvocationOutput.
-
         # Validate the `invoke()` method is implemented
         if "invoke" in cls.__abstractmethods__:
             raise ValueError(f'Invocation "{invocation_type}" must implement the "invoke" method')
@@ -674,12 +539,17 @@ def invocation(
             )
 
         docstring = cls.__doc__
-        new_class = create_model(cls.__qualname__, __base__=cls, __module__=cls.__module__, **fields)  # type: ignore
-        new_class.__doc__ = docstring
+        cls = create_model(
+            cls.__qualname__,
+            __base__=cls,
+            __module__=cls.__module__,
+            type=(invocation_type_annotation, invocation_type_field),
+        )
+        cls.__doc__ = docstring
 
-        InvocationRegistry.register_invocation(new_class)
+        InvocationRegistry.register_invocation(cls)
 
-        return new_class
+        return cls
 
     return wrapper
 
@@ -702,41 +572,29 @@ def invocation_output(
         if re.compile(r"^\S+$").match(output_type) is None:
             raise ValueError(f'"output_type" must consist of non-whitespace characters, got "{output_type}"')
 
+        if output_type in InvocationRegistry.get_output_types():
+            raise ValueError(f'Invocation type "{output_type}" already exists')
+
         validate_fields(cls.model_fields, output_type)
 
-        fields: dict[str, tuple[Any, FieldInfo]] = {}
-
-        for field_name, field_info in cls.model_fields.items():
-            annotation = field_info.annotation
-            assert annotation is not None, f"{field_name} on invocation output {output_type} has no type annotation."
-            assert isinstance(field_info.json_schema_extra, dict), (
-                f"{field_name} on invocation output {output_type} has a non-dict json_schema_extra, did you forget to use InputField?"
-            )
-
-            cls._original_model_fields[field_name] = OriginalModelField(annotation=annotation, field_info=field_info)
-
-            if field_info.default is not PydanticUndefined and is_optional(annotation):
-                annotation = annotation | None
-            fields[field_name] = (annotation, field_info)
-
         # Add the output type to the model.
-        output_type_annotation = Literal[output_type]
 
-        # Field() returns an instance of FieldInfo, but thanks to a pydantic implementation detail, it is _typed_ as Any.
-        # This cast makes the type annotation match the class's true type.
-        output_type_field_info = cast(
-            FieldInfo,
-            Field(title="type", default=output_type, json_schema_extra={"field_kind": FieldKind.NodeAttribute}),
+        output_type_annotation = Literal[output_type]  # type: ignore
+        output_type_field = Field(
+            title="type", default=output_type, json_schema_extra={"field_kind": FieldKind.NodeAttribute}
         )
 
-        fields["type"] = (output_type_annotation, output_type_field_info)
-
         docstring = cls.__doc__
-        new_class = create_model(cls.__qualname__, __base__=cls, __module__=cls.__module__, **fields)
-        new_class.__doc__ = docstring
+        cls = create_model(
+            cls.__qualname__,
+            __base__=cls,
+            __module__=cls.__module__,
+            type=(output_type_annotation, output_type_field),
+        )
+        cls.__doc__ = docstring
 
-        InvocationRegistry.register_output(new_class)
+        InvocationRegistry.register_output(cls)
 
-        return new_class
+        return cls
 
     return wrapper

invokeai/app/invocations/batch.py

@@ -64,6 +64,7 @@ class ImageBatchInvocation(BaseBatchInvocation):
     """Create a batched generation, where the workflow is executed once for each image in the batch."""
 
     images: list[ImageField] = InputField(
+        default=[],
         min_length=1,
         description="The images to batch over",
     )
@@ -119,6 +120,7 @@ class StringBatchInvocation(BaseBatchInvocation):
     """Create a batched generation, where the workflow is executed once for each string in the batch."""
 
     strings: list[str] = InputField(
+        default=[],
         min_length=1,
         description="The strings to batch over",
     )
@@ -174,6 +176,7 @@ class IntegerBatchInvocation(BaseBatchInvocation):
     """Create a batched generation, where the workflow is executed once for each integer in the batch."""
 
     integers: list[int] = InputField(
+        default=[],
         min_length=1,
         description="The integers to batch over",
     )
@@ -227,6 +230,7 @@ class FloatBatchInvocation(BaseBatchInvocation):
     """Create a batched generation, where the workflow is executed once for each float in the batch."""
 
     floats: list[float] = InputField(
+        default=[],
         min_length=1,
         description="The floats to batch over",
     )

invokeai/app/invocations/cogview4_denoise.py

@@ -1,363 +0,0 @@
-from typing import Callable, Optional
-
-import torch
-import torchvision.transforms as tv_transforms
-from diffusers.models.transformers.transformer_cogview4 import CogView4Transformer2DModel
-from torchvision.transforms.functional import resize as tv_resize
-from tqdm import tqdm
-
-from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
-from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
-from invokeai.app.invocations.fields import (
-    CogView4ConditioningField,
-    DenoiseMaskField,
-    FieldDescriptions,
-    Input,
-    InputField,
-    LatentsField,
-    WithBoard,
-    WithMetadata,
-)
-from invokeai.app.invocations.model import TransformerField
-from invokeai.app.invocations.primitives import LatentsOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.flux.sampling_utils import clip_timestep_schedule_fractional
-from invokeai.backend.model_manager.config import BaseModelType
-from invokeai.backend.rectified_flow.rectified_flow_inpaint_extension import RectifiedFlowInpaintExtension
-from invokeai.backend.stable_diffusion.diffusers_pipeline import PipelineIntermediateState
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import CogView4ConditioningInfo
-from invokeai.backend.util.devices import TorchDevice
-
-
-@invocation(
-    "cogview4_denoise",
-    title="Denoise - CogView4",
-    tags=["image", "cogview4"],
-    category="image",
-    version="1.0.0",
-    classification=Classification.Prototype,
-)
-class CogView4DenoiseInvocation(BaseInvocation, WithMetadata, WithBoard):
-    """Run the denoising process with a CogView4 model."""
-
-    # If latents is provided, this means we are doing image-to-image.
-    latents: Optional[LatentsField] = InputField(
-        default=None, description=FieldDescriptions.latents, input=Input.Connection
-    )
-    # denoise_mask is used for image-to-image inpainting. Only the masked region is modified.
-    denoise_mask: Optional[DenoiseMaskField] = InputField(
-        default=None, description=FieldDescriptions.denoise_mask, input=Input.Connection
-    )
-    denoising_start: float = InputField(default=0.0, ge=0, le=1, description=FieldDescriptions.denoising_start)
-    denoising_end: float = InputField(default=1.0, ge=0, le=1, description=FieldDescriptions.denoising_end)
-    transformer: TransformerField = InputField(
-        description=FieldDescriptions.cogview4_model, input=Input.Connection, title="Transformer"
-    )
-    positive_conditioning: CogView4ConditioningField = InputField(
-        description=FieldDescriptions.positive_cond, input=Input.Connection
-    )
-    negative_conditioning: CogView4ConditioningField = InputField(
-        description=FieldDescriptions.negative_cond, input=Input.Connection
-    )
-    cfg_scale: float | list[float] = InputField(default=3.5, description=FieldDescriptions.cfg_scale, title="CFG Scale")
-    width: int = InputField(default=1024, multiple_of=32, description="Width of the generated image.")
-    height: int = InputField(default=1024, multiple_of=32, description="Height of the generated image.")
-    steps: int = InputField(default=25, gt=0, description=FieldDescriptions.steps)
-    seed: int = InputField(default=0, description="Randomness seed for reproducibility.")
-
-    @torch.no_grad()
-    def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = self._run_diffusion(context)
-        latents = latents.detach().to("cpu")
-
-        name = context.tensors.save(tensor=latents)
-        return LatentsOutput.build(latents_name=name, latents=latents, seed=None)
-
-    def _prep_inpaint_mask(self, context: InvocationContext, latents: torch.Tensor) -> torch.Tensor | None:
-        """Prepare the inpaint mask.
-        - Loads the mask
-        - Resizes if necessary
-        - Casts to same device/dtype as latents
-
-        Args:
-            context (InvocationContext): The invocation context, for loading the inpaint mask.
-            latents (torch.Tensor): A latent image tensor. Used to determine the target shape, device, and dtype for the
-                inpaint mask.
-
-        Returns:
-            torch.Tensor | None: Inpaint mask. Values of 0.0 represent the regions to be fully denoised, and 1.0
-                represent the regions to be preserved.
-        """
-        if self.denoise_mask is None:
-            return None
-        mask = context.tensors.load(self.denoise_mask.mask_name)
-
-        # The input denoise_mask contains values in [0, 1], where 0.0 represents the regions to be fully denoised, and
-        # 1.0 represents the regions to be preserved.
-        # We invert the mask so that the regions to be preserved are 0.0 and the regions to be denoised are 1.0.
-        mask = 1.0 - mask
-
-        _, _, latent_height, latent_width = latents.shape
-        mask = tv_resize(
-            img=mask,
-            size=[latent_height, latent_width],
-            interpolation=tv_transforms.InterpolationMode.BILINEAR,
-            antialias=False,
-        )
-
-        mask = mask.to(device=latents.device, dtype=latents.dtype)
-        return mask
-
-    def _load_text_conditioning(
-        self,
-        context: InvocationContext,
-        conditioning_name: str,
-        dtype: torch.dtype,
-        device: torch.device,
-    ) -> torch.Tensor:
-        # Load the conditioning data.
-        cond_data = context.conditioning.load(conditioning_name)
-        assert len(cond_data.conditionings) == 1
-        cogview4_conditioning = cond_data.conditionings[0]
-        assert isinstance(cogview4_conditioning, CogView4ConditioningInfo)
-        cogview4_conditioning = cogview4_conditioning.to(dtype=dtype, device=device)
-
-        return cogview4_conditioning.glm_embeds
-
-    def _get_noise(
-        self,
-        batch_size: int,
-        num_channels_latents: int,
-        height: int,
-        width: int,
-        dtype: torch.dtype,
-        device: torch.device,
-        seed: int,
-    ) -> torch.Tensor:
-        # We always generate noise on the same device and dtype then cast to ensure consistency across devices/dtypes.
-        rand_device = "cpu"
-        rand_dtype = torch.float16
-
-        return torch.randn(
-            batch_size,
-            num_channels_latents,
-            int(height) // LATENT_SCALE_FACTOR,
-            int(width) // LATENT_SCALE_FACTOR,
-            device=rand_device,
-            dtype=rand_dtype,
-            generator=torch.Generator(device=rand_device).manual_seed(seed),
-        ).to(device=device, dtype=dtype)
-
-    def _prepare_cfg_scale(self, num_timesteps: int) -> list[float]:
-        """Prepare the CFG scale list.
-
-        Args:
-            num_timesteps (int): The number of timesteps in the scheduler. Could be different from num_steps depending
-            on the scheduler used (e.g. higher order schedulers).
-
-        Returns:
-            list[float]: _description_
-        """
-        if isinstance(self.cfg_scale, float):
-            cfg_scale = [self.cfg_scale] * num_timesteps
-        elif isinstance(self.cfg_scale, list):
-            assert len(self.cfg_scale) == num_timesteps
-            cfg_scale = self.cfg_scale
-        else:
-            raise ValueError(f"Invalid CFG scale type: {type(self.cfg_scale)}")
-
-        return cfg_scale
-
-    def _convert_timesteps_to_sigmas(self, image_seq_len: int, timesteps: torch.Tensor) -> list[float]:
-        # The logic to prepare the timestep / sigma schedule is based on:
-        # https://github.com/huggingface/diffusers/blob/b38450d5d2e5b87d5ff7088ee5798c85587b9635/src/diffusers/pipelines/cogview4/pipeline_cogview4.py#L575-L595
-        # The default FlowMatchEulerDiscreteScheduler configs are based on:
-        # https://huggingface.co/THUDM/CogView4-6B/blob/fb6f57289c73ac6d139e8d81bd5a4602d1877847/scheduler/scheduler_config.json
-        # This implementation differs slightly from the original for the sake of simplicity (differs in terminal value
-        # handling, not quantizing timesteps to integers, etc.).
-
-        def calculate_timestep_shift(
-            image_seq_len: int, base_seq_len: int = 256, base_shift: float = 0.25, max_shift: float = 0.75
-        ) -> float:
-            m = (image_seq_len / base_seq_len) ** 0.5
-            mu = m * max_shift + base_shift
-            return mu
-
-        def time_shift_linear(mu: float, sigma: float, t: torch.Tensor) -> torch.Tensor:
-            return mu / (mu + (1 / t - 1) ** sigma)
-
-        mu = calculate_timestep_shift(image_seq_len)
-        sigmas = time_shift_linear(mu, 1.0, timesteps)
-        return sigmas.tolist()
-
-    def _run_diffusion(
-        self,
-        context: InvocationContext,
-    ):
-        inference_dtype = torch.bfloat16
-        device = TorchDevice.choose_torch_device()
-
-        transformer_info = context.models.load(self.transformer.transformer)
-        assert isinstance(transformer_info.model, CogView4Transformer2DModel)
-
-        # Load/process the conditioning data.
-        # TODO(ryand): Make CFG optional.
-        do_classifier_free_guidance = True
-        pos_prompt_embeds = self._load_text_conditioning(
-            context=context,
-            conditioning_name=self.positive_conditioning.conditioning_name,
-            dtype=inference_dtype,
-            device=device,
-        )
-        neg_prompt_embeds = self._load_text_conditioning(
-            context=context,
-            conditioning_name=self.negative_conditioning.conditioning_name,
-            dtype=inference_dtype,
-            device=device,
-        )
-
-        # Prepare misc. conditioning variables.
-        # TODO(ryand): We could expose these as params (like with SDXL). But, we should experiment to see if they are
-        # useful first.
-        original_size = torch.tensor([(self.height, self.width)], dtype=pos_prompt_embeds.dtype, device=device)
-        target_size = torch.tensor([(self.height, self.width)], dtype=pos_prompt_embeds.dtype, device=device)
-        crops_coords_top_left = torch.tensor([(0, 0)], dtype=pos_prompt_embeds.dtype, device=device)
-
-        # Prepare the timestep / sigma schedule.
-        patch_size = transformer_info.model.config.patch_size  # type: ignore
-        assert isinstance(patch_size, int)
-        image_seq_len = ((self.height // LATENT_SCALE_FACTOR) * (self.width // LATENT_SCALE_FACTOR)) // (patch_size**2)
-        # We add an extra step to the end to account for the final timestep of 0.0.
-        timesteps: list[float] = torch.linspace(1, 0, self.steps + 1).tolist()
-        # Clip the timesteps schedule based on denoising_start and denoising_end.
-        timesteps = clip_timestep_schedule_fractional(timesteps, self.denoising_start, self.denoising_end)
-        sigmas = self._convert_timesteps_to_sigmas(image_seq_len, torch.tensor(timesteps))
-        total_steps = len(timesteps) - 1
-
-        # Prepare the CFG scale list.
-        cfg_scale = self._prepare_cfg_scale(total_steps)
-
-        # Load the input latents, if provided.
-        init_latents = context.tensors.load(self.latents.latents_name) if self.latents else None
-        if init_latents is not None:
-            init_latents = init_latents.to(device=device, dtype=inference_dtype)
-
-        # Generate initial latent noise.
-        num_channels_latents = transformer_info.model.config.in_channels  # type: ignore
-        assert isinstance(num_channels_latents, int)
-        noise = self._get_noise(
-            batch_size=1,
-            num_channels_latents=num_channels_latents,
-            height=self.height,
-            width=self.width,
-            dtype=inference_dtype,
-            device=device,
-            seed=self.seed,
-        )
-
-        # Prepare input latent image.
-        if init_latents is not None:
-            # Noise the init_latents by the appropriate amount for the first timestep.
-            s_0 = sigmas[0]
-            latents = s_0 * noise + (1.0 - s_0) * init_latents
-        else:
-            # init_latents are not provided, so we are not doing image-to-image (i.e. we are starting from pure noise).
-            if self.denoising_start > 1e-5:
-                raise ValueError("denoising_start should be 0 when initial latents are not provided.")
-            latents = noise
-
-        # If len(timesteps) == 1, then short-circuit. We are just noising the input latents, but not taking any
-        # denoising steps.
-        if len(timesteps) <= 1:
-            return latents
-
-        # Prepare inpaint extension.
-        inpaint_mask = self._prep_inpaint_mask(context, latents)
-        inpaint_extension: RectifiedFlowInpaintExtension | None = None
-        if inpaint_mask is not None:
-            assert init_latents is not None
-            inpaint_extension = RectifiedFlowInpaintExtension(
-                init_latents=init_latents,
-                inpaint_mask=inpaint_mask,
-                noise=noise,
-            )
-
-        step_callback = self._build_step_callback(context)
-
-        step_callback(
-            PipelineIntermediateState(
-                step=0,
-                order=1,
-                total_steps=total_steps,
-                timestep=int(timesteps[0]),
-                latents=latents,
-            ),
-        )
-
-        with transformer_info.model_on_device() as (_, transformer):
-            assert isinstance(transformer, CogView4Transformer2DModel)
-
-            # Denoising loop
-            for step_idx in tqdm(range(total_steps)):
-                t_curr = timesteps[step_idx]
-                sigma_curr = sigmas[step_idx]
-                sigma_prev = sigmas[step_idx + 1]
-
-                # Expand the timestep to match the latent model input.
-                # Multiply by 1000 to match the default FlowMatchEulerDiscreteScheduler num_train_timesteps.
-                timestep = torch.tensor([t_curr * 1000], device=device).expand(latents.shape[0])
-
-                # TODO(ryand): Support both sequential and batched CFG inference.
-                noise_pred_cond = transformer(
-                    hidden_states=latents,
-                    encoder_hidden_states=pos_prompt_embeds,
-                    timestep=timestep,
-                    original_size=original_size,
-                    target_size=target_size,
-                    crop_coords=crops_coords_top_left,
-                    return_dict=False,
-                )[0]
-
-                # Apply CFG.
-                if do_classifier_free_guidance:
-                    noise_pred_uncond = transformer(
-                        hidden_states=latents,
-                        encoder_hidden_states=neg_prompt_embeds,
-                        timestep=timestep,
-                        original_size=original_size,
-                        target_size=target_size,
-                        crop_coords=crops_coords_top_left,
-                        return_dict=False,
-                    )[0]
-
-                    noise_pred = noise_pred_uncond + cfg_scale[step_idx] * (noise_pred_cond - noise_pred_uncond)
-                else:
-                    noise_pred = noise_pred_cond
-
-                # Compute the previous noisy sample x_t -> x_t-1.
-                latents_dtype = latents.dtype
-                # TODO(ryand): Is casting to float32 necessary for precision/stability? I copied this from SD3.
-                latents = latents.to(dtype=torch.float32)
-                latents = latents + (sigma_prev - sigma_curr) * noise_pred
-                latents = latents.to(dtype=latents_dtype)
-
-                if inpaint_extension is not None:
-                    latents = inpaint_extension.merge_intermediate_latents_with_init_latents(latents, sigma_prev)
-
-                step_callback(
-                    PipelineIntermediateState(
-                        step=step_idx + 1,
-                        order=1,
-                        total_steps=total_steps,
-                        timestep=int(t_curr),
-                        latents=latents,
-                    ),
-                )
-
-        return latents
-
-    def _build_step_callback(self, context: InvocationContext) -> Callable[[PipelineIntermediateState], None]:
-        def step_callback(state: PipelineIntermediateState) -> None:
-            context.util.sd_step_callback(state, BaseModelType.CogView4)
-
-        return step_callback

invokeai/app/invocations/cogview4_image_to_latents.py

@@ -1,69 +0,0 @@
-import einops
-import torch
-from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
-
-from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
-from invokeai.app.invocations.fields import (
-    FieldDescriptions,
-    ImageField,
-    Input,
-    InputField,
-    WithBoard,
-    WithMetadata,
-)
-from invokeai.app.invocations.model import VAEField
-from invokeai.app.invocations.primitives import LatentsOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.load.load_base import LoadedModel
-from invokeai.backend.stable_diffusion.diffusers_pipeline import image_resized_to_grid_as_tensor
-from invokeai.backend.util.devices import TorchDevice
-
-# TODO(ryand): This is effectively a copy of SD3ImageToLatentsInvocation and a subset of ImageToLatentsInvocation. We
-# should refactor to avoid this duplication.
-
-
-@invocation(
-    "cogview4_i2l",
-    title="Image to Latents - CogView4",
-    tags=["image", "latents", "vae", "i2l", "cogview4"],
-    category="image",
-    version="1.0.0",
-    classification=Classification.Prototype,
-)
-class CogView4ImageToLatentsInvocation(BaseInvocation, WithMetadata, WithBoard):
-    """Generates latents from an image."""
-
-    image: ImageField = InputField(description="The image to encode.")
-    vae: VAEField = InputField(description=FieldDescriptions.vae, input=Input.Connection)
-
-    @staticmethod
-    def vae_encode(vae_info: LoadedModel, image_tensor: torch.Tensor) -> torch.Tensor:
-        with vae_info as vae:
-            assert isinstance(vae, AutoencoderKL)
-
-            vae.disable_tiling()
-
-            image_tensor = image_tensor.to(device=TorchDevice.choose_torch_device(), dtype=vae.dtype)
-            with torch.inference_mode():
-                image_tensor_dist = vae.encode(image_tensor).latent_dist
-                # TODO: Use seed to make sampling reproducible.
-                latents: torch.Tensor = image_tensor_dist.sample().to(dtype=vae.dtype)
-
-            latents = vae.config.scaling_factor * latents
-
-        return latents
-
-    @torch.no_grad()
-    def invoke(self, context: InvocationContext) -> LatentsOutput:
-        image = context.images.get_pil(self.image.image_name)
-
-        image_tensor = image_resized_to_grid_as_tensor(image.convert("RGB"))
-        if image_tensor.dim() == 3:
-            image_tensor = einops.rearrange(image_tensor, "c h w -> 1 c h w")
-
-        vae_info = context.models.load(self.vae.vae)
-        latents = self.vae_encode(vae_info=vae_info, image_tensor=image_tensor)
-
-        latents = latents.to("cpu")
-        name = context.tensors.save(tensor=latents)
-        return LatentsOutput.build(latents_name=name, latents=latents, seed=None)

invokeai/app/invocations/cogview4_latents_to_image.py

@@ -1,86 +0,0 @@
-from contextlib import nullcontext
-
-import torch
-from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
-from einops import rearrange
-from PIL import Image
-
-from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
-from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
-from invokeai.app.invocations.fields import (
-    FieldDescriptions,
-    Input,
-    InputField,
-    LatentsField,
-    WithBoard,
-    WithMetadata,
-)
-from invokeai.app.invocations.model import VAEField
-from invokeai.app.invocations.primitives import ImageOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.stable_diffusion.extensions.seamless import SeamlessExt
-from invokeai.backend.util.devices import TorchDevice
-
-# TODO(ryand): This is effectively a copy of SD3LatentsToImageInvocation and a subset of LatentsToImageInvocation. We
-# should refactor to avoid this duplication.
-
-
-@invocation(
-    "cogview4_l2i",
-    title="Latents to Image - CogView4",
-    tags=["latents", "image", "vae", "l2i", "cogview4"],
-    category="latents",
-    version="1.0.0",
-    classification=Classification.Prototype,
-)
-class CogView4LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
-    """Generates an image from latents."""
-
-    latents: LatentsField = InputField(description=FieldDescriptions.latents, input=Input.Connection)
-    vae: VAEField = InputField(description=FieldDescriptions.vae, input=Input.Connection)
-
-    def _estimate_working_memory(self, latents: torch.Tensor, vae: AutoencoderKL) -> int:
-        """Estimate the working memory required by the invocation in bytes."""
-        out_h = LATENT_SCALE_FACTOR * latents.shape[-2]
-        out_w = LATENT_SCALE_FACTOR * latents.shape[-1]
-        element_size = next(vae.parameters()).element_size()
-        scaling_constant = 2200  # Determined experimentally.
-        working_memory = out_h * out_w * element_size * scaling_constant
-        return int(working_memory)
-
-    @torch.no_grad()
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        latents = context.tensors.load(self.latents.latents_name)
-
-        vae_info = context.models.load(self.vae.vae)
-        assert isinstance(vae_info.model, (AutoencoderKL))
-        estimated_working_memory = self._estimate_working_memory(latents, vae_info.model)
-        with (
-            SeamlessExt.static_patch_model(vae_info.model, self.vae.seamless_axes),
-            vae_info.model_on_device(working_mem_bytes=estimated_working_memory) as (_, vae),
-        ):
-            context.util.signal_progress("Running VAE")
-            assert isinstance(vae, (AutoencoderKL))
-            latents = latents.to(TorchDevice.choose_torch_device())
-
-            vae.disable_tiling()
-
-            tiling_context = nullcontext()
-
-            # clear memory as vae decode can request a lot
-            TorchDevice.empty_cache()
-
-            with torch.inference_mode(), tiling_context:
-                # copied from diffusers pipeline
-                latents = latents / vae.config.scaling_factor
-                img = vae.decode(latents, return_dict=False)[0]
-
-            img = img.clamp(-1, 1)
-            img = rearrange(img[0], "c h w -> h w c")  # noqa: F821
-            img_pil = Image.fromarray((127.5 * (img + 1.0)).byte().cpu().numpy())
-
-        TorchDevice.empty_cache()
-
-        image_dto = context.images.save(image=img_pil)
-
-        return ImageOutput.build(image_dto)

invokeai/app/invocations/cogview4_model_loader.py

@@ -1,55 +0,0 @@
-from invokeai.app.invocations.baseinvocation import (
-    BaseInvocation,
-    BaseInvocationOutput,
-    Classification,
-    invocation,
-    invocation_output,
-)
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIType
-from invokeai.app.invocations.model import (
-    GlmEncoderField,
-    ModelIdentifierField,
-    TransformerField,
-    VAEField,
-)
-from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.config import SubModelType
-
-
-@invocation_output("cogview4_model_loader_output")
-class CogView4ModelLoaderOutput(BaseInvocationOutput):
-    """CogView4 base model loader output."""
-
-    transformer: TransformerField = OutputField(description=FieldDescriptions.transformer, title="Transformer")
-    glm_encoder: GlmEncoderField = OutputField(description=FieldDescriptions.glm_encoder, title="GLM Encoder")
-    vae: VAEField = OutputField(description=FieldDescriptions.vae, title="VAE")
-
-
-@invocation(
-    "cogview4_model_loader",
-    title="Main Model - CogView4",
-    tags=["model", "cogview4"],
-    category="model",
-    version="1.0.0",
-    classification=Classification.Prototype,
-)
-class CogView4ModelLoaderInvocation(BaseInvocation):
-    """Loads a CogView4 base model, outputting its submodels."""
-
-    model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.cogview4_model,
-        ui_type=UIType.CogView4MainModel,
-        input=Input.Direct,
-    )
-
-    def invoke(self, context: InvocationContext) -> CogView4ModelLoaderOutput:
-        transformer = self.model.model_copy(update={"submodel_type": SubModelType.Transformer})
-        vae = self.model.model_copy(update={"submodel_type": SubModelType.VAE})
-        glm_tokenizer = self.model.model_copy(update={"submodel_type": SubModelType.Tokenizer})
-        glm_encoder = self.model.model_copy(update={"submodel_type": SubModelType.TextEncoder})
-
-        return CogView4ModelLoaderOutput(
-            transformer=TransformerField(transformer=transformer, loras=[]),
-            glm_encoder=GlmEncoderField(tokenizer=glm_tokenizer, text_encoder=glm_encoder),
-            vae=VAEField(vae=vae),
-        )

invokeai/app/invocations/cogview4_text_encoder.py

@@ -1,92 +0,0 @@
-import torch
-from transformers import GlmModel, PreTrainedTokenizerFast
-
-from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, UIComponent
-from invokeai.app.invocations.model import GlmEncoderField
-from invokeai.app.invocations.primitives import CogView4ConditioningOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
-    CogView4ConditioningInfo,
-    ConditioningFieldData,
-)
-from invokeai.backend.util.devices import TorchDevice
-
-# The CogView4 GLM Text Encoder max sequence length set based on the default in diffusers.
-COGVIEW4_GLM_MAX_SEQ_LEN = 1024
-
-
-@invocation(
-    "cogview4_text_encoder",
-    title="Prompt - CogView4",
-    tags=["prompt", "conditioning", "cogview4"],
-    category="conditioning",
-    version="1.0.0",
-    classification=Classification.Prototype,
-)
-class CogView4TextEncoderInvocation(BaseInvocation):
-    """Encodes and preps a prompt for a cogview4 image."""
-
-    prompt: str = InputField(description="Text prompt to encode.", ui_component=UIComponent.Textarea)
-    glm_encoder: GlmEncoderField = InputField(
-        title="GLM Encoder",
-        description=FieldDescriptions.glm_encoder,
-        input=Input.Connection,
-    )
-
-    @torch.no_grad()
-    def invoke(self, context: InvocationContext) -> CogView4ConditioningOutput:
-        glm_embeds = self._glm_encode(context, max_seq_len=COGVIEW4_GLM_MAX_SEQ_LEN)
-        conditioning_data = ConditioningFieldData(conditionings=[CogView4ConditioningInfo(glm_embeds=glm_embeds)])
-        conditioning_name = context.conditioning.save(conditioning_data)
-        return CogView4ConditioningOutput.build(conditioning_name)
-
-    def _glm_encode(self, context: InvocationContext, max_seq_len: int) -> torch.Tensor:
-        prompt = [self.prompt]
-
-        # TODO(ryand): Add model inputs to the invocation rather than hard-coding.
-        with (
-            context.models.load(self.glm_encoder.text_encoder).model_on_device() as (_, glm_text_encoder),
-            context.models.load(self.glm_encoder.tokenizer).model_on_device() as (_, glm_tokenizer),
-        ):
-            context.util.signal_progress("Running GLM text encoder")
-            assert isinstance(glm_text_encoder, GlmModel)
-            assert isinstance(glm_tokenizer, PreTrainedTokenizerFast)
-
-            text_inputs = glm_tokenizer(
-                prompt,
-                padding="longest",
-                max_length=max_seq_len,
-                truncation=True,
-                add_special_tokens=True,
-                return_tensors="pt",
-            )
-            text_input_ids = text_inputs.input_ids
-            untruncated_ids = glm_tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
-            assert isinstance(text_input_ids, torch.Tensor)
-            assert isinstance(untruncated_ids, torch.Tensor)
-            if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
-                text_input_ids, untruncated_ids
-            ):
-                removed_text = glm_tokenizer.batch_decode(untruncated_ids[:, max_seq_len - 1 : -1])
-                context.logger.warning(
-                    "The following part of your input was truncated because `max_sequence_length` is set to "
-                    f" {max_seq_len} tokens: {removed_text}"
-                )
-
-            current_length = text_input_ids.shape[1]
-            pad_length = (16 - (current_length % 16)) % 16
-            if pad_length > 0:
-                pad_ids = torch.full(
-                    (text_input_ids.shape[0], pad_length),
-                    fill_value=glm_tokenizer.pad_token_id,
-                    dtype=text_input_ids.dtype,
-                    device=text_input_ids.device,
-                )
-                text_input_ids = torch.cat([pad_ids, text_input_ids], dim=1)
-            prompt_embeds = glm_text_encoder(
-                text_input_ids.to(TorchDevice.choose_torch_device()), output_hidden_states=True
-            ).hidden_states[-2]
-
-        assert isinstance(prompt_embeds, torch.Tensor)
-        return prompt_embeds

invokeai/app/invocations/compel.py

@@ -1,7 +1,7 @@
 from typing import Iterator, List, Optional, Tuple, Union, cast
 
 import torch
-from compel import Compel, ReturnedEmbeddingsType, SplitLongTextMode
+from compel import Compel, ReturnedEmbeddingsType
 from compel.prompt_parser import Blend, Conjunction, CrossAttentionControlSubstitute, FlattenedPrompt, Fragment
 from transformers import CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer
 
@@ -104,7 +104,6 @@ class CompelInvocation(BaseInvocation):
                 dtype_for_device_getter=TorchDevice.choose_torch_dtype,
                 truncate_long_prompts=False,
                 device=TorchDevice.choose_torch_device(),
-                split_long_text_mode=SplitLongTextMode.SENTENCES,
             )
 
             conjunction = Compel.parse_prompt_string(self.prompt)
@@ -206,7 +205,6 @@ class SDXLPromptInvocationBase:
                 returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,  # TODO: clip skip
                 requires_pooled=get_pooled,
                 device=TorchDevice.choose_torch_device(),
-                split_long_text_mode=SplitLongTextMode.SENTENCES,
             )
 
             conjunction = Compel.parse_prompt_string(prompt)

invokeai/app/invocations/composition-nodes.py

@@ -274,12 +274,12 @@ class InvokeAdjustImageHuePlusInvocation(BaseInvocation, WithMetadata, WithBoard
     title="Enhance Image",
     tags=["enhance", "image"],
     category="image",
-    version="1.2.1",
+    version="1.2.0",
 )
 class InvokeImageEnhanceInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Applies processing from PIL's ImageEnhance module. Originally created by @dwringer"""
 
-    image: ImageField = InputField(description="The image for which to apply processing")
+    image: ImageField = InputField(default=None, description="The image for which to apply processing")
     invert: bool = InputField(default=False, description="Whether to invert the image colors")
     color: float = InputField(ge=0, default=1.0, description="Color enhancement factor")
     contrast: float = InputField(ge=0, default=1.0, description="Contrast enhancement factor")

invokeai/app/invocations/controlnet.py

@@ -22,11 +22,7 @@ from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import ImageOutput
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.app.util.controlnet_utils import (
-    CONTROLNET_MODE_VALUES,
-    CONTROLNET_RESIZE_VALUES,
-    heuristic_resize_fast,
-)
+from invokeai.app.util.controlnet_utils import CONTROLNET_MODE_VALUES, CONTROLNET_RESIZE_VALUES, heuristic_resize
 from invokeai.backend.image_util.util import np_to_pil, pil_to_np
 
 
@@ -113,7 +109,7 @@ class ControlNetInvocation(BaseInvocation):
     title="Heuristic Resize",
     tags=["image, controlnet"],
     category="image",
-    version="1.1.1",
+    version="1.0.1",
     classification=Classification.Prototype,
 )
 class HeuristicResizeInvocation(BaseInvocation):
@@ -126,7 +122,7 @@ class HeuristicResizeInvocation(BaseInvocation):
     def invoke(self, context: InvocationContext) -> ImageOutput:
         image = context.images.get_pil(self.image.image_name, "RGB")
         np_img = pil_to_np(image)
-        np_resized = heuristic_resize_fast(np_img, (self.width, self.height))
+        np_resized = heuristic_resize(np_img, (self.width, self.height))
         resized = np_to_pil(np_resized)
         image_dto = context.images.save(image=resized)
         return ImageOutput.build(image_dto)

invokeai/app/invocations/create_gradient_mask.py

@@ -1,14 +1,12 @@
 from typing import Literal, Optional
 
-import cv2
 import numpy as np
 import torch
 import torchvision.transforms as T
-from PIL import Image
+from PIL import Image, ImageFilter
 from torchvision.transforms.functional import resize as tv_resize
 
 from invokeai.app.invocations.baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
-from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
 from invokeai.app.invocations.fields import (
     DenoiseMaskField,
     FieldDescriptions,
@@ -44,13 +42,15 @@ class GradientMaskOutput(BaseInvocationOutput):
     title="Create Gradient Mask",
     tags=["mask", "denoise"],
     category="latents",
-    version="1.3.0",
+    version="1.2.0",
 )
 class CreateGradientMaskInvocation(BaseInvocation):
-    """Creates mask for denoising."""
+    """Creates mask for denoising model run."""
 
-    mask: ImageField = InputField(description="Image which will be masked", ui_order=1)
-    edge_radius: int = InputField(default=16, ge=0, description="How far to expand the edges of the mask", ui_order=2)
+    mask: ImageField = InputField(default=None, description="Image which will be masked", ui_order=1)
+    edge_radius: int = InputField(
+        default=16, ge=0, description="How far to blur/expand the edges of the mask", ui_order=2
+    )
     coherence_mode: Literal["Gaussian Blur", "Box Blur", "Staged"] = InputField(default="Gaussian Blur", ui_order=3)
     minimum_denoise: float = InputField(
         default=0.0, ge=0, le=1, description="Minimum denoise level for the coherence region", ui_order=4
@@ -81,110 +81,45 @@ class CreateGradientMaskInvocation(BaseInvocation):
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> GradientMaskOutput:
         mask_image = context.images.get_pil(self.mask.image_name, mode="L")
-
-        # Resize the mask_image. Makes the filter 64x faster and doesn't hurt quality in latent scale anyway
-        mask_image = mask_image.resize(
-            (
-                mask_image.width // LATENT_SCALE_FACTOR,
-                mask_image.height // LATENT_SCALE_FACTOR,
-            ),
-            resample=Image.Resampling.BILINEAR,
-        )
-
-        mask_np_orig = np.array(mask_image, dtype=np.float32)
-
-        self.edge_radius = self.edge_radius // LATENT_SCALE_FACTOR  # scale the edge radius to match the mask size
-
         if self.edge_radius > 0:
-            mask_np = 255 - mask_np_orig  # invert so 0 is unmasked (higher values = higher denoise strength)
-            dilated_mask = mask_np.copy()
-
-            # Create kernel based on coherence mode
             if self.coherence_mode == "Box Blur":
-                # Create a circular distance kernel that fades from center outward
-                kernel_size = self.edge_radius * 2 + 1
-                center = self.edge_radius
-                kernel = np.zeros((kernel_size, kernel_size), dtype=np.float32)
-                for i in range(kernel_size):
-                    for j in range(kernel_size):
-                        dist = np.sqrt((i - center) ** 2 + (j - center) ** 2)
-                        if dist <= self.edge_radius:
-                            kernel[i, j] = 1.0 - (dist / self.edge_radius)
-            else:  # Gaussian Blur or Staged
-                # Create a Gaussian kernel
-                kernel_size = self.edge_radius * 2 + 1
-                kernel = cv2.getGaussianKernel(
-                    kernel_size, self.edge_radius / 2.5
-                )  # 2.5 is a magic number (standard deviation capturing)
-                kernel = kernel * kernel.T  # Make 2D gaussian kernel
-                kernel = kernel / np.max(kernel)  # Normalize center to 1.0
+                blur_mask = mask_image.filter(ImageFilter.BoxBlur(self.edge_radius))
+            else:  # Gaussian Blur OR Staged
+                # Gaussian Blur uses standard deviation. 1/2 radius is a good approximation
+                blur_mask = mask_image.filter(ImageFilter.GaussianBlur(self.edge_radius / 2))
 
-                # Ensure values outside radius are 0
-                center = self.edge_radius
-                for i in range(kernel_size):
-                    for j in range(kernel_size):
-                        dist = np.sqrt((i - center) ** 2 + (j - center) ** 2)
-                        if dist > self.edge_radius:
-                            kernel[i, j] = 0
+            blur_tensor: torch.Tensor = image_resized_to_grid_as_tensor(blur_mask, normalize=False)
 
-            # 2D max filter
-            mask_tensor = torch.tensor(mask_np)
-            kernel_tensor = torch.tensor(kernel)
-            dilated_mask = 255 - self.max_filter2D_torch(mask_tensor, kernel_tensor).cpu()
-            dilated_mask = dilated_mask.numpy()
+            # redistribute blur so that the original edges are 0 and blur outwards to 1
+            blur_tensor = (blur_tensor - 0.5) * 2
+            blur_tensor[blur_tensor < 0] = 0.0
 
-            threshold = (1 - self.minimum_denoise) * 255
+            threshold = 1 - self.minimum_denoise
 
             if self.coherence_mode == "Staged":
-                # wherever expanded mask is darker than the original mask but original was above threshhold, set it to the threshold
-                # makes any expansion areas drop to threshhold. Raising minimum across the image happen outside of this if
-                threshold_mask = (dilated_mask < mask_np_orig) & (mask_np_orig > threshold)
-                dilated_mask = np.where(threshold_mask, threshold, mask_np_orig)
-
-            # wherever expanded mask is less than 255 but greater than threshold, drop it to threshold (minimum denoise)
-            threshold_mask = (dilated_mask > threshold) & (dilated_mask < 255)
-            dilated_mask = np.where(threshold_mask, threshold, dilated_mask)
+                # wherever the blur_tensor is less than fully masked, convert it to threshold
+                blur_tensor = torch.where((blur_tensor < 1) & (blur_tensor > 0), threshold, blur_tensor)
+            else:
+                # wherever the blur_tensor is above threshold but less than 1, drop it to threshold
+                blur_tensor = torch.where((blur_tensor > threshold) & (blur_tensor < 1), threshold, blur_tensor)
 
         else:
-            dilated_mask = mask_np_orig.copy()
+            blur_tensor: torch.Tensor = image_resized_to_grid_as_tensor(mask_image, normalize=False)
 
-        # convert to tensor
-        dilated_mask = np.clip(dilated_mask, 0, 255).astype(np.uint8)
-        mask_tensor = torch.tensor(dilated_mask, device=torch.device("cpu"))
+        mask_name = context.tensors.save(tensor=blur_tensor.unsqueeze(1))
 
-        # binary mask for compositing
-        expanded_mask = np.where((dilated_mask < 255), 0, 255)
-        expanded_mask_image = Image.fromarray(expanded_mask.astype(np.uint8), mode="L")
-        expanded_mask_image = expanded_mask_image.resize(
-            (
-                mask_image.width * LATENT_SCALE_FACTOR,
-                mask_image.height * LATENT_SCALE_FACTOR,
-            ),
-            resample=Image.Resampling.NEAREST,
-        )
+        # compute a [0, 1] mask from the blur_tensor
+        expanded_mask = torch.where((blur_tensor < 1), 0, 1)
+        expanded_mask_image = Image.fromarray((expanded_mask.squeeze(0).numpy() * 255).astype(np.uint8), mode="L")
         expanded_image_dto = context.images.save(expanded_mask_image)
 
-        # restore the original mask size
-        dilated_mask = Image.fromarray(dilated_mask.astype(np.uint8))
-        dilated_mask = dilated_mask.resize(
-            (
-                mask_image.width * LATENT_SCALE_FACTOR,
-                mask_image.height * LATENT_SCALE_FACTOR,
-            ),
-            resample=Image.Resampling.NEAREST,
-        )
-
-        # stack the mask as a tensor, repeating 4 times on dimmension 1
-        dilated_mask_tensor = image_resized_to_grid_as_tensor(dilated_mask, normalize=False)
-        mask_name = context.tensors.save(tensor=dilated_mask_tensor.unsqueeze(0))
-
         masked_latents_name = None
         if self.unet is not None and self.vae is not None and self.image is not None:
             # all three fields must be present at the same time
             main_model_config = context.models.get_config(self.unet.unet.key)
             assert isinstance(main_model_config, MainConfigBase)
             if main_model_config.variant is ModelVariantType.Inpaint:
-                mask = dilated_mask_tensor
+                mask = blur_tensor
                 vae_info: LoadedModel = context.models.load(self.vae.vae)
                 image = context.images.get_pil(self.image.image_name)
                 image_tensor = image_resized_to_grid_as_tensor(image.convert("RGB"))
@@ -202,29 +137,3 @@ class CreateGradientMaskInvocation(BaseInvocation):
             denoise_mask=DenoiseMaskField(mask_name=mask_name, masked_latents_name=masked_latents_name, gradient=True),
             expanded_mask_area=ImageField(image_name=expanded_image_dto.image_name),
         )
-
-    def max_filter2D_torch(self, image: torch.Tensor, kernel: torch.Tensor) -> torch.Tensor:
-        """
-        This morphological operation is much faster in torch than numpy or opencv
-        For reasonable kernel sizes, the overhead of copying the data to the GPU is not worth it.
-        """
-        h, w = kernel.shape
-        pad_h, pad_w = h // 2, w // 2
-
-        padded = torch.nn.functional.pad(image, (pad_w, pad_w, pad_h, pad_h), mode="constant", value=0)
-        result = torch.zeros_like(image)
-
-        # This looks like it's inside out, but it does the same thing and is more efficient
-        for i in range(h):
-            for j in range(w):
-                weight = kernel[i, j]
-                if weight <= 0:
-                    continue
-
-                # Extract the region from padded tensor
-                region = padded[i : i + image.shape[0], j : j + image.shape[1]]
-
-                # Apply weight and update max
-                result = torch.maximum(result, region * weight)
-
-        return result

invokeai/app/invocations/denoise_latents.py

@@ -608,7 +608,6 @@ class DenoiseLatentsInvocation(BaseInvocation):
                     end_step_percent=single_ip_adapter.end_step_percent,
                     ip_adapter_conditioning=IPAdapterConditioningInfo(image_prompt_embeds, uncond_image_prompt_embeds),
                     mask=mask,
-                    method=single_ip_adapter.method,
                 )
             )
 

invokeai/app/invocations/fields.py

@@ -40,7 +40,6 @@ class UIType(str, Enum, metaclass=MetaEnum):
 
     # region Model Field Types
     MainModel = "MainModelField"
-    CogView4MainModel = "CogView4MainModelField"
     FluxMainModel = "FluxMainModelField"
     SD3MainModel = "SD3MainModelField"
     SDXLMainModel = "SDXLMainModelField"
@@ -61,9 +60,6 @@ class UIType(str, Enum, metaclass=MetaEnum):
     SigLipModel = "SigLipModelField"
     FluxReduxModel = "FluxReduxModelField"
     LlavaOnevisionModel = "LLaVAModelField"
-    Imagen3Model = "Imagen3ModelField"
-    Imagen4Model = "Imagen4ModelField"
-    ChatGPT4oModel = "ChatGPT4oModelField"
     # endregion
 
     # region Misc Field Types
@@ -141,7 +137,6 @@ class FieldDescriptions:
     noise = "Noise tensor"
     clip = "CLIP (tokenizer, text encoder, LoRAs) and skipped layer count"
     t5_encoder = "T5 tokenizer and text encoder"
-    glm_encoder = "GLM (THUDM) tokenizer and text encoder"
     clip_embed_model = "CLIP Embed loader"
     clip_g_model = "CLIP-G Embed loader"
     unet = "UNet (scheduler, LoRAs)"
@@ -156,7 +151,6 @@ class FieldDescriptions:
     main_model = "Main model (UNet, VAE, CLIP) to load"
     flux_model = "Flux model (Transformer) to load"
     sd3_model = "SD3 model (MMDiTX) to load"
-    cogview4_model = "CogView4 model (Transformer) 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"
@@ -296,12 +290,6 @@ class SD3ConditioningField(BaseModel):
     conditioning_name: str = Field(description="The name of conditioning tensor")
 
 
-class CogView4ConditioningField(BaseModel):
-    """A conditioning tensor primitive value"""
-
-    conditioning_name: str = Field(description="The name of conditioning tensor")
-
-
 class ConditioningField(BaseModel):
     """A conditioning tensor primitive value"""
 
@@ -401,8 +389,8 @@ class InputFieldJSONSchemaExtra(BaseModel):
     """
 
     input: Input
+    orig_required: bool
     field_kind: FieldKind
-    orig_required: bool = True
     default: Optional[Any] = None
     orig_default: Optional[Any] = None
     ui_hidden: bool = False
@@ -499,7 +487,7 @@ def InputField(
     input: Input = Input.Any,
     ui_type: Optional[UIType] = None,
     ui_component: Optional[UIComponent] = None,
-    ui_hidden: Optional[bool] = None,
+    ui_hidden: bool = False,
     ui_order: Optional[int] = None,
     ui_choice_labels: Optional[dict[str, str]] = None,
 ) -> Any:
@@ -535,20 +523,15 @@ def InputField(
 
     json_schema_extra_ = InputFieldJSONSchemaExtra(
         input=input,
+        ui_type=ui_type,
+        ui_component=ui_component,
+        ui_hidden=ui_hidden,
+        ui_order=ui_order,
+        ui_choice_labels=ui_choice_labels,
         field_kind=FieldKind.Input,
+        orig_required=True,
     )
 
-    if ui_type is not None:
-        json_schema_extra_.ui_type = ui_type
-    if ui_component is not None:
-        json_schema_extra_.ui_component = ui_component
-    if ui_hidden is not None:
-        json_schema_extra_.ui_hidden = ui_hidden
-    if ui_order is not None:
-        json_schema_extra_.ui_order = ui_order
-    if ui_choice_labels is not None:
-        json_schema_extra_.ui_choice_labels = ui_choice_labels
-
     """
     There is a conflict between the typing of invocation definitions and the typing of an invocation's
     `invoke()` function.
@@ -620,7 +603,7 @@ def InputField(
 
     return Field(
         **provided_args,
-        json_schema_extra=json_schema_extra_.model_dump(exclude_unset=True),
+        json_schema_extra=json_schema_extra_.model_dump(exclude_none=True),
     )
 
 

invokeai/app/invocations/flux_denoise.py

@@ -33,6 +33,7 @@ from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.flux.controlnet.instantx_controlnet_flux import InstantXControlNetFlux
 from invokeai.backend.flux.controlnet.xlabs_controlnet_flux import XLabsControlNetFlux
 from invokeai.backend.flux.denoise import denoise
+from invokeai.backend.flux.extensions.inpaint_extension import InpaintExtension
 from invokeai.backend.flux.extensions.instantx_controlnet_extension import InstantXControlNetExtension
 from invokeai.backend.flux.extensions.regional_prompting_extension import RegionalPromptingExtension
 from invokeai.backend.flux.extensions.xlabs_controlnet_extension import XLabsControlNetExtension
@@ -52,7 +53,6 @@ from invokeai.backend.model_manager.taxonomy import ModelFormat, ModelVariantTyp
 from invokeai.backend.patches.layer_patcher import LayerPatcher
 from invokeai.backend.patches.lora_conversions.flux_lora_constants import FLUX_LORA_TRANSFORMER_PREFIX
 from invokeai.backend.patches.model_patch_raw import ModelPatchRaw
-from invokeai.backend.rectified_flow.rectified_flow_inpaint_extension import RectifiedFlowInpaintExtension
 from invokeai.backend.stable_diffusion.diffusers_pipeline import PipelineIntermediateState
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import FLUXConditioningInfo
 from invokeai.backend.util.devices import TorchDevice
@@ -295,10 +295,10 @@ class FluxDenoiseInvocation(BaseInvocation, WithMetadata, WithBoard):
         assert packed_h * packed_w == x.shape[1]
 
         # Prepare inpaint extension.
-        inpaint_extension: RectifiedFlowInpaintExtension | None = None
+        inpaint_extension: InpaintExtension | None = None
         if inpaint_mask is not None:
             assert init_latents is not None
-            inpaint_extension = RectifiedFlowInpaintExtension(
+            inpaint_extension = InpaintExtension(
                 init_latents=init_latents,
                 inpaint_mask=inpaint_mask,
                 noise=noise,

invokeai/app/invocations/flux_redux.py

@@ -1,9 +1,7 @@
-import math
-from typing import Literal, Optional
+from typing import Optional
 
 import torch
 from PIL import Image
-from transformers import SiglipImageProcessor, SiglipVisionModel
 
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
@@ -41,15 +39,12 @@ class FluxReduxOutput(BaseInvocationOutput):
     )
 
 
-DOWNSAMPLING_FUNCTIONS = Literal["nearest", "bilinear", "bicubic", "area", "nearest-exact"]
-
-
 @invocation(
     "flux_redux",
     title="FLUX Redux",
     tags=["ip_adapter", "control"],
     category="ip_adapter",
-    version="2.1.0",
+    version="2.0.0",
     classification=Classification.Beta,
 )
 class FluxReduxInvocation(BaseInvocation):
@@ -66,64 +61,23 @@ class FluxReduxInvocation(BaseInvocation):
         title="FLUX Redux Model",
         ui_type=UIType.FluxReduxModel,
     )
-    downsampling_factor: int = InputField(
-        ge=1,
-        le=9,
-        default=1,
-        description="Redux Downsampling Factor (1-9)",
-    )
-    downsampling_function: DOWNSAMPLING_FUNCTIONS = InputField(
-        default="area",
-        description="Redux Downsampling Function",
-    )
-    weight: float = InputField(
-        ge=0,
-        le=1,
-        default=1.0,
-        description="Redux weight (0.0-1.0)",
-    )
 
     def invoke(self, context: InvocationContext) -> FluxReduxOutput:
         image = context.images.get_pil(self.image.image_name, "RGB")
 
         encoded_x = self._siglip_encode(context, image)
         redux_conditioning = self._flux_redux_encode(context, encoded_x)
-        if self.downsampling_factor > 1 or self.weight != 1.0:
-            redux_conditioning = self._downsample_weight(context, redux_conditioning)
 
         tensor_name = context.tensors.save(redux_conditioning)
         return FluxReduxOutput(
             redux_cond=FluxReduxConditioningField(conditioning=TensorField(tensor_name=tensor_name), mask=self.mask)
         )
 
-    @torch.no_grad()
-    def _downsample_weight(self, context: InvocationContext, redux_conditioning: torch.Tensor) -> torch.Tensor:
-        # Downsampling derived from https://github.com/kaibioinfo/ComfyUI_AdvancedRefluxControl
-        (b, t, h) = redux_conditioning.shape
-        m = int(math.sqrt(t))
-        if self.downsampling_factor > 1:
-            redux_conditioning = redux_conditioning.view(b, m, m, h)
-            redux_conditioning = torch.nn.functional.interpolate(
-                redux_conditioning.transpose(1, -1),
-                size=(m // self.downsampling_factor, m // self.downsampling_factor),
-                mode=self.downsampling_function,
-            )
-            redux_conditioning = redux_conditioning.transpose(1, -1).reshape(b, -1, h)
-        if self.weight != 1.0:
-            redux_conditioning = redux_conditioning * self.weight * self.weight
-        return redux_conditioning
-
     @torch.no_grad()
     def _siglip_encode(self, context: InvocationContext, image: Image.Image) -> torch.Tensor:
         siglip_model_config = self._get_siglip_model(context)
-        with context.models.load(siglip_model_config.key).model_on_device() as (_, model):
-            assert isinstance(model, SiglipVisionModel)
-
-            model_abs_path = context.models.get_absolute_path(siglip_model_config)
-            processor = SiglipImageProcessor.from_pretrained(model_abs_path, local_files_only=True)
-            assert isinstance(processor, SiglipImageProcessor)
-
-            siglip_pipeline = SigLipPipeline(processor, model)
+        with context.models.load(siglip_model_config.key).model_on_device() as (_, siglip_pipeline):
+            assert isinstance(siglip_pipeline, SigLipPipeline)
             return siglip_pipeline.encode_image(
                 x=image, device=TorchDevice.choose_torch_device(), dtype=TorchDevice.choose_torch_dtype()
             )

invokeai/app/invocations/ideal_size.py

@@ -21,14 +21,14 @@ class IdealSizeOutput(BaseInvocationOutput):
     "ideal_size",
     title="Ideal Size - SD1.5, SDXL",
     tags=["latents", "math", "ideal_size"],
-    version="1.0.6",
+    version="1.0.5",
 )
 class IdealSizeInvocation(BaseInvocation):
     """Calculates the ideal size for generation to avoid duplication"""
 
     width: int = InputField(default=1024, description="Final image width")
     height: int = InputField(default=576, description="Final image height")
-    unet: UNetField = InputField(description=FieldDescriptions.unet)
+    unet: UNetField = InputField(default=None, description=FieldDescriptions.unet)
     multiplier: float = InputField(
         default=1.0,
         description="Amount to multiply the model's dimensions by when calculating the ideal size (may result in "

invokeai/app/invocations/image.py

@@ -975,13 +975,13 @@ class SaveImageInvocation(BaseInvocation, WithMetadata, WithBoard):
     title="Canvas Paste Back",
     tags=["image", "combine"],
     category="image",
-    version="1.0.1",
+    version="1.0.0",
 )
 class CanvasPasteBackInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Combines two images by using the mask provided. Intended for use on the Unified Canvas."""
 
     source_image: ImageField = InputField(description="The source image")
-    target_image: ImageField = InputField(description="The target image")
+    target_image: ImageField = InputField(default=None, description="The target image")
     mask: ImageField = InputField(
         description="The mask to use when pasting",
     )
@@ -1218,15 +1218,12 @@ class ApplyMaskToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
     title="Add Image Noise",
     tags=["image", "noise"],
     category="image",
-    version="1.1.0",
+    version="1.0.1",
 )
 class ImageNoiseInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Add noise to an image"""
 
     image: ImageField = InputField(description="The image to add noise to")
-    mask: Optional[ImageField] = InputField(
-        default=None, description="Optional mask determining where to apply noise (black=noise, white=no noise)"
-    )
     seed: int = InputField(
         default=0,
         ge=0,
@@ -1270,27 +1267,12 @@ class ImageNoiseInvocation(BaseInvocation, WithMetadata, WithBoard):
         noise = Image.fromarray(noise.astype(numpy.uint8), mode="RGB").resize(
             (image.width, image.height), Image.Resampling.NEAREST
         )
-
-        # Create a noisy version of the input image
         noisy_image = Image.blend(image.convert("RGB"), noise, self.amount).convert("RGBA")
 
-        # Apply mask if provided
-        if self.mask is not None:
-            mask_image = context.images.get_pil(self.mask.image_name, mode="L")
+        # Paste back the alpha channel
+        noisy_image.putalpha(alpha)
 
-            if mask_image.size != image.size:
-                mask_image = mask_image.resize(image.size, Image.Resampling.LANCZOS)
-
-            result_image = image.copy()
-            mask_image = ImageOps.invert(mask_image)
-            result_image.paste(noisy_image, (0, 0), mask=mask_image)
-        else:
-            result_image = noisy_image
-
-        # Paste back the alpha channel from the original image
-        result_image.putalpha(alpha)
-
-        image_dto = context.images.save(image=result_image)
+        image_dto = context.images.save(image=noisy_image)
 
         return ImageOutput.build(image_dto)
 

invokeai/app/invocations/infill.py

@@ -127,16 +127,13 @@ class InfillPatchMatchInvocation(InfillImageProcessorInvocation):
         return infilled
 
 
-LAMA_MODEL_URL = "https://github.com/Sanster/models/releases/download/add_big_lama/big-lama.pt"
-
-
 @invocation("infill_lama", title="LaMa Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.2")
 class LaMaInfillInvocation(InfillImageProcessorInvocation):
     """Infills transparent areas of an image using the LaMa model"""
 
     def infill(self, image: Image.Image):
         with self._context.models.load_remote_model(
-            source=LAMA_MODEL_URL,
+            source="https://github.com/Sanster/models/releases/download/add_big_lama/big-lama.pt",
             loader=LaMA.load_jit_model,
         ) as model:
             lama = LaMA(model)

invokeai/app/invocations/ip_adapter.py

@@ -31,7 +31,6 @@ class IPAdapterField(BaseModel):
     image_encoder_model: ModelIdentifierField = Field(description="The name of the CLIP image encoder model.")
     weight: Union[float, List[float]] = Field(default=1, description="The weight given to the IP-Adapter.")
     target_blocks: List[str] = Field(default=[], description="The IP Adapter blocks to apply")
-    method: str = Field(default="full", description="Weight apply method")
     begin_step_percent: float = Field(
         default=0, ge=0, le=1, description="When the IP-Adapter is first applied (% of total steps)"
     )
@@ -95,7 +94,7 @@ class IPAdapterInvocation(BaseInvocation):
     weight: Union[float, List[float]] = InputField(
         default=1, description="The weight given to the IP-Adapter", title="Weight"
     )
-    method: Literal["full", "style", "composition", "style_strong", "style_precise"] = InputField(
+    method: Literal["full", "style", "composition"] = InputField(
         default="full", description="The method to apply the IP-Adapter"
     )
     begin_step_percent: float = InputField(
@@ -148,38 +147,6 @@ class IPAdapterInvocation(BaseInvocation):
                 target_blocks = ["down_blocks.2.attentions.1"]
             else:
                 raise ValueError(f"Unsupported IP-Adapter base type: '{ip_adapter_info.base}'.")
-        elif self.method == "style_precise":
-            if ip_adapter_info.base == "sd-1":
-                target_blocks = ["up_blocks.1", "down_blocks.2", "mid_block"]
-            elif ip_adapter_info.base == "sdxl":
-                target_blocks = ["up_blocks.0.attentions.1", "down_blocks.2.attentions.1"]
-            else:
-                raise ValueError(f"Unsupported IP-Adapter base type: '{ip_adapter_info.base}'.")
-        elif self.method == "style_strong":
-            if ip_adapter_info.base == "sd-1":
-                target_blocks = ["up_blocks.0", "up_blocks.1", "up_blocks.2", "down_blocks.0", "down_blocks.1"]
-            elif ip_adapter_info.base == "sdxl":
-                target_blocks = [
-                    "up_blocks.0.attentions.1",
-                    "up_blocks.1.attentions.1",
-                    "up_blocks.2.attentions.1",
-                    "up_blocks.0.attentions.2",
-                    "up_blocks.1.attentions.2",
-                    "up_blocks.2.attentions.2",
-                    "up_blocks.0.attentions.0",
-                    "up_blocks.1.attentions.0",
-                    "up_blocks.2.attentions.0",
-                    "down_blocks.0.attentions.0",
-                    "down_blocks.0.attentions.1",
-                    "down_blocks.0.attentions.2",
-                    "down_blocks.1.attentions.0",
-                    "down_blocks.1.attentions.1",
-                    "down_blocks.1.attentions.2",
-                    "down_blocks.2.attentions.0",
-                    "down_blocks.2.attentions.2",
-                ]
-            else:
-                raise ValueError(f"Unsupported IP-Adapter base type: '{ip_adapter_info.base}'.")
         elif self.method == "full":
             target_blocks = ["block"]
         else:
@@ -195,7 +162,6 @@ class IPAdapterInvocation(BaseInvocation):
                 begin_step_percent=self.begin_step_percent,
                 end_step_percent=self.end_step_percent,
                 mask=self.mask,
-                method=self.method,
             ),
         )
 

invokeai/app/invocations/llava_onevision_vllm.py

@@ -3,14 +3,13 @@ from typing import Any
 import torch
 from PIL.Image import Image
 from pydantic import field_validator
-from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration, LlavaOnevisionProcessor
 
 from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
 from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, UIComponent, UIType
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import StringOutput
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.llava_onevision_pipeline import LlavaOnevisionPipeline
+from invokeai.backend.llava_onevision_model import LlavaOnevisionModel
 from invokeai.backend.util.devices import TorchDevice
 
 
@@ -55,17 +54,10 @@ class LlavaOnevisionVllmInvocation(BaseInvocation):
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> StringOutput:
         images = self._get_images(context)
-        model_config = context.models.get_config(self.vllm_model)
 
-        with context.models.load(self.vllm_model).model_on_device() as (_, model):
-            assert isinstance(model, LlavaOnevisionForConditionalGeneration)
-
-            model_abs_path = context.models.get_absolute_path(model_config)
-            processor = AutoProcessor.from_pretrained(model_abs_path, local_files_only=True)
-            assert isinstance(processor, LlavaOnevisionProcessor)
-
-            model = LlavaOnevisionPipeline(model, processor)
-            output = model.run(
+        with context.models.load(self.vllm_model) as vllm_model:
+            assert isinstance(vllm_model, LlavaOnevisionModel)
+            output = vllm_model.run(
                 prompt=self.prompt,
                 images=images,
                 device=TorchDevice.choose_torch_device(),

invokeai/app/invocations/metadata.py

@@ -42,9 +42,7 @@ class IPAdapterMetadataField(BaseModel):
     image: ImageField = Field(description="The IP-Adapter image prompt.")
     ip_adapter_model: ModelIdentifierField = Field(description="The IP-Adapter model.")
     clip_vision_model: Literal["ViT-L", "ViT-H", "ViT-G"] = Field(description="The CLIP Vision model")
-    method: Literal["full", "style", "composition", "style_strong", "style_precise"] = Field(
-        description="Method to apply IP Weights with"
-    )
+    method: Literal["full", "style", "composition"] = Field(description="Method to apply IP Weights with")
     weight: Union[float, list[float]] = Field(description="The weight given to the IP-Adapter")
     begin_step_percent: float = Field(description="When the IP-Adapter is first applied (% of total steps)")
     end_step_percent: float = Field(description="When the IP-Adapter is last applied (% of total steps)")
@@ -154,10 +152,6 @@ GENERATION_MODES = Literal[
     "sd3_img2img",
     "sd3_inpaint",
     "sd3_outpaint",
-    "cogview4_txt2img",
-    "cogview4_img2img",
-    "cogview4_inpaint",
-    "cogview4_outpaint",
 ]
 
 

invokeai/app/invocations/metadata_linked.py

@@ -39,17 +39,7 @@ from invokeai.app.invocations.model import (
     VAEField,
     VAEOutput,
 )
-from invokeai.app.invocations.primitives import (
-    BooleanCollectionOutput,
-    BooleanOutput,
-    FloatCollectionOutput,
-    FloatOutput,
-    IntegerCollectionOutput,
-    IntegerOutput,
-    LatentsOutput,
-    StringCollectionOutput,
-    StringOutput,
-)
+from invokeai.app.invocations.primitives import BooleanOutput, FloatOutput, IntegerOutput, LatentsOutput, StringOutput
 from invokeai.app.invocations.scheduler import SchedulerOutput
 from invokeai.app.invocations.t2i_adapter import T2IAdapterField, T2IAdapterInvocation
 from invokeai.app.services.shared.invocation_context import InvocationContext
@@ -1172,133 +1162,3 @@ class MetadataToT2IAdaptersInvocation(BaseInvocation, WithMetadata):
             adapters = append_list(T2IAdapterField, i.t2i_adapter, adapters)
 
         return MDT2IAdapterListOutput(t2i_adapter_list=adapters)
-
-
-@invocation(
-    "metadata_to_string_collection",
-    title="Metadata To String Collection",
-    tags=["metadata"],
-    category="metadata",
-    version="1.0.0",
-    classification=Classification.Beta,
-)
-class MetadataToStringCollectionInvocation(BaseInvocation, WithMetadata):
-    """Extracts a string collection value of a label from metadata"""
-
-    label: CORE_LABELS_STRING = InputField(
-        default=CUSTOM_LABEL,
-        description=FieldDescriptions.metadata_item_label,
-        input=Input.Direct,
-    )
-    custom_label: Optional[str] = InputField(
-        default=None,
-        description=FieldDescriptions.metadata_item_label,
-        input=Input.Direct,
-    )
-    default_value: list[str] = InputField(
-        description="The default string collection to use if not found in the metadata"
-    )
-
-    _validate_custom_label = model_validator(mode="after")(validate_custom_label)
-
-    def invoke(self, context: InvocationContext) -> StringCollectionOutput:
-        data: Dict[str, Any] = {} if self.metadata is None else self.metadata.root
-        output = data.get(str(self.custom_label if self.label == CUSTOM_LABEL else self.label), self.default_value)
-
-        return StringCollectionOutput(collection=output)
-
-
-@invocation(
-    "metadata_to_integer_collection",
-    title="Metadata To Integer Collection",
-    tags=["metadata"],
-    category="metadata",
-    version="1.0.0",
-    classification=Classification.Beta,
-)
-class MetadataToIntegerCollectionInvocation(BaseInvocation, WithMetadata):
-    """Extracts an integer value Collection of a label from metadata"""
-
-    label: CORE_LABELS_INTEGER = InputField(
-        default=CUSTOM_LABEL,
-        description=FieldDescriptions.metadata_item_label,
-        input=Input.Direct,
-    )
-    custom_label: Optional[str] = InputField(
-        default=None,
-        description=FieldDescriptions.metadata_item_label,
-        input=Input.Direct,
-    )
-    default_value: list[int] = InputField(description="The default integer to use if not found in the metadata")
-
-    _validate_custom_label = model_validator(mode="after")(validate_custom_label)
-
-    def invoke(self, context: InvocationContext) -> IntegerCollectionOutput:
-        data: Dict[str, Any] = {} if self.metadata is None else self.metadata.root
-        output = data.get(str(self.custom_label if self.label == CUSTOM_LABEL else self.label), self.default_value)
-
-        return IntegerCollectionOutput(collection=output)
-
-
-@invocation(
-    "metadata_to_float_collection",
-    title="Metadata To Float Collection",
-    tags=["metadata"],
-    category="metadata",
-    version="1.0.0",
-    classification=Classification.Beta,
-)
-class MetadataToFloatCollectionInvocation(BaseInvocation, WithMetadata):
-    """Extracts a Float value Collection of a label from metadata"""
-
-    label: CORE_LABELS_FLOAT = InputField(
-        default=CUSTOM_LABEL,
-        description=FieldDescriptions.metadata_item_label,
-        input=Input.Direct,
-    )
-    custom_label: Optional[str] = InputField(
-        default=None,
-        description=FieldDescriptions.metadata_item_label,
-        input=Input.Direct,
-    )
-    default_value: list[float] = InputField(description="The default float to use if not found in the metadata")
-
-    _validate_custom_label = model_validator(mode="after")(validate_custom_label)
-
-    def invoke(self, context: InvocationContext) -> FloatCollectionOutput:
-        data: Dict[str, Any] = {} if self.metadata is None else self.metadata.root
-        output = data.get(str(self.custom_label if self.label == CUSTOM_LABEL else self.label), self.default_value)
-
-        return FloatCollectionOutput(collection=output)
-
-
-@invocation(
-    "metadata_to_bool_collection",
-    title="Metadata To Bool Collection",
-    tags=["metadata"],
-    category="metadata",
-    version="1.0.0",
-    classification=Classification.Beta,
-)
-class MetadataToBoolCollectionInvocation(BaseInvocation, WithMetadata):
-    """Extracts a Boolean value Collection of a label from metadata"""
-
-    label: CORE_LABELS_BOOL = InputField(
-        default=CUSTOM_LABEL,
-        description=FieldDescriptions.metadata_item_label,
-        input=Input.Direct,
-    )
-    custom_label: Optional[str] = InputField(
-        default=None,
-        description=FieldDescriptions.metadata_item_label,
-        input=Input.Direct,
-    )
-    default_value: list[bool] = InputField(description="The default bool to use if not found in the metadata")
-
-    _validate_custom_label = model_validator(mode="after")(validate_custom_label)
-
-    def invoke(self, context: InvocationContext) -> BooleanCollectionOutput:
-        data: Dict[str, Any] = {} if self.metadata is None else self.metadata.root
-        output = data.get(str(self.custom_label if self.label == CUSTOM_LABEL else self.label), self.default_value)
-
-        return BooleanCollectionOutput(collection=output)

invokeai/app/invocations/model.py

@@ -68,11 +68,6 @@ class T5EncoderField(BaseModel):
     loras: List[LoRAField] = Field(description="LoRAs to apply on model loading")
 
 
-class GlmEncoderField(BaseModel):
-    tokenizer: ModelIdentifierField = Field(description="Info to load tokenizer submodel")
-    text_encoder: ModelIdentifierField = Field(description="Info to load text_encoder submodel")
-
-
 class VAEField(BaseModel):
     vae: ModelIdentifierField = Field(description="Info to load vae submodel")
     seamless_axes: List[str] = Field(default_factory=list, description='Axes("x" and "y") to which apply seamless')

invokeai/app/invocations/primitives.py

@@ -13,7 +13,6 @@ from invokeai.app.invocations.baseinvocation import (
 from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
 from invokeai.app.invocations.fields import (
     BoundingBoxField,
-    CogView4ConditioningField,
     ColorField,
     ConditioningField,
     DenoiseMaskField,
@@ -441,17 +440,6 @@ class SD3ConditioningOutput(BaseInvocationOutput):
         return cls(conditioning=SD3ConditioningField(conditioning_name=conditioning_name))
 
 
-@invocation_output("cogview4_conditioning_output")
-class CogView4ConditioningOutput(BaseInvocationOutput):
-    """Base class for nodes that output a CogView text conditioning tensor."""
-
-    conditioning: CogView4ConditioningField = OutputField(description=FieldDescriptions.cond)
-
-    @classmethod
-    def build(cls, conditioning_name: str) -> "CogView4ConditioningOutput":
-        return cls(conditioning=CogView4ConditioningField(conditioning_name=conditioning_name))
-
-
 @invocation_output("conditioning_output")
 class ConditioningOutput(BaseInvocationOutput):
     """Base class for nodes that output a single conditioning tensor"""

invokeai/app/invocations/sd3_denoise.py

@@ -24,7 +24,7 @@ from invokeai.app.invocations.sd3_text_encoder import SD3_T5_MAX_SEQ_LEN
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.flux.sampling_utils import clip_timestep_schedule_fractional
 from invokeai.backend.model_manager import BaseModelType
-from invokeai.backend.rectified_flow.rectified_flow_inpaint_extension import RectifiedFlowInpaintExtension
+from invokeai.backend.sd3.extensions.inpaint_extension import InpaintExtension
 from invokeai.backend.stable_diffusion.diffusers_pipeline import PipelineIntermediateState
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import SD3ConditioningInfo
 from invokeai.backend.util.devices import TorchDevice
@@ -263,10 +263,10 @@ class SD3DenoiseInvocation(BaseInvocation, WithMetadata, WithBoard):
 
         # Prepare inpaint extension.
         inpaint_mask = self._prep_inpaint_mask(context, latents)
-        inpaint_extension: RectifiedFlowInpaintExtension | None = None
+        inpaint_extension: InpaintExtension | None = None
         if inpaint_mask is not None:
             assert init_latents is not None
-            inpaint_extension = RectifiedFlowInpaintExtension(
+            inpaint_extension = InpaintExtension(
                 init_latents=init_latents,
                 inpaint_mask=inpaint_mask,
                 noise=noise,

invokeai/app/invocations/segment_anything.py

@@ -6,7 +6,7 @@ import numpy as np
 import torch
 from PIL import Image
 from pydantic import BaseModel, Field
-from transformers import AutoProcessor
+from transformers import AutoModelForMaskGeneration, AutoProcessor
 from transformers.models.sam import SamModel
 from transformers.models.sam.processing_sam import SamProcessor
 
@@ -104,13 +104,14 @@ class SegmentAnythingInvocation(BaseInvocation):
 
     @staticmethod
     def _load_sam_model(model_path: Path):
-        sam_model = SamModel.from_pretrained(
+        sam_model = AutoModelForMaskGeneration.from_pretrained(
             model_path,
             local_files_only=True,
             # TODO(ryand): Setting the torch_dtype here doesn't work. Investigate whether fp16 is supported by the
             # model, and figure out how to make it work in the pipeline.
             # torch_dtype=TorchDevice.choose_torch_dtype(),
         )
+        assert isinstance(sam_model, SamModel)
 
         sam_processor = AutoProcessor.from_pretrained(model_path, local_files_only=True)
         assert isinstance(sam_processor, SamProcessor)

invokeai/app/run_app.py

@@ -1,3 +1,12 @@
+import uvicorn
+
+from invokeai.app.invocations.load_custom_nodes import load_custom_nodes
+from invokeai.app.services.config.config_default import get_config
+from invokeai.app.util.torch_cuda_allocator import configure_torch_cuda_allocator
+from invokeai.backend.util.logging import InvokeAILogger
+from invokeai.frontend.cli.arg_parser import InvokeAIArgs
+
+
 def get_app():
     """Import the app and event loop. We wrap this in a function to more explicitly control when it happens, because
     importing from api_app does a bunch of stuff - it's more like calling a function than importing a module.
@@ -9,18 +18,9 @@ def get_app():
 
 def run_app() -> None:
     """The main entrypoint for the app."""
-    from invokeai.frontend.cli.arg_parser import InvokeAIArgs
-
-    # Parse the CLI arguments before doing anything else, which ensures CLI args correctly override settings from other
-    # sources like `invokeai.yaml` or env vars.
+    # Parse the CLI arguments.
     InvokeAIArgs.parse_args()
 
-    import uvicorn
-
-    from invokeai.app.services.config.config_default import get_config
-    from invokeai.app.util.torch_cuda_allocator import configure_torch_cuda_allocator
-    from invokeai.backend.util.logging import InvokeAILogger
-
     # Load config.
     app_config = get_config()
 
@@ -31,14 +31,6 @@ def run_app() -> None:
     if app_config.pytorch_cuda_alloc_conf:
         configure_torch_cuda_allocator(app_config.pytorch_cuda_alloc_conf, logger)
 
-    # This import must happen after configure_torch_cuda_allocator() is called, because the module imports torch.
-    from invokeai.app.invocations.baseinvocation import InvocationRegistry
-    from invokeai.app.invocations.load_custom_nodes import load_custom_nodes
-    from invokeai.backend.util.devices import TorchDevice
-
-    torch_device_name = TorchDevice.get_torch_device_name()
-    logger.info(f"Using torch device: {torch_device_name}")
-
     # Import from startup_utils here to avoid importing torch before configure_torch_cuda_allocator() is called.
     from invokeai.app.util.startup_utils import (
         apply_monkeypatches,
@@ -68,15 +60,6 @@ def run_app() -> None:
     # core nodes have been imported so that we can catch when a custom node clobbers a core node.
     load_custom_nodes(custom_nodes_path=app_config.custom_nodes_path, logger=logger)
 
-    # Check all invocations and ensure their outputs are registered.
-    for invocation in InvocationRegistry.get_invocation_classes():
-        invocation_type = invocation.get_type()
-        output_annotation = invocation.get_output_annotation()
-        if output_annotation not in InvocationRegistry.get_output_classes():
-            logger.warning(
-                f'Invocation "{invocation_type}" has unregistered output class "{output_annotation.__name__}"'
-            )
-
     if app_config.dev_reload:
         # load_custom_nodes seems to bypass jurrigged's import sniffer, so be sure to call it *after* they're already
         # imported.

invokeai/app/services/board_image_records/board_image_records_sqlite.py

@@ -98,18 +98,9 @@ class SqliteBoardImageRecordStorage(BoardImageRecordStorageBase):
                 FROM images
                 LEFT JOIN board_images ON board_images.image_name = images.image_name
                 WHERE 1=1
-                """
-
-        # Handle board_id filter
-        if board_id == "none":
-            stmt += """--sql
-                AND board_images.board_id IS NULL
-                """
-        else:
-            stmt += """--sql
                 AND board_images.board_id = ?
                 """
-            params.append(board_id)
+        params.append(board_id)
 
         # Add the category filter
         if categories is not None:

invokeai/app/services/events/events_common.py

@@ -241,7 +241,6 @@ class QueueItemStatusChangedEvent(QueueItemEventBase):
     batch_status: BatchStatus = Field(description="The status of the batch")
     queue_status: SessionQueueStatus = Field(description="The status of the queue")
     session_id: str = Field(description="The ID of the session (aka graph execution state)")
-    credits: Optional[float] = Field(default=None, description="The total credits used for this queue item")
 
     @classmethod
     def build(
@@ -264,7 +263,6 @@ class QueueItemStatusChangedEvent(QueueItemEventBase):
             completed_at=str(queue_item.completed_at) if queue_item.completed_at else None,
             batch_status=batch_status,
             queue_status=queue_status,
-            credits=queue_item.credits,
         )
 
 

invokeai/app/services/invocation_services.py

@@ -27,10 +27,6 @@ if TYPE_CHECKING:
     from invokeai.app.services.invocation_stats.invocation_stats_base import InvocationStatsServiceBase
     from invokeai.app.services.model_images.model_images_base import ModelImageFileStorageBase
     from invokeai.app.services.model_manager.model_manager_base import ModelManagerServiceBase
-    from invokeai.app.services.model_relationship_records.model_relationship_records_base import (
-        ModelRelationshipRecordStorageBase,
-    )
-    from invokeai.app.services.model_relationships.model_relationships_base import ModelRelationshipsServiceABC
     from invokeai.app.services.names.names_base import NameServiceBase
     from invokeai.app.services.session_processor.session_processor_base import SessionProcessorBase
     from invokeai.app.services.session_queue.session_queue_base import SessionQueueBase
@@ -58,8 +54,6 @@ class InvocationServices:
         logger: "Logger",
         model_images: "ModelImageFileStorageBase",
         model_manager: "ModelManagerServiceBase",
-        model_relationships: "ModelRelationshipsServiceABC",
-        model_relationship_records: "ModelRelationshipRecordStorageBase",
         download_queue: "DownloadQueueServiceBase",
         performance_statistics: "InvocationStatsServiceBase",
         session_queue: "SessionQueueBase",
@@ -87,8 +81,6 @@ class InvocationServices:
         self.logger = logger
         self.model_images = model_images
         self.model_manager = model_manager
-        self.model_relationships = model_relationships
-        self.model_relationship_records = model_relationship_records
         self.download_queue = download_queue
         self.performance_statistics = performance_statistics
         self.session_queue = session_queue

invokeai/app/services/invocation_stats/invocation_stats_base.py

@@ -60,7 +60,7 @@ class InvocationStatsServiceBase(ABC):
         pass
 
     @abstractmethod
-    def reset_stats(self, graph_execution_state_id: str) -> None:
+    def reset_stats(self):
         """Reset all stored statistics."""
         pass
 

invokeai/app/services/invocation_stats/invocation_stats_default.py

@@ -73,9 +73,9 @@ class InvocationStatsService(InvocationStatsServiceBase):
             )
             self._stats[graph_execution_state_id].add_node_execution_stats(node_stats)
 
-    def reset_stats(self, graph_execution_state_id: str) -> None:
-        self._stats.pop(graph_execution_state_id, None)
-        self._cache_stats.pop(graph_execution_state_id, None)
+    def reset_stats(self):
+        self._stats = {}
+        self._cache_stats = {}
 
     def get_stats(self, graph_execution_state_id: str) -> InvocationStatsSummary:
         graph_stats_summary = self._get_graph_summary(graph_execution_state_id)

invokeai/app/services/model_install/model_install_default.py

@@ -647,18 +647,10 @@ class ModelInstallService(ModelInstallServiceBase):
         hash_algo = self._app_config.hashing_algorithm
         fields = config.model_dump()
 
-        # WARNING!
-        # The legacy probe relies on the implicit order of tests to determine model classification.
-        # This can lead to regressions between the legacy and new probes.
-        # Do NOT change the order of `probe` and `classify` without implementing one of the following fixes:
-        # Short-term fix: `classify` tests `matches` in the same order as the legacy probe.
-        # Long-term fix: Improve `matches` to be more specific so that only one config matches
-        #   any given model - eliminating ambiguity and removing reliance on order.
-        # After implementing either of these fixes, remove @pytest.mark.xfail from `test_regression_against_model_probe`
         try:
-            return ModelProbe.probe(model_path=model_path, fields=fields, hash_algo=hash_algo)  # type: ignore
+            return ModelConfigBase.classify(model_path=model_path, hash_algo=hash_algo, **fields)
         except InvalidModelConfigException:
-            return ModelConfigBase.classify(model_path, hash_algo, **fields)
+            return ModelProbe.probe(model_path=model_path, fields=fields, hash_algo=hash_algo)  # type: ignore
 
     def _register(
         self, model_path: Path, config: Optional[ModelRecordChanges] = None, info: Optional[AnyModelConfig] = None

invokeai/app/services/model_records/model_records_base.py

@@ -80,7 +80,6 @@ class ModelRecordChanges(BaseModelExcludeNull):
     type: Optional[ModelType] = Field(description="Type of model", default=None)
     key: Optional[str] = Field(description="Database ID for this model", default=None)
     hash: Optional[str] = Field(description="hash of model file", default=None)
-    file_size: Optional[int] = Field(description="Size of model file", default=None)
     format: Optional[str] = Field(description="format of model file", default=None)
     trigger_phrases: Optional[set[str]] = Field(description="Set of trigger phrases for this model", default=None)
     default_settings: Optional[MainModelDefaultSettings | ControlAdapterDefaultSettings] = Field(

invokeai/app/services/model_relationship_records/model_relationship_records_base.py

@@ -1,25 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class ModelRelationshipRecordStorageBase(ABC):
-    """Abstract base class for model-to-model relationship record storage."""
-
-    @abstractmethod
-    def add_model_relationship(self, model_key_1: str, model_key_2: str) -> None:
-        """Creates a relationship between two models by keys."""
-        pass
-
-    @abstractmethod
-    def remove_model_relationship(self, model_key_1: str, model_key_2: str) -> None:
-        """Removes a relationship between two models by keys."""
-        pass
-
-    @abstractmethod
-    def get_related_model_keys(self, model_key: str) -> list[str]:
-        """Gets all models keys related to a given model key."""
-        pass
-
-    @abstractmethod
-    def get_related_model_keys_batch(self, model_keys: list[str]) -> list[str]:
-        """Get related model keys for multiple models given a list of keys."""
-        pass

invokeai/app/services/model_relationship_records/model_relationship_records_sqlite.py

@@ -1,66 +0,0 @@
-import sqlite3
-
-from invokeai.app.services.model_relationship_records.model_relationship_records_base import (
-    ModelRelationshipRecordStorageBase,
-)
-from invokeai.app.services.shared.sqlite.sqlite_database import SqliteDatabase
-
-
-class SqliteModelRelationshipRecordStorage(ModelRelationshipRecordStorageBase):
-    def __init__(self, db: SqliteDatabase) -> None:
-        super().__init__()
-        self._conn = db.conn
-
-    def add_model_relationship(self, model_key_1: str, model_key_2: str) -> None:
-        if model_key_1 == model_key_2:
-            raise ValueError("Cannot relate a model to itself.")
-        a, b = sorted([model_key_1, model_key_2])
-        try:
-            cursor = self._conn.cursor()
-            cursor.execute(
-                "INSERT OR IGNORE INTO model_relationships (model_key_1, model_key_2) VALUES (?, ?)",
-                (a, b),
-            )
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-
-    def remove_model_relationship(self, model_key_1: str, model_key_2: str) -> None:
-        a, b = sorted([model_key_1, model_key_2])
-        try:
-            cursor = self._conn.cursor()
-            cursor.execute(
-                "DELETE FROM model_relationships WHERE model_key_1 = ? AND model_key_2 = ?",
-                (a, b),
-            )
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-
-    def get_related_model_keys(self, model_key: str) -> list[str]:
-        cursor = self._conn.cursor()
-        cursor.execute(
-            """
-            SELECT model_key_2 FROM model_relationships WHERE model_key_1 = ?
-            UNION
-            SELECT model_key_1 FROM model_relationships WHERE model_key_2 = ?
-            """,
-            (model_key, model_key),
-        )
-        return [row[0] for row in cursor.fetchall()]
-
-    def get_related_model_keys_batch(self, model_keys: list[str]) -> list[str]:
-        cursor = self._conn.cursor()
-
-        key_list = ",".join("?" for _ in model_keys)
-        cursor.execute(
-            f"""
-            SELECT model_key_2 FROM model_relationships WHERE model_key_1 IN ({key_list})
-            UNION
-            SELECT model_key_1 FROM model_relationships WHERE model_key_2 IN ({key_list})
-            """,
-            model_keys + model_keys,
-        )
-        return [row[0] for row in cursor.fetchall()]

invokeai/app/services/model_relationships/model_relationships_base.py

@@ -1,25 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class ModelRelationshipsServiceABC(ABC):
-    """High-level service for managing model-to-model relationships."""
-
-    @abstractmethod
-    def add_model_relationship(self, model_key_1: str, model_key_2: str) -> None:
-        """Creates a relationship between two models keys."""
-        pass
-
-    @abstractmethod
-    def remove_model_relationship(self, model_key_1: str, model_key_2: str) -> None:
-        """Removes a relationship between two models keys."""
-        pass
-
-    @abstractmethod
-    def get_related_model_keys(self, model_key: str) -> list[str]:
-        """Gets all models keys related to a given model key."""
-        pass
-
-    @abstractmethod
-    def get_related_model_keys_batch(self, model_keys: list[str]) -> list[str]:
-        """Get related model keys for multiple models."""
-        pass

invokeai/app/services/model_relationships/model_relationships_common.py

@@ -1,9 +0,0 @@
-from datetime import datetime
-
-from invokeai.app.util.model_exclude_null import BaseModelExcludeNull
-
-
-class ModelRelationship(BaseModelExcludeNull):
-    model_key_1: str
-    model_key_2: str
-    created_at: datetime

invokeai/app/services/model_relationships/model_relationships_default.py

@@ -1,31 +0,0 @@
-from invokeai.app.services.invoker import Invoker
-from invokeai.app.services.model_relationships.model_relationships_base import ModelRelationshipsServiceABC
-from invokeai.backend.model_manager.config import AnyModelConfig
-
-
-class ModelRelationshipsService(ModelRelationshipsServiceABC):
-    __invoker: Invoker
-
-    def start(self, invoker: Invoker) -> None:
-        self.__invoker = invoker
-
-    def add_model_relationship(self, model_key_1: str, model_key_2: str) -> None:
-        self.__invoker.services.model_relationship_records.add_model_relationship(model_key_1, model_key_2)
-
-    def remove_model_relationship(self, model_key_1: str, model_key_2: str) -> None:
-        self.__invoker.services.model_relationship_records.remove_model_relationship(model_key_1, model_key_2)
-
-    def get_related_model_keys(self, model_key: str) -> list[str]:
-        return self.__invoker.services.model_relationship_records.get_related_model_keys(model_key)
-
-    def add_relationship_from_models(self, model_1: AnyModelConfig, model_2: AnyModelConfig) -> None:
-        self.add_model_relationship(model_1.key, model_2.key)
-
-    def remove_relationship_from_models(self, model_1: AnyModelConfig, model_2: AnyModelConfig) -> None:
-        self.remove_model_relationship(model_1.key, model_2.key)
-
-    def get_related_keys_from_model(self, model: AnyModelConfig) -> list[str]:
-        return self.get_related_model_keys(model.key)
-
-    def get_related_model_keys_batch(self, model_keys: list[str]) -> list[str]:
-        return self.__invoker.services.model_relationship_records.get_related_model_keys_batch(model_keys)

invokeai/app/services/session_processor/session_processor_default.py

@@ -210,7 +210,7 @@ class DefaultSessionRunner(SessionRunnerBase):
             # we don't care about that - suppress the error.
             with suppress(GESStatsNotFoundError):
                 self._services.performance_statistics.log_stats(queue_item.session.id)
-                self._services.performance_statistics.reset_stats(queue_item.session.id)
+                self._services.performance_statistics.reset_stats()
 
             for callback in self._on_after_run_session_callbacks:
                 callback(queue_item=queue_item)

invokeai/app/services/session_queue/session_queue_common.py

@@ -148,7 +148,7 @@ class Batch(BaseModel):
                     node = cast(BaseInvocation, graph.get_node(batch_data.node_path))
                 except NodeNotFoundError:
                     raise NodeNotFoundError(f"Node {batch_data.node_path} not found in graph")
-                if batch_data.field_name not in type(node).model_fields:
+                if batch_data.field_name not in node.model_fields:
                     raise NodeNotFoundError(f"Field {batch_data.field_name} not found in node {batch_data.node_path}")
         return values
 
@@ -257,7 +257,6 @@ class SessionQueueItemWithoutGraph(BaseModel):
     api_output_fields: Optional[list[FieldIdentifier]] = Field(
         default=None, description="The nodes that were used as output from the API"
     )
-    credits: Optional[float] = Field(default=None, description="The total credits used for this queue item")
 
     @classmethod
     def queue_item_dto_from_dict(cls, queue_item_dict: dict) -> "SessionQueueItemDTO":

invokeai/app/services/shared/graph.py

@@ -424,7 +424,7 @@ class Graph(BaseModel):
                 )
 
             # input fields are on the node
-            if edge.destination.field not in type(destination_node).model_fields:
+            if edge.destination.field not in destination_node.model_fields:
                 raise NodeFieldNotFoundError(
                     f"Edge destination field {edge.destination.field} does not exist in node {edge.destination.node_id}"
                 )

invokeai/app/services/shared/invocation_context.py

@@ -18,10 +18,9 @@ from invokeai.app.services.invocation_services import InvocationServices
 from invokeai.app.services.model_records.model_records_base import UnknownModelException
 from invokeai.app.services.session_processor.session_processor_common import ProgressImage
 from invokeai.app.services.shared.sqlite.sqlite_common import SQLiteDirection
-from invokeai.app.util.step_callback import diffusion_step_callback
+from invokeai.app.util.step_callback import flux_step_callback, stable_diffusion_step_callback
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
-    ModelConfigBase,
 )
 from invokeai.backend.model_manager.load.load_base import LoadedModel, LoadedModelWithoutConfig
 from invokeai.backend.model_manager.taxonomy import AnyModel, BaseModelType, ModelFormat, ModelType, SubModelType
@@ -544,30 +543,6 @@ class ModelsInterface(InvocationContextInterface):
         self._util.signal_progress(f"Loading model {source}")
         return self._services.model_manager.load.load_model_from_path(model_path=model_path, loader=loader)
 
-    def get_absolute_path(self, config_or_path: AnyModelConfig | Path | str) -> Path:
-        """Gets the absolute path for a given model config or path.
-
-        For example, if the model's path is `flux/main/FLUX Dev.safetensors`, and the models path is
-        `/home/username/InvokeAI/models`, this method will return
-        `/home/username/InvokeAI/models/flux/main/FLUX Dev.safetensors`.
-
-        Args:
-            config_or_path: The model config or path.
-
-        Returns:
-            The absolute path to the model.
-        """
-
-        model_path = Path(config_or_path.path) if isinstance(config_or_path, ModelConfigBase) else Path(config_or_path)
-
-        if model_path.is_absolute():
-            return model_path.resolve()
-
-        base_models_path = self._services.configuration.models_path
-        joined_path = base_models_path / model_path
-        resolved_path = joined_path.resolve()
-        return resolved_path
-
 
 class ConfigInterface(InvocationContextInterface):
     def get(self) -> InvokeAIAppConfig:
@@ -607,7 +582,7 @@ class UtilInterface(InvocationContextInterface):
             base_model: The base model for the current denoising step.
         """
 
-        diffusion_step_callback(
+        stable_diffusion_step_callback(
             signal_progress=self.signal_progress,
             intermediate_state=intermediate_state,
             base_model=base_model,
@@ -625,10 +600,9 @@ class UtilInterface(InvocationContextInterface):
             intermediate_state: The intermediate state of the diffusion pipeline.
         """
 
-        diffusion_step_callback(
+        flux_step_callback(
             signal_progress=self.signal_progress,
             intermediate_state=intermediate_state,
-            base_model=BaseModelType.Flux,
             is_canceled=self.is_canceled,
         )
 

invokeai/app/services/shared/sqlite/sqlite_util.py

@@ -21,8 +21,6 @@ from invokeai.app.services.shared.sqlite_migrator.migrations.migration_15 import
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_16 import build_migration_16
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_17 import build_migration_17
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_18 import build_migration_18
-from invokeai.app.services.shared.sqlite_migrator.migrations.migration_19 import build_migration_19
-from invokeai.app.services.shared.sqlite_migrator.migrations.migration_20 import build_migration_20
 from invokeai.app.services.shared.sqlite_migrator.sqlite_migrator_impl import SqliteMigrator
 
 
@@ -61,8 +59,6 @@ def init_db(config: InvokeAIAppConfig, logger: Logger, image_files: ImageFileSto
     migrator.register_migration(build_migration_16())
     migrator.register_migration(build_migration_17())
     migrator.register_migration(build_migration_18())
-    migrator.register_migration(build_migration_19(app_config=config))
-    migrator.register_migration(build_migration_20())
     migrator.run_migrations()
 
     return db

invokeai/app/services/shared/sqlite_migrator/migrations/migration_19.py

@@ -1,37 +0,0 @@
-import sqlite3
-
-from invokeai.app.services.config import InvokeAIAppConfig
-from invokeai.app.services.shared.sqlite_migrator.sqlite_migrator_common import Migration
-from invokeai.backend.model_manager.model_on_disk import ModelOnDisk
-
-
-class Migration19Callback:
-    def __init__(self, app_config: InvokeAIAppConfig):
-        self.models_path = app_config.models_path
-
-    def __call__(self, cursor: sqlite3.Cursor) -> None:
-        self._populate_size(cursor)
-        self._add_size_column(cursor)
-
-    def _add_size_column(self, cursor: sqlite3.Cursor) -> None:
-        cursor.execute(
-            "ALTER TABLE models ADD COLUMN file_size INTEGER "
-            "GENERATED ALWAYS as (json_extract(config, '$.file_size')) VIRTUAL NOT NULL"
-        )
-
-    def _populate_size(self, cursor: sqlite3.Cursor) -> None:
-        all_models = cursor.execute("SELECT id, path FROM models;").fetchall()
-
-        for model_id, model_path in all_models:
-            mod = ModelOnDisk(self.models_path / model_path)
-            cursor.execute(
-                "UPDATE models SET config = json_set(config, '$.file_size', ?) WHERE id = ?", (mod.size(), model_id)
-            )
-
-
-def build_migration_19(app_config: InvokeAIAppConfig) -> Migration:
-    return Migration(
-        from_version=18,
-        to_version=19,
-        callback=Migration19Callback(app_config),
-    )

invokeai/app/services/shared/sqlite_migrator/migrations/migration_20.py

@@ -1,37 +0,0 @@
-import sqlite3
-
-from invokeai.app.services.shared.sqlite_migrator.sqlite_migrator_common import Migration
-
-
-class Migration20Callback:
-    def __call__(self, cursor: sqlite3.Cursor) -> None:
-        cursor.execute(
-            """
-            -- many-to-many relationship table for models
-            CREATE TABLE IF NOT EXISTS model_relationships (
-                -- model_key_1 and model_key_2 are the same as the key(primary key) in the models table
-                model_key_1 TEXT NOT NULL,
-                model_key_2 TEXT NOT NULL,
-                created_at TEXT DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
-                PRIMARY KEY (model_key_1, model_key_2),
-                -- model_key_1 < model_key_2, to ensure uniqueness and prevent duplicates
-                FOREIGN KEY (model_key_1) REFERENCES models(id) ON DELETE CASCADE,
-                FOREIGN KEY (model_key_2) REFERENCES models(id) ON DELETE CASCADE
-            );
-            """
-        )
-        cursor.execute(
-            """
-            -- Creates an index to keep performance equal when searching for model_key_1 or model_key_2
-            CREATE INDEX IF NOT EXISTS keyx_model_relationships_model_key_2
-            ON model_relationships(model_key_2)
-            """
-        )
-
-
-def build_migration_20() -> Migration:
-    return Migration(
-        from_version=19,
-        to_version=20,
-        callback=Migration20Callback(),
-    )

invokeai/app/services/workflow_records/default_workflows/CogView4_TextToImage.json

@@ -1,343 +0,0 @@
-{
-  "name": "Text to Image - CogView4",
-  "author": "",
-  "description": "Generate an image from a prompt with CogView4.",
-  "version": "",
-  "contact": "",
-  "tags": "CogView4, Text to Image",
-  "notes": "",
-  "exposedFields": [],
-  "meta": { "category": "default", "version": "3.0.0" },
-  "id": "default_0e405a8e-ab5e-4e6c-bd99-b59deabd5591",
-  "form": {
-    "elements": {
-      "container-XSINSu999B": {
-        "id": "container-XSINSu999B",
-        "data": {
-          "layout": "column",
-          "children": [
-            "heading-N0TXlsboP5",
-            "text-PVw8AvXCTz",
-            "divider-5wmCOm9mqG",
-            "node-field-gPil4XSw8L",
-            "node-field-T2oYYNrAzH",
-            "node-field-SRj6Dn28lm"
-          ]
-        },
-        "type": "container"
-      },
-      "node-field-gPil4XSw8L": {
-        "id": "node-field-gPil4XSw8L",
-        "type": "node-field",
-        "parentId": "container-XSINSu999B",
-        "data": {
-          "fieldIdentifier": {
-            "nodeId": "a4569d8b-6a43-44b9-8919-4ceec6682904",
-            "fieldName": "prompt"
-          },
-          "settings": {
-            "type": "string-field-config",
-            "component": "textarea"
-          },
-          "showDescription": false
-        }
-      },
-      "node-field-T2oYYNrAzH": {
-        "id": "node-field-T2oYYNrAzH",
-        "type": "node-field",
-        "parentId": "container-XSINSu999B",
-        "data": {
-          "fieldIdentifier": {
-            "nodeId": "acb26944-1208-4016-9929-ab8dd0860573",
-            "fieldName": "prompt"
-          },
-          "settings": {
-            "type": "string-field-config",
-            "component": "textarea"
-          },
-          "showDescription": false
-        }
-      },
-      "node-field-SRj6Dn28lm": {
-        "id": "node-field-SRj6Dn28lm",
-        "type": "node-field",
-        "parentId": "container-XSINSu999B",
-        "data": {
-          "fieldIdentifier": {
-            "nodeId": "7890507c-d346-4d13-bcb4-bc6d4850b2e3",
-            "fieldName": "model"
-          },
-          "showDescription": false
-        }
-      },
-      "heading-N0TXlsboP5": {
-        "id": "heading-N0TXlsboP5",
-        "parentId": "container-XSINSu999B",
-        "type": "heading",
-        "data": { "content": "Text to Image - CogView4" }
-      },
-      "text-PVw8AvXCTz": {
-        "id": "text-PVw8AvXCTz",
-        "parentId": "container-XSINSu999B",
-        "type": "text",
-        "data": { "content": "Generate an image from a prompt with CogView4." }
-      },
-      "divider-5wmCOm9mqG": {
-        "id": "divider-5wmCOm9mqG",
-        "parentId": "container-XSINSu999B",
-        "type": "divider"
-      }
-    },
-    "rootElementId": "container-XSINSu999B"
-  },
-  "nodes": [
-    {
-      "id": "7890507c-d346-4d13-bcb4-bc6d4850b2e3",
-      "type": "invocation",
-      "data": {
-        "id": "7890507c-d346-4d13-bcb4-bc6d4850b2e3",
-        "version": "1.0.0",
-        "nodePack": "invokeai",
-        "label": "",
-        "notes": "",
-        "type": "cogview4_model_loader",
-        "inputs": {
-          "model": {
-            "name": "model",
-            "label": ""
-          }
-        },
-        "isOpen": true,
-        "isIntermediate": true,
-        "useCache": true
-      },
-      "position": { "x": -52.193850056888095, "y": 282.4721422789611 }
-    },
-    {
-      "id": "a4569d8b-6a43-44b9-8919-4ceec6682904",
-      "type": "invocation",
-      "data": {
-        "id": "a4569d8b-6a43-44b9-8919-4ceec6682904",
-        "version": "1.0.0",
-        "nodePack": "invokeai",
-        "label": "",
-        "notes": "",
-        "type": "cogview4_text_encoder",
-        "inputs": {
-          "prompt": {
-            "name": "prompt",
-            "label": "Positive Prompt",
-            "description": "",
-            "value": "A whimsical stuffed gnome sits on a golden sandy beach, its plush fabric slightly textured and well-worn. The gnome has a round, cheerful face with a fluffy white beard, a bulbous nose, and a tall, slightly floppy red hat with a few decorative stitching details. It wears a tiny blue vest over a soft, earthy-toned tunic, and its stubby arms grasp a ripe yellow banana with a few brown speckles. The ocean waves gently roll onto the shore in the background, with turquoise water reflecting the warm glow of the late afternoon sun. A few scattered seashells and driftwood pieces are near the gnome, while a colorful beach umbrella and footprints in the sand hint at a lively beach scene. The sky is a soft pastel blend of pink, orange, and light blue, with wispy clouds stretching across the horizon.\n"
-          },
-          "glm_encoder": {
-            "name": "glm_encoder",
-            "label": "",
-            "description": ""
-          }
-        },
-        "isOpen": true,
-        "isIntermediate": true,
-        "useCache": true
-      },
-      "position": { "x": 328.9380683664592, "y": 305.11768986950995 }
-    },
-    {
-      "id": "acb26944-1208-4016-9929-ab8dd0860573",
-      "type": "invocation",
-      "data": {
-        "id": "acb26944-1208-4016-9929-ab8dd0860573",
-        "version": "1.0.0",
-        "nodePack": "invokeai",
-        "label": "",
-        "notes": "",
-        "type": "cogview4_text_encoder",
-        "inputs": {
-          "prompt": {
-            "name": "prompt",
-            "label": "Negative Prompt",
-            "description": "",
-            "value": ""
-          },
-          "glm_encoder": {
-            "name": "glm_encoder",
-            "label": "",
-            "description": ""
-          }
-        },
-        "isOpen": true,
-        "isIntermediate": true,
-        "useCache": true
-      },
-      "position": { "x": 334.6799782744916, "y": 496.5882067536601 }
-    },
-    {
-      "id": "cdd72700-463d-4e10-8d76-3e842e4c0b49",
-      "type": "invocation",
-      "data": {
-        "id": "cdd72700-463d-4e10-8d76-3e842e4c0b49",
-        "version": "1.0.0",
-        "nodePack": "invokeai",
-        "label": "",
-        "notes": "",
-        "type": "cogview4_l2i",
-        "inputs": {
-          "board": {
-            "name": "board",
-            "label": "",
-            "description": "",
-            "value": "auto"
-          },
-          "metadata": { "name": "metadata", "label": "", "description": "" },
-          "latents": { "name": "latents", "label": "", "description": "" },
-          "vae": { "name": "vae", "label": "", "description": "" }
-        },
-        "isOpen": true,
-        "isIntermediate": false,
-        "useCache": true
-      },
-      "position": { "x": 1112.027247217991, "y": 294.1351498145327 }
-    },
-    {
-      "id": "e75e2ced-284e-4135-81dc-cdf06c7a409d",
-      "type": "invocation",
-      "data": {
-        "id": "e75e2ced-284e-4135-81dc-cdf06c7a409d",
-        "version": "1.0.0",
-        "nodePack": "invokeai",
-        "label": "",
-        "notes": "",
-        "type": "cogview4_denoise",
-        "inputs": {
-          "board": {
-            "name": "board",
-            "label": "",
-            "description": "",
-            "value": "auto"
-          },
-          "metadata": { "name": "metadata", "label": "", "description": "" },
-          "latents": { "name": "latents", "label": "", "description": "" },
-          "denoise_mask": {
-            "name": "denoise_mask",
-            "label": "",
-            "description": ""
-          },
-          "denoising_start": {
-            "name": "denoising_start",
-            "label": "",
-            "description": "",
-            "value": 0
-          },
-          "denoising_end": {
-            "name": "denoising_end",
-            "label": "",
-            "description": "",
-            "value": 1
-          },
-          "transformer": {
-            "name": "transformer",
-            "label": "",
-            "description": ""
-          },
-          "positive_conditioning": {
-            "name": "positive_conditioning",
-            "label": "",
-            "description": ""
-          },
-          "negative_conditioning": {
-            "name": "negative_conditioning",
-            "label": "",
-            "description": ""
-          },
-          "cfg_scale": {
-            "name": "cfg_scale",
-            "label": "",
-            "description": "",
-            "value": 3.5
-          },
-          "width": {
-            "name": "width",
-            "label": "",
-            "description": "",
-            "value": 1024
-          },
-          "height": {
-            "name": "height",
-            "label": "",
-            "description": "",
-            "value": 1024
-          },
-          "steps": {
-            "name": "steps",
-            "label": "",
-            "description": "",
-            "value": 30
-          },
-          "seed": { "name": "seed", "label": "", "description": "", "value": 0 }
-        },
-        "isOpen": true,
-        "isIntermediate": true,
-        "useCache": false
-      },
-      "position": { "x": 720.8830004638692, "y": 332.66609681908415 }
-    }
-  ],
-  "edges": [
-    {
-      "id": "reactflow__edge-7890507c-d346-4d13-bcb4-bc6d4850b2e3vae-cdd72700-463d-4e10-8d76-3e842e4c0b49vae",
-      "type": "default",
-      "source": "7890507c-d346-4d13-bcb4-bc6d4850b2e3",
-      "target": "cdd72700-463d-4e10-8d76-3e842e4c0b49",
-      "sourceHandle": "vae",
-      "targetHandle": "vae"
-    },
-    {
-      "id": "reactflow__edge-7890507c-d346-4d13-bcb4-bc6d4850b2e3glm_encoder-a4569d8b-6a43-44b9-8919-4ceec6682904glm_encoder",
-      "type": "default",
-      "source": "7890507c-d346-4d13-bcb4-bc6d4850b2e3",
-      "target": "a4569d8b-6a43-44b9-8919-4ceec6682904",
-      "sourceHandle": "glm_encoder",
-      "targetHandle": "glm_encoder"
-    },
-    {
-      "id": "reactflow__edge-7890507c-d346-4d13-bcb4-bc6d4850b2e3glm_encoder-acb26944-1208-4016-9929-ab8dd0860573glm_encoder",
-      "type": "default",
-      "source": "7890507c-d346-4d13-bcb4-bc6d4850b2e3",
-      "target": "acb26944-1208-4016-9929-ab8dd0860573",
-      "sourceHandle": "glm_encoder",
-      "targetHandle": "glm_encoder"
-    },
-    {
-      "id": "reactflow__edge-a4569d8b-6a43-44b9-8919-4ceec6682904conditioning-e75e2ced-284e-4135-81dc-cdf06c7a409dpositive_conditioning",
-      "type": "default",
-      "source": "a4569d8b-6a43-44b9-8919-4ceec6682904",
-      "target": "e75e2ced-284e-4135-81dc-cdf06c7a409d",
-      "sourceHandle": "conditioning",
-      "targetHandle": "positive_conditioning"
-    },
-    {
-      "id": "reactflow__edge-acb26944-1208-4016-9929-ab8dd0860573conditioning-e75e2ced-284e-4135-81dc-cdf06c7a409dnegative_conditioning",
-      "type": "default",
-      "source": "acb26944-1208-4016-9929-ab8dd0860573",
-      "target": "e75e2ced-284e-4135-81dc-cdf06c7a409d",
-      "sourceHandle": "conditioning",
-      "targetHandle": "negative_conditioning"
-    },
-    {
-      "id": "reactflow__edge-e75e2ced-284e-4135-81dc-cdf06c7a409dlatents-cdd72700-463d-4e10-8d76-3e842e4c0b49latents",
-      "type": "default",
-      "source": "e75e2ced-284e-4135-81dc-cdf06c7a409d",
-      "target": "cdd72700-463d-4e10-8d76-3e842e4c0b49",
-      "sourceHandle": "latents",
-      "targetHandle": "latents"
-    },
-    {
-      "id": "reactflow__edge-7890507c-d346-4d13-bcb4-bc6d4850b2e3transformer-e75e2ced-284e-4135-81dc-cdf06c7a409dtransformer",
-      "type": "default",
-      "source": "7890507c-d346-4d13-bcb4-bc6d4850b2e3",
-      "target": "e75e2ced-284e-4135-81dc-cdf06c7a409d",
-      "sourceHandle": "transformer",
-      "targetHandle": "transformer"
-    }
-  ]
-}

invokeai/app/util/controlnet_utils.py

@@ -230,86 +230,6 @@ def heuristic_resize(np_img: np.ndarray[Any, Any], size: tuple[int, int]) -> np.
     return resized
 
 
-# precompute common kernels
-_KERNEL3 = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
-# directional masks for NMS
-_DIRS = [
-    np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0]], np.uint8),
-    np.array([[0, 1, 0], [0, 1, 0], [0, 1, 0]], np.uint8),
-    np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], np.uint8),
-    np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], np.uint8),
-]
-
-
-def heuristic_resize_fast(np_img: np.ndarray, size: tuple[int, int]) -> np.ndarray:
-    h, w = np_img.shape[:2]
-    # early exit
-    if (w, h) == size:
-        return np_img
-
-    # separate alpha channel
-    img = np_img
-    alpha = None
-    if img.ndim == 3 and img.shape[2] == 4:
-        alpha, img = img[:, :, 3], img[:, :, :3]
-
-    # build small sample for unique‐color & binary detection
-    flat = img.reshape(-1, img.shape[-1])
-    N = flat.shape[0]
-    # include four corners to avoid missing extreme values
-    corners = np.vstack([img[0, 0], img[0, w - 1], img[h - 1, 0], img[h - 1, w - 1]])
-    cnt = min(N, 100_000)
-    samp = np.vstack([corners, flat[np.random.choice(N, cnt, replace=False)]])
-    uc = np.unique(samp, axis=0).shape[0]
-    vmin, vmax = samp.min(), samp.max()
-
-    # detect binary edge map & one‐pixel‐edge case
-    is_binary = uc == 2 and vmin < 16 and vmax > 240
-    one_pixel_edge = False
-    if is_binary:
-        # single gray conversion
-        gray0 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        grad = cv2.morphologyEx(gray0, cv2.MORPH_GRADIENT, _KERNEL3)
-        cnt_edge = cv2.countNonZero(grad)
-        cnt_all = cv2.countNonZero((gray0 > 127).astype(np.uint8))
-        one_pixel_edge = (2 * cnt_edge) > cnt_all
-
-    # choose interp for color/seg/grayscale
-    area_new, area_old = size[0] * size[1], w * h
-    if 2 < uc < 200:  # segmentation map
-        interp = cv2.INTER_NEAREST
-    elif area_new < area_old:
-        interp = cv2.INTER_AREA
-    else:
-        interp = cv2.INTER_CUBIC
-
-    # single resize pass on RGB
-    resized = cv2.resize(img, size, interpolation=interp)
-
-    if is_binary:
-        # convert to gray & apply NMS via C++ dilate
-        gray_r = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
-        nms = np.zeros_like(gray_r)
-        for K in _DIRS:
-            d = cv2.dilate(gray_r, K)
-            mask = d == gray_r
-            nms[mask] = gray_r[mask]
-
-        # threshold + thinning if needed
-        _, bw = cv2.threshold(nms, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-        out_bin = cv2.ximgproc.thinning(bw) if one_pixel_edge else bw
-        # restore 3 channels
-        resized = np.stack([out_bin] * 3, axis=2)
-
-    # restore alpha with same interp as RGB for consistency
-    if alpha is not None:
-        am = cv2.resize(alpha, size, interpolation=interp)
-        am = (am > 127).astype(np.uint8) * 255
-        resized = np.dstack((resized, am))
-
-    return resized
-
-
 ###########################################################################
 # Copied from detectmap_proc method in scripts/detectmap_proc.py in Mikubill/sd-webui-controlnet
 #    modified for InvokeAI
@@ -324,7 +244,7 @@ def np_img_resize(
     np_img = normalize_image_channel_count(np_img)
 
     if resize_mode == "just_resize":  # RESIZE
-        np_img = heuristic_resize_fast(np_img, (w, h))
+        np_img = heuristic_resize(np_img, (w, h))
         np_img = clone_contiguous(np_img)
         return np_img_to_torch(np_img, device), np_img
 
@@ -345,7 +265,7 @@ def np_img_resize(
             # Inpaint hijack
             high_quality_border_color[3] = 255
         high_quality_background = np.tile(high_quality_border_color[None, None], [h, w, 1])
-        np_img = heuristic_resize_fast(np_img, (safeint(old_w * k), safeint(old_h * k)))
+        np_img = heuristic_resize(np_img, (safeint(old_w * k), safeint(old_h * k)))
         new_h, new_w, _ = np_img.shape
         pad_h = max(0, (h - new_h) // 2)
         pad_w = max(0, (w - new_w) // 2)
@@ -355,7 +275,7 @@ def np_img_resize(
         return np_img_to_torch(np_img, device), np_img
     else:  # resize_mode == "crop_resize"  (INNER_FIT)
         k = max(k0, k1)
-        np_img = heuristic_resize_fast(np_img, (safeint(old_w * k), safeint(old_h * k)))
+        np_img = heuristic_resize(np_img, (safeint(old_w * k), safeint(old_h * k)))
         new_h, new_w, _ = np_img.shape
         pad_h = max(0, (new_h - h) // 2)
         pad_w = max(0, (new_w - w) // 2)

invokeai/app/util/custom_openapi.py

@@ -12,9 +12,6 @@ from invokeai.app.invocations.fields import InputFieldJSONSchemaExtra, OutputFie
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.services.events.events_common import EventBase
 from invokeai.app.services.session_processor.session_processor_common import ProgressImage
-from invokeai.backend.util.logging import InvokeAILogger
-
-logger = InvokeAILogger.get_logger()
 
 
 def move_defs_to_top_level(openapi_schema: dict[str, Any], component_schema: dict[str, Any]) -> None:
@@ -64,10 +61,6 @@ def get_openapi_func(
         # We need to manually add all outputs to the schema - pydantic doesn't add them because they aren't used directly.
         for output in InvocationRegistry.get_output_classes():
             json_schema = output.model_json_schema(mode="serialization", ref_template="#/components/schemas/{model}")
-            # Remove output_metadata that is only used on back-end from the schema
-            if "output_meta" in json_schema["properties"]:
-                json_schema["properties"].pop("output_meta")
-
             move_defs_to_top_level(openapi_schema, json_schema)
             openapi_schema["components"]["schemas"][output.__name__] = json_schema
 

invokeai/app/util/misc.py

@@ -10,7 +10,7 @@ def get_timestamp() -> int:
 
 
 def get_iso_timestamp() -> str:
-    return datetime.datetime.now(datetime.timezone.utc).isoformat()
+    return datetime.datetime.utcnow().isoformat()
 
 
 def get_datetime_from_iso_timestamp(iso_timestamp: str) -> datetime.datetime:

invokeai/app/util/step_callback.py

@@ -8,8 +8,6 @@ from invokeai.app.services.session_processor.session_processor_common import Can
 from invokeai.backend.model_manager.taxonomy import BaseModelType
 from invokeai.backend.stable_diffusion.diffusers_pipeline import PipelineIntermediateState
 
-# See scripts/generate_vae_linear_approximation.py for generating these factors.
-
 # fast latents preview matrix for sdxl
 # generated by @StAlKeR7779
 SDXL_LATENT_RGB_FACTORS = [
@@ -74,32 +72,11 @@ FLUX_LATENT_RGB_FACTORS = [
     [-0.1146, -0.0827, -0.0598],
 ]
 
-COGVIEW4_LATENT_RGB_FACTORS = [
-    [0.00408832, -0.00082485, -0.00214816],
-    [0.00084172, 0.00132241, 0.00842067],
-    [-0.00466737, -0.00983181, -0.00699561],
-    [0.03698397, -0.04797235, 0.03585809],
-    [0.00234701, -0.00124326, 0.00080869],
-    [-0.00723903, -0.00388422, -0.00656606],
-    [-0.00970917, -0.00467356, -0.00971113],
-    [0.17292486, -0.03452463, -0.1457515],
-    [0.02330308, 0.02942557, 0.02704329],
-    [-0.00903131, -0.01499841, -0.01432564],
-    [0.01250298, 0.0019407, -0.02168986],
-    [0.01371188, 0.00498283, -0.01302135],
-    [0.42396525, 0.4280575, 0.42148206],
-    [0.00983825, 0.00613302, 0.00610316],
-    [0.00473307, -0.00889551, -0.00915924],
-    [-0.00955853, -0.00980067, -0.00977842],
-]
-
 
 def sample_to_lowres_estimated_image(
     samples: torch.Tensor, latent_rgb_factors: torch.Tensor, smooth_matrix: Optional[torch.Tensor] = None
 ):
-    if samples.dim() == 4:
-        samples = samples[0]
-    latent_image = samples.permute(1, 2, 0) @ latent_rgb_factors
+    latent_image = samples[0].permute(1, 2, 0) @ latent_rgb_factors
 
     if smooth_matrix is not None:
         latent_image = latent_image.unsqueeze(0).permute(3, 0, 1, 2)
@@ -131,7 +108,7 @@ def calc_percentage(intermediate_state: PipelineIntermediateState) -> float:
 SignalProgressFunc: TypeAlias = Callable[[str, float | None, Image.Image | None, tuple[int, int] | None], None]
 
 
-def diffusion_step_callback(
+def stable_diffusion_step_callback(
     signal_progress: SignalProgressFunc,
     intermediate_state: PipelineIntermediateState,
     base_model: BaseModelType,
@@ -148,28 +125,39 @@ def diffusion_step_callback(
     else:
         sample = intermediate_state.latents
 
-    smooth_matrix: list[list[float]] | None = None
-    if base_model in [BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2]:
-        latent_rgb_factors = SD1_5_LATENT_RGB_FACTORS
-    elif base_model in [BaseModelType.StableDiffusionXL, BaseModelType.StableDiffusionXLRefiner]:
-        latent_rgb_factors = SDXL_LATENT_RGB_FACTORS
-        smooth_matrix = SDXL_SMOOTH_MATRIX
+    if base_model in [BaseModelType.StableDiffusionXL, BaseModelType.StableDiffusionXLRefiner]:
+        sdxl_latent_rgb_factors = torch.tensor(SDXL_LATENT_RGB_FACTORS, dtype=sample.dtype, device=sample.device)
+        sdxl_smooth_matrix = torch.tensor(SDXL_SMOOTH_MATRIX, dtype=sample.dtype, device=sample.device)
+        image = sample_to_lowres_estimated_image(sample, sdxl_latent_rgb_factors, sdxl_smooth_matrix)
     elif base_model == BaseModelType.StableDiffusion3:
-        latent_rgb_factors = SD3_5_LATENT_RGB_FACTORS
-    elif base_model == BaseModelType.CogView4:
-        latent_rgb_factors = COGVIEW4_LATENT_RGB_FACTORS
-    elif base_model == BaseModelType.Flux:
-        latent_rgb_factors = FLUX_LATENT_RGB_FACTORS
+        sd3_latent_rgb_factors = torch.tensor(SD3_5_LATENT_RGB_FACTORS, dtype=sample.dtype, device=sample.device)
+        image = sample_to_lowres_estimated_image(sample, sd3_latent_rgb_factors)
     else:
-        raise ValueError(f"Unsupported base model: {base_model}")
-
-    latent_rgb_factors_torch = torch.tensor(latent_rgb_factors, dtype=sample.dtype, device=sample.device)
-    smooth_matrix_torch = (
-        torch.tensor(smooth_matrix, dtype=sample.dtype, device=sample.device) if smooth_matrix else None
-    )
-    image = sample_to_lowres_estimated_image(
-        samples=sample, latent_rgb_factors=latent_rgb_factors_torch, smooth_matrix=smooth_matrix_torch
-    )
+        v1_5_latent_rgb_factors = torch.tensor(SD1_5_LATENT_RGB_FACTORS, dtype=sample.dtype, device=sample.device)
+        image = sample_to_lowres_estimated_image(sample, v1_5_latent_rgb_factors)
+
+    width = image.width * 8
+    height = image.height * 8
+    percentage = calc_percentage(intermediate_state)
+
+    signal_progress("Denoising", percentage, image, (width, height))
+
+
+def flux_step_callback(
+    signal_progress: SignalProgressFunc,
+    intermediate_state: PipelineIntermediateState,
+    is_canceled: Callable[[], bool],
+) -> None:
+    if is_canceled():
+        raise CanceledException
+    sample = intermediate_state.latents
+    latent_rgb_factors = torch.tensor(FLUX_LATENT_RGB_FACTORS, dtype=sample.dtype, device=sample.device)
+    latent_image_perm = sample.permute(1, 2, 0).to(dtype=sample.dtype, device=sample.device)
+    latent_image = latent_image_perm @ latent_rgb_factors
+    latents_ubyte = (
+        ((latent_image + 1) / 2).clamp(0, 1).mul(0xFF)  # change scale from -1..1 to 0..1  # to 0..255
+    ).to(device="cpu", dtype=torch.uint8)
+    image = Image.fromarray(latents_ubyte.cpu().numpy())
 
     width = image.width * 8
     height = image.height * 8

invokeai/backend/flux/denoise.py

@@ -5,12 +5,12 @@ import torch
 from tqdm import tqdm
 
 from invokeai.backend.flux.controlnet.controlnet_flux_output import ControlNetFluxOutput, sum_controlnet_flux_outputs
+from invokeai.backend.flux.extensions.inpaint_extension import InpaintExtension
 from invokeai.backend.flux.extensions.instantx_controlnet_extension import InstantXControlNetExtension
 from invokeai.backend.flux.extensions.regional_prompting_extension import RegionalPromptingExtension
 from invokeai.backend.flux.extensions.xlabs_controlnet_extension import XLabsControlNetExtension
 from invokeai.backend.flux.extensions.xlabs_ip_adapter_extension import XLabsIPAdapterExtension
 from invokeai.backend.flux.model import Flux
-from invokeai.backend.rectified_flow.rectified_flow_inpaint_extension import RectifiedFlowInpaintExtension
 from invokeai.backend.stable_diffusion.diffusers_pipeline import PipelineIntermediateState
 
 
@@ -26,7 +26,7 @@ def denoise(
     step_callback: Callable[[PipelineIntermediateState], None],
     guidance: float,
     cfg_scale: list[float],
-    inpaint_extension: RectifiedFlowInpaintExtension | None,
+    inpaint_extension: InpaintExtension | None,
     controlnet_extensions: list[XLabsControlNetExtension | InstantXControlNetExtension],
     pos_ip_adapter_extensions: list[XLabsIPAdapterExtension],
     neg_ip_adapter_extensions: list[XLabsIPAdapterExtension],

invokeai/backend/flux/extensions/inpaint_extension.py

@@ -1,15 +1,8 @@
 import torch
 
 
-def assert_broadcastable(*shapes):
-    try:
-        torch.broadcast_shapes(*shapes)
-    except RuntimeError as e:
-        raise AssertionError(f"Shapes {shapes} are not broadcastable.") from e
-
-
-class RectifiedFlowInpaintExtension:
-    """A class for managing inpainting with rectified flow models (e.g. FLUX, SD3, CogView4)."""
+class InpaintExtension:
+    """A class for managing inpainting with FLUX."""
 
     def __init__(self, init_latents: torch.Tensor, inpaint_mask: torch.Tensor, noise: torch.Tensor):
         """Initialize InpaintExtension.
@@ -21,8 +14,7 @@ class RectifiedFlowInpaintExtension:
                 inpainted region with the background. In 'packed' format.
             noise (torch.Tensor): The noise tensor used to noise the init_latents. In 'packed' format.
         """
-        assert_broadcastable(init_latents.shape, inpaint_mask.shape, noise.shape)
-
+        assert init_latents.shape == inpaint_mask.shape == noise.shape
         self._init_latents = init_latents
         self._inpaint_mask = inpaint_mask
         self._noise = noise
@@ -30,13 +22,18 @@ class RectifiedFlowInpaintExtension:
     def _apply_mask_gradient_adjustment(self, t_prev: float) -> torch.Tensor:
         """Applies inpaint mask gradient adjustment and returns the inpaint mask to be used at the current timestep."""
         # As we progress through the denoising process, we promote gradient regions of the mask to have a full weight of
-        # 1.0. This helps to produce more coherent seams around the inpainted region.
-
+        # 1.0. This helps to produce more coherent seams around the inpainted region. We experimented with a (small)
+        # number of promotion strategies (e.g. gradual promotion based on timestep), but found that a simple cutoff
+        # threshold worked well.
         # We use a small epsilon to avoid any potential issues with floating point precision.
         eps = 1e-4
-        mask = torch.where(self._inpaint_mask >= t_prev + eps, 1.0, 0.0).to(
-            dtype=self._inpaint_mask.dtype, device=self._inpaint_mask.device
-        )
+        mask_gradient_t_cutoff = 0.5
+        if t_prev > mask_gradient_t_cutoff:
+            # Early in the denoising process, use the inpaint mask as-is.
+            return self._inpaint_mask
+        else:
+            # After the cut-off, promote all non-zero mask values to 1.0.
+            mask = self._inpaint_mask.where(self._inpaint_mask <= (0.0 + eps), 1.0)
 
         return mask
 

invokeai/backend/llava_onevision_model.py

@@ -1,15 +1,26 @@
+from pathlib import Path
+from typing import Optional
+
 import torch
 from PIL.Image import Image
-from transformers import LlavaOnevisionForConditionalGeneration, LlavaOnevisionProcessor
+from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration, LlavaOnevisionProcessor
+
+from invokeai.backend.raw_model import RawModel
 
 
-class LlavaOnevisionPipeline:
-    """A wrapper for a LLaVA Onevision model + processor."""
-
+class LlavaOnevisionModel(RawModel):
     def __init__(self, vllm_model: LlavaOnevisionForConditionalGeneration, processor: LlavaOnevisionProcessor):
         self._vllm_model = vllm_model
         self._processor = processor
 
+    @classmethod
+    def load_from_path(cls, path: str | Path):
+        vllm_model = LlavaOnevisionForConditionalGeneration.from_pretrained(path, local_files_only=True)
+        assert isinstance(vllm_model, LlavaOnevisionForConditionalGeneration)
+        processor = AutoProcessor.from_pretrained(path, local_files_only=True)
+        assert isinstance(processor, LlavaOnevisionProcessor)
+        return cls(vllm_model, processor)
+
     def run(self, prompt: str, images: list[Image], device: torch.device, dtype: torch.dtype) -> str:
         # TODO(ryand): Tune the max number of images that are useful for the model.
         if len(images) > 3:
@@ -33,3 +44,13 @@ class LlavaOnevisionPipeline:
         # The output_str will include the prompt, so we extract the response.
         response = output_str.split("assistant\n", 1)[1].strip()
         return response
+
+    def to(self, device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None) -> None:
+        self._vllm_model.to(device=device, dtype=dtype)
+
+    def calc_size(self) -> int:
+        """Get size of the model in memory in bytes."""
+        # HACK(ryand): Fix this issue with circular imports.
+        from invokeai.backend.model_manager.load.model_util import calc_module_size
+
+        return calc_module_size(self._vllm_model)

invokeai/backend/model_manager/config.py

@@ -128,7 +128,6 @@ class ModelConfigBase(ABC, BaseModel):
     path: str = Field(
         description="Path to the model on the filesystem. Relative paths are relative to the Invoke root directory."
     )
-    file_size: int = Field(description="The size of the model in bytes.")
     name: str = Field(description="Name of the model.")
     type: ModelType = Field(description="Model type")
     format: ModelFormat = Field(description="Model format")
@@ -144,37 +143,34 @@ class ModelConfigBase(ABC, BaseModel):
     submodels: Optional[Dict[SubModelType, SubmodelDefinition]] = Field(
         description="Loadable submodels in this model", default=None
     )
-    usage_info: Optional[str] = Field(default=None, description="Usage information for this model")
 
-    USING_LEGACY_PROBE: ClassVar[set] = set()
-    USING_CLASSIFY_API: ClassVar[set] = set()
+    _USING_LEGACY_PROBE: ClassVar[set] = set()
+    _USING_CLASSIFY_API: ClassVar[set] = set()
     _MATCH_SPEED: ClassVar[MatchSpeed] = MatchSpeed.MED
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
         if issubclass(cls, LegacyProbeMixin):
-            ModelConfigBase.USING_LEGACY_PROBE.add(cls)
+            ModelConfigBase._USING_LEGACY_PROBE.add(cls)
         else:
-            ModelConfigBase.USING_CLASSIFY_API.add(cls)
+            ModelConfigBase._USING_CLASSIFY_API.add(cls)
 
     @staticmethod
     def all_config_classes():
-        subclasses = ModelConfigBase.USING_LEGACY_PROBE | ModelConfigBase.USING_CLASSIFY_API
+        subclasses = ModelConfigBase._USING_LEGACY_PROBE | ModelConfigBase._USING_CLASSIFY_API
         concrete = {cls for cls in subclasses if not isabstract(cls)}
         return concrete
 
     @staticmethod
-    def classify(mod: str | Path | ModelOnDisk, hash_algo: HASHING_ALGORITHMS = "blake3_single", **overrides):
+    def classify(model_path: Path, hash_algo: HASHING_ALGORITHMS = "blake3_single", **overrides):
         """
         Returns the best matching ModelConfig instance from a model's file/folder path.
         Raises InvalidModelConfigException if no valid configuration is found.
         Created to deprecate ModelProbe.probe
         """
-        if isinstance(mod, Path | str):
-            mod = ModelOnDisk(mod, hash_algo)
-
-        candidates = ModelConfigBase.USING_CLASSIFY_API
+        candidates = ModelConfigBase._USING_CLASSIFY_API
         sorted_by_match_speed = sorted(candidates, key=lambda cls: (cls._MATCH_SPEED, cls.__name__))
+        mod = ModelOnDisk(model_path, hash_algo)
 
         for config_cls in sorted_by_match_speed:
             try:
@@ -245,7 +241,6 @@ class ModelConfigBase(ABC, BaseModel):
         fields["key"] = fields.get("key") or uuid_string()
         fields["description"] = fields.get("description") or f"{base.value} {type.value} model {name}"
         fields["repo_variant"] = fields.get("repo_variant") or mod.repo_variant()
-        fields["file_size"] = fields.get("file_size") or mod.size()
 
         return cls(**fields)
 
@@ -603,21 +598,6 @@ class LlavaOnevisionConfig(DiffusersConfigBase, ModelConfigBase):
         }
 
 
-class ApiModelConfig(MainConfigBase, ModelConfigBase):
-    """Model config for API-based models."""
-
-    format: Literal[ModelFormat.Api] = ModelFormat.Api
-
-    @classmethod
-    def matches(cls, mod: ModelOnDisk) -> bool:
-        # API models are not stored on disk, so we can't match them.
-        return False
-
-    @classmethod
-    def parse(cls, mod: ModelOnDisk) -> dict[str, Any]:
-        raise NotImplementedError("API models are not parsed from disk.")
-
-
 def get_model_discriminator_value(v: Any) -> str:
     """
     Computes the discriminator value for a model config.
@@ -685,7 +665,6 @@ AnyModelConfig = Annotated[
         Annotated[SigLIPConfig, SigLIPConfig.get_tag()],
         Annotated[FluxReduxConfig, FluxReduxConfig.get_tag()],
         Annotated[LlavaOnevisionConfig, LlavaOnevisionConfig.get_tag()],
-        Annotated[ApiModelConfig, ApiModelConfig.get_tag()],
     ],
     Discriminator(get_model_discriminator_value),
 ]

invokeai/backend/model_manager/legacy_probe.py

@@ -27,7 +27,6 @@ from invokeai.backend.model_manager.config import (
     SubmodelDefinition,
 )
 from invokeai.backend.model_manager.load.model_loaders.generic_diffusers import ConfigLoader
-from invokeai.backend.model_manager.model_on_disk import ModelOnDisk
 from invokeai.backend.model_manager.taxonomy import (
     AnyVariant,
     BaseModelType,
@@ -146,7 +145,6 @@ class ModelProbe(object):
         "CLIPTextModelWithProjection": ModelType.CLIPEmbed,
         "SiglipModel": ModelType.SigLIP,
         "LlavaOnevisionForConditionalGeneration": ModelType.LlavaOnevision,
-        "CogView4Pipeline": ModelType.Main,
     }
 
     TYPE2VARIANT: Dict[ModelType, Callable[[str], Optional[AnyVariant]]] = {ModelType.CLIPEmbed: get_clip_variant_type}
@@ -209,7 +207,6 @@ class ModelProbe(object):
         )
         fields["format"] = ModelFormat(fields.get("format")) if "format" in fields else probe.get_format()
         fields["hash"] = fields.get("hash") or ModelHash(algorithm=hash_algo).hash(model_path)
-        fields["file_size"] = fields.get("file_size") or ModelOnDisk(model_path).size()
 
         fields["default_settings"] = fields.get("default_settings")
 
@@ -859,8 +856,6 @@ class PipelineFolderProbe(FolderProbeBase):
                 transformer_conf = json.load(file)
             if transformer_conf["_class_name"] == "SD3Transformer2DModel":
                 return BaseModelType.StableDiffusion3
-            elif transformer_conf["_class_name"] == "CogView4Transformer2DModel":
-                return BaseModelType.CogView4
             else:
                 raise InvalidModelConfigException(f"Unknown base model for {self.model_path}")
 

invokeai/backend/model_manager/load/model_cache/cached_model/cached_model_only_full_load.py

@@ -2,8 +2,6 @@ from typing import Any
 
 import torch
 
-from invokeai.backend.quantization.gguf.ggml_tensor import GGMLTensor
-
 
 class CachedModelOnlyFullLoad:
     """A wrapper around a PyTorch model to handle full loads and unloads between the CPU and the compute device.
@@ -78,15 +76,7 @@ class CachedModelOnlyFullLoad:
             for k, v in self._cpu_state_dict.items():
                 new_state_dict[k] = v.to(self._compute_device, copy=True)
             self._model.load_state_dict(new_state_dict, assign=True)
-
-        check_for_gguf = hasattr(self._model, "state_dict") and self._model.state_dict().get("img_in.weight")
-        if isinstance(check_for_gguf, GGMLTensor):
-            old_value = torch.__future__.get_overwrite_module_params_on_conversion()
-            torch.__future__.set_overwrite_module_params_on_conversion(True)
-            self._model.to(self._compute_device)
-            torch.__future__.set_overwrite_module_params_on_conversion(old_value)
-        else:
-            self._model.to(self._compute_device)
+        self._model.to(self._compute_device)
 
         self._is_in_vram = True
         return self._total_bytes
@@ -102,15 +92,7 @@ class CachedModelOnlyFullLoad:
 
         if self._cpu_state_dict is not None:
             self._model.load_state_dict(self._cpu_state_dict, assign=True)
-
-        check_for_gguf = hasattr(self._model, "state_dict") and self._model.state_dict().get("img_in.weight")
-        if isinstance(check_for_gguf, GGMLTensor):
-            old_value = torch.__future__.get_overwrite_module_params_on_conversion()
-            torch.__future__.set_overwrite_module_params_on_conversion(True)
-            self._model.to(self._offload_device)
-            torch.__future__.set_overwrite_module_params_on_conversion(old_value)
-        else:
-            self._model.to(self._offload_device)
+        self._model.to(self._offload_device)
 
         self._is_in_vram = False
         return self._total_bytes

invokeai/backend/model_manager/load/model_cache/model_cache.py

@@ -2,10 +2,9 @@ import gc
 import logging
 import threading
 import time
-from dataclasses import dataclass
 from functools import wraps
 from logging import Logger
-from typing import Any, Callable, Dict, List, Optional, Protocol
+from typing import Any, Callable, Dict, List, Optional
 
 import psutil
 import torch
@@ -55,39 +54,6 @@ def synchronized(method: Callable[..., Any]) -> Callable[..., Any]:
     return wrapper
 
 
-@dataclass
-class CacheEntrySnapshot:
-    cache_key: str
-    total_bytes: int
-    current_vram_bytes: int
-
-
-class CacheMissCallback(Protocol):
-    def __call__(
-        self,
-        model_key: str,
-        cache_snapshot: dict[str, CacheEntrySnapshot],
-    ) -> None: ...
-
-
-class CacheHitCallback(Protocol):
-    def __call__(
-        self,
-        model_key: str,
-        cache_snapshot: dict[str, CacheEntrySnapshot],
-    ) -> None: ...
-
-
-class CacheModelsClearedCallback(Protocol):
-    def __call__(
-        self,
-        models_cleared: int,
-        bytes_requested: int,
-        bytes_freed: int,
-        cache_snapshot: dict[str, CacheEntrySnapshot],
-    ) -> None: ...
-
-
 class ModelCache:
     """A cache for managing models in memory.
 
@@ -178,34 +144,6 @@ class ModelCache:
         # - Requests to empty the cache from a separate thread
         self._lock = threading.RLock()
 
-        self._on_cache_hit_callbacks: set[CacheHitCallback] = set()
-        self._on_cache_miss_callbacks: set[CacheMissCallback] = set()
-        self._on_cache_models_cleared_callbacks: set[CacheModelsClearedCallback] = set()
-
-    def on_cache_hit(self, cb: CacheHitCallback) -> Callable[[], None]:
-        self._on_cache_hit_callbacks.add(cb)
-
-        def unsubscribe() -> None:
-            self._on_cache_hit_callbacks.discard(cb)
-
-        return unsubscribe
-
-    def on_cache_miss(self, cb: CacheHitCallback) -> Callable[[], None]:
-        self._on_cache_miss_callbacks.add(cb)
-
-        def unsubscribe() -> None:
-            self._on_cache_miss_callbacks.discard(cb)
-
-        return unsubscribe
-
-    def on_cache_models_cleared(self, cb: CacheModelsClearedCallback) -> Callable[[], None]:
-        self._on_cache_models_cleared_callbacks.add(cb)
-
-        def unsubscribe() -> None:
-            self._on_cache_models_cleared_callbacks.discard(cb)
-
-        return unsubscribe
-
     @property
     @synchronized
     def stats(self) -> Optional[CacheStats]:
@@ -257,20 +195,6 @@ class ModelCache:
             f"Added model {key} (Type: {model.__class__.__name__}, Wrap mode: {wrapped_model.__class__.__name__}, Model size: {size / MB:.2f}MB)"
         )
 
-    @synchronized
-    def _get_cache_snapshot(self) -> dict[str, CacheEntrySnapshot]:
-        overview: dict[str, CacheEntrySnapshot] = {}
-        for cache_key, cache_entry in self._cached_models.items():
-            total_bytes = cache_entry.cached_model.total_bytes()
-            current_vram_bytes = cache_entry.cached_model.cur_vram_bytes()
-            overview[cache_key] = CacheEntrySnapshot(
-                cache_key=cache_key,
-                total_bytes=total_bytes,
-                current_vram_bytes=current_vram_bytes,
-            )
-
-        return overview
-
     @synchronized
     def get(self, key: str, stats_name: Optional[str] = None) -> CacheRecord:
         """Retrieve a model from the cache.
@@ -284,8 +208,6 @@ class ModelCache:
             if self.stats:
                 self.stats.hits += 1
         else:
-            for cb in self._on_cache_miss_callbacks:
-                cb(model_key=key, cache_snapshot=self._get_cache_snapshot())
             if self.stats:
                 self.stats.misses += 1
             self._logger.debug(f"Cache miss: {key}")
@@ -307,8 +229,6 @@ class ModelCache:
         self._cache_stack.append(key)
 
         self._logger.debug(f"Cache hit: {key} (Type: {cache_entry.cached_model.model.__class__.__name__})")
-        for cb in self._on_cache_hit_callbacks:
-            cb(model_key=key, cache_snapshot=self._get_cache_snapshot())
         return cache_entry
 
     @synchronized
@@ -729,13 +649,6 @@ class ModelCache:
             # immediately when their reference count hits 0.
             if self.stats:
                 self.stats.cleared = models_cleared
-            for cb in self._on_cache_models_cleared_callbacks:
-                cb(
-                    models_cleared=models_cleared,
-                    bytes_requested=bytes_needed,
-                    bytes_freed=ram_bytes_freed,
-                    cache_snapshot=self._get_cache_snapshot(),
-                )
             gc.collect()
 
         TorchDevice.empty_cache()

invokeai/backend/model_manager/load/model_cache/torch_module_autocast/custom_modules/custom_linear.py

@@ -13,12 +13,6 @@ from invokeai.backend.patches.layers.lora_layer import LoRALayer
 
 def linear_lora_forward(input: torch.Tensor, lora_layer: LoRALayer, lora_weight: float) -> torch.Tensor:
     """An optimized implementation of the residual calculation for a sidecar linear LoRALayer."""
-    # up matrix and down matrix have different ranks so we can't simply multiply them
-    if lora_layer.up.shape[1] != lora_layer.down.shape[0]:
-        x = torch.nn.functional.linear(input, lora_layer.get_weight(lora_weight), bias=lora_layer.bias)
-        x *= lora_weight * lora_layer.scale()
-        return x
-
     x = torch.nn.functional.linear(input, lora_layer.down)
     if lora_layer.mid is not None:
         x = torch.nn.functional.linear(x, lora_layer.mid)

invokeai/backend/model_manager/load/model_loaders/cogview4.py

@@ -1,60 +0,0 @@
-from pathlib import Path
-from typing import Optional
-
-import torch
-
-from invokeai.backend.model_manager.config import (
-    AnyModelConfig,
-    CheckpointConfigBase,
-    DiffusersConfigBase,
-)
-from invokeai.backend.model_manager.load.model_loader_registry import ModelLoaderRegistry
-from invokeai.backend.model_manager.load.model_loaders.generic_diffusers import GenericDiffusersLoader
-from invokeai.backend.model_manager.taxonomy import (
-    AnyModel,
-    BaseModelType,
-    ModelFormat,
-    ModelType,
-    SubModelType,
-)
-
-
-@ModelLoaderRegistry.register(base=BaseModelType.CogView4, type=ModelType.Main, format=ModelFormat.Diffusers)
-class CogView4DiffusersModel(GenericDiffusersLoader):
-    """Class to load CogView4 main models."""
-
-    def _load_model(
-        self,
-        config: AnyModelConfig,
-        submodel_type: Optional[SubModelType] = None,
-    ) -> AnyModel:
-        if isinstance(config, CheckpointConfigBase):
-            raise NotImplementedError("CheckpointConfigBase is not implemented for CogView4 models.")
-
-        if submodel_type is None:
-            raise Exception("A submodel type must be provided when loading main pipelines.")
-
-        model_path = Path(config.path)
-        load_class = self.get_hf_load_class(model_path, submodel_type)
-        repo_variant = config.repo_variant if isinstance(config, DiffusersConfigBase) else None
-        variant = repo_variant.value if repo_variant else None
-        model_path = model_path / submodel_type.value
-
-        # We force bfloat16 for CogView4 models. It produces black images with float16. I haven't tracked down
-        # specifically which model(s) is/are responsible.
-        dtype = torch.bfloat16
-        try:
-            result: AnyModel = load_class.from_pretrained(
-                model_path,
-                torch_dtype=dtype,
-                variant=variant,
-            )
-        except OSError as e:
-            if variant and "no file named" in str(
-                e
-            ):  # try without the variant, just in case user's preferences changed
-                result = load_class.from_pretrained(model_path, torch_dtype=dtype)
-            else:
-                raise e
-
-        return result

invokeai/backend/model_manager/load/model_loaders/llava_onevision.py

@@ -1,8 +1,7 @@
 from pathlib import Path
 from typing import Optional
 
-from transformers import LlavaOnevisionForConditionalGeneration
-
+from invokeai.backend.llava_onevision_model import LlavaOnevisionModel
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
 )
@@ -24,8 +23,6 @@ class LlavaOnevisionModelLoader(ModelLoader):
             raise ValueError("Unexpected submodel requested for LLaVA OneVision model.")
 
         model_path = Path(config.path)
-        model = LlavaOnevisionForConditionalGeneration.from_pretrained(
-            model_path, local_files_only=True, torch_dtype=self._torch_dtype
-        )
-        assert isinstance(model, LlavaOnevisionForConditionalGeneration)
+        model = LlavaOnevisionModel.load_from_path(model_path)
+        model.to(dtype=self._torch_dtype)
         return model

invokeai/backend/model_manager/load/model_loaders/sig_lip_pipeline.py

@@ -1,14 +1,13 @@
 from pathlib import Path
 from typing import Optional
 
-from transformers import SiglipVisionModel
-
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
 )
 from invokeai.backend.model_manager.load.load_default import ModelLoader
 from invokeai.backend.model_manager.load.model_loader_registry import ModelLoaderRegistry
 from invokeai.backend.model_manager.taxonomy import AnyModel, BaseModelType, ModelFormat, ModelType, SubModelType
+from invokeai.backend.sig_lip.sig_lip_pipeline import SigLipPipeline
 
 
 @ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.SigLIP, format=ModelFormat.Diffusers)
@@ -24,5 +23,6 @@ class SigLIPModelLoader(ModelLoader):
             raise ValueError("Unexpected submodel requested for LLaVA OneVision model.")
 
         model_path = Path(config.path)
-        model = SiglipVisionModel.from_pretrained(model_path, local_files_only=True, torch_dtype=self._torch_dtype)
+        model = SigLipPipeline.load_from_path(model_path)
+        model.to(dtype=self._torch_dtype)
         return model

invokeai/backend/model_manager/load/model_util.py

@@ -6,7 +6,6 @@ import logging
 from pathlib import Path
 from typing import Optional
 
-import onnxruntime as ort
 import torch
 from diffusers.pipelines.pipeline_utils import DiffusionPipeline
 from diffusers.schedulers.scheduling_utils import SchedulerMixin
@@ -16,9 +15,11 @@ from invokeai.backend.image_util.depth_anything.depth_anything_pipeline import D
 from invokeai.backend.image_util.grounding_dino.grounding_dino_pipeline import GroundingDinoPipeline
 from invokeai.backend.image_util.segment_anything.segment_anything_pipeline import SegmentAnythingPipeline
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter
+from invokeai.backend.llava_onevision_model import LlavaOnevisionModel
 from invokeai.backend.model_manager.taxonomy import AnyModel
 from invokeai.backend.onnx.onnx_runtime import IAIOnnxRuntimeModel
 from invokeai.backend.patches.model_patch_raw import ModelPatchRaw
+from invokeai.backend.sig_lip.sig_lip_pipeline import SigLipPipeline
 from invokeai.backend.spandrel_image_to_image_model import SpandrelImageToImageModel
 from invokeai.backend.textual_inversion import TextualInversionModelRaw
 from invokeai.backend.util.calc_tensor_size import calc_tensor_size
@@ -49,19 +50,11 @@ def calc_model_size_by_data(logger: logging.Logger, model: AnyModel) -> int:
             GroundingDinoPipeline,
             SegmentAnythingPipeline,
             DepthAnythingPipeline,
+            SigLipPipeline,
+            LlavaOnevisionModel,
         ),
     ):
         return model.calc_size()
-    elif isinstance(model, ort.InferenceSession):
-        if model._model_bytes is not None:
-            # If the model is already loaded, return the size of the model bytes
-            return len(model._model_bytes)
-        elif model._model_path is not None:
-            # If the model is not loaded, return the size of the model path
-            return calc_model_size_by_fs(Path(model._model_path))
-        else:
-            # If neither is available, return 0
-            return 0
     elif isinstance(
         model,
         (

invokeai/backend/model_manager/metadata/fetch/huggingface.py

@@ -62,14 +62,11 @@ class HuggingFaceMetadataFetch(ModelMetadataFetchBase):
         # If this too fails, raise exception.
 
         model_info = None
-
-        # Handling for our special syntax - we only want the base HF `org/repo` here.
-        repo_id = id.split("::")[0] or id
         while not model_info:
             try:
-                model_info = HfApi().model_info(repo_id=repo_id, files_metadata=True, revision=variant)
+                model_info = HfApi().model_info(repo_id=id, files_metadata=True, revision=variant)
             except RepositoryNotFoundError as excp:
-                raise UnknownMetadataException(f"'{repo_id}' not found. See trace for details.") from excp
+                raise UnknownMetadataException(f"'{id}' not found. See trace for details.") from excp
             except RevisionNotFoundError:
                 if variant is None:
                     raise
@@ -78,14 +75,14 @@ class HuggingFaceMetadataFetch(ModelMetadataFetchBase):
 
         files: list[RemoteModelFile] = []
 
-        _, name = repo_id.split("/")
+        _, name = id.split("/")
 
         for s in model_info.siblings or []:
             assert s.rfilename is not None
             assert s.size is not None
             files.append(
                 RemoteModelFile(
-                    url=hf_hub_url(repo_id, s.rfilename, revision=variant or "main"),
+                    url=hf_hub_url(id, s.rfilename, revision=variant or "main"),
                     path=Path(name, s.rfilename),
                     size=s.size,
                     sha256=s.lfs.get("sha256") if s.lfs else None,

invokeai/backend/model_manager/model_on_disk.py

@@ -4,7 +4,6 @@ from typing import Any, Optional, TypeAlias
 import safetensors.torch
 import torch
 from picklescan.scanner import scan_file_path
-from safetensors import safe_open
 
 from invokeai.backend.model_hash.model_hash import HASHING_ALGORITHMS, ModelHash
 from invokeai.backend.model_manager.taxonomy import ModelRepoVariant
@@ -36,21 +35,12 @@ class ModelOnDisk:
             return self.path.stat().st_size
         return sum(file.stat().st_size for file in self.path.rglob("*"))
 
-    def weight_files(self) -> set[Path]:
+    def component_paths(self) -> set[Path]:
         if self.path.is_file():
             return {self.path}
         extensions = {".safetensors", ".pt", ".pth", ".ckpt", ".bin", ".gguf"}
         return {f for f in self.path.rglob("*") if f.suffix in extensions}
 
-    def metadata(self, path: Optional[Path] = None) -> dict[str, str]:
-        try:
-            with safe_open(self.path, framework="pt", device="cpu") as f:
-                metadata = f.metadata()
-                assert isinstance(metadata, dict)
-                return metadata
-        except Exception:
-            return {}
-
     def repo_variant(self) -> Optional[ModelRepoVariant]:
         if self.path.is_file():
             return None
@@ -74,7 +64,18 @@ class ModelOnDisk:
         if path in sd_cache:
             return sd_cache[path]
 
-        path = self.resolve_weight_file(path)
+        if not path:
+            components = list(self.component_paths())
+            match components:
+                case []:
+                    raise ValueError("No weight files found for this model")
+                case [p]:
+                    path = p
+                case ps if len(ps) >= 2:
+                    raise ValueError(
+                        f"Multiple weight files found for this model: {ps}. "
+                        f"Please specify the intended file using the 'path' argument"
+                    )
 
         with SilenceWarnings():
             if path.suffix.endswith((".ckpt", ".pt", ".pth", ".bin")):
@@ -93,18 +94,3 @@ class ModelOnDisk:
         state_dict = checkpoint.get("state_dict", checkpoint)
         sd_cache[path] = state_dict
         return state_dict
-
-    def resolve_weight_file(self, path: Optional[Path] = None) -> Path:
-        if not path:
-            weight_files = list(self.weight_files())
-            match weight_files:
-                case []:
-                    raise ValueError("No weight files found for this model")
-                case [p]:
-                    return p
-                case ps if len(ps) >= 2:
-                    raise ValueError(
-                        f"Multiple weight files found for this model: {ps}. "
-                        f"Please specify the intended file using the 'path' argument"
-                    )
-        return path

invokeai/backend/model_manager/starter_models.py

@@ -593,16 +593,6 @@ swinir = StarterModel(
 
 # endregion
 
-# region CogView4
-cogview4 = StarterModel(
-    name="CogView4",
-    base=BaseModelType.CogView4,
-    source="THUDM/CogView4-6B",
-    description="The base CogView4 model (~29GB).",
-    type=ModelType.Main,
-)
-# endregion
-
 # region SigLIP
 siglip = StarterModel(
     name="SigLIP - google/siglip-so400m-patch14-384",
@@ -715,7 +705,6 @@ STARTER_MODELS: list[StarterModel] = [
     flux_redux,
     llava_onevision,
     flux_fill,
-    cogview4,
 ]
 
 sd1_bundle: list[StarterModel] = [