upgrade Dockerfile to use python 3.12

we will use uv.lock to ensure reproducibility

.dockerignore

@@ -1,11 +1,9 @@
 *
 !invokeai
 !pyproject.toml
-!uv.lock
 !docker/docker-entrypoint.sh
 !LICENSE
 
-**/dist
 **/node_modules
 **/__pycache__
-**/*.egg-info
+**/*.egg-info

.git-blame-ignore-revs

@@ -1,5 +1,2 @@
 b3dccfaeb636599c02effc377cdd8a87d658256c
 218b6d0546b990fc449c876fb99f44b50c4daa35
-182580ff6970caed400be178c5b888514b75d7f2
-8e9d5c1187b0d36da80571ce4c8ba9b3a37b6c46
-99aac5870e1092b182e6c5f21abcaab6936a4ad1

.github/CODEOWNERS

@@ -2,11 +2,11 @@
 /.github/workflows/  @lstein @blessedcoolant @hipsterusername @ebr @jazzhaiku
 
 # documentation
-/docs/ @lstein @blessedcoolant @hipsterusername @psychedelicious
-/mkdocs.yml @lstein @blessedcoolant @hipsterusername @psychedelicious
+/docs/ @lstein @blessedcoolant @hipsterusername @Millu
+/mkdocs.yml @lstein  @blessedcoolant @hipsterusername @Millu
 
 # nodes
-/invokeai/app/ @blessedcoolant @psychedelicious @brandonrising @hipsterusername @jazzhaiku
+/invokeai/app/ @Kyle0654 @blessedcoolant @psychedelicious @brandonrising @hipsterusername @jazzhaiku
 
 # installation and configuration
 /pyproject.toml  @lstein @blessedcoolant @hipsterusername
@@ -22,7 +22,7 @@
 /invokeai/backend @blessedcoolant @psychedelicious @lstein @maryhipp @hipsterusername
 
 # generation, model management, postprocessing
-/invokeai/backend  @lstein @blessedcoolant @brandonrising @hipsterusername @jazzhaiku
+/invokeai/backend  @damian0815 @lstein @blessedcoolant @gregghelt2 @StAlKeR7779 @brandonrising @ryanjdick @hipsterusername @jazzhaiku
 
 # front ends
 /invokeai/frontend/CLI @lstein @hipsterusername

.github/workflows/build-container.yml

@@ -97,8 +97,6 @@ jobs:
           context: .
           file: docker/Dockerfile
           platforms: ${{ env.PLATFORMS }}
-          build-args: |
-            GPU_DRIVER=${{ matrix.gpu-driver }}
           push: ${{ github.ref == 'refs/heads/main' || github.ref_type == 'tag' || github.event.inputs.push-to-registry }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

.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:
@@ -17,7 +17,7 @@ jobs:
       - name: setup python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.12'
+          python-version: '3.10'
           cache: pip
           cache-dependency-path: pyproject.toml
 
@@ -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

@@ -34,9 +34,6 @@ on:
 
 jobs:
   python-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:
@@ -60,19 +57,25 @@ jobs:
               - '!invokeai/frontend/web/**'
               - 'tests/**'
 
-      - name: setup uv
+      - name: setup python
         if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}
-        uses: astral-sh/setup-uv@v5
+        uses: actions/setup-python@v5
         with:
-          version: '0.6.10'
-          enable-cache: true
+          python-version: '3.10'
+          cache: pip
+          cache-dependency-path: pyproject.toml
+
+      - name: install ruff
+        if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}
+        run: pip install ruff==0.9.9
+        shell: bash
 
       - 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 .
+        run: ruff check --output-format=github .
         shell: bash
 
       - name: ruff format
         if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}
-        run: uv tool run ruff@0.11.2 format --check .
+        run: ruff format --check .
         shell: bash

.github/workflows/python-tests.yml

@@ -39,15 +39,24 @@ jobs:
     strategy:
       matrix:
         python-version:
+          - '3.10'
           - '3.11'
-          - '3.12'
         platform:
+          - linux-cuda-11_7
+          - linux-rocm-5_2
           - linux-cpu
           - macos-default
           - windows-cpu
         include:
+          - platform: linux-cuda-11_7
+            os: ubuntu-22.04
+            github-env: $GITHUB_ENV
+          - platform: linux-rocm-5_2
+            os: ubuntu-22.04
+            extra-index-url: 'https://download.pytorch.org/whl/rocm5.2'
+            github-env: $GITHUB_ENV
           - platform: linux-cpu
-            os: ubuntu-24.04
+            os: ubuntu-22.04
             extra-index-url: 'https://download.pytorch.org/whl/cpu'
             github-env: $GITHUB_ENV
           - platform: macos-default
@@ -61,8 +70,6 @@ jobs:
     timeout-minutes: 15 # expected run time: 2-6 min, depending on platform
     env:
       PIP_USE_PEP517: '1'
-      UV_SYSTEM_PYTHON: 1
-
     steps:
       - name: checkout
         # https://github.com/nschloe/action-cached-lfs-checkout
@@ -85,25 +92,20 @@ jobs:
               - '!invokeai/frontend/web/**'
               - 'tests/**'
 
-      - name: setup uv
-        if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}
-        uses: astral-sh/setup-uv@v5
-        with:
-          version: '0.6.10'
-          enable-cache: true
-          python-version: ${{ matrix.python-version }}
-
       - name: setup python
         if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
+          cache: pip
+          cache-dependency-path: pyproject.toml
 
       - name: install dependencies
         if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}
         env:
-          UV_INDEX: ${{ matrix.extra-index-url }}
-        run: uv pip install --editable ".[test]"
+          PIP_EXTRA_INDEX_URL: ${{ matrix.extra-index-url }}
+        run: >
+          pip3 install --editable=".[test]"
 
       - name: run pytest
         if: ${{ steps.changed-files.outputs.python_any_changed == 'true' || inputs.always_run == true }}

.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/typegen-checks.yml

@@ -54,25 +54,17 @@ jobs:
               - 'pyproject.toml'
               - 'invokeai/**'
 
-      - name: setup uv
-        if: ${{ steps.changed-files.outputs.src_any_changed == 'true' || inputs.always_run == true }}
-        uses: astral-sh/setup-uv@v5
-        with:
-          version: '0.6.10'
-          enable-cache: true
-          python-version: '3.11'
-
       - name: setup python
         if: ${{ steps.changed-files.outputs.src_any_changed == 'true' || inputs.always_run == true }}
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.10'
+          cache: pip
+          cache-dependency-path: pyproject.toml
 
-      - name: install dependencies
+      - name: install python dependencies
         if: ${{ steps.changed-files.outputs.src_any_changed == 'true' || inputs.always_run == true }}
-        env:
-          UV_INDEX: ${{ matrix.extra-index-url }}
-        run: uv pip install --editable .
+        run: pip3 install --use-pep517 --editable="."
 
       - name: install frontend dependencies
         if: ${{ steps.changed-files.outputs.src_any_changed == 'true' || inputs.always_run == true }}
@@ -85,7 +77,7 @@ jobs:
 
       - name: generate schema
         if: ${{ steps.changed-files.outputs.src_any_changed == 'true' || inputs.always_run == true }}
-        run: cd invokeai/frontend/web && uv run ../../../scripts/generate_openapi_schema.py | pnpm typegen
+        run: make frontend-typegen
         shell: bash
 
       - name: compare files

.nvmrc

@@ -1 +1 @@
-v22.14.0
+v22.12.0

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

@@ -1,6 +1,68 @@
 # syntax=docker/dockerfile:1.4
 
-#### Web UI ------------------------------------
+## Builder stage
+
+FROM library/ubuntu:24.04 AS builder
+
+ARG DEBIAN_FRONTEND=noninteractive
+RUN rm -f /etc/apt/apt.conf.d/docker-clean; echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
+    --mount=type=cache,target=/var/lib/apt,sharing=locked \
+    apt update && apt-get install -y \
+        build-essential \
+        git
+
+# Install `uv` for package management
+COPY --from=ghcr.io/astral-sh/uv:0.6.0 /uv /uvx /bin/
+
+ENV VIRTUAL_ENV=/opt/venv
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+ENV INVOKEAI_SRC=/opt/invokeai
+ENV PYTHON_VERSION=3.12
+ENV UV_PYTHON=3.12
+ENV UV_COMPILE_BYTECODE=1
+ENV UV_LINK_MODE=copy
+ENV UV_PROJECT_ENVIRONMENT="$VIRTUAL_ENV"
+ENV UV_INDEX="https://download.pytorch.org/whl/cu124"
+
+ARG GPU_DRIVER=cuda
+# unused but available
+ARG BUILDPLATFORM
+
+# Switch to the `ubuntu` user to work around dependency issues with uv-installed python
+RUN mkdir -p ${VIRTUAL_ENV} && \
+    mkdir -p ${INVOKEAI_SRC} && \
+    chmod -R a+w /opt && \
+    mkdir ~ubuntu/.cache && chown ubuntu: ~ubuntu/.cache
+USER ubuntu
+
+# Install python
+RUN --mount=type=cache,target=/home/ubuntu/.cache/uv,uid=1000,gid=1000 \
+  uv python install ${PYTHON_VERSION}
+
+WORKDIR ${INVOKEAI_SRC}
+
+# Install project's dependencies as a separate layer so they aren't rebuilt every commit.
+# bind-mount instead of copy to defer adding sources to the image until next layer.
+#
+# NOTE: there are no pytorch builds for arm64 + cuda, only cpu
+# x86_64/CUDA is the default
+RUN --mount=type=cache,target=/home/ubuntu/.cache/uv,uid=1000,gid=1000 \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=invokeai/version,target=invokeai/version \
+    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.1"; \
+    fi && \
+    uv sync
+
+# Now that the bulk of the dependencies have been installed, copy in the project files that change more frequently.
+COPY pyproject.toml uv.lock ./
+COPY invokeai invokeai
+
+#### Build the Web UI ------------------------------------
 
 FROM docker.io/node:22-slim AS web-builder
 ENV PNPM_HOME="/pnpm"
@@ -14,89 +76,69 @@ RUN --mount=type=cache,target=/pnpm/store \
     pnpm install --frozen-lockfile
 RUN npx vite build
 
-## Backend ---------------------------------------
+#### Runtime stage ---------------------------------------
 
-FROM library/ubuntu:24.04
+FROM library/ubuntu:24.04 AS runtime
 
 ARG DEBIAN_FRONTEND=noninteractive
-RUN rm -f /etc/apt/apt.conf.d/docker-clean; echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache
-RUN --mount=type=cache,target=/var/cache/apt \
-    --mount=type=cache,target=/var/lib/apt \
-    apt update && apt install -y --no-install-recommends \
-    ca-certificates \
-    git \
-    gosu \
-    libglib2.0-0 \
-    libgl1 \
-    libglx-mesa0 \
-    build-essential \
-    libopencv-dev \
-    libstdc++-10-dev
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
 
-ENV \
-    PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    VIRTUAL_ENV=/opt/venv \
-    INVOKEAI_SRC=/opt/invokeai \
-    PYTHON_VERSION=3.12 \
-    UV_PYTHON=3.12 \
-    UV_COMPILE_BYTECODE=1 \
-    UV_MANAGED_PYTHON=1 \
-    UV_LINK_MODE=copy \
-    UV_PROJECT_ENVIRONMENT=/opt/venv \
-    UV_INDEX="https://download.pytorch.org/whl/cu124" \
-    INVOKEAI_ROOT=/invokeai \
-    INVOKEAI_HOST=0.0.0.0 \
-    INVOKEAI_PORT=9090 \
-    PATH="/opt/venv/bin:$PATH" \
-    CONTAINER_UID=${CONTAINER_UID:-1000} \
-    CONTAINER_GID=${CONTAINER_GID:-1000}
+RUN apt update && apt install -y --no-install-recommends \
+        git \
+        curl \
+        vim \
+        tmux \
+        ncdu \
+        iotop \
+        bzip2 \
+        gosu \
+        magic-wormhole \
+        libglib2.0-0 \
+        libgl1 \
+        libglx-mesa0 \
+        build-essential \
+        libopencv-dev \
+        libstdc++-10-dev &&\
+    apt-get clean && apt-get autoclean
 
-ARG GPU_DRIVER=cuda
+ENV INVOKEAI_SRC=/opt/invokeai
+ENV VIRTUAL_ENV=/opt/venv
+ENV UV_PROJECT_ENVIRONMENT="$VIRTUAL_ENV"
+ENV PYTHON_VERSION=3.12
+ENV INVOKEAI_ROOT=/invokeai
+ENV INVOKEAI_HOST=0.0.0.0
+ENV INVOKEAI_PORT=9090
+ENV PATH="$VIRTUAL_ENV/bin:$INVOKEAI_SRC:$PATH"
+ENV CONTAINER_UID=${CONTAINER_UID:-1000}
+ENV CONTAINER_GID=${CONTAINER_GID:-1000}
 
 # Install `uv` for package management
-COPY --from=ghcr.io/astral-sh/uv:0.6.9 /uv /uvx /bin/
+# and install python for the ubuntu user (expected to exist on ubuntu >=24.x)
+# this is too tiny to optimize with multi-stage builds, but maybe we'll come back to it
+COPY --from=ghcr.io/astral-sh/uv:0.6.0 /uv /uvx /bin/
+USER ubuntu
+RUN uv python install ${PYTHON_VERSION}
+USER root
 
-# Install python & allow non-root user to use it by traversing the /root dir without read permissions
-RUN --mount=type=cache,target=/root/.cache/uv \
-    uv python install ${PYTHON_VERSION} && \
-    # chmod --recursive a+rX /root/.local/share/uv/python
-    chmod 711 /root
-
-WORKDIR ${INVOKEAI_SRC}
-
-# Install project's dependencies as a separate layer so they aren't rebuilt every commit.
-# bind-mount instead of copy to defer adding sources to the image until next layer.
-#
-# NOTE: there are no pytorch builds for arm64 + cuda, only cpu
-# x86_64/CUDA is the default
-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 \
-    # this is just to get the package manager to recognize that the project exists, without making changes to the docker layer
-    --mount=type=bind,source=invokeai/version,target=invokeai/version \
-    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 sync --frozen
-
-# build patchmatch
-RUN cd /usr/lib/$(uname -p)-linux-gnu/pkgconfig/ && ln -sf opencv4.pc opencv.pc
-RUN python -c "from patchmatch import patch_match"
+# --link requires buldkit w/ dockerfile syntax 1.4
+COPY --link --from=builder ${INVOKEAI_SRC} ${INVOKEAI_SRC}
+COPY --link --from=builder ${VIRTUAL_ENV} ${VIRTUAL_ENV}
+COPY --link --from=web-builder /build/dist ${INVOKEAI_SRC}/invokeai/frontend/web/dist
 
 # Link amdgpu.ids for ROCm builds
 # contributed by https://github.com/Rubonnek
 RUN mkdir -p "/opt/amdgpu/share/libdrm" &&\
-    ln -s "/usr/share/libdrm/amdgpu.ids" "/opt/amdgpu/share/libdrm/amdgpu.ids"
+  ln -s "/usr/share/libdrm/amdgpu.ids" "/opt/amdgpu/share/libdrm/amdgpu.ids"
+
+WORKDIR ${INVOKEAI_SRC}
+
+# build patchmatch
+RUN cd /usr/lib/$(uname -p)-linux-gnu/pkgconfig/ && ln -sf opencv4.pc opencv.pc
+RUN python -c "from patchmatch import patch_match"
 
 RUN mkdir -p ${INVOKEAI_ROOT} && chown -R ${CONTAINER_UID}:${CONTAINER_GID} ${INVOKEAI_ROOT}
 
 COPY docker/docker-entrypoint.sh ./
 ENTRYPOINT ["/opt/invokeai/docker-entrypoint.sh"]
 CMD ["invokeai-web"]
-
-# --link requires buldkit w/ dockerfile syntax 1.4, does not work with podman
-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

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/cu124 --reinstall
+      uv pip install -e ".[dev,test,docs,xformers]" --python 3.11 --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/manual.md

@@ -43,10 +43,10 @@ The following commands vary depending on the version of Invoke being installed a
 3. Create a virtual environment in that directory:
 
     ```sh
-    uv venv --relocatable --prompt invoke --python 3.12 --python-preference only-managed .venv
+    uv venv --relocatable --prompt invoke --python 3.11 --python-preference only-managed .venv
     ```
 
-    This command creates a portable virtual environment at `.venv` complete with a portable python 3.12. It doesn't matter if your system has no python installed, or has a different version - `uv` will handle everything.
+    This command creates a portable virtual environment at `.venv` complete with a portable python 3.11. It doesn't matter if your system has no python installed, or has a different version - `uv` will handle everything.
 
 4. Activate the virtual environment:
 
@@ -64,7 +64,7 @@ The following commands vary depending on the version of Invoke being installed a
 
 5. Choose a version to install. Review the [GitHub releases page](https://github.com/invoke-ai/InvokeAI/releases).
 
-6. Determine the package specifier to use when installing. This is a performance optimization.
+6. Determine the package package specifier to use when installing. This is a performance optimization.
 
     - If you have an Nvidia 20xx series GPU or older, use `invokeai[xformers]`.
     - If you have an Nvidia 30xx series GPU or newer, or do not have an Nvidia GPU, use `invokeai`.
@@ -88,13 +88,13 @@ The following commands vary depending on the version of Invoke being installed a
 8. Install the `invokeai` package. Substitute the package specifier and version.
 
     ```sh
-    uv pip install <PACKAGE_SPECIFIER>==<VERSION> --python 3.12 --python-preference only-managed --force-reinstall
+    uv pip install <PACKAGE_SPECIFIER>==<VERSION> --python 3.11 --python-preference only-managed --force-reinstall
     ```
 
     If you determined you needed to use a `PyPI` index URL in the previous step, you'll need to add `--index=<INDEX_URL>` like this:
 
     ```sh
-    uv pip install <PACKAGE_SPECIFIER>==<VERSION> --python 3.12 --python-preference only-managed --index=<INDEX_URL> --force-reinstall
+    uv pip install <PACKAGE_SPECIFIER>==<VERSION> --python 3.11 --python-preference only-managed --index=<INDEX_URL> --force-reinstall
     ```
 
 9. Deactivate and reactivate your venv so that the invokeai-specific commands become available in the environment:

docs/installation/requirements.md

@@ -41,7 +41,7 @@ The requirements below are rough guidelines for best performance. GPUs with less
 
     You don't need to do this if you are installing with the [Invoke Launcher](./quick_start.md).
 
-Invoke requires python 3.10 through 3.12. If you don't already have one of these versions installed, we suggest installing 3.12, as it will be supported for longer.
+Invoke requires python 3.10 or 3.11. If you don't already have one of these versions installed, we suggest installing 3.11, as it will be supported for longer.
 
 Check that your system has an up-to-date Python installed by running `python3 --version` in the terminal (Linux, macOS) or cmd/powershell (Windows).
 
@@ -49,19 +49,19 @@ Check that your system has an up-to-date Python installed by running `python3 --
 
     === "Windows"
 
-        - Install python with [an official installer].
+        - Install python 3.11 with [an official installer].
         - The installer includes an option to add python to your PATH. Be sure to enable this. If you missed it, re-run the installer, choose to modify an existing installation, and tick that checkbox.
         - You may need to install [Microsoft Visual C++ Redistributable].
 
     === "macOS"
 
-        - Install python with [an official installer].
+        - Install python 3.11 with [an official installer].
         - If model installs fail with a certificate error, you may need to run this command (changing the python version to match what you have installed): `/Applications/Python\ 3.10/Install\ Certificates.command`
         - If you haven't already, you will need to install the XCode CLI Tools by running `xcode-select --install` in a terminal.
 
     === "Linux"
 
-        - Installing python varies depending on your system. We recommend [using `uv` to manage your python installation](https://docs.astral.sh/uv/concepts/python-versions/#installing-a-python-version).
+        - Installing python varies depending on your system. On Ubuntu, you can use the [deadsnakes PPA](https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa).
         - You'll need to install `libglib2.0-0` and `libgl1-mesa-glx` for OpenCV to work. For example, on a Debian system: `sudo apt update && sudo apt install -y libglib2.0-0 libgl1-mesa-glx`
 
 ## Drivers

installer/create_installer.sh

@@ -32,6 +32,12 @@ 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}:"
@@ -71,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
@@ -85,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

@@ -37,13 +37,7 @@ from invokeai.app.services.style_preset_records.style_preset_records_sqlite impo
 from invokeai.app.services.urls.urls_default import LocalUrlService
 from invokeai.app.services.workflow_records.workflow_records_sqlite import SqliteWorkflowRecordsStorage
 from invokeai.app.services.workflow_thumbnails.workflow_thumbnails_disk import WorkflowThumbnailFileStorageDisk
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
-    BasicConditioningInfo,
-    ConditioningFieldData,
-    FLUXConditioningInfo,
-    SD3ConditioningInfo,
-    SDXLConditioningInfo,
-)
+from invokeai.backend.stable_diffusion.diffusion.conditioning_data import ConditioningFieldData
 from invokeai.backend.util.logging import InvokeAILogger
 from invokeai.version.invokeai_version import __version__
 
@@ -107,25 +101,10 @@ class ApiDependencies:
         images = ImageService()
         invocation_cache = MemoryInvocationCache(max_cache_size=config.node_cache_size)
         tensors = ObjectSerializerForwardCache(
-            ObjectSerializerDisk[torch.Tensor](
-                output_folder / "tensors",
-                safe_globals=[torch.Tensor],
-                ephemeral=True,
-            ),
-            max_cache_size=0,
+            ObjectSerializerDisk[torch.Tensor](output_folder / "tensors", ephemeral=True)
         )
         conditioning = ObjectSerializerForwardCache(
-            ObjectSerializerDisk[ConditioningFieldData](
-                output_folder / "conditioning",
-                safe_globals=[
-                    ConditioningFieldData,
-                    BasicConditioningInfo,
-                    SDXLConditioningInfo,
-                    FLUXConditioningInfo,
-                    SD3ConditioningInfo,
-                ],
-                ephemeral=True,
-            ),
+            ObjectSerializerDisk[ConditioningFieldData](output_folder / "conditioning", ephemeral=True)
         )
         download_queue_service = DownloadQueueService(app_config=configuration, event_bus=events)
         model_images_service = ModelImageFileStorageDisk(model_images_folder / "model_images")

invokeai/app/api/routers/app_info.py

@@ -12,7 +12,6 @@ from pydantic import BaseModel, Field
 
 from invokeai.app.api.dependencies import ApiDependencies
 from invokeai.app.invocations.upscale import ESRGAN_MODELS
-from invokeai.app.services.config.config_default import InvokeAIAppConfig, get_config
 from invokeai.app.services.invocation_cache.invocation_cache_common import InvocationCacheStatus
 from invokeai.backend.image_util.infill_methods.patchmatch import PatchMatch
 from invokeai.backend.util.logging import logging
@@ -100,7 +99,7 @@ async def get_app_deps() -> AppDependencyVersions:
 
 
 @app_router.get("/config", operation_id="get_config", status_code=200, response_model=AppConfig)
-async def get_config_() -> AppConfig:
+async def get_config() -> AppConfig:
     infill_methods = ["lama", "tile", "cv2", "color"]  # TODO: add mosaic back
     if PatchMatch.patchmatch_available():
         infill_methods.append("patchmatch")
@@ -122,21 +121,6 @@ async def get_config_() -> AppConfig:
     )
 
 
-class InvokeAIAppConfigWithSetFields(BaseModel):
-    """InvokeAI App Config with model fields set"""
-
-    set_fields: set[str] = Field(description="The set fields")
-    config: InvokeAIAppConfig = Field(description="The InvokeAI App Config")
-
-
-@app_router.get(
-    "/runtime_config", operation_id="get_runtime_config", status_code=200, response_model=InvokeAIAppConfigWithSetFields
-)
-async def get_runtime_config() -> InvokeAIAppConfigWithSetFields:
-    config = get_config()
-    return InvokeAIAppConfigWithSetFields(set_fields=config.model_fields_set, config=config)
-
-
 @app_router.get(
     "/logging",
     operation_id="get_log_level",

invokeai/app/api/routers/images.py

@@ -96,22 +96,6 @@ async def upload_image(
         raise HTTPException(status_code=500, detail="Failed to create image")
 
 
-class ImageUploadEntry(BaseModel):
-    image_dto: ImageDTO = Body(description="The image DTO")
-    presigned_url: str = Body(description="The URL to get the presigned URL for the image upload")
-
-
-@images_router.post("/", operation_id="create_image_upload_entry")
-async def create_image_upload_entry(
-    width: int = Body(description="The width of the image"),
-    height: int = Body(description="The height of the image"),
-    board_id: Optional[str] = Body(default=None, description="The board to add this image to, if any"),
-) -> ImageUploadEntry:
-    """Uploads an image from a URL, not implemented"""
-
-    raise HTTPException(status_code=501, detail="Not implemented")
-
-
 @images_router.delete("/i/{image_name}", operation_id="delete_image")
 async def delete_image(
     image_name: str = Path(description="The name of the image to delete"),

invokeai/app/api/routers/model_manager.py

@@ -28,10 +28,12 @@ from invokeai.app.services.model_records import (
     UnknownModelException,
 )
 from invokeai.app.util.suppress_output import SuppressOutput
-from invokeai.backend.model_manager import BaseModelType, ModelFormat, ModelType
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
+    BaseModelType,
     MainCheckpointConfig,
+    ModelFormat,
+    ModelType,
 )
 from invokeai.backend.model_manager.load.model_cache.cache_stats import CacheStats
 from invokeai.backend.model_manager.metadata.fetch.huggingface import HuggingFaceMetadataFetch

invokeai/app/api/routers/session_queue.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from fastapi import Body, Path, Query
 from fastapi.routing import APIRouter
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from invokeai.app.api.dependencies import ApiDependencies
 from invokeai.app.services.session_processor.session_processor_common import SessionProcessorStatus
@@ -15,7 +15,6 @@ from invokeai.app.services.session_queue.session_queue_common import (
     CancelByDestinationResult,
     ClearResult,
     EnqueueBatchResult,
-    FieldIdentifier,
     PruneResult,
     RetryItemsResult,
     SessionQueueCountsByDestination,
@@ -35,12 +34,6 @@ class SessionQueueAndProcessorStatus(BaseModel):
     processor: SessionProcessorStatus
 
 
-class ValidationRunData(BaseModel):
-    workflow_id: str = Field(description="The id of the workflow being published.")
-    input_fields: list[FieldIdentifier] = Body(description="The input fields for the published workflow")
-    output_fields: list[FieldIdentifier] = Body(description="The output fields for the published workflow")
-
-
 @session_queue_router.post(
     "/{queue_id}/enqueue_batch",
     operation_id="enqueue_batch",
@@ -52,10 +45,6 @@ async def enqueue_batch(
     queue_id: str = Path(description="The queue id to perform this operation on"),
     batch: Batch = Body(description="Batch to process"),
     prepend: bool = Body(default=False, description="Whether or not to prepend this batch in the queue"),
-    validation_run_data: Optional[ValidationRunData] = Body(
-        default=None,
-        description="The validation run data to use for this batch. This is only used if this is a validation run.",
-    ),
 ) -> EnqueueBatchResult:
     """Processes a batch and enqueues the output graphs for execution."""
 

invokeai/app/api/routers/workflows.py

@@ -106,7 +106,6 @@ async def list_workflows(
     tags: Optional[list[str]] = Query(default=None, description="The tags of workflow to get"),
     query: Optional[str] = Query(default=None, description="The text to query by (matches name and description)"),
     has_been_opened: Optional[bool] = Query(default=None, description="Whether to include/exclude recent workflows"),
-    is_published: Optional[bool] = Query(default=None, description="Whether to include/exclude published workflows"),
 ) -> PaginatedResults[WorkflowRecordListItemWithThumbnailDTO]:
     """Gets a page of workflows"""
     workflows_with_thumbnails: list[WorkflowRecordListItemWithThumbnailDTO] = []
@@ -119,7 +118,6 @@ async def list_workflows(
         categories=categories,
         tags=tags,
         has_been_opened=has_been_opened,
-        is_published=is_published,
     )
     for workflow in workflows.items:
         workflows_with_thumbnails.append(

invokeai/app/invocations/baseinvocation.py

@@ -8,7 +8,6 @@ import sys
 import warnings
 from abc import ABC, abstractmethod
 from enum import Enum
-from functools import lru_cache
 from inspect import signature
 from typing import (
     TYPE_CHECKING,
@@ -28,6 +27,7 @@ import semver
 from pydantic import BaseModel, ConfigDict, Field, TypeAdapter, create_model
 from pydantic.fields import FieldInfo
 from pydantic_core import PydanticUndefined
+from typing_extensions import TypeAliasType
 
 from invokeai.app.invocations.fields import (
     FieldKind,
@@ -100,6 +100,37 @@ class BaseInvocationOutput(BaseModel):
     All invocation outputs must use the `@invocation_output` decorator to provide their unique type.
     """
 
+    _output_classes: ClassVar[set[BaseInvocationOutput]] = set()
+    _typeadapter: ClassVar[Optional[TypeAdapter[Any]]] = None
+    _typeadapter_needs_update: ClassVar[bool] = False
+
+    @classmethod
+    def register_output(cls, output: BaseInvocationOutput) -> None:
+        """Registers an invocation output."""
+        cls._output_classes.add(output)
+        cls._typeadapter_needs_update = True
+
+    @classmethod
+    def get_outputs(cls) -> Iterable[BaseInvocationOutput]:
+        """Gets all invocation outputs."""
+        return cls._output_classes
+
+    @classmethod
+    def get_typeadapter(cls) -> TypeAdapter[Any]:
+        """Gets a pydantc TypeAdapter for the union of all invocation output types."""
+        if not cls._typeadapter or cls._typeadapter_needs_update:
+            AnyInvocationOutput = TypeAliasType(
+                "AnyInvocationOutput", Annotated[Union[tuple(cls._output_classes)], Field(discriminator="type")]
+            )
+            cls._typeadapter = TypeAdapter(AnyInvocationOutput)
+            cls._typeadapter_needs_update = False
+        return cls._typeadapter
+
+    @classmethod
+    def get_output_types(cls) -> Iterable[str]:
+        """Gets all invocation output types."""
+        return (i.get_type() for i in BaseInvocationOutput.get_outputs())
+
     @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."""
@@ -142,16 +173,76 @@ class BaseInvocation(ABC, BaseModel):
     All invocations must use the `@invocation` decorator to provide their unique type.
     """
 
+    _invocation_classes: ClassVar[set[BaseInvocation]] = set()
+    _typeadapter: ClassVar[Optional[TypeAdapter[Any]]] = None
+    _typeadapter_needs_update: ClassVar[bool] = False
+
     @classmethod
     def get_type(cls) -> str:
         """Gets the invocation's type, as provided by the `@invocation` decorator."""
         return cls.model_fields["type"].default
 
+    @classmethod
+    def register_invocation(cls, invocation: BaseInvocation) -> None:
+        """Registers an invocation."""
+        cls._invocation_classes.add(invocation)
+        cls._typeadapter_needs_update = True
+
+    @classmethod
+    def get_typeadapter(cls) -> TypeAdapter[Any]:
+        """Gets a pydantc TypeAdapter for the union of all invocation types."""
+        if not cls._typeadapter or cls._typeadapter_needs_update:
+            AnyInvocation = TypeAliasType(
+                "AnyInvocation", Annotated[Union[tuple(cls.get_invocations())], Field(discriminator="type")]
+            )
+            cls._typeadapter = TypeAdapter(AnyInvocation)
+            cls._typeadapter_needs_update = False
+        return cls._typeadapter
+
+    @classmethod
+    def invalidate_typeadapter(cls) -> None:
+        """Invalidates the typeadapter, forcing it to be rebuilt on next access. If the invocation allowlist or
+        denylist is changed, this should be called to ensure the typeadapter is updated and validation respects
+        the updated allowlist and denylist."""
+        cls._typeadapter_needs_update = True
+
+    @classmethod
+    def get_invocations(cls) -> Iterable[BaseInvocation]:
+        """Gets all invocations, respecting the allowlist and denylist."""
+        app_config = get_config()
+        allowed_invocations: set[BaseInvocation] = set()
+        for sc in cls._invocation_classes:
+            invocation_type = sc.get_type()
+            is_in_allowlist = (
+                invocation_type in app_config.allow_nodes if isinstance(app_config.allow_nodes, list) else True
+            )
+            is_in_denylist = (
+                invocation_type in app_config.deny_nodes if isinstance(app_config.deny_nodes, list) else False
+            )
+            if is_in_allowlist and not is_in_denylist:
+                allowed_invocations.add(sc)
+        return allowed_invocations
+
+    @classmethod
+    def get_invocations_map(cls) -> dict[str, BaseInvocation]:
+        """Gets a map of all invocation types to their invocation classes."""
+        return {i.get_type(): i for i in BaseInvocation.get_invocations()}
+
+    @classmethod
+    def get_invocation_types(cls) -> Iterable[str]:
+        """Gets all invocation types."""
+        return (i.get_type() for i in BaseInvocation.get_invocations())
+
     @classmethod
     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
 
+    @classmethod
+    def get_invocation_for_type(cls, invocation_type: str) -> BaseInvocation | None:
+        """Gets the invocation class for a given invocation type."""
+        return cls.get_invocations_map().get(invocation_type)
+
     @staticmethod
     def json_schema_extra(schema: dict[str, Any], model_class: Type[BaseInvocation]) -> None:
         """Adds various UI-facing attributes to the invocation's OpenAPI schema."""
@@ -249,105 +340,6 @@ class BaseInvocation(ABC, BaseModel):
 TBaseInvocation = TypeVar("TBaseInvocation", bound=BaseInvocation)
 
 
-class InvocationRegistry:
-    _invocation_classes: ClassVar[set[type[BaseInvocation]]] = set()
-    _output_classes: ClassVar[set[type[BaseInvocationOutput]]] = set()
-
-    @classmethod
-    def register_invocation(cls, invocation: type[BaseInvocation]) -> None:
-        """Registers an invocation."""
-        cls._invocation_classes.add(invocation)
-        cls.invalidate_invocation_typeadapter()
-
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_invocation_typeadapter(cls) -> TypeAdapter[Any]:
-        """Gets a pydantic TypeAdapter for the union of all invocation types.
-
-        This is used to parse serialized invocations into the correct invocation class.
-
-        This method is cached to avoid rebuilding the TypeAdapter on every access. If the invocation allowlist or
-        denylist is changed, the cache should be cleared to ensure the TypeAdapter is updated and validation respects
-        the updated allowlist and denylist.
-
-        @see https://docs.pydantic.dev/latest/concepts/type_adapter/
-        """
-        return TypeAdapter(Annotated[Union[tuple(cls.get_invocation_classes())], Field(discriminator="type")])
-
-    @classmethod
-    def invalidate_invocation_typeadapter(cls) -> None:
-        """Invalidates the cached invocation type adapter."""
-        cls.get_invocation_typeadapter.cache_clear()
-
-    @classmethod
-    def get_invocation_classes(cls) -> Iterable[type[BaseInvocation]]:
-        """Gets all invocations, respecting the allowlist and denylist."""
-        app_config = get_config()
-        allowed_invocations: set[type[BaseInvocation]] = set()
-        for sc in cls._invocation_classes:
-            invocation_type = sc.get_type()
-            is_in_allowlist = (
-                invocation_type in app_config.allow_nodes if isinstance(app_config.allow_nodes, list) else True
-            )
-            is_in_denylist = (
-                invocation_type in app_config.deny_nodes if isinstance(app_config.deny_nodes, list) else False
-            )
-            if is_in_allowlist and not is_in_denylist:
-                allowed_invocations.add(sc)
-        return allowed_invocations
-
-    @classmethod
-    def get_invocations_map(cls) -> dict[str, type[BaseInvocation]]:
-        """Gets a map of all invocation types to their invocation classes."""
-        return {i.get_type(): i for i in cls.get_invocation_classes()}
-
-    @classmethod
-    def get_invocation_types(cls) -> Iterable[str]:
-        """Gets all invocation types."""
-        return (i.get_type() for i in cls.get_invocation_classes())
-
-    @classmethod
-    def get_invocation_for_type(cls, invocation_type: str) -> type[BaseInvocation] | None:
-        """Gets the invocation class for a given invocation type."""
-        return cls.get_invocations_map().get(invocation_type)
-
-    @classmethod
-    def register_output(cls, output: "type[TBaseInvocationOutput]") -> None:
-        """Registers an invocation output."""
-        cls._output_classes.add(output)
-        cls.invalidate_output_typeadapter()
-
-    @classmethod
-    def get_output_classes(cls) -> Iterable[type[BaseInvocationOutput]]:
-        """Gets all invocation outputs."""
-        return cls._output_classes
-
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_output_typeadapter(cls) -> TypeAdapter[Any]:
-        """Gets a pydantic TypeAdapter for the union of all invocation output types.
-
-        This is used to parse serialized invocation outputs into the correct invocation output class.
-
-        This method is cached to avoid rebuilding the TypeAdapter on every access. If the invocation allowlist or
-        denylist is changed, the cache should be cleared to ensure the TypeAdapter is updated and validation respects
-        the updated allowlist and denylist.
-
-        @see https://docs.pydantic.dev/latest/concepts/type_adapter/
-        """
-        return TypeAdapter(Annotated[Union[tuple(cls._output_classes)], Field(discriminator="type")])
-
-    @classmethod
-    def invalidate_output_typeadapter(cls) -> None:
-        """Invalidates the cached invocation output type adapter."""
-        cls.get_output_typeadapter.cache_clear()
-
-    @classmethod
-    def get_output_types(cls) -> Iterable[str]:
-        """Gets all invocation output types."""
-        return (i.get_type() for i in cls.get_output_classes())
-
-
 RESERVED_NODE_ATTRIBUTE_FIELD_NAMES = {
     "id",
     "is_intermediate",
@@ -461,8 +453,8 @@ def invocation(
         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)
+        if invocation_type in BaseInvocation.get_invocation_types():
+            clobbered_invocation = BaseInvocation.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
 
@@ -547,7 +539,8 @@ def invocation(
         )
         cls.__doc__ = docstring
 
-        InvocationRegistry.register_invocation(cls)
+        # TODO: how to type this correctly? it's typed as ModelMetaclass, a private class in pydantic
+        BaseInvocation.register_invocation(cls)  # type: ignore
 
         return cls
 
@@ -572,7 +565,7 @@ 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():
+        if output_type in BaseInvocationOutput.get_output_types():
             raise ValueError(f'Invocation type "{output_type}" already exists')
 
         validate_fields(cls.model_fields, output_type)
@@ -593,7 +586,7 @@ def invocation_output(
         )
         cls.__doc__ = docstring
 
-        InvocationRegistry.register_output(cls)
+        BaseInvocationOutput.register_output(cls)  # type: ignore # TODO: how to type this correctly?
 
         return cls
 

invokeai/app/invocations/controlnet.py

@@ -1,128 +0,0 @@
-# Invocations for ControlNet image preprocessors
-# initial implementation by Gregg Helt, 2023
-from typing import List, Union
-
-from pydantic import BaseModel, Field, field_validator, model_validator
-
-from invokeai.app.invocations.baseinvocation import (
-    BaseInvocation,
-    BaseInvocationOutput,
-    Classification,
-    invocation,
-    invocation_output,
-)
-from invokeai.app.invocations.fields import (
-    FieldDescriptions,
-    ImageField,
-    InputField,
-    OutputField,
-    UIType,
-)
-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
-from invokeai.backend.image_util.util import np_to_pil, pil_to_np
-
-
-class ControlField(BaseModel):
-    image: ImageField = Field(description="The control image")
-    control_model: ModelIdentifierField = Field(description="The ControlNet model to use")
-    control_weight: Union[float, List[float]] = Field(default=1, description="The weight given to the ControlNet")
-    begin_step_percent: float = Field(
-        default=0, ge=0, le=1, description="When the ControlNet is first applied (% of total steps)"
-    )
-    end_step_percent: float = Field(
-        default=1, ge=0, le=1, description="When the ControlNet is last applied (% of total steps)"
-    )
-    control_mode: CONTROLNET_MODE_VALUES = Field(default="balanced", description="The control mode to use")
-    resize_mode: CONTROLNET_RESIZE_VALUES = Field(default="just_resize", description="The resize mode to use")
-
-    @field_validator("control_weight")
-    @classmethod
-    def validate_control_weight(cls, v):
-        validate_weights(v)
-        return v
-
-    @model_validator(mode="after")
-    def validate_begin_end_step_percent(self):
-        validate_begin_end_step(self.begin_step_percent, self.end_step_percent)
-        return self
-
-
-@invocation_output("control_output")
-class ControlOutput(BaseInvocationOutput):
-    """node output for ControlNet info"""
-
-    # Outputs
-    control: ControlField = OutputField(description=FieldDescriptions.control)
-
-
-@invocation("controlnet", title="ControlNet - SD1.5, SDXL", tags=["controlnet"], category="controlnet", version="1.1.3")
-class ControlNetInvocation(BaseInvocation):
-    """Collects ControlNet info to pass to other nodes"""
-
-    image: ImageField = InputField(description="The control image")
-    control_model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.controlnet_model, ui_type=UIType.ControlNetModel
-    )
-    control_weight: Union[float, List[float]] = InputField(
-        default=1.0, ge=-1, le=2, description="The weight given to the ControlNet"
-    )
-    begin_step_percent: float = InputField(
-        default=0, ge=0, le=1, description="When the ControlNet is first applied (% of total steps)"
-    )
-    end_step_percent: float = InputField(
-        default=1, ge=0, le=1, description="When the ControlNet is last applied (% of total steps)"
-    )
-    control_mode: CONTROLNET_MODE_VALUES = InputField(default="balanced", description="The control mode used")
-    resize_mode: CONTROLNET_RESIZE_VALUES = InputField(default="just_resize", description="The resize mode used")
-
-    @field_validator("control_weight")
-    @classmethod
-    def validate_control_weight(cls, v):
-        validate_weights(v)
-        return v
-
-    @model_validator(mode="after")
-    def validate_begin_end_step_percent(self) -> "ControlNetInvocation":
-        validate_begin_end_step(self.begin_step_percent, self.end_step_percent)
-        return self
-
-    def invoke(self, context: InvocationContext) -> ControlOutput:
-        return ControlOutput(
-            control=ControlField(
-                image=self.image,
-                control_model=self.control_model,
-                control_weight=self.control_weight,
-                begin_step_percent=self.begin_step_percent,
-                end_step_percent=self.end_step_percent,
-                control_mode=self.control_mode,
-                resize_mode=self.resize_mode,
-            ),
-        )
-
-
-@invocation(
-    "heuristic_resize",
-    title="Heuristic Resize",
-    tags=["image, controlnet"],
-    category="image",
-    version="1.0.1",
-    classification=Classification.Prototype,
-)
-class HeuristicResizeInvocation(BaseInvocation):
-    """Resize an image using a heuristic method. Preserves edge maps."""
-
-    image: ImageField = InputField(description="The image to resize")
-    width: int = InputField(default=512, ge=1, description="The width to resize to (px)")
-    height: int = InputField(default=512, ge=1, description="The height to resize to (px)")
-
-    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(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/controlnet_image_processors.py

@@ -0,0 +1,716 @@
+# Invocations for ControlNet image preprocessors
+# initial implementation by Gregg Helt, 2023
+# heavily leverages controlnet_aux package: https://github.com/patrickvonplaten/controlnet_aux
+from builtins import bool, float
+from pathlib import Path
+from typing import Dict, List, Literal, Union
+
+import cv2
+import numpy as np
+from controlnet_aux import (
+    ContentShuffleDetector,
+    LeresDetector,
+    MediapipeFaceDetector,
+    MidasDetector,
+    MLSDdetector,
+    NormalBaeDetector,
+    PidiNetDetector,
+    SamDetector,
+    ZoeDetector,
+)
+from controlnet_aux.util import HWC3, ade_palette
+from PIL import Image
+from pydantic import BaseModel, Field, field_validator, model_validator
+from transformers import pipeline
+from transformers.pipelines import DepthEstimationPipeline
+
+from invokeai.app.invocations.baseinvocation import (
+    BaseInvocation,
+    BaseInvocationOutput,
+    Classification,
+    invocation,
+    invocation_output,
+)
+from invokeai.app.invocations.fields import (
+    FieldDescriptions,
+    ImageField,
+    InputField,
+    OutputField,
+    UIType,
+    WithBoard,
+    WithMetadata,
+)
+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
+from invokeai.backend.image_util.canny import get_canny_edges
+from invokeai.backend.image_util.depth_anything.depth_anything_pipeline import DepthAnythingPipeline
+from invokeai.backend.image_util.dw_openpose import DWPOSE_MODELS, DWOpenposeDetector
+from invokeai.backend.image_util.hed import HEDProcessor
+from invokeai.backend.image_util.lineart import LineartProcessor
+from invokeai.backend.image_util.lineart_anime import LineartAnimeProcessor
+from invokeai.backend.image_util.util import np_to_pil, pil_to_np
+
+
+class ControlField(BaseModel):
+    image: ImageField = Field(description="The control image")
+    control_model: ModelIdentifierField = Field(description="The ControlNet model to use")
+    control_weight: Union[float, List[float]] = Field(default=1, description="The weight given to the ControlNet")
+    begin_step_percent: float = Field(
+        default=0, ge=0, le=1, description="When the ControlNet is first applied (% of total steps)"
+    )
+    end_step_percent: float = Field(
+        default=1, ge=0, le=1, description="When the ControlNet is last applied (% of total steps)"
+    )
+    control_mode: CONTROLNET_MODE_VALUES = Field(default="balanced", description="The control mode to use")
+    resize_mode: CONTROLNET_RESIZE_VALUES = Field(default="just_resize", description="The resize mode to use")
+
+    @field_validator("control_weight")
+    @classmethod
+    def validate_control_weight(cls, v):
+        validate_weights(v)
+        return v
+
+    @model_validator(mode="after")
+    def validate_begin_end_step_percent(self):
+        validate_begin_end_step(self.begin_step_percent, self.end_step_percent)
+        return self
+
+
+@invocation_output("control_output")
+class ControlOutput(BaseInvocationOutput):
+    """node output for ControlNet info"""
+
+    # Outputs
+    control: ControlField = OutputField(description=FieldDescriptions.control)
+
+
+@invocation("controlnet", title="ControlNet - SD1.5, SDXL", tags=["controlnet"], category="controlnet", version="1.1.3")
+class ControlNetInvocation(BaseInvocation):
+    """Collects ControlNet info to pass to other nodes"""
+
+    image: ImageField = InputField(description="The control image")
+    control_model: ModelIdentifierField = InputField(
+        description=FieldDescriptions.controlnet_model, ui_type=UIType.ControlNetModel
+    )
+    control_weight: Union[float, List[float]] = InputField(
+        default=1.0, ge=-1, le=2, description="The weight given to the ControlNet"
+    )
+    begin_step_percent: float = InputField(
+        default=0, ge=0, le=1, description="When the ControlNet is first applied (% of total steps)"
+    )
+    end_step_percent: float = InputField(
+        default=1, ge=0, le=1, description="When the ControlNet is last applied (% of total steps)"
+    )
+    control_mode: CONTROLNET_MODE_VALUES = InputField(default="balanced", description="The control mode used")
+    resize_mode: CONTROLNET_RESIZE_VALUES = InputField(default="just_resize", description="The resize mode used")
+
+    @field_validator("control_weight")
+    @classmethod
+    def validate_control_weight(cls, v):
+        validate_weights(v)
+        return v
+
+    @model_validator(mode="after")
+    def validate_begin_end_step_percent(self) -> "ControlNetInvocation":
+        validate_begin_end_step(self.begin_step_percent, self.end_step_percent)
+        return self
+
+    def invoke(self, context: InvocationContext) -> ControlOutput:
+        return ControlOutput(
+            control=ControlField(
+                image=self.image,
+                control_model=self.control_model,
+                control_weight=self.control_weight,
+                begin_step_percent=self.begin_step_percent,
+                end_step_percent=self.end_step_percent,
+                control_mode=self.control_mode,
+                resize_mode=self.resize_mode,
+            ),
+        )
+
+
+# This invocation exists for other invocations to subclass it - do not register with @invocation!
+class ImageProcessorInvocation(BaseInvocation, WithMetadata, WithBoard):
+    """Base class for invocations that preprocess images for ControlNet"""
+
+    image: ImageField = InputField(description="The image to process")
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        # superclass just passes through image without processing
+        return image
+
+    def load_image(self, context: InvocationContext) -> Image.Image:
+        # allows override for any special formatting specific to the preprocessor
+        return context.images.get_pil(self.image.image_name, "RGB")
+
+    def invoke(self, context: InvocationContext) -> ImageOutput:
+        self._context = context
+        raw_image = self.load_image(context)
+        # image type should be PIL.PngImagePlugin.PngImageFile ?
+        processed_image = self.run_processor(raw_image)
+
+        # currently can't see processed image in node UI without a showImage node,
+        #    so for now setting image_type to RESULT instead of INTERMEDIATE so will get saved in gallery
+        image_dto = context.images.save(image=processed_image)
+
+        """Builds an ImageOutput and its ImageField"""
+        processed_image_field = ImageField(image_name=image_dto.image_name)
+        return ImageOutput(
+            image=processed_image_field,
+            # width=processed_image.width,
+            width=image_dto.width,
+            # height=processed_image.height,
+            height=image_dto.height,
+            # mode=processed_image.mode,
+        )
+
+
+@invocation(
+    "canny_image_processor",
+    title="Canny Processor",
+    tags=["controlnet", "canny"],
+    category="controlnet",
+    version="1.3.3",
+    classification=Classification.Deprecated,
+)
+class CannyImageProcessorInvocation(ImageProcessorInvocation):
+    """Canny edge detection for ControlNet"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    low_threshold: int = InputField(
+        default=100, ge=0, le=255, description="The low threshold of the Canny pixel gradient (0-255)"
+    )
+    high_threshold: int = InputField(
+        default=200, ge=0, le=255, description="The high threshold of the Canny pixel gradient (0-255)"
+    )
+
+    def load_image(self, context: InvocationContext) -> Image.Image:
+        # Keep alpha channel for Canny processing to detect edges of transparent areas
+        return context.images.get_pil(self.image.image_name, "RGBA")
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        processed_image = get_canny_edges(
+            image,
+            self.low_threshold,
+            self.high_threshold,
+            detect_resolution=self.detect_resolution,
+            image_resolution=self.image_resolution,
+        )
+        return processed_image
+
+
+@invocation(
+    "hed_image_processor",
+    title="HED (softedge) Processor",
+    tags=["controlnet", "hed", "softedge"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class HedImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies HED edge detection to image"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    # safe not supported in controlnet_aux v0.0.3
+    # safe: bool = InputField(default=False, description=FieldDescriptions.safe_mode)
+    scribble: bool = InputField(default=False, description=FieldDescriptions.scribble_mode)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        hed_processor = HEDProcessor()
+        processed_image = hed_processor.run(
+            image,
+            detect_resolution=self.detect_resolution,
+            image_resolution=self.image_resolution,
+            # safe not supported in controlnet_aux v0.0.3
+            # safe=self.safe,
+            scribble=self.scribble,
+        )
+        return processed_image
+
+
+@invocation(
+    "lineart_image_processor",
+    title="Lineart Processor",
+    tags=["controlnet", "lineart"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class LineartImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies line art processing to image"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    coarse: bool = InputField(default=False, description="Whether to use coarse mode")
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        lineart_processor = LineartProcessor()
+        processed_image = lineart_processor.run(
+            image, detect_resolution=self.detect_resolution, image_resolution=self.image_resolution, coarse=self.coarse
+        )
+        return processed_image
+
+
+@invocation(
+    "lineart_anime_image_processor",
+    title="Lineart Anime Processor",
+    tags=["controlnet", "lineart", "anime"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class LineartAnimeImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies line art anime processing to image"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        processor = LineartAnimeProcessor()
+        processed_image = processor.run(
+            image,
+            detect_resolution=self.detect_resolution,
+            image_resolution=self.image_resolution,
+        )
+        return processed_image
+
+
+@invocation(
+    "midas_depth_image_processor",
+    title="Midas Depth Processor",
+    tags=["controlnet", "midas"],
+    category="controlnet",
+    version="1.2.4",
+    classification=Classification.Deprecated,
+)
+class MidasDepthImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies Midas depth processing to image"""
+
+    a_mult: float = InputField(default=2.0, ge=0, description="Midas parameter `a_mult` (a = a_mult * PI)")
+    bg_th: float = InputField(default=0.1, ge=0, description="Midas parameter `bg_th`")
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    # depth_and_normal not supported in controlnet_aux v0.0.3
+    # depth_and_normal: bool = InputField(default=False, description="whether to use depth and normal mode")
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        # TODO: replace from_pretrained() calls with context.models.download_and_cache() (or similar)
+        midas_processor = MidasDetector.from_pretrained("lllyasviel/Annotators")
+        processed_image = midas_processor(
+            image,
+            a=np.pi * self.a_mult,
+            bg_th=self.bg_th,
+            image_resolution=self.image_resolution,
+            detect_resolution=self.detect_resolution,
+            # dept_and_normal not supported in controlnet_aux v0.0.3
+            # depth_and_normal=self.depth_and_normal,
+        )
+        return processed_image
+
+
+@invocation(
+    "normalbae_image_processor",
+    title="Normal BAE Processor",
+    tags=["controlnet"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class NormalbaeImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies NormalBae processing to image"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        normalbae_processor = NormalBaeDetector.from_pretrained("lllyasviel/Annotators")
+        processed_image = normalbae_processor(
+            image, detect_resolution=self.detect_resolution, image_resolution=self.image_resolution
+        )
+        return processed_image
+
+
+@invocation(
+    "mlsd_image_processor",
+    title="MLSD Processor",
+    tags=["controlnet", "mlsd"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class MlsdImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies MLSD processing to image"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    thr_v: float = InputField(default=0.1, ge=0, description="MLSD parameter `thr_v`")
+    thr_d: float = InputField(default=0.1, ge=0, description="MLSD parameter `thr_d`")
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        mlsd_processor = MLSDdetector.from_pretrained("lllyasviel/Annotators")
+        processed_image = mlsd_processor(
+            image,
+            detect_resolution=self.detect_resolution,
+            image_resolution=self.image_resolution,
+            thr_v=self.thr_v,
+            thr_d=self.thr_d,
+        )
+        return processed_image
+
+
+@invocation(
+    "pidi_image_processor",
+    title="PIDI Processor",
+    tags=["controlnet", "pidi"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class PidiImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies PIDI processing to image"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    safe: bool = InputField(default=False, description=FieldDescriptions.safe_mode)
+    scribble: bool = InputField(default=False, description=FieldDescriptions.scribble_mode)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        pidi_processor = PidiNetDetector.from_pretrained("lllyasviel/Annotators")
+        processed_image = pidi_processor(
+            image,
+            detect_resolution=self.detect_resolution,
+            image_resolution=self.image_resolution,
+            safe=self.safe,
+            scribble=self.scribble,
+        )
+        return processed_image
+
+
+@invocation(
+    "content_shuffle_image_processor",
+    title="Content Shuffle Processor",
+    tags=["controlnet", "contentshuffle"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class ContentShuffleImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies content shuffle processing to image"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    h: int = InputField(default=512, ge=0, description="Content shuffle `h` parameter")
+    w: int = InputField(default=512, ge=0, description="Content shuffle `w` parameter")
+    f: int = InputField(default=256, ge=0, description="Content shuffle `f` parameter")
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        content_shuffle_processor = ContentShuffleDetector()
+        processed_image = content_shuffle_processor(
+            image,
+            detect_resolution=self.detect_resolution,
+            image_resolution=self.image_resolution,
+            h=self.h,
+            w=self.w,
+            f=self.f,
+        )
+        return processed_image
+
+
+# should work with controlnet_aux >= 0.0.4 and timm <= 0.6.13
+@invocation(
+    "zoe_depth_image_processor",
+    title="Zoe (Depth) Processor",
+    tags=["controlnet", "zoe", "depth"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class ZoeDepthImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies Zoe depth processing to image"""
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        zoe_depth_processor = ZoeDetector.from_pretrained("lllyasviel/Annotators")
+        processed_image = zoe_depth_processor(image)
+        return processed_image
+
+
+@invocation(
+    "mediapipe_face_processor",
+    title="Mediapipe Face Processor",
+    tags=["controlnet", "mediapipe", "face"],
+    category="controlnet",
+    version="1.2.4",
+    classification=Classification.Deprecated,
+)
+class MediapipeFaceProcessorInvocation(ImageProcessorInvocation):
+    """Applies mediapipe face processing to image"""
+
+    max_faces: int = InputField(default=1, ge=1, description="Maximum number of faces to detect")
+    min_confidence: float = InputField(default=0.5, ge=0, le=1, description="Minimum confidence for face detection")
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        mediapipe_face_processor = MediapipeFaceDetector()
+        processed_image = mediapipe_face_processor(
+            image,
+            max_faces=self.max_faces,
+            min_confidence=self.min_confidence,
+            image_resolution=self.image_resolution,
+            detect_resolution=self.detect_resolution,
+        )
+        return processed_image
+
+
+@invocation(
+    "leres_image_processor",
+    title="Leres (Depth) Processor",
+    tags=["controlnet", "leres", "depth"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class LeresImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies leres processing to image"""
+
+    thr_a: float = InputField(default=0, description="Leres parameter `thr_a`")
+    thr_b: float = InputField(default=0, description="Leres parameter `thr_b`")
+    boost: bool = InputField(default=False, description="Whether to use boost mode")
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        leres_processor = LeresDetector.from_pretrained("lllyasviel/Annotators")
+        processed_image = leres_processor(
+            image,
+            thr_a=self.thr_a,
+            thr_b=self.thr_b,
+            boost=self.boost,
+            detect_resolution=self.detect_resolution,
+            image_resolution=self.image_resolution,
+        )
+        return processed_image
+
+
+@invocation(
+    "tile_image_processor",
+    title="Tile Resample Processor",
+    tags=["controlnet", "tile"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class TileResamplerProcessorInvocation(ImageProcessorInvocation):
+    """Tile resampler processor"""
+
+    # res: int = InputField(default=512, ge=0, le=1024, description="The pixel resolution for each tile")
+    down_sampling_rate: float = InputField(default=1.0, ge=1.0, le=8.0, description="Down sampling rate")
+
+    # tile_resample copied from sd-webui-controlnet/scripts/processor.py
+    def tile_resample(
+        self,
+        np_img: np.ndarray,
+        res=512,  # never used?
+        down_sampling_rate=1.0,
+    ):
+        np_img = HWC3(np_img)
+        if down_sampling_rate < 1.1:
+            return np_img
+        H, W, C = np_img.shape
+        H = int(float(H) / float(down_sampling_rate))
+        W = int(float(W) / float(down_sampling_rate))
+        np_img = cv2.resize(np_img, (W, H), interpolation=cv2.INTER_AREA)
+        return np_img
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        np_img = np.array(image, dtype=np.uint8)
+        processed_np_image = self.tile_resample(
+            np_img,
+            # res=self.tile_size,
+            down_sampling_rate=self.down_sampling_rate,
+        )
+        processed_image = Image.fromarray(processed_np_image)
+        return processed_image
+
+
+@invocation(
+    "segment_anything_processor",
+    title="Segment Anything Processor",
+    tags=["controlnet", "segmentanything"],
+    category="controlnet",
+    version="1.2.4",
+    classification=Classification.Deprecated,
+)
+class SegmentAnythingProcessorInvocation(ImageProcessorInvocation):
+    """Applies segment anything processing to image"""
+
+    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        # segment_anything_processor = SamDetector.from_pretrained("ybelkada/segment-anything", subfolder="checkpoints")
+        segment_anything_processor = SamDetectorReproducibleColors.from_pretrained(
+            "ybelkada/segment-anything", subfolder="checkpoints"
+        )
+        np_img = np.array(image, dtype=np.uint8)
+        processed_image = segment_anything_processor(
+            np_img, image_resolution=self.image_resolution, detect_resolution=self.detect_resolution
+        )
+        return processed_image
+
+
+class SamDetectorReproducibleColors(SamDetector):
+    # overriding SamDetector.show_anns() method to use reproducible colors for segmentation image
+    #     base class show_anns() method randomizes colors,
+    #     which seems to also lead to non-reproducible image generation
+    # so using ADE20k color palette instead
+    def show_anns(self, anns: List[Dict]):
+        if len(anns) == 0:
+            return
+        sorted_anns = sorted(anns, key=(lambda x: x["area"]), reverse=True)
+        h, w = anns[0]["segmentation"].shape
+        final_img = Image.fromarray(np.zeros((h, w, 3), dtype=np.uint8), mode="RGB")
+        palette = ade_palette()
+        for i, ann in enumerate(sorted_anns):
+            m = ann["segmentation"]
+            img = np.empty((m.shape[0], m.shape[1], 3), dtype=np.uint8)
+            # doing modulo just in case number of annotated regions exceeds number of colors in palette
+            ann_color = palette[i % len(palette)]
+            img[:, :] = ann_color
+            final_img.paste(Image.fromarray(img, mode="RGB"), (0, 0), Image.fromarray(np.uint8(m * 255)))
+        return np.array(final_img, dtype=np.uint8)
+
+
+@invocation(
+    "color_map_image_processor",
+    title="Color Map Processor",
+    tags=["controlnet"],
+    category="controlnet",
+    version="1.2.3",
+    classification=Classification.Deprecated,
+)
+class ColorMapImageProcessorInvocation(ImageProcessorInvocation):
+    """Generates a color map from the provided image"""
+
+    color_map_tile_size: int = InputField(default=64, ge=1, description=FieldDescriptions.tile_size)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        np_image = np.array(image, dtype=np.uint8)
+        height, width = np_image.shape[:2]
+
+        width_tile_size = min(self.color_map_tile_size, width)
+        height_tile_size = min(self.color_map_tile_size, height)
+
+        color_map = cv2.resize(
+            np_image,
+            (width // width_tile_size, height // height_tile_size),
+            interpolation=cv2.INTER_CUBIC,
+        )
+        color_map = cv2.resize(color_map, (width, height), interpolation=cv2.INTER_NEAREST)
+        color_map = Image.fromarray(color_map)
+        return color_map
+
+
+DEPTH_ANYTHING_MODEL_SIZES = Literal["large", "base", "small", "small_v2"]
+# DepthAnything V2 Small model is licensed under Apache 2.0 but not the base and large models.
+DEPTH_ANYTHING_MODELS = {
+    "large": "LiheYoung/depth-anything-large-hf",
+    "base": "LiheYoung/depth-anything-base-hf",
+    "small": "LiheYoung/depth-anything-small-hf",
+    "small_v2": "depth-anything/Depth-Anything-V2-Small-hf",
+}
+
+
+@invocation(
+    "depth_anything_image_processor",
+    title="Depth Anything Processor",
+    tags=["controlnet", "depth", "depth anything"],
+    category="controlnet",
+    version="1.1.3",
+    classification=Classification.Deprecated,
+)
+class DepthAnythingImageProcessorInvocation(ImageProcessorInvocation):
+    """Generates a depth map based on the Depth Anything algorithm"""
+
+    model_size: DEPTH_ANYTHING_MODEL_SIZES = InputField(
+        default="small_v2", description="The size of the depth model to use"
+    )
+    resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        def load_depth_anything(model_path: Path):
+            depth_anything_pipeline = pipeline(model=str(model_path), task="depth-estimation", local_files_only=True)
+            assert isinstance(depth_anything_pipeline, DepthEstimationPipeline)
+            return DepthAnythingPipeline(depth_anything_pipeline)
+
+        with self._context.models.load_remote_model(
+            source=DEPTH_ANYTHING_MODELS[self.model_size], loader=load_depth_anything
+        ) as depth_anything_detector:
+            assert isinstance(depth_anything_detector, DepthAnythingPipeline)
+            depth_map = depth_anything_detector.generate_depth(image)
+
+            # Resizing to user target specified size
+            new_height = int(image.size[1] * (self.resolution / image.size[0]))
+            depth_map = depth_map.resize((self.resolution, new_height))
+
+            return depth_map
+
+
+@invocation(
+    "dw_openpose_image_processor",
+    title="DW Openpose Image Processor",
+    tags=["controlnet", "dwpose", "openpose"],
+    category="controlnet",
+    version="1.1.1",
+    classification=Classification.Deprecated,
+)
+class DWOpenposeImageProcessorInvocation(ImageProcessorInvocation):
+    """Generates an openpose pose from an image using DWPose"""
+
+    draw_body: bool = InputField(default=True)
+    draw_face: bool = InputField(default=False)
+    draw_hands: bool = InputField(default=False)
+    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+
+    def run_processor(self, image: Image.Image) -> Image.Image:
+        onnx_det = self._context.models.download_and_cache_model(DWPOSE_MODELS["yolox_l.onnx"])
+        onnx_pose = self._context.models.download_and_cache_model(DWPOSE_MODELS["dw-ll_ucoco_384.onnx"])
+
+        dw_openpose = DWOpenposeDetector(onnx_det=onnx_det, onnx_pose=onnx_pose)
+        processed_image = dw_openpose(
+            image,
+            draw_face=self.draw_face,
+            draw_hands=self.draw_hands,
+            draw_body=self.draw_body,
+            resolution=self.image_resolution,
+        )
+        return processed_image
+
+
+@invocation(
+    "heuristic_resize",
+    title="Heuristic Resize",
+    tags=["image, controlnet"],
+    category="image",
+    version="1.0.1",
+    classification=Classification.Prototype,
+)
+class HeuristicResizeInvocation(BaseInvocation):
+    """Resize an image using a heuristic method. Preserves edge maps."""
+
+    image: ImageField = InputField(description="The image to resize")
+    width: int = InputField(default=512, ge=1, description="The width to resize to (px)")
+    height: int = InputField(default=512, ge=1, description="The height to resize to (px)")
+
+    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(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

@@ -19,8 +19,7 @@ from invokeai.app.invocations.image_to_latents import ImageToLatentsInvocation
 from invokeai.app.invocations.model import UNetField, VAEField
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.model_manager import LoadedModel
-from invokeai.backend.model_manager.config import MainConfigBase
-from invokeai.backend.model_manager.taxonomy import ModelVariantType
+from invokeai.backend.model_manager.config import MainConfigBase, ModelVariantType
 from invokeai.backend.stable_diffusion.diffusers_pipeline import image_resized_to_grid_as_tensor
 
 

invokeai/app/invocations/denoise_latents.py

@@ -22,7 +22,7 @@ from transformers import CLIPVisionModelWithProjection
 
 from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
 from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
-from invokeai.app.invocations.controlnet import ControlField
+from invokeai.app.invocations.controlnet_image_processors import ControlField
 from invokeai.app.invocations.fields import (
     ConditioningField,
     DenoiseMaskField,
@@ -39,8 +39,8 @@ from invokeai.app.invocations.t2i_adapter import T2IAdapterField
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.controlnet_utils import prepare_control_image
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter
+from invokeai.backend.model_manager import BaseModelType, ModelVariantType
 from invokeai.backend.model_manager.config import AnyModelConfig
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelVariantType
 from invokeai.backend.model_patcher import ModelPatcher
 from invokeai.backend.patches.layer_patcher import LayerPatcher
 from invokeai.backend.patches.model_patch_raw import ModelPatchRaw

invokeai/app/invocations/dw_openpose.py

@@ -4,7 +4,7 @@ from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
 from invokeai.app.invocations.fields import ImageField, InputField, WithBoard, WithMetadata
 from invokeai.app.invocations.primitives import ImageOutput
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.image_util.dw_openpose import DWOpenposeDetector
+from invokeai.backend.image_util.dw_openpose import DWOpenposeDetector2
 
 
 @invocation(
@@ -25,20 +25,20 @@ class DWOpenposeDetectionInvocation(BaseInvocation, WithMetadata, WithBoard):
     def invoke(self, context: InvocationContext) -> ImageOutput:
         image = context.images.get_pil(self.image.image_name, "RGB")
 
-        onnx_det_path = context.models.download_and_cache_model(DWOpenposeDetector.get_model_url_det())
-        onnx_pose_path = context.models.download_and_cache_model(DWOpenposeDetector.get_model_url_pose())
+        onnx_det_path = context.models.download_and_cache_model(DWOpenposeDetector2.get_model_url_det())
+        onnx_pose_path = context.models.download_and_cache_model(DWOpenposeDetector2.get_model_url_pose())
 
         loaded_session_det = context.models.load_local_model(
-            onnx_det_path, DWOpenposeDetector.create_onnx_inference_session
+            onnx_det_path, DWOpenposeDetector2.create_onnx_inference_session
         )
         loaded_session_pose = context.models.load_local_model(
-            onnx_pose_path, DWOpenposeDetector.create_onnx_inference_session
+            onnx_pose_path, DWOpenposeDetector2.create_onnx_inference_session
         )
 
         with loaded_session_det as session_det, loaded_session_pose as session_pose:
             assert isinstance(session_det, ort.InferenceSession)
             assert isinstance(session_pose, ort.InferenceSession)
-            detector = DWOpenposeDetector(session_det=session_det, session_pose=session_pose)
+            detector = DWOpenposeDetector2(session_det=session_det, session_pose=session_pose)
             detected_image = detector.run(
                 image,
                 draw_face=self.draw_face,

invokeai/app/invocations/flux_control_lora_loader.py

@@ -1,6 +1,7 @@
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Classification,
     invocation,
     invocation_output,
 )
@@ -24,6 +25,7 @@ class FluxControlLoRALoaderOutput(BaseInvocationOutput):
     tags=["lora", "model", "flux"],
     category="model",
     version="1.1.1",
+    classification=Classification.Prototype,
 )
 class FluxControlLoRALoaderInvocation(BaseInvocation):
     """LoRA model and Image to use with FLUX transformer generation."""

invokeai/app/invocations/flux_controlnet.py

@@ -3,6 +3,7 @@ from pydantic import BaseModel, Field, field_validator, model_validator
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Classification,
     invocation,
     invocation_output,
 )
@@ -51,6 +52,7 @@ class FluxControlNetOutput(BaseInvocationOutput):
     tags=["controlnet", "flux"],
     category="controlnet",
     version="1.0.0",
+    classification=Classification.Prototype,
 )
 class FluxControlNetInvocation(BaseInvocation):
     """Collect FLUX ControlNet info to pass to other nodes."""

invokeai/app/invocations/flux_denoise.py

@@ -10,7 +10,7 @@ from PIL import Image
 from torchvision.transforms.functional import resize as tv_resize
 from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
+from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
 from invokeai.app.invocations.fields import (
     DenoiseMaskField,
     FieldDescriptions,
@@ -49,7 +49,7 @@ from invokeai.backend.flux.sampling_utils import (
     unpack,
 )
 from invokeai.backend.flux.text_conditioning import FluxReduxConditioning, FluxTextConditioning
-from invokeai.backend.model_manager.taxonomy import ModelFormat, ModelVariantType
+from invokeai.backend.model_manager.config import ModelFormat, ModelVariantType
 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
@@ -64,6 +64,7 @@ from invokeai.backend.util.devices import TorchDevice
     tags=["image", "flux"],
     category="image",
     version="3.3.0",
+    classification=Classification.Prototype,
 )
 class FluxDenoiseInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Run denoising process with a FLUX transformer model."""

invokeai/app/invocations/flux_fill.py

@@ -31,7 +31,7 @@ class FluxFillOutput(BaseInvocationOutput):
     tags=["inpaint"],
     category="inpaint",
     version="1.0.0",
-    classification=Classification.Beta,
+    classification=Classification.Prototype,
 )
 class FluxFillInvocation(BaseInvocation):
     """Prepare the FLUX Fill conditioning data."""

invokeai/app/invocations/flux_ip_adapter.py

@@ -4,7 +4,7 @@ from typing import List, Literal, Union
 from pydantic import field_validator, model_validator
 from typing_extensions import Self
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
+from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
 from invokeai.app.invocations.fields import InputField, UIType
 from invokeai.app.invocations.ip_adapter import (
     CLIP_VISION_MODEL_MAP,
@@ -28,6 +28,7 @@ from invokeai.backend.model_manager.config import (
     tags=["ip_adapter", "control"],
     category="ip_adapter",
     version="1.0.0",
+    classification=Classification.Prototype,
 )
 class FluxIPAdapterInvocation(BaseInvocation):
     """Collects FLUX IP-Adapter info to pass to other nodes."""

invokeai/app/invocations/flux_lora_loader.py

@@ -3,13 +3,14 @@ from typing import Optional
 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 CLIPField, LoRAField, ModelIdentifierField, T5EncoderField, TransformerField
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import BaseModelType
+from invokeai.backend.model_manager.config import BaseModelType
 
 
 @invocation_output("flux_lora_loader_output")
@@ -31,6 +32,7 @@ class FluxLoRALoaderOutput(BaseInvocationOutput):
     tags=["lora", "model", "flux"],
     category="model",
     version="1.2.1",
+    classification=Classification.Prototype,
 )
 class FluxLoRALoaderInvocation(BaseInvocation):
     """Apply a LoRA model to a FLUX transformer and/or text encoder."""
@@ -109,6 +111,7 @@ class FluxLoRALoaderInvocation(BaseInvocation):
     tags=["lora", "model", "flux"],
     category="model",
     version="1.3.1",
+    classification=Classification.Prototype,
 )
 class FLUXLoRACollectionLoader(BaseInvocation):
     """Applies a collection of LoRAs to a FLUX transformer."""

invokeai/app/invocations/flux_model_loader.py

@@ -3,6 +3,7 @@ from typing import Literal
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Classification,
     invocation,
     invocation_output,
 )
@@ -16,8 +17,8 @@ from invokeai.app.util.t5_model_identifier import (
 from invokeai.backend.flux.util import max_seq_lengths
 from invokeai.backend.model_manager.config import (
     CheckpointConfigBase,
+    SubModelType,
 )
-from invokeai.backend.model_manager.taxonomy import SubModelType
 
 
 @invocation_output("flux_model_loader_output")
@@ -40,6 +41,7 @@ class FluxModelLoaderOutput(BaseInvocationOutput):
     tags=["model", "flux"],
     category="model",
     version="1.0.6",
+    classification=Classification.Prototype,
 )
 class FluxModelLoaderInvocation(BaseInvocation):
     """Loads a flux base model, outputting its submodels."""

invokeai/app/invocations/flux_redux.py

@@ -23,8 +23,7 @@ from invokeai.app.invocations.primitives import ImageField
 from invokeai.app.services.model_records.model_records_base import ModelRecordChanges
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.flux.redux.flux_redux_model import FluxReduxModel
-from invokeai.backend.model_manager import BaseModelType, ModelType
-from invokeai.backend.model_manager.config import AnyModelConfig
+from invokeai.backend.model_manager.config import AnyModelConfig, BaseModelType, ModelType
 from invokeai.backend.model_manager.starter_models import siglip
 from invokeai.backend.sig_lip.sig_lip_pipeline import SigLipPipeline
 from invokeai.backend.util.devices import TorchDevice
@@ -45,7 +44,7 @@ class FluxReduxOutput(BaseInvocationOutput):
     tags=["ip_adapter", "control"],
     category="ip_adapter",
     version="2.0.0",
-    classification=Classification.Beta,
+    classification=Classification.Prototype,
 )
 class FluxReduxInvocation(BaseInvocation):
     """Runs a FLUX Redux model to generate a conditioning tensor."""

invokeai/app/invocations/flux_text_encoder.py

@@ -4,7 +4,7 @@ from typing import Iterator, Literal, Optional, Tuple
 import torch
 from transformers import CLIPTextModel, CLIPTokenizer, T5EncoderModel, T5Tokenizer, T5TokenizerFast
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
+from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
 from invokeai.app.invocations.fields import (
     FieldDescriptions,
     FluxConditioningField,
@@ -17,7 +17,7 @@ from invokeai.app.invocations.model import CLIPField, T5EncoderField
 from invokeai.app.invocations.primitives import FluxConditioningOutput
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.flux.modules.conditioner import HFEncoder
-from invokeai.backend.model_manager import ModelFormat
+from invokeai.backend.model_manager.config import ModelFormat
 from invokeai.backend.patches.layer_patcher import LayerPatcher
 from invokeai.backend.patches.lora_conversions.flux_lora_constants import FLUX_LORA_CLIP_PREFIX, FLUX_LORA_T5_PREFIX
 from invokeai.backend.patches.model_patch_raw import ModelPatchRaw
@@ -30,6 +30,7 @@ from invokeai.backend.stable_diffusion.diffusion.conditioning_data import Condit
     tags=["prompt", "conditioning", "flux"],
     category="conditioning",
     version="1.1.2",
+    classification=Classification.Prototype,
 )
 class FluxTextEncoderInvocation(BaseInvocation):
     """Encodes and preps a prompt for a flux image."""

invokeai/app/invocations/ideal_size.py

@@ -6,7 +6,7 @@ from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
 from invokeai.app.invocations.fields import FieldDescriptions, InputField, OutputField
 from invokeai.app.invocations.model import UNetField
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import BaseModelType
+from invokeai.backend.model_manager.config import BaseModelType
 
 
 @invocation_output("ideal_size_output")

invokeai/app/invocations/image.py

@@ -355,6 +355,7 @@ class ImageBlurInvocation(BaseInvocation, WithMetadata, WithBoard):
     tags=["image", "unsharp_mask"],
     category="image",
     version="1.2.2",
+    classification=Classification.Beta,
 )
 class UnsharpMaskInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Applies an unsharp mask filter to an image"""
@@ -1089,13 +1090,12 @@ class CanvasV2MaskAndCropInvocation(BaseInvocation, WithMetadata, WithBoard):
 
 
 @invocation(
-    "expand_mask_with_fade", title="Expand Mask with Fade", tags=["image", "mask"], category="image", version="1.0.1"
+    "expand_mask_with_fade", title="Expand Mask with Fade", tags=["image", "mask"], category="image", version="1.0.0"
 )
 class ExpandMaskWithFadeInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Expands a mask with a fade effect. The mask uses black to indicate areas to keep from the generated image and white for areas to discard.
     The mask is thresholded to create a binary mask, and then a distance transform is applied to create a fade effect.
     The fade size is specified in pixels, and the mask is expanded by that amount. The result is a mask with a smooth transition from black to white.
-    If the fade size is 0, the mask is returned as-is.
     """
 
     mask: ImageField = InputField(description="The mask to expand")
@@ -1105,11 +1105,6 @@ class ExpandMaskWithFadeInvocation(BaseInvocation, WithMetadata, WithBoard):
     def invoke(self, context: InvocationContext) -> ImageOutput:
         pil_mask = context.images.get_pil(self.mask.image_name, mode="L")
 
-        if self.fade_size_px == 0:
-            # If the fade size is 0, just return the mask as-is.
-            image_dto = context.images.save(image=pil_mask, image_category=ImageCategory.MASK)
-            return ImageOutput.build(image_dto)
-
         np_mask = numpy.array(pil_mask)
 
         # Threshold the mask to create a binary mask - 0 for black, 255 for white
@@ -1147,21 +1142,8 @@ class ExpandMaskWithFadeInvocation(BaseInvocation, WithMetadata, WithBoard):
         coeffs = numpy.polyfit(x_control, y_control, 3)
         poly = numpy.poly1d(coeffs)
 
-        # Evaluate the polynomial
-        feather = poly(d_norm)
-
-        # The polynomial fit isn't perfect. Points beyond the fade distance are likely to be slightly less than 1.0,
-        # even though the control points indicate that they should be exactly 1.0. This is due to the nature of the
-        # polynomial fit, which is a best approximation of the control points but not an exact match.
-
-        # When this occurs, the area outside the mask and fade-out will not be 100% transparent. For example, it may
-        # have an alpha value of 1 instead of 0. So we must force pixels at or beyond the fade distance to exactly 1.0.
-
-        # Force pixels at or beyond the fade distance to exactly 1.0
-        feather = numpy.where(d_norm >= 1.0, 1.0, feather)
-
-        # Clip any other values to ensure they're in the valid range [0,1]
-        feather = numpy.clip(feather, 0, 1)
+        # Evaluate and clip the smooth mapping
+        feather = numpy.clip(poly(d_norm), 0, 1)
 
         # Build final image.
         np_result = numpy.where(black_mask == 1, 0, (feather * 255).astype(numpy.uint8))
@@ -1283,6 +1265,7 @@ class ImageNoiseInvocation(BaseInvocation, WithMetadata, WithBoard):
     category="image",
     version="1.0.0",
     tags=["image", "crop"],
+    classification=Classification.Beta,
 )
 class CropImageToBoundingBoxInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Crop an image to the given bounding box. If the bounding box is omitted, the image is cropped to the non-transparent pixels."""
@@ -1309,6 +1292,7 @@ class CropImageToBoundingBoxInvocation(BaseInvocation, WithMetadata, WithBoard):
     category="image",
     version="1.0.0",
     tags=["image", "crop"],
+    classification=Classification.Beta,
 )
 class PasteImageIntoBoundingBoxInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Paste the source image into the target image at the given bounding box.

invokeai/app/invocations/ip_adapter.py

@@ -13,8 +13,10 @@ from invokeai.app.services.model_records.model_records_base import ModelRecordCh
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
+    BaseModelType,
     IPAdapterCheckpointConfig,
     IPAdapterInvokeAIConfig,
+    ModelType,
 )
 from invokeai.backend.model_manager.starter_models import (
     StarterModel,
@@ -22,7 +24,6 @@ from invokeai.backend.model_manager.starter_models import (
     ip_adapter_sd_image_encoder,
     ip_adapter_sdxl_image_encoder,
 )
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
 
 
 class IPAdapterField(BaseModel):

invokeai/app/invocations/llava_onevision_vllm.py

@@ -4,7 +4,7 @@ import torch
 from PIL.Image import Image
 from pydantic import field_validator
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
+from invokeai.app.invocations.baseinvocation import BaseInvocation, 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
@@ -13,14 +13,7 @@ from invokeai.backend.llava_onevision_model import LlavaOnevisionModel
 from invokeai.backend.util.devices import TorchDevice
 
 
-@invocation(
-    "llava_onevision_vllm",
-    title="LLaVA OneVision VLLM",
-    tags=["vllm"],
-    category="vllm",
-    version="1.0.0",
-    classification=Classification.Beta,
-)
+@invocation("llava_onevision_vllm", title="LLaVA OneVision VLLM", tags=["vllm"], category="vllm", version="1.0.0")
 class LlavaOnevisionVllmInvocation(BaseInvocation):
     """Run a LLaVA OneVision VLLM model."""
 

invokeai/app/invocations/mask.py

@@ -4,6 +4,7 @@ from PIL import Image
 
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
+    Classification,
     InvocationContext,
     invocation,
 )
@@ -57,6 +58,7 @@ class RectangleMaskInvocation(BaseInvocation, WithMetadata):
     tags=["conditioning"],
     category="conditioning",
     version="1.0.0",
+    classification=Classification.Beta,
 )
 class AlphaMaskToTensorInvocation(BaseInvocation):
     """Convert a mask image to a tensor. Opaque regions are 1 and transparent regions are 0."""
@@ -85,6 +87,7 @@ class AlphaMaskToTensorInvocation(BaseInvocation):
     tags=["conditioning"],
     category="conditioning",
     version="1.1.0",
+    classification=Classification.Beta,
 )
 class InvertTensorMaskInvocation(BaseInvocation):
     """Inverts a tensor mask."""
@@ -231,6 +234,7 @@ WHITE = ColorField(r=255, g=255, b=255, a=255)
     tags=["mask"],
     category="mask",
     version="1.0.0",
+    classification=Classification.Beta,
 )
 class GetMaskBoundingBoxInvocation(BaseInvocation):
     """Gets the bounding box of the given mask image."""

invokeai/app/invocations/metadata_linked.py

@@ -14,7 +14,7 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.controlnet import ControlField, ControlNetInvocation
+from invokeai.app.invocations.controlnet_image_processors import ControlField, ControlNetInvocation
 from invokeai.app.invocations.denoise_latents import DenoiseLatentsInvocation
 from invokeai.app.invocations.fields import (
     FieldDescriptions,
@@ -43,7 +43,7 @@ from invokeai.app.invocations.primitives import BooleanOutput, FloatOutput, Inte
 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
-from invokeai.backend.model_manager.taxonomy import ModelType, SubModelType
+from invokeai.backend.model_manager.config import ModelType, SubModelType
 from invokeai.backend.stable_diffusion.schedulers.schedulers import SCHEDULER_NAME_VALUES
 from invokeai.version import __version__
 

invokeai/app/invocations/model.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, Field
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Classification,
     invocation,
     invocation_output,
 )
@@ -14,8 +15,10 @@ from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.shared.models import FreeUConfig
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
+    BaseModelType,
+    ModelType,
+    SubModelType,
 )
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType, SubModelType
 
 
 class ModelIdentifierField(BaseModel):
@@ -123,6 +126,7 @@ class ModelIdentifierOutput(BaseInvocationOutput):
     tags=["model"],
     category="model",
     version="1.0.1",
+    classification=Classification.Prototype,
 )
 class ModelIdentifierInvocation(BaseInvocation):
     """Selects any model, outputting it its identifier. Be careful with this one! The identifier will be accepted as

invokeai/app/invocations/sd3_denoise.py

@@ -6,7 +6,7 @@ from diffusers.models.transformers.transformer_sd3 import SD3Transformer2DModel
 from torchvision.transforms.functional import resize as tv_resize
 from tqdm import tqdm
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
+from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
 from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
 from invokeai.app.invocations.fields import (
     DenoiseMaskField,
@@ -23,7 +23,7 @@ from invokeai.app.invocations.primitives import LatentsOutput
 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.model_manager.config import BaseModelType
 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
@@ -36,6 +36,7 @@ from invokeai.backend.util.devices import TorchDevice
     tags=["image", "sd3"],
     category="image",
     version="1.1.1",
+    classification=Classification.Prototype,
 )
 class SD3DenoiseInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Run denoising process with a SD3 model."""

invokeai/app/invocations/sd3_image_to_latents.py

@@ -2,7 +2,7 @@ import einops
 import torch
 from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
+from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
 from invokeai.app.invocations.fields import (
     FieldDescriptions,
     ImageField,
@@ -25,6 +25,7 @@ from invokeai.backend.util.devices import TorchDevice
     tags=["image", "latents", "vae", "i2l", "sd3"],
     category="image",
     version="1.0.1",
+    classification=Classification.Prototype,
 )
 class SD3ImageToLatentsInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Generates latents from an image."""

invokeai/app/invocations/sd3_model_loader.py

@@ -3,6 +3,7 @@ from typing import Optional
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Classification,
     invocation,
     invocation_output,
 )
@@ -13,7 +14,7 @@ from invokeai.app.util.t5_model_identifier import (
     preprocess_t5_encoder_model_identifier,
     preprocess_t5_tokenizer_model_identifier,
 )
-from invokeai.backend.model_manager.taxonomy import SubModelType
+from invokeai.backend.model_manager.config import SubModelType
 
 
 @invocation_output("sd3_model_loader_output")
@@ -33,6 +34,7 @@ class Sd3ModelLoaderOutput(BaseInvocationOutput):
     tags=["model", "sd3"],
     category="model",
     version="1.0.1",
+    classification=Classification.Prototype,
 )
 class Sd3ModelLoaderInvocation(BaseInvocation):
     """Loads a SD3 base model, outputting its submodels."""

invokeai/app/invocations/sd3_text_encoder.py

@@ -11,12 +11,12 @@ from transformers import (
     T5TokenizerFast,
 )
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
+from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
 from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField
 from invokeai.app.invocations.model import CLIPField, T5EncoderField
 from invokeai.app.invocations.primitives import SD3ConditioningOutput
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import ModelFormat
+from invokeai.backend.model_manager.config import ModelFormat
 from invokeai.backend.patches.layer_patcher import LayerPatcher
 from invokeai.backend.patches.lora_conversions.flux_lora_constants import FLUX_LORA_CLIP_PREFIX
 from invokeai.backend.patches.model_patch_raw import ModelPatchRaw
@@ -33,6 +33,7 @@ SD3_T5_MAX_SEQ_LEN = 256
     tags=["prompt", "conditioning", "sd3"],
     category="conditioning",
     version="1.0.1",
+    classification=Classification.Prototype,
 )
 class Sd3TextEncoderInvocation(BaseInvocation):
     """Encodes and preps a prompt for a SD3 image."""

invokeai/app/invocations/sdxl.py

@@ -2,7 +2,7 @@ from invokeai.app.invocations.baseinvocation import BaseInvocation, BaseInvocati
 from invokeai.app.invocations.fields import FieldDescriptions, InputField, OutputField, UIType
 from invokeai.app.invocations.model import CLIPField, ModelIdentifierField, UNetField, VAEField
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import SubModelType
+from invokeai.backend.model_manager import SubModelType
 
 
 @invocation_output("sdxl_model_loader_output")

invokeai/app/invocations/tiled_multi_diffusion_denoise_latents.py

@@ -7,9 +7,9 @@ from diffusers.models.unets.unet_2d_condition import UNet2DConditionModel
 from diffusers.schedulers.scheduling_utils import SchedulerMixin
 from pydantic import field_validator
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
+from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
 from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
-from invokeai.app.invocations.controlnet import ControlField
+from invokeai.app.invocations.controlnet_image_processors import ControlField
 from invokeai.app.invocations.denoise_latents import DenoiseLatentsInvocation, get_scheduler
 from invokeai.app.invocations.fields import (
     ConditioningField,
@@ -56,6 +56,7 @@ def crop_controlnet_data(control_data: ControlNetData, latent_region: TBLR) -> C
     title="Tiled Multi-Diffusion Denoise - SD1.5, SDXL",
     tags=["upscale", "denoise"],
     category="latents",
+    classification=Classification.Beta,
     version="1.0.1",
 )
 class TiledMultiDiffusionDenoiseLatents(BaseInvocation):

invokeai/app/invocations/tiles.py

@@ -7,6 +7,7 @@ from pydantic import BaseModel
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Classification,
     invocation,
     invocation_output,
 )
@@ -39,6 +40,7 @@ class CalculateImageTilesOutput(BaseInvocationOutput):
     tags=["tiles"],
     category="tiles",
     version="1.0.1",
+    classification=Classification.Beta,
 )
 class CalculateImageTilesInvocation(BaseInvocation):
     """Calculate the coordinates and overlaps of tiles that cover a target image shape."""
@@ -72,6 +74,7 @@ class CalculateImageTilesInvocation(BaseInvocation):
     tags=["tiles"],
     category="tiles",
     version="1.1.1",
+    classification=Classification.Beta,
 )
 class CalculateImageTilesEvenSplitInvocation(BaseInvocation):
     """Calculate the coordinates and overlaps of tiles that cover a target image shape."""
@@ -114,6 +117,7 @@ class CalculateImageTilesEvenSplitInvocation(BaseInvocation):
     tags=["tiles"],
     category="tiles",
     version="1.0.1",
+    classification=Classification.Beta,
 )
 class CalculateImageTilesMinimumOverlapInvocation(BaseInvocation):
     """Calculate the coordinates and overlaps of tiles that cover a target image shape."""
@@ -164,6 +168,7 @@ class TileToPropertiesOutput(BaseInvocationOutput):
     tags=["tiles"],
     category="tiles",
     version="1.0.1",
+    classification=Classification.Beta,
 )
 class TileToPropertiesInvocation(BaseInvocation):
     """Split a Tile into its individual properties."""
@@ -196,6 +201,7 @@ class PairTileImageOutput(BaseInvocationOutput):
     tags=["tiles"],
     category="tiles",
     version="1.0.1",
+    classification=Classification.Beta,
 )
 class PairTileImageInvocation(BaseInvocation):
     """Pair an image with its tile properties."""
@@ -224,6 +230,7 @@ BLEND_MODES = Literal["Linear", "Seam"]
     tags=["tiles"],
     category="tiles",
     version="1.1.1",
+    classification=Classification.Beta,
 )
 class MergeTilesToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Merge multiple tile images into a single image."""

invokeai/app/run_app.py

@@ -41,15 +41,16 @@ def run_app() -> None:
     )
 
     # Find an open port, and modify the config accordingly.
-    first_open_port = find_open_port(app_config.port)
-    if app_config.port != first_open_port:
-        orig_config_port = app_config.port
-        app_config.port = first_open_port
+    orig_config_port = app_config.port
+    app_config.port = find_open_port(app_config.port)
+    if orig_config_port != app_config.port:
         logger.warning(f"Port {orig_config_port} is already in use. Using port {app_config.port}.")
 
     # Miscellaneous startup tasks.
     apply_monkeypatches()
     register_mime_types()
+    if app_config.dev_reload:
+        enable_dev_reload()
     check_cudnn(logger)
 
     # Initialize the app and event loop.
@@ -60,11 +61,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)
 
-    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.
-        enable_dev_reload(custom_nodes_path=app_config.custom_nodes_path)
-
     # Start the server.
     config = uvicorn.Config(
         app=app,

invokeai/app/services/events/events_base.py

@@ -44,8 +44,7 @@ if TYPE_CHECKING:
         SessionQueueItem,
         SessionQueueStatus,
     )
-    from invokeai.backend.model_manager import SubModelType
-    from invokeai.backend.model_manager.config import AnyModelConfig
+    from invokeai.backend.model_manager.config import AnyModelConfig, SubModelType
 
 
 class EventServiceBase:

invokeai/app/services/events/events_common.py

@@ -16,8 +16,7 @@ from invokeai.app.services.session_queue.session_queue_common import (
 )
 from invokeai.app.services.shared.graph import AnyInvocation, AnyInvocationOutput
 from invokeai.app.util.misc import get_timestamp
-from invokeai.backend.model_manager import SubModelType
-from invokeai.backend.model_manager.config import AnyModelConfig
+from invokeai.backend.model_manager.config import AnyModelConfig, SubModelType
 
 if TYPE_CHECKING:
     from invokeai.app.services.download.download_base import DownloadJob

invokeai/app/services/model_install/model_install_common.py

@@ -10,9 +10,9 @@ from typing_extensions import Annotated
 
 from invokeai.app.services.download import DownloadJob, MultiFileDownloadJob
 from invokeai.app.services.model_records import ModelRecordChanges
-from invokeai.backend.model_manager.config import AnyModelConfig
+from invokeai.backend.model_manager import AnyModelConfig, ModelRepoVariant
+from invokeai.backend.model_manager.config import ModelSourceType
 from invokeai.backend.model_manager.metadata import AnyModelRepoMetadata
-from invokeai.backend.model_manager.taxonomy import ModelRepoVariant, ModelSourceType
 
 
 class InstallStatus(str, Enum):

invokeai/app/services/model_install/model_install_default.py

@@ -39,6 +39,8 @@ from invokeai.backend.model_manager.config import (
     CheckpointConfigBase,
     InvalidModelConfigException,
     ModelConfigBase,
+    ModelRepoVariant,
+    ModelSourceType,
 )
 from invokeai.backend.model_manager.legacy_probe import ModelProbe
 from invokeai.backend.model_manager.metadata import (
@@ -50,7 +52,6 @@ from invokeai.backend.model_manager.metadata import (
 )
 from invokeai.backend.model_manager.metadata.metadata_base import HuggingFaceMetadata
 from invokeai.backend.model_manager.search import ModelSearch
-from invokeai.backend.model_manager.taxonomy import ModelRepoVariant, ModelSourceType
 from invokeai.backend.util import InvokeAILogger
 from invokeai.backend.util.catch_sigint import catch_sigint
 from invokeai.backend.util.devices import TorchDevice

invokeai/app/services/model_load/model_load_base.py

@@ -5,10 +5,9 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Callable, Optional
 
-from invokeai.backend.model_manager.config import AnyModelConfig
+from invokeai.backend.model_manager import AnyModel, AnyModelConfig, SubModelType
 from invokeai.backend.model_manager.load import LoadedModel, LoadedModelWithoutConfig
 from invokeai.backend.model_manager.load.model_cache.model_cache import ModelCache
-from invokeai.backend.model_manager.taxonomy import AnyModel, SubModelType
 
 
 class ModelLoadServiceBase(ABC):

invokeai/app/services/model_load/model_load_default.py

@@ -11,7 +11,7 @@ from torch import load as torch_load
 from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.app.services.invoker import Invoker
 from invokeai.app.services.model_load.model_load_base import ModelLoadServiceBase
-from invokeai.backend.model_manager.config import AnyModelConfig
+from invokeai.backend.model_manager import AnyModel, AnyModelConfig, SubModelType
 from invokeai.backend.model_manager.load import (
     LoadedModel,
     LoadedModelWithoutConfig,
@@ -20,7 +20,6 @@ from invokeai.backend.model_manager.load import (
 )
 from invokeai.backend.model_manager.load.model_cache.model_cache import ModelCache
 from invokeai.backend.model_manager.load.model_loaders.generic_diffusers import GenericDiffusersLoader
-from invokeai.backend.model_manager.taxonomy import AnyModel, SubModelType
 from invokeai.backend.util.devices import TorchDevice
 from invokeai.backend.util.logging import InvokeAILogger
 

invokeai/app/services/model_manager/__init__.py

@@ -1,12 +1,16 @@
 """Initialization file for model manager service."""
 
 from invokeai.app.services.model_manager.model_manager_default import ModelManagerService, ModelManagerServiceBase
-from invokeai.backend.model_manager import AnyModelConfig
+from invokeai.backend.model_manager import AnyModel, AnyModelConfig, BaseModelType, ModelType, SubModelType
 from invokeai.backend.model_manager.load import LoadedModel
 
 __all__ = [
     "ModelManagerServiceBase",
     "ModelManagerService",
+    "AnyModel",
     "AnyModelConfig",
+    "BaseModelType",
+    "ModelType",
+    "SubModelType",
     "LoadedModel",
 ]

invokeai/app/services/model_records/model_records_base.py

@@ -14,12 +14,10 @@ from invokeai.app.services.shared.pagination import PaginatedResults
 from invokeai.app.util.model_exclude_null import BaseModelExcludeNull
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
-    ControlAdapterDefaultSettings,
-    MainModelDefaultSettings,
-)
-from invokeai.backend.model_manager.taxonomy import (
     BaseModelType,
     ClipVariantType,
+    ControlAdapterDefaultSettings,
+    MainModelDefaultSettings,
     ModelFormat,
     ModelSourceType,
     ModelType,

invokeai/app/services/model_records/model_records_sql.py

@@ -60,9 +60,11 @@ from invokeai.app.services.shared.pagination import PaginatedResults
 from invokeai.app.services.shared.sqlite.sqlite_database import SqliteDatabase
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
+    BaseModelType,
     ModelConfigFactory,
+    ModelFormat,
+    ModelType,
 )
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelFormat, ModelType
 
 
 class ModelRecordServiceSQL(ModelRecordServiceBase):
@@ -302,10 +304,7 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
                 # We catch this error so that the app can still run if there are invalid model configs in the database.
                 # One reason that an invalid model config might be in the database is if someone had to rollback from a
                 # newer version of the app that added a new model type.
-                row_data = f"{row[0][:64]}..." if len(row[0]) > 64 else row[0]
-                self._logger.warning(
-                    f"Found an invalid model config in the database. Ignoring this model. ({row_data})"
-                )
+                self._logger.warning(f"Found an invalid model config in the database. Ignoring this model. ({row[0]})")
             else:
                 results.append(model_config)
 

invokeai/app/services/object_serializer/object_serializer_disk.py

@@ -21,16 +21,10 @@ class ObjectSerializerDisk(ObjectSerializerBase[T]):
     """Disk-backed storage for arbitrary python objects. Serialization is handled by `torch.save` and `torch.load`.
 
     :param output_dir: The folder where the serialized objects will be stored
-    :param safe_globals: A list of types to be added to the safe globals for torch serialization
     :param ephemeral: If True, objects will be stored in a temporary directory inside the given output_dir and cleaned up on exit
     """
 
-    def __init__(
-        self,
-        output_dir: Path,
-        safe_globals: list[type],
-        ephemeral: bool = False,
-    ) -> None:
+    def __init__(self, output_dir: Path, ephemeral: bool = False):
         super().__init__()
         self._ephemeral = ephemeral
         self._base_output_dir = output_dir
@@ -48,8 +42,6 @@ class ObjectSerializerDisk(ObjectSerializerBase[T]):
         self._output_dir = Path(self._tempdir.name) if self._tempdir else self._base_output_dir
         self.__obj_class_name: Optional[str] = None
 
-        torch.serialization.add_safe_globals(safe_globals) if safe_globals else None
-
     def load(self, name: str) -> T:
         file_path = self._get_path(name)
         try:

invokeai/app/services/session_queue/session_queue_common.py

@@ -201,12 +201,6 @@ def get_workflow(queue_item_dict: dict) -> Optional[WorkflowWithoutID]:
     return None
 
 
-class FieldIdentifier(BaseModel):
-    kind: Literal["input", "output"] = Field(description="The kind of field")
-    node_id: str = Field(description="The ID of the node")
-    field_name: str = Field(description="The name of the field")
-
-
 class SessionQueueItemWithoutGraph(BaseModel):
     """Session queue item without the full graph. Used for serialization."""
 
@@ -243,20 +237,6 @@ class SessionQueueItemWithoutGraph(BaseModel):
     retried_from_item_id: Optional[int] = Field(
         default=None, description="The item_id of the queue item that this item was retried from"
     )
-    is_api_validation_run: bool = Field(
-        default=False,
-        description="Whether this queue item is an API validation run.",
-    )
-    published_workflow_id: Optional[str] = Field(
-        default=None,
-        description="The ID of the published workflow associated with this queue item",
-    )
-    api_input_fields: Optional[list[FieldIdentifier]] = Field(
-        default=None, description="The fields that were used as input to the API"
-    )
-    api_output_fields: Optional[list[FieldIdentifier]] = Field(
-        default=None, description="The nodes that were used as output from the API"
-    )
 
     @classmethod
     def queue_item_dto_from_dict(cls, queue_item_dict: dict) -> "SessionQueueItemDTO":

invokeai/app/services/shared/graph.py

@@ -21,7 +21,6 @@ from invokeai.app.invocations import *  # noqa: F401 F403
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
-    InvocationRegistry,
     invocation,
     invocation_output,
 )
@@ -284,7 +283,7 @@ class AnyInvocation(BaseInvocation):
     @classmethod
     def __get_pydantic_core_schema__(cls, source_type: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
         def validate_invocation(v: Any) -> "AnyInvocation":
-            return InvocationRegistry.get_invocation_typeadapter().validate_python(v)
+            return BaseInvocation.get_typeadapter().validate_python(v)
 
         return core_schema.no_info_plain_validator_function(validate_invocation)
 
@@ -295,7 +294,7 @@ class AnyInvocation(BaseInvocation):
         # Nodes are too powerful, we have to make our own OpenAPI schema manually
         # No but really, because the schema is dynamic depending on loaded nodes, we need to generate it manually
         oneOf: list[dict[str, str]] = []
-        names = [i.__name__ for i in InvocationRegistry.get_invocation_classes()]
+        names = [i.__name__ for i in BaseInvocation.get_invocations()]
         for name in sorted(names):
             oneOf.append({"$ref": f"#/components/schemas/{name}"})
         return {"oneOf": oneOf}
@@ -305,7 +304,7 @@ class AnyInvocationOutput(BaseInvocationOutput):
     @classmethod
     def __get_pydantic_core_schema__(cls, source_type: Any, handler: GetCoreSchemaHandler):
         def validate_invocation_output(v: Any) -> "AnyInvocationOutput":
-            return InvocationRegistry.get_output_typeadapter().validate_python(v)
+            return BaseInvocationOutput.get_typeadapter().validate_python(v)
 
         return core_schema.no_info_plain_validator_function(validate_invocation_output)
 
@@ -317,7 +316,7 @@ class AnyInvocationOutput(BaseInvocationOutput):
         # No but really, because the schema is dynamic depending on loaded nodes, we need to generate it manually
 
         oneOf: list[dict[str, str]] = []
-        names = [i.__name__ for i in InvocationRegistry.get_output_classes()]
+        names = [i.__name__ for i in BaseInvocationOutput.get_outputs()]
         for name in sorted(names):
             oneOf.append({"$ref": f"#/components/schemas/{name}"})
         return {"oneOf": oneOf}

invokeai/app/services/shared/invocation_context.py

@@ -20,10 +20,14 @@ from invokeai.app.services.session_processor.session_processor_common import Pro
 from invokeai.app.services.shared.sqlite.sqlite_common import SQLiteDirection
 from invokeai.app.util.step_callback import flux_step_callback, stable_diffusion_step_callback
 from invokeai.backend.model_manager.config import (
+    AnyModel,
     AnyModelConfig,
+    BaseModelType,
+    ModelFormat,
+    ModelType,
+    SubModelType,
 )
 from invokeai.backend.model_manager.load.load_base import LoadedModel, LoadedModelWithoutConfig
-from invokeai.backend.model_manager.taxonomy import AnyModel, BaseModelType, ModelFormat, ModelType, SubModelType
 from invokeai.backend.stable_diffusion.diffusers_pipeline import PipelineIntermediateState
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import ConditioningFieldData
 

invokeai/app/services/workflow_records/workflow_records_base.py

@@ -47,7 +47,6 @@ class WorkflowRecordsStorageBase(ABC):
         query: Optional[str],
         tags: Optional[list[str]],
         has_been_opened: Optional[bool],
-        is_published: Optional[bool],
     ) -> PaginatedResults[WorkflowRecordListItemDTO]:
         """Gets many workflows."""
         pass
@@ -57,7 +56,6 @@ class WorkflowRecordsStorageBase(ABC):
         self,
         categories: list[WorkflowCategory],
         has_been_opened: Optional[bool] = None,
-        is_published: Optional[bool] = None,
     ) -> dict[str, int]:
         """Gets a dictionary of counts for each of the provided categories."""
         pass
@@ -68,7 +66,6 @@ class WorkflowRecordsStorageBase(ABC):
         tags: list[str],
         categories: Optional[list[WorkflowCategory]] = None,
         has_been_opened: Optional[bool] = None,
-        is_published: Optional[bool] = None,
     ) -> dict[str, int]:
         """Gets a dictionary of counts for each of the provided tags."""
         pass

invokeai/app/services/workflow_records/workflow_records_common.py

@@ -67,7 +67,6 @@ class WorkflowWithoutID(BaseModel):
     # This is typed as optional to prevent errors when pulling workflows from the DB. The frontend adds a default form if
     # it is None.
     form: dict[str, JsonValue] | None = Field(default=None, description="The form of the workflow.")
-    is_published: bool | None = Field(default=None, description="Whether the workflow is published or not.")
 
     model_config = ConfigDict(extra="ignore")
 
@@ -102,7 +101,6 @@ class WorkflowRecordDTOBase(BaseModel):
     opened_at: Optional[Union[datetime.datetime, str]] = Field(
         default=None, description="The opened timestamp of the workflow."
     )
-    is_published: bool | None = Field(default=None, description="Whether the workflow is published or not.")
 
 
 class WorkflowRecordDTO(WorkflowRecordDTOBase):

invokeai/app/services/workflow_records/workflow_records_sqlite.py

@@ -119,7 +119,6 @@ class SqliteWorkflowRecordsStorage(WorkflowRecordsStorageBase):
         query: Optional[str] = None,
         tags: Optional[list[str]] = None,
         has_been_opened: Optional[bool] = None,
-        is_published: Optional[bool] = None,
     ) -> PaginatedResults[WorkflowRecordListItemDTO]:
         # sanitize!
         assert order_by in WorkflowRecordOrderBy
@@ -242,7 +241,6 @@ class SqliteWorkflowRecordsStorage(WorkflowRecordsStorageBase):
         tags: list[str],
         categories: Optional[list[WorkflowCategory]] = None,
         has_been_opened: Optional[bool] = None,
-        is_published: Optional[bool] = None,
     ) -> dict[str, int]:
         if not tags:
             return {}
@@ -294,7 +292,6 @@ class SqliteWorkflowRecordsStorage(WorkflowRecordsStorageBase):
         self,
         categories: list[WorkflowCategory],
         has_been_opened: Optional[bool] = None,
-        is_published: Optional[bool] = None,
     ) -> dict[str, int]:
         cursor = self._conn.cursor()
         result: dict[str, int] = {}

invokeai/app/util/custom_openapi.py

@@ -4,10 +4,7 @@ from fastapi import FastAPI
 from fastapi.openapi.utils import get_openapi
 from pydantic.json_schema import models_json_schema
 
-from invokeai.app.invocations.baseinvocation import (
-    InvocationRegistry,
-    UIConfigBase,
-)
+from invokeai.app.invocations.baseinvocation import BaseInvocation, BaseInvocationOutput, UIConfigBase
 from invokeai.app.invocations.fields import InputFieldJSONSchemaExtra, OutputFieldJSONSchemaExtra
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.services.events.events_common import EventBase
@@ -59,14 +56,14 @@ def get_openapi_func(
         invocation_output_map_required: list[str] = []
 
         # 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():
+        for output in BaseInvocationOutput.get_outputs():
             json_schema = output.model_json_schema(mode="serialization", ref_template="#/components/schemas/{model}")
             move_defs_to_top_level(openapi_schema, json_schema)
             openapi_schema["components"]["schemas"][output.__name__] = json_schema
 
         # Technically, invocations are added to the schema by pydantic, but we still need to manually set their output
         # property, so we'll just do it all manually.
-        for invocation in InvocationRegistry.get_invocation_classes():
+        for invocation in BaseInvocation.get_invocations():
             json_schema = invocation.model_json_schema(
                 mode="serialization", ref_template="#/components/schemas/{model}"
             )

invokeai/app/util/startup_utils.py

@@ -1,7 +1,6 @@
 import logging
 import mimetypes
 import socket
-from pathlib import Path
 
 import torch
 
@@ -34,16 +33,7 @@ def check_cudnn(logger: logging.Logger) -> None:
             )
 
 
-def invokeai_source_dir() -> Path:
-    # `invokeai.__file__` doesn't always work for editable installs
-    this_module_path = Path(__file__).resolve()
-    # https://youtrack.jetbrains.com/issue/PY-38382/Unresolved-reference-spec-but-this-is-standard-builtin
-    # noinspection PyUnresolvedReferences
-    depth = len(__spec__.parent.split("."))
-    return this_module_path.parents[depth - 1]
-
-
-def enable_dev_reload(custom_nodes_path=None) -> None:
+def enable_dev_reload() -> None:
     """Enable hot reloading on python file changes during development."""
     from invokeai.backend.util.logging import InvokeAILogger
 
@@ -54,10 +44,7 @@ def enable_dev_reload(custom_nodes_path=None) -> None:
             'Can\'t start `--dev_reload` because jurigged is not found; `pip install -e ".[dev]"` to include development dependencies.'
         ) from e
     else:
-        paths = [str(invokeai_source_dir() / "*.py")]
-        if custom_nodes_path:
-            paths.append(str(custom_nodes_path / "*.py"))
-        jurigged.watch(pattern=paths, logger=InvokeAILogger.get_logger(name="jurigged").info)
+        jurigged.watch(logger=InvokeAILogger.get_logger(name="jurigged").info)
 
 
 def apply_monkeypatches() -> None:
@@ -65,6 +52,9 @@ def apply_monkeypatches() -> None:
 
     import invokeai.backend.util.hotfixes  # noqa: F401 (monkeypatching on import)
 
+    if torch.backends.mps.is_available():
+        import invokeai.backend.util.mps_fixes  # noqa: F401 (monkeypatching on import)
+
 
 def register_mime_types() -> None:
     """Register additional mime types for windows."""

invokeai/app/util/step_callback.py

@@ -5,7 +5,7 @@ import torch
 from PIL import Image
 
 from invokeai.app.services.session_processor.session_processor_common import CanceledException
-from invokeai.backend.model_manager.taxonomy import BaseModelType
+from invokeai.backend.model_manager.config import BaseModelType
 from invokeai.backend.stable_diffusion.diffusers_pipeline import PipelineIntermediateState
 
 # fast latents preview matrix for sdxl

invokeai/app/util/t5_model_identifier.py

@@ -1,5 +1,5 @@
 from invokeai.app.invocations.model import ModelIdentifierField
-from invokeai.backend.model_manager.taxonomy import BaseModelType, SubModelType
+from invokeai.backend.model_manager.config import BaseModelType, SubModelType
 
 
 def preprocess_t5_encoder_model_identifier(model_identifier: ModelIdentifierField) -> ModelIdentifierField:

invokeai/app/util/ti_utils.py

@@ -4,7 +4,7 @@ from typing import List, Tuple
 import invokeai.backend.util.logging as logger
 from invokeai.app.services.model_records import UnknownModelException
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
+from invokeai.backend.model_manager.config import BaseModelType, ModelType
 from invokeai.backend.textual_inversion import TextualInversionModelRaw
 
 

invokeai/backend/flux/flux_state_dict_utils.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from invokeai.backend.model_manager.legacy_probe import CkptType
-
-
-def get_flux_in_channels_from_state_dict(state_dict: "CkptType") -> int | None:
-    """Gets the in channels from the state dict."""
-
-    # "Standard" FLUX models use "img_in.weight", but some community fine tunes use
-    # "model.diffusion_model.img_in.weight". Known models that use the latter key:
-    # - https://civitai.com/models/885098?modelVersionId=990775
-    # - https://civitai.com/models/1018060?modelVersionId=1596255
-    # - https://civitai.com/models/978314/ultrareal-fine-tune?modelVersionId=1413133
-
-    keys = {"img_in.weight", "model.diffusion_model.img_in.weight"}
-
-    for key in keys:
-        val = state_dict.get(key)
-        if val is not None:
-            return val.shape[1]
-
-    return None

invokeai/backend/image_util/dw_openpose/__init__.py

@@ -5,14 +5,62 @@ import huggingface_hub
 import numpy as np
 import onnxruntime as ort
 import torch
+from controlnet_aux.util import resize_image
 from PIL import Image
 
 from invokeai.backend.image_util.dw_openpose.onnxdet import inference_detector
 from invokeai.backend.image_util.dw_openpose.onnxpose import inference_pose
 from invokeai.backend.image_util.dw_openpose.utils import NDArrayInt, draw_bodypose, draw_facepose, draw_handpose
+from invokeai.backend.image_util.dw_openpose.wholebody import Wholebody
 from invokeai.backend.image_util.util import np_to_pil
 from invokeai.backend.util.devices import TorchDevice
 
+DWPOSE_MODELS = {
+    "yolox_l.onnx": "https://huggingface.co/yzd-v/DWPose/resolve/main/yolox_l.onnx?download=true",
+    "dw-ll_ucoco_384.onnx": "https://huggingface.co/yzd-v/DWPose/resolve/main/dw-ll_ucoco_384.onnx?download=true",
+}
+
+
+def draw_pose(
+    pose: Dict[str, NDArrayInt | Dict[str, NDArrayInt]],
+    H: int,
+    W: int,
+    draw_face: bool = True,
+    draw_body: bool = True,
+    draw_hands: bool = True,
+    resolution: int = 512,
+) -> Image.Image:
+    bodies = pose["bodies"]
+    faces = pose["faces"]
+    hands = pose["hands"]
+
+    assert isinstance(bodies, dict)
+    candidate = bodies["candidate"]
+
+    assert isinstance(bodies, dict)
+    subset = bodies["subset"]
+
+    canvas = np.zeros(shape=(H, W, 3), dtype=np.uint8)
+
+    if draw_body:
+        canvas = draw_bodypose(canvas, candidate, subset)
+
+    if draw_hands:
+        assert isinstance(hands, np.ndarray)
+        canvas = draw_handpose(canvas, hands)
+
+    if draw_face:
+        assert isinstance(hands, np.ndarray)
+        canvas = draw_facepose(canvas, faces)  # type: ignore
+
+    dwpose_image: Image.Image = resize_image(
+        canvas,
+        resolution,
+    )
+    dwpose_image = Image.fromarray(dwpose_image)
+
+    return dwpose_image
+
 
 class DWOpenposeDetector:
     """
@@ -20,6 +68,62 @@ class DWOpenposeDetector:
     Credits: https://github.com/IDEA-Research/DWPose
     """
 
+    def __init__(self, onnx_det: Path, onnx_pose: Path) -> None:
+        self.pose_estimation = Wholebody(onnx_det=onnx_det, onnx_pose=onnx_pose)
+
+    def __call__(
+        self,
+        image: Image.Image,
+        draw_face: bool = False,
+        draw_body: bool = True,
+        draw_hands: bool = False,
+        resolution: int = 512,
+    ) -> Image.Image:
+        np_image = np.array(image)
+        H, W, C = np_image.shape
+
+        with torch.no_grad():
+            candidate, subset = self.pose_estimation(np_image)
+            nums, keys, locs = candidate.shape
+            candidate[..., 0] /= float(W)
+            candidate[..., 1] /= float(H)
+            body = candidate[:, :18].copy()
+            body = body.reshape(nums * 18, locs)
+            score = subset[:, :18]
+            for i in range(len(score)):
+                for j in range(len(score[i])):
+                    if score[i][j] > 0.3:
+                        score[i][j] = int(18 * i + j)
+                    else:
+                        score[i][j] = -1
+
+            un_visible = subset < 0.3
+            candidate[un_visible] = -1
+
+            # foot = candidate[:, 18:24]
+
+            faces = candidate[:, 24:92]
+
+            hands = candidate[:, 92:113]
+            hands = np.vstack([hands, candidate[:, 113:]])
+
+            bodies = {"candidate": body, "subset": score}
+            pose = {"bodies": bodies, "hands": hands, "faces": faces}
+
+            return draw_pose(
+                pose, H, W, draw_face=draw_face, draw_hands=draw_hands, draw_body=draw_body, resolution=resolution
+            )
+
+
+class DWOpenposeDetector2:
+    """
+    Code from the original implementation of the DW Openpose Detector.
+    Credits: https://github.com/IDEA-Research/DWPose
+
+    This implementation is similar to DWOpenposeDetector, with some alterations to allow the onnx models to be loaded
+    and managed by the model manager.
+    """
+
     hf_repo_id = "yzd-v/DWPose"
     hf_filename_onnx_det = "yolox_l.onnx"
     hf_filename_onnx_pose = "dw-ll_ucoco_384.onnx"
@@ -109,7 +213,7 @@ class DWOpenposeDetector:
             bodies = {"candidate": body, "subset": score}
             pose = {"bodies": bodies, "hands": hands, "faces": faces}
 
-            return DWOpenposeDetector.draw_pose(
+            return DWOpenposeDetector2.draw_pose(
                 pose, H, W, draw_face=draw_face, draw_hands=draw_hands, draw_body=draw_body
             )
 

invokeai/backend/image_util/dw_openpose/utils.py

@@ -3,6 +3,7 @@
 import math
 
 import cv2
+import matplotlib
 import numpy as np
 import numpy.typing as npt
 
@@ -126,13 +127,11 @@ def draw_handpose(canvas: NDArrayInt, all_hand_peaks: NDArrayInt) -> NDArrayInt:
             x2 = int(x2 * W)
             y2 = int(y2 * H)
             if x1 > eps and y1 > eps and x2 > eps and y2 > eps:
-                hsv_color = np.array([[[ie / float(len(edges)) * 180, 255, 255]]], dtype=np.uint8)
-                rgb_color = cv2.cvtColor(hsv_color, cv2.COLOR_HSV2RGB)[0, 0]
                 cv2.line(
                     canvas,
                     (x1, y1),
                     (x2, y2),
-                    rgb_color.tolist(),
+                    matplotlib.colors.hsv_to_rgb([ie / float(len(edges)), 1.0, 1.0]) * 255,
                     thickness=2,
                 )
 

invokeai/backend/image_util/dw_openpose/wholebody.py

@@ -0,0 +1,44 @@
+# Code from the original DWPose Implementation: https://github.com/IDEA-Research/DWPose
+# Modified pathing to suit Invoke
+
+
+from pathlib import Path
+
+import numpy as np
+import onnxruntime as ort
+
+from invokeai.app.services.config.config_default import get_config
+from invokeai.backend.image_util.dw_openpose.onnxdet import inference_detector
+from invokeai.backend.image_util.dw_openpose.onnxpose import inference_pose
+from invokeai.backend.util.devices import TorchDevice
+
+config = get_config()
+
+
+class Wholebody:
+    def __init__(self, onnx_det: Path, onnx_pose: Path):
+        device = TorchDevice.choose_torch_device()
+
+        providers = ["CUDAExecutionProvider"] if device.type == "cuda" else ["CPUExecutionProvider"]
+
+        self.session_det = ort.InferenceSession(path_or_bytes=onnx_det, providers=providers)
+        self.session_pose = ort.InferenceSession(path_or_bytes=onnx_pose, providers=providers)
+
+    def __call__(self, oriImg):
+        det_result = inference_detector(self.session_det, oriImg)
+        keypoints, scores = inference_pose(self.session_pose, det_result, oriImg)
+
+        keypoints_info = np.concatenate((keypoints, scores[..., None]), axis=-1)
+        # compute neck joint
+        neck = np.mean(keypoints_info[:, [5, 6]], axis=1)
+        # neck score when visualizing pred
+        neck[:, 2:4] = np.logical_and(keypoints_info[:, 5, 2:4] > 0.3, keypoints_info[:, 6, 2:4] > 0.3).astype(int)
+        new_keypoints_info = np.insert(keypoints_info, 17, neck, axis=1)
+        mmpose_idx = [17, 6, 8, 10, 7, 9, 12, 14, 16, 13, 15, 2, 1, 4, 3]
+        openpose_idx = [1, 2, 3, 4, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17]
+        new_keypoints_info[:, openpose_idx] = new_keypoints_info[:, mmpose_idx]
+        keypoints_info = new_keypoints_info
+
+        keypoints, scores = keypoints_info[..., :2], keypoints_info[..., 2]
+
+        return keypoints, scores

invokeai/backend/image_util/infill_methods/lama.py

@@ -6,8 +6,8 @@ import torch
 from PIL import Image
 
 import invokeai.backend.util.logging as logger
+from invokeai.backend.model_manager.config import AnyModel
 from invokeai.backend.model_manager.load.model_cache.utils import get_effective_device
-from invokeai.backend.model_manager.taxonomy import AnyModel
 
 
 def norm_img(np_img):

invokeai/backend/image_util/normal_bae/nets/submodules/efficientnet_repo/geffnet/conv2d_layers.py

@@ -16,7 +16,7 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
-from .config import is_exportable, is_scriptable
+from .config import *
 
 
 # From PyTorch internals

invokeai/backend/image_util/normal_bae/nets/submodules/efficientnet_repo/geffnet/efficientnet_builder.py

@@ -5,8 +5,8 @@ Copyright 2020 Ross Wightman
 import re
 from copy import deepcopy
 
-from .conv2d_layers import CondConv2d, get_condconv_initializer, math, partial, select_conv2d
-from geffnet.activations import F, get_act_layer, nn, sigmoid, torch
+from .conv2d_layers import *
+from geffnet.activations import *
 
 __all__ = ['get_bn_args_tf', 'resolve_bn_args', 'resolve_se_args', 'resolve_act_layer', 'make_divisible',
            'round_channels', 'drop_connect', 'SqueezeExcite', 'ConvBnAct', 'DepthwiseSeparableConv',

invokeai/backend/image_util/normal_bae/nets/submodules/efficientnet_repo/geffnet/gen_efficientnet.py

@@ -32,9 +32,7 @@ import torch.nn.functional as F
 from .config import layer_config_kwargs, is_scriptable
 from .conv2d_layers import select_conv2d
 from .helpers import load_pretrained
-from .efficientnet_builder import (BN_EPS_TF_DEFAULT, EfficientNetBuilder, decode_arch_def,
-                                   initialize_weight_default, initialize_weight_goog,
-                                   resolve_act_layer, resolve_bn_args, round_channels)
+from .efficientnet_builder import *
 
 __all__ = ['GenEfficientNet', 'mnasnet_050', 'mnasnet_075', 'mnasnet_100', 'mnasnet_b1', 'mnasnet_140',
            'semnasnet_050', 'semnasnet_075', 'semnasnet_100', 'mnasnet_a1', 'semnasnet_140', 'mnasnet_small',

invokeai/backend/image_util/normal_bae/nets/submodules/efficientnet_repo/geffnet/mobilenetv3.py

@@ -13,9 +13,7 @@ from .activations import get_act_fn, get_act_layer, HardSwish
 from .config import layer_config_kwargs
 from .conv2d_layers import select_conv2d
 from .helpers import load_pretrained
-from .efficientnet_builder import (BN_EPS_TF_DEFAULT, EfficientNetBuilder, decode_arch_def,
-                                   initialize_weight_default, initialize_weight_goog,
-                                   resolve_act_layer, resolve_bn_args, round_channels)
+from .efficientnet_builder import *
 
 __all__ = ['mobilenetv3_rw', 'mobilenetv3_large_075', 'mobilenetv3_large_100', 'mobilenetv3_large_minimal_100',
            'mobilenetv3_small_075', 'mobilenetv3_small_100', 'mobilenetv3_small_minimal_100',

invokeai/backend/image_util/realesrgan/realesrgan.py

@@ -10,7 +10,7 @@ from cv2.typing import MatLike
 from tqdm import tqdm
 
 from invokeai.backend.image_util.basicsr.rrdbnet_arch import RRDBNet
-from invokeai.backend.model_manager.taxonomy import AnyModel
+from invokeai.backend.model_manager.config import AnyModel
 from invokeai.backend.util.devices import TorchDevice
 
 """

invokeai/backend/llava_onevision_model.py

@@ -47,10 +47,3 @@ class LlavaOnevisionModel(RawModel):
 
     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/__init__.py

@@ -1,45 +1,37 @@
 """Re-export frequently-used symbols from the Model Manager backend."""
 
 from invokeai.backend.model_manager.config import (
+    AnyModel,
     AnyModelConfig,
+    BaseModelType,
     InvalidModelConfigException,
     ModelConfigBase,
     ModelConfigFactory,
-)
-from invokeai.backend.model_manager.legacy_probe import ModelProbe
-from invokeai.backend.model_manager.load import LoadedModel
-from invokeai.backend.model_manager.search import ModelSearch
-from invokeai.backend.model_manager.taxonomy import (
-    AnyModel,
-    AnyVariant,
-    BaseModelType,
-    ClipVariantType,
     ModelFormat,
     ModelRepoVariant,
-    ModelSourceType,
     ModelType,
     ModelVariantType,
     SchedulerPredictionType,
     SubModelType,
 )
+from invokeai.backend.model_manager.legacy_probe import ModelProbe
+from invokeai.backend.model_manager.load import LoadedModel
+from invokeai.backend.model_manager.search import ModelSearch
 
 __all__ = [
+    "AnyModel",
     "AnyModelConfig",
+    "BaseModelType",
+    "ModelRepoVariant",
     "InvalidModelConfigException",
     "LoadedModel",
     "ModelConfigFactory",
+    "ModelFormat",
     "ModelProbe",
     "ModelSearch",
-    "ModelConfigBase",
-    "AnyModel",
-    "AnyVariant",
-    "BaseModelType",
-    "ClipVariantType",
-    "ModelFormat",
-    "ModelRepoVariant",
-    "ModelSourceType",
     "ModelType",
     "ModelVariantType",
     "SchedulerPredictionType",
     "SubModelType",
+    "ModelConfigBase",
 ]

invokeai/backend/model_manager/config.py

@@ -30,41 +30,153 @@ from inspect import isabstract
 from pathlib import Path
 from typing import ClassVar, Literal, Optional, TypeAlias, Union
 
+import diffusers
+import onnxruntime as ort
+import safetensors.torch
+import torch
+from diffusers.models.modeling_utils import ModelMixin
+from picklescan.scanner import scan_file_path
 from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag, TypeAdapter
 from typing_extensions import Annotated, Any, Dict
 
 from invokeai.app.util.misc import uuid_string
 from invokeai.backend.model_hash.hash_validator import validate_hash
-from invokeai.backend.model_hash.model_hash import HASHING_ALGORITHMS
-from invokeai.backend.model_manager.model_on_disk import ModelOnDisk
-from invokeai.backend.model_manager.taxonomy import (
-    AnyVariant,
-    BaseModelType,
-    ClipVariantType,
-    FluxLoRAFormat,
-    ModelFormat,
-    ModelRepoVariant,
-    ModelSourceType,
-    ModelType,
-    ModelVariantType,
-    SchedulerPredictionType,
-    SubModelType,
-)
-from invokeai.backend.model_manager.util.model_util import lora_token_vector_length
+from invokeai.backend.model_hash.model_hash import HASHING_ALGORITHMS, ModelHash
+from invokeai.backend.quantization.gguf.loaders import gguf_sd_loader
+from invokeai.backend.raw_model import RawModel
 from invokeai.backend.stable_diffusion.schedulers.schedulers import SCHEDULER_NAME_VALUES
+from invokeai.backend.util.silence_warnings import SilenceWarnings
 
 logger = logging.getLogger(__name__)
 
+# ModelMixin is the base class for all diffusers and transformers models
+# RawModel is the InvokeAI wrapper class for ip_adapters, loras, textual_inversion and onnx runtime
+AnyModel = Union[
+    ModelMixin, RawModel, torch.nn.Module, Dict[str, torch.Tensor], diffusers.DiffusionPipeline, ort.InferenceSession
+]
+
 
 class InvalidModelConfigException(Exception):
     """Exception for when config parser doesn't recognize this combination of model type and format."""
 
-    pass
+
+class BaseModelType(str, Enum):
+    """Base model type."""
+
+    Any = "any"
+    StableDiffusion1 = "sd-1"
+    StableDiffusion2 = "sd-2"
+    StableDiffusion3 = "sd-3"
+    StableDiffusionXL = "sdxl"
+    StableDiffusionXLRefiner = "sdxl-refiner"
+    Flux = "flux"
+    # Kandinsky2_1 = "kandinsky-2.1"
+
+
+class ModelType(str, Enum):
+    """Model type."""
+
+    ONNX = "onnx"
+    Main = "main"
+    VAE = "vae"
+    LoRA = "lora"
+    ControlLoRa = "control_lora"
+    ControlNet = "controlnet"  # used by model_probe
+    TextualInversion = "embedding"
+    IPAdapter = "ip_adapter"
+    CLIPVision = "clip_vision"
+    CLIPEmbed = "clip_embed"
+    T2IAdapter = "t2i_adapter"
+    T5Encoder = "t5_encoder"
+    SpandrelImageToImage = "spandrel_image_to_image"
+    SigLIP = "siglip"
+    FluxRedux = "flux_redux"
+    LlavaOnevision = "llava_onevision"
+
+
+class SubModelType(str, Enum):
+    """Submodel type."""
+
+    UNet = "unet"
+    Transformer = "transformer"
+    TextEncoder = "text_encoder"
+    TextEncoder2 = "text_encoder_2"
+    TextEncoder3 = "text_encoder_3"
+    Tokenizer = "tokenizer"
+    Tokenizer2 = "tokenizer_2"
+    Tokenizer3 = "tokenizer_3"
+    VAE = "vae"
+    VAEDecoder = "vae_decoder"
+    VAEEncoder = "vae_encoder"
+    Scheduler = "scheduler"
+    SafetyChecker = "safety_checker"
+
+
+class ClipVariantType(str, Enum):
+    """Variant type."""
+
+    L = "large"
+    G = "gigantic"
+
+
+class ModelVariantType(str, Enum):
+    """Variant type."""
+
+    Normal = "normal"
+    Inpaint = "inpaint"
+    Depth = "depth"
+
+
+class ModelFormat(str, Enum):
+    """Storage format of model."""
+
+    Diffusers = "diffusers"
+    Checkpoint = "checkpoint"
+    LyCORIS = "lycoris"
+    ONNX = "onnx"
+    Olive = "olive"
+    EmbeddingFile = "embedding_file"
+    EmbeddingFolder = "embedding_folder"
+    InvokeAI = "invokeai"
+    T5Encoder = "t5_encoder"
+    BnbQuantizedLlmInt8b = "bnb_quantized_int8b"
+    BnbQuantizednf4b = "bnb_quantized_nf4b"
+    GGUFQuantized = "gguf_quantized"
+
+
+class SchedulerPredictionType(str, Enum):
+    """Scheduler prediction type."""
+
+    Epsilon = "epsilon"
+    VPrediction = "v_prediction"
+    Sample = "sample"
+
+
+class ModelRepoVariant(str, Enum):
+    """Various hugging face variants on the diffusers format."""
+
+    Default = ""  # model files without "fp16" or other qualifier
+    FP16 = "fp16"
+    FP32 = "fp32"
+    ONNX = "onnx"
+    OpenVINO = "openvino"
+    Flax = "flax"
+
+
+class ModelSourceType(str, Enum):
+    """Model source type."""
+
+    Path = "path"
+    Url = "url"
+    HFRepoID = "hf_repo_id"
 
 
 DEFAULTS_PRECISION = Literal["fp16", "fp32"]
 
 
+AnyVariant: TypeAlias = Union[ModelVariantType, ClipVariantType, None]
+
+
 class SubmodelDefinition(BaseModel):
     path_or_prefix: str
     model_type: ModelType
@@ -95,6 +207,68 @@ class ControlAdapterDefaultSettings(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
 
+class ModelOnDisk:
+    """A utility class representing a model stored on disk."""
+
+    def __init__(self, path: Path, hash_algo: HASHING_ALGORITHMS = "blake3_single"):
+        self.path = path
+        self.format_type = ModelFormat.Diffusers if path.is_dir() else ModelFormat.Checkpoint
+        if self.path.suffix in {".safetensors", ".bin", ".pt", ".ckpt"}:
+            self.name = path.stem
+        else:
+            self.name = path.name
+        self.hash_algo = hash_algo
+
+    def hash(self):
+        return ModelHash(algorithm=self.hash_algo).hash(self.path)
+
+    def size(self):
+        if self.format_type == ModelFormat.Checkpoint:
+            return self.path.stat().st_size
+        return sum(file.stat().st_size for file in self.path.rglob("*"))
+
+    def component_paths(self):
+        if self.format_type == ModelFormat.Checkpoint:
+            return {self.path}
+        extensions = {".safetensors", ".pt", ".pth", ".ckpt", ".bin", ".gguf"}
+        return {f for f in self.path.rglob("*") if f.suffix in extensions}
+
+    def repo_variant(self):
+        if self.format_type == ModelFormat.Checkpoint:
+            return None
+
+        weight_files = list(self.path.glob("**/*.safetensors"))
+        weight_files.extend(list(self.path.glob("**/*.bin")))
+        for x in weight_files:
+            if ".fp16" in x.suffixes:
+                return ModelRepoVariant.FP16
+            if "openvino_model" in x.name:
+                return ModelRepoVariant.OpenVINO
+            if "flax_model" in x.name:
+                return ModelRepoVariant.Flax
+            if x.suffix == ".onnx":
+                return ModelRepoVariant.ONNX
+        return ModelRepoVariant.Default
+
+    @staticmethod
+    def load_state_dict(path: Path):
+        with SilenceWarnings():
+            if path.suffix.endswith((".ckpt", ".pt", ".pth", ".bin")):
+                scan_result = scan_file_path(path)
+                if scan_result.infected_files != 0 or scan_result.scan_err:
+                    raise RuntimeError(f"The model {path.stem} is potentially infected by malware. Aborting import.")
+                checkpoint = torch.load(path, map_location="cpu")
+            elif path.suffix.endswith(".gguf"):
+                checkpoint = gguf_sd_loader(path, compute_dtype=torch.float32)
+            elif path.suffix.endswith(".safetensors"):
+                checkpoint = safetensors.torch.load_file(path)
+            else:
+                raise ValueError(f"Unrecognized model extension: {path.suffix}")
+
+        state_dict = checkpoint.get("state_dict", checkpoint)
+        return state_dict
+
+
 class MatchSpeed(int, Enum):
     """Represents the estimated runtime speed of a config's 'matches' method."""
 
@@ -169,18 +343,16 @@ class ModelConfigBase(ABC, BaseModel):
         Created to deprecate ModelProbe.probe
         """
         candidates = ModelConfigBase._USING_CLASSIFY_API
-        sorted_by_match_speed = sorted(candidates, key=lambda cls: (cls._MATCH_SPEED, cls.__name__))
+        sorted_by_match_speed = sorted(candidates, key=lambda cls: cls._MATCH_SPEED)
         mod = ModelOnDisk(model_path, hash_algo)
 
         for config_cls in sorted_by_match_speed:
             try:
-                if not config_cls.matches(mod):
-                    continue
-            except Exception as e:
-                logger.warning(f"Unexpected exception while matching {mod.name} to '{config_cls.__name__}': {e}")
-                continue
-            else:
                 return config_cls.from_model_on_disk(mod, **overrides)
+            except InvalidModelConfigException:
+                logger.debug(f"ModelConfig '{config_cls.__name__}' failed to parse '{mod.path}', trying next config")
+            except Exception as e:
+                logger.error(f"Unexpected exception while parsing '{config_cls.__name__}': {e}, trying next config")
 
         raise InvalidModelConfigException("No valid config found")
 
@@ -220,12 +392,12 @@ class ModelConfigBase(ABC, BaseModel):
         if "source_type" in overrides:
             overrides["source_type"] = ModelSourceType(overrides["source_type"])
 
-        if "variant" in overrides:
-            overrides["variant"] = ModelVariantType(overrides["variant"])
-
     @classmethod
     def from_model_on_disk(cls, mod: ModelOnDisk, **overrides):
         """Creates an instance of this config or raises InvalidModelConfigException."""
+        if not cls.matches(mod):
+            raise InvalidModelConfigException(f"Path {mod.path} does not match {cls.__name__} format")
+
         fields = cls.parse(mod)
         cls.cast_overrides(overrides)
         fields.update(overrides)
@@ -282,38 +454,6 @@ class LoRAConfigBase(ABC, BaseModel):
     type: Literal[ModelType.LoRA] = ModelType.LoRA
     trigger_phrases: Optional[set[str]] = Field(description="Set of trigger phrases for this model", default=None)
 
-    @classmethod
-    def flux_lora_format(cls, mod: ModelOnDisk):
-        key = "FLUX_LORA_FORMAT"
-        if key in mod.cache:
-            return mod.cache[key]
-
-        from invokeai.backend.patches.lora_conversions.formats import flux_format_from_state_dict
-
-        sd = mod.load_state_dict(mod.path)
-        value = flux_format_from_state_dict(sd)
-        mod.cache[key] = value
-        return value
-
-    @classmethod
-    def base_model(cls, mod: ModelOnDisk) -> BaseModelType:
-        if cls.flux_lora_format(mod):
-            return BaseModelType.Flux
-
-        state_dict = mod.load_state_dict()
-        # If we've gotten here, we assume that the model is a Stable Diffusion model
-        token_vector_length = lora_token_vector_length(state_dict)
-        if token_vector_length == 768:
-            return BaseModelType.StableDiffusion1
-        elif token_vector_length == 1024:
-            return BaseModelType.StableDiffusion2
-        elif token_vector_length == 1280:
-            return BaseModelType.StableDiffusionXL  # recognizes format at https://civitai.com/models/224641
-        elif token_vector_length == 2048:
-            return BaseModelType.StableDiffusionXL
-        else:
-            raise InvalidModelConfigException("Unknown LoRA type")
-
 
 class T5EncoderConfigBase(ABC, BaseModel):
     """Base class for diffusers-style models."""
@@ -329,40 +469,11 @@ class T5EncoderBnbQuantizedLlmInt8bConfig(T5EncoderConfigBase, LegacyProbeMixin,
     format: Literal[ModelFormat.BnbQuantizedLlmInt8b] = ModelFormat.BnbQuantizedLlmInt8b
 
 
-class LoRALyCORISConfig(LoRAConfigBase, ModelConfigBase):
+class LoRALyCORISConfig(LoRAConfigBase, LegacyProbeMixin, ModelConfigBase):
     """Model config for LoRA/Lycoris models."""
 
     format: Literal[ModelFormat.LyCORIS] = ModelFormat.LyCORIS
 
-    @classmethod
-    def matches(cls, mod: ModelOnDisk) -> bool:
-        if mod.path.is_dir():
-            return False
-
-        # Avoid false positive match against ControlLoRA and Diffusers
-        if cls.flux_lora_format(mod) in [FluxLoRAFormat.Control, FluxLoRAFormat.Diffusers]:
-            return False
-
-        state_dict = mod.load_state_dict()
-        for key in state_dict.keys():
-            if type(key) is int:
-                continue
-
-            if key.startswith(("lora_te_", "lora_unet_", "lora_te1_", "lora_te2_", "lora_transformer_")):
-                return True
-            # "lora_A.weight" and "lora_B.weight" are associated with models in PEFT format. We don't support all PEFT
-            # LoRA models, but as of the time of writing, we support Diffusers FLUX PEFT LoRA models.
-            if key.endswith(("to_k_lora.up.weight", "to_q_lora.down.weight", "lora_A.weight", "lora_B.weight")):
-                return True
-
-        return False
-
-    @classmethod
-    def parse(cls, mod: ModelOnDisk) -> dict[str, Any]:
-        return {
-            "base": cls.base_model(mod),
-        }
-
 
 class ControlAdapterConfigBase(ABC, BaseModel):
     default_settings: Optional[ControlAdapterDefaultSettings] = Field(
@@ -386,26 +497,11 @@ class ControlLoRADiffusersConfig(ControlAdapterConfigBase, LegacyProbeMixin, Mod
     format: Literal[ModelFormat.Diffusers] = ModelFormat.Diffusers
 
 
-class LoRADiffusersConfig(LoRAConfigBase, ModelConfigBase):
+class LoRADiffusersConfig(LoRAConfigBase, LegacyProbeMixin, ModelConfigBase):
     """Model config for LoRA/Diffusers models."""
 
     format: Literal[ModelFormat.Diffusers] = ModelFormat.Diffusers
 
-    @classmethod
-    def matches(cls, mod: ModelOnDisk) -> bool:
-        if mod.path.is_file():
-            return cls.flux_lora_format(mod) == FluxLoRAFormat.Diffusers
-
-        suffixes = ["bin", "safetensors"]
-        weight_files = [mod.path / f"pytorch_lora_weights.{sfx}" for sfx in suffixes]
-        return any(wf.exists() for wf in weight_files)
-
-    @classmethod
-    def parse(cls, mod: ModelOnDisk) -> dict[str, Any]:
-        return {
-            "base": cls.base_model(mod),
-        }
-
 
 class VAECheckpointConfig(CheckpointConfigBase, LegacyProbeMixin, ModelConfigBase):
     """Model config for standalone VAE models."""
@@ -577,7 +673,7 @@ class LlavaOnevisionConfig(DiffusersConfigBase, ModelConfigBase):
 
     @classmethod
     def matches(cls, mod: ModelOnDisk) -> bool:
-        if mod.path.is_file():
+        if mod.format_type == ModelFormat.Checkpoint:
             return False
 
         config_path = mod.path / "config.json"

invokeai/backend/model_manager/legacy_probe.py

@@ -14,30 +14,27 @@ from invokeai.backend.flux.controlnet.state_dict_utils import (
     is_state_dict_instantx_controlnet,
     is_state_dict_xlabs_controlnet,
 )
-from invokeai.backend.flux.flux_state_dict_utils import get_flux_in_channels_from_state_dict
 from invokeai.backend.flux.ip_adapter.state_dict_utils import is_state_dict_xlabs_ip_adapter
 from invokeai.backend.flux.redux.flux_redux_state_dict_utils import is_state_dict_likely_flux_redux
 from invokeai.backend.model_hash.model_hash import HASHING_ALGORITHMS, ModelHash
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
+    AnyVariant,
+    BaseModelType,
     ControlAdapterDefaultSettings,
     InvalidModelConfigException,
     MainModelDefaultSettings,
     ModelConfigFactory,
-    SubmodelDefinition,
-)
-from invokeai.backend.model_manager.load.model_loaders.generic_diffusers import ConfigLoader
-from invokeai.backend.model_manager.taxonomy import (
-    AnyVariant,
-    BaseModelType,
     ModelFormat,
     ModelRepoVariant,
     ModelSourceType,
     ModelType,
     ModelVariantType,
     SchedulerPredictionType,
+    SubmodelDefinition,
     SubModelType,
 )
+from invokeai.backend.model_manager.load.model_loaders.generic_diffusers import ConfigLoader
 from invokeai.backend.model_manager.util.model_util import (
     get_clip_variant_type,
     lora_token_vector_length,
@@ -565,14 +562,7 @@ class CheckpointProbeBase(ProbeBase):
         state_dict = self.checkpoint.get("state_dict") or self.checkpoint
 
         if base_type == BaseModelType.Flux:
-            in_channels = get_flux_in_channels_from_state_dict(state_dict)
-
-            if in_channels is None:
-                # If we cannot find the in_channels, we assume that this is a normal variant. Log a warning.
-                logger.warning(
-                    f"{self.model_path} does not have img_in.weight or model.diffusion_model.img_in.weight key. Assuming normal variant."
-                )
-                return ModelVariantType.Normal
+            in_channels = state_dict["img_in.weight"].shape[1]
 
             # FLUX Model variant types are distinguished by input channels:
             # - Unquantized Dev and Schnell have in_channels=64

invokeai/backend/model_manager/load/load_base.py

@@ -13,11 +13,12 @@ import torch
 
 from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.backend.model_manager.config import (
+    AnyModel,
     AnyModelConfig,
+    SubModelType,
 )
 from invokeai.backend.model_manager.load.model_cache.cache_record import CacheRecord
 from invokeai.backend.model_manager.load.model_cache.model_cache import ModelCache
-from invokeai.backend.model_manager.taxonomy import AnyModel, SubModelType
 
 
 class LoadedModelWithoutConfig:

invokeai/backend/model_manager/load/load_default.py

@@ -6,16 +6,18 @@ from pathlib import Path
 from typing import Optional
 
 from invokeai.app.services.config import InvokeAIAppConfig
-from invokeai.backend.model_manager.config import AnyModelConfig, DiffusersConfigBase, InvalidModelConfigException
+from invokeai.backend.model_manager import (
+    AnyModel,
+    AnyModelConfig,
+    InvalidModelConfigException,
+    SubModelType,
+)
+from invokeai.backend.model_manager.config import DiffusersConfigBase
 from invokeai.backend.model_manager.load.load_base import LoadedModel, ModelLoaderBase
 from invokeai.backend.model_manager.load.model_cache.cache_record import CacheRecord
 from invokeai.backend.model_manager.load.model_cache.model_cache import ModelCache, get_model_cache_key
 from invokeai.backend.model_manager.load.model_util import calc_model_size_by_fs
 from invokeai.backend.model_manager.load.optimizations import skip_torch_weight_init
-from invokeai.backend.model_manager.taxonomy import (
-    AnyModel,
-    SubModelType,
-)
 from invokeai.backend.util.devices import TorchDevice