Merge branch 'feat/controlnet_backend' of https://github.com/invoke-ai/InvokeAI into feat/controlnet_backend

.github/CODEOWNERS

@@ -2,7 +2,7 @@
 /.github/workflows/  @lstein @blessedcoolant
 
 # documentation
-/docs/ @lstein @blessedcoolant @hipsterusername
+/docs/ @lstein  @tildebyte @blessedcoolant
 /mkdocs.yml @lstein  @blessedcoolant
 
 # nodes
@@ -18,17 +18,17 @@
 /invokeai/version @lstein @blessedcoolant
 
 # web ui
-/invokeai/frontend @blessedcoolant @psychedelicious @lstein @maryhipp
-/invokeai/backend @blessedcoolant @psychedelicious @lstein @maryhipp
+/invokeai/frontend @blessedcoolant @psychedelicious @lstein
+/invokeai/backend @blessedcoolant @psychedelicious @lstein
 
 # generation, model management, postprocessing
-/invokeai/backend  @damian0815 @lstein @blessedcoolant @jpphoto @gregghelt2 @StAlKeR7779
+/invokeai/backend  @damian0815 @lstein @blessedcoolant @jpphoto @gregghelt2
 
 # front ends
 /invokeai/frontend/CLI @lstein
 /invokeai/frontend/install @lstein @ebr  
-/invokeai/frontend/merge @lstein @blessedcoolant 
-/invokeai/frontend/training @lstein @blessedcoolant 
-/invokeai/frontend/web @psychedelicious @blessedcoolant @maryhipp 
+/invokeai/frontend/merge @lstein @blessedcoolant @hipsterusername
+/invokeai/frontend/training @lstein @blessedcoolant @hipsterusername
+/invokeai/frontend/web @psychedelicious @blessedcoolant
 
 

.github/workflows/mkdocs-material.yml

@@ -2,7 +2,8 @@ name: mkdocs-material
 on:
   push:
     branches:
-      - 'refs/heads/v2.3'
+      - 'main'
+      - 'development'
 
 permissions:
     contents: write
@@ -11,10 +12,6 @@ jobs:
   mkdocs-material:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
-    env:
-      REPO_URL: '${{ github.server_url }}/${{ github.repository }}'
-      REPO_NAME: '${{ github.repository }}'
-      SITE_URL: 'https://${{ github.repository_owner }}.github.io/InvokeAI'
     steps:
       - name: checkout sources
         uses: actions/checkout@v3
@@ -25,15 +22,11 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: '3.10'
-          cache: pip
-          cache-dependency-path: pyproject.toml
 
       - name: install requirements
-        env:
-          PIP_USE_PEP517: 1
         run: |
           python -m \
-            pip install ".[docs]"
+            pip install -r docs/requirements-mkdocs.txt
 
       - name: confirm buildability
         run: |
@@ -43,7 +36,7 @@ jobs:
             --verbose
 
       - name: deploy to gh-pages
-        if: ${{ github.ref == 'refs/heads/v2.3' }}
+        if: ${{ github.ref == 'refs/heads/main' }}
         run: |
           python -m \
             mkdocs gh-deploy \

.github/workflows/test-invoke-pip-skip.yml

@@ -1,16 +1,10 @@
 name: Test invoke.py pip
-
-# This is a dummy stand-in for the actual tests
-# we don't need to run python tests on non-Python changes
-# But PRs require passing tests to be mergeable
-
 on:
   pull_request:
     paths:
       - '**'
       - '!pyproject.toml'
       - '!invokeai/**'
-      - '!tests/**'
       - 'invokeai/frontend/web/**'
   merge_group:
   workflow_dispatch:
@@ -25,26 +19,48 @@ jobs:
     strategy:
       matrix:
         python-version:
+          # - '3.9'
           - '3.10'
         pytorch:
+          # - linux-cuda-11_6
           - linux-cuda-11_7
           - linux-rocm-5_2
           - linux-cpu
           - macos-default
           - windows-cpu
+          # - windows-cuda-11_6
+          # - windows-cuda-11_7
         include:
+          # - pytorch: linux-cuda-11_6
+          #   os: ubuntu-22.04
+          #   extra-index-url: 'https://download.pytorch.org/whl/cu116'
+          #   github-env: $GITHUB_ENV
           - pytorch: linux-cuda-11_7
             os: ubuntu-22.04
+            github-env: $GITHUB_ENV
           - pytorch: linux-rocm-5_2
             os: ubuntu-22.04
+            extra-index-url: 'https://download.pytorch.org/whl/rocm5.2'
+            github-env: $GITHUB_ENV
           - pytorch: linux-cpu
             os: ubuntu-22.04
+            extra-index-url: 'https://download.pytorch.org/whl/cpu'
+            github-env: $GITHUB_ENV
           - pytorch: macos-default
             os: macOS-12
+            github-env: $GITHUB_ENV
           - pytorch: windows-cpu
             os: windows-2022
+            github-env: $env:GITHUB_ENV
+          # - pytorch: windows-cuda-11_6
+          #   os: windows-2022
+          #   extra-index-url: 'https://download.pytorch.org/whl/cu116'
+          #   github-env: $env:GITHUB_ENV
+          # - pytorch: windows-cuda-11_7
+          #   os: windows-2022
+          #   extra-index-url: 'https://download.pytorch.org/whl/cu117'
+          #   github-env: $env:GITHUB_ENV
     name: ${{ matrix.pytorch }} on ${{ matrix.python-version }}
     runs-on: ${{ matrix.os }}
     steps:
-      - name: skip
-        run: echo "no build required"
+      - run: 'echo "No build required"'

.github/workflows/test-invoke-pip.yml

@@ -11,7 +11,6 @@ on:
     paths:
       - 'pyproject.toml'
       - 'invokeai/**'
-      - 'tests/**'
       - '!invokeai/frontend/web/**'
     types:
       - 'ready_for_review'
@@ -33,12 +32,19 @@ jobs:
           # - '3.9'
           - '3.10'
         pytorch:
+          # - linux-cuda-11_6
           - linux-cuda-11_7
           - linux-rocm-5_2
           - linux-cpu
           - macos-default
           - windows-cpu
+          # - windows-cuda-11_6
+          # - windows-cuda-11_7
         include:
+          # - pytorch: linux-cuda-11_6
+          #   os: ubuntu-22.04
+          #   extra-index-url: 'https://download.pytorch.org/whl/cu116'
+          #   github-env: $GITHUB_ENV
           - pytorch: linux-cuda-11_7
             os: ubuntu-22.04
             github-env: $GITHUB_ENV
@@ -56,6 +62,14 @@ jobs:
           - pytorch: windows-cpu
             os: windows-2022
             github-env: $env:GITHUB_ENV
+          # - pytorch: windows-cuda-11_6
+          #   os: windows-2022
+          #   extra-index-url: 'https://download.pytorch.org/whl/cu116'
+          #   github-env: $env:GITHUB_ENV
+          # - pytorch: windows-cuda-11_7
+          #   os: windows-2022
+          #   extra-index-url: 'https://download.pytorch.org/whl/cu117'
+          #   github-env: $env:GITHUB_ENV
     name: ${{ matrix.pytorch }} on ${{ matrix.python-version }}
     runs-on: ${{ matrix.os }}
     env:
@@ -66,6 +80,11 @@ jobs:
         uses: actions/checkout@v3
 
       - name: set test prompt to main branch validation
+        if: ${{ github.ref == 'refs/heads/main' }}
+        run: echo "TEST_PROMPTS=tests/preflight_prompts.txt" >> ${{ matrix.github-env }}
+
+      - name: set test prompt to Pull Request validation
+        if: ${{ github.ref != 'refs/heads/main' }}
         run: echo "TEST_PROMPTS=tests/validate_pr_prompt.txt" >> ${{ matrix.github-env }}
 
       - name: setup python
@@ -86,38 +105,40 @@ jobs:
         id: run-pytest
         run: pytest
 
-      # - name: run invokeai-configure
-      #   env:
-      #     HUGGING_FACE_HUB_TOKEN: ${{ secrets.HUGGINGFACE_TOKEN }}
-      #   run: >
-      #     invokeai-configure
-      #     --yes
-      #     --default_only
-      #     --full-precision
-      #   # can't use fp16 weights without a GPU
+      - name: set INVOKEAI_OUTDIR
+        run: >
+          python -c
+          "import os;from invokeai.backend.globals import Globals;OUTDIR=os.path.join(Globals.root,str('outputs'));print(f'INVOKEAI_OUTDIR={OUTDIR}')"
+          >> ${{ matrix.github-env }}
 
-      # - name: run invokeai
-      #   id: run-invokeai
-      #   env:
-      #     # Set offline mode to make sure configure preloaded successfully.
-      #     HF_HUB_OFFLINE: 1
-      #     HF_DATASETS_OFFLINE: 1
-      #     TRANSFORMERS_OFFLINE: 1
-      #     INVOKEAI_OUTDIR: ${{ github.workspace }}/results
-      #   run: >
-      #     invokeai
-      #     --no-patchmatch
-      #     --no-nsfw_checker
-      #     --precision=float32
-      #     --always_use_cpu
-      #     --use_memory_db
-      #     --outdir ${{ env.INVOKEAI_OUTDIR }}/${{ matrix.python-version }}/${{ matrix.pytorch }}
-      #     --from_file ${{ env.TEST_PROMPTS }}
+      - name: run invokeai-configure
+        id: run-preload-models
+        env:
+          HUGGING_FACE_HUB_TOKEN: ${{ secrets.HUGGINGFACE_TOKEN }}
+        run: >
+          invokeai-configure
+          --yes
+          --default_only
+          --full-precision
+        # can't use fp16 weights without a GPU
 
-      # - name: Archive results
-      #   env:
-      #     INVOKEAI_OUTDIR: ${{ github.workspace }}/results
-      #   uses: actions/upload-artifact@v3
-      #   with:
-      #     name: results
-      #     path: ${{ env.INVOKEAI_OUTDIR }}
+      - name: run invokeai
+        id: run-invokeai
+        env:
+          # Set offline mode to make sure configure preloaded successfully.
+          HF_HUB_OFFLINE: 1
+          HF_DATASETS_OFFLINE: 1
+          TRANSFORMERS_OFFLINE: 1
+        run: >
+          invokeai
+          --no-patchmatch
+          --no-nsfw_checker
+          --from_file ${{ env.TEST_PROMPTS }}
+          --outdir ${{ env.INVOKEAI_OUTDIR }}/${{ matrix.python-version }}/${{ matrix.pytorch }}
+
+      - name: Archive results
+        id: archive-results
+        uses: actions/upload-artifact@v3
+        with:
+          name: results
+          path: ${{ env.INVOKEAI_OUTDIR }}

.gitignore

@@ -201,8 +201,6 @@ checkpoints
 # If it's a Mac
 .DS_Store
 
-invokeai/frontend/web/dist/*
-
 # Let the frontend manage its own gitignore
 !invokeai/frontend/web/*
 

README.md

@@ -33,8 +33,6 @@
 
 </div>
 
-_**Note: The UI is not fully functional on `main`. If you need a stable UI based on `main`, use the `pre-nodes` tag while we [migrate to a new backend](https://github.com/invoke-ai/InvokeAI/discussions/3246).**_
-
 InvokeAI is a leading creative engine built to empower professionals and enthusiasts alike. Generate and create stunning visual media using the latest AI-driven technologies. InvokeAI offers an industry leading Web Interface, interactive Command Line Interface, and also serves as the foundation for multiple commercial products.
 
 **Quick links**: [[How to Install](https://invoke-ai.github.io/InvokeAI/#installation)] [<a href="https://discord.gg/ZmtBAhwWhy">Discord Server</a>] [<a href="https://invoke-ai.github.io/InvokeAI/">Documentation and Tutorials</a>] [<a href="https://github.com/invoke-ai/InvokeAI/">Code and Downloads</a>] [<a href="https://github.com/invoke-ai/InvokeAI/issues">Bug Reports</a>] [<a href="https://github.com/invoke-ai/InvokeAI/discussions">Discussion, Ideas & Q&A</a>]
@@ -43,23 +41,6 @@ _Note: InvokeAI is rapidly evolving. Please use the
 [Issues](https://github.com/invoke-ai/InvokeAI/issues) tab to report bugs and make feature
 requests. Be sure to use the provided templates. They will help us diagnose issues faster._
 
-## FOR DEVELOPERS - MIGRATING TO THE 3.0.0 MODELS FORMAT
-
-The models directory and models.yaml have changed. To migrate to the
-new layout, please follow this recipe:
-
-1. Run `python scripts/migrate_models_to_3.0.py <path_to_root_directory>
-
-2. This will create a new models directory named `models-3.0` and a
-   new config directory named `models.yaml-3.0`, both in the current
-   working directory. If you prefer to name them something else, pass
-   the `--dest-directory` and/or `--dest-yaml` arguments.
-
-3. Check that the new models directory and yaml file look ok.
-
-4. Replace the existing directory and file, keeping backup copies just in
-case.
-
 <div align="center">
 
 ![canvas preview](https://github.com/invoke-ai/InvokeAI/raw/main/docs/assets/canvas_preview.png)

binary_installer/install.bat.in

@@ -0,0 +1,164 @@
+@echo off
+
+@rem This script will install git (if not found on the PATH variable)
+@rem  using micromamba (an 8mb static-linked single-file binary, conda replacement).
+@rem For users who already have git, this step will be skipped.
+
+@rem Next, it'll download the project's source code.
+@rem Then it will download a self-contained, standalone Python and unpack it.
+@rem Finally, it'll create the Python virtual environment and preload the models.
+
+@rem This enables a user to install this project without manually installing git or Python
+
+@rem change to the script's directory
+PUSHD "%~dp0"
+
+set "no_cache_dir=--no-cache-dir"
+if "%1" == "use-cache" (
+    set "no_cache_dir="
+)
+
+echo ***** Installing InvokeAI.. *****
+@rem Config
+set INSTALL_ENV_DIR=%cd%\installer_files\env
+@rem https://mamba.readthedocs.io/en/latest/installation.html
+set MICROMAMBA_DOWNLOAD_URL=https://github.com/cmdr2/stable-diffusion-ui/releases/download/v1.1/micromamba.exe
+set RELEASE_URL=https://github.com/invoke-ai/InvokeAI
+set RELEASE_SOURCEBALL=/archive/refs/heads/main.tar.gz
+set PYTHON_BUILD_STANDALONE_URL=https://github.com/indygreg/python-build-standalone/releases/download
+set PYTHON_BUILD_STANDALONE=20221002/cpython-3.10.7+20221002-x86_64-pc-windows-msvc-shared-install_only.tar.gz
+
+set PACKAGES_TO_INSTALL=
+
+call git --version >.tmp1 2>.tmp2
+if "%ERRORLEVEL%" NEQ "0" set PACKAGES_TO_INSTALL=%PACKAGES_TO_INSTALL% git
+
+@rem Cleanup
+del /q .tmp1 .tmp2
+
+@rem (if necessary) install git into a contained environment
+if "%PACKAGES_TO_INSTALL%" NEQ "" (
+    @rem download micromamba
+    echo ***** Downloading micromamba from %MICROMAMBA_DOWNLOAD_URL% to micromamba.exe *****
+
+    call curl -L "%MICROMAMBA_DOWNLOAD_URL%" > micromamba.exe
+
+    @rem test the mamba binary
+    echo ***** Micromamba version:  *****
+    call micromamba.exe --version
+
+    @rem create the installer env
+    if not exist "%INSTALL_ENV_DIR%" (
+        call micromamba.exe create -y --prefix "%INSTALL_ENV_DIR%"
+    )
+
+    echo ***** Packages to install:%PACKAGES_TO_INSTALL% *****
+
+    call micromamba.exe install -y --prefix "%INSTALL_ENV_DIR%" -c conda-forge %PACKAGES_TO_INSTALL%
+
+    if not exist "%INSTALL_ENV_DIR%" (
+        echo ----- There was a problem while installing "%PACKAGES_TO_INSTALL%" using micromamba. Cannot continue. -----
+        pause
+        exit /b
+    )
+)
+
+del /q micromamba.exe
+
+@rem For 'git' only
+set PATH=%INSTALL_ENV_DIR%\Library\bin;%PATH%
+
+@rem Download/unpack/clean up InvokeAI release sourceball
+set err_msg=----- InvokeAI source download failed -----
+echo Trying to download "%RELEASE_URL%%RELEASE_SOURCEBALL%"
+curl -L %RELEASE_URL%%RELEASE_SOURCEBALL% --output InvokeAI.tgz
+if %errorlevel% neq 0 goto err_exit
+
+set err_msg=----- InvokeAI source unpack failed -----
+tar -zxf InvokeAI.tgz
+if %errorlevel% neq 0 goto err_exit
+
+del /q InvokeAI.tgz
+
+set err_msg=----- InvokeAI source copy failed -----
+cd InvokeAI-*
+xcopy . .. /e /h
+if %errorlevel% neq 0 goto err_exit
+cd ..
+
+@rem cleanup
+for /f %%i in ('dir /b InvokeAI-*') do rd /s /q %%i
+rd /s /q .dev_scripts .github docker-build tests
+del /q requirements.in requirements-mkdocs.txt shell.nix
+
+echo ***** Unpacked InvokeAI source *****
+
+@rem Download/unpack/clean up python-build-standalone
+set err_msg=----- Python download failed -----
+curl -L %PYTHON_BUILD_STANDALONE_URL%/%PYTHON_BUILD_STANDALONE% --output python.tgz
+if %errorlevel% neq 0 goto err_exit
+
+set err_msg=----- Python unpack failed -----
+tar -zxf python.tgz
+if %errorlevel% neq 0 goto err_exit
+
+del /q python.tgz
+
+echo ***** Unpacked python-build-standalone *****
+
+@rem create venv
+set err_msg=----- problem creating venv -----
+.\python\python -E -s -m venv .venv
+if %errorlevel% neq 0 goto err_exit
+call .venv\Scripts\activate.bat
+
+echo ***** Created Python virtual environment *****
+
+@rem Print venv's Python version
+set err_msg=----- problem calling venv's python -----
+echo We're running under
+.venv\Scripts\python --version
+if %errorlevel% neq 0 goto err_exit
+
+set err_msg=----- pip update failed -----
+.venv\Scripts\python -m pip install %no_cache_dir% --no-warn-script-location --upgrade pip wheel
+if %errorlevel% neq 0 goto err_exit
+
+echo ***** Updated pip and wheel *****
+
+set err_msg=----- requirements file copy failed -----
+copy binary_installer\py3.10-windows-x86_64-cuda-reqs.txt requirements.txt
+if %errorlevel% neq 0 goto err_exit
+
+set err_msg=----- main pip install failed -----
+.venv\Scripts\python -m pip install %no_cache_dir% --no-warn-script-location -r requirements.txt
+if %errorlevel% neq 0 goto err_exit
+
+echo ***** Installed Python dependencies *****
+
+set err_msg=----- InvokeAI setup failed -----
+.venv\Scripts\python -m pip install %no_cache_dir% --no-warn-script-location -e .
+if %errorlevel% neq 0 goto err_exit
+
+copy binary_installer\invoke.bat.in .\invoke.bat
+echo ***** Installed invoke launcher script ******
+
+@rem more cleanup
+rd /s /q binary_installer installer_files
+
+@rem preload the models
+call .venv\Scripts\python ldm\invoke\config\invokeai_configure.py
+set err_msg=----- model download clone failed -----
+if %errorlevel% neq 0 goto err_exit
+deactivate
+
+echo ***** Finished downloading models *****
+
+echo All done! Execute the file invoke.bat in this directory to start InvokeAI
+pause
+exit
+
+:err_exit
+    echo %err_msg%
+    pause
+    exit

binary_installer/install.sh.in

@@ -0,0 +1,235 @@
+#!/usr/bin/env bash
+
+# ensure we're in the correct folder in case user's CWD is somewhere else
+scriptdir=$(dirname "$0")
+cd "$scriptdir"
+
+set -euo pipefail
+IFS=$'\n\t'
+
+function _err_exit {
+    if test "$1" -ne 0
+    then
+        echo -e "Error code $1; Error caught was '$2'"
+        read -p "Press any key to exit..."
+        exit
+    fi
+}
+
+# This script will install git (if not found on the PATH variable)
+#  using micromamba (an 8mb static-linked single-file binary, conda replacement).
+# For users who already have git, this step will be skipped.
+
+# Next, it'll download the project's source code.
+# Then it will download a self-contained, standalone Python and unpack it.
+# Finally, it'll create the Python virtual environment and preload the models.
+
+# This enables a user to install this project without manually installing git or Python
+
+echo -e "\n***** Installing InvokeAI into $(pwd)... *****\n"
+
+export no_cache_dir="--no-cache-dir"
+if [ $# -ge 1 ]; then
+    if [ "$1" = "use-cache" ]; then
+        export no_cache_dir=""
+    fi
+fi
+
+
+OS_NAME=$(uname -s)
+case "${OS_NAME}" in
+    Linux*)     OS_NAME="linux";;
+    Darwin*)    OS_NAME="darwin";;
+    *)          echo -e "\n----- Unknown OS: $OS_NAME! This script runs only on Linux or macOS -----\n" && exit
+esac
+
+OS_ARCH=$(uname -m)
+case "${OS_ARCH}" in
+    x86_64*)    ;;
+    arm64*)     ;;
+    *)          echo -e "\n----- Unknown system architecture: $OS_ARCH! This script runs only on x86_64 or arm64 -----\n" && exit
+esac
+
+# https://mamba.readthedocs.io/en/latest/installation.html
+MAMBA_OS_NAME=$OS_NAME
+MAMBA_ARCH=$OS_ARCH
+if [ "$OS_NAME" == "darwin" ]; then
+    MAMBA_OS_NAME="osx"
+fi
+
+if [ "$OS_ARCH" == "linux" ]; then
+    MAMBA_ARCH="aarch64"
+fi
+
+if [ "$OS_ARCH" == "x86_64" ]; then
+    MAMBA_ARCH="64"
+fi
+
+PY_ARCH=$OS_ARCH
+if [ "$OS_ARCH" == "arm64" ]; then
+    PY_ARCH="aarch64"
+fi
+
+# Compute device ('cd' segment of reqs files) detect goes here
+# This needs a ton of work
+# Suggestions:
+#   - lspci
+#   - check $PATH for nvidia-smi, gtt CUDA/GPU version from output
+#   - Surely there's a similar utility for AMD?
+CD="cuda"
+if [ "$OS_NAME" == "darwin" ] && [ "$OS_ARCH" == "arm64" ]; then
+    CD="mps"
+fi
+
+# config
+INSTALL_ENV_DIR="$(pwd)/installer_files/env"
+MICROMAMBA_DOWNLOAD_URL="https://micro.mamba.pm/api/micromamba/${MAMBA_OS_NAME}-${MAMBA_ARCH}/latest"
+RELEASE_URL=https://github.com/invoke-ai/InvokeAI
+RELEASE_SOURCEBALL=/archive/refs/heads/main.tar.gz
+PYTHON_BUILD_STANDALONE_URL=https://github.com/indygreg/python-build-standalone/releases/download
+if [ "$OS_NAME" == "darwin" ]; then
+    PYTHON_BUILD_STANDALONE=20221002/cpython-3.10.7+20221002-${PY_ARCH}-apple-darwin-install_only.tar.gz
+elif [ "$OS_NAME" == "linux" ]; then
+    PYTHON_BUILD_STANDALONE=20221002/cpython-3.10.7+20221002-${PY_ARCH}-unknown-linux-gnu-install_only.tar.gz
+fi
+echo "INSTALLING $RELEASE_SOURCEBALL FROM $RELEASE_URL"
+
+PACKAGES_TO_INSTALL=""
+
+if ! hash "git" &>/dev/null; then PACKAGES_TO_INSTALL="$PACKAGES_TO_INSTALL git"; fi
+
+# (if necessary) install git and conda into a contained environment
+if [ "$PACKAGES_TO_INSTALL" != "" ]; then
+    # download micromamba
+    echo -e "\n***** Downloading micromamba from $MICROMAMBA_DOWNLOAD_URL to micromamba *****\n"
+
+    curl -L "$MICROMAMBA_DOWNLOAD_URL" | tar -xvjO bin/micromamba > micromamba
+
+    chmod u+x ./micromamba
+
+    # test the mamba binary
+    echo -e "\n***** Micromamba version: *****\n"
+    ./micromamba --version
+
+    # create the installer env
+    if [ ! -e "$INSTALL_ENV_DIR" ]; then
+        ./micromamba create -y --prefix "$INSTALL_ENV_DIR"
+    fi
+
+    echo -e "\n***** Packages to install:$PACKAGES_TO_INSTALL *****\n"
+
+    ./micromamba install -y --prefix "$INSTALL_ENV_DIR" -c conda-forge "$PACKAGES_TO_INSTALL"
+
+    if [ ! -e "$INSTALL_ENV_DIR" ]; then
+        echo -e "\n----- There was a problem while initializing micromamba. Cannot continue. -----\n"
+        exit
+    fi
+fi
+
+rm -f micromamba.exe
+
+export PATH="$INSTALL_ENV_DIR/bin:$PATH"
+
+# Download/unpack/clean up InvokeAI release sourceball
+_err_msg="\n----- InvokeAI source download failed -----\n"
+curl -L $RELEASE_URL/$RELEASE_SOURCEBALL --output InvokeAI.tgz
+_err_exit $? _err_msg
+_err_msg="\n----- InvokeAI source unpack failed -----\n"
+tar -zxf InvokeAI.tgz
+_err_exit $? _err_msg
+
+rm -f InvokeAI.tgz
+
+_err_msg="\n----- InvokeAI source copy failed -----\n"
+cd InvokeAI-*
+cp -r . ..
+_err_exit $? _err_msg
+cd ..
+
+# cleanup
+rm -rf InvokeAI-*/
+rm -rf .dev_scripts/ .github/ docker-build/ tests/ requirements.in requirements-mkdocs.txt shell.nix
+
+echo -e "\n***** Unpacked InvokeAI source *****\n"
+
+# Download/unpack/clean up python-build-standalone
+_err_msg="\n----- Python download failed -----\n"
+curl -L $PYTHON_BUILD_STANDALONE_URL/$PYTHON_BUILD_STANDALONE --output python.tgz
+_err_exit $? _err_msg
+_err_msg="\n----- Python unpack failed -----\n"
+tar -zxf python.tgz
+_err_exit $? _err_msg
+
+rm -f python.tgz
+
+echo -e "\n***** Unpacked python-build-standalone *****\n"
+
+# create venv
+_err_msg="\n----- problem creating venv -----\n"
+
+if [ "$OS_NAME" == "darwin" ]; then
+    # patch sysconfig so that extensions can build properly
+    # adapted from https://github.com/cashapp/hermit-packages/commit/fcba384663892f4d9cfb35e8639ff7a28166ee43
+    PYTHON_INSTALL_DIR="$(pwd)/python"
+    SYSCONFIG="$(echo python/lib/python*/_sysconfigdata_*.py)"
+    TMPFILE="$(mktemp)"
+    chmod +w "${SYSCONFIG}"
+    cp "${SYSCONFIG}" "${TMPFILE}"
+    sed "s,'/install,'${PYTHON_INSTALL_DIR},g" "${TMPFILE}" > "${SYSCONFIG}"
+    rm -f "${TMPFILE}"
+fi
+
+./python/bin/python3 -E -s -m venv .venv
+_err_exit $? _err_msg
+source .venv/bin/activate
+
+echo -e "\n***** Created Python virtual environment *****\n"
+
+# Print venv's Python version
+_err_msg="\n----- problem calling venv's python -----\n"
+echo -e "We're running under"
+.venv/bin/python3 --version
+_err_exit $? _err_msg
+
+_err_msg="\n----- pip update failed -----\n"
+.venv/bin/python3 -m pip install $no_cache_dir --no-warn-script-location --upgrade pip
+_err_exit $? _err_msg
+
+echo -e "\n***** Updated pip *****\n"
+
+_err_msg="\n----- requirements file copy failed -----\n"
+cp binary_installer/py3.10-${OS_NAME}-"${OS_ARCH}"-${CD}-reqs.txt requirements.txt
+_err_exit $? _err_msg
+
+_err_msg="\n----- main pip install failed -----\n"
+.venv/bin/python3 -m pip install $no_cache_dir --no-warn-script-location -r requirements.txt
+_err_exit $? _err_msg
+
+echo -e "\n***** Installed Python dependencies *****\n"
+
+_err_msg="\n----- InvokeAI setup failed -----\n"
+.venv/bin/python3 -m pip install $no_cache_dir --no-warn-script-location -e .
+_err_exit $? _err_msg
+
+echo -e "\n***** Installed InvokeAI *****\n"
+
+cp binary_installer/invoke.sh.in ./invoke.sh
+chmod a+rx ./invoke.sh
+echo -e "\n***** Installed invoke launcher script ******\n"
+
+# more cleanup
+rm -rf binary_installer/ installer_files/
+
+# preload the models
+.venv/bin/python3 scripts/configure_invokeai.py
+_err_msg="\n----- model download clone failed -----\n"
+_err_exit $? _err_msg
+deactivate
+
+echo -e "\n***** Finished downloading models *****\n"
+
+echo "All done! Run the command"
+echo "  $scriptdir/invoke.sh"
+echo "to start InvokeAI."
+read -p "Press any key to exit..."
+exit

binary_installer/invoke.bat.in

@@ -0,0 +1,36 @@
+@echo off
+
+PUSHD "%~dp0"
+call .venv\Scripts\activate.bat
+
+echo Do you want to generate images using the
+echo 1. command-line
+echo 2. browser-based UI
+echo OR
+echo 3. open the developer console
+set /p choice="Please enter 1, 2 or 3: "
+if /i "%choice%" == "1" (
+    echo Starting the InvokeAI command-line.
+    .venv\Scripts\python scripts\invoke.py %*
+) else if /i "%choice%" == "2" (
+    echo Starting the InvokeAI browser-based UI.
+    .venv\Scripts\python scripts\invoke.py --web %*
+) else if /i "%choice%" == "3" (
+    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 (
+    echo Invalid selection
+    pause
+    exit /b
+)
+
+deactivate

binary_installer/invoke.sh.in

@@ -0,0 +1,46 @@
+#!/usr/bin/env sh
+
+set -eu
+
+. .venv/bin/activate
+
+# set required env var for torch on mac MPS
+ if [ "$(uname -s)" == "Darwin" ]; then
+     export PYTORCH_ENABLE_MPS_FALLBACK=1
+ fi
+
+echo "Do you want to generate images using the"
+echo "1. command-line"
+echo "2. browser-based UI"
+echo "OR"
+echo "3. open the developer console"
+echo "Please enter 1, 2, or 3:"
+read choice
+
+case $choice in
+    1)
+        printf "\nStarting the InvokeAI command-line..\n";
+        .venv/bin/python scripts/invoke.py $*;
+    ;;
+    2)
+        printf "\nStarting the InvokeAI browser-based UI..\n";
+        .venv/bin/python scripts/invoke.py --web $*;
+    ;;
+    3)
+        printf "\nDeveloper Console:\n";
+        printf "Python command is:\n\t";
+        which python;
+        printf "Python version is:\n\t";
+        python --version;
+        echo "*************************"
+        echo "You are now in your user shell ($SHELL) with the local InvokeAI Python virtual environment activated,";
+        echo "so that you can troubleshoot this InvokeAI installation as necessary.";
+        printf "*************************\n"
+        echo "*** Type \`exit\` to quit this shell and deactivate the Python virtual environment *** ";
+        /usr/bin/env "$SHELL";
+    ;;
+    *)
+        echo "Invalid selection";
+        exit
+    ;;
+esac

binary_installer/readme.txt

@@ -0,0 +1,17 @@
+InvokeAI
+
+Project homepage: https://github.com/invoke-ai/InvokeAI
+
+Installation on Windows:
+    NOTE: You might need to enable Windows Long Paths. If you're not sure,
+    then you almost certainly need to. Simply double-click the 'WinLongPathsEnabled.reg'
+    file. Note that you will need to have admin privileges in order to
+    do this.
+
+    Please double-click the 'install.bat' file (while keeping it inside the invokeAI folder).
+
+Installation on Linux and Mac:
+    Please open the terminal, and run './install.sh' (while keeping it inside the invokeAI folder).
+
+After installation, please run the 'invoke.bat' file (on Windows) or 'invoke.sh'
+file (on Linux/Mac) to start InvokeAI.

binary_installer/requirements.in

@@ -0,0 +1,33 @@
+--prefer-binary
+--extra-index-url https://download.pytorch.org/whl/torch_stable.html
+--extra-index-url https://download.pytorch.org/whl/cu116
+--trusted-host https://download.pytorch.org
+accelerate~=0.15
+albumentations
+diffusers[torch]~=0.11
+einops
+eventlet
+flask_cors
+flask_socketio
+flaskwebgui==1.0.3
+getpass_asterisk
+imageio-ffmpeg
+pyreadline3
+realesrgan
+send2trash
+streamlit
+taming-transformers-rom1504
+test-tube
+torch-fidelity
+torch==1.12.1 ; platform_system == 'Darwin'
+torch==1.12.0+cu116 ; platform_system == 'Linux' or platform_system == 'Windows'
+torchvision==0.13.1 ; platform_system == 'Darwin'
+torchvision==0.13.0+cu116 ; platform_system == 'Linux' or platform_system == 'Windows'
+transformers
+picklescan
+https://github.com/openai/CLIP/archive/d50d76daa670286dd6cacf3bcd80b5e4823fc8e1.zip
+https://github.com/invoke-ai/clipseg/archive/1f754751c85d7d4255fa681f4491ff5711c1c288.zip
+https://github.com/invoke-ai/GFPGAN/archive/3f5d2397361199bc4a91c08bb7d80f04d7805615.zip ; platform_system=='Windows'
+https://github.com/invoke-ai/GFPGAN/archive/c796277a1cf77954e5fc0b288d7062d162894248.zip ; platform_system=='Linux' or platform_system=='Darwin'
+https://github.com/Birch-san/k-diffusion/archive/363386981fee88620709cf8f6f2eea167bd6cd74.zip
+https://github.com/invoke-ai/PyPatchMatch/archive/129863937a8ab37f6bbcec327c994c0f932abdbc.zip

docs/contributing/INVOCATIONS.md

@@ -19,56 +19,31 @@ An invocation looks like this:
 ```py
 class UpscaleInvocation(BaseInvocation):
     """Upscales an image."""
-
-    # fmt: off
-    type: Literal["upscale"] = "upscale"
+    type: Literal['upscale'] = 'upscale'
 
     # Inputs
-    image: Union[ImageField, None] = Field(description="The input image", default=None)
-    strength: float                = Field(default=0.75, gt=0, le=1, description="The strength")
-    level: Literal[2, 4]           = Field(default=2, description="The upscale level")
-    # fmt: on
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["upscaling", "image"],
-            },
-        }
+    image: Union[ImageField,None] = Field(description="The input image")
+    strength: float               = Field(default=0.75, gt=0, le=1, description="The strength")
+    level: Literal[2,4]           = Field(default=2, description = "The upscale level")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
-        )
-        results = context.services.restoration.upscale_and_reconstruct(
-            image_list=[[image, 0]],
-            upscale=(self.level, self.strength),
-            strength=0.0,  # GFPGAN strength
-            save_original=False,
-            image_callback=None,
+        image = context.services.images.get(self.image.image_type, self.image.image_name)
+        results = context.services.generate.upscale_and_reconstruct(
+            image_list     = [[image, 0]],
+            upscale        = (self.level, self.strength),
+            strength       = 0.0, # GFPGAN strength
+            save_original  = False,
+            image_callback = None,
         )
 
         # Results are image and seed, unwrap for now
         # TODO: can this return multiple results?
-        image_dto = context.services.images.create(
-            image=results[0][0],
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(context.graph_execution_state_id, self.id)
+        context.services.images.save(image_type, image_name, results[0][0])
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image = ImageField(image_type = image_type, image_name = image_name)
         )
-
 ```
 
 Each portion is important to implement correctly.
@@ -120,67 +95,25 @@ Finally, note that for all linking, the `type` of the linked fields must match.
 If the `name` also matches, then the field can be **automatically linked** to a
 previous invocation by name and matching.
 
-### Config
-
-```py
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["upscaling", "image"],
-            },
-        }
-```
-
-This is an optional configuration for the invocation. It inherits from
-pydantic's model `Config` class, and it used primarily to customize the
-autogenerated OpenAPI schema.
-
-The UI relies on the OpenAPI schema in two ways:
-
-- An API client & Typescript types are generated from it. This happens at build
-  time.
-- The node editor parses the schema into a template used by the UI to create the
-  node editor UI. This parsing happens at runtime.
-
-In this example, a `ui` key has been added to the `schema_extra` dict to provide
-some tags for the UI, to facilitate filtering nodes.
-
-See the Schema Generation section below for more information.
-
 ### Invoke Function
 
 ```py
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
-        )
-        results = context.services.restoration.upscale_and_reconstruct(
-            image_list=[[image, 0]],
-            upscale=(self.level, self.strength),
-            strength=0.0,  # GFPGAN strength
-            save_original=False,
-            image_callback=None,
+        image = context.services.images.get(self.image.image_type, self.image.image_name)
+        results = context.services.generate.upscale_and_reconstruct(
+            image_list     = [[image, 0]],
+            upscale        = (self.level, self.strength),
+            strength       = 0.0, # GFPGAN strength
+            save_original  = False,
+            image_callback = None,
         )
 
         # Results are image and seed, unwrap for now
-        # TODO: can this return multiple results?
-        image_dto = context.services.images.create(
-            image=results[0][0],
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(context.graph_execution_state_id, self.id)
+        context.services.images.save(image_type, image_name, results[0][0])
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image = ImageField(image_type = image_type, image_name = image_name)
         )
 ```
 
@@ -202,16 +135,9 @@ scenarios. If you need functionality, please provide it as a service in the
 ```py
 class ImageOutput(BaseInvocationOutput):
     """Base class for invocations that output an image"""
+    type: Literal['image'] = 'image'
 
-    # fmt: off
-    type: Literal["image_output"] = "image_output"
-    image:      ImageField = Field(default=None, description="The output image")
-    width:             int = Field(description="The width of the image in pixels")
-    height:            int = Field(description="The height of the image in pixels")
-    # fmt: on
-
-    class Config:
-        schema_extra = {"required": ["type", "image", "width", "height"]}
+    image: ImageField = Field(default=None, description="The output image")
 ```
 
 Output classes look like an invocation class without the invoke method. Prefer
@@ -242,36 +168,35 @@ Here's that `ImageOutput` class, without the needed schema customisation:
 class ImageOutput(BaseInvocationOutput):
     """Base class for invocations that output an image"""
 
-    # fmt: off
-    type: Literal["image_output"] = "image_output"
+    type: Literal["image"] = "image"
     image:      ImageField = Field(default=None, description="The output image")
-    width:             int = Field(description="The width of the image in pixels")
-    height:            int = Field(description="The height of the image in pixels")
-    # fmt: on
 ```
 
-The OpenAPI schema that results from this `ImageOutput` will have the `type`,
-`image`, `width` and `height` properties marked as optional, even though we know
-they will always have a value.
+The generated OpenAPI schema, and all clients/types generated from it, will have
+the `type` and `image` properties marked as optional, even though we know they
+will always have a value by the time we can interact with them via the API.
+
+Here's the same class, but with the schema customisation added:
 
 ```python
 class ImageOutput(BaseInvocationOutput):
     """Base class for invocations that output an image"""
 
-    # fmt: off
-    type: Literal["image_output"] = "image_output"
+    type: Literal["image"] = "image"
     image:      ImageField = Field(default=None, description="The output image")
-    width:             int = Field(description="The width of the image in pixels")
-    height:            int = Field(description="The height of the image in pixels")
-    # fmt: on
 
-    # Add schema customization
     class Config:
-        schema_extra = {"required": ["type", "image", "width", "height"]}
+        schema_extra = {
+            'required': [
+                'type',
+                'image',
+            ]
+        }
 ```
 
-With the customization in place, the schema will now show these properties as
-required, obviating the need for extensive null checks in client code.
+The resultant schema (and any API client or types generated from it) will now
+have see `type` as string literal `"image"` and `image` as an `ImageField`
+object.
 
 See this `pydantic` issue for discussion on this solution:
 <https://github.com/pydantic/pydantic/discussions/4577>

docs/features/LOGGING.md

@@ -1,171 +0,0 @@
----
-title: Controlling Logging
----
-
-# :material-image-off: Controlling Logging
-
-## Controlling How InvokeAI Logs Status Messages
-
-InvokeAI logs status messages using a configurable logging system. You
-can log to the terminal window, to a designated file on the local
-machine, to the syslog facility on a Linux or Mac, or to a properly
-configured web server. You can configure several logs at the same
-time, and control the level of message logged and the logging format
-(to a limited extent).
-
-Three command-line options control logging:
-
-### `--log_handlers <handler1> <handler2> ...`
-
-This option activates one or more log handlers. Options are "console",
-"file", "syslog" and "http". To specify more than one, separate them
-by spaces:
-
-```bash
-invokeai-web --log_handlers console syslog=/dev/log file=C:\Users\fred\invokeai.log
-```
-
-The format of these options is described below.
-
-### `--log_format {plain|color|legacy|syslog}`
-
-This controls the format of log messages written to the console. Only
-the "console" log handler is currently affected by this setting.
-
-* "plain" provides formatted messages like this:
-
-```bash
-
-[2023-05-24 23:18:2[2023-05-24 23:18:50,352]::[InvokeAI]::DEBUG --> this is a debug message
-[2023-05-24 23:18:50,352]::[InvokeAI]::INFO --> this is an informational messages
-[2023-05-24 23:18:50,352]::[InvokeAI]::WARNING --> this is a warning
-[2023-05-24 23:18:50,352]::[InvokeAI]::ERROR --> this is an error
-[2023-05-24 23:18:50,352]::[InvokeAI]::CRITICAL --> this is a critical error
-```
-
-* "color" produces similar output, but the text will be color coded to
-indicate the severity of the message.
-
-* "legacy" produces output similar to InvokeAI versions 2.3 and earlier:
-
-```bash
-### this is a critical error
-*** this is an error
-** this is a warning
->> this is an informational messages
-   | this is a debug message
-```
-
-* "syslog" produces messages suitable for syslog entries:
-
-```bash
-InvokeAI [2691178] <CRITICAL> this is a critical error
-InvokeAI [2691178] <ERROR> this is an error
-InvokeAI [2691178] <WARNING> this is a warning
-InvokeAI [2691178] <INFO> this is an informational messages
-InvokeAI [2691178] <DEBUG> this is a debug message
-```
-
-(note that the date, time and hostname will be added by the syslog
-system)
-
-### `--log_level {debug|info|warning|error|critical}`
-
-Providing this command-line option will cause only messages at the
-specified level or above to be emitted.
-
-## Console logging
-
-When "console" is provided to `--log_handlers`, messages will be
-written to the command line window in which InvokeAI was launched. By
-default, the color formatter will be used unless overridden by
-`--log_format`.
-
-## File logging
-
-When "file" is provided to `--log_handlers`, entries will be written
-to the file indicated in the path argument. By default, the "plain"
-format will be used:
-
-```bash
-invokeai-web --log_handlers file=/var/log/invokeai.log
-```
-
-## Syslog logging
-
-When "syslog" is requested, entries will be sent to the syslog
-system. There are a variety of ways to control where the log message
-is sent:
-
-* Send to the local machine using the `/dev/log` socket:
-
-```
-invokeai-web --log_handlers syslog=/dev/log
-```
-
-* Send to the local machine using a UDP message:
-
-```
-invokeai-web --log_handlers syslog=localhost
-```
-
-* Send to the local machine using a UDP message on a nonstandard
-  port:
-
-```
-invokeai-web --log_handlers syslog=localhost:512
-```
-
-* Send to a remote machine named "loghost" on the local LAN using
-  facility LOG_USER and UDP packets:
-
-```
-invokeai-web --log_handlers syslog=loghost,facility=LOG_USER,socktype=SOCK_DGRAM
-```
-
-This can be abbreviated `syslog=loghost`, as LOG_USER and SOCK_DGRAM
-are defaults.
-
-* Send to a remote machine named "loghost" using the facility LOCAL0
-  and using a TCP socket:
-
-```
-invokeai-web --log_handlers syslog=loghost,facility=LOG_LOCAL0,socktype=SOCK_STREAM
-```
-
-If no arguments are specified (just a bare "syslog"), then the logging
-system will look for a UNIX socket named `/dev/log`, and if not found
-try to send a UDP message to `localhost`. The Macintosh OS used to
-support logging to a socket named `/var/run/syslog`, but this feature
-has since been disabled.
-
-## Web logging
-
-If you have access to a web server that is configured to log messages
-when a particular URL is requested, you can log using the "http"
-method:
-
-```
-invokeai-web --log_handlers http=http://my.server/path/to/logger,method=POST
-```
-
-The optional [,method=] part can be used to specify whether the URL
-accepts GET (default) or POST messages.
-
-Currently password authentication and SSL are not supported.
-
-## Using the configuration file
-
-You can set and forget logging options by adding a "Logging" section
-to `invokeai.yaml`:
-
-```
-InvokeAI:
-  [... other settings...]
-  Logging:
-    log_handlers:
-       - console
-       - syslog=/dev/log
-    log_level: info
-    log_format: color
-```

docs/features/index.md

@@ -57,9 +57,6 @@ Personalize models by adding your own style or subjects.
 ## * [The NSFW Checker](NSFW.md)
 Prevent InvokeAI from displaying unwanted racy images.
 
-## * [Controlling Logging](LOGGING.md)
-Control how InvokeAI logs status messages.
-
 ## * [Miscellaneous](OTHER.md)
 Run InvokeAI on Google Colab, generate images with repeating patterns,
 batch process a file of prompts, increase the "creativity" of image

docs/index.md

@@ -67,7 +67,7 @@ title: Home
 implementation of Stable Diffusion, the open source text-to-image and
 image-to-image generator. It provides a streamlined process with various new
 features and options to aid the image generation process. It runs on Windows,
-Mac and Linux machines, and runs on GPU cards with as little as 4 GB of RAM.
+Mac and Linux machines, and runs on GPU cards with as little as 4 GB or RAM.
 
 **Quick links**: [<a href="https://discord.gg/ZmtBAhwWhy">Discord Server</a>]
 [<a href="https://github.com/invoke-ai/InvokeAI/">Code and Downloads</a>] [<a

docs/installation/010_INSTALL_AUTOMATED.md

@@ -89,7 +89,7 @@ experimental versions later.
          sudo apt update
          sudo apt install -y software-properties-common
          sudo add-apt-repository -y ppa:deadsnakes/ppa
-         sudo apt install -y python3.10 python3-pip python3.10-venv
+         sudo apt install python3.10 python3-pip python3.10-venv
          sudo update-alternatives --install /usr/local/bin/python python /usr/bin/python3.10 3
          ```
 

docs/installation/020_INSTALL_MANUAL.md

@@ -216,7 +216,7 @@ manager, please follow these steps:
 9.  Run the command-line- or the web- interface:
 
     From within INVOKEAI_ROOT, activate the environment
-    (with `source .venv/bin/activate` or `.venv\scripts\activate`), and then run
+    (with `source .venv/bin/activate` or `.venv\scripts\activate), and then run
     the script `invokeai`. If the virtual environment you selected is NOT inside
     INVOKEAI_ROOT, then you must specify the path to the root directory by adding
     `--root_dir \path\to\invokeai` to the commands below:

installer/install.bat.in

@@ -38,7 +38,6 @@ echo    https://learn.microsoft.com/en-US/cpp/windows/latest-supported-vc-redist
 echo.
 echo See %INSTRUCTIONS% for more details.
 echo.
-echo "For the best user experience we suggest enlarging or maximizing this window now."
 pause
 
 @rem ---------------------------- check Python version ---------------

installer/install.sh.in

@@ -25,8 +25,7 @@ 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."
-    echo "For the best user experience we suggest enlarging or maximizing this window now."
+    echo "Please install Python 3.9 or higher before running this script. See instructions at $INSTRUCTIONS for help."
     read -p "Press any key to exit"
     exit -1
 fi

installer/lib/installer.py

@@ -247,8 +247,8 @@ class InvokeAiInstance:
             pip[
                 "install",
                 "--require-virtualenv",
-                "torch~=2.0.0",
-                "torchvision>=0.14.1",
+                "torch",
+                "torchvision",
                 "--force-reinstall",
                 "--find-links" if find_links is not None else None,
                 find_links,

installer/lib/messages.py

@@ -293,8 +293,6 @@ def introduction() -> None:
                 "3. Create initial configuration files.",
                 "",
                 "[i]At any point you may interrupt this program and resume later.",
-                "",
-                "[b]For the best user experience, please enlarge or maximize this window",
             ),
         )
     )

installer/templates/invoke.bat.in

@@ -7,42 +7,42 @@ call .venv\Scripts\activate.bat
 set INVOKEAI_ROOT=.
 
 :start
-echo Desired action:
-echo 1. Generate images with the browser-based interface
-echo 2. Explore InvokeAI nodes using a command-line interface
-echo 3. Run textual inversion training
-echo 4. Merge models (diffusers type only)
-echo 5. Download and install models
-echo 6. Change InvokeAI startup options
-echo 7. Re-run the configure script to fix a broken install
-echo 8. Open the developer console
-echo 9. Update InvokeAI
-echo 10. Command-line help
-echo Q - Quit
-set /P choice="Please enter 1-10, Q: [2] "
-if not defined choice set choice=2
-IF /I "%choice%" == "1" (
-    echo Starting the InvokeAI browser-based UI..
-    python .venv\Scripts\invokeai-web.exe %*
-) ELSE IF /I "%choice%" == "2" (
+echo Do you want to generate images using the
+echo 1. command-line interface
+echo 2. browser-based UI
+echo 3. run textual inversion training
+echo 4. merge models (diffusers type only)
+echo 5. download and install models
+echo 6. change InvokeAI startup options
+echo 7. re-run the configure script to fix a broken install
+echo 8. open the developer console
+echo 9. update InvokeAI
+echo 10. command-line help
+echo Q - quit
+set /P restore="Please enter 1-10, Q: [2] "
+if not defined restore set restore=2
+IF /I "%restore%" == "1" (
     echo Starting the InvokeAI command-line..
     python .venv\Scripts\invokeai.exe %*
-) ELSE IF /I "%choice%" == "3" (
+) ELSE IF /I "%restore%" == "2" (
+    echo Starting the InvokeAI browser-based UI..
+    python .venv\Scripts\invokeai.exe --web %*
+) ELSE IF /I "%restore%" == "3" (
     echo Starting textual inversion training..
     python .venv\Scripts\invokeai-ti.exe --gui
-) ELSE IF /I "%choice%" == "4" (
+) ELSE IF /I "%restore%" == "4" (
     echo Starting model merging script..
     python .venv\Scripts\invokeai-merge.exe --gui
-) ELSE IF /I "%choice%" == "5" (
+) ELSE IF /I "%restore%" == "5" (
     echo Running invokeai-model-install...
     python .venv\Scripts\invokeai-model-install.exe
-) ELSE IF /I "%choice%" == "6" (
+) ELSE IF /I "%restore%" == "6" (
     echo Running invokeai-configure...
     python .venv\Scripts\invokeai-configure.exe --skip-sd-weight --skip-support-models
-) ELSE IF /I "%choice%" == "7" (
+) ELSE IF /I "%restore%" == "7" (
     echo Running invokeai-configure...
     python .venv\Scripts\invokeai-configure.exe --yes --default_only
-) ELSE IF /I "%choice%" == "8" (
+) ELSE IF /I "%restore%" == "8" (
     echo Developer Console
     echo Python command is:
     where python
@@ -54,15 +54,15 @@ IF /I "%choice%" == "1" (
     echo *************************
     echo *** Type `exit` to quit this shell and deactivate the Python virtual environment ***
     call cmd /k
-) ELSE IF /I "%choice%" == "9" (
+) ELSE IF /I "%restore%" == "9" (
    echo Running invokeai-update...
    python .venv\Scripts\invokeai-update.exe %*
-) ELSE IF /I "%choice%" == "10" (
+) ELSE IF /I "%restore%" == "10" (
     echo Displaying command line help...
     python .venv\Scripts\invokeai.exe --help %*
     pause
     exit /b
-) ELSE IF /I "%choice%" == "q" (
+) ELSE IF /I "%restore%" == "q" (
     echo Goodbye!
     goto ending
 ) ELSE (

installer/templates/invoke.sh.in

@@ -1,10 +1,5 @@
 #!/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,
@@ -16,168 +11,85 @@
 
 set -eu
 
-# Ensure we're in the correct folder in case user's CWD is somewhere else
+# ensure we're in the correct folder in case user's CWD is somewhere else
 scriptdir=$(dirname "$0")
 cd "$scriptdir"
 
 . .venv/bin/activate
 
 export INVOKEAI_ROOT="$scriptdir"
-PARAMS=$@
 
-# Check to see if dialog is installed (it seems to be fairly standard, but good to check regardless) and if the user has passed the --no-tui argument to disable the dialog TUI
-tui=true
-if command -v dialog &>/dev/null; then
-    # This must use $@ to properly loop through the arguments passed by the user
-    for arg in "$@"; do
-        if [ "$arg" == "--no-tui" ]; then
-            tui=false
-            # Remove the --no-tui argument to avoid errors later on when passing arguments to InvokeAI
-            PARAMS=$(echo "$PARAMS" | sed 's/--no-tui//')
-            break
-        fi
-    done
-else
-    tui=false
-fi
-
-# Set required env var for torch on mac MPS
+# set required env var for torch on mac MPS
 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 "Explore InvokeAI nodes using a command-line interface\n"
-        invokeai $PARAMS
-        ;;
-    3)
-        clear
-        printf "Textual inversion training\n"
-        invokeai-ti --gui $PARAMS
-        ;;
-    4)
-        clear
-        printf "Merge models (diffusers type only)\n"
-        invokeai-merge --gui $PARAMS
-        ;;
-    5)
-        clear
-        printf "Download and install models\n"
-        invokeai-model-install --root ${INVOKEAI_ROOT}
-        ;;
-    6)
-        clear
-        printf "Change InvokeAI startup options\n"
-        invokeai-configure --root ${INVOKEAI_ROOT} --skip-sd-weights --skip-support-models
-        ;;
-    7)
-        clear
-        printf "Re-run the configure script to fix a broken install\n"
-        invokeai-configure --root ${INVOKEAI_ROOT} --yes --default_only
-        ;;
-    8)
-        clear
-        printf "Open the developer console\n"
-        file_name=$(basename "${BASH_SOURCE[0]}")
-        bash --init-file "$file_name"
-        ;;
-    9)
-        clear
-        printf "Update InvokeAI\n"
-        invokeai-update
-        ;;
-    10)
-        clear
-        printf "Command-line help\n"
-        invokeai --help
-        ;;
-    "HELP 1")
-        clear
-        printf "Command-line help\n"
-        invokeai --help
-        ;;
-    *)
-        clear
-        printf "Exiting...\n"
-        exit
-        ;;
-    esac
-    clear
-}
-
-# Dialog-based TUI for launcing Invoke functions
-do_dialog() {
-    options=(
-        1 "Generate images with a browser-based interface"
-        2 "Generate images using a command-line interface"
-        3 "Textual inversion training"
-        4 "Merge models (diffusers type only)"
-        5 "Download and install models"
-        6 "Change InvokeAI startup options"
-        7 "Re-run the configure script to fix a broken install"
-        8 "Open the developer console"
-        9 "Update InvokeAI")
-
-    choice=$(dialog --clear \
-        --backtitle "\Zb\Zu\Z3InvokeAI" \
-        --colors \
-        --title "What would you like to do?" \
-        --ok-label "Run" \
-        --cancel-label "Exit" \
-        --help-button \
-        --help-label "CLI Help" \
-        --menu "Select an option:" \
-        0 0 0 \
-        "${options[@]}" \
-        2>&1 >/dev/tty) || clear
-    do_choice "$choice"
-    clear
-}
-
-# Command-line interface for launching Invoke functions
-do_line_input() {
-    clear
-    printf " ** For a more attractive experience, please install the 'dialog' utility using your package manager. **\n\n"
-    printf "What would you like to do?\n"
-    printf "1: Generate images using the browser-based interface\n"
-    printf "2: Explore InvokeAI nodes using the command-line interface\n"
-    printf "3: Run textual inversion training\n"
-    printf "4: Merge models (diffusers type only)\n"
-    printf "5: Download and install models\n"
-    printf "6: Change InvokeAI startup options\n"
-    printf "7: Re-run the configure script to fix a broken install\n"
-    printf "8: Open the developer console\n"
-    printf "9: Update InvokeAI\n"
-    printf "10: Command-line help\n"
-    printf "Q: Quit\n\n"
-    read -p "Please enter 1-10, Q: [1] " yn
-    choice=${yn:='1'}
-    do_choice $choice
-    clear
-}
-
-# Main IF statement for launching Invoke with either the TUI or CLI, and for checking if the user is in the developer console
 if [ "$0" != "bash" ]; then
-    while true; do
-        if $tui; then
-            # .dialogrc must be located in the same directory as the invoke.sh script
-            export DIALOGRC="./.dialogrc"
-            do_dialog
-        else
-            do_line_input
-        fi
-    done
+  while true
+  do
+    echo "Do you want to generate images using the"
+    echo "1. command-line interface"
+    echo "2. browser-based UI"
+    echo "3. run textual inversion training"
+    echo "4. merge models (diffusers type only)"
+    echo "5. download and install models"
+    echo "6. change InvokeAI startup options"
+    echo "7. re-run the configure script to fix a broken install"
+    echo "8. open the developer console"
+    echo "9. update InvokeAI"
+    echo "10. command-line help"
+    echo "Q - Quit"
+    echo ""
+    read -p "Please enter 1-10, Q: [2] " yn
+    choice=${yn:='2'}
+    case $choice in
+        1)
+            echo "Starting the InvokeAI command-line..."
+            invokeai $@
+            ;;
+        2)
+            echo "Starting the InvokeAI browser-based UI..."
+            invokeai --web $@
+            ;;
+        3)
+            echo "Starting Textual Inversion:"
+            invokeai-ti --gui $@
+            ;;
+        4)
+            echo "Merging Models:"
+            invokeai-merge --gui $@
+            ;;
+        5)
+            invokeai-model-install --root ${INVOKEAI_ROOT}
+            ;;
+        6)
+            invokeai-configure --root ${INVOKEAI_ROOT} --skip-sd-weights --skip-support-models
+            ;;
+        7)
+            invokeai-configure --root ${INVOKEAI_ROOT} --yes --default_only
+            ;;
+        8)
+            echo "Developer Console:"
+            file_name=$(basename "${BASH_SOURCE[0]}")
+            bash --init-file "$file_name"
+            ;;
+        9)
+            echo "Update:"
+            invokeai-update
+            ;;
+        10)
+            invokeai --help
+            ;;
+        [qQ])
+            exit 0
+            ;;
+        *)
+            echo "Invalid selection"
+            exit;;
+    esac
+ done
 else # in developer console
     python --version
-    printf "Press ^D to exit\n"
+    echo "Press ^D to exit"
     export PS1="(InvokeAI) \u@\h \w> "
 fi

invokeai/app/api/dependencies.py

@@ -1,34 +1,24 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-from logging import Logger
 import os
-from invokeai.app.services.board_image_record_storage import (
-    SqliteBoardImageRecordStorage,
-)
-from invokeai.app.services.board_images import (
-    BoardImagesService,
-    BoardImagesServiceDependencies,
-)
-from invokeai.app.services.board_record_storage import SqliteBoardRecordStorage
-from invokeai.app.services.boards import BoardService, BoardServiceDependencies
-from invokeai.app.services.image_record_storage import SqliteImageRecordStorage
-from invokeai.app.services.images import ImageService, ImageServiceDependencies
-from invokeai.app.services.metadata import CoreMetadataService
-from invokeai.app.services.resource_name import SimpleNameService
-from invokeai.app.services.urls import LocalUrlService
-from invokeai.backend.util.logging import InvokeAILogger
+from argparse import Namespace
+
+from invokeai.app.services.metadata import PngMetadataService, MetadataServiceBase
 
 from ..services.default_graphs import create_system_graphs
+
 from ..services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
+
+from ...backend import Globals
+from ..services.model_manager_initializer import get_model_manager
 from ..services.restoration_services import RestorationServices
 from ..services.graph import GraphExecutionState, LibraryGraph
-from ..services.image_file_storage import DiskImageFileStorage
+from ..services.image_storage import DiskImageStorage
 from ..services.invocation_queue import MemoryInvocationQueue
 from ..services.invocation_services import InvocationServices
 from ..services.invoker import Invoker
 from ..services.processor import DefaultInvocationProcessor
 from ..services.sqlite import SqliteItemStorage
-from ..services.model_manager_service import ModelManagerService
 from .events import FastAPIEventService
 
 
@@ -48,91 +38,52 @@ def check_internet() -> bool:
         return False
 
 
-logger = InvokeAILogger.getLogger()
-
-
 class ApiDependencies:
     """Contains and initializes all dependencies for the API"""
 
     invoker: Invoker = None
 
     @staticmethod
-    def initialize(config, event_handler_id: int, logger: Logger = logger):
-        logger.info(f"Internet connectivity is {config.internet_available}")
+    def initialize(config, event_handler_id: int):
+        Globals.try_patchmatch = config.patchmatch
+        Globals.always_use_cpu = config.always_use_cpu
+        Globals.internet_available = config.internet_available and check_internet()
+        Globals.disable_xformers = not config.xformers
+        Globals.ckpt_convert = config.ckpt_convert
+
+        # TODO: Use a logger
+        print(f">> Internet connectivity is {Globals.internet_available}")
 
         events = FastAPIEventService(event_handler_id)
 
-        output_folder = config.output_path
+        output_folder = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "../../../../outputs")
+        )
+
+        latents = ForwardCacheLatentsStorage(DiskLatentsStorage(f'{output_folder}/latents'))
+
+        metadata = PngMetadataService()
+
+        images = DiskImageStorage(f'{output_folder}/images', metadata_service=metadata)
 
         # TODO: build a file/path manager?
-        db_location = config.db_path
-        db_location.parent.mkdir(parents=True, exist_ok=True)
-
-        graph_execution_manager = SqliteItemStorage[GraphExecutionState](
-            filename=db_location, table_name="graph_executions"
-        )
-
-        urls = LocalUrlService()
-        metadata = CoreMetadataService()
-        image_record_storage = SqliteImageRecordStorage(db_location)
-        image_file_storage = DiskImageFileStorage(f"{output_folder}/images")
-        names = SimpleNameService()
-        latents = ForwardCacheLatentsStorage(
-            DiskLatentsStorage(f"{output_folder}/latents")
-        )
-
-        board_record_storage = SqliteBoardRecordStorage(db_location)
-        board_image_record_storage = SqliteBoardImageRecordStorage(db_location)
-
-        boards = BoardService(
-            services=BoardServiceDependencies(
-                board_image_record_storage=board_image_record_storage,
-                board_record_storage=board_record_storage,
-                image_record_storage=image_record_storage,
-                url=urls,
-                logger=logger,
-            )
-        )
-
-        board_images = BoardImagesService(
-            services=BoardImagesServiceDependencies(
-                board_image_record_storage=board_image_record_storage,
-                board_record_storage=board_record_storage,
-                image_record_storage=image_record_storage,
-                url=urls,
-                logger=logger,
-            )
-        )
-
-        images = ImageService(
-            services=ImageServiceDependencies(
-                board_image_record_storage=board_image_record_storage,
-                image_record_storage=image_record_storage,
-                image_file_storage=image_file_storage,
-                metadata=metadata,
-                url=urls,
-                logger=logger,
-                names=names,
-                graph_execution_manager=graph_execution_manager,
-            )
-        )
+        db_location = os.path.join(output_folder, "invokeai.db")
 
         services = InvocationServices(
-            model_manager=ModelManagerService(config,logger),
+            model_manager=get_model_manager(config),
             events=events,
             latents=latents,
             images=images,
-            boards=boards,
-            board_images=board_images,
+            metadata=metadata,
             queue=MemoryInvocationQueue(),
             graph_library=SqliteItemStorage[LibraryGraph](
                 filename=db_location, table_name="graphs"
             ),
-            graph_execution_manager=graph_execution_manager,
+            graph_execution_manager=SqliteItemStorage[GraphExecutionState](
+                filename=db_location, table_name="graph_executions"
+            ),
             processor=DefaultInvocationProcessor(),
-            restoration=RestorationServices(config, logger),
-            configuration=config,
-            logger=logger,
+            restoration=RestorationServices(config),
         )
 
         create_system_graphs(services.graph_library)

invokeai/app/api/models/images.py

@@ -0,0 +1,34 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from invokeai.app.models.image import ImageType
+from invokeai.app.services.metadata import InvokeAIMetadata
+
+
+class ImageResponseMetadata(BaseModel):
+    """An image's metadata. Used only in HTTP responses."""
+
+    created: int = Field(description="The creation timestamp of the image")
+    width: int = Field(description="The width of the image in pixels")
+    height: int = Field(description="The height of the image in pixels")
+    invokeai: Optional[InvokeAIMetadata] = Field(
+        description="The image's InvokeAI-specific metadata"
+    )
+
+
+class ImageResponse(BaseModel):
+    """The response type for images"""
+
+    image_type: ImageType = Field(description="The type of the image")
+    image_name: str = Field(description="The name of the image")
+    image_url: str = Field(description="The url of the image")
+    thumbnail_url: str = Field(description="The url of the image's thumbnail")
+    metadata: ImageResponseMetadata = Field(description="The image's metadata")
+
+
+class ProgressImage(BaseModel):
+    """The progress image sent intermittently during processing"""
+
+    width: int = Field(description="The effective width of the image in pixels")
+    height: int = Field(description="The effective height of the image in pixels")
+    dataURL: str = Field(description="The image data as a b64 data URL")

invokeai/app/api/routers/board_images.py

@@ -1,69 +0,0 @@
-from fastapi import Body, HTTPException, Path, Query
-from fastapi.routing import APIRouter
-from invokeai.app.services.board_record_storage import BoardRecord, BoardChanges
-from invokeai.app.services.image_record_storage import OffsetPaginatedResults
-from invokeai.app.services.models.board_record import BoardDTO
-from invokeai.app.services.models.image_record import ImageDTO
-
-from ..dependencies import ApiDependencies
-
-board_images_router = APIRouter(prefix="/v1/board_images", tags=["boards"])
-
-
-@board_images_router.post(
-    "/",
-    operation_id="create_board_image",
-    responses={
-        201: {"description": "The image was added to a board successfully"},
-    },
-    status_code=201,
-)
-async def create_board_image(
-    board_id: str = Body(description="The id of the board to add to"),
-    image_name: str = Body(description="The name of the image to add"),
-):
-    """Creates a board_image"""
-    try:
-        result = ApiDependencies.invoker.services.board_images.add_image_to_board(board_id=board_id, image_name=image_name)
-        return result
-    except Exception as e:
-        raise HTTPException(status_code=500, detail="Failed to add to board")
-    
-@board_images_router.delete(
-    "/",
-    operation_id="remove_board_image",
-    responses={
-        201: {"description": "The image was removed from the board successfully"},
-    },
-    status_code=201,
-)
-async def remove_board_image(
-    board_id: str = Body(description="The id of the board"),
-    image_name: str = Body(description="The name of the image to remove"),
-):
-    """Deletes a board_image"""
-    try:
-        result = ApiDependencies.invoker.services.board_images.remove_image_from_board(board_id=board_id, image_name=image_name)
-        return result
-    except Exception as e:
-        raise HTTPException(status_code=500, detail="Failed to update board")
-
-
-
-@board_images_router.get(
-    "/{board_id}",
-    operation_id="list_board_images",
-    response_model=OffsetPaginatedResults[ImageDTO],
-)
-async def list_board_images(
-    board_id: str = Path(description="The id of the board"),
-    offset: int = Query(default=0, description="The page offset"),
-    limit: int = Query(default=10, description="The number of boards per page"),
-) -> OffsetPaginatedResults[ImageDTO]:
-    """Gets a list of images for a board"""
-
-    results = ApiDependencies.invoker.services.board_images.get_images_for_board(
-        board_id,
-    )
-    return results
-

invokeai/app/api/routers/boards.py

@@ -1,108 +0,0 @@
-from typing import Optional, Union
-from fastapi import Body, HTTPException, Path, Query
-from fastapi.routing import APIRouter
-from invokeai.app.services.board_record_storage import BoardChanges
-from invokeai.app.services.image_record_storage import OffsetPaginatedResults
-from invokeai.app.services.models.board_record import BoardDTO
-
-from ..dependencies import ApiDependencies
-
-boards_router = APIRouter(prefix="/v1/boards", tags=["boards"])
-
-
-@boards_router.post(
-    "/",
-    operation_id="create_board",
-    responses={
-        201: {"description": "The board was created successfully"},
-    },
-    status_code=201,
-    response_model=BoardDTO,
-)
-async def create_board(
-    board_name: str = Query(description="The name of the board to create"),
-) -> BoardDTO:
-    """Creates a board"""
-    try:
-        result = ApiDependencies.invoker.services.boards.create(board_name=board_name)
-        return result
-    except Exception as e:
-        raise HTTPException(status_code=500, detail="Failed to create board")
-
-
-@boards_router.get("/{board_id}", operation_id="get_board", response_model=BoardDTO)
-async def get_board(
-    board_id: str = Path(description="The id of board to get"),
-) -> BoardDTO:
-    """Gets a board"""
-
-    try:
-        result = ApiDependencies.invoker.services.boards.get_dto(board_id=board_id)
-        return result
-    except Exception as e:
-        raise HTTPException(status_code=404, detail="Board not found")
-
-
-@boards_router.patch(
-    "/{board_id}",
-    operation_id="update_board",
-    responses={
-        201: {
-            "description": "The board was updated successfully",
-        },
-    },
-    status_code=201,
-    response_model=BoardDTO,
-)
-async def update_board(
-    board_id: str = Path(description="The id of board to update"),
-    changes: BoardChanges = Body(description="The changes to apply to the board"),
-) -> BoardDTO:
-    """Updates a board"""
-    try:
-        result = ApiDependencies.invoker.services.boards.update(
-            board_id=board_id, changes=changes
-        )
-        return result
-    except Exception as e:
-        raise HTTPException(status_code=500, detail="Failed to update board")
-
-
-@boards_router.delete("/{board_id}", operation_id="delete_board")
-async def delete_board(
-    board_id: str = Path(description="The id of board to delete"),
-) -> None:
-    """Deletes a board"""
-
-    try:
-        ApiDependencies.invoker.services.boards.delete(board_id=board_id)
-    except Exception as e:
-        # TODO: Does this need any exception handling at all?
-        pass
-
-
-@boards_router.get(
-    "/",
-    operation_id="list_boards",
-    response_model=Union[OffsetPaginatedResults[BoardDTO], list[BoardDTO]],
-)
-async def list_boards(
-    all: Optional[bool] = Query(default=None, description="Whether to list all boards"),
-    offset: Optional[int] = Query(default=None, description="The page offset"),
-    limit: Optional[int] = Query(
-        default=None, description="The number of boards per page"
-    ),
-) -> Union[OffsetPaginatedResults[BoardDTO], list[BoardDTO]]:
-    """Gets a list of boards"""
-    if all:
-        return ApiDependencies.invoker.services.boards.get_all()
-    elif offset is not None and limit is not None:
-        return ApiDependencies.invoker.services.boards.get_many(
-            offset,
-            limit,
-        )
-    else:
-        raise HTTPException(
-            status_code=400,
-            detail="Invalid request: Must provide either 'all' or both 'offset' and 'limit'",
-        )

invokeai/app/api/routers/images.py

@@ -1,241 +1,128 @@
+# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 import io
-from typing import Optional
-from fastapi import Body, HTTPException, Path, Query, Request, Response, UploadFile
+from datetime import datetime, timezone
+import json
+import os
+from typing import Any
+import uuid
+
+from fastapi import HTTPException, Path, Query, Request, UploadFile
+from fastapi.responses import FileResponse, Response
 from fastapi.routing import APIRouter
-from fastapi.responses import FileResponse
 from PIL import Image
-from invokeai.app.models.image import (
-    ImageCategory,
-    ResourceOrigin,
-)
-from invokeai.app.services.image_record_storage import OffsetPaginatedResults
-from invokeai.app.services.models.image_record import (
-    ImageDTO,
-    ImageRecordChanges,
-    ImageUrlsDTO,
-)
+from invokeai.app.api.models.images import ImageResponse, ImageResponseMetadata
+from invokeai.app.services.metadata import InvokeAIMetadata
 from invokeai.app.services.item_storage import PaginatedResults
 
+from ...services.image_storage import ImageType
 from ..dependencies import ApiDependencies
 
 images_router = APIRouter(prefix="/v1/images", tags=["images"])
 
 
+@images_router.get("/{image_type}/{image_name}", operation_id="get_image")
+async def get_image(
+    image_type: ImageType = Path(description="The type of image to get"),
+    image_name: str = Path(description="The name of the image to get"),
+) -> FileResponse | Response:
+    """Gets a result"""
+
+    path = ApiDependencies.invoker.services.images.get_path(
+        image_type=image_type, image_name=image_name
+    )
+
+    if ApiDependencies.invoker.services.images.validate_path(path):
+        return FileResponse(path)
+    else:
+        raise HTTPException(status_code=404)
+
+
+@images_router.get(
+    "/{image_type}/thumbnails/{image_name}", operation_id="get_thumbnail"
+)
+async def get_thumbnail(
+    image_type: ImageType = Path(description="The type of image to get"),
+    image_name: str = Path(description="The name of the image to get"),
+) -> FileResponse | Response:
+    """Gets a thumbnail"""
+
+    path = ApiDependencies.invoker.services.images.get_path(
+        image_type=image_type, image_name=image_name, is_thumbnail=True
+    )
+
+    if ApiDependencies.invoker.services.images.validate_path(path):
+        return FileResponse(path)
+    else:
+        raise HTTPException(status_code=404)
+
+
 @images_router.post(
-    "/",
+    "/uploads/",
     operation_id="upload_image",
     responses={
-        201: {"description": "The image was uploaded successfully"},
+        201: {
+            "description": "The image was uploaded successfully",
+            "model": ImageResponse,
+        },
         415: {"description": "Image upload failed"},
     },
     status_code=201,
-    response_model=ImageDTO,
 )
 async def upload_image(
-    file: UploadFile,
-    request: Request,
-    response: Response,
-    image_category: ImageCategory = Query(description="The category of the image"),
-    is_intermediate: bool = Query(description="Whether this is an intermediate image"),
-    session_id: Optional[str] = Query(
-        default=None, description="The session ID associated with this upload, if any"
-    ),
-) -> ImageDTO:
-    """Uploads an image"""
+    file: UploadFile, request: Request, response: Response
+) -> ImageResponse:
     if not file.content_type.startswith("image"):
         raise HTTPException(status_code=415, detail="Not an image")
 
     contents = await file.read()
 
     try:
-        pil_image = Image.open(io.BytesIO(contents))
+        img = Image.open(io.BytesIO(contents))
     except:
         # Error opening the image
         raise HTTPException(status_code=415, detail="Failed to read image")
 
-    try:
-        image_dto = ApiDependencies.invoker.services.images.create(
-            image=pil_image,
-            image_origin=ResourceOrigin.EXTERNAL,
-            image_category=image_category,
-            session_id=session_id,
-            is_intermediate=is_intermediate,
-        )
+    filename = f"{uuid.uuid4()}_{str(int(datetime.now(timezone.utc).timestamp()))}.png"
 
-        response.status_code = 201
-        response.headers["Location"] = image_dto.image_url
+    (image_path, thumbnail_path, ctime) = ApiDependencies.invoker.services.images.save(
+        ImageType.UPLOAD, filename, img
+    )
 
-        return image_dto
-    except Exception as e:
-        raise HTTPException(status_code=500, detail="Failed to create image")
+    invokeai_metadata = ApiDependencies.invoker.services.metadata.get_metadata(img)
 
+    res = ImageResponse(
+        image_type=ImageType.UPLOAD,
+        image_name=filename,
+        image_url=f"api/v1/images/{ImageType.UPLOAD.value}/{filename}",
+        thumbnail_url=f"api/v1/images/{ImageType.UPLOAD.value}/thumbnails/{os.path.splitext(filename)[0]}.webp",
+        metadata=ImageResponseMetadata(
+            created=ctime,
+            width=img.width,
+            height=img.height,
+            invokeai=invokeai_metadata,
+        ),
+    )
 
-@images_router.delete("/{image_name}", operation_id="delete_image")
-async def delete_image(
-    image_name: str = Path(description="The name of the image to delete"),
-) -> None:
-    """Deletes an image"""
+    response.status_code = 201
+    response.headers["Location"] = request.url_for(
+        "get_image", image_type=ImageType.UPLOAD.value, image_name=filename
+    )
 
-    try:
-        ApiDependencies.invoker.services.images.delete(image_name)
-    except Exception as e:
-        # TODO: Does this need any exception handling at all?
-        pass
-
-
-@images_router.patch(
-    "/{image_name}",
-    operation_id="update_image",
-    response_model=ImageDTO,
-)
-async def update_image(
-    image_name: str = Path(description="The name of the image to update"),
-    image_changes: ImageRecordChanges = Body(
-        description="The changes to apply to the image"
-    ),
-) -> ImageDTO:
-    """Updates an image"""
-
-    try:
-        return ApiDependencies.invoker.services.images.update(image_name, image_changes)
-    except Exception as e:
-        raise HTTPException(status_code=400, detail="Failed to update image")
-
-
-@images_router.get(
-    "/{image_name}/metadata",
-    operation_id="get_image_metadata",
-    response_model=ImageDTO,
-)
-async def get_image_metadata(
-    image_name: str = Path(description="The name of image to get"),
-) -> ImageDTO:
-    """Gets an image's metadata"""
-
-    try:
-        return ApiDependencies.invoker.services.images.get_dto(image_name)
-    except Exception as e:
-        raise HTTPException(status_code=404)
-
-
-@images_router.get(
-    "/{image_name}",
-    operation_id="get_image_full",
-    response_class=Response,
-    responses={
-        200: {
-            "description": "Return the full-resolution image",
-            "content": {"image/png": {}},
-        },
-        404: {"description": "Image not found"},
-    },
-)
-async def get_image_full(
-    image_name: str = Path(description="The name of full-resolution image file to get"),
-) -> FileResponse:
-    """Gets a full-resolution image file"""
-
-    try:
-        path = ApiDependencies.invoker.services.images.get_path(image_name)
-
-        if not ApiDependencies.invoker.services.images.validate_path(path):
-            raise HTTPException(status_code=404)
-
-        return FileResponse(
-            path,
-            media_type="image/png",
-            filename=image_name,
-            content_disposition_type="inline",
-        )
-    except Exception as e:
-        raise HTTPException(status_code=404)
-
-
-@images_router.get(
-    "/{image_name}/thumbnail",
-    operation_id="get_image_thumbnail",
-    response_class=Response,
-    responses={
-        200: {
-            "description": "Return the image thumbnail",
-            "content": {"image/webp": {}},
-        },
-        404: {"description": "Image not found"},
-    },
-)
-async def get_image_thumbnail(
-    image_name: str = Path(description="The name of thumbnail image file to get"),
-) -> FileResponse:
-    """Gets a thumbnail image file"""
-
-    try:
-        path = ApiDependencies.invoker.services.images.get_path(
-            image_name, thumbnail=True
-        )
-        if not ApiDependencies.invoker.services.images.validate_path(path):
-            raise HTTPException(status_code=404)
-
-        return FileResponse(
-            path, media_type="image/webp", content_disposition_type="inline"
-        )
-    except Exception as e:
-        raise HTTPException(status_code=404)
-
-
-@images_router.get(
-    "/{image_name}/urls",
-    operation_id="get_image_urls",
-    response_model=ImageUrlsDTO,
-)
-async def get_image_urls(
-    image_name: str = Path(description="The name of the image whose URL to get"),
-) -> ImageUrlsDTO:
-    """Gets an image and thumbnail URL"""
-
-    try:
-        image_url = ApiDependencies.invoker.services.images.get_url(image_name)
-        thumbnail_url = ApiDependencies.invoker.services.images.get_url(
-            image_name, thumbnail=True
-        )
-        return ImageUrlsDTO(
-            image_name=image_name,
-            image_url=image_url,
-            thumbnail_url=thumbnail_url,
-        )
-    except Exception as e:
-        raise HTTPException(status_code=404)
+    return res
 
 
 @images_router.get(
     "/",
-    operation_id="list_images_with_metadata",
-    response_model=OffsetPaginatedResults[ImageDTO],
+    operation_id="list_images",
+    responses={200: {"model": PaginatedResults[ImageResponse]}},
 )
-async def list_images_with_metadata(
-    image_origin: Optional[ResourceOrigin] = Query(
-        default=None, description="The origin of images to list"
+async def list_images(
+    image_type: ImageType = Query(
+        default=ImageType.RESULT, description="The type of images to get"
     ),
-    categories: Optional[list[ImageCategory]] = Query(
-        default=None, description="The categories of image to include"
-    ),
-    is_intermediate: Optional[bool] = Query(
-        default=None, description="Whether to list intermediate images"
-    ),
-    board_id: Optional[str] = Query(
-        default=None, description="The board id to filter by"
-    ),
-    offset: int = Query(default=0, description="The page offset"),
-    limit: int = Query(default=10, description="The number of images per page"),
-) -> OffsetPaginatedResults[ImageDTO]:
+    page: int = Query(default=0, description="The page of images to get"),
+    per_page: int = Query(default=10, description="The number of images per page"),
+) -> PaginatedResults[ImageResponse]:
     """Gets a list of images"""
-
-    image_dtos = ApiDependencies.invoker.services.images.get_many(
-        offset,
-        limit,
-        image_origin,
-        categories,
-        is_intermediate,
-        board_id,
-    )
-
-    return image_dtos
+    result = ApiDependencies.invoker.services.images.list(image_type, page, per_page)
+    return result

invokeai/app/api/routers/models.py

@@ -1,14 +1,17 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654) and 2023 Kent Keirsey (https://github.com/hipsterusername)
 
-from typing import Annotated, Literal, Optional, Union, Dict
+import shutil
+import asyncio
+from typing import Annotated, Any, List, Literal, Optional, Union
 
-from fastapi import Query
 from fastapi.routing import APIRouter, HTTPException
 from pydantic import BaseModel, Field, parse_obj_as
+from pathlib import Path
 from ..dependencies import ApiDependencies
-from invokeai.backend import BaseModelType, ModelType
-from invokeai.backend.model_management.models import OPENAPI_MODEL_CONFIGS
-MODEL_CONFIGS = Union[tuple(OPENAPI_MODEL_CONFIGS)]
+from invokeai.backend.globals import Globals, global_converted_ckpts_dir
+from invokeai.backend.args import Args
+
+
 
 models_router = APIRouter(prefix="/v1/models", tags=["models"])
 
@@ -20,15 +23,6 @@ class VaeRepo(BaseModel):
 
 class ModelInfo(BaseModel):
     description: Optional[str] = Field(description="A description of the model")
-    model_name: str = Field(description="The name of the model")
-    model_type: str = Field(description="The type of the model")
-    
-class DiffusersModelInfo(ModelInfo):
-    format: Literal['folder'] = 'folder'
-
-    vae: Optional[VaeRepo] = Field(description="The VAE repo to use for this model")
-    repo_id: Optional[str] = Field(description="The repo ID to use for this model")
-    path: Optional[str] = Field(description="The path to the model")
     
 class CkptModelInfo(ModelInfo):
     format: Literal['ckpt'] = 'ckpt'
@@ -39,8 +33,12 @@ class CkptModelInfo(ModelInfo):
     width: Optional[int] = Field(description="The width of the model")
     height: Optional[int] = Field(description="The height of the model")
 
-class SafetensorsModelInfo(CkptModelInfo):
-    format: Literal['safetensors'] = 'safetensors'
+class DiffusersModelInfo(ModelInfo):
+    format: Literal['diffusers'] = 'diffusers'
+
+    vae: Optional[VaeRepo] = Field(description="The VAE repo to use for this model")
+    repo_id: Optional[str] = Field(description="The repo ID to use for this model")
+    path: Optional[str] = Field(description="The path to the model")
 
 class CreateModelRequest(BaseModel):
     name: str = Field(description="The name of the model")
@@ -62,7 +60,7 @@ class ConvertedModelResponse(BaseModel):
     info: DiffusersModelInfo = Field(description="The converted model info")
 
 class ModelsList(BaseModel):
-    models: list[MODEL_CONFIGS]
+    models: dict[str, Annotated[Union[(CkptModelInfo,DiffusersModelInfo)], Field(discriminator="format")]]
 
 
 @models_router.get(
@@ -70,16 +68,9 @@ class ModelsList(BaseModel):
     operation_id="list_models",
     responses={200: {"model": ModelsList }},
 )
-async def list_models(
-    base_model: Optional[BaseModelType] = Query(
-        default=None, description="Base model"
-    ),
-    model_type: Optional[ModelType] = Query(
-        default=None, description="The type of model to get"
-    ),
-) -> ModelsList:
+async def list_models() -> ModelsList:
     """Gets a list of models"""
-    models_raw = ApiDependencies.invoker.services.model_manager.list_models(base_model, model_type)
+    models_raw = ApiDependencies.invoker.services.model_manager.list_models()
     models = parse_obj_as(ModelsList, { "models": models_raw })
     return models
 
@@ -121,20 +112,19 @@ async def update_model(
 async def delete_model(model_name: str) -> None:
     """Delete Model"""
     model_names = ApiDependencies.invoker.services.model_manager.model_names()
-    logger = ApiDependencies.invoker.services.logger
     model_exists = model_name in model_names
 
     # check if model exists
-    logger.info(f"Checking for model {model_name}...")
+    print(f">> Checking for model {model_name}...")
            
     if model_exists:
-        logger.info(f"Deleting Model: {model_name}")
+        print(f">> Deleting Model: {model_name}")
         ApiDependencies.invoker.services.model_manager.del_model(model_name, delete_files=True)
-        logger.info(f"Model Deleted: {model_name}")
+        print(f">> Model Deleted: {model_name}")
         raise HTTPException(status_code=204, detail=f"Model '{model_name}' deleted successfully")
     
     else:
-        logger.error("Model not found")
+        print(f">> Model not found")
         raise HTTPException(status_code=404, detail=f"Model '{model_name}' not found")
     
 
@@ -258,4 +248,4 @@ async def delete_model(model_name: str) -> None:
         #         )
         #         print(f">> Models Merged: {models_to_merge}")
         #         print(f">> New Model Added: {model_merge_info['merged_model_name']}")
-        #     except Exception as e:
+        #     except Exception as e:

invokeai/app/api/routers/sessions.py

@@ -2,7 +2,8 @@
 
 from typing import Annotated, List, Optional, Union
 
-from fastapi import Body, HTTPException, Path, Query, Response
+from fastapi import Body, Path, Query
+from fastapi.responses import Response
 from fastapi.routing import APIRouter
 from pydantic.fields import Field
 
@@ -75,7 +76,7 @@ async def get_session(
     """Gets a session"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        raise HTTPException(status_code=404)
+        return Response(status_code=404)
     else:
         return session
 
@@ -98,7 +99,7 @@ async def add_node(
     """Adds a node to the graph"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        raise HTTPException(status_code=404)
+        return Response(status_code=404)
 
     try:
         session.add_node(node)
@@ -107,9 +108,9 @@ async def add_node(
         )  # TODO: can this be done automatically, or add node through an API?
         return session.id
     except NodeAlreadyExecutedError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
     except IndexError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
 
 
 @session_router.put(
@@ -131,7 +132,7 @@ async def update_node(
     """Updates a node in the graph and removes all linked edges"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        raise HTTPException(status_code=404)
+        return Response(status_code=404)
 
     try:
         session.update_node(node_path, node)
@@ -140,9 +141,9 @@ async def update_node(
         )  # TODO: can this be done automatically, or add node through an API?
         return session
     except NodeAlreadyExecutedError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
     except IndexError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
 
 
 @session_router.delete(
@@ -161,7 +162,7 @@ async def delete_node(
     """Deletes a node in the graph and removes all linked edges"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        raise HTTPException(status_code=404)
+        return Response(status_code=404)
 
     try:
         session.delete_node(node_path)
@@ -170,9 +171,9 @@ async def delete_node(
         )  # TODO: can this be done automatically, or add node through an API?
         return session
     except NodeAlreadyExecutedError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
     except IndexError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
 
 
 @session_router.post(
@@ -191,7 +192,7 @@ async def add_edge(
     """Adds an edge to the graph"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        raise HTTPException(status_code=404)
+        return Response(status_code=404)
 
     try:
         session.add_edge(edge)
@@ -200,9 +201,9 @@ async def add_edge(
         )  # TODO: can this be done automatically, or add node through an API?
         return session
     except NodeAlreadyExecutedError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
     except IndexError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
 
 
 # TODO: the edge being in the path here is really ugly, find a better solution
@@ -225,7 +226,7 @@ async def delete_edge(
     """Deletes an edge from the graph"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        raise HTTPException(status_code=404)
+        return Response(status_code=404)
 
     try:
         edge = Edge(
@@ -238,9 +239,9 @@ async def delete_edge(
         )  # TODO: can this be done automatically, or add node through an API?
         return session
     except NodeAlreadyExecutedError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
     except IndexError:
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
 
 
 @session_router.put(
@@ -258,14 +259,14 @@ async def invoke_session(
     all: bool = Query(
         default=False, description="Whether or not to invoke all remaining invocations"
     ),
-) -> Response:
+) -> None:
     """Invokes a session"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        raise HTTPException(status_code=404)
+        return Response(status_code=404)
 
     if session.is_complete():
-        raise HTTPException(status_code=400)
+        return Response(status_code=400)
 
     ApiDependencies.invoker.invoke(session, invoke_all=all)
     return Response(status_code=202)
@@ -280,7 +281,7 @@ async def invoke_session(
 )
 async def cancel_session_invoke(
     session_id: str = Path(description="The id of the session to cancel"),
-) -> Response:
+) -> None:
     """Invokes a session"""
     ApiDependencies.invoker.cancel(session_id)
     return Response(status_code=202)

invokeai/app/api_app.py

@@ -3,7 +3,6 @@ import asyncio
 from inspect import signature
 
 import uvicorn
-
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
@@ -11,21 +10,13 @@ from fastapi.openapi.utils import get_openapi
 from fastapi.staticfiles import StaticFiles
 from fastapi_events.handlers.local import local_handler
 from fastapi_events.middleware import EventHandlerASGIMiddleware
-from pathlib import Path
 from pydantic.schema import schema
 
-#This should come early so that modules can log their initialization properly
-from .services.config import InvokeAIAppConfig
-from ..backend.util.logging import InvokeAILogger
-app_config = InvokeAIAppConfig.get_config()
-app_config.parse_args()
-logger = InvokeAILogger.getLogger(config=app_config)
-
-import invokeai.frontend.web as web_dir
-
+from ..backend import Args
 from .api.dependencies import ApiDependencies
-from .api.routers import sessions, models, images, boards, board_images
+from .api.routers import images, sessions, models
 from .api.sockets import SocketIO
+from .invocations import *
 from .invocations.baseinvocation import BaseInvocation
 
 # Create the app
@@ -42,21 +33,30 @@ app.add_middleware(
     middleware_id=event_handler_id,
 )
 
+# Add CORS
+# TODO: use configuration for this
+origins = []
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 socket_io = SocketIO(app)
 
+config = {}
+
+
 # Add startup event to load dependencies
 @app.on_event("startup")
 async def startup_event():
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=app_config.allow_origins,
-        allow_credentials=app_config.allow_credentials,
-        allow_methods=app_config.allow_methods,
-        allow_headers=app_config.allow_headers,
-    )
+    config = Args()
+    config.parse_args()
 
     ApiDependencies.initialize(
-        config=app_config, event_handler_id=event_handler_id, logger=logger
+        config=config, event_handler_id=event_handler_id
     )
 
 
@@ -74,13 +74,10 @@ async def shutdown_event():
 
 app.include_router(sessions.session_router, prefix="/api")
 
-app.include_router(models.models_router, prefix="/api")
-
 app.include_router(images.images_router, prefix="/api")
 
-app.include_router(boards.boards_router, prefix="/api")
+app.include_router(models.models_router, prefix="/api")
 
-app.include_router(board_images.board_images_router, prefix="/api")
 
 # Build a custom OpenAPI to include all outputs
 # TODO: can outputs be included on metadata of invocation schemas somehow?
@@ -120,22 +117,6 @@ def custom_openapi():
 
         invoker_schema["output"] = outputs_ref
 
-    from invokeai.backend.model_management.models import get_model_config_enums
-    for model_config_format_enum in set(get_model_config_enums()):
-        name = model_config_format_enum.__qualname__
-
-        if name in openapi_schema["components"]["schemas"]:
-            # print(f"Config with name {name} already defined")
-            continue
-
-        # "BaseModelType":{"title":"BaseModelType","description":"An enumeration.","enum":["sd-1","sd-2"],"type":"string"}
-        openapi_schema["components"]["schemas"][name] = dict(
-            title=name,
-            description="An enumeration.",
-            type="string",
-            enum=list(v.value for v in model_config_format_enum),
-        )
-
     app.openapi_schema = openapi_schema
     return app.openapi_schema
 
@@ -143,7 +124,8 @@ def custom_openapi():
 app.openapi = custom_openapi
 
 # Override API doc favicons
-app.mount("/static", StaticFiles(directory=Path(web_dir.__path__[0], 'static/dream_web')), name="static")
+app.mount("/static", StaticFiles(directory="static/dream_web"), name="static")
+
 
 @app.get("/docs", include_in_schema=False)
 def overridden_swagger():
@@ -163,20 +145,16 @@ def overridden_redoc():
     )
 
 
-# Must mount *after* the other routes else it borks em
-app.mount("/", 
-          StaticFiles(directory=Path(web_dir.__path__[0],"dist"), 
-                      html=True
-                     ), name="ui"
-         )
-
 def invoke_api():
     # Start our own event loop for eventing usage
+    # TODO: determine if there's a better way to do this
     loop = asyncio.new_event_loop()
-    config = uvicorn.Config(app=app, host=app_config.host, port=app_config.port, loop=loop)
+    config = uvicorn.Config(app=app, host="0.0.0.0", port=9090, loop=loop)
     # Use access_log to turn off logging
+
     server = uvicorn.Server(config)
     loop.run_until_complete(server.serve())
 
+
 if __name__ == "__main__":
     invoke_api()

invokeai/app/cli/commands.py

@@ -2,15 +2,14 @@
 
 from abc import ABC, abstractmethod
 import argparse
-from typing import Any, Callable, Iterable, Literal, Union, get_args, get_origin, get_type_hints
+from typing import Any, Callable, Iterable, Literal, get_args, get_origin, get_type_hints
 from pydantic import BaseModel, Field
 import networkx as nx
 import matplotlib.pyplot as plt
 
-import invokeai.backend.util.logging as logger
 from ..invocations.baseinvocation import BaseInvocation
 from ..invocations.image import ImageField
-from ..services.graph import GraphExecutionState, LibraryGraph, Edge
+from ..services.graph import GraphExecutionState, LibraryGraph, GraphInvocation, Edge
 from ..services.invoker import Invoker
 
 
@@ -230,7 +229,7 @@ class HistoryCommand(BaseCommand):
         for i in range(min(self.count, len(history))):
             entry_id = history[-1 - i]
             entry = context.get_session().graph.get_node(entry_id)
-            logger.info(f"{entry_id}: {get_invocation_command(entry)}")
+            print(f"{entry_id}: {get_invocation_command(entry)}")
 
 
 class SetDefaultCommand(BaseCommand):
@@ -285,19 +284,3 @@ class DrawExecutionGraphCommand(BaseCommand):
         nx.draw_networkx_labels(nxgraph, pos, font_size=20, font_family="sans-serif")
         plt.axis("off")
         plt.show()
-
-class SortedHelpFormatter(argparse.HelpFormatter):
-    def _iter_indented_subactions(self, action):
-        try:
-            get_subactions = action._get_subactions
-        except AttributeError:
-            pass
-        else:
-            self._indent()
-            if isinstance(action, argparse._SubParsersAction):
-                for subaction in sorted(get_subactions(), key=lambda x: x.dest):
-                    yield subaction
-            else:
-                for subaction in get_subactions():
-                    yield subaction
-                self._dedent()

invokeai/app/cli/completer.py

@@ -10,11 +10,9 @@ import shlex
 from pathlib import Path
 from typing import List, Dict, Literal, get_args, get_type_hints, get_origin
 
-import invokeai.backend.util.logging as logger
-from ...backend import ModelManager
+from ...backend import ModelManager, Globals
 from ..invocations.baseinvocation import BaseInvocation
 from .commands import BaseCommand
-from ..services.invocation_services import InvocationServices
 
 # singleton object, class variable
 completer = None
@@ -132,13 +130,13 @@ class Completer(object):
             readline.redisplay()
             self.linebuffer = None
     
-def set_autocompleter(services: InvocationServices) -> Completer:
+def set_autocompleter(model_manager: ModelManager) -> Completer:
     global completer
     
     if completer:
         return completer
     
-    completer = Completer(services.model_manager)
+    completer = Completer(model_manager)
 
     readline.set_completer(completer.complete)
     # pyreadline3 does not have a set_auto_history() method
@@ -154,7 +152,7 @@ def set_autocompleter(services: InvocationServices) -> Completer:
     readline.parse_and_bind("set skip-completed-text on")
     readline.parse_and_bind("set show-all-if-ambiguous on")
 
-    histfile = Path(services.configuration.root_dir / ".invoke_history")
+    histfile = Path(Globals.root, ".invoke_history")
     try:
         readline.read_history_file(histfile)
         readline.set_history_length(1000)
@@ -162,8 +160,8 @@ def set_autocompleter(services: InvocationServices) -> Completer:
         pass
     except OSError:  # file likely corrupted
         newname = f"{histfile}.old"
-        logger.error(
-            f"Your history file {histfile} couldn't be loaded and may be corrupted. Renaming it to {newname}"
+        print(
+            f"## Your history file {histfile} couldn't be loaded and may be corrupted. Renaming it to {newname}"
         )
         histfile.replace(Path(newname))
     atexit.register(readline.write_history_file, histfile)

invokeai/app/cli_app.py

@@ -4,44 +4,36 @@ import argparse
 import os
 import re
 import shlex
-import sys
 import time
-from typing import Union, get_type_hints
+from typing import (
+    Union,
+    get_type_hints,
+)
 
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel
 from pydantic.fields import Field
 
-# This should come early so that the logger can pick up its configuration options
-from .services.config import InvokeAIAppConfig
-from invokeai.backend.util.logging import InvokeAILogger
-config = InvokeAIAppConfig.get_config()
-config.parse_args()
-logger = InvokeAILogger().getLogger(config=config)
+from invokeai.app.services.metadata import PngMetadataService
+
+from .services.default_graphs import create_system_graphs
 
-from invokeai.app.services.image_record_storage import SqliteImageRecordStorage
-from invokeai.app.services.images import ImageService
-from invokeai.app.services.metadata import CoreMetadataService
-from invokeai.app.services.resource_name import SimpleNameService
-from invokeai.app.services.urls import LocalUrlService
-from .services.default_graphs import (default_text_to_image_graph_id,
-                                      create_system_graphs)
 from .services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
 
-from .cli.commands import (BaseCommand, CliContext, ExitCli,
-                           SortedHelpFormatter, add_graph_parsers, add_parsers)
+from ..backend import Args
+from .cli.commands import BaseCommand, CliContext, ExitCli, add_graph_parsers, add_parsers, get_graph_execution_history
 from .cli.completer import set_autocompleter
+from .invocations import *
 from .invocations.baseinvocation import BaseInvocation
 from .services.events import EventServiceBase
-from .services.graph import (Edge, EdgeConnection, GraphExecutionState,
-                             GraphInvocation, LibraryGraph,
-                             are_connection_types_compatible)
-from .services.image_file_storage import DiskImageFileStorage
+from .services.model_manager_initializer import get_model_manager
+from .services.restoration_services import RestorationServices
+from .services.graph import Edge, EdgeConnection, ExposedNodeInput, GraphExecutionState, GraphInvocation, LibraryGraph, are_connection_types_compatible
+from .services.default_graphs import default_text_to_image_graph_id
+from .services.image_storage import DiskImageStorage
 from .services.invocation_queue import MemoryInvocationQueue
 from .services.invocation_services import InvocationServices
 from .services.invoker import Invoker
-from .services.model_manager_service import ModelManagerService
 from .services.processor import DefaultInvocationProcessor
-from .services.restoration_services import RestorationServices
 from .services.sqlite import SqliteItemStorage
 
 
@@ -52,6 +44,7 @@ class CliCommand(BaseModel):
 class InvalidArgs(Exception):
     pass
 
+
 def add_invocation_args(command_parser):
     # Add linking capability
     command_parser.add_argument(
@@ -72,7 +65,7 @@ def add_invocation_args(command_parser):
 
 def get_command_parser(services: InvocationServices) -> argparse.ArgumentParser:
     # Create invocation parser
-    parser = argparse.ArgumentParser(formatter_class=SortedHelpFormatter)
+    parser = argparse.ArgumentParser()
 
     def exit(*args, **kwargs):
         raise InvalidArgs
@@ -189,77 +182,54 @@ def invoke_all(context: CliContext):
     # Print any errors
     if context.session.has_error():
         for n in context.session.errors:
-            context.invoker.services.logger.error(
+            print(
                 f"Error in node {n} (source node {context.session.prepared_source_mapping[n]}): {context.session.errors[n]}"
             )
         
         raise SessionError()
 
-def invoke_cli():
-    # get the optional list of invocations to execute on the command line
-    parser = config.get_parser()
-    parser.add_argument('commands',nargs='*')
-    invocation_commands = parser.parse_args().commands
 
-    # get the optional file to read commands from.
-    # Simplest is to use it for STDIN
-    if infile := config.from_file:
-        sys.stdin = open(infile,"r")
-    
-    model_manager = ModelManagerService(config,logger)
+def invoke_cli():
+    config = Args()
+    config.parse_args()
+    model_manager = get_model_manager(config)
+
+    # This initializes the autocompleter and returns it.
+    # Currently nothing is done with the returned Completer
+    # object, but the object can be used to change autocompletion
+    # behavior on the fly, if desired.
+    completer = set_autocompleter(model_manager)
 
     events = EventServiceBase()
-    output_folder = config.output_path
+
+    metadata = PngMetadataService()
+
+    output_folder = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "../../../outputs")
+    )
 
     # TODO: build a file/path manager?
-    if config.use_memory_db:
-        db_location = ":memory:"
-    else:
-        db_location = config.db_path
-        db_location.parent.mkdir(parents=True,exist_ok=True)
-
-    logger.info(f'InvokeAI database location is "{db_location}"')
-
-    graph_execution_manager = SqliteItemStorage[GraphExecutionState](
-            filename=db_location, table_name="graph_executions"
-        )
-
-    urls = LocalUrlService()
-    metadata = CoreMetadataService()
-    image_record_storage = SqliteImageRecordStorage(db_location)
-    image_file_storage = DiskImageFileStorage(f"{output_folder}/images")
-    names = SimpleNameService()
-
-    images = ImageService(
-        image_record_storage=image_record_storage,
-        image_file_storage=image_file_storage,
-        metadata=metadata,
-        url=urls,
-        logger=logger,
-        names=names,
-        graph_execution_manager=graph_execution_manager,
-    )
+    db_location = os.path.join(output_folder, "invokeai.db")
 
     services = InvocationServices(
         model_manager=model_manager,
         events=events,
         latents = ForwardCacheLatentsStorage(DiskLatentsStorage(f'{output_folder}/latents')),
-        images=images,
+        images=DiskImageStorage(f'{output_folder}/images', metadata_service=metadata),
+        metadata=metadata,
         queue=MemoryInvocationQueue(),
         graph_library=SqliteItemStorage[LibraryGraph](
             filename=db_location, table_name="graphs"
         ),
-        graph_execution_manager=graph_execution_manager,
+        graph_execution_manager=SqliteItemStorage[GraphExecutionState](
+            filename=db_location, table_name="graph_executions"
+        ),
         processor=DefaultInvocationProcessor(),
-        restoration=RestorationServices(config,logger=logger),
-        logger=logger,
-        configuration=config,
+        restoration=RestorationServices(config),
     )
-    
 
     system_graphs = create_system_graphs(services.graph_library)
     system_graph_names = set([g.name for g in system_graphs])
-    set_autocompleter(services)
 
     invoker = Invoker(services)
     session: GraphExecutionState = invoker.create_execution_state()
@@ -271,18 +241,10 @@ def invoke_cli():
     # print(services.session_manager.list())
 
     context = CliContext(invoker, session, parser)
-    set_autocompleter(services)
 
-    command_line_args_exist = len(invocation_commands) > 0
-    done = False
-    
-    while not done:
+    while True:
         try:
-            if command_line_args_exist:
-                cmd_input = invocation_commands.pop(0)
-                done = len(invocation_commands) == 0
-            else:
-                cmd_input = input("invoke> ")
+            cmd_input = input("invoke> ")
         except (KeyboardInterrupt, EOFError):
             # Ctrl-c exits
             break
@@ -403,15 +365,12 @@ def invoke_cli():
             invoke_all(context)
 
         except InvalidArgs:
-            invoker.services.logger.warning('Invalid command, use "help" to list commands')
+            print('Invalid command, use "help" to list commands')
             continue
 
-        except ValidationError:
-            invoker.services.logger.warning('Invalid command arguments, run "<command> --help" for summary')
-
         except SessionError:
             # Start a new session
-            invoker.services.logger.warning("Session error: creating a new session")
+            print("Session error: creating a new session")
             context.reset()
 
         except ExitCli:

invokeai/app/invocations/baseinvocation.py

@@ -1,15 +1,12 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-from __future__ import annotations
-
 from abc import ABC, abstractmethod
 from inspect import signature
-from typing import get_args, get_type_hints, Dict, List, Literal, TypedDict, TYPE_CHECKING
+from typing import get_args, get_type_hints, Dict, List, Literal, TypedDict
 
 from pydantic import BaseModel, Field
 
-if TYPE_CHECKING:
-    from ..services.invocation_services import InvocationServices
+from ..services.invocation_services import InvocationServices
 
 
 class InvocationContext:
@@ -78,7 +75,6 @@ class BaseInvocation(ABC, BaseModel):
     
     #fmt: off
     id: str = Field(description="The id of this node. Must be unique among all nodes.")
-    is_intermediate: bool = Field(default=False, description="Whether or not this node is an intermediate node.")
     #fmt: on
 
 
@@ -96,7 +92,6 @@ class UIConfig(TypedDict, total=False):
             "image",
             "latents",
             "model",
-            "control",
         ],
     ]
     tags: List[str]

invokeai/app/invocations/collections.py

@@ -1,14 +1,14 @@
-# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654) and the InvokeAI Team
+# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
 
-from typing import Literal
+from typing import Literal, Optional
 
 import numpy as np
-from pydantic import Field, validator
-
-from invokeai.app.util.misc import SEED_MAX, get_random_seed
+import numpy.random
+from pydantic import Field
 
 from .baseinvocation import (
     BaseInvocation,
+    InvocationConfig,
     InvocationContext,
     BaseInvocationOutput,
 )
@@ -22,17 +22,9 @@ class IntCollectionOutput(BaseInvocationOutput):
     # Outputs
     collection: list[int] = Field(default=[], description="The int collection")
 
-class FloatCollectionOutput(BaseInvocationOutput):
-    """A collection of floats"""
-
-    type: Literal["float_collection"] = "float_collection"
-
-    # Outputs
-    collection: list[float] = Field(default=[], description="The float collection")
-
 
 class RangeInvocation(BaseInvocation):
-    """Creates a range of numbers from start to stop with step"""
+    """Creates a range"""
 
     type: Literal["range"] = "range"
 
@@ -41,34 +33,12 @@ class RangeInvocation(BaseInvocation):
     stop: int = Field(default=10, description="The stop of the range")
     step: int = Field(default=1, description="The step of the range")
 
-    @validator("stop")
-    def stop_gt_start(cls, v, values):
-        if "start" in values and v <= values["start"]:
-            raise ValueError("stop must be greater than start")
-        return v
-
     def invoke(self, context: InvocationContext) -> IntCollectionOutput:
         return IntCollectionOutput(
             collection=list(range(self.start, self.stop, self.step))
         )
 
 
-class RangeOfSizeInvocation(BaseInvocation):
-    """Creates a range from start to start + size with step"""
-
-    type: Literal["range_of_size"] = "range_of_size"
-
-    # Inputs
-    start: int = Field(default=0, description="The start of the range")
-    size: int = Field(default=1, description="The number of values")
-    step: int = Field(default=1, description="The step of the range")
-
-    def invoke(self, context: InvocationContext) -> IntCollectionOutput:
-        return IntCollectionOutput(
-            collection=list(range(self.start, self.start + self.size, self.step))
-        )
-
-
 class RandomRangeInvocation(BaseInvocation):
     """Creates a collection of random numbers"""
 
@@ -80,11 +50,11 @@ class RandomRangeInvocation(BaseInvocation):
         default=np.iinfo(np.int32).max, description="The exclusive high value"
     )
     size: int = Field(default=1, description="The number of values to generate")
-    seed: int = Field(
+    seed: Optional[int] = Field(
         ge=0,
-        le=SEED_MAX,
-        description="The seed for the RNG (omit for random)",
-        default_factory=get_random_seed,
+        le=np.iinfo(np.int32).max,
+        description="The seed for the RNG",
+        default_factory=lambda: numpy.random.randint(0, np.iinfo(np.int32).max),
     )
 
     def invoke(self, context: InvocationContext) -> IntCollectionOutput:

invokeai/app/invocations/compel.py

@@ -1,269 +0,0 @@
-from typing import Literal, Optional, Union
-from pydantic import BaseModel, Field
-from contextlib import ExitStack
-import re
-
-from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext, InvocationConfig
-from .model import ClipField
-
-from ...backend.util.devices import torch_dtype
-from ...backend.stable_diffusion.diffusion import InvokeAIDiffuserComponent
-from ...backend.model_management import BaseModelType, ModelType, SubModelType
-from ...backend.model_management.lora import ModelPatcher
-
-from compel import Compel
-from compel.prompt_parser import (
-    Blend,
-    CrossAttentionControlSubstitute,
-    FlattenedPrompt,
-    Fragment, Conjunction,
-)
-
-
-class ConditioningField(BaseModel):
-    conditioning_name: Optional[str] = Field(default=None, description="The name of conditioning data")
-    class Config:
-        schema_extra = {"required": ["conditioning_name"]}
-
-
-class CompelOutput(BaseInvocationOutput):
-    """Compel parser output"""
-
-    #fmt: off
-    type: Literal["compel_output"] = "compel_output"
-
-    conditioning: ConditioningField = Field(default=None, description="Conditioning")
-    #fmt: on
-
-
-class CompelInvocation(BaseInvocation):
-    """Parse prompt using compel package to conditioning."""
-
-    type: Literal["compel"] = "compel"
-
-    prompt: str = Field(default="", description="Prompt")
-    clip: ClipField = Field(None, description="Clip to use")
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "title": "Prompt (Compel)",
-                "tags": ["prompt", "compel"],
-                "type_hints": {
-                  "model": "model"
-                }
-            },
-        }
-
-    def invoke(self, context: InvocationContext) -> CompelOutput:
-
-        tokenizer_info = context.services.model_manager.get_model(
-            **self.clip.tokenizer.dict(),
-        )
-        text_encoder_info = context.services.model_manager.get_model(
-            **self.clip.text_encoder.dict(),
-        )
-        with tokenizer_info as orig_tokenizer,\
-             text_encoder_info as text_encoder,\
-             ExitStack() as stack:
-
-            loras = [(stack.enter_context(context.services.model_manager.get_model(**lora.dict(exclude={"weight"}))), lora.weight) for lora in self.clip.loras]
-
-            ti_list = []
-            for trigger in re.findall(r"<[a-zA-Z0-9., _-]+>", self.prompt):
-                name = trigger[1:-1]
-                try:
-                    ti_list.append(
-                        stack.enter_context(
-                            context.services.model_manager.get_model(
-                                model_name=name,
-                                base_model=self.clip.text_encoder.base_model,
-                                model_type=ModelType.TextualInversion,
-                            )
-                        )
-                    )
-                except Exception:
-                    #print(e)
-                    #import traceback
-                    #print(traceback.format_exc())
-                    print(f"Warn: trigger: \"{trigger}\" not found")
-
-            with ModelPatcher.apply_lora_text_encoder(text_encoder, loras),\
-                 ModelPatcher.apply_ti(orig_tokenizer, text_encoder, ti_list) as (tokenizer, ti_manager):
-
-                compel = Compel(
-                    tokenizer=tokenizer,
-                    text_encoder=text_encoder,
-                    textual_inversion_manager=ti_manager,
-                    dtype_for_device_getter=torch_dtype,
-                    truncate_long_prompts=True, # TODO:
-                )
-                
-                conjunction = Compel.parse_prompt_string(self.prompt)
-                prompt: Union[FlattenedPrompt, Blend] = conjunction.prompts[0]
-
-                if context.services.configuration.log_tokenization:
-                    log_tokenization_for_prompt_object(prompt, tokenizer)
-
-                c, options = compel.build_conditioning_tensor_for_prompt_object(prompt)
-                
-                # TODO: long prompt support
-                #if not self.truncate_long_prompts:
-                #    [c, uc] = compel.pad_conditioning_tensors_to_same_length([c, uc])
-                ec = InvokeAIDiffuserComponent.ExtraConditioningInfo(
-                    tokens_count_including_eos_bos=get_max_token_count(tokenizer, conjunction),
-                    cross_attention_control_args=options.get("cross_attention_control", None),
-                )
-                
-            conditioning_name = f"{context.graph_execution_state_id}_{self.id}_conditioning"
-
-            # TODO: hacky but works ;D maybe rename latents somehow?
-            context.services.latents.save(conditioning_name, (c, ec))
-
-            return CompelOutput(
-                conditioning=ConditioningField(
-                    conditioning_name=conditioning_name,
-                ),
-            )
-
-
-def get_max_token_count(
-    tokenizer, prompt: Union[FlattenedPrompt, Blend, Conjunction], truncate_if_too_long=False
-) -> int:
-    if type(prompt) is Blend:
-        blend: Blend = prompt
-        return max(
-            [
-                get_max_token_count(tokenizer, p, truncate_if_too_long)
-                for p in blend.prompts
-            ]
-        )
-    elif type(prompt) is Conjunction:
-        conjunction: Conjunction = prompt
-        return sum(
-            [
-                get_max_token_count(tokenizer, p, truncate_if_too_long)
-                for p in conjunction.prompts
-            ]
-        )
-    else:
-        return len(
-            get_tokens_for_prompt_object(tokenizer, prompt, truncate_if_too_long)
-        )
-
-
-def get_tokens_for_prompt_object(
-    tokenizer, parsed_prompt: FlattenedPrompt, truncate_if_too_long=True
-) -> [str]:
-    if type(parsed_prompt) is Blend:
-        raise ValueError(
-            "Blend is not supported here - you need to get tokens for each of its .children"
-        )
-
-    text_fragments = [
-        x.text
-        if type(x) is Fragment
-        else (
-            " ".join([f.text for f in x.original])
-            if type(x) is CrossAttentionControlSubstitute
-            else str(x)
-        )
-        for x in parsed_prompt.children
-    ]
-    text = " ".join(text_fragments)
-    tokens = tokenizer.tokenize(text)
-    if truncate_if_too_long:
-        max_tokens_length = tokenizer.model_max_length - 2  # typically 75
-        tokens = tokens[0:max_tokens_length]
-    return tokens
-
-
-def log_tokenization_for_conjunction(
-    c: Conjunction, tokenizer, display_label_prefix=None
-):
-    display_label_prefix = display_label_prefix or ""
-    for i, p in enumerate(c.prompts):
-        if len(c.prompts)>1:
-            this_display_label_prefix = f"{display_label_prefix}(conjunction part {i + 1}, weight={c.weights[i]})"
-        else:
-            this_display_label_prefix = display_label_prefix
-        log_tokenization_for_prompt_object(
-            p,
-            tokenizer,
-            display_label_prefix=this_display_label_prefix
-        )
-
-
-def log_tokenization_for_prompt_object(
-    p: Union[Blend, FlattenedPrompt], tokenizer, display_label_prefix=None
-):
-    display_label_prefix = display_label_prefix or ""
-    if type(p) is Blend:
-        blend: Blend = p
-        for i, c in enumerate(blend.prompts):
-            log_tokenization_for_prompt_object(
-                c,
-                tokenizer,
-                display_label_prefix=f"{display_label_prefix}(blend part {i + 1}, weight={blend.weights[i]})",
-            )
-    elif type(p) is FlattenedPrompt:
-        flattened_prompt: FlattenedPrompt = p
-        if flattened_prompt.wants_cross_attention_control:
-            original_fragments = []
-            edited_fragments = []
-            for f in flattened_prompt.children:
-                if type(f) is CrossAttentionControlSubstitute:
-                    original_fragments += f.original
-                    edited_fragments += f.edited
-                else:
-                    original_fragments.append(f)
-                    edited_fragments.append(f)
-
-            original_text = " ".join([x.text for x in original_fragments])
-            log_tokenization_for_text(
-                original_text,
-                tokenizer,
-                display_label=f"{display_label_prefix}(.swap originals)",
-            )
-            edited_text = " ".join([x.text for x in edited_fragments])
-            log_tokenization_for_text(
-                edited_text,
-                tokenizer,
-                display_label=f"{display_label_prefix}(.swap replacements)",
-            )
-        else:
-            text = " ".join([x.text for x in flattened_prompt.children])
-            log_tokenization_for_text(
-                text, tokenizer, display_label=display_label_prefix
-            )
-
-
-def log_tokenization_for_text(text, tokenizer, display_label=None, truncate_if_too_long=False):
-    """shows how the prompt is tokenized
-    # usually tokens have '</w>' to indicate end-of-word,
-    # but for readability it has been replaced with ' '
-    """
-    tokens = tokenizer.tokenize(text)
-    tokenized = ""
-    discarded = ""
-    usedTokens = 0
-    totalTokens = len(tokens)
-
-    for i in range(0, totalTokens):
-        token = tokens[i].replace("</w>", " ")
-        # alternate color
-        s = (usedTokens % 6) + 1
-        if truncate_if_too_long and i >= tokenizer.model_max_length:
-            discarded = discarded + f"\x1b[0;3{s};40m{token}"
-        else:
-            tokenized = tokenized + f"\x1b[0;3{s};40m{token}"
-            usedTokens += 1
-
-    if usedTokens > 0:
-        print(f'\n>> [TOKENLOG] Tokens {display_label or ""} ({usedTokens}):')
-        print(f"{tokenized}\x1b[0m")
-
-    if discarded != "":
-        print(f"\n>> [TOKENLOG] Tokens Discarded ({totalTokens - usedTokens}):")
-        print(f"{discarded}\x1b[0m")

invokeai/app/invocations/controlnet_image_processors.py

@@ -1,457 +0,0 @@
-# InvokeAI nodes for ControlNet image preprocessors
-# initial implementation by Gregg Helt, 2023
-# heavily leverages controlnet_aux package: https://github.com/patrickvonplaten/controlnet_aux
-from builtins import float, bool
-
-import numpy as np
-from typing import Literal, Optional, Union, List
-from PIL import Image, ImageFilter, ImageOps
-from pydantic import BaseModel, Field, validator
-
-from ..models.image import ImageField, ImageCategory, ResourceOrigin
-from .baseinvocation import (
-    BaseInvocation,
-    BaseInvocationOutput,
-    InvocationContext,
-    InvocationConfig,
-)
-
-from controlnet_aux import (
-    CannyDetector,
-    HEDdetector,
-    LineartDetector,
-    LineartAnimeDetector,
-    MidasDetector,
-    MLSDdetector,
-    NormalBaeDetector,
-    OpenposeDetector,
-    PidiNetDetector,
-    ContentShuffleDetector,
-    ZoeDetector,
-    MediapipeFaceDetector,
-)
-
-from .image import ImageOutput, PILInvocationConfig
-
-CONTROLNET_DEFAULT_MODELS = [
-    ###########################################
-    # lllyasviel sd v1.5, ControlNet v1.0 models
-    ##############################################
-    "lllyasviel/sd-controlnet-canny",
-    "lllyasviel/sd-controlnet-depth",
-    "lllyasviel/sd-controlnet-hed",
-    "lllyasviel/sd-controlnet-seg",
-    "lllyasviel/sd-controlnet-openpose",
-    "lllyasviel/sd-controlnet-scribble",
-    "lllyasviel/sd-controlnet-normal",
-    "lllyasviel/sd-controlnet-mlsd",
-
-    #############################################
-    # lllyasviel sd v1.5, ControlNet v1.1 models
-    #############################################
-    "lllyasviel/control_v11p_sd15_canny",
-    "lllyasviel/control_v11p_sd15_openpose",
-    "lllyasviel/control_v11p_sd15_seg",
-    # "lllyasviel/control_v11p_sd15_depth",  # broken
-    "lllyasviel/control_v11f1p_sd15_depth",
-    "lllyasviel/control_v11p_sd15_normalbae",
-    "lllyasviel/control_v11p_sd15_scribble",
-    "lllyasviel/control_v11p_sd15_mlsd",
-    "lllyasviel/control_v11p_sd15_softedge",
-    "lllyasviel/control_v11p_sd15s2_lineart_anime",
-    "lllyasviel/control_v11p_sd15_lineart",
-    "lllyasviel/control_v11p_sd15_inpaint",
-    # "lllyasviel/control_v11u_sd15_tile",
-    # problem (temporary?) with huffingface "lllyasviel/control_v11u_sd15_tile",
-    # so for now replace  "lllyasviel/control_v11f1e_sd15_tile",
-    "lllyasviel/control_v11e_sd15_shuffle",
-    "lllyasviel/control_v11e_sd15_ip2p",
-    "lllyasviel/control_v11f1e_sd15_tile",
-
-     #################################################
-     #  thibaud sd v2.1 models (ControlNet v1.0? or v1.1?
-     ##################################################
-     "thibaud/controlnet-sd21-openpose-diffusers",
-     "thibaud/controlnet-sd21-canny-diffusers",
-     "thibaud/controlnet-sd21-depth-diffusers",
-     "thibaud/controlnet-sd21-scribble-diffusers",
-     "thibaud/controlnet-sd21-hed-diffusers",
-     "thibaud/controlnet-sd21-zoedepth-diffusers",
-     "thibaud/controlnet-sd21-color-diffusers",
-     "thibaud/controlnet-sd21-openposev2-diffusers",
-     "thibaud/controlnet-sd21-lineart-diffusers",
-     "thibaud/controlnet-sd21-normalbae-diffusers",
-     "thibaud/controlnet-sd21-ade20k-diffusers",
-
-     ##############################################
-     #  ControlNetMediaPipeface, ControlNet v1.1
-     ##############################################
-     # ["CrucibleAI/ControlNetMediaPipeFace", "diffusion_sd15"],  # SD 1.5
-     #    diffusion_sd15 needs to be passed to from_pretrained() as subfolder arg
-     #    hacked t2l to split to model & subfolder if format is "model,subfolder"
-     "CrucibleAI/ControlNetMediaPipeFace,diffusion_sd15",  # SD 1.5
-     "CrucibleAI/ControlNetMediaPipeFace",  # SD 2.1?
-]
-
-CONTROLNET_NAME_VALUES = Literal[tuple(CONTROLNET_DEFAULT_MODELS)]
-CONTROLNET_MODE_VALUES = Literal[tuple(["balanced", "more_prompt", "more_control", "unbalanced"])]
-
-class ControlField(BaseModel):
-    image: ImageField = Field(default=None, description="The control image")
-    control_model: Optional[str] = Field(default=None, description="The ControlNet model to use")
-    # control_weight: Optional[float] = Field(default=1, description="weight given to controlnet")
-    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 contorl mode to use")
-
-    @validator("control_weight")
-    def abs_le_one(cls, v):
-        """validate that all abs(values) are <=1"""
-        if isinstance(v, list):
-            for i in v:
-                if abs(i) > 1:
-                    raise ValueError('all abs(control_weight) must be <= 1')
-        else:
-            if abs(v) > 1:
-                raise ValueError('abs(control_weight) must be <= 1')
-        return v
-    class Config:
-        schema_extra = {
-            "required": ["image", "control_model", "control_weight", "begin_step_percent", "end_step_percent"],
-            "ui": {
-                "type_hints": {
-                    "control_weight": "float",
-                    # "control_weight": "number",
-                }
-            }
-        }
-
-
-class ControlOutput(BaseInvocationOutput):
-    """node output for ControlNet info"""
-    # fmt: off
-    type: Literal["control_output"] = "control_output"
-    control: ControlField = Field(default=None, description="The control info")
-    # fmt: on
-
-
-class ControlNetInvocation(BaseInvocation):
-    """Collects ControlNet info to pass to other nodes"""
-    # fmt: off
-    type: Literal["controlnet"] = "controlnet"
-    # Inputs
-    image: ImageField = Field(default=None, description="The control image")
-    control_model: CONTROLNET_NAME_VALUES = Field(default="lllyasviel/sd-controlnet-canny",
-                                                  description="control model used")
-    control_weight: Union[float, List[float]] = Field(default=1.0, 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 used")
-    # fmt: on
-
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["latents"],
-                "type_hints": {
-                  "model": "model",
-                  "control": "control",
-                  # "cfg_scale": "float",
-                  "cfg_scale": "number",
-                  "control_weight": "float",
-                }
-            },
-        }
-
-    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,
-            ),
-        )
-
-# TODO: move image processors to separate file (image_analysis.py
-class ImageProcessorInvocation(BaseInvocation, PILInvocationConfig):
-    """Base class for invocations that preprocess images for ControlNet"""
-
-    # fmt: off
-    type: Literal["image_processor"] = "image_processor"
-    # Inputs
-    image: ImageField = Field(default=None, description="The image to process")
-    # fmt: on
-
-
-    def run_processor(self, image):
-        # superclass just passes through image without processing
-        return image
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        raw_image = context.services.images.get_pil_image(self.image.image_name)
-        # image type should be PIL.PngImagePlugin.PngImageFile ?
-        processed_image = self.run_processor(raw_image)
-
-        # FIXME: what happened to image metadata?
-        # metadata = context.services.metadata.build_metadata(
-        #     session_id=context.graph_execution_state_id, node=self
-        # )
-
-        # 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.services.images.create(
-            image=processed_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.CONTROL,
-            session_id=context.graph_execution_state_id,
-            node_id=self.id,
-            is_intermediate=self.is_intermediate
-        )
-
-        """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,
-        )
-
-
-class CannyImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Canny edge detection for ControlNet"""
-    # fmt: off
-    type: Literal["canny_image_processor"] = "canny_image_processor"
-    # Input
-    low_threshold: int = Field(default=100, ge=0, le=255, description="The low threshold of the Canny pixel gradient (0-255)")
-    high_threshold: int = Field(default=200, ge=0, le=255, description="The high threshold of the Canny pixel gradient (0-255)")
-    # fmt: on
-
-    def run_processor(self, image):
-        canny_processor = CannyDetector()
-        processed_image = canny_processor(image, self.low_threshold, self.high_threshold)
-        return processed_image
-
-
-class HedImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies HED edge detection to image"""
-    # fmt: off
-    type: Literal["hed_image_processor"] = "hed_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="The pixel resolution for detection")
-    image_resolution: int = Field(default=512, ge=0, description="The pixel resolution for the output image")
-    # safe not supported in controlnet_aux v0.0.3
-    # safe: bool = Field(default=False, description="whether to use safe mode")
-    scribble: bool = Field(default=False, description="Whether to use scribble mode")
-    # fmt: on
-
-    def run_processor(self, image):
-        hed_processor = HEDdetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = hed_processor(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
-
-
-class LineartImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies line art processing to image"""
-    # fmt: off
-    type: Literal["lineart_image_processor"] = "lineart_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="The pixel resolution for detection")
-    image_resolution: int = Field(default=512, ge=0, description="The pixel resolution for the output image")
-    coarse: bool = Field(default=False, description="Whether to use coarse mode")
-    # fmt: on
-
-    def run_processor(self, image):
-        lineart_processor = LineartDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = lineart_processor(image,
-                                            detect_resolution=self.detect_resolution,
-                                            image_resolution=self.image_resolution,
-                                            coarse=self.coarse)
-        return processed_image
-
-
-class LineartAnimeImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies line art anime processing to image"""
-    # fmt: off
-    type: Literal["lineart_anime_image_processor"] = "lineart_anime_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="The pixel resolution for detection")
-    image_resolution: int = Field(default=512, ge=0, description="The pixel resolution for the output image")
-    # fmt: on
-
-    def run_processor(self, image):
-        processor = LineartAnimeDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = processor(image,
-                                    detect_resolution=self.detect_resolution,
-                                    image_resolution=self.image_resolution,
-                                    )
-        return processed_image
-
-
-class OpenposeImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies Openpose processing to image"""
-    # fmt: off
-    type: Literal["openpose_image_processor"] = "openpose_image_processor"
-    # Inputs
-    hand_and_face: bool = Field(default=False, description="Whether to use hands and face mode")
-    detect_resolution: int = Field(default=512, ge=0, description="The pixel resolution for detection")
-    image_resolution: int = Field(default=512, ge=0, description="The pixel resolution for the output image")
-    # fmt: on
-
-    def run_processor(self, image):
-        openpose_processor = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = openpose_processor(image,
-                                             detect_resolution=self.detect_resolution,
-                                             image_resolution=self.image_resolution,
-                                             hand_and_face=self.hand_and_face,
-                                             )
-        return processed_image
-
-
-class MidasDepthImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies Midas depth processing to image"""
-    # fmt: off
-    type: Literal["midas_depth_image_processor"] = "midas_depth_image_processor"
-    # Inputs
-    a_mult: float = Field(default=2.0, ge=0, description="Midas parameter `a_mult` (a = a_mult * PI)")
-    bg_th: float = Field(default=0.1, ge=0, description="Midas parameter `bg_th`")
-    # depth_and_normal not supported in controlnet_aux v0.0.3
-    # depth_and_normal: bool = Field(default=False, description="whether to use depth and normal mode")
-    # fmt: on
-
-    def run_processor(self, image):
-        midas_processor = MidasDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = midas_processor(image,
-                                          a=np.pi * self.a_mult,
-                                          bg_th=self.bg_th,
-                                          # dept_and_normal not supported in controlnet_aux v0.0.3
-                                          # depth_and_normal=self.depth_and_normal,
-                                          )
-        return processed_image
-
-
-class NormalbaeImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies NormalBae processing to image"""
-    # fmt: off
-    type: Literal["normalbae_image_processor"] = "normalbae_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="The pixel resolution for detection")
-    image_resolution: int = Field(default=512, ge=0, description="The pixel resolution for the output image")
-    # fmt: on
-
-    def run_processor(self, 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
-
-
-class MlsdImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies MLSD processing to image"""
-    # fmt: off
-    type: Literal["mlsd_image_processor"] = "mlsd_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="The pixel resolution for detection")
-    image_resolution: int = Field(default=512, ge=0, description="The pixel resolution for the output image")
-    thr_v: float = Field(default=0.1, ge=0, description="MLSD parameter `thr_v`")
-    thr_d: float = Field(default=0.1, ge=0, description="MLSD parameter `thr_d`")
-    # fmt: on
-
-    def run_processor(self, 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
-
-
-class PidiImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies PIDI processing to image"""
-    # fmt: off
-    type: Literal["pidi_image_processor"] = "pidi_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="The pixel resolution for detection")
-    image_resolution: int = Field(default=512, ge=0, description="The pixel resolution for the output image")
-    safe: bool = Field(default=False, description="Whether to use safe mode")
-    scribble: bool = Field(default=False, description="Whether to use scribble mode")
-    # fmt: on
-
-    def run_processor(self, 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
-
-
-class ContentShuffleImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies content shuffle processing to image"""
-    # fmt: off
-    type: Literal["content_shuffle_image_processor"] = "content_shuffle_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="The pixel resolution for detection")
-    image_resolution: int = Field(default=512, ge=0, description="The pixel resolution for the output image")
-    h: Union[int, None] = Field(default=512, ge=0, description="Content shuffle `h` parameter")
-    w: Union[int, None] = Field(default=512, ge=0, description="Content shuffle `w` parameter")
-    f: Union[int, None] = Field(default=256, ge=0, description="Content shuffle `f` parameter")
-    # fmt: on
-
-    def run_processor(self, 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
-class ZoeDepthImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies Zoe depth processing to image"""
-    # fmt: off
-    type: Literal["zoe_depth_image_processor"] = "zoe_depth_image_processor"
-    # fmt: on
-
-    def run_processor(self, image):
-        zoe_depth_processor = ZoeDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = zoe_depth_processor(image)
-        return processed_image
-
-
-class MediapipeFaceProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies mediapipe face processing to image"""
-    # fmt: off
-    type: Literal["mediapipe_face_processor"] = "mediapipe_face_processor"
-    # Inputs
-    max_faces: int = Field(default=1, ge=1, description="Maximum number of faces to detect")
-    min_confidence: float = Field(default=0.5, ge=0, le=1, description="Minimum confidence for face detection")
-    # fmt: on
-
-    def run_processor(self, image):
-        mediapipe_face_processor = MediapipeFaceDetector()
-        processed_image = mediapipe_face_processor(image, max_faces=self.max_faces, min_confidence=self.min_confidence)
-        return processed_image

invokeai/app/invocations/cv.py

@@ -7,9 +7,9 @@ import numpy
 from PIL import Image, ImageOps
 from pydantic import BaseModel, Field
 
-from invokeai.app.models.image import ImageCategory, ImageField, ResourceOrigin
+from invokeai.app.models.image import ImageField, ImageType
 from .baseinvocation import BaseInvocation, InvocationContext, InvocationConfig
-from .image import ImageOutput
+from .image import ImageOutput, build_image_output
 
 
 class CvInvocationConfig(BaseModel):
@@ -26,23 +26,24 @@ class CvInvocationConfig(BaseModel):
 
 class CvInpaintInvocation(BaseInvocation, CvInvocationConfig):
     """Simple inpaint using opencv."""
-
-    # fmt: off
+    #fmt: off
     type: Literal["cv_inpaint"] = "cv_inpaint"
 
     # Inputs
     image: ImageField = Field(default=None, description="The image to inpaint")
     mask: ImageField = Field(default=None, description="The mask to use when inpainting")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-        mask = context.services.images.get_pil_image(self.mask.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
+        mask = context.services.images.get(self.mask.image_type, self.mask.image_name)
 
         # Convert to cv image/mask
         # TODO: consider making these utility functions
         cv_image = cv.cvtColor(numpy.array(image.convert("RGB")), cv.COLOR_RGB2BGR)
-        cv_mask = numpy.array(ImageOps.invert(mask.convert("L")))
+        cv_mask = numpy.array(ImageOps.invert(mask))
 
         # Inpaint
         cv_inpainted = cv.inpaint(cv_image, cv_mask, 3, cv.INPAINT_TELEA)
@@ -51,17 +52,18 @@ class CvInpaintInvocation(BaseInvocation, CvInvocationConfig):
         # TODO: consider making a utility function
         image_inpainted = Image.fromarray(cv.cvtColor(cv_inpainted, cv.COLOR_BGR2RGB))
 
-        image_dto = context.services.images.create(
-            image=image_inpainted,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
         )
+        
+        context.services.images.save(image_type, image_name, image_inpainted, metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=image_inpainted,
+        )

invokeai/app/invocations/generate.py

@@ -1,79 +1,142 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
 from functools import partial
-from typing import Literal, Optional, Union, get_args
+from typing import Literal, Optional, Union
 
-import torch
+import numpy as np
 from diffusers import ControlNetModel
+from torch import Tensor
+import torch
+
 from pydantic import BaseModel, Field
 
-from invokeai.app.models.image import (ColorField, ImageCategory, ImageField,
-                                       ResourceOrigin)
-from invokeai.app.util.misc import SEED_MAX, get_random_seed
-from invokeai.backend.generator.inpaint import infill_methods
-
-from ...backend.generator import Inpaint, InvokeAIGenerator
+from invokeai.app.models.image import ImageField, ImageType
+from invokeai.app.invocations.util.choose_model import choose_model
+from .baseinvocation import BaseInvocation, InvocationContext, InvocationConfig
+from .image import ImageOutput, build_image_output
+from ...backend.generator import Txt2Img, Img2Img, Inpaint, InvokeAIGenerator
 from ...backend.stable_diffusion import PipelineIntermediateState
 from ..util.step_callback import stable_diffusion_step_callback
-from .baseinvocation import BaseInvocation, InvocationConfig, InvocationContext
-from .image import ImageOutput
-
-import re
-from ...backend.model_management.lora import ModelPatcher
-from ...backend.stable_diffusion.diffusers_pipeline import StableDiffusionGeneratorPipeline
-from .model import UNetField, VaeField
-from .compel import ConditioningField
-from contextlib import contextmanager, ExitStack, ContextDecorator
 
 SAMPLER_NAME_VALUES = Literal[tuple(InvokeAIGenerator.schedulers())]
-INFILL_METHODS = Literal[tuple(infill_methods())]
-DEFAULT_INFILL_METHOD = (
-    "patchmatch" if "patchmatch" in get_args(INFILL_METHODS) else "tile"
-)
 
 
-from .latent import get_scheduler
+class SDImageInvocation(BaseModel):
+    """Helper class to provide all Stable Diffusion raster image invocations with additional config"""
 
-class OldModelContext(ContextDecorator):
-    model: StableDiffusionGeneratorPipeline
+    # Schema customisation
+    class Config(InvocationConfig):
+        schema_extra = {
+            "ui": {
+                "tags": ["stable-diffusion", "image"],
+                "type_hints": {
+                    "model": "model",
+                },
+            },
+        }
 
-    def __init__(self, model):
-        self.model = model
 
-    def __enter__(self):
-        return self.model
+# Text to image
+class TextToImageInvocation(BaseInvocation, SDImageInvocation):
+    """Generates an image using text2img."""
 
-    def __exit__(self, *exc):
-        return False
+    type: Literal["txt2img"] = "txt2img"
 
-class OldModelInfo:
-    name: str
-    hash: str
-    context: OldModelContext
+    # Inputs
+    # TODO: consider making prompt optional to enable providing prompt through a link
+    # fmt: off
+    prompt: Optional[str] = Field(description="The prompt to generate an image from")
+    seed:        int = Field(default=-1,ge=-1, le=np.iinfo(np.uint32).max, description="The seed to use (-1 for a random seed)", )
+    steps:       int = Field(default=10, gt=0, description="The number of steps to use to generate the image")
+    width:       int = Field(default=512, multiple_of=64, gt=0, description="The width of the resulting image", )
+    height:      int = Field(default=512, multiple_of=64, gt=0, description="The height of the resulting image", )
+    cfg_scale: float = Field(default=7.5, gt=0, description="The Classifier-Free Guidance, higher values may result in a result closer to the prompt", )
+    scheduler: SAMPLER_NAME_VALUES = Field(default="k_lms", description="The scheduler to use" )
+    seamless:   bool = Field(default=False, description="Whether or not to generate an image that can tile without seams", )
+    model:       str = Field(default="", description="The model to use (currently ignored)")
+    progress_images: bool = Field(default=False, description="Whether or not to produce progress images during generation",  )
+    control_model: Optional[str] = Field(default=None, description="The control model to use")
+    control_image: Optional[ImageField] = Field(default=None, description="The processed control image")
+    # control_strength: Optional[float] = Field(default=1.0, ge=0, le=1, description="The strength of the controlnet")
+    # fmt: on
 
-    def __init__(self, name: str, hash: str, model: StableDiffusionGeneratorPipeline):
-        self.name = name
-        self.hash = hash
-        self.context = OldModelContext(
-            model=model,
+    # TODO: pass this an emitter method or something? or a session for dispatching?
+    def dispatch_progress(
+        self,
+        context: InvocationContext,
+        source_node_id: str,
+        intermediate_state: PipelineIntermediateState,
+    ) -> None:
+        stable_diffusion_step_callback(
+            context=context,
+            intermediate_state=intermediate_state,
+            node=self.dict(),
+            source_node_id=source_node_id,
+        )
+
+    def invoke(self, context: InvocationContext) -> ImageOutput:
+        model = choose_model(context.services.model_manager, self.model)
+
+        # loading controlnet image (currently requires pre-processed image)
+        control_image = (
+            None if self.control_image is None
+            else context.services.images.get(
+                self.control_image.image_type, self.control_image.image_name
+            )
+        )
+        # loading controlnet model
+        if (self.control_model is None or self.control_model==''):
+            control_model = None
+        else:
+            # FIXME: change this to dropdown menu?
+            control_model = ControlNetModel.from_pretrained(self.control_model,
+                                                            torch_dtype=torch.float16).to("cuda")
+
+        # Get the source node id (we are invoking the prepared node)
+        graph_execution_state = context.services.graph_execution_manager.get(
+            context.graph_execution_state_id
+        )
+        source_node_id = graph_execution_state.prepared_source_mapping[self.id]
+
+        txt2img = Txt2Img(model, control_model=control_model)
+        outputs = txt2img.generate(
+            prompt=self.prompt,
+            step_callback=partial(self.dispatch_progress, context, source_node_id),
+            control_image=control_image,
+            **self.dict(
+                exclude={"prompt", "control_image" }
+            ),  # Shorthand for passing all of the parameters above manually
+        )
+        # Outputs is an infinite iterator that will return a new InvokeAIGeneratorOutput object
+        # each time it is called. We only need the first one.
+        generate_output = next(outputs)
+
+        # Results are image and seed, unwrap for now and ignore the seed
+        # TODO: pre-seed?
+        # TODO: can this return multiple results? Should it?
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
+        )
+
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
+        )
+
+        context.services.images.save(
+            image_type, image_name, generate_output.image, metadata
+        )
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=generate_output.image,
         )
 
 
-class InpaintInvocation(BaseInvocation):
-    """Generates an image using inpaint."""
+class ImageToImageInvocation(TextToImageInvocation):
+    """Generates an image using img2img."""
 
-    type: Literal["inpaint"] = "inpaint"
-
-    positive_conditioning: Optional[ConditioningField] = Field(description="Positive conditioning for generation")
-    negative_conditioning: Optional[ConditioningField] = Field(description="Negative conditioning for generation")
-    seed:        int = Field(ge=0, le=SEED_MAX, description="The seed to use (omit for random)", default_factory=get_random_seed)
-    steps:       int = Field(default=30, gt=0, description="The number of steps to use to generate the image")
-    width:       int = Field(default=512, multiple_of=8, gt=0, description="The width of the resulting image", )
-    height:      int = Field(default=512, multiple_of=8, gt=0, description="The height of the resulting image", )
-    cfg_scale: float = Field(default=7.5, ge=1, description="The Classifier-Free Guidance, higher values may result in a result closer to the prompt", )
-    scheduler: SAMPLER_NAME_VALUES = Field(default="euler", description="The scheduler to use" )
-    unet: UNetField = Field(default=None, description="UNet model")
-    vae: VaeField = Field(default=None, description="Vae model")
+    type: Literal["img2img"] = "img2img"
 
     # Inputs
     image: Union[ImageField, None] = Field(description="The input image")
@@ -85,56 +148,6 @@ class InpaintInvocation(BaseInvocation):
         description="Whether or not the result should be fit to the aspect ratio of the input image",
     )
 
-    # Inputs
-    mask: Union[ImageField, None] = Field(description="The mask")
-    seam_size: int = Field(default=96, ge=1, description="The seam inpaint size (px)")
-    seam_blur: int = Field(
-        default=16, ge=0, description="The seam inpaint blur radius (px)"
-    )
-    seam_strength: float = Field(
-        default=0.75, gt=0, le=1, description="The seam inpaint strength"
-    )
-    seam_steps: int = Field(
-        default=30, ge=1, description="The number of steps to use for seam inpaint"
-    )
-    tile_size: int = Field(
-        default=32, ge=1, description="The tile infill method size (px)"
-    )
-    infill_method: INFILL_METHODS = Field(
-        default=DEFAULT_INFILL_METHOD,
-        description="The method used to infill empty regions (px)",
-    )
-    inpaint_width: Optional[int] = Field(
-        default=None,
-        multiple_of=8,
-        gt=0,
-        description="The width of the inpaint region (px)",
-    )
-    inpaint_height: Optional[int] = Field(
-        default=None,
-        multiple_of=8,
-        gt=0,
-        description="The height of the inpaint region (px)",
-    )
-    inpaint_fill: Optional[ColorField] = Field(
-        default=ColorField(r=127, g=127, b=127, a=255),
-        description="The solid infill method color",
-    )
-    inpaint_replace: float = Field(
-        default=0.0,
-        ge=0.0,
-        le=1.0,
-        description="The amount by which to replace masked areas with latent noise",
-    )
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["stable-diffusion", "image"],
-            },
-        }
-
     def dispatch_progress(
         self,
         context: InvocationContext,
@@ -148,60 +161,18 @@ class InpaintInvocation(BaseInvocation):
             source_node_id=source_node_id,
         )
 
-    def get_conditioning(self, context):
-        c, extra_conditioning_info = context.services.latents.get(self.positive_conditioning.conditioning_name)
-        uc, _ = context.services.latents.get(self.negative_conditioning.conditioning_name)
-
-        return (uc, c, extra_conditioning_info)
-
-    @contextmanager
-    def load_model_old_way(self, context, scheduler):
-        unet_info = context.services.model_manager.get_model(**self.unet.unet.dict())
-        vae_info = context.services.model_manager.get_model(**self.vae.vae.dict())
-
-        #unet = unet_info.context.model
-        #vae = vae_info.context.model
-
-        with ExitStack() as stack:
-            loras = [(stack.enter_context(context.services.model_manager.get_model(**lora.dict(exclude={"weight"}))), lora.weight) for lora in self.unet.loras]
-
-            with vae_info as vae,\
-                 unet_info as unet,\
-                 ModelPatcher.apply_lora_unet(unet, loras):
-
-                device = context.services.model_manager.mgr.cache.execution_device
-                dtype = context.services.model_manager.mgr.cache.precision
-
-                pipeline = StableDiffusionGeneratorPipeline(
-                    vae=vae,
-                    text_encoder=None,
-                    tokenizer=None,
-                    unet=unet,
-                    scheduler=scheduler,
-                    safety_checker=None,
-                    feature_extractor=None,
-                    requires_safety_checker=False,
-                    precision="float16" if dtype == torch.float16 else "float32",
-                    execution_device=device,
-                )
-
-                yield OldModelInfo(
-                    name=self.unet.unet.model_name,
-                    hash="<NO-HASH>",
-                    model=pipeline,
-                )
-
     def invoke(self, context: InvocationContext) -> ImageOutput:
         image = (
             None
             if self.image is None
-            else context.services.images.get_pil_image(self.image.image_name)
-        )
-        mask = (
-            None
-            if self.mask is None
-            else context.services.images.get_pil_image(self.mask.image_name)
+            else context.services.images.get(
+                self.image.image_type, self.image.image_name
+            )
         )
+        mask = None
+
+        # Handle invalid model parameter
+        model = choose_model(context.services.model_manager, self.model)
 
         # Get the source node id (we are invoking the prepared node)
         graph_execution_state = context.services.graph_execution_manager.get(
@@ -209,40 +180,123 @@ class InpaintInvocation(BaseInvocation):
         )
         source_node_id = graph_execution_state.prepared_source_mapping[self.id]
 
-        conditioning = self.get_conditioning(context)
-        scheduler = get_scheduler(
-            context=context,
-            scheduler_info=self.unet.scheduler,
-            scheduler_name=self.scheduler,
+        outputs = Img2Img(model).generate(
+            prompt=self.prompt,
+            init_image=image,
+            init_mask=mask,
+            step_callback=partial(self.dispatch_progress, context, source_node_id),
+            **self.dict(
+                exclude={"prompt", "image", "mask"}
+            ),  # Shorthand for passing all of the parameters above manually
         )
 
-        with self.load_model_old_way(context, scheduler) as model:
-            outputs = Inpaint(model).generate(
-                conditioning=conditioning,
-                scheduler=scheduler,
-                init_image=image,
-                mask_image=mask,
-                step_callback=partial(self.dispatch_progress, context, source_node_id),
-                **self.dict(
-                    exclude={"positive_conditioning", "negative_conditioning", "scheduler", "image", "mask"}
-                ),  # Shorthand for passing all of the parameters above manually
-            )
-
         # Outputs is an infinite iterator that will return a new InvokeAIGeneratorOutput object
         # each time it is called. We only need the first one.
         generator_output = next(outputs)
 
-        image_dto = context.services.images.create(
-            image=generator_output.image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            session_id=context.graph_execution_state_id,
-            node_id=self.id,
-            is_intermediate=self.is_intermediate,
+        result_image = generator_output.image
+
+        # Results are image and seed, unwrap for now and ignore the seed
+        # TODO: pre-seed?
+        # TODO: can this return multiple results? Should it?
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
+        )
+
+        context.services.images.save(image_type, image_name, result_image, metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=result_image,
+        )
+
+
+class InpaintInvocation(ImageToImageInvocation):
+    """Generates an image using inpaint."""
+
+    type: Literal["inpaint"] = "inpaint"
+
+    # Inputs
+    mask: Union[ImageField, None] = Field(description="The mask")
+    inpaint_replace: float = Field(
+        default=0.0,
+        ge=0.0,
+        le=1.0,
+        description="The amount by which to replace masked areas with latent noise",
+    )
+
+    def dispatch_progress(
+        self,
+        context: InvocationContext,
+        source_node_id: str,
+        intermediate_state: PipelineIntermediateState,
+    ) -> None:
+        stable_diffusion_step_callback(
+            context=context,
+            intermediate_state=intermediate_state,
+            node=self.dict(),
+            source_node_id=source_node_id,
+        )
+
+    def invoke(self, context: InvocationContext) -> ImageOutput:
+        image = (
+            None
+            if self.image is None
+            else context.services.images.get(
+                self.image.image_type, self.image.image_name
+            )
+        )
+        mask = (
+            None
+            if self.mask is None
+            else context.services.images.get(self.mask.image_type, self.mask.image_name)
+        )
+
+        # Handle invalid model parameter
+        model = choose_model(context.services.model_manager, self.model)
+
+        # Get the source node id (we are invoking the prepared node)
+        graph_execution_state = context.services.graph_execution_manager.get(
+            context.graph_execution_state_id
+        )
+        source_node_id = graph_execution_state.prepared_source_mapping[self.id]
+
+        outputs = Inpaint(model).generate(
+            prompt=self.prompt,
+            init_img=image,
+            init_mask=mask,
+            step_callback=partial(self.dispatch_progress, context, source_node_id),
+            **self.dict(
+                exclude={"prompt", "image", "mask"}
+            ),  # Shorthand for passing all of the parameters above manually
+        )
+
+        # Outputs is an infinite iterator that will return a new InvokeAIGeneratorOutput object
+        # each time it is called. We only need the first one.
+        generator_output = next(outputs)
+
+        result_image = generator_output.image
+
+        # Results are image and seed, unwrap for now and ignore the seed
+        # TODO: pre-seed?
+        # TODO: can this return multiple results? Should it?
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
+        )
+
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
+        )
+
+        context.services.images.save(image_type, image_name, result_image, metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=result_image,
         )

invokeai/app/invocations/image.py

@@ -1,13 +1,12 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-import io
-from typing import Literal, Optional, Union
+from typing import Literal, Optional
 
 import numpy
-from PIL import Image, ImageFilter, ImageOps, ImageChops
+from PIL import Image, ImageFilter, ImageOps
 from pydantic import BaseModel, Field
 
-from ..models.image import ImageCategory, ImageField, ResourceOrigin
+from ..models.image import ImageField, ImageType
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
@@ -31,14 +30,32 @@ class ImageOutput(BaseInvocationOutput):
     """Base class for invocations that output an image"""
 
     # fmt: off
-    type: Literal["image_output"] = "image_output"
+    type: Literal["image"] = "image"
     image:      ImageField = Field(default=None, description="The output image")
-    width:             int = Field(description="The width of the image in pixels")
-    height:            int = Field(description="The height of the image in pixels")
+    width:   Optional[int] = Field(default=None, description="The width of the image in pixels")
+    height:  Optional[int] = Field(default=None, description="The height of the image in pixels")
     # fmt: on
 
     class Config:
-        schema_extra = {"required": ["type", "image", "width", "height"]}
+        schema_extra = {
+            "required": ["type", "image", "width", "height", "mode"]
+        }
+
+
+def build_image_output(
+    image_type: ImageType, image_name: str, image: Image.Image
+) -> ImageOutput:
+    """Builds an ImageOutput and its ImageField"""
+    image_field = ImageField(
+        image_name=image_name,
+        image_type=image_type,
+    )
+    return ImageOutput(
+        image=image_field,
+        width=image.width,
+        height=image.height,
+        mode=image.mode,
+    )
 
 
 class MaskOutput(BaseInvocationOutput):
@@ -47,8 +64,6 @@ class MaskOutput(BaseInvocationOutput):
     # fmt: off
     type: Literal["mask"] = "mask"
     mask:      ImageField = Field(default=None, description="The output mask")
-    width:            int = Field(description="The width of the mask in pixels")
-    height:           int = Field(description="The height of the mask in pixels")
     # fmt: on
 
     class Config:
@@ -67,17 +82,16 @@ class LoadImageInvocation(BaseInvocation):
     type: Literal["load_image"] = "load_image"
 
     # Inputs
-    image: Union[ImageField, None] = Field(
-        default=None, description="The image to load"
-    )
+    image_type: ImageType = Field(description="The type of the image")
+    image_name:       str = Field(description="The name of the image")
     # fmt: on
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(self.image_type, self.image_name)
 
-        return ImageOutput(
-            image=ImageField(image_name=self.image.image_name),
-            width=image.width,
-            height=image.height,
+        return build_image_output(
+            image_type=self.image_type,
+            image_name=self.image_name,
+            image=image,
         )
 
 
@@ -87,32 +101,32 @@ class ShowImageInvocation(BaseInvocation):
     type: Literal["show_image"] = "show_image"
 
     # Inputs
-    image: Union[ImageField, None] = Field(
-        default=None, description="The image to show"
-    )
+    image: ImageField = Field(default=None, description="The image to show")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
         if image:
             image.show()
 
         # TODO: how to handle failure?
 
-        return ImageOutput(
-            image=ImageField(image_name=self.image.image_name),
-            width=image.width,
-            height=image.height,
+        return build_image_output(
+            image_type=self.image.image_type,
+            image_name=self.image.image_name,
+            image=image,
         )
 
 
-class ImageCropInvocation(BaseInvocation, PILInvocationConfig):
+class CropImageInvocation(BaseInvocation, PILInvocationConfig):
     """Crops an image to a specified box. The box can be outside of the image."""
 
     # fmt: off
-    type: Literal["img_crop"] = "img_crop"
+    type: Literal["crop"] = "crop"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to crop")
+    image: ImageField = Field(default=None, description="The image to crop")
     x:      int = Field(default=0, description="The left x coordinate of the crop rectangle")
     y:      int = Field(default=0, description="The top y coordinate of the crop rectangle")
     width:  int = Field(default=512, gt=0, description="The width of the crop rectangle")
@@ -120,51 +134,58 @@ class ImageCropInvocation(BaseInvocation, PILInvocationConfig):
     # fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
 
         image_crop = Image.new(
             mode="RGBA", size=(self.width, self.height), color=(0, 0, 0, 0)
         )
         image_crop.paste(image, (-self.x, -self.y))
 
-        image_dto = context.services.images.create(
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
+        )
+
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
+        )
+        
+        context.services.images.save(image_type, image_name, image_crop, metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
             image=image_crop,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
         )
 
 
-class ImagePasteInvocation(BaseInvocation, PILInvocationConfig):
+class PasteImageInvocation(BaseInvocation, PILInvocationConfig):
     """Pastes an image into another image."""
 
     # fmt: off
-    type: Literal["img_paste"] = "img_paste"
+    type: Literal["paste"] = "paste"
 
     # Inputs
-    base_image:     Union[ImageField, None]  = Field(default=None, description="The base image")
-    image:          Union[ImageField, None]  = Field(default=None, description="The image to paste")
+    base_image:     ImageField = Field(default=None, description="The base image")
+    image:          ImageField = Field(default=None, description="The image to paste")
     mask: Optional[ImageField] = Field(default=None, description="The mask to use when pasting")
     x:                     int = Field(default=0, description="The left x coordinate at which to paste the image")
     y:                     int = Field(default=0, description="The top y coordinate at which to paste the image")
     # fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        base_image = context.services.images.get_pil_image(self.base_image.image_name)
-        image = context.services.images.get_pil_image(self.image.image_name)
+        base_image = context.services.images.get(
+            self.base_image.image_type, self.base_image.image_name
+        )
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
         mask = (
             None
             if self.mask is None
             else ImageOps.invert(
-                context.services.images.get_pil_image(self.mask.image_name)
+                context.services.images.get(self.mask.image_type, self.mask.image_name)
             )
         )
         # TODO: probably shouldn't invert mask here... should user be required to do it?
@@ -180,19 +201,20 @@ class ImagePasteInvocation(BaseInvocation, PILInvocationConfig):
         new_image.paste(base_image, (abs(min_x), abs(min_y)))
         new_image.paste(image, (max(0, self.x), max(0, self.y)), mask=mask)
 
-        image_dto = context.services.images.create(
-            image=new_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
+        )
+        
+        context.services.images.save(image_type, image_name, new_image, metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=new_image,
         )
 
 
@@ -203,150 +225,48 @@ class MaskFromAlphaInvocation(BaseInvocation, PILInvocationConfig):
     type: Literal["tomask"] = "tomask"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to create the mask from")
+    image: ImageField = Field(default=None, description="The image to create the mask from")
     invert:      bool = Field(default=False, description="Whether or not to invert the mask")
     # fmt: on
 
     def invoke(self, context: InvocationContext) -> MaskOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
 
         image_mask = image.split()[-1]
         if self.invert:
             image_mask = ImageOps.invert(image_mask)
 
-        image_dto = context.services.images.create(
-            image=image_mask,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.MASK,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return MaskOutput(
-            mask=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
         )
 
-
-class ImageMultiplyInvocation(BaseInvocation, PILInvocationConfig):
-    """Multiplies two images together using `PIL.ImageChops.multiply()`."""
-
-    # fmt: off
-    type: Literal["img_mul"] = "img_mul"
-
-    # Inputs
-    image1: Union[ImageField, None]  = Field(default=None, description="The first image to multiply")
-    image2: Union[ImageField, None]  = Field(default=None, description="The second image to multiply")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image1 = context.services.images.get_pil_image(self.image1.image_name)
-        image2 = context.services.images.get_pil_image(self.image2.image_name)
-
-        multiply_image = ImageChops.multiply(image1, image2)
-
-        image_dto = context.services.images.create(
-            image=multiply_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
+        context.services.images.save(image_type, image_name, image_mask, metadata)
+        return MaskOutput(mask=ImageField(image_type=image_type, image_name=image_name))
 
 
-IMAGE_CHANNELS = Literal["A", "R", "G", "B"]
-
-
-class ImageChannelInvocation(BaseInvocation, PILInvocationConfig):
-    """Gets a channel from an image."""
-
-    # fmt: off
-    type: Literal["img_chan"] = "img_chan"
-
-    # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to get the channel from")
-    channel: IMAGE_CHANNELS  = Field(default="A", description="The channel to get")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        channel_image = image.getchannel(self.channel)
-
-        image_dto = context.services.images.create(
-            image=channel_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-IMAGE_MODES = Literal["L", "RGB", "RGBA", "CMYK", "YCbCr", "LAB", "HSV", "I", "F"]
-
-
-class ImageConvertInvocation(BaseInvocation, PILInvocationConfig):
-    """Converts an image to a different mode."""
-
-    # fmt: off
-    type: Literal["img_conv"] = "img_conv"
-
-    # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to convert")
-    mode: IMAGE_MODES  = Field(default="L", description="The mode to convert to")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        converted_image = image.convert(self.mode)
-
-        image_dto = context.services.images.create(
-            image=converted_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-class ImageBlurInvocation(BaseInvocation, PILInvocationConfig):
+class BlurInvocation(BaseInvocation, PILInvocationConfig):
     """Blurs an image"""
 
     # fmt: off
-    type: Literal["img_blur"] = "img_blur"
+    type: Literal["blur"] = "blur"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to blur")
+    image: ImageField = Field(default=None, description="The image to blur")
     radius:     float = Field(default=8.0, ge=0, description="The blur radius")
     blur_type: Literal["gaussian", "box"] = Field(default="gaussian", description="The type of blur")
     # fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
 
         blur = (
             ImageFilter.GaussianBlur(self.radius)
@@ -355,171 +275,74 @@ class ImageBlurInvocation(BaseInvocation, PILInvocationConfig):
         )
         blur_image = image.filter(blur)
 
-        image_dto = context.services.images.create(
-            image=blur_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
+        )
+
+        context.services.images.save(image_type, image_name, blur_image, metadata)
+        return build_image_output(
+            image_type=image_type, image_name=image_name, image=blur_image
         )
 
 
-PIL_RESAMPLING_MODES = Literal[
-    "nearest",
-    "box",
-    "bilinear",
-    "hamming",
-    "bicubic",
-    "lanczos",
-]
-
-
-PIL_RESAMPLING_MAP = {
-    "nearest": Image.Resampling.NEAREST,
-    "box": Image.Resampling.BOX,
-    "bilinear": Image.Resampling.BILINEAR,
-    "hamming": Image.Resampling.HAMMING,
-    "bicubic": Image.Resampling.BICUBIC,
-    "lanczos": Image.Resampling.LANCZOS,
-}
-
-
-class ImageResizeInvocation(BaseInvocation, PILInvocationConfig):
-    """Resizes an image to specific dimensions"""
-
-    # fmt: off
-    type: Literal["img_resize"] = "img_resize"
-
-    # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to resize")
-    width:                         int = Field(ge=64, multiple_of=8, description="The width to resize to (px)")
-    height:                        int = Field(ge=64, multiple_of=8, description="The height to resize to (px)")
-    resample_mode:  PIL_RESAMPLING_MODES = Field(default="bicubic", description="The resampling mode")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        resample_mode = PIL_RESAMPLING_MAP[self.resample_mode]
-
-        resize_image = image.resize(
-            (self.width, self.height),
-            resample=resample_mode,
-        )
-
-        image_dto = context.services.images.create(
-            image=resize_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-class ImageScaleInvocation(BaseInvocation, PILInvocationConfig):
-    """Scales an image by a factor"""
-
-    # fmt: off
-    type: Literal["img_scale"] = "img_scale"
-
-    # Inputs
-    image:       Union[ImageField, None] = Field(default=None, description="The image to scale")
-    scale_factor:                  float = Field(gt=0, description="The factor by which to scale the image")
-    resample_mode:  PIL_RESAMPLING_MODES = Field(default="bicubic", description="The resampling mode")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        resample_mode = PIL_RESAMPLING_MAP[self.resample_mode]
-        width = int(image.width * self.scale_factor)
-        height = int(image.height * self.scale_factor)
-
-        resize_image = image.resize(
-            (width, height),
-            resample=resample_mode,
-        )
-
-        image_dto = context.services.images.create(
-            image=resize_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-class ImageLerpInvocation(BaseInvocation, PILInvocationConfig):
+class LerpInvocation(BaseInvocation, PILInvocationConfig):
     """Linear interpolation of all pixels of an image"""
 
     # fmt: off
-    type: Literal["img_lerp"] = "img_lerp"
+    type: Literal["lerp"] = "lerp"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to lerp")
+    image: ImageField = Field(default=None, description="The image to lerp")
     min: int = Field(default=0, ge=0, le=255, description="The minimum output value")
     max: int = Field(default=255, ge=0, le=255, description="The maximum output value")
     # fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
 
         image_arr = numpy.asarray(image, dtype=numpy.float32) / 255
         image_arr = image_arr * (self.max - self.min) + self.max
 
         lerp_image = Image.fromarray(numpy.uint8(image_arr))
 
-        image_dto = context.services.images.create(
-            image=lerp_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
+        )
+
+        context.services.images.save(image_type, image_name, lerp_image, metadata)
+        return build_image_output(
+            image_type=image_type, image_name=image_name, image=lerp_image
         )
 
 
-class ImageInverseLerpInvocation(BaseInvocation, PILInvocationConfig):
+class InverseLerpInvocation(BaseInvocation, PILInvocationConfig):
     """Inverse linear interpolation of all pixels of an image"""
 
     # fmt: off
-    type: Literal["img_ilerp"] = "img_ilerp"
+    type: Literal["ilerp"] = "ilerp"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to lerp")
+    image: ImageField = Field(default=None, description="The image to lerp")
     min: int = Field(default=0, ge=0, le=255, description="The minimum input value")
     max: int = Field(default=255, ge=0, le=255, description="The maximum input value")
     # fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
 
         image_arr = numpy.asarray(image, dtype=numpy.float32)
         image_arr = (
@@ -531,17 +354,16 @@ class ImageInverseLerpInvocation(BaseInvocation, PILInvocationConfig):
 
         ilerp_image = Image.fromarray(numpy.uint8(image_arr))
 
-        image_dto = context.services.images.create(
-            image=ilerp_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
+        )
+
+        context.services.images.save(image_type, image_name, ilerp_image, metadata)
+        return build_image_output(
+            image_type=image_type, image_name=image_name, image=ilerp_image
         )

invokeai/app/invocations/infill.py

@@ -1,230 +0,0 @@
-# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654) and the InvokeAI Team
-
-from typing import Literal, Union, get_args
-
-import numpy as np
-import math
-from PIL import Image, ImageOps
-from pydantic import Field
-
-from invokeai.app.invocations.image import ImageOutput
-from invokeai.app.util.misc import SEED_MAX, get_random_seed
-from invokeai.backend.image_util.patchmatch import PatchMatch
-
-from ..models.image import ColorField, ImageCategory, ImageField, ResourceOrigin
-from .baseinvocation import (
-    BaseInvocation,
-    InvocationContext,
-)
-
-
-def infill_methods() -> list[str]:
-    methods = [
-        "tile",
-        "solid",
-    ]
-    if PatchMatch.patchmatch_available():
-        methods.insert(0, "patchmatch")
-    return methods
-
-
-INFILL_METHODS = Literal[tuple(infill_methods())]
-DEFAULT_INFILL_METHOD = (
-    "patchmatch" if "patchmatch" in get_args(INFILL_METHODS) else "tile"
-)
-
-
-def infill_patchmatch(im: Image.Image) -> Image.Image:
-    if im.mode != "RGBA":
-        return im
-
-    # Skip patchmatch if patchmatch isn't available
-    if not PatchMatch.patchmatch_available():
-        return im
-
-    # Patchmatch (note, we may want to expose patch_size? Increasing it significantly impacts performance though)
-    im_patched_np = PatchMatch.inpaint(
-        im.convert("RGB"), ImageOps.invert(im.split()[-1]), patch_size=3
-    )
-    im_patched = Image.fromarray(im_patched_np, mode="RGB")
-    return im_patched
-
-
-def get_tile_images(image: np.ndarray, width=8, height=8):
-    _nrows, _ncols, depth = image.shape
-    _strides = image.strides
-
-    nrows, _m = divmod(_nrows, height)
-    ncols, _n = divmod(_ncols, width)
-    if _m != 0 or _n != 0:
-        return None
-
-    return np.lib.stride_tricks.as_strided(
-        np.ravel(image),
-        shape=(nrows, ncols, height, width, depth),
-        strides=(height * _strides[0], width * _strides[1], *_strides),
-        writeable=False,
-    )
-
-
-def tile_fill_missing(
-    im: Image.Image, tile_size: int = 16, seed: Union[int, None] = None
-) -> Image.Image:
-    # Only fill if there's an alpha layer
-    if im.mode != "RGBA":
-        return im
-
-    a = np.asarray(im, dtype=np.uint8)
-
-    tile_size_tuple = (tile_size, tile_size)
-
-    # Get the image as tiles of a specified size
-    tiles = get_tile_images(a, *tile_size_tuple).copy()
-
-    # Get the mask as tiles
-    tiles_mask = tiles[:, :, :, :, 3]
-
-    # Find any mask tiles with any fully transparent pixels (we will be replacing these later)
-    tmask_shape = tiles_mask.shape
-    tiles_mask = tiles_mask.reshape(math.prod(tiles_mask.shape))
-    n, ny = (math.prod(tmask_shape[0:2])), math.prod(tmask_shape[2:])
-    tiles_mask = tiles_mask > 0
-    tiles_mask = tiles_mask.reshape((n, ny)).all(axis=1)
-
-    # Get RGB tiles in single array and filter by the mask
-    tshape = tiles.shape
-    tiles_all = tiles.reshape((math.prod(tiles.shape[0:2]), *tiles.shape[2:]))
-    filtered_tiles = tiles_all[tiles_mask]
-
-    if len(filtered_tiles) == 0:
-        return im
-
-    # Find all invalid tiles and replace with a random valid tile
-    replace_count = (tiles_mask == False).sum()
-    rng = np.random.default_rng(seed=seed)
-    tiles_all[np.logical_not(tiles_mask)] = filtered_tiles[
-        rng.choice(filtered_tiles.shape[0], replace_count), :, :, :
-    ]
-
-    # Convert back to an image
-    tiles_all = tiles_all.reshape(tshape)
-    tiles_all = tiles_all.swapaxes(1, 2)
-    st = tiles_all.reshape(
-        (
-            math.prod(tiles_all.shape[0:2]),
-            math.prod(tiles_all.shape[2:4]),
-            tiles_all.shape[4],
-        )
-    )
-    si = Image.fromarray(st, mode="RGBA")
-
-    return si
-
-
-class InfillColorInvocation(BaseInvocation):
-    """Infills transparent areas of an image with a solid color"""
-
-    type: Literal["infill_rgba"] = "infill_rgba"
-    image: Union[ImageField, None] = Field(
-        default=None, description="The image to infill"
-    )
-    color: ColorField = Field(
-        default=ColorField(r=127, g=127, b=127, a=255),
-        description="The color to use to infill",
-    )
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        solid_bg = Image.new("RGBA", image.size, self.color.tuple())
-        infilled = Image.alpha_composite(solid_bg, image.convert("RGBA"))
-
-        infilled.paste(image, (0, 0), image.split()[-1])
-
-        image_dto = context.services.images.create(
-            image=infilled,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-class InfillTileInvocation(BaseInvocation):
-    """Infills transparent areas of an image with tiles of the image"""
-
-    type: Literal["infill_tile"] = "infill_tile"
-
-    image: Union[ImageField, None] = Field(
-        default=None, description="The image to infill"
-    )
-    tile_size: int = Field(default=32, ge=1, description="The tile size (px)")
-    seed: int = Field(
-        ge=0,
-        le=SEED_MAX,
-        description="The seed to use for tile generation (omit for random)",
-        default_factory=get_random_seed,
-    )
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        infilled = tile_fill_missing(
-            image.copy(), seed=self.seed, tile_size=self.tile_size
-        )
-        infilled.paste(image, (0, 0), image.split()[-1])
-
-        image_dto = context.services.images.create(
-            image=infilled,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-class InfillPatchMatchInvocation(BaseInvocation):
-    """Infills transparent areas of an image using the PatchMatch algorithm"""
-
-    type: Literal["infill_patchmatch"] = "infill_patchmatch"
-
-    image: Union[ImageField, None] = Field(
-        default=None, description="The image to infill"
-    )
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        if PatchMatch.patchmatch_available():
-            infilled = infill_patchmatch(image.copy())
-        else:
-            raise ValueError("PatchMatch is not available on this system")
-
-        image_dto = context.services.images.create(
-            image=infilled,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )

invokeai/app/invocations/latent.py

@@ -1,36 +1,30 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
 
-from contextlib import ExitStack
-from typing import List, Literal, Optional, Union
-
-import einops
-
-from pydantic import BaseModel, Field, validator
+import random
+from typing import Literal, Optional
+from pydantic import BaseModel, Field
 import torch
-from diffusers import ControlNetModel, DPMSolverMultistepScheduler
-from diffusers.image_processor import VaeImageProcessor
-from diffusers.schedulers import SchedulerMixin as Scheduler
 
-from invokeai.app.util.misc import SEED_MAX, get_random_seed
+from invokeai.app.invocations.util.choose_model import choose_model
+
 from invokeai.app.util.step_callback import stable_diffusion_step_callback
 
-from ..models.image import ImageCategory, ImageField, ResourceOrigin
-from ...backend.image_util.seamless import configure_model_padding
-from ...backend.stable_diffusion import PipelineIntermediateState
-from ...backend.stable_diffusion.diffusers_pipeline import (
-    ConditioningData, ControlNetData, StableDiffusionGeneratorPipeline,
-    image_resized_to_grid_as_tensor)
-from ...backend.stable_diffusion.diffusion.shared_invokeai_diffusion import \
-    PostprocessingSettings
-from ...backend.stable_diffusion.schedulers import SCHEDULER_MAP
+from ...backend.model_management.model_manager import ModelManager
 from ...backend.util.devices import choose_torch_device, torch_dtype
-from ...backend.model_management.lora import ModelPatcher
-from .baseinvocation import (BaseInvocation, BaseInvocationOutput,
-                             InvocationConfig, InvocationContext)
-from .compel import ConditioningField
-from .controlnet_image_processors import ControlField
-from .image import ImageOutput
-from .model import ModelInfo, UNetField, VaeField
+from ...backend.stable_diffusion.diffusion.shared_invokeai_diffusion import PostprocessingSettings
+from ...backend.image_util.seamless import configure_model_padding
+from ...backend.prompting.conditioning import get_uc_and_c_and_ec
+from ...backend.stable_diffusion.diffusers_pipeline import ConditioningData, StableDiffusionGeneratorPipeline
+from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext, InvocationConfig
+import numpy as np
+from ..services.image_storage import ImageType
+from .baseinvocation import BaseInvocation, InvocationContext
+from .image import ImageField, ImageOutput, build_image_output
+from ...backend.stable_diffusion import PipelineIntermediateState
+from diffusers.schedulers import SchedulerMixin as Scheduler
+import diffusers
+from diffusers import DiffusionPipeline
+
 
 class LatentsField(BaseModel):
     """A latents field used for passing latents between invocations"""
@@ -43,62 +37,41 @@ class LatentsField(BaseModel):
 class LatentsOutput(BaseInvocationOutput):
     """Base class for invocations that output latents"""
     #fmt: off
-    type: Literal["latents_output"] = "latents_output"
-
-    # Inputs
-    latents: LatentsField          = Field(default=None, description="The output latents")
-    width:                     int = Field(description="The width of the latents in pixels")
-    height:                    int = Field(description="The height of the latents in pixels")
+    type: Literal["latent_output"] = "latent_output"
+    latents: LatentsField            = Field(default=None, description="The output latents")
     #fmt: on
 
-
-def build_latents_output(latents_name: str, latents: torch.Tensor):
-      return LatentsOutput(
-          latents=LatentsField(latents_name=latents_name),
-          width=latents.size()[3] * 8,
-          height=latents.size()[2] * 8,
-      )
-
 class NoiseOutput(BaseInvocationOutput):
     """Invocation noise output"""
     #fmt: off
-    type:  Literal["noise_output"] = "noise_output"
-
-    # Inputs
+    type: Literal["noise_output"] = "noise_output"
     noise: LatentsField            = Field(default=None, description="The output noise")
-    width:                     int = Field(description="The width of the noise in pixels")
-    height:                    int = Field(description="The height of the noise in pixels")
     #fmt: on
 
-def build_noise_output(latents_name: str, latents: torch.Tensor):
-      return NoiseOutput(
-          noise=LatentsField(latents_name=latents_name),
-          width=latents.size()[3] * 8,
-          height=latents.size()[2] * 8,
-      )
+
+# TODO: this seems like a hack
+scheduler_map = dict(
+    ddim=diffusers.DDIMScheduler,
+    dpmpp_2=diffusers.DPMSolverMultistepScheduler,
+    k_dpm_2=diffusers.KDPM2DiscreteScheduler,
+    k_dpm_2_a=diffusers.KDPM2AncestralDiscreteScheduler,
+    k_dpmpp_2=diffusers.DPMSolverMultistepScheduler,
+    k_euler=diffusers.EulerDiscreteScheduler,
+    k_euler_a=diffusers.EulerAncestralDiscreteScheduler,
+    k_heun=diffusers.HeunDiscreteScheduler,
+    k_lms=diffusers.LMSDiscreteScheduler,
+    plms=diffusers.PNDMScheduler,
+)
 
 
 SAMPLER_NAME_VALUES = Literal[
-    tuple(list(SCHEDULER_MAP.keys()))
+    tuple(list(scheduler_map.keys()))
 ]
 
 
-
-def get_scheduler(
-    context: InvocationContext,
-    scheduler_info: ModelInfo,
-    scheduler_name: str,
-) -> Scheduler:
-    scheduler_class, scheduler_extra_config = SCHEDULER_MAP.get(scheduler_name, SCHEDULER_MAP['ddim'])
-    orig_scheduler_info = context.services.model_manager.get_model(**scheduler_info.dict())
-    with orig_scheduler_info as orig_scheduler:
-        scheduler_config = orig_scheduler.config
-        
-    if "_backup" in scheduler_config:
-        scheduler_config = scheduler_config["_backup"]
-    scheduler_config = {**scheduler_config, **scheduler_extra_config, "_backup": scheduler_config}
-    scheduler = scheduler_class.from_config(scheduler_config)
-    
+def get_scheduler(scheduler_name:str, model: StableDiffusionGeneratorPipeline)->Scheduler:
+    scheduler_class = scheduler_map.get(scheduler_name,'ddim')
+    scheduler = scheduler_class.from_config(model.scheduler.config)
     # hack copied over from generate.py
     if not hasattr(scheduler, 'uses_inpainting_model'):
         scheduler.uses_inpainting_model = lambda: False
@@ -128,15 +101,20 @@ def get_noise(width:int, height:int, device:torch.device, seed:int = 0, latent_c
     #     x = (1 - self.perlin) * x + self.perlin * perlin_noise
     return x
 
+
+def random_seed():
+    return random.randint(0, np.iinfo(np.uint32).max)
+
+
 class NoiseInvocation(BaseInvocation):
     """Generates latent noise."""
 
     type: Literal["noise"] = "noise"
 
     # Inputs
-    seed:       int = Field(ge=0, le=SEED_MAX, description="The seed to use", default_factory=get_random_seed)
-    width:       int = Field(default=512, multiple_of=8, gt=0, description="The width of the resulting noise", )
-    height:      int = Field(default=512, multiple_of=8, gt=0, description="The height of the resulting noise", )
+    seed:        int = Field(ge=0, le=np.iinfo(np.uint32).max, description="The seed to use", default_factory=random_seed)
+    width:       int = Field(default=512, multiple_of=64, gt=0, description="The width of the resulting noise", )
+    height:      int = Field(default=512, multiple_of=64, gt=0, description="The height of the resulting noise", )
 
 
     # Schema customisation
@@ -147,62 +125,47 @@ class NoiseInvocation(BaseInvocation):
             },
         }
 
-    @validator("seed", pre=True)
-    def modulo_seed(cls, v):
-        """Returns the seed modulo SEED_MAX to ensure it is within the valid range."""
-        return v % SEED_MAX
-
     def invoke(self, context: InvocationContext) -> NoiseOutput:
         device = torch.device(choose_torch_device())
         noise = get_noise(self.width, self.height, device, self.seed)
 
         name = f'{context.graph_execution_state_id}__{self.id}'
-        context.services.latents.save(name, noise)
-        return build_noise_output(latents_name=name, latents=noise)
+        context.services.latents.set(name, noise)
+        return NoiseOutput(
+            noise=LatentsField(latents_name=name)
+        )
 
 
 # Text to image
 class TextToLatentsInvocation(BaseInvocation):
-    """Generates latents from conditionings."""
+    """Generates latents from a prompt."""
 
     type: Literal["t2l"] = "t2l"
 
     # Inputs
+    # TODO: consider making prompt optional to enable providing prompt through a link
     # fmt: off
-    positive_conditioning: Optional[ConditioningField] = Field(description="Positive conditioning for generation")
-    negative_conditioning: Optional[ConditioningField] = Field(description="Negative conditioning for generation")
+    prompt: Optional[str] = Field(description="The prompt to generate an image from")
+    seed:        int = Field(default=-1,ge=-1, le=np.iinfo(np.uint32).max, description="The seed to use (-1 for a random seed)", )
     noise: Optional[LatentsField] = Field(description="The noise to use")
     steps:       int = Field(default=10, gt=0, description="The number of steps to use to generate the image")
-    cfg_scale: Union[float, List[float]] = Field(default=7.5, ge=1, description="The Classifier-Free Guidance, higher values may result in a result closer to the prompt", )
-    scheduler: SAMPLER_NAME_VALUES = Field(default="euler", description="The scheduler to use" )
-    unet: UNetField = Field(default=None, description="UNet submodel")
-    control: Union[ControlField, list[ControlField]] = Field(default=None, description="The control to use")
-    #seamless:   bool = Field(default=False, description="Whether or not to generate an image that can tile without seams", )
-    #seamless_axes: str = Field(default="", description="The axes to tile the image on, 'x' and/or 'y'")
+    width:       int = Field(default=512, multiple_of=64, gt=0, description="The width of the resulting image", )
+    height:      int = Field(default=512, multiple_of=64, gt=0, description="The height of the resulting image", )
+    cfg_scale: float = Field(default=7.5, gt=0, description="The Classifier-Free Guidance, higher values may result in a result closer to the prompt", )
+    scheduler: SAMPLER_NAME_VALUES = Field(default="k_lms", description="The scheduler to use" )
+    seamless:   bool = Field(default=False, description="Whether or not to generate an image that can tile without seams", )
+    seamless_axes: str = Field(default="", description="The axes to tile the image on, 'x' and/or 'y'")
+    model:       str = Field(default="", description="The model to use (currently ignored)")
+    progress_images: bool = Field(default=False, description="Whether or not to produce progress images during generation",  )
     # fmt: on
 
-    @validator("cfg_scale")
-    def ge_one(cls, v):
-        """validate that all cfg_scale values are >= 1"""
-        if isinstance(v, list):
-            for i in v:
-                if i < 1:
-                    raise ValueError('cfg_scale must be greater than 1')
-        else:
-            if v < 1:
-                raise ValueError('cfg_scale must be greater than 1')
-        return v
-
     # Schema customisation
     class Config(InvocationConfig):
         schema_extra = {
             "ui": {
-                "tags": ["latents"],
+                "tags": ["latents", "image"],
                 "type_hints": {
-                  "model": "model",
-                  "control": "control",
-                  # "cfg_scale": "float",
-                  "cfg_scale": "number"
+                  "model": "model"
                 }
             },
         }
@@ -218,136 +181,47 @@ class TextToLatentsInvocation(BaseInvocation):
             source_node_id=source_node_id,
         )
 
-    def get_conditioning_data(self, context: InvocationContext, scheduler) -> ConditioningData:
-        c, extra_conditioning_info = context.services.latents.get(self.positive_conditioning.conditioning_name)
-        uc, _ = context.services.latents.get(self.negative_conditioning.conditioning_name)
+    def get_model(self, model_manager: ModelManager) -> StableDiffusionGeneratorPipeline:
+        model_info = choose_model(model_manager, self.model)
+        model_name = model_info['model_name']
+        model_hash = model_info['hash']
+        model: StableDiffusionGeneratorPipeline = model_info['model']
+        model.scheduler = get_scheduler(
+            model=model,
+            scheduler_name=self.scheduler
+        )
 
+        if isinstance(model, DiffusionPipeline):
+            for component in [model.unet, model.vae]:
+                configure_model_padding(component,
+                                        self.seamless,
+                                        self.seamless_axes
+                                        )
+        else:
+            configure_model_padding(model,
+                                    self.seamless,
+                                    self.seamless_axes
+                                    )
+
+        return model
+
+
+    def get_conditioning_data(self, model: StableDiffusionGeneratorPipeline) -> ConditioningData:
+        uc, c, extra_conditioning_info = get_uc_and_c_and_ec(self.prompt, model=model)
         conditioning_data = ConditioningData(
-            unconditioned_embeddings=uc,
-            text_embeddings=c,
-            guidance_scale=self.cfg_scale,
-            extra=extra_conditioning_info,
+            uc,
+            c,
+            self.cfg_scale,
+            extra_conditioning_info,
             postprocessing_settings=PostprocessingSettings(
                 threshold=0.0,#threshold,
                 warmup=0.2,#warmup,
                 h_symmetry_time_pct=None,#h_symmetry_time_pct,
                 v_symmetry_time_pct=None#v_symmetry_time_pct,
             ),
-        )
-
-        conditioning_data = conditioning_data.add_scheduler_args_if_applicable(
-            scheduler,
-
-            # for ddim scheduler
-            eta=0.0, #ddim_eta
-
-            # for ancestral and sde schedulers
-            generator=torch.Generator(device=uc.device).manual_seed(0),
-        )
+        ).add_scheduler_args_if_applicable(model.scheduler, eta=None)#ddim_eta)
         return conditioning_data
 
-    def create_pipeline(self, unet, scheduler) -> StableDiffusionGeneratorPipeline:
-        # TODO:
-        #configure_model_padding(
-        #    unet,
-        #    self.seamless,
-        #    self.seamless_axes,
-        #)
-
-        class FakeVae:
-            class FakeVaeConfig:
-                def __init__(self):
-                    self.block_out_channels = [0]
-            
-            def __init__(self):
-                self.config = FakeVae.FakeVaeConfig()
-
-        return StableDiffusionGeneratorPipeline(
-            vae=FakeVae(), # TODO: oh...
-            text_encoder=None,
-            tokenizer=None,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=None,
-            feature_extractor=None,
-            requires_safety_checker=False,
-            precision="float16" if unet.dtype == torch.float16 else "float32",
-        )
-    
-    def prep_control_data(
-        self,
-        context: InvocationContext,
-        model: StableDiffusionGeneratorPipeline, # really only need model for dtype and device
-        control_input: List[ControlField],
-        latents_shape: List[int],
-        do_classifier_free_guidance: bool = True,
-    ) -> List[ControlNetData]:
-
-        # assuming fixed dimensional scaling of 8:1 for image:latents
-        control_height_resize = latents_shape[2] * 8
-        control_width_resize = latents_shape[3] * 8
-        if control_input is None:
-            control_list = None
-        elif isinstance(control_input, list) and len(control_input) == 0:
-            control_list = None
-        elif isinstance(control_input, ControlField):
-            control_list = [control_input]
-        elif isinstance(control_input, list) and len(control_input) > 0 and isinstance(control_input[0], ControlField):
-            control_list = control_input
-        else:
-            control_list = None
-        if (control_list is None):
-            control_data = None
-            # from above handling, any control that is not None should now be of type list[ControlField]
-        else:
-            # FIXME: add checks to skip entry if model or image is None
-            #        and if weight is None, populate with default 1.0?
-            control_data = []
-            control_models = []
-            for control_info in control_list:
-                # handle control models
-                if ("," in control_info.control_model):
-                    control_model_split = control_info.control_model.split(",")
-                    control_name = control_model_split[0]
-                    control_subfolder = control_model_split[1]
-                    print("Using HF model subfolders")
-                    print("    control_name: ", control_name)
-                    print("    control_subfolder: ", control_subfolder)
-                    control_model = ControlNetModel.from_pretrained(control_name,
-                                                                    subfolder=control_subfolder,
-                                                                    torch_dtype=model.unet.dtype).to(model.device)
-                else:
-                    control_model = ControlNetModel.from_pretrained(control_info.control_model,
-                                                                    torch_dtype=model.unet.dtype).to(model.device)
-                control_models.append(control_model)
-                control_image_field = control_info.image
-                input_image = context.services.images.get_pil_image(control_image_field.image_name)
-                # self.image.image_type, self.image.image_name
-                # FIXME: still need to test with different widths, heights, devices, dtypes
-                #        and add in batch_size, num_images_per_prompt?
-                #        and do real check for classifier_free_guidance?
-                # prepare_control_image should return torch.Tensor of shape(batch_size, 3, height, width)
-                control_image = model.prepare_control_image(
-                    image=input_image,
-                    do_classifier_free_guidance=do_classifier_free_guidance,
-                    width=control_width_resize,
-                    height=control_height_resize,
-                    # batch_size=batch_size * num_images_per_prompt,
-                    # num_images_per_prompt=num_images_per_prompt,
-                    device=control_model.device,
-                    dtype=control_model.dtype,
-                    control_mode=control_info.control_mode,
-                )
-                control_item = ControlNetData(model=control_model,
-                                              image_tensor=control_image,
-                                              weight=control_info.control_weight,
-                                              begin_step_percent=control_info.begin_step_percent,
-                                              end_step_percent=control_info.end_step_percent,
-                                              control_mode=control_info.control_mode,
-                                              )
-                control_data.append(control_item)
-                # MultiControlNetModel has been refactored out, just need list[ControlNetData]
-        return control_data
 
     def invoke(self, context: InvocationContext) -> LatentsOutput:
         noise = context.services.latents.get(self.noise.latents_name)
@@ -359,68 +233,49 @@ class TextToLatentsInvocation(BaseInvocation):
         def step_callback(state: PipelineIntermediateState):
             self.dispatch_progress(context, source_node_id, state)
 
-        unet_info = context.services.model_manager.get_model(**self.unet.unet.dict())
-        with unet_info as unet,\
-             ExitStack() as stack:
+        model = self.get_model(context.services.model_manager)
+        conditioning_data = self.get_conditioning_data(model)
 
-            scheduler = get_scheduler(
-                context=context,
-                scheduler_info=self.unet.scheduler,
-                scheduler_name=self.scheduler,
-            )
-            
-            pipeline = self.create_pipeline(unet, scheduler)
-            conditioning_data = self.get_conditioning_data(context, scheduler)
+        # TODO: Verify the noise is the right size
 
-            loras = [(stack.enter_context(context.services.model_manager.get_model(**lora.dict(exclude={"weight"}))), lora.weight) for lora in self.unet.loras]
-
-            control_data = self.prep_control_data(
-                model=pipeline, context=context, control_input=self.control,
-                latents_shape=noise.shape,
-                # do_classifier_free_guidance=(self.cfg_scale >= 1.0))
-                do_classifier_free_guidance=True,
-            )
-
-            with ModelPatcher.apply_lora_unet(pipeline.unet, loras):
-                # TODO: Verify the noise is the right size
-                result_latents, result_attention_map_saver = pipeline.latents_from_embeddings(
-                    latents=torch.zeros_like(noise, dtype=torch_dtype(unet.device)),
-                    noise=noise,
-                    num_inference_steps=self.steps,
-                    conditioning_data=conditioning_data,
-                    control_data=control_data, # list[ControlNetData]
-                    callback=step_callback,
-                )
+        result_latents, result_attention_map_saver = model.latents_from_embeddings(
+            latents=torch.zeros_like(noise, dtype=torch_dtype(model.device)),
+            noise=noise,
+            num_inference_steps=self.steps,
+            conditioning_data=conditioning_data,
+            callback=step_callback
+        )
 
         # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
         torch.cuda.empty_cache()
 
         name = f'{context.graph_execution_state_id}__{self.id}'
-        context.services.latents.save(name, result_latents)
-        return build_latents_output(latents_name=name, latents=result_latents)
+        context.services.latents.set(name, result_latents)
+        return LatentsOutput(
+            latents=LatentsField(latents_name=name)
+        )
+
 
 class LatentsToLatentsInvocation(TextToLatentsInvocation):
     """Generates latents using latents as base image."""
 
     type: Literal["l2l"] = "l2l"
 
-    # Inputs
-    latents: Optional[LatentsField] = Field(description="The latents to use as a base image")
-    strength: float = Field(default=0.7, ge=0, le=1, description="The strength of the latents to use")
-
     # Schema customisation
     class Config(InvocationConfig):
         schema_extra = {
             "ui": {
                 "tags": ["latents"],
                 "type_hints": {
-                    "model": "model",
-                    "control": "control",
-                    "cfg_scale": "number",
+                    "model": "model"
                 }
             },
         }
 
+    # Inputs
+    latents: Optional[LatentsField] = Field(description="The latents to use as a base image")
+    strength: float = Field(default=0.5, description="The strength of the latents to use")
+
     def invoke(self, context: InvocationContext) -> LatentsOutput:
         noise = context.services.latents.get(self.noise.latents_name)
         latent = context.services.latents.get(self.latents.latents_name)
@@ -432,59 +287,38 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
         def step_callback(state: PipelineIntermediateState):
             self.dispatch_progress(context, source_node_id, state)
 
-        unet_info = context.services.model_manager.get_model(
-            **self.unet.unet.dict(),
+        model = self.get_model(context.services.model_manager)
+        conditioning_data = self.get_conditioning_data(model)
+
+        # TODO: Verify the noise is the right size
+
+        initial_latents = latent if self.strength < 1.0 else torch.zeros_like(
+            latent, device=model.device, dtype=latent.dtype
         )
 
-        with unet_info as unet,\
-             ExitStack() as stack:
+        timesteps, _ = model.get_img2img_timesteps(
+            self.steps,
+            self.strength,
+            device=model.device,
+        )
 
-            scheduler = get_scheduler(
-                context=context,
-                scheduler_info=self.unet.scheduler,
-                scheduler_name=self.scheduler,
-            )
-
-            pipeline = self.create_pipeline(unet, scheduler)
-            conditioning_data = self.get_conditioning_data(context, scheduler)
-            
-            control_data = self.prep_control_data(
-                model=pipeline, context=context, control_input=self.control,
-                latents_shape=noise.shape,
-                # do_classifier_free_guidance=(self.cfg_scale >= 1.0))
-                do_classifier_free_guidance=True,
-            )
-
-            # TODO: Verify the noise is the right size
-            initial_latents = latent if self.strength < 1.0 else torch.zeros_like(
-                latent, device=unet.device, dtype=latent.dtype
-            )
-
-            timesteps, _ = pipeline.get_img2img_timesteps(
-                self.steps,
-                self.strength,
-                device=unet.device,
-            )
-
-            loras = [(stack.enter_context(context.services.model_manager.get_model(**lora.dict(exclude={"weight"}))), lora.weight) for lora in self.unet.loras]
-
-            with ModelPatcher.apply_lora_unet(pipeline.unet, loras):
-                result_latents, result_attention_map_saver = pipeline.latents_from_embeddings(
-                    latents=initial_latents,
-                    timesteps=timesteps,
-                    noise=noise,
-                    num_inference_steps=self.steps,
-                    conditioning_data=conditioning_data,
-                    control_data=control_data,  # list[ControlNetData]
-                    callback=step_callback
-                )
+        result_latents, result_attention_map_saver = model.latents_from_embeddings(
+            latents=initial_latents,
+            timesteps=timesteps,
+            noise=noise,
+            num_inference_steps=self.steps,
+            conditioning_data=conditioning_data,
+            callback=step_callback
+        )
 
         # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
         torch.cuda.empty_cache()
 
         name = f'{context.graph_execution_state_id}__{self.id}'
-        context.services.latents.save(name, result_latents)
-        return build_latents_output(latents_name=name, latents=result_latents)
+        context.services.latents.set(name, result_latents)
+        return LatentsOutput(
+            latents=LatentsField(latents_name=name)
+        )
 
 
 # Latent to image
@@ -495,14 +329,16 @@ class LatentsToImageInvocation(BaseInvocation):
 
     # Inputs
     latents: Optional[LatentsField] = Field(description="The latents to generate an image from")
-    vae: VaeField = Field(default=None, description="Vae submodel")
-    tiled: bool = Field(default=False, description="Decode latents by overlaping tiles(less memory consumption)")
+    model: str = Field(default="", description="The model to use")
 
     # Schema customisation
     class Config(InvocationConfig):
         schema_extra = {
             "ui": {
                 "tags": ["latents", "image"],
+                "type_hints": {
+                  "model": "model"
+                }
             },
         }
 
@@ -510,164 +346,26 @@ class LatentsToImageInvocation(BaseInvocation):
     def invoke(self, context: InvocationContext) -> ImageOutput:
         latents = context.services.latents.get(self.latents.latents_name)
 
-        vae_info = context.services.model_manager.get_model(
-            **self.vae.vae.dict(),
-        )
+        # TODO: this only really needs the vae
+        model_info = choose_model(context.services.model_manager, self.model)
+        model: StableDiffusionGeneratorPipeline = model_info['model']
 
-        with vae_info as vae:
-            if self.tiled or context.services.configuration.tiled_decode:
-                vae.enable_tiling()
-            else:
-                vae.disable_tiling()
+        with torch.inference_mode():
+            np_image = model.decode_latents(latents)
+            image = model.numpy_to_pil(np_image)[0]
 
-            # clear memory as vae decode can request a lot
-            torch.cuda.empty_cache()
+            image_type = ImageType.RESULT
+            image_name = context.services.images.create_name(
+                context.graph_execution_state_id, self.id
+            )
 
-            with torch.inference_mode():
-                # copied from diffusers pipeline
-                latents = latents / vae.config.scaling_factor
-                image = vae.decode(latents, return_dict=False)[0]
-                image = (image / 2 + 0.5).clamp(0, 1) # denormalize
-                # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
-                np_image = image.cpu().permute(0, 2, 3, 1).float().numpy()
+            metadata = context.services.metadata.build_metadata(
+                session_id=context.graph_execution_state_id, node=self
+            )
 
-                image = VaeImageProcessor.numpy_to_pil(np_image)[0]
-
-        torch.cuda.empty_cache()
-
-        image_dto = context.services.images.create(
-            image=image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-LATENTS_INTERPOLATION_MODE = Literal[
-    "nearest", "linear", "bilinear", "bicubic", "trilinear", "area", "nearest-exact"
-]
-
-
-class ResizeLatentsInvocation(BaseInvocation):
-    """Resizes latents to explicit width/height (in pixels). Provided dimensions are floor-divided by 8."""
-
-    type: Literal["lresize"] = "lresize"
-
-    # Inputs
-    latents:    Optional[LatentsField] = Field(description="The latents to resize")
-    width:                         int = Field(ge=64, multiple_of=8, description="The width to resize to (px)")
-    height:                        int = Field(ge=64, multiple_of=8, description="The height to resize to (px)")
-    mode:   LATENTS_INTERPOLATION_MODE = Field(default="bilinear", description="The interpolation mode")
-    antialias:                    bool = Field(default=False, description="Whether or not to antialias (applied in bilinear and bicubic modes only)")
-
-    def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = context.services.latents.get(self.latents.latents_name)
-
-        resized_latents = torch.nn.functional.interpolate(
-            latents,
-            size=(self.height // 8, self.width // 8),
-            mode=self.mode,
-            antialias=self.antialias if self.mode in ["bilinear", "bicubic"] else False,
-        )
-
-        # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
-        torch.cuda.empty_cache()
-
-        name = f"{context.graph_execution_state_id}__{self.id}"
-        # context.services.latents.set(name, resized_latents)
-        context.services.latents.save(name, resized_latents)
-        return build_latents_output(latents_name=name, latents=resized_latents)
-
-
-class ScaleLatentsInvocation(BaseInvocation):
-    """Scales latents by a given factor."""
-
-    type: Literal["lscale"] = "lscale"
-
-    # Inputs
-    latents:   Optional[LatentsField] = Field(description="The latents to scale")
-    scale_factor:               float = Field(gt=0, description="The factor by which to scale the latents")
-    mode:  LATENTS_INTERPOLATION_MODE = Field(default="bilinear", description="The interpolation mode")
-    antialias:                   bool = Field(default=False, description="Whether or not to antialias (applied in bilinear and bicubic modes only)")
-
-    def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = context.services.latents.get(self.latents.latents_name)
-
-        # resizing
-        resized_latents = torch.nn.functional.interpolate(
-            latents,
-            scale_factor=self.scale_factor,
-            mode=self.mode,
-            antialias=self.antialias if self.mode in ["bilinear", "bicubic"] else False,
-        )
-
-        # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
-        torch.cuda.empty_cache()
-
-        name = f"{context.graph_execution_state_id}__{self.id}"
-        # context.services.latents.set(name, resized_latents)
-        context.services.latents.save(name, resized_latents)
-        return build_latents_output(latents_name=name, latents=resized_latents)
-
-
-class ImageToLatentsInvocation(BaseInvocation):
-    """Encodes an image into latents."""
-
-    type: Literal["i2l"] = "i2l"
-
-    # Inputs
-    image: Union[ImageField, None] = Field(description="The image to encode")
-    vae: VaeField = Field(default=None, description="Vae submodel")
-    tiled: bool = Field(default=False, description="Encode latents by overlaping tiles(less memory consumption)")
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["latents", "image"],
-            },
-        }
-
-    @torch.no_grad()
-    def invoke(self, context: InvocationContext) -> LatentsOutput:
-        # image = context.services.images.get(
-        #     self.image.image_type, self.image.image_name
-        # )
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        #vae_info = context.services.model_manager.get_model(**self.vae.vae.dict())
-        vae_info = context.services.model_manager.get_model(
-            **self.vae.vae.dict(),
-        )
-
-        image_tensor = image_resized_to_grid_as_tensor(image.convert("RGB"))
-        if image_tensor.dim() == 3:
-            image_tensor = einops.rearrange(image_tensor, "c h w -> 1 c h w")
-
-        with vae_info as vae:
-            if self.tiled:
-                vae.enable_tiling()
-            else:
-                vae.disable_tiling()
-
-            # non_noised_latents_from_image
-            image_tensor = image_tensor.to(device=vae.device, dtype=vae.dtype)
-            with torch.inference_mode():
-                image_tensor_dist = vae.encode(image_tensor).latent_dist
-                latents = image_tensor_dist.sample().to(
-                    dtype=vae.dtype
-                )  # FIXME: uses torch.randn. make reproducible!
-
-            latents = 0.18215 * latents
-
-        name = f"{context.graph_execution_state_id}__{self.id}"
-        # context.services.latents.set(name, latents)
-        context.services.latents.save(name, latents)
-        return build_latents_output(latents_name=name, latents=latents)
+            context.services.images.save(image_type, image_name, image, metadata)
+            return build_image_output(
+                image_type=image_type,
+                image_name=image_name,
+                image=image
+            )

invokeai/app/invocations/math.py

@@ -3,14 +3,8 @@
 from typing import Literal
 
 from pydantic import BaseModel, Field
-import numpy as np
 
-from .baseinvocation import (
-    BaseInvocation,
-    BaseInvocationOutput,
-    InvocationContext,
-    InvocationConfig,
-)
+from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext, InvocationConfig
 
 
 class MathInvocationConfig(BaseModel):
@@ -27,30 +21,19 @@ class MathInvocationConfig(BaseModel):
 
 class IntOutput(BaseInvocationOutput):
     """An integer output"""
-
-    # fmt: off
+    #fmt: off
     type: Literal["int_output"] = "int_output"
     a: int = Field(default=None, description="The output integer")
-    # fmt: on
-
-
-class FloatOutput(BaseInvocationOutput):
-    """A float output"""
-
-    # fmt: off
-    type: Literal["float_output"] = "float_output"
-    param: float = Field(default=None, description="The output float")
-    # fmt: on
+    #fmt: on
 
 
 class AddInvocation(BaseInvocation, MathInvocationConfig):
     """Adds two numbers"""
-
-    # fmt: off
+    #fmt: off
     type: Literal["add"] = "add"
     a: int = Field(default=0, description="The first number")
     b: int = Field(default=0, description="The second number")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> IntOutput:
         return IntOutput(a=self.a + self.b)
@@ -58,12 +41,11 @@ class AddInvocation(BaseInvocation, MathInvocationConfig):
 
 class SubtractInvocation(BaseInvocation, MathInvocationConfig):
     """Subtracts two numbers"""
-
-    # fmt: off
+    #fmt: off
     type: Literal["sub"] = "sub"
     a: int = Field(default=0, description="The first number")
     b: int = Field(default=0, description="The second number")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> IntOutput:
         return IntOutput(a=self.a - self.b)
@@ -71,12 +53,11 @@ class SubtractInvocation(BaseInvocation, MathInvocationConfig):
 
 class MultiplyInvocation(BaseInvocation, MathInvocationConfig):
     """Multiplies two numbers"""
-
-    # fmt: off
+    #fmt: off
     type: Literal["mul"] = "mul"
     a: int = Field(default=0, description="The first number")
     b: int = Field(default=0, description="The second number")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> IntOutput:
         return IntOutput(a=self.a * self.b)
@@ -84,26 +65,11 @@ class MultiplyInvocation(BaseInvocation, MathInvocationConfig):
 
 class DivideInvocation(BaseInvocation, MathInvocationConfig):
     """Divides two numbers"""
-
-    # fmt: off
+    #fmt: off
     type: Literal["div"] = "div"
     a: int = Field(default=0, description="The first number")
     b: int = Field(default=0, description="The second number")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> IntOutput:
         return IntOutput(a=int(self.a / self.b))
-
-
-class RandomIntInvocation(BaseInvocation):
-    """Outputs a single random integer."""
-
-    # fmt: off
-    type: Literal["rand_int"] = "rand_int"
-    low: int = Field(default=0, description="The inclusive low value")
-    high: int = Field(
-        default=np.iinfo(np.int32).max, description="The exclusive high value"
-    )
-    # fmt: on
-    def invoke(self, context: InvocationContext) -> IntOutput:
-        return IntOutput(a=np.random.randint(self.low, self.high))

invokeai/app/invocations/model.py

@@ -1,217 +0,0 @@
-from typing import Literal, Optional, Union, List
-from pydantic import BaseModel, Field
-import copy
-
-from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext, InvocationConfig
-
-from ...backend.util.devices import choose_torch_device, torch_dtype
-from ...backend.model_management import BaseModelType, ModelType, SubModelType
-
-class ModelInfo(BaseModel):
-    model_name: str = Field(description="Info to load submodel")
-    base_model: BaseModelType = Field(description="Base model")
-    model_type: ModelType = Field(description="Info to load submodel")
-    submodel: Optional[SubModelType] = Field(description="Info to load submodel")
-
-class LoraInfo(ModelInfo):
-    weight: float = Field(description="Lora's weight which to use when apply to model")
-
-class UNetField(BaseModel):
-    unet: ModelInfo = Field(description="Info to load unet submodel")
-    scheduler: ModelInfo = Field(description="Info to load scheduler submodel")
-    loras: List[LoraInfo] = Field(description="Loras to apply on model loading")
-
-class ClipField(BaseModel):
-    tokenizer: ModelInfo = Field(description="Info to load tokenizer submodel")
-    text_encoder: ModelInfo = Field(description="Info to load text_encoder submodel")
-    loras: List[LoraInfo] = Field(description="Loras to apply on model loading")
-
-class VaeField(BaseModel):
-    # TODO: better naming?
-    vae: ModelInfo = Field(description="Info to load vae submodel")
-
-
-class ModelLoaderOutput(BaseInvocationOutput):
-    """Model loader output"""
-
-    #fmt: off
-    type: Literal["model_loader_output"] = "model_loader_output"
-
-    unet: UNetField = Field(default=None, description="UNet submodel")
-    clip: ClipField = Field(default=None, description="Tokenizer and text_encoder submodels")
-    vae: VaeField = Field(default=None, description="Vae submodel")
-    #fmt: on
-
-
-class PipelineModelField(BaseModel):
-    """Pipeline model field"""
-
-    model_name: str = Field(description="Name of the model")
-    base_model: BaseModelType = Field(description="Base model")
-
-
-class PipelineModelLoaderInvocation(BaseInvocation):
-    """Loads a pipeline model, outputting its submodels."""
-
-    type: Literal["pipeline_model_loader"] = "pipeline_model_loader"
-
-    model: PipelineModelField = Field(description="The model to load")
-    # TODO: precision?
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["model", "loader"],
-                "type_hints": {
-                  "model": "model"
-                }
-            },
-        }
-
-    def invoke(self, context: InvocationContext) -> ModelLoaderOutput:
-
-        base_model = self.model.base_model
-        model_name = self.model.model_name
-        model_type = ModelType.Pipeline
-
-        # TODO: not found exceptions
-        if not context.services.model_manager.model_exists(
-            model_name=model_name,
-            base_model=base_model,
-            model_type=model_type,
-        ):
-            raise Exception(f"Unknown {base_model} {model_type} model: {model_name}")
-
-        """
-        if not context.services.model_manager.model_exists(
-            model_name=self.model_name,
-            model_type=SDModelType.Diffusers,
-            submodel=SDModelType.Tokenizer,
-        ):
-            raise Exception(
-                f"Failed to find tokenizer submodel in {self.model_name}! Check if model corrupted"
-            )
-
-        if not context.services.model_manager.model_exists(
-            model_name=self.model_name,
-            model_type=SDModelType.Diffusers,
-            submodel=SDModelType.TextEncoder,
-        ):
-            raise Exception(
-                f"Failed to find text_encoder submodel in {self.model_name}! Check if model corrupted"
-            )
-
-        if not context.services.model_manager.model_exists(
-            model_name=self.model_name,
-            model_type=SDModelType.Diffusers,
-            submodel=SDModelType.UNet,
-        ):
-            raise Exception(
-                f"Failed to find unet submodel from {self.model_name}! Check if model corrupted"
-            )
-        """
-
-
-        return ModelLoaderOutput(
-            unet=UNetField(
-                unet=ModelInfo(
-                    model_name=model_name,
-                    base_model=base_model,
-                    model_type=model_type,
-                    submodel=SubModelType.UNet,
-                ),
-                scheduler=ModelInfo(
-                    model_name=model_name,
-                    base_model=base_model,
-                    model_type=model_type,
-                    submodel=SubModelType.Scheduler,
-                ),
-                loras=[],
-            ),
-            clip=ClipField(
-                tokenizer=ModelInfo(
-                    model_name=model_name,
-                    base_model=base_model,
-                    model_type=model_type,
-                    submodel=SubModelType.Tokenizer,
-                ),
-                text_encoder=ModelInfo(
-                    model_name=model_name,
-                    base_model=base_model,
-                    model_type=model_type,
-                    submodel=SubModelType.TextEncoder,
-                ),
-                loras=[],
-            ),
-            vae=VaeField(
-                vae=ModelInfo(
-                    model_name=model_name,
-                    base_model=base_model,
-                    model_type=model_type,
-                    submodel=SubModelType.Vae,
-                ),
-            )
-        )
-
-class LoraLoaderOutput(BaseInvocationOutput):
-    """Model loader output"""
-
-    #fmt: off
-    type: Literal["lora_loader_output"] = "lora_loader_output"
-
-    unet: Optional[UNetField] = Field(default=None, description="UNet submodel")
-    clip: Optional[ClipField] = Field(default=None, description="Tokenizer and text_encoder submodels")
-    #fmt: on
-
-class LoraLoaderInvocation(BaseInvocation):
-    """Apply selected lora to unet and text_encoder."""
-
-    type: Literal["lora_loader"] = "lora_loader"
-
-    lora_name: str = Field(description="Lora model name")
-    weight: float = Field(default=0.75, description="With what weight to apply lora")
-
-    unet: Optional[UNetField] = Field(description="UNet model for applying lora")
-    clip: Optional[ClipField] = Field(description="Clip model for applying lora")
-
-    def invoke(self, context: InvocationContext) -> LoraLoaderOutput:
-
-        if not context.services.model_manager.model_exists(
-            model_name=self.lora_name,
-            model_type=SDModelType.Lora,
-        ):
-            raise Exception(f"Unkown lora name: {self.lora_name}!")
-
-        if self.unet is not None and any(lora.model_name == self.lora_name for lora in self.unet.loras):
-            raise Exception(f"Lora \"{self.lora_name}\" already applied to unet")
-
-        if self.clip is not None and any(lora.model_name == self.lora_name for lora in self.clip.loras):
-            raise Exception(f"Lora \"{self.lora_name}\" already applied to clip")
-
-        output = LoraLoaderOutput()
-
-        if self.unet is not None:
-            output.unet = copy.deepcopy(self.unet)
-            output.unet.loras.append(
-                LoraInfo(
-                    model_name=self.lora_name,
-                    model_type=SDModelType.Lora,
-                    submodel=None,
-                    weight=self.weight,
-                )
-            )
-
-        if self.clip is not None:
-            output.clip = copy.deepcopy(self.clip)
-            output.clip.loras.append(
-                LoraInfo(
-                    model_name=self.lora_name,
-                    model_type=SDModelType.Lora,
-                    submodel=None,
-                    weight=self.weight,
-                )
-            )
-
-        return output
-

invokeai/app/invocations/param_easing.py

@@ -1,237 +0,0 @@
-import io
-from typing import Literal, Optional, Any
-
-# from PIL.Image import Image
-import PIL.Image
-from matplotlib.ticker import MaxNLocator
-from matplotlib.figure import Figure
-
-from pydantic import BaseModel, Field
-import numpy as np
-import matplotlib.pyplot as plt
-
-from easing_functions import (
-    LinearInOut,
-    QuadEaseInOut, QuadEaseIn, QuadEaseOut,
-    CubicEaseInOut, CubicEaseIn, CubicEaseOut,
-    QuarticEaseInOut, QuarticEaseIn, QuarticEaseOut,
-    QuinticEaseInOut, QuinticEaseIn, QuinticEaseOut,
-    SineEaseInOut, SineEaseIn, SineEaseOut,
-    CircularEaseIn, CircularEaseInOut, CircularEaseOut,
-    ExponentialEaseInOut, ExponentialEaseIn, ExponentialEaseOut,
-    ElasticEaseIn, ElasticEaseInOut, ElasticEaseOut,
-    BackEaseIn, BackEaseInOut, BackEaseOut,
-    BounceEaseIn, BounceEaseInOut, BounceEaseOut)
-
-from .baseinvocation import (
-    BaseInvocation,
-    BaseInvocationOutput,
-    InvocationContext,
-    InvocationConfig,
-)
-from ...backend.util.logging import InvokeAILogger
-from .collections import FloatCollectionOutput
-
-
-class FloatLinearRangeInvocation(BaseInvocation):
-    """Creates a range"""
-
-    type: Literal["float_range"] = "float_range"
-
-    # Inputs
-    start: float = Field(default=5, description="The first value of the range")
-    stop: float = Field(default=10, description="The last value of the range")
-    steps: int = Field(default=30, description="number of values to interpolate over (including start and stop)")
-
-    def invoke(self, context: InvocationContext) -> FloatCollectionOutput:
-        param_list = list(np.linspace(self.start, self.stop, self.steps))
-        return FloatCollectionOutput(
-            collection=param_list
-        )
-
-
-EASING_FUNCTIONS_MAP = {
-    "Linear": LinearInOut,
-    "QuadIn": QuadEaseIn,
-    "QuadOut": QuadEaseOut,
-    "QuadInOut": QuadEaseInOut,
-    "CubicIn": CubicEaseIn,
-    "CubicOut": CubicEaseOut,
-    "CubicInOut": CubicEaseInOut,
-    "QuarticIn": QuarticEaseIn,
-    "QuarticOut": QuarticEaseOut,
-    "QuarticInOut": QuarticEaseInOut,
-    "QuinticIn": QuinticEaseIn,
-    "QuinticOut": QuinticEaseOut,
-    "QuinticInOut": QuinticEaseInOut,
-    "SineIn": SineEaseIn,
-    "SineOut": SineEaseOut,
-    "SineInOut": SineEaseInOut,
-    "CircularIn": CircularEaseIn,
-    "CircularOut": CircularEaseOut,
-    "CircularInOut": CircularEaseInOut,
-    "ExponentialIn": ExponentialEaseIn,
-    "ExponentialOut": ExponentialEaseOut,
-    "ExponentialInOut": ExponentialEaseInOut,
-    "ElasticIn": ElasticEaseIn,
-    "ElasticOut": ElasticEaseOut,
-    "ElasticInOut": ElasticEaseInOut,
-    "BackIn": BackEaseIn,
-    "BackOut": BackEaseOut,
-    "BackInOut": BackEaseInOut,
-    "BounceIn": BounceEaseIn,
-    "BounceOut": BounceEaseOut,
-    "BounceInOut": BounceEaseInOut,
-}
-
-EASING_FUNCTION_KEYS: Any = Literal[
-    tuple(list(EASING_FUNCTIONS_MAP.keys()))
-]
-
-
-# actually I think for now could just use CollectionOutput (which is list[Any]
-class StepParamEasingInvocation(BaseInvocation):
-    """Experimental per-step parameter easing for denoising steps"""
-
-    type: Literal["step_param_easing"] = "step_param_easing"
-
-    # Inputs
-    # fmt: off
-    easing: EASING_FUNCTION_KEYS = Field(default="Linear", description="The easing function to use")
-    num_steps: int = Field(default=20, description="number of denoising steps")
-    start_value: float = Field(default=0.0, description="easing starting value")
-    end_value: float = Field(default=1.0, description="easing ending value")
-    start_step_percent: float = Field(default=0.0, description="fraction of steps at which to start easing")
-    end_step_percent: float = Field(default=1.0, description="fraction of steps after which to end easing")
-    # if None, then start_value is used prior to easing start
-    pre_start_value: Optional[float] = Field(default=None, description="value before easing start")
-    # if None, then end value is used prior to easing end
-    post_end_value: Optional[float] = Field(default=None, description="value after easing end")
-    mirror: bool = Field(default=False, description="include mirror of easing function")
-    # FIXME: add alt_mirror option (alternative to default or mirror), or remove entirely
-    # alt_mirror: bool = Field(default=False, description="alternative mirroring by dual easing")
-    show_easing_plot: bool = Field(default=False, description="show easing plot")
-    # fmt: on
-
-
-    def invoke(self, context: InvocationContext) -> FloatCollectionOutput:
-        log_diagnostics = False
-        # convert from start_step_percent to nearest step <= (steps * start_step_percent)
-        # start_step = int(np.floor(self.num_steps * self.start_step_percent))
-        start_step = int(np.round(self.num_steps * self.start_step_percent))
-        # convert from end_step_percent to nearest step >= (steps * end_step_percent)
-        # end_step = int(np.ceil((self.num_steps - 1) * self.end_step_percent))
-        end_step = int(np.round((self.num_steps - 1) * self.end_step_percent))
-
-        # end_step = int(np.ceil(self.num_steps * self.end_step_percent))
-        num_easing_steps = end_step - start_step + 1
-
-        # num_presteps = max(start_step - 1, 0)
-        num_presteps = start_step
-        num_poststeps = self.num_steps - (num_presteps + num_easing_steps)
-        prelist = list(num_presteps * [self.pre_start_value])
-        postlist = list(num_poststeps * [self.post_end_value])
-
-        if log_diagnostics:
-            logger = InvokeAILogger.getLogger(name="StepParamEasing")
-            logger.debug("start_step: " + str(start_step))
-            logger.debug("end_step: " + str(end_step))
-            logger.debug("num_easing_steps: " + str(num_easing_steps))
-            logger.debug("num_presteps: " + str(num_presteps))
-            logger.debug("num_poststeps: " + str(num_poststeps))
-            logger.debug("prelist size: " + str(len(prelist)))
-            logger.debug("postlist size: " + str(len(postlist)))
-            logger.debug("prelist: " + str(prelist))
-            logger.debug("postlist: " + str(postlist))
-
-        easing_class = EASING_FUNCTIONS_MAP[self.easing]
-        if log_diagnostics:
-            logger.debug("easing class: " + str(easing_class))
-        easing_list = list()
-        if self.mirror:  # "expected" mirroring
-            # if number of steps is even, squeeze duration down to (number_of_steps)/2
-            # and create reverse copy of list to append
-            # if number of steps is odd, squeeze duration down to ceil(number_of_steps/2)
-            # and create reverse copy of list[1:end-1]
-            # but if even then number_of_steps/2 === ceil(number_of_steps/2), so can just use ceil always
-
-            base_easing_duration = int(np.ceil(num_easing_steps/2.0))
-            if log_diagnostics: logger.debug("base easing duration: " + str(base_easing_duration))
-            even_num_steps = (num_easing_steps % 2 == 0)  # even number of steps
-            easing_function = easing_class(start=self.start_value,
-                                           end=self.end_value,
-                                           duration=base_easing_duration - 1)
-            base_easing_vals = list()
-            for step_index in range(base_easing_duration):
-                easing_val = easing_function.ease(step_index)
-                base_easing_vals.append(easing_val)
-                if log_diagnostics:
-                    logger.debug("step_index: " + str(step_index) + ", easing_val: " + str(easing_val))
-            if even_num_steps:
-                mirror_easing_vals = list(reversed(base_easing_vals))
-            else:
-                mirror_easing_vals = list(reversed(base_easing_vals[0:-1]))
-            if log_diagnostics:
-                logger.debug("base easing vals: " + str(base_easing_vals))
-                logger.debug("mirror easing vals: " + str(mirror_easing_vals))
-            easing_list = base_easing_vals + mirror_easing_vals
-
-        # FIXME: add alt_mirror option (alternative to default or mirror), or remove entirely
-        # elif self.alt_mirror:  # function mirroring (unintuitive behavior (at least to me))
-        #     # half_ease_duration = round(num_easing_steps - 1 / 2)
-        #     half_ease_duration = round((num_easing_steps - 1) / 2)
-        #     easing_function = easing_class(start=self.start_value,
-        #                                    end=self.end_value,
-        #                                    duration=half_ease_duration,
-        #                                    )
-        #
-        #     mirror_function = easing_class(start=self.end_value,
-        #                                    end=self.start_value,
-        #                                    duration=half_ease_duration,
-        #                                    )
-        #     for step_index in range(num_easing_steps):
-        #         if step_index <= half_ease_duration:
-        #             step_val = easing_function.ease(step_index)
-        #         else:
-        #             step_val = mirror_function.ease(step_index - half_ease_duration)
-        #         easing_list.append(step_val)
-        #         if log_diagnostics: logger.debug(step_index, step_val)
-        #
-
-        else:  # no mirroring (default)
-            easing_function = easing_class(start=self.start_value,
-                                           end=self.end_value,
-                                           duration=num_easing_steps - 1)
-            for step_index in range(num_easing_steps):
-                step_val = easing_function.ease(step_index)
-                easing_list.append(step_val)
-                if log_diagnostics:
-                    logger.debug("step_index: " + str(step_index) + ", easing_val: " + str(step_val))
-
-        if log_diagnostics:
-            logger.debug("prelist size: " + str(len(prelist)))
-            logger.debug("easing_list size: " + str(len(easing_list)))
-            logger.debug("postlist size: " + str(len(postlist)))
-
-        param_list = prelist + easing_list + postlist
-
-        if self.show_easing_plot:
-            plt.figure()
-            plt.xlabel("Step")
-            plt.ylabel("Param Value")
-            plt.title("Per-Step Values Based On Easing: " + self.easing)
-            plt.bar(range(len(param_list)), param_list)
-            # plt.plot(param_list)
-            ax = plt.gca()
-            ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-            buf = io.BytesIO()
-            plt.savefig(buf, format='png')
-            buf.seek(0)
-            im = PIL.Image.open(buf)
-            im.show()
-            buf.close()
-
-        # output array of size steps, each entry list[i] is param value for step i
-        return FloatCollectionOutput(
-            collection=param_list
-        )

invokeai/app/invocations/params.py

@@ -3,7 +3,7 @@
 from typing import Literal
 from pydantic import Field
 from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext
-from .math import IntOutput, FloatOutput
+from .math import IntOutput
 
 # Pass-through parameter nodes - used by subgraphs
 
@@ -16,13 +16,3 @@ class ParamIntInvocation(BaseInvocation):
 
     def invoke(self, context: InvocationContext) -> IntOutput:
         return IntOutput(a=self.a)
-
-class ParamFloatInvocation(BaseInvocation):
-    """A float parameter"""
-    #fmt: off
-    type: Literal["param_float"] = "param_float"
-    param: float = Field(default=0.0, description="The float value")
-    #fmt: on
-
-    def invoke(self, context: InvocationContext) -> FloatOutput:
-        return FloatOutput(param=self.param)

invokeai/app/invocations/prompt.py

@@ -2,8 +2,8 @@ from typing import Literal
 
 from pydantic.fields import Field
 
-from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext
-from dynamicprompts.generators import RandomPromptGenerator, CombinatorialPromptGenerator
+from .baseinvocation import BaseInvocationOutput
+
 
 class PromptOutput(BaseInvocationOutput):
     """Base class for invocations that output a prompt"""
@@ -20,38 +20,3 @@ class PromptOutput(BaseInvocationOutput):
                 'prompt',
             ]
         }
-
-
-class PromptCollectionOutput(BaseInvocationOutput):
-    """Base class for invocations that output a collection of prompts"""
-
-    # fmt: off
-    type: Literal["prompt_collection_output"] = "prompt_collection_output"
-
-    prompt_collection: list[str] = Field(description="The output prompt collection")
-    count: int = Field(description="The size of the prompt collection")
-    # fmt: on
-
-    class Config:
-        schema_extra = {"required": ["type", "prompt_collection", "count"]}
-
-
-class DynamicPromptInvocation(BaseInvocation):
-    """Parses a prompt using adieyal/dynamicprompts' random or combinatorial generator"""
-
-    type: Literal["dynamic_prompt"] = "dynamic_prompt"
-    prompt: str = Field(description="The prompt to parse with dynamicprompts")
-    max_prompts: int = Field(default=1, description="The number of prompts to generate")
-    combinatorial: bool = Field(
-        default=False, description="Whether to use the combinatorial generator"
-    )
-
-    def invoke(self, context: InvocationContext) -> PromptCollectionOutput:
-        if self.combinatorial:
-            generator = CombinatorialPromptGenerator()
-            prompts = generator.generate(self.prompt, max_prompts=self.max_prompts)
-        else:
-            generator = RandomPromptGenerator()
-            prompts = generator.generate(self.prompt, num_images=self.max_prompts)
-
-        return PromptCollectionOutput(prompt_collection=prompts, count=len(prompts))

invokeai/app/invocations/reconstruct.py

@@ -2,23 +2,21 @@ from typing import Literal, Union
 
 from pydantic import Field
 
-from invokeai.app.models.image import ImageCategory, ImageField, ResourceOrigin
+from invokeai.app.models.image import ImageField, ImageType
 
 from .baseinvocation import BaseInvocation, InvocationContext, InvocationConfig
-from .image import ImageOutput
-
+from .image import ImageOutput, build_image_output
 
 class RestoreFaceInvocation(BaseInvocation):
     """Restores faces in an image."""
-
-    # fmt: off
+    #fmt: off
     type:  Literal["restore_face"] = "restore_face"
 
     # Inputs
     image: Union[ImageField, None] = Field(description="The input image")
     strength:                float = Field(default=0.75, gt=0, le=1, description="The strength of the restoration"  )
-    # fmt: on
-
+    #fmt: on
+    
     # Schema customisation
     class Config(InvocationConfig):
         schema_extra = {
@@ -28,7 +26,9 @@ class RestoreFaceInvocation(BaseInvocation):
         }
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
         results = context.services.restoration.upscale_and_reconstruct(
             image_list=[[image, 0]],
             upscale=None,
@@ -39,17 +39,18 @@ class RestoreFaceInvocation(BaseInvocation):
 
         # Results are image and seed, unwrap for now
         # TODO: can this return multiple results?
-        image_dto = context.services.images.create(
-            image=results[0][0],
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
         )
+
+        context.services.images.save(image_type, image_name, results[0][0], metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=results[0][0]
+        )

invokeai/app/invocations/upscale.py

@@ -1,31 +1,25 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-from email.mime import image
 from typing import Literal, Union
-import cv2 as cv
-import numpy as np
 
 from pydantic import Field
-from realesrgan import RealESRGANer
-from PIL import Image
-from basicsr.archs.rrdbnet_arch import RRDBNet
 
-from invokeai.app.models.image import ImageCategory, ImageField, ResourceOrigin
+from invokeai.app.models.image import ImageField, ImageType
 from .baseinvocation import BaseInvocation, InvocationContext, InvocationConfig
-from .image import ImageOutput
+from .image import ImageOutput, build_image_output
 
 
 class UpscaleInvocation(BaseInvocation):
     """Upscales an image."""
-
-    # fmt: off
+    #fmt: off
     type: Literal["upscale"] = "upscale"
 
     # Inputs
     image: Union[ImageField, None] = Field(description="The input image", default=None)
     strength: float = Field(default=0.75, gt=0, le=1, description="The strength")
     level: Literal[2, 4] = Field(default=2, description="The upscale level")
-    # fmt: on
+    #fmt: on
+
 
     # Schema customisation
     class Config(InvocationConfig):
@@ -36,7 +30,9 @@ class UpscaleInvocation(BaseInvocation):
         }
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
         results = context.services.restoration.upscale_and_reconstruct(
             image_list=[[image, 0]],
             upscale=(self.level, self.strength),
@@ -47,87 +43,18 @@ class UpscaleInvocation(BaseInvocation):
 
         # Results are image and seed, unwrap for now
         # TODO: can this return multiple results?
-        image_dto = context.services.images.create(
-            image=results[0][0],
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
 
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
+        metadata = context.services.metadata.build_metadata(
+            session_id=context.graph_execution_state_id, node=self
         )
 
-
-REALESRGAN_MODELS = Literal[
-    "RealESRGAN_x4plus",
-    "RealESRGAN_x4plus_anime_6B",
-    "ESRGAN_SRx4_DF2KOST_official-ff704c30",
-]
-
-
-class RealESRGANInvocation(BaseInvocation):
-    """Upscales an image using Real-ESRGAN."""
-
-    # fmt: off
-    type: Literal["realesrgan"] = "realesrgan"
-    image: Union[ImageField, None] = Field(default=None, description="The input image" )
-    model_name: REALESRGAN_MODELS = Field(default="RealESRGAN_x4plus", description="The Real-ESRGAN model to use")
-    scale: Literal[2, 4] = Field(default=4, description="The final upsampling scale")
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_name)
-
-        model = None
-        netscale = None
-        model_path = None
-
-        if self.model_name == 'RealESRGAN x4 Plus': # x4 RRDBNet model
-            model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
-            netscale = 4
-            model_path = f'core/upscaling/realesrgan/RealESRGAN_x4plus.pth'
-        elif self.model_name == 'RealESRGAN x4 Plus (Anime 6B)':  # x4 RRDBNet model with 6 blocks
-            model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=6, num_grow_ch=32, scale=4)
-            netscale = 4
-            model_path = f'core/upscaling/realesrgan/RealESRGAN_x4plus_anime_6B.pth'
-        # elif self.model_name in ['RealESRGAN_x2plus']:  # x2 RRDBNet model
-        #     model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=2)
-        #     netscale = 2
-        elif self.model_name in ['ESRGAN x4']:  # x2 RRDBNet model
-            model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
-            netscale = 4
-            model_path = f'core/upscaling/realesrgan/ESRGAN_SRx4_DF2KOST_official-ff704c30.pth'
-
-        if not model or not netscale or not model_path:
-            raise Exception(f"Invalid model {self.model_name}")
-        
-        upsampler = RealESRGANer(
-            scale=netscale,
-            model_path=model_path,
-            model=model,
-            half=False,
-        )
-
-        # Real-ESRGAN uses cv2 internally, and cv2 uses BGR vs RGB for PIL
-        cv_image = cv.cvtColor(np.array(image.convert("RGB")), cv.COLOR_RGB2BGR)
-        upscaled_image, img_mode = upsampler.enhance(cv_image, outscale=self.scale)
-        pil_image = Image.fromarray(cv.cvtColor(upscaled_image, cv.COLOR_BGR2RGB)).convert('RGBA')
-
-        image_dto = context.services.images.create(
-            image=pil_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
+        context.services.images.save(image_type, image_name, results[0][0], metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=results[0][0]
+        )

invokeai/app/invocations/util/choose_model.py

@@ -0,0 +1,14 @@
+from invokeai.backend.model_management.model_manager import ModelManager
+
+
+def choose_model(model_manager: ModelManager, model_name: str):
+    """Returns the default model if the `model_name` not a valid model, else returns the selected model."""
+    if model_manager.valid_model(model_name):
+        model = model_manager.get_model(model_name)
+    else:
+        model = model_manager.get_model()
+        print(
+            f"* Warning: '{model_name}' is not a valid model name. Using default model \'{model['model_name']}\' instead."
+        )
+
+    return model

invokeai/app/models/image.py

@@ -1,90 +1,29 @@
 from enum import Enum
-from typing import Optional, Tuple
+from typing import Optional
 from pydantic import BaseModel, Field
 
-from invokeai.app.util.metaenum import MetaEnum
+
+class ImageType(str, Enum):
+    RESULT = "results"
+    INTERMEDIATE = "intermediates"
+    UPLOAD = "uploads"
 
 
-class ResourceOrigin(str, Enum, metaclass=MetaEnum):
-    """The origin of a resource (eg image).
-
-    - INTERNAL: The resource was created by the application.
-    - EXTERNAL: The resource was not created by the application.
-    This may be a user-initiated upload, or an internal application upload (eg Canvas init image).
-    """
-
-    INTERNAL = "internal"
-    """The resource was created by the application."""
-    EXTERNAL = "external"
-    """The resource was not created by the application.
-    This may be a user-initiated upload, or an internal application upload (eg Canvas init image).
-    """
-
-
-class InvalidOriginException(ValueError):
-    """Raised when a provided value is not a valid ResourceOrigin.
-
-    Subclasses `ValueError`.
-    """
-
-    def __init__(self, message="Invalid resource origin."):
-        super().__init__(message)
-
-
-class ImageCategory(str, Enum, metaclass=MetaEnum):
-    """The category of an image.
-
-    - GENERAL: The image is an output, init image, or otherwise an image without a specialized purpose.
-    - MASK: The image is a mask image.
-    - CONTROL: The image is a ControlNet control image.
-    - USER: The image is a user-provide image.
-    - OTHER: The image is some other type of image with a specialized purpose. To be used by external nodes.
-    """
-
-    GENERAL = "general"
-    """GENERAL: The image is an output, init image, or otherwise an image without a specialized purpose."""
-    MASK = "mask"
-    """MASK: The image is a mask image."""
-    CONTROL = "control"
-    """CONTROL: The image is a ControlNet control image."""
-    USER = "user"
-    """USER: The image is a user-provide image."""
-    OTHER = "other"
-    """OTHER: The image is some other type of image with a specialized purpose. To be used by external nodes."""
-
-
-class InvalidImageCategoryException(ValueError):
-    """Raised when a provided value is not a valid ImageCategory.
-
-    Subclasses `ValueError`.
-    """
-
-    def __init__(self, message="Invalid image category."):
-        super().__init__(message)
+def is_image_type(obj):
+    try:
+        ImageType(obj)
+    except ValueError:
+        return False
+    return True
 
 
 class ImageField(BaseModel):
     """An image field used for passing image objects between invocations"""
 
+    image_type: ImageType = Field(
+        default=ImageType.RESULT, description="The type of the image"
+    )
     image_name: Optional[str] = Field(default=None, description="The name of the image")
 
     class Config:
-        schema_extra = {"required": ["image_name"]}
-
-
-class ColorField(BaseModel):
-    r: int = Field(ge=0, le=255, description="The red component")
-    g: int = Field(ge=0, le=255, description="The green component")
-    b: int = Field(ge=0, le=255, description="The blue component")
-    a: int = Field(ge=0, le=255, description="The alpha component")
-
-    def tuple(self) -> Tuple[int, int, int, int]:
-        return (self.r, self.g, self.b, self.a)
-
-
-class ProgressImage(BaseModel):
-    """The progress image sent intermittently during processing"""
-
-    width: int = Field(description="The effective width of the image in pixels")
-    height: int = Field(description="The effective height of the image in pixels")
-    dataURL: str = Field(description="The image data as a b64 data URL")
+        schema_extra = {"required": ["image_type", "image_name"]}

invokeai/app/models/metadata.py

@@ -1,93 +0,0 @@
-from typing import Optional, Union, List
-from pydantic import BaseModel, Extra, Field, StrictFloat, StrictInt, StrictStr
-
-
-class ImageMetadata(BaseModel):
-    """
-    Core generation metadata for an image/tensor generated in InvokeAI.
-
-    Also includes any metadata from the image's PNG tEXt chunks.
-
-    Generated by traversing the execution graph, collecting the parameters of the nearest ancestors
-    of a given node.
-
-    Full metadata may be accessed by querying for the session in the `graph_executions` table.
-    """
-
-    class Config:
-        extra = Extra.allow
-        """
-        This lets the ImageMetadata class accept arbitrary additional fields. The CoreMetadataService
-        won't add any fields that are not already defined, but other a different metadata service
-        implementation might.
-        """
-
-    type: Optional[StrictStr] = Field(
-        default=None,
-        description="The type of the ancestor node of the image output node.",
-    )
-    """The type of the ancestor node of the image output node."""
-    positive_conditioning: Optional[StrictStr] = Field(
-        default=None, description="The positive conditioning."
-    )
-    """The positive conditioning"""
-    negative_conditioning: Optional[StrictStr] = Field(
-        default=None, description="The negative conditioning."
-    )
-    """The negative conditioning"""
-    width: Optional[StrictInt] = Field(
-        default=None, description="Width of the image/latents in pixels."
-    )
-    """Width of the image/latents in pixels"""
-    height: Optional[StrictInt] = Field(
-        default=None, description="Height of the image/latents in pixels."
-    )
-    """Height of the image/latents in pixels"""
-    seed: Optional[StrictInt] = Field(
-        default=None, description="The seed used for noise generation."
-    )
-    """The seed used for noise generation"""
-    # cfg_scale: Optional[StrictFloat] = Field(
-    # cfg_scale: Union[float, list[float]] = Field(
-    cfg_scale: Union[StrictFloat, List[StrictFloat]] = Field(
-        default=None, description="The classifier-free guidance scale."
-    )
-    """The classifier-free guidance scale"""
-    steps: Optional[StrictInt] = Field(
-        default=None, description="The number of steps used for inference."
-    )
-    """The number of steps used for inference"""
-    scheduler: Optional[StrictStr] = Field(
-        default=None, description="The scheduler used for inference."
-    )
-    """The scheduler used for inference"""
-    model: Optional[StrictStr] = Field(
-        default=None, description="The model used for inference."
-    )
-    """The model used for inference"""
-    strength: Optional[StrictFloat] = Field(
-        default=None,
-        description="The strength used for image-to-image/latents-to-latents.",
-    )
-    """The strength used for image-to-image/latents-to-latents."""
-    latents: Optional[StrictStr] = Field(
-        default=None, description="The ID of the initial latents."
-    )
-    """The ID of the initial latents"""
-    vae: Optional[StrictStr] = Field(
-        default=None, description="The VAE used for decoding."
-    )
-    """The VAE used for decoding"""
-    unet: Optional[StrictStr] = Field(
-        default=None, description="The UNet used dor inference."
-    )
-    """The UNet used dor inference"""
-    clip: Optional[StrictStr] = Field(
-        default=None, description="The CLIP Encoder used for conditioning."
-    )
-    """The CLIP Encoder used for conditioning"""
-    extra: Optional[StrictStr] = Field(
-        default=None,
-        description="Uploaded image metadata, extracted from the PNG tEXt chunk.",
-    )
-    """Uploaded image metadata, extracted from the PNG tEXt chunk."""

invokeai/app/services/board_image_record_storage.py

@@ -1,254 +0,0 @@
-from abc import ABC, abstractmethod
-import sqlite3
-import threading
-from typing import Union, cast
-from invokeai.app.services.board_record_storage import BoardRecord
-
-from invokeai.app.services.image_record_storage import OffsetPaginatedResults
-from invokeai.app.services.models.image_record import (
-    ImageRecord,
-    deserialize_image_record,
-)
-
-
-class BoardImageRecordStorageBase(ABC):
-    """Abstract base class for the one-to-many board-image relationship record storage."""
-
-    @abstractmethod
-    def add_image_to_board(
-        self,
-        board_id: str,
-        image_name: str,
-    ) -> None:
-        """Adds an image to a board."""
-        pass
-
-    @abstractmethod
-    def remove_image_from_board(
-        self,
-        board_id: str,
-        image_name: str,
-    ) -> None:
-        """Removes an image from a board."""
-        pass
-
-    @abstractmethod
-    def get_images_for_board(
-        self,
-        board_id: str,
-    ) -> OffsetPaginatedResults[ImageRecord]:
-        """Gets images for a board."""
-        pass
-
-    @abstractmethod
-    def get_board_for_image(
-        self,
-        image_name: str,
-    ) -> Union[str, None]:
-        """Gets an image's board id, if it has one."""
-        pass
-
-    @abstractmethod
-    def get_image_count_for_board(
-        self,
-        board_id: str,
-    ) -> int:
-        """Gets the number of images for a board."""
-        pass
-
-
-class SqliteBoardImageRecordStorage(BoardImageRecordStorageBase):
-    _filename: str
-    _conn: sqlite3.Connection
-    _cursor: sqlite3.Cursor
-    _lock: threading.Lock
-
-    def __init__(self, filename: str) -> None:
-        super().__init__()
-        self._filename = filename
-        self._conn = sqlite3.connect(filename, check_same_thread=False)
-        # Enable row factory to get rows as dictionaries (must be done before making the cursor!)
-        self._conn.row_factory = sqlite3.Row
-        self._cursor = self._conn.cursor()
-        self._lock = threading.Lock()
-
-        try:
-            self._lock.acquire()
-            # Enable foreign keys
-            self._conn.execute("PRAGMA foreign_keys = ON;")
-            self._create_tables()
-            self._conn.commit()
-        finally:
-            self._lock.release()
-
-    def _create_tables(self) -> None:
-        """Creates the `board_images` junction table."""
-
-        # Create the `board_images` junction table.
-        self._cursor.execute(
-            """--sql
-            CREATE TABLE IF NOT EXISTS board_images (
-                board_id TEXT NOT NULL,
-                image_name TEXT NOT NULL,
-                created_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
-                -- updated via trigger
-                updated_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
-                -- Soft delete, currently unused
-                deleted_at DATETIME,
-                -- enforce one-to-many relationship between boards and images using PK
-                -- (we can extend this to many-to-many later)
-                PRIMARY KEY (image_name),
-                FOREIGN KEY (board_id) REFERENCES boards (board_id) ON DELETE CASCADE,
-                FOREIGN KEY (image_name) REFERENCES images (image_name) ON DELETE CASCADE
-            );
-            """
-        )
-
-        # Add index for board id
-        self._cursor.execute(
-            """--sql
-            CREATE INDEX IF NOT EXISTS idx_board_images_board_id ON board_images (board_id);
-            """
-        )
-
-        # Add index for board id, sorted by created_at
-        self._cursor.execute(
-            """--sql
-            CREATE INDEX IF NOT EXISTS idx_board_images_board_id_created_at ON board_images (board_id, created_at);
-            """
-        )
-
-        # Add trigger for `updated_at`.
-        self._cursor.execute(
-            """--sql
-            CREATE TRIGGER IF NOT EXISTS tg_board_images_updated_at
-            AFTER UPDATE
-            ON board_images FOR EACH ROW
-            BEGIN
-                UPDATE board_images SET updated_at = STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')
-                    WHERE board_id = old.board_id AND image_name = old.image_name;
-            END;
-            """
-        )
-
-    def add_image_to_board(
-        self,
-        board_id: str,
-        image_name: str,
-    ) -> None:
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                INSERT INTO board_images (board_id, image_name)
-                VALUES (?, ?)
-                ON CONFLICT (image_name) DO UPDATE SET board_id = ?;
-                """,
-                (board_id, image_name, board_id),
-            )
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-        finally:
-            self._lock.release()
-
-    def remove_image_from_board(
-        self,
-        board_id: str,
-        image_name: str,
-    ) -> None:
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                DELETE FROM board_images
-                WHERE board_id = ? AND image_name = ?;
-                """,
-                (board_id, image_name),
-            )
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-        finally:
-            self._lock.release()
-
-    def get_images_for_board(
-        self,
-        board_id: str,
-        offset: int = 0,
-        limit: int = 10,
-    ) -> OffsetPaginatedResults[ImageRecord]:
-        # TODO: this isn't paginated yet?
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                SELECT images.*
-                FROM board_images
-                INNER JOIN images ON board_images.image_name = images.image_name
-                WHERE board_images.board_id = ?
-                ORDER BY board_images.updated_at DESC;
-                """,
-                (board_id,),
-            )
-            result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            images = list(map(lambda r: deserialize_image_record(dict(r)), result))
-
-            self._cursor.execute(
-                """--sql
-                SELECT COUNT(*) FROM images WHERE 1=1;
-                """
-            )
-            count = cast(int, self._cursor.fetchone()[0])
-
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-        finally:
-            self._lock.release()
-        return OffsetPaginatedResults(
-            items=images, offset=offset, limit=limit, total=count
-        )
-
-    def get_board_for_image(
-        self,
-        image_name: str,
-    ) -> Union[str, None]:
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                SELECT board_id
-                FROM board_images
-                WHERE image_name = ?;
-                """,
-                (image_name,),
-            )
-            result = self._cursor.fetchone()
-            if result is None:
-                return None
-            return cast(str, result[0])
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-        finally:
-            self._lock.release()
-
-    def get_image_count_for_board(self, board_id: str) -> int:
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                SELECT COUNT(*) FROM board_images WHERE board_id = ?;
-                """,
-                (board_id,),
-            )
-            count = cast(int, self._cursor.fetchone()[0])
-            return count
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-        finally:
-            self._lock.release()

invokeai/app/services/board_images.py

@@ -1,142 +0,0 @@
-from abc import ABC, abstractmethod
-from logging import Logger
-from typing import List, Union
-from invokeai.app.services.board_image_record_storage import BoardImageRecordStorageBase
-from invokeai.app.services.board_record_storage import (
-    BoardRecord,
-    BoardRecordStorageBase,
-)
-
-from invokeai.app.services.image_record_storage import (
-    ImageRecordStorageBase,
-    OffsetPaginatedResults,
-)
-from invokeai.app.services.models.board_record import BoardDTO
-from invokeai.app.services.models.image_record import ImageDTO, image_record_to_dto
-from invokeai.app.services.urls import UrlServiceBase
-
-
-class BoardImagesServiceABC(ABC):
-    """High-level service for board-image relationship management."""
-
-    @abstractmethod
-    def add_image_to_board(
-        self,
-        board_id: str,
-        image_name: str,
-    ) -> None:
-        """Adds an image to a board."""
-        pass
-
-    @abstractmethod
-    def remove_image_from_board(
-        self,
-        board_id: str,
-        image_name: str,
-    ) -> None:
-        """Removes an image from a board."""
-        pass
-
-    @abstractmethod
-    def get_images_for_board(
-        self,
-        board_id: str,
-    ) -> OffsetPaginatedResults[ImageDTO]:
-        """Gets images for a board."""
-        pass
-
-    @abstractmethod
-    def get_board_for_image(
-        self,
-        image_name: str,
-    ) -> Union[str, None]:
-        """Gets an image's board id, if it has one."""
-        pass
-
-
-class BoardImagesServiceDependencies:
-    """Service dependencies for the BoardImagesService."""
-
-    board_image_records: BoardImageRecordStorageBase
-    board_records: BoardRecordStorageBase
-    image_records: ImageRecordStorageBase
-    urls: UrlServiceBase
-    logger: Logger
-
-    def __init__(
-        self,
-        board_image_record_storage: BoardImageRecordStorageBase,
-        image_record_storage: ImageRecordStorageBase,
-        board_record_storage: BoardRecordStorageBase,
-        url: UrlServiceBase,
-        logger: Logger,
-    ):
-        self.board_image_records = board_image_record_storage
-        self.image_records = image_record_storage
-        self.board_records = board_record_storage
-        self.urls = url
-        self.logger = logger
-
-
-class BoardImagesService(BoardImagesServiceABC):
-    _services: BoardImagesServiceDependencies
-
-    def __init__(self, services: BoardImagesServiceDependencies):
-        self._services = services
-
-    def add_image_to_board(
-        self,
-        board_id: str,
-        image_name: str,
-    ) -> None:
-        self._services.board_image_records.add_image_to_board(board_id, image_name)
-
-    def remove_image_from_board(
-        self,
-        board_id: str,
-        image_name: str,
-    ) -> None:
-        self._services.board_image_records.remove_image_from_board(board_id, image_name)
-
-    def get_images_for_board(
-        self,
-        board_id: str,
-    ) -> OffsetPaginatedResults[ImageDTO]:
-        image_records = self._services.board_image_records.get_images_for_board(
-            board_id
-        )
-        image_dtos = list(
-            map(
-                lambda r: image_record_to_dto(
-                    r,
-                    self._services.urls.get_image_url(r.image_name),
-                    self._services.urls.get_image_url(r.image_name, True),
-                    board_id,
-                ),
-                image_records.items,
-            )
-        )
-        return OffsetPaginatedResults[ImageDTO](
-            items=image_dtos,
-            offset=image_records.offset,
-            limit=image_records.limit,
-            total=image_records.total,
-        )
-
-    def get_board_for_image(
-        self,
-        image_name: str,
-    ) -> Union[str, None]:
-        board_id = self._services.board_image_records.get_board_for_image(image_name)
-        return board_id
-
-
-def board_record_to_dto(
-    board_record: BoardRecord, cover_image_name: str | None, image_count: int
-) -> BoardDTO:
-    """Converts a board record to a board DTO."""
-    return BoardDTO(
-        **board_record.dict(exclude={'cover_image_name'}),
-        cover_image_name=cover_image_name,
-        image_count=image_count,
-    )

invokeai/app/services/board_record_storage.py

@@ -1,329 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional, cast
-import sqlite3
-import threading
-from typing import Optional, Union
-import uuid
-from invokeai.app.services.image_record_storage import OffsetPaginatedResults
-from invokeai.app.services.models.board_record import (
-    BoardRecord,
-    deserialize_board_record,
-)
-
-from pydantic import BaseModel, Field, Extra
-
-
-class BoardChanges(BaseModel, extra=Extra.forbid):
-    board_name: Optional[str] = Field(description="The board's new name.")
-    cover_image_name: Optional[str] = Field(
-        description="The name of the board's new cover image."
-    )
-
-
-class BoardRecordNotFoundException(Exception):
-    """Raised when an board record is not found."""
-
-    def __init__(self, message="Board record not found"):
-        super().__init__(message)
-
-
-class BoardRecordSaveException(Exception):
-    """Raised when an board record cannot be saved."""
-
-    def __init__(self, message="Board record not saved"):
-        super().__init__(message)
-
-
-class BoardRecordDeleteException(Exception):
-    """Raised when an board record cannot be deleted."""
-
-    def __init__(self, message="Board record not deleted"):
-        super().__init__(message)
-
-
-class BoardRecordStorageBase(ABC):
-    """Low-level service responsible for interfacing with the board record store."""
-
-    @abstractmethod
-    def delete(self, board_id: str) -> None:
-        """Deletes a board record."""
-        pass
-
-    @abstractmethod
-    def save(
-        self,
-        board_name: str,
-    ) -> BoardRecord:
-        """Saves a board record."""
-        pass
-
-    @abstractmethod
-    def get(
-        self,
-        board_id: str,
-    ) -> BoardRecord:
-        """Gets a board record."""
-        pass
-
-    @abstractmethod
-    def update(
-        self,
-        board_id: str,
-        changes: BoardChanges,
-    ) -> BoardRecord:
-        """Updates a board record."""
-        pass
-
-    @abstractmethod
-    def get_many(
-        self,
-        offset: int = 0,
-        limit: int = 10,
-    ) -> OffsetPaginatedResults[BoardRecord]:
-        """Gets many board records."""
-        pass
-
-    @abstractmethod
-    def get_all(
-        self,
-    ) -> list[BoardRecord]:
-        """Gets all board records."""
-        pass
-
-
-class SqliteBoardRecordStorage(BoardRecordStorageBase):
-    _filename: str
-    _conn: sqlite3.Connection
-    _cursor: sqlite3.Cursor
-    _lock: threading.Lock
-
-    def __init__(self, filename: str) -> None:
-        super().__init__()
-        self._filename = filename
-        self._conn = sqlite3.connect(filename, check_same_thread=False)
-        # Enable row factory to get rows as dictionaries (must be done before making the cursor!)
-        self._conn.row_factory = sqlite3.Row
-        self._cursor = self._conn.cursor()
-        self._lock = threading.Lock()
-
-        try:
-            self._lock.acquire()
-            # Enable foreign keys
-            self._conn.execute("PRAGMA foreign_keys = ON;")
-            self._create_tables()
-            self._conn.commit()
-        finally:
-            self._lock.release()
-
-    def _create_tables(self) -> None:
-        """Creates the `boards` table and `board_images` junction table."""
-
-        # Create the `boards` table.
-        self._cursor.execute(
-            """--sql
-            CREATE TABLE IF NOT EXISTS boards (
-                board_id TEXT NOT NULL PRIMARY KEY,
-                board_name TEXT NOT NULL,
-                cover_image_name TEXT,
-                created_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
-                -- Updated via trigger
-                updated_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
-                -- Soft delete, currently unused
-                deleted_at DATETIME,
-                FOREIGN KEY (cover_image_name) REFERENCES images (image_name) ON DELETE SET NULL
-            );
-            """
-        )
-
-        self._cursor.execute(
-            """--sql
-            CREATE INDEX IF NOT EXISTS idx_boards_created_at ON boards (created_at);
-            """
-        )
-
-        # Add trigger for `updated_at`.
-        self._cursor.execute(
-            """--sql
-            CREATE TRIGGER IF NOT EXISTS tg_boards_updated_at
-            AFTER UPDATE
-            ON boards FOR EACH ROW
-            BEGIN
-                UPDATE boards SET updated_at = current_timestamp
-                    WHERE board_id = old.board_id;
-            END;
-            """
-        )
-
-    def delete(self, board_id: str) -> None:
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                DELETE FROM boards
-                WHERE board_id = ?;
-                """,
-                (board_id,),
-            )
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise BoardRecordDeleteException from e
-        except Exception as e:
-            self._conn.rollback()
-            raise BoardRecordDeleteException from e
-        finally:
-            self._lock.release()
-
-    def save(
-        self,
-        board_name: str,
-    ) -> BoardRecord:
-        try:
-            board_id = str(uuid.uuid4())
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                INSERT OR IGNORE INTO boards (board_id, board_name)
-                VALUES (?, ?);
-                """,
-                (board_id, board_name),
-            )
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise BoardRecordSaveException from e
-        finally:
-            self._lock.release()
-        return self.get(board_id)
-
-    def get(
-        self,
-        board_id: str,
-    ) -> BoardRecord:
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                SELECT *
-                FROM boards
-                WHERE board_id = ?;
-                """,
-                (board_id,),
-            )
-
-            result = cast(Union[sqlite3.Row, None], self._cursor.fetchone())
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise BoardRecordNotFoundException from e
-        finally:
-            self._lock.release()
-        if result is None:
-            raise BoardRecordNotFoundException
-        return BoardRecord(**dict(result))
-
-    def update(
-        self,
-        board_id: str,
-        changes: BoardChanges,
-    ) -> BoardRecord:
-        try:
-            self._lock.acquire()
-
-            # Change the name of a board
-            if changes.board_name is not None:
-                self._cursor.execute(
-                    f"""--sql
-                    UPDATE boards
-                    SET board_name = ?
-                    WHERE board_id = ?;
-                    """,
-                    (changes.board_name, board_id),
-                )
-
-            # Change the cover image of a board
-            if changes.cover_image_name is not None:
-                self._cursor.execute(
-                    f"""--sql
-                    UPDATE boards
-                    SET cover_image_name = ?
-                    WHERE board_id = ?;
-                    """,
-                    (changes.cover_image_name, board_id),
-                )
-
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise BoardRecordSaveException from e
-        finally:
-            self._lock.release()
-        return self.get(board_id)
-
-    def get_many(
-        self,
-        offset: int = 0,
-        limit: int = 10,
-    ) -> OffsetPaginatedResults[BoardRecord]:
-        try:
-            self._lock.acquire()
-
-            # Get all the boards
-            self._cursor.execute(
-                """--sql
-                SELECT *
-                FROM boards
-                ORDER BY created_at DESC
-                LIMIT ? OFFSET ?;
-                """,
-                (limit, offset),
-            )
-
-            result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            boards = list(map(lambda r: deserialize_board_record(dict(r)), result))
-
-            # Get the total number of boards
-            self._cursor.execute(
-                """--sql
-                SELECT COUNT(*)
-                FROM boards
-                WHERE 1=1;
-                """
-            )
-
-            count = cast(int, self._cursor.fetchone()[0])
-
-            return OffsetPaginatedResults[BoardRecord](
-                items=boards, offset=offset, limit=limit, total=count
-            )
-
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-        finally:
-            self._lock.release()
-
-    def get_all(
-        self,
-    ) -> list[BoardRecord]:
-        try:
-            self._lock.acquire()
-
-            # Get all the boards
-            self._cursor.execute(
-                """--sql
-                SELECT *
-                FROM boards
-                ORDER BY created_at DESC
-                """
-            )
-
-            result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            boards = list(map(lambda r: deserialize_board_record(dict(r)), result))
-
-            return boards
-
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-        finally:
-            self._lock.release()

invokeai/app/services/boards.py

@@ -1,185 +0,0 @@
-from abc import ABC, abstractmethod
-
-from logging import Logger
-from invokeai.app.services.board_image_record_storage import BoardImageRecordStorageBase
-from invokeai.app.services.board_images import board_record_to_dto
-
-from invokeai.app.services.board_record_storage import (
-    BoardChanges,
-    BoardRecordStorageBase,
-)
-from invokeai.app.services.image_record_storage import (
-    ImageRecordStorageBase,
-    OffsetPaginatedResults,
-)
-from invokeai.app.services.models.board_record import BoardDTO
-from invokeai.app.services.urls import UrlServiceBase
-
-
-class BoardServiceABC(ABC):
-    """High-level service for board management."""
-
-    @abstractmethod
-    def create(
-        self,
-        board_name: str,
-    ) -> BoardDTO:
-        """Creates a board."""
-        pass
-
-    @abstractmethod
-    def get_dto(
-        self,
-        board_id: str,
-    ) -> BoardDTO:
-        """Gets a board."""
-        pass
-
-    @abstractmethod
-    def update(
-        self,
-        board_id: str,
-        changes: BoardChanges,
-    ) -> BoardDTO:
-        """Updates a board."""
-        pass
-
-    @abstractmethod
-    def delete(
-        self,
-        board_id: str,
-    ) -> None:
-        """Deletes a board."""
-        pass
-
-    @abstractmethod
-    def get_many(
-        self,
-        offset: int = 0,
-        limit: int = 10,
-    ) -> OffsetPaginatedResults[BoardDTO]:
-        """Gets many boards."""
-        pass
-
-    @abstractmethod
-    def get_all(
-        self,
-    ) -> list[BoardDTO]:
-        """Gets all boards."""
-        pass
-
-
-class BoardServiceDependencies:
-    """Service dependencies for the BoardService."""
-
-    board_image_records: BoardImageRecordStorageBase
-    board_records: BoardRecordStorageBase
-    image_records: ImageRecordStorageBase
-    urls: UrlServiceBase
-    logger: Logger
-
-    def __init__(
-        self,
-        board_image_record_storage: BoardImageRecordStorageBase,
-        image_record_storage: ImageRecordStorageBase,
-        board_record_storage: BoardRecordStorageBase,
-        url: UrlServiceBase,
-        logger: Logger,
-    ):
-        self.board_image_records = board_image_record_storage
-        self.image_records = image_record_storage
-        self.board_records = board_record_storage
-        self.urls = url
-        self.logger = logger
-
-
-class BoardService(BoardServiceABC):
-    _services: BoardServiceDependencies
-
-    def __init__(self, services: BoardServiceDependencies):
-        self._services = services
-
-    def create(
-        self,
-        board_name: str,
-    ) -> BoardDTO:
-        board_record = self._services.board_records.save(board_name)
-        return board_record_to_dto(board_record, None, 0)
-
-    def get_dto(self, board_id: str) -> BoardDTO:
-        board_record = self._services.board_records.get(board_id)
-        cover_image = self._services.image_records.get_most_recent_image_for_board(
-            board_record.board_id
-        )
-        if cover_image:
-            cover_image_name = cover_image.image_name
-        else:
-            cover_image_name = None
-        image_count = self._services.board_image_records.get_image_count_for_board(
-            board_id
-        )
-        return board_record_to_dto(board_record, cover_image_name, image_count)
-
-    def update(
-        self,
-        board_id: str,
-        changes: BoardChanges,
-    ) -> BoardDTO:
-        board_record = self._services.board_records.update(board_id, changes)
-        cover_image = self._services.image_records.get_most_recent_image_for_board(
-            board_record.board_id
-        )
-        if cover_image:
-            cover_image_name = cover_image.image_name
-        else:
-            cover_image_name = None
-
-        image_count = self._services.board_image_records.get_image_count_for_board(
-            board_id
-        )
-        return board_record_to_dto(board_record, cover_image_name, image_count)
-
-    def delete(self, board_id: str) -> None:
-        self._services.board_records.delete(board_id)
-
-    def get_many(
-        self, offset: int = 0, limit: int = 10
-    ) -> OffsetPaginatedResults[BoardDTO]:
-        board_records = self._services.board_records.get_many(offset, limit)
-        board_dtos = []
-        for r in board_records.items:
-            cover_image = self._services.image_records.get_most_recent_image_for_board(
-                r.board_id
-            )
-            if cover_image:
-                cover_image_name = cover_image.image_name
-            else:
-                cover_image_name = None
-
-            image_count = self._services.board_image_records.get_image_count_for_board(
-                r.board_id
-            )
-            board_dtos.append(board_record_to_dto(r, cover_image_name, image_count))
-
-        return OffsetPaginatedResults[BoardDTO](
-            items=board_dtos, offset=offset, limit=limit, total=len(board_dtos)
-        )
-
-    def get_all(self) -> list[BoardDTO]:
-        board_records = self._services.board_records.get_all()
-        board_dtos = []
-        for r in board_records:
-            cover_image = self._services.image_records.get_most_recent_image_for_board(
-                r.board_id
-            )
-            if cover_image:
-                cover_image_name = cover_image.image_name
-            else:
-                cover_image_name = None
-
-            image_count = self._services.board_image_records.get_image_count_for_board(
-                r.board_id
-            )
-            board_dtos.append(board_record_to_dto(r, cover_image_name, image_count))
-
-        return board_dtos

invokeai/app/services/config.py

@@ -1,539 +0,0 @@
-# Copyright (c) 2023 Lincoln Stein (https://github.com/lstein) and the InvokeAI Development Team
-
-'''Invokeai configuration system.
-
-Arguments and fields are taken from the pydantic definition of the
-model.  Defaults can be set by creating a yaml configuration file that
-has a top-level key of "InvokeAI" and subheadings for each of the
-categories returned by `invokeai --help`. The file looks like this:
-
-[file: invokeai.yaml]
-
-InvokeAI:
-  Paths:
-    root: /home/lstein/invokeai-main
-    conf_path: configs/models.yaml
-    legacy_conf_dir: configs/stable-diffusion
-    outdir: outputs
-    autoconvert_dir: null
-  Models:
-    model: stable-diffusion-1.5
-    embeddings: true
-  Memory/Performance:
-    xformers_enabled: false
-    sequential_guidance: false
-    precision: float16
-    max_loaded_models: 4
-    always_use_cpu: false
-    free_gpu_mem: false
-  Features:
-    nsfw_checker: true
-    restore: true
-    esrgan: true
-    patchmatch: true
-    internet_available: true
-    log_tokenization: false
-  Web Server:
-    host: 127.0.0.1
-    port: 8081
-    allow_origins: []
-    allow_credentials: true
-    allow_methods:
-    - '*'
-    allow_headers:
-    - '*'
-
-The default name of the configuration file is `invokeai.yaml`, located
-in INVOKEAI_ROOT. You can replace supersede this by providing any
-OmegaConf dictionary object initialization time:
-
- omegaconf = OmegaConf.load('/tmp/init.yaml')
- conf = InvokeAIAppConfig()
- conf.parse_args(conf=omegaconf)
-
-InvokeAIAppConfig.parse_args() will parse the contents of `sys.argv`
-at initialization time. You may pass a list of strings in the optional
-`argv` argument to use instead of the system argv:
-
- conf.parse_args(argv=['--xformers_enabled'])
-
-It is also possible to set a value at initialization time. However, if
-you call parse_args() it may be overwritten.
-
- conf = InvokeAIAppConfig(xformers_enabled=True)
- conf.parse_args(argv=['--no-xformers'])
- conf.xformers_enabled
- # False
-
-
-To avoid this, use `get_config()` to retrieve the application-wide
-configuration object. This will retain any properties set at object
-creation time:
-
- conf = InvokeAIAppConfig.get_config(xformers_enabled=True)
- conf.parse_args(argv=['--no-xformers'])
- conf.xformers_enabled
- # True
-
-Any setting can be overwritten by setting an environment variable of
-form: "INVOKEAI_<setting>", as in:
-
-  export INVOKEAI_port=8080
-
-Order of precedence (from highest):
-   1) initialization options
-   2) command line options
-   3) environment variable options
-   4) config file options
-   5) pydantic defaults
-
-Typical usage at the top level file:
-
- from invokeai.app.services.config import InvokeAIAppConfig
-
- # get global configuration and print its nsfw_checker value
- conf = InvokeAIAppConfig.get_config()
- conf.parse_args()
- print(conf.nsfw_checker)
-
-Typical usage in a backend module:
-
- from invokeai.app.services.config import InvokeAIAppConfig
-
- # get global configuration and print its nsfw_checker value
- conf = InvokeAIAppConfig.get_config()
- print(conf.nsfw_checker)
-
-
-Computed properties:
-
-The InvokeAIAppConfig object has a series of properties that
-resolve paths relative to the runtime root directory. They each return
-a Path object:
-
- root_path          - path to InvokeAI root
- output_path        - path to default outputs directory
- model_conf_path    - path to models.yaml
- conf               - alias for the above
- embedding_path     - path to the embeddings directory
- lora_path          - path to the LoRA directory
-
-In most cases, you will want to create a single InvokeAIAppConfig
-object for the entire application. The InvokeAIAppConfig.get_config() function
-does this:
-
-  config = InvokeAIAppConfig.get_config()
-  config.parse_args()   # read values from the command line/config file
-  print(config.root)
-
-# Subclassing
-
-If you wish to create a similar class, please subclass the
-`InvokeAISettings` class and define a Literal field named "type",
-which is set to the desired top-level name.  For example, to create a
-"InvokeBatch" configuration, define like this:
-
-  class InvokeBatch(InvokeAISettings):
-     type: Literal["InvokeBatch"] = "InvokeBatch"
-     node_count : int = Field(default=1, description="Number of nodes to run on", category='Resources')
-     cpu_count  : int = Field(default=8, description="Number of GPUs to run on per node", category='Resources')
-
-This will now read and write from the "InvokeBatch" section of the
-config file, look for environment variables named INVOKEBATCH_*, and
-accept the command-line arguments `--node_count` and `--cpu_count`. The
-two configs are kept in separate sections of the config file:
-
-  # invokeai.yaml
-
-  InvokeBatch:
-     Resources:
-        node_count: 1
-        cpu_count: 8
-
-  InvokeAI:
-     Paths:
-        root: /home/lstein/invokeai-main
-        conf_path: configs/models.yaml
-        legacy_conf_dir: configs/stable-diffusion
-        outdir: outputs
-     ...
-
-'''
-from __future__ import annotations
-import argparse
-import pydoc
-import os
-import sys
-from argparse import ArgumentParser
-from omegaconf import OmegaConf, DictConfig
-from pathlib import Path
-from pydantic import BaseSettings, Field, parse_obj_as
-from typing import ClassVar, Dict, List, Literal, Union, get_origin, get_type_hints, get_args
-
-INIT_FILE = Path('invokeai.yaml')
-DB_FILE   = Path('invokeai.db')
-LEGACY_INIT_FILE = Path('invokeai.init')
-
-class InvokeAISettings(BaseSettings):
-    '''
-    Runtime configuration settings in which default values are
-    read from an omegaconf .yaml file.
-    '''
-    initconf             : ClassVar[DictConfig] = None
-    argparse_groups      : ClassVar[Dict] = {}
-
-    def parse_args(self, argv: list=sys.argv[1:]):
-        parser = self.get_parser()
-        opt = parser.parse_args(argv)
-        for name in self.__fields__:
-            if name not in self._excluded():
-                setattr(self, name, getattr(opt,name))
-
-    def to_yaml(self)->str:
-        """
-        Return a YAML string representing our settings. This can be used
-        as the contents of `invokeai.yaml` to restore settings later.
-        """
-        cls = self.__class__
-        type = get_args(get_type_hints(cls)['type'])[0]
-        field_dict = dict({type:dict()})
-        for name,field in self.__fields__.items():
-            if name in cls._excluded():
-                continue
-            category = field.field_info.extra.get("category") or "Uncategorized"
-            value = getattr(self,name)
-            if category not in field_dict[type]:
-                field_dict[type][category] = dict()
-            # keep paths as strings to make it easier to read
-            field_dict[type][category][name] = str(value) if isinstance(value,Path) else value
-        conf = OmegaConf.create(field_dict)
-        return OmegaConf.to_yaml(conf)
-
-    @classmethod
-    def add_parser_arguments(cls, parser):
-        if 'type' in get_type_hints(cls):
-            settings_stanza = get_args(get_type_hints(cls)['type'])[0]
-        else:
-            settings_stanza = "Uncategorized"
-
-        env_prefix = cls.Config.env_prefix if hasattr(cls.Config,'env_prefix') else settings_stanza.upper()
-
-        initconf = cls.initconf.get(settings_stanza) \
-            if cls.initconf and settings_stanza in cls.initconf \
-               else OmegaConf.create()
-
-        # create an upcase version of the environment in
-        # order to achieve case-insensitive environment
-        # variables (the way Windows does)
-        upcase_environ = dict()
-        for key,value in os.environ.items():
-            upcase_environ[key.upper()] = value
-        
-        fields = cls.__fields__
-        cls.argparse_groups = {}
-        
-        for name, field in fields.items():
-            if name not in cls._excluded():
-                current_default = field.default
-
-                category = field.field_info.extra.get("category","Uncategorized")
-                env_name = env_prefix + '_' + name
-                if category in initconf and name in initconf.get(category):
-                    field.default = initconf.get(category).get(name)
-                if env_name.upper() in upcase_environ:
-                    field.default = upcase_environ[env_name.upper()]
-                cls.add_field_argument(parser, name, field)
-
-                field.default = current_default
-
-    @classmethod
-    def cmd_name(self, command_field: str='type')->str:
-        hints = get_type_hints(self)
-        if command_field in hints:
-            return get_args(hints[command_field])[0]
-        else:
-            return 'Uncategorized'
-
-    @classmethod
-    def get_parser(cls)->ArgumentParser:
-        parser = PagingArgumentParser(
-            prog=cls.cmd_name(),
-            description=cls.__doc__,
-        )
-        cls.add_parser_arguments(parser)
-        return parser
-
-    @classmethod
-    def add_subparser(cls, parser: argparse.ArgumentParser):
-        parser.add_parser(cls.cmd_name(), help=cls.__doc__)
-
-    @classmethod
-    def _excluded(self)->List[str]:
-        return ['type','initconf']
-
-    class Config:
-        env_file_encoding = 'utf-8'
-        arbitrary_types_allowed = True
-        case_sensitive = True
-
-    @classmethod
-    def add_field_argument(cls, command_parser, name: str, field, default_override = None):
-        field_type = get_type_hints(cls).get(name)
-        default = default_override if default_override is not None else field.default if field.default_factory is None else field.default_factory()
-        if category := field.field_info.extra.get("category"):
-            if category not in cls.argparse_groups:
-                cls.argparse_groups[category] = command_parser.add_argument_group(category)
-            argparse_group = cls.argparse_groups[category]
-        else:
-            argparse_group = command_parser
-
-        if get_origin(field_type) == Literal:
-            allowed_values = get_args(field.type_)
-            allowed_types = set()
-            for val in allowed_values:
-                allowed_types.add(type(val))
-            allowed_types_list = list(allowed_types)
-            field_type = allowed_types_list[0] if len(allowed_types) == 1 else Union[allowed_types_list]  # type: ignore
-
-            argparse_group.add_argument(
-                f"--{name}",
-                dest=name,
-                type=field_type,
-                default=default,
-                choices=allowed_values,
-                help=field.field_info.description,
-            )
-
-        elif get_origin(field_type) == list:
-            argparse_group.add_argument(
-                f"--{name}",
-                dest=name,
-                nargs='*',
-                type=field.type_,
-                default=default,
-                action=argparse.BooleanOptionalAction if field.type_==bool else 'store',
-                help=field.field_info.description,
-            )
-        else:
-            argparse_group.add_argument(
-                f"--{name}",
-                dest=name,
-                type=field.type_,
-                default=default,
-                action=argparse.BooleanOptionalAction if field.type_==bool else 'store',
-                help=field.field_info.description,
-            )
-def _find_root()->Path:
-    if os.environ.get("INVOKEAI_ROOT"):
-        root = Path(os.environ.get("INVOKEAI_ROOT")).resolve()
-    elif (
-            os.environ.get("VIRTUAL_ENV")
-            and (Path(os.environ.get("VIRTUAL_ENV"), "..", INIT_FILE).exists()
-                 or
-                 Path(os.environ.get("VIRTUAL_ENV"), "..", LEGACY_INIT_FILE).exists()
-                 )
-    ):
-        root = Path(os.environ.get("VIRTUAL_ENV"), "..").resolve()
-    else:
-        root = Path("~/invokeai").expanduser().resolve()
-    return root
-
-class InvokeAIAppConfig(InvokeAISettings):
-    '''
-Generate images using Stable Diffusion. Use "invokeai" to launch
-the command-line client (recommended for experts only), or
-"invokeai-web" to launch the web server. Global options
-can be changed by editing the file "INVOKEAI_ROOT/invokeai.yaml" or by
-setting environment variables INVOKEAI_<setting>.
-     '''
-    singleton_config: ClassVar[InvokeAIAppConfig] = None
-    singleton_init: ClassVar[Dict] = None
-    
-    #fmt: off
-    type: Literal["InvokeAI"] = "InvokeAI"
-    host                : str = Field(default="127.0.0.1", description="IP address to bind to", category='Web Server')
-    port                : int = Field(default=9090, description="Port to bind to", category='Web Server')
-    allow_origins       : List[str] = Field(default=[], description="Allowed CORS origins", category='Web Server')
-    allow_credentials   : bool = Field(default=True, description="Allow CORS credentials", category='Web Server')
-    allow_methods       : List[str] = Field(default=["*"], description="Methods allowed for CORS", category='Web Server')
-    allow_headers       : List[str] = Field(default=["*"], description="Headers allowed for CORS", category='Web Server')
-
-    esrgan              : bool = Field(default=True, description="Enable/disable upscaling code", category='Features')
-    internet_available  : bool = Field(default=True, description="If true, attempt to download models on the fly; otherwise only use local models", category='Features')
-    log_tokenization    : bool = Field(default=False, description="Enable logging of parsed prompt tokens.", category='Features')
-    nsfw_checker        : bool = Field(default=True, description="Enable/disable the NSFW checker", category='Features')
-    patchmatch          : bool = Field(default=True, description="Enable/disable patchmatch inpaint code", category='Features')
-    restore             : bool = Field(default=True, description="Enable/disable face restoration code", category='Features')
-
-    always_use_cpu      : bool = Field(default=False, description="If true, use the CPU for rendering even if a GPU is available.", category='Memory/Performance')
-    free_gpu_mem        : bool = Field(default=False, description="If true, purge model from GPU after each generation.", category='Memory/Performance')
-    max_loaded_models   : int = Field(default=2, gt=0, description="Maximum number of models to keep in memory for rapid switching", category='Memory/Performance')
-    precision           : Literal[tuple(['auto','float16','float32','autocast'])] = Field(default='float16',description='Floating point precision', category='Memory/Performance')
-    sequential_guidance : bool = Field(default=False, description="Whether to calculate guidance in serial instead of in parallel, lowering memory requirements", category='Memory/Performance')
-    xformers_enabled    : bool = Field(default=True, description="Enable/disable memory-efficient attention", category='Memory/Performance')
-    tiled_decode        : bool = Field(default=False, description="Whether to enable tiled VAE decode (reduces memory consumption with some performance penalty)", category='Memory/Performance')
-
-    root                : Path = Field(default=_find_root(), description='InvokeAI runtime root directory', category='Paths')
-    autoconvert_dir     : Path = Field(default=None, description='Path to a directory of ckpt files to be converted into diffusers and imported on startup.', category='Paths')
-    conf_path           : Path = Field(default='configs/models.yaml', description='Path to models definition file', category='Paths')
-    models_dir          : Path = Field(default='./models', description='Path to the models directory', category='Paths')
-    legacy_conf_dir     : Path = Field(default='configs/stable-diffusion', description='Path to directory of legacy checkpoint config files', category='Paths')
-    db_dir              : Path = Field(default='databases', description='Path to InvokeAI databases directory', category='Paths')
-    outdir              : Path = Field(default='outputs', description='Default folder for output images', category='Paths')
-    from_file           : Path = Field(default=None, description='Take command input from the indicated file (command-line client only)', category='Paths')
-    use_memory_db       : bool = Field(default=False, description='Use in-memory database for storing image metadata', category='Paths')
-    
-    model               : str = Field(default='stable-diffusion-1.5', description='Initial model name', category='Models')
-    
-    log_handlers        : List[str] = Field(default=["console"], description='Log handler. Valid options are "console", "file=<path>", "syslog=path|address:host:port", "http=<url>"', category="Logging")
-    # note - would be better to read the log_format values from logging.py, but this creates circular dependencies issues
-    log_format          : Literal[tuple(['plain','color','syslog','legacy'])] = Field(default="color", description='Log format. Use "plain" for text-only, "color" for colorized output, "legacy" for 2.3-style logging and "syslog" for syslog-style', category="Logging")
-    log_level           : Literal[tuple(["debug","info","warning","error","critical"])] = Field(default="debug", description="Emit logging messages at this level or  higher", category="Logging")
-    #fmt: on
-
-    def parse_args(self, argv: List[str]=None, conf: DictConfig = None, clobber=False):
-        '''
-        Update settings with contents of init file, environment, and 
-        command-line settings.
-        :param conf: alternate Omegaconf dictionary object
-        :param argv: aternate sys.argv list
-        :param clobber: ovewrite any initialization parameters passed during initialization
-        '''
-        # Set the runtime root directory. We parse command-line switches here
-        # in order to pick up the --root_dir option.
-        super().parse_args(argv)
-        if conf is None:
-            try:
-                conf = OmegaConf.load(self.root_dir / INIT_FILE)
-            except:
-                pass
-        InvokeAISettings.initconf = conf
-        
-        # parse args again in order to pick up settings in configuration file
-        super().parse_args(argv)
-
-        if self.singleton_init and not clobber:
-            hints = get_type_hints(self.__class__)
-            for k in self.singleton_init:
-                setattr(self,k,parse_obj_as(hints[k],self.singleton_init[k]))
-
-    @classmethod
-    def get_config(cls,**kwargs)->InvokeAIAppConfig:
-        '''
-        This returns a singleton InvokeAIAppConfig configuration object.
-        '''
-        if cls.singleton_config is None \
-           or type(cls.singleton_config)!=cls \
-           or (kwargs and cls.singleton_init != kwargs):
-            cls.singleton_config = cls(**kwargs)
-            cls.singleton_init = kwargs
-        return cls.singleton_config
-        
-    @property
-    def root_path(self)->Path:
-        '''
-        Path to the runtime root directory
-        '''
-        if self.root:
-            return Path(self.root).expanduser()
-        else:
-            return self.find_root()
-
-    @property
-    def root_dir(self)->Path:
-        '''
-        Alias for above.
-        '''
-        return self.root_path
-
-    def _resolve(self,partial_path:Path)->Path:
-        return (self.root_path / partial_path).resolve()
-
-    @property
-    def init_file_path(self)->Path:
-        '''
-        Path to invokeai.yaml
-        '''
-        return self._resolve(INIT_FILE)
-
-    @property
-    def output_path(self)->Path:
-        '''
-        Path to defaults outputs directory.
-        '''
-        return self._resolve(self.outdir)
-
-    @property
-    def db_path(self)->Path:
-        '''
-        Path to the invokeai.db file.
-        '''
-        return self._resolve(self.db_dir) / DB_FILE
-
-    @property
-    def model_conf_path(self)->Path:
-        '''
-        Path to models configuration file.
-        '''
-        return self._resolve(self.conf_path)
-
-    @property
-    def legacy_conf_path(self)->Path:
-        '''
-        Path to directory of legacy configuration files (e.g. v1-inference.yaml)
-        '''
-        return self._resolve(self.legacy_conf_dir)
-
-    @property
-    def models_path(self)->Path:
-        '''
-        Path to the models directory
-        '''
-        return self._resolve(self.models_dir)
-
-    @property
-    def autoconvert_path(self)->Path:
-        '''
-        Path to the directory containing models to be imported automatically at startup.
-        '''
-        return self._resolve(self.autoconvert_dir) if self.autoconvert_dir else None
-
-    # the following methods support legacy calls leftover from the Globals era
-    @property
-    def full_precision(self)->bool:
-        """Return true if precision set to float32"""
-        return self.precision=='float32'
-
-    @property
-    def disable_xformers(self)->bool:
-        """Return true if xformers_enabled is false"""
-        return not self.xformers_enabled
-
-    @property
-    def try_patchmatch(self)->bool:
-        """Return true if patchmatch true"""
-        return self.patchmatch
-
-    @staticmethod
-    def find_root()->Path:
-        '''
-        Choose the runtime root directory when not specified on command line or
-        init file.
-        '''
-        return _find_root()
-
-
-class PagingArgumentParser(argparse.ArgumentParser):
-    '''
-    A custom ArgumentParser that uses pydoc to page its output.
-    It also supports reading defaults from an init file.
-    '''
-    def print_help(self, file=None):
-        text = self.format_help()
-        pydoc.pager(text)
-
-def get_invokeai_config(**kwargs)->InvokeAIAppConfig:
-    '''
-    Legacy function which returns InvokeAIAppConfig.get_config()
-    '''
-    return InvokeAIAppConfig.get_config(**kwargs)

invokeai/app/services/default_graphs.py

@@ -1,5 +1,4 @@
 from ..invocations.latent import LatentsToImageInvocation, NoiseInvocation, TextToLatentsInvocation
-from ..invocations.compel import CompelInvocation
 from ..invocations.params import ParamIntInvocation
 from .graph import Edge, EdgeConnection, ExposedNodeInput, ExposedNodeOutput, Graph, LibraryGraph
 from .item_storage import ItemStorageABC
@@ -17,45 +16,38 @@ def create_text_to_image() -> LibraryGraph:
             nodes={
                 'width': ParamIntInvocation(id='width', a=512),
                 'height': ParamIntInvocation(id='height', a=512),
-                'seed': ParamIntInvocation(id='seed', a=-1),
                 '3': NoiseInvocation(id='3'),
-                '4': CompelInvocation(id='4'),
-                '5': CompelInvocation(id='5'),
-                '6': TextToLatentsInvocation(id='6'),
-                '7': LatentsToImageInvocation(id='7'),
+                '4': TextToLatentsInvocation(id='4'),
+                '5': LatentsToImageInvocation(id='5')
             },
             edges=[
                 Edge(source=EdgeConnection(node_id='width', field='a'), destination=EdgeConnection(node_id='3', field='width')),
                 Edge(source=EdgeConnection(node_id='height', field='a'), destination=EdgeConnection(node_id='3', field='height')),
-                Edge(source=EdgeConnection(node_id='seed', field='a'), destination=EdgeConnection(node_id='3', field='seed')),
-                Edge(source=EdgeConnection(node_id='3', field='noise'), destination=EdgeConnection(node_id='6', field='noise')),
-                Edge(source=EdgeConnection(node_id='6', field='latents'), destination=EdgeConnection(node_id='7', field='latents')),
-                Edge(source=EdgeConnection(node_id='4', field='conditioning'), destination=EdgeConnection(node_id='6', field='positive_conditioning')),
-                Edge(source=EdgeConnection(node_id='5', field='conditioning'), destination=EdgeConnection(node_id='6', field='negative_conditioning')),
+                Edge(source=EdgeConnection(node_id='width', field='a'), destination=EdgeConnection(node_id='4', field='width')),
+                Edge(source=EdgeConnection(node_id='height', field='a'), destination=EdgeConnection(node_id='4', field='height')),
+                Edge(source=EdgeConnection(node_id='3', field='noise'), destination=EdgeConnection(node_id='4', field='noise')),
+                Edge(source=EdgeConnection(node_id='4', field='latents'), destination=EdgeConnection(node_id='5', field='latents')),
             ]
         ),
         exposed_inputs=[
-            ExposedNodeInput(node_path='4', field='prompt', alias='positive_prompt'),
-            ExposedNodeInput(node_path='5', field='prompt', alias='negative_prompt'),
+            ExposedNodeInput(node_path='4', field='prompt', alias='prompt'),
             ExposedNodeInput(node_path='width', field='a', alias='width'),
-            ExposedNodeInput(node_path='height', field='a', alias='height'),
-            ExposedNodeInput(node_path='seed', field='a', alias='seed'),
+            ExposedNodeInput(node_path='height', field='a', alias='height')
         ],
         exposed_outputs=[
-            ExposedNodeOutput(node_path='7', field='image', alias='image')
+            ExposedNodeOutput(node_path='5', field='image', alias='image')
         ])
 
 
 def create_system_graphs(graph_library: ItemStorageABC[LibraryGraph]) -> list[LibraryGraph]:
     """Creates the default system graphs, or adds new versions if the old ones don't match"""
-    
-    # TODO: Uncomment this when we are ready to fix this up to prevent breaking changes
+
     graphs: list[LibraryGraph] = list()
 
-    # text_to_image = graph_library.get(default_text_to_image_graph_id)
+    text_to_image = graph_library.get(default_text_to_image_graph_id)
     
-    # # TODO: Check if the graph is the same as the default one, and if not, update it
-    # #if text_to_image is None:
+    # TODO: Check if the graph is the same as the default one, and if not, update it
+    #if text_to_image is None:
     text_to_image = create_text_to_image()
     graph_library.set(text_to_image)
 

invokeai/app/services/events.py

@@ -1,10 +1,9 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
 from typing import Any
-from invokeai.app.models.image import ProgressImage
+from invokeai.app.api.models.images import ProgressImage
 from invokeai.app.util.misc import get_timestamp
-from invokeai.app.services.model_manager_service import BaseModelType, ModelType, SubModelType, ModelInfo
-from invokeai.app.models.exceptions import CanceledException
+
 
 class EventServiceBase:
     session_event: str = "session_event"
@@ -102,53 +101,3 @@ class EventServiceBase:
                 graph_execution_state_id=graph_execution_state_id,
             ),
         )
-
-    def emit_model_load_started (
-            self,
-            graph_execution_state_id: str,
-            node: dict,
-            source_node_id: str,
-            model_name: str,
-            base_model: BaseModelType,
-            model_type: ModelType,
-            submodel: SubModelType,
-    ) -> None:
-        """Emitted when a model is requested"""
-        self.__emit_session_event(
-            event_name="model_load_started",
-            payload=dict(
-                graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
-                model_name=model_name,
-                base_model=base_model,
-                model_type=model_type,
-                submodel=submodel,
-            ),
-        )
-
-    def emit_model_load_completed(
-            self,
-            graph_execution_state_id: str,
-            node: dict,
-            source_node_id: str,
-            model_name: str,
-            base_model: BaseModelType,
-            model_type: ModelType,
-            submodel: SubModelType,
-            model_info: ModelInfo,
-    ) -> None:
-        """Emitted when a model is correctly loaded (returns model info)"""
-        self.__emit_session_event(
-            event_name="model_load_completed",
-            payload=dict(
-                graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
-                model_name=model_name,
-                base_model=base_model,
-                model_type=model_type,
-                submodel=submodel,
-                model_info=model_info,
-            ),
-        )

invokeai/app/services/graph.py

@@ -60,33 +60,6 @@ def get_input_field(node: BaseInvocation, field: str) -> Any:
     node_input_field = node_inputs.get(field) or None
     return node_input_field
 
-from typing import Optional, Union, List, get_args
-
-def is_union_subtype(t1, t2):
-    t1_args = get_args(t1)
-    t2_args = get_args(t2)
-    if not t1_args:
-        # t1 is a single type
-        return t1 in t2_args
-    else:
-        # t1 is a Union, check that all of its types are in t2_args
-        return all(arg in t2_args for arg in t1_args)
-
-def is_list_or_contains_list(t):
-    t_args = get_args(t)
-
-    # If the type is a List
-    if get_origin(t) is list:
-        return True
-
-    # If the type is a Union
-    elif t_args:
-        # Check if any of the types in the Union is a List
-        for arg in t_args:
-            if get_origin(arg) is list:
-                return True
-    return False
-
 
 def are_connection_types_compatible(from_type: Any, to_type: Any) -> bool:
     if not from_type:
@@ -112,8 +85,7 @@ def are_connection_types_compatible(from_type: Any, to_type: Any) -> bool:
         if to_type in get_args(from_type):
             return True
 
-        # if not issubclass(from_type, to_type):
-        if not is_union_subtype(from_type, to_type):
+        if not issubclass(from_type, to_type):
             return False
     else:
         return False
@@ -163,7 +135,6 @@ class GraphInvocationOutput(BaseInvocationOutput):
 
 # TODO: Fill this out and move to invocations
 class GraphInvocation(BaseInvocation):
-    """Execute a graph"""
     type: Literal["graph"] = "graph"
 
     # TODO: figure out how to create a default here
@@ -191,7 +162,6 @@ class IterateInvocationOutput(BaseInvocationOutput):
 
 # TODO: Fill this out and move to invocations
 class IterateInvocation(BaseInvocation):
-    """Iterates over a list of items"""
     type: Literal["iterate"] = "iterate"
 
     collection: list[Any] = Field(
@@ -391,7 +361,7 @@ class Graph(BaseModel):
             from_node = self.get_node(edge.source.node_id)
             to_node = self.get_node(edge.destination.node_id)
         except NodeNotFoundError:
-            raise InvalidEdgeError("One or both nodes don't exist: {edge.source.node_id} -> {edge.destination.node_id}")
+            raise InvalidEdgeError("One or both nodes don't exist")
 
         # Validate that an edge to this node+field doesn't already exist
         input_edges = self._get_input_edges(edge.destination.node_id, edge.destination.field)
@@ -402,41 +372,41 @@ class Graph(BaseModel):
         g = self.nx_graph_flat()
         g.add_edge(edge.source.node_id, edge.destination.node_id)
         if not nx.is_directed_acyclic_graph(g):
-            raise InvalidEdgeError(f'Edge creates a cycle in the graph: {edge.source.node_id} -> {edge.destination.node_id}')
+            raise InvalidEdgeError(f'Edge creates a cycle in the graph')
 
         # Validate that the field types are compatible
         if not are_connections_compatible(
             from_node, edge.source.field, to_node, edge.destination.field
         ):
-            raise InvalidEdgeError(f'Fields are incompatible: cannot connect {edge.source.node_id}.{edge.source.field} to {edge.destination.node_id}.{edge.destination.field}')
+            raise InvalidEdgeError(f'Fields are incompatible')
 
         # Validate if iterator output type matches iterator input type (if this edge results in both being set)
         if isinstance(to_node, IterateInvocation) and edge.destination.field == "collection":
             if not self._is_iterator_connection_valid(
                 edge.destination.node_id, new_input=edge.source
             ):
-                raise InvalidEdgeError(f'Iterator input type does not match iterator output type: {edge.source.node_id}.{edge.source.field} to {edge.destination.node_id}.{edge.destination.field}')
+                raise InvalidEdgeError(f'Iterator input type does not match iterator output type')
 
         # Validate if iterator input type matches output type (if this edge results in both being set)
         if isinstance(from_node, IterateInvocation) and edge.source.field == "item":
             if not self._is_iterator_connection_valid(
                 edge.source.node_id, new_output=edge.destination
             ):
-                raise InvalidEdgeError(f'Iterator output type does not match iterator input type:, {edge.source.node_id}.{edge.source.field} to {edge.destination.node_id}.{edge.destination.field}')
+                raise InvalidEdgeError(f'Iterator output type does not match iterator input type')
 
         # Validate if collector input type matches output type (if this edge results in both being set)
         if isinstance(to_node, CollectInvocation) and edge.destination.field == "item":
             if not self._is_collector_connection_valid(
                 edge.destination.node_id, new_input=edge.source
             ):
-                raise InvalidEdgeError(f'Collector output type does not match collector input type: {edge.source.node_id}.{edge.source.field} to {edge.destination.node_id}.{edge.destination.field}')
+                raise InvalidEdgeError(f'Collector output type does not match collector input type')
 
         # Validate if collector output type matches input type (if this edge results in both being set)
         if isinstance(from_node, CollectInvocation) and edge.source.field == "collection":
             if not self._is_collector_connection_valid(
                 edge.source.node_id, new_output=edge.destination
             ):
-                raise InvalidEdgeError(f'Collector input type does not match collector output type: {edge.source.node_id}.{edge.source.field} to {edge.destination.node_id}.{edge.destination.field}')
+                raise InvalidEdgeError(f'Collector input type does not match collector output type')
 
 
     def has_node(self, node_path: str) -> bool:
@@ -722,11 +692,7 @@ class Graph(BaseModel):
         input_root_type = next(t[0] for t in type_degrees if t[1] == 0)  # type: ignore
 
         # Verify that all outputs are lists
-        # if not all((get_origin(f) == list for f in output_fields)):
-        #     return False
-
-        # Verify that all outputs are lists
-        if not all(is_list_or_contains_list(f) for f in output_fields):
+        if not all((get_origin(f) == list for f in output_fields)):
             return False
 
         # Verify that all outputs match the input type (are a base class or the same class)
@@ -745,13 +711,6 @@ class Graph(BaseModel):
         g.add_edges_from(set([(e.source.node_id, e.destination.node_id) for e in self.edges]))
         return g
 
-    def nx_graph_with_data(self) -> nx.DiGraph:
-        """Returns a NetworkX DiGraph representing the data and layout of this graph"""
-        g = nx.DiGraph()
-        g.add_nodes_from([n for n in self.nodes.items()])
-        g.add_edges_from(set([(e.source.node_id, e.destination.node_id) for e in self.edges]))
-        return g
-
     def nx_graph_flat(
         self, nx_graph: Optional[nx.DiGraph] = None, prefix: Optional[str] = None
     ) -> nx.DiGraph:
@@ -857,9 +816,11 @@ class GraphExecutionState(BaseModel):
         if next_node is None:
             prepared_id = self._prepare()
 
-            # Prepare as many nodes as we can
-            while prepared_id is not None:
-                prepared_id = self._prepare()
+            # TODO: prepare multiple nodes at once?
+            # while prepared_id is not None and not isinstance(self.graph.nodes[prepared_id], IterateInvocation):
+            #     prepared_id = self._prepare()
+
+            if prepared_id is not None:
                 next_node = self._get_next_node()
 
         # Get values from edges
@@ -1006,30 +967,14 @@ class GraphExecutionState(BaseModel):
         # Get flattened source graph
         g = self.graph.nx_graph_flat()
 
-        # Find next node that:
-        # - was not already prepared
-        # - is not an iterate node whose inputs have not been executed
-        # - does not have an unexecuted iterate ancestor
+        # Find next unprepared node where all source nodes are executed
         sorted_nodes = nx.topological_sort(g)
         next_node_id = next(
             (
                 n
                 for n in sorted_nodes
-                # exclude nodes that have already been prepared
                 if n not in self.source_prepared_mapping
-                # exclude iterate nodes whose inputs have not been executed
-                and not (
-                    isinstance(self.graph.get_node(n), IterateInvocation)  # `n` is an iterate node...
-                    and not all((e[0] in self.executed for e in g.in_edges(n)))  # ...that has unexecuted inputs
-                )
-                # exclude nodes who have unexecuted iterate ancestors
-                and not any(
-                    (
-                        isinstance(self.graph.get_node(a), IterateInvocation)  # `a` is an iterate ancestor of `n`...
-                        and a not in self.executed  # ...that is not executed
-                        for a in nx.ancestors(g, n)  # for all ancestors `a` of node `n`
-                    )
-                )
+                and all((e[0] in self.executed for e in g.in_edges(n)))
             ),
             None,
         )
@@ -1126,22 +1071,9 @@ class GraphExecutionState(BaseModel):
         )
 
     def _get_next_node(self) -> Optional[BaseInvocation]:
-        """Gets the deepest node that is ready to be executed"""
         g = self.execution_graph.nx_graph()
-
-        # Depth-first search with pre-order traversal is a depth-first topological sort
-        sorted_nodes = nx.dfs_preorder_nodes(g)
-        
-        next_node = next(
-            (
-                n
-                for n in sorted_nodes
-                if n not in self.executed # the node must not already be executed...
-                and all((e[0] in self.executed for e in g.in_edges(n))) # ...and all its inputs must be executed
-            ),
-            None,
-        )
-
+        sorted_nodes = nx.topological_sort(g)
+        next_node = next((n for n in sorted_nodes if n not in self.executed), None)
         if next_node is None:
             return None
 

invokeai/app/services/image_file_storage.py

@@ -1,186 +0,0 @@
-# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654) and the InvokeAI Team
-from abc import ABC, abstractmethod
-from pathlib import Path
-from queue import Queue
-from typing import Dict, Optional
-
-from PIL.Image import Image as PILImageType
-from PIL import Image, PngImagePlugin
-from send2trash import send2trash
-
-from invokeai.app.models.image import ResourceOrigin
-from invokeai.app.models.metadata import ImageMetadata
-from invokeai.app.util.thumbnails import get_thumbnail_name, make_thumbnail
-
-
-# TODO: Should these excpetions subclass existing python exceptions?
-class ImageFileNotFoundException(Exception):
-    """Raised when an image file is not found in storage."""
-
-    def __init__(self, message="Image file not found"):
-        super().__init__(message)
-
-
-class ImageFileSaveException(Exception):
-    """Raised when an image cannot be saved."""
-
-    def __init__(self, message="Image file not saved"):
-        super().__init__(message)
-
-
-class ImageFileDeleteException(Exception):
-    """Raised when an image cannot be deleted."""
-
-    def __init__(self, message="Image file not deleted"):
-        super().__init__(message)
-
-
-class ImageFileStorageBase(ABC):
-    """Low-level service responsible for storing and retrieving image files."""
-
-    @abstractmethod
-    def get(self, image_name: str) -> PILImageType:
-        """Retrieves an image as PIL Image."""
-        pass
-
-    @abstractmethod
-    def get_path(self, image_name: str, thumbnail: bool = False) -> str:
-        """Gets the internal path to an image or thumbnail."""
-        pass
-
-    # TODO: We need to validate paths before starlette makes the FileResponse, else we get a
-    # 500 internal server error. I don't like having this method on the service.
-    @abstractmethod
-    def validate_path(self, path: str) -> bool:
-        """Validates the path given for an image or thumbnail."""
-        pass
-
-    @abstractmethod
-    def save(
-        self,
-        image: PILImageType,
-        image_name: str,
-        metadata: Optional[ImageMetadata] = None,
-        thumbnail_size: int = 256,
-    ) -> None:
-        """Saves an image and a 256x256 WEBP thumbnail. Returns a tuple of the image name, thumbnail name, and created timestamp."""
-        pass
-
-    @abstractmethod
-    def delete(self, image_name: str) -> None:
-        """Deletes an image and its thumbnail (if one exists)."""
-        pass
-
-
-class DiskImageFileStorage(ImageFileStorageBase):
-    """Stores images on disk"""
-
-    __output_folder: Path
-    __cache_ids: Queue  # TODO: this is an incredibly naive cache
-    __cache: Dict[Path, PILImageType]
-    __max_cache_size: int
-
-    def __init__(self, output_folder: str | Path):
-        self.__cache = dict()
-        self.__cache_ids = Queue()
-        self.__max_cache_size = 10  # TODO: get this from config
-
-        self.__output_folder: Path = output_folder if isinstance(output_folder, Path) else Path(output_folder)
-        self.__thumbnails_folder = self.__output_folder / 'thumbnails'
-
-        # Validate required output folders at launch
-        self.__validate_storage_folders()
-
-    def get(self, image_name: str) -> PILImageType:
-        try:
-            image_path = self.get_path(image_name)
-            
-            cache_item = self.__get_cache(image_path)
-            if cache_item:
-                return cache_item
-
-            image = Image.open(image_path)
-            self.__set_cache(image_path, image)
-            return image
-        except FileNotFoundError as e:
-            raise ImageFileNotFoundException from e
-
-    def save(
-        self,
-        image: PILImageType,
-        image_name: str,
-        metadata: Optional[ImageMetadata] = None,
-        thumbnail_size: int = 256,
-    ) -> None:
-        try:
-            self.__validate_storage_folders()
-            image_path = self.get_path(image_name)
-
-            if metadata is not None:
-                pnginfo = PngImagePlugin.PngInfo()
-                pnginfo.add_text("invokeai", metadata.json())
-                image.save(image_path, "PNG", pnginfo=pnginfo)
-            else:
-                image.save(image_path, "PNG")
-
-            thumbnail_name = get_thumbnail_name(image_name)
-            thumbnail_path = self.get_path(thumbnail_name, thumbnail=True)
-            thumbnail_image = make_thumbnail(image, thumbnail_size)
-            thumbnail_image.save(thumbnail_path)
-
-            self.__set_cache(image_path, image)
-            self.__set_cache(thumbnail_path, thumbnail_image)
-        except Exception as e:
-            raise ImageFileSaveException from e
-
-    def delete(self, image_name: str) -> None:
-        try:
-            image_path = self.get_path(image_name)
-
-            if image_path.exists():
-                send2trash(image_path)
-            if image_path in self.__cache:
-                del self.__cache[image_path]
-
-            thumbnail_name = get_thumbnail_name(image_name)
-            thumbnail_path = self.get_path(thumbnail_name, True)
-
-            if thumbnail_path.exists():
-                send2trash(thumbnail_path)
-            if thumbnail_path in self.__cache:
-                del self.__cache[thumbnail_path]
-        except Exception as e:
-            raise ImageFileDeleteException from e
-
-    # TODO: make this a bit more flexible for e.g. cloud storage
-    def get_path(self, image_name: str, thumbnail: bool = False) -> Path:
-        path = self.__output_folder / image_name
-        
-        if thumbnail:
-            thumbnail_name = get_thumbnail_name(image_name)
-            path = self.__thumbnails_folder / thumbnail_name
-
-        return path
-
-    def validate_path(self, path: str | Path) -> bool:
-        """Validates the path given for an image or thumbnail."""
-        path = path if isinstance(path, Path) else Path(path)
-        return path.exists()
-    
-    def __validate_storage_folders(self) -> None:
-        """Checks if the required output folders exist and create them if they don't"""
-        folders: list[Path] = [self.__output_folder, self.__thumbnails_folder]
-        for folder in folders:
-            folder.mkdir(parents=True, exist_ok=True)
-
-    def __get_cache(self, image_name: Path) -> PILImageType | None:
-        return None if image_name not in self.__cache else self.__cache[image_name]
-
-    def __set_cache(self, image_name: Path, image: PILImageType):
-        if not image_name in self.__cache:
-            self.__cache[image_name] = image
-            self.__cache_ids.put(image_name)  # TODO: this should refresh position for LRU cache
-            if len(self.__cache) > self.__max_cache_size:
-                cache_id = self.__cache_ids.get()
-                if cache_id in self.__cache:
-                    del self.__cache[cache_id]

invokeai/app/services/image_record_storage.py

@@ -1,475 +0,0 @@
-from abc import ABC, abstractmethod
-from datetime import datetime
-from typing import Generic, Optional, TypeVar, cast
-import sqlite3
-import threading
-from typing import Optional, Union
-
-from pydantic import BaseModel, Field
-from pydantic.generics import GenericModel
-
-from invokeai.app.models.metadata import ImageMetadata
-from invokeai.app.models.image import (
-    ImageCategory,
-    ResourceOrigin,
-)
-from invokeai.app.services.models.image_record import (
-    ImageRecord,
-    ImageRecordChanges,
-    deserialize_image_record,
-)
-
-T = TypeVar("T", bound=BaseModel)
-
-
-class OffsetPaginatedResults(GenericModel, Generic[T]):
-    """Offset-paginated results"""
-
-    # fmt: off
-    items: list[T] = Field(description="Items")
-    offset: int = Field(description="Offset from which to retrieve items")
-    limit: int = Field(description="Limit of items to get")
-    total: int = Field(description="Total number of items in result")
-    # fmt: on
-
-
-# TODO: Should these excpetions subclass existing python exceptions?
-class ImageRecordNotFoundException(Exception):
-    """Raised when an image record is not found."""
-
-    def __init__(self, message="Image record not found"):
-        super().__init__(message)
-
-
-class ImageRecordSaveException(Exception):
-    """Raised when an image record cannot be saved."""
-
-    def __init__(self, message="Image record not saved"):
-        super().__init__(message)
-
-
-class ImageRecordDeleteException(Exception):
-    """Raised when an image record cannot be deleted."""
-
-    def __init__(self, message="Image record not deleted"):
-        super().__init__(message)
-
-
-class ImageRecordStorageBase(ABC):
-    """Low-level service responsible for interfacing with the image record store."""
-
-    # TODO: Implement an `update()` method
-
-    @abstractmethod
-    def get(self, image_name: str) -> ImageRecord:
-        """Gets an image record."""
-        pass
-
-    @abstractmethod
-    def update(
-        self,
-        image_name: str,
-        changes: ImageRecordChanges,
-    ) -> None:
-        """Updates an image record."""
-        pass
-
-    @abstractmethod
-    def get_many(
-        self,
-        offset: int = 0,
-        limit: int = 10,
-        image_origin: Optional[ResourceOrigin] = None,
-        categories: Optional[list[ImageCategory]] = None,
-        is_intermediate: Optional[bool] = None,
-        board_id: Optional[str] = None,
-    ) -> OffsetPaginatedResults[ImageRecord]:
-        """Gets a page of image records."""
-        pass
-
-    # TODO: The database has a nullable `deleted_at` column, currently unused.
-    # Should we implement soft deletes? Would need coordination with ImageFileStorage.
-    @abstractmethod
-    def delete(self, image_name: str) -> None:
-        """Deletes an image record."""
-        pass
-
-    @abstractmethod
-    def save(
-        self,
-        image_name: str,
-        image_origin: ResourceOrigin,
-        image_category: ImageCategory,
-        width: int,
-        height: int,
-        session_id: Optional[str],
-        node_id: Optional[str],
-        metadata: Optional[ImageMetadata],
-        is_intermediate: bool = False,
-    ) -> datetime:
-        """Saves an image record."""
-        pass
-
-    @abstractmethod
-    def get_most_recent_image_for_board(self, board_id: str) -> ImageRecord | None:
-        """Gets the most recent image for a board."""
-        pass
-
-
-class SqliteImageRecordStorage(ImageRecordStorageBase):
-    _filename: str
-    _conn: sqlite3.Connection
-    _cursor: sqlite3.Cursor
-    _lock: threading.Lock
-
-    def __init__(self, filename: str) -> None:
-        super().__init__()
-        self._filename = filename
-        self._conn = sqlite3.connect(filename, check_same_thread=False)
-        # Enable row factory to get rows as dictionaries (must be done before making the cursor!)
-        self._conn.row_factory = sqlite3.Row
-        self._cursor = self._conn.cursor()
-        self._lock = threading.Lock()
-
-        try:
-            self._lock.acquire()
-            # Enable foreign keys
-            self._conn.execute("PRAGMA foreign_keys = ON;")
-            self._create_tables()
-            self._conn.commit()
-        finally:
-            self._lock.release()
-
-    def _create_tables(self) -> None:
-        """Creates the `images` table."""
-
-        # Create the `images` table.
-        self._cursor.execute(
-            """--sql
-            CREATE TABLE IF NOT EXISTS images (
-                image_name TEXT NOT NULL PRIMARY KEY,
-                -- This is an enum in python, unrestricted string here for flexibility
-                image_origin TEXT NOT NULL,
-                -- This is an enum in python, unrestricted string here for flexibility
-                image_category TEXT NOT NULL,
-                width INTEGER NOT NULL,
-                height INTEGER NOT NULL,
-                session_id TEXT,
-                node_id TEXT,
-                metadata TEXT,
-                is_intermediate BOOLEAN DEFAULT FALSE,
-                board_id TEXT,
-                created_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
-                -- Updated via trigger
-                updated_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
-                -- Soft delete, currently unused
-                deleted_at DATETIME
-            );
-            """
-        )
-
-        # Create the `images` table indices.
-        self._cursor.execute(
-            """--sql
-            CREATE UNIQUE INDEX IF NOT EXISTS idx_images_image_name ON images(image_name);
-            """
-        )
-        self._cursor.execute(
-            """--sql
-            CREATE INDEX IF NOT EXISTS idx_images_image_origin ON images(image_origin);
-            """
-        )
-        self._cursor.execute(
-            """--sql
-            CREATE INDEX IF NOT EXISTS idx_images_image_category ON images(image_category);
-            """
-        )
-        self._cursor.execute(
-            """--sql
-            CREATE INDEX IF NOT EXISTS idx_images_created_at ON images(created_at);
-            """
-        )
-
-        # Add trigger for `updated_at`.
-        self._cursor.execute(
-            """--sql
-            CREATE TRIGGER IF NOT EXISTS tg_images_updated_at
-            AFTER UPDATE
-            ON images FOR EACH ROW
-            BEGIN
-                UPDATE images SET updated_at = STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')
-                    WHERE image_name = old.image_name;
-            END;
-            """
-        )
-
-    def get(self, image_name: str) -> Union[ImageRecord, None]:
-        try:
-            self._lock.acquire()
-
-            self._cursor.execute(
-                f"""--sql
-                SELECT * FROM images
-                WHERE image_name = ?;
-                """,
-                (image_name,),
-            )
-
-            result = cast(Union[sqlite3.Row, None], self._cursor.fetchone())
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise ImageRecordNotFoundException from e
-        finally:
-            self._lock.release()
-
-        if not result:
-            raise ImageRecordNotFoundException
-
-        return deserialize_image_record(dict(result))
-
-    def update(
-        self,
-        image_name: str,
-        changes: ImageRecordChanges,
-    ) -> None:
-        try:
-            self._lock.acquire()
-            # Change the category of the image
-            if changes.image_category is not None:
-                self._cursor.execute(
-                    f"""--sql
-                    UPDATE images
-                    SET image_category = ?
-                    WHERE image_name = ?;
-                    """,
-                    (changes.image_category, image_name),
-                )
-
-            # Change the session associated with the image
-            if changes.session_id is not None:
-                self._cursor.execute(
-                    f"""--sql
-                    UPDATE images
-                    SET session_id = ?
-                    WHERE image_name = ?;
-                    """,
-                    (changes.session_id, image_name),
-                )
-
-            # Change the image's `is_intermediate`` flag
-            if changes.is_intermediate is not None:
-                self._cursor.execute(
-                    f"""--sql
-                    UPDATE images
-                    SET is_intermediate = ?
-                    WHERE image_name = ?;
-                    """,
-                    (changes.is_intermediate, image_name),
-                )
-
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise ImageRecordSaveException from e
-        finally:
-            self._lock.release()
-
-    def get_many(
-        self,
-        offset: int = 0,
-        limit: int = 10,
-        image_origin: Optional[ResourceOrigin] = None,
-        categories: Optional[list[ImageCategory]] = None,
-        is_intermediate: Optional[bool] = None,
-        board_id: Optional[str] = None,
-    ) -> OffsetPaginatedResults[ImageRecord]:
-        try:
-            self._lock.acquire()
-
-            # Manually build two queries - one for the count, one for the records
-            count_query = """--sql
-            SELECT COUNT(*)
-            FROM images
-            LEFT JOIN board_images ON board_images.image_name = images.image_name
-            WHERE 1=1
-            """
-
-            images_query = """--sql
-            SELECT images.*
-            FROM images
-            LEFT JOIN board_images ON board_images.image_name = images.image_name
-            WHERE 1=1
-            """
-
-            query_conditions = ""
-            query_params = []
-
-            if image_origin is not None:
-                query_conditions += """--sql
-                AND images.image_origin = ?
-                """
-                query_params.append(image_origin.value)
-
-            if categories is not None:
-                # Convert the enum values to unique list of strings
-                category_strings = list(map(lambda c: c.value, set(categories)))
-                # Create the correct length of placeholders
-                placeholders = ",".join("?" * len(category_strings))
-
-                query_conditions += f"""--sql
-                AND images.image_category IN ( {placeholders} )
-                """
-
-                # Unpack the included categories into the query params
-                for c in category_strings:
-                    query_params.append(c)
-
-            if is_intermediate is not None:
-                query_conditions += """--sql
-                AND images.is_intermediate = ?
-                """
-
-                query_params.append(is_intermediate)
-
-            if board_id is not None:
-                query_conditions += """--sql
-                AND board_images.board_id = ?
-                """
-
-                query_params.append(board_id)
-
-            query_pagination = """--sql
-            ORDER BY images.created_at DESC LIMIT ? OFFSET ?
-            """
-
-            # Final images query with pagination
-            images_query += query_conditions + query_pagination + ";"
-            # Add all the parameters
-            images_params = query_params.copy()
-            images_params.append(limit)
-            images_params.append(offset)
-            # Build the list of images, deserializing each row
-            self._cursor.execute(images_query, images_params)
-            result = cast(list[sqlite3.Row], self._cursor.fetchall())
-            images = list(map(lambda r: deserialize_image_record(dict(r)), result))
-
-            # Set up and execute the count query, without pagination
-            count_query += query_conditions + ";"
-            count_params = query_params.copy()
-            self._cursor.execute(count_query, count_params)
-            count = cast(int, self._cursor.fetchone()[0])
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise e
-        finally:
-            self._lock.release()
-
-        return OffsetPaginatedResults(
-            items=images, offset=offset, limit=limit, total=count
-        )
-
-    def delete(self, image_name: str) -> None:
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                DELETE FROM images
-                WHERE image_name = ?;
-                """,
-                (image_name,),
-            )
-            self._conn.commit()
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise ImageRecordDeleteException from e
-        finally:
-            self._lock.release()
-
-    def save(
-        self,
-        image_name: str,
-        image_origin: ResourceOrigin,
-        image_category: ImageCategory,
-        session_id: Optional[str],
-        width: int,
-        height: int,
-        node_id: Optional[str],
-        metadata: Optional[ImageMetadata],
-        is_intermediate: bool = False,
-    ) -> datetime:
-        try:
-            metadata_json = (
-                None if metadata is None else metadata.json(exclude_none=True)
-            )
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                INSERT OR IGNORE INTO images (
-                    image_name,
-                    image_origin,
-                    image_category,
-                    width,
-                    height,
-                    node_id,
-                    session_id,
-                    metadata,
-                    is_intermediate
-                    )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
-                """,
-                (
-                    image_name,
-                    image_origin.value,
-                    image_category.value,
-                    width,
-                    height,
-                    node_id,
-                    session_id,
-                    metadata_json,
-                    is_intermediate,
-                ),
-            )
-            self._conn.commit()
-
-            self._cursor.execute(
-                """--sql
-                SELECT created_at
-                FROM images
-                WHERE image_name = ?;
-                """,
-                (image_name,),
-            )
-
-            created_at = datetime.fromisoformat(self._cursor.fetchone()[0])
-
-            return created_at
-        except sqlite3.Error as e:
-            self._conn.rollback()
-            raise ImageRecordSaveException from e
-        finally:
-            self._lock.release()
-
-    def get_most_recent_image_for_board(
-        self, board_id: str
-    ) -> Union[ImageRecord, None]:
-        try:
-            self._lock.acquire()
-            self._cursor.execute(
-                """--sql
-                SELECT images.*
-                FROM images
-                JOIN board_images ON images.image_name = board_images.image_name
-                WHERE board_images.board_id = ?
-                ORDER BY images.created_at DESC
-                LIMIT 1;
-                """,
-                (board_id,),
-            )
-
-            result = cast(Union[sqlite3.Row, None], self._cursor.fetchone())
-        finally:
-            self._lock.release()
-        if result is None:
-            return None
-
-        return deserialize_image_record(dict(result))

invokeai/app/services/image_storage.py

@@ -0,0 +1,238 @@
+# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
+
+import os
+from glob import glob
+from abc import ABC, abstractmethod
+from pathlib import Path
+from queue import Queue
+from typing import Dict, List, Tuple
+
+from PIL.Image import Image
+import PIL.Image as PILImage
+from invokeai.app.api.models.images import ImageResponse, ImageResponseMetadata
+from invokeai.app.models.image import ImageType
+from invokeai.app.services.metadata import (
+    InvokeAIMetadata,
+    MetadataServiceBase,
+    build_invokeai_metadata_pnginfo,
+)
+from invokeai.app.services.item_storage import PaginatedResults
+from invokeai.app.util.misc import get_timestamp
+from invokeai.app.util.thumbnails import get_thumbnail_name, make_thumbnail
+
+
+class ImageStorageBase(ABC):
+    """Responsible for storing and retrieving images."""
+
+    @abstractmethod
+    def get(self, image_type: ImageType, image_name: str) -> Image:
+        """Retrieves an image as PIL Image."""
+        pass
+
+    @abstractmethod
+    def list(
+        self, image_type: ImageType, page: int = 0, per_page: int = 10
+    ) -> PaginatedResults[ImageResponse]:
+        """Gets a paginated list of images."""
+        pass
+
+    # TODO: make this a bit more flexible for e.g. cloud storage
+    @abstractmethod
+    def get_path(
+        self, image_type: ImageType, image_name: str, is_thumbnail: bool = False
+    ) -> str:
+        """Gets the path to an image or its thumbnail."""
+        pass
+
+    # TODO: make this a bit more flexible for e.g. cloud storage
+    @abstractmethod
+    def validate_path(self, path: str) -> bool:
+        """Validates an image path."""
+        pass
+
+    @abstractmethod
+    def save(
+        self,
+        image_type: ImageType,
+        image_name: str,
+        image: Image,
+        metadata: InvokeAIMetadata | None = None,
+    ) -> Tuple[str, str, int]:
+        """Saves an image and a 256x256 WEBP thumbnail. Returns a tuple of the image path, thumbnail path, and created timestamp."""
+        pass
+
+    @abstractmethod
+    def delete(self, image_type: ImageType, image_name: str) -> None:
+        """Deletes an image and its thumbnail (if one exists)."""
+        pass
+
+    def create_name(self, context_id: str, node_id: str) -> str:
+        """Creates a unique contextual image filename."""
+        return f"{context_id}_{node_id}_{str(get_timestamp())}.png"
+
+
+class DiskImageStorage(ImageStorageBase):
+    """Stores images on disk"""
+
+    __output_folder: str
+    __cache_ids: Queue  # TODO: this is an incredibly naive cache
+    __cache: Dict[str, Image]
+    __max_cache_size: int
+    __metadata_service: MetadataServiceBase
+
+    def __init__(self, output_folder: str, metadata_service: MetadataServiceBase):
+        self.__output_folder = output_folder
+        self.__cache = dict()
+        self.__cache_ids = Queue()
+        self.__max_cache_size = 10  # TODO: get this from config
+        self.__metadata_service = metadata_service
+
+        Path(output_folder).mkdir(parents=True, exist_ok=True)
+
+        # TODO: don't hard-code. get/save/delete should maybe take subpath?
+        for image_type in ImageType:
+            Path(os.path.join(output_folder, image_type)).mkdir(
+                parents=True, exist_ok=True
+            )
+            Path(os.path.join(output_folder, image_type, "thumbnails")).mkdir(
+                parents=True, exist_ok=True
+            )
+
+    def list(
+        self, image_type: ImageType, page: int = 0, per_page: int = 10
+    ) -> PaginatedResults[ImageResponse]:
+        dir_path = os.path.join(self.__output_folder, image_type)
+        image_paths = glob(f"{dir_path}/*.png")
+        count = len(image_paths)
+
+        sorted_image_paths = sorted(
+            glob(f"{dir_path}/*.png"), key=os.path.getctime, reverse=True
+        )
+
+        page_of_image_paths = sorted_image_paths[
+            page * per_page : (page + 1) * per_page
+        ]
+
+        page_of_images: List[ImageResponse] = []
+
+        for path in page_of_image_paths:
+            filename = os.path.basename(path)
+            img = PILImage.open(path)
+
+            invokeai_metadata = self.__metadata_service.get_metadata(img)
+
+            page_of_images.append(
+                ImageResponse(
+                    image_type=image_type.value,
+                    image_name=filename,
+                    # TODO: DiskImageStorage should not be building URLs...?
+                    image_url=f"api/v1/images/{image_type.value}/{filename}",
+                    thumbnail_url=f"api/v1/images/{image_type.value}/thumbnails/{os.path.splitext(filename)[0]}.webp",
+                    # TODO: Creation of this object should happen elsewhere (?), just making it fit here so it works
+                    metadata=ImageResponseMetadata(
+                        created=int(os.path.getctime(path)),
+                        width=img.width,
+                        height=img.height,
+                        invokeai=invokeai_metadata,
+                    ),
+                )
+            )
+
+        page_count_trunc = int(count / per_page)
+        page_count_mod = count % per_page
+        page_count = page_count_trunc if page_count_mod == 0 else page_count_trunc + 1
+
+        return PaginatedResults[ImageResponse](
+            items=page_of_images,
+            page=page,
+            pages=page_count,
+            per_page=per_page,
+            total=count,
+        )
+
+    def get(self, image_type: ImageType, image_name: str) -> Image:
+        image_path = self.get_path(image_type, image_name)
+        cache_item = self.__get_cache(image_path)
+        if cache_item:
+            return cache_item
+
+        image = PILImage.open(image_path)
+        self.__set_cache(image_path, image)
+        return image
+
+    # TODO: make this a bit more flexible for e.g. cloud storage
+    def get_path(
+        self, image_type: ImageType, image_name: str, is_thumbnail: bool = False
+    ) -> str:
+        # strip out any relative path shenanigans
+        basename = os.path.basename(image_name)
+
+        if is_thumbnail:
+            path = os.path.join(
+                self.__output_folder, image_type, "thumbnails", basename
+            )
+        else:
+            path = os.path.join(self.__output_folder, image_type, basename)
+
+        return path
+
+    def validate_path(self, path: str) -> bool:
+        try:
+            os.stat(path)
+            return True
+        except Exception:
+            return False
+
+    def save(
+        self,
+        image_type: ImageType,
+        image_name: str,
+        image: Image,
+        metadata: InvokeAIMetadata | None = None,
+    ) -> Tuple[str, str, int]:
+        image_path = self.get_path(image_type, image_name)
+
+        # TODO: Reading the image and then saving it strips the metadata...
+        if metadata:
+            pnginfo = build_invokeai_metadata_pnginfo(metadata=metadata)
+            image.save(image_path, "PNG", pnginfo=pnginfo)
+        else:
+            image.save(image_path) # this saved image has an empty info
+
+        thumbnail_name = get_thumbnail_name(image_name)
+        thumbnail_path = self.get_path(image_type, thumbnail_name, is_thumbnail=True)
+        thumbnail_image = make_thumbnail(image)
+        thumbnail_image.save(thumbnail_path)
+
+        self.__set_cache(image_path, image)
+        self.__set_cache(thumbnail_path, thumbnail_image)
+
+        return (image_path, thumbnail_path, int(os.path.getctime(image_path)))
+
+    def delete(self, image_type: ImageType, image_name: str) -> None:
+        image_path = self.get_path(image_type, image_name)
+        thumbnail_path = self.get_path(image_type, image_name, True)
+        if os.path.exists(image_path):
+            os.remove(image_path)
+
+        if image_path in self.__cache:
+            del self.__cache[image_path]
+
+        if os.path.exists(thumbnail_path):
+            os.remove(thumbnail_path)
+
+        if thumbnail_path in self.__cache:
+            del self.__cache[thumbnail_path]
+
+    def __get_cache(self, image_name: str) -> Image:
+        return None if image_name not in self.__cache else self.__cache[image_name]
+
+    def __set_cache(self, image_name: str, image: Image):
+        if not image_name in self.__cache:
+            self.__cache[image_name] = image
+            self.__cache_ids.put(
+                image_name
+            )  # TODO: this should refresh position for LRU cache
+            if len(self.__cache) > self.__max_cache_size:
+                cache_id = self.__cache_ids.get()
+                del self.__cache[cache_id]

invokeai/app/services/images.py

@@ -1,354 +0,0 @@
-from abc import ABC, abstractmethod
-from logging import Logger
-from typing import Optional, TYPE_CHECKING, Union
-from PIL.Image import Image as PILImageType
-
-from invokeai.app.models.image import (
-    ImageCategory,
-    ResourceOrigin,
-    InvalidImageCategoryException,
-    InvalidOriginException,
-)
-from invokeai.app.models.metadata import ImageMetadata
-from invokeai.app.services.board_image_record_storage import BoardImageRecordStorageBase
-from invokeai.app.services.image_record_storage import (
-    ImageRecordDeleteException,
-    ImageRecordNotFoundException,
-    ImageRecordSaveException,
-    ImageRecordStorageBase,
-    OffsetPaginatedResults,
-)
-from invokeai.app.services.models.image_record import (
-    ImageRecord,
-    ImageDTO,
-    ImageRecordChanges,
-    image_record_to_dto,
-)
-from invokeai.app.services.image_file_storage import (
-    ImageFileDeleteException,
-    ImageFileNotFoundException,
-    ImageFileSaveException,
-    ImageFileStorageBase,
-)
-from invokeai.app.services.item_storage import ItemStorageABC, PaginatedResults
-from invokeai.app.services.metadata import MetadataServiceBase
-from invokeai.app.services.resource_name import NameServiceBase
-from invokeai.app.services.urls import UrlServiceBase
-
-if TYPE_CHECKING:
-    from invokeai.app.services.graph import GraphExecutionState
-
-
-class ImageServiceABC(ABC):
-    """High-level service for image management."""
-
-    @abstractmethod
-    def create(
-        self,
-        image: PILImageType,
-        image_origin: ResourceOrigin,
-        image_category: ImageCategory,
-        node_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        is_intermediate: bool = False,
-    ) -> ImageDTO:
-        """Creates an image, storing the file and its metadata."""
-        pass
-
-    @abstractmethod
-    def update(
-        self,
-        image_name: str,
-        changes: ImageRecordChanges,
-    ) -> ImageDTO:
-        """Updates an image."""
-        pass
-
-    @abstractmethod
-    def get_pil_image(self, image_name: str) -> PILImageType:
-        """Gets an image as a PIL image."""
-        pass
-
-    @abstractmethod
-    def get_record(self, image_name: str) -> ImageRecord:
-        """Gets an image record."""
-        pass
-
-    @abstractmethod
-    def get_dto(self, image_name: str) -> ImageDTO:
-        """Gets an image DTO."""
-        pass
-
-    @abstractmethod
-    def get_path(self, image_name: str, thumbnail: bool = False) -> str:
-        """Gets an image's path."""
-        pass
-
-    @abstractmethod
-    def validate_path(self, path: str) -> bool:
-        """Validates an image's path."""
-        pass
-
-    @abstractmethod
-    def get_url(self, image_name: str, thumbnail: bool = False) -> str:
-        """Gets an image's or thumbnail's URL."""
-        pass
-
-    @abstractmethod
-    def get_many(
-        self,
-        offset: int = 0,
-        limit: int = 10,
-        image_origin: Optional[ResourceOrigin] = None,
-        categories: Optional[list[ImageCategory]] = None,
-        is_intermediate: Optional[bool] = None,
-        board_id: Optional[str] = None,
-    ) -> OffsetPaginatedResults[ImageDTO]:
-        """Gets a paginated list of image DTOs."""
-        pass
-
-    @abstractmethod
-    def delete(self, image_name: str):
-        """Deletes an image."""
-        pass
-
-
-class ImageServiceDependencies:
-    """Service dependencies for the ImageService."""
-
-    image_records: ImageRecordStorageBase
-    image_files: ImageFileStorageBase
-    board_image_records: BoardImageRecordStorageBase
-    metadata: MetadataServiceBase
-    urls: UrlServiceBase
-    logger: Logger
-    names: NameServiceBase
-    graph_execution_manager: ItemStorageABC["GraphExecutionState"]
-
-    def __init__(
-        self,
-        image_record_storage: ImageRecordStorageBase,
-        image_file_storage: ImageFileStorageBase,
-        board_image_record_storage: BoardImageRecordStorageBase,
-        metadata: MetadataServiceBase,
-        url: UrlServiceBase,
-        logger: Logger,
-        names: NameServiceBase,
-        graph_execution_manager: ItemStorageABC["GraphExecutionState"],
-    ):
-        self.image_records = image_record_storage
-        self.image_files = image_file_storage
-        self.board_image_records = board_image_record_storage
-        self.metadata = metadata
-        self.urls = url
-        self.logger = logger
-        self.names = names
-        self.graph_execution_manager = graph_execution_manager
-
-
-class ImageService(ImageServiceABC):
-    _services: ImageServiceDependencies
-
-    def __init__(self, services: ImageServiceDependencies):
-        self._services = services
-
-    def create(
-        self,
-        image: PILImageType,
-        image_origin: ResourceOrigin,
-        image_category: ImageCategory,
-        node_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        is_intermediate: bool = False,
-    ) -> ImageDTO:
-        if image_origin not in ResourceOrigin:
-            raise InvalidOriginException
-
-        if image_category not in ImageCategory:
-            raise InvalidImageCategoryException
-
-        image_name = self._services.names.create_image_name()
-
-        metadata = self._get_metadata(session_id, node_id)
-
-        (width, height) = image.size
-
-        try:
-            # TODO: Consider using a transaction here to ensure consistency between storage and database
-            self._services.image_records.save(
-                # Non-nullable fields
-                image_name=image_name,
-                image_origin=image_origin,
-                image_category=image_category,
-                width=width,
-                height=height,
-                # Meta fields
-                is_intermediate=is_intermediate,
-                # Nullable fields
-                node_id=node_id,
-                session_id=session_id,
-                metadata=metadata,
-            )
-
-            self._services.image_files.save(
-                image_name=image_name,
-                image=image,
-                metadata=metadata,
-            )
-
-            image_dto = self.get_dto(image_name)
-
-            return image_dto
-        except ImageRecordSaveException:
-            self._services.logger.error("Failed to save image record")
-            raise
-        except ImageFileSaveException:
-            self._services.logger.error("Failed to save image file")
-            raise
-        except Exception as e:
-            self._services.logger.error("Problem saving image record and file")
-            raise e
-
-    def update(
-        self,
-        image_name: str,
-        changes: ImageRecordChanges,
-    ) -> ImageDTO:
-        try:
-            self._services.image_records.update(image_name, changes)
-            return self.get_dto(image_name)
-        except ImageRecordSaveException:
-            self._services.logger.error("Failed to update image record")
-            raise
-        except Exception as e:
-            self._services.logger.error("Problem updating image record")
-            raise e
-
-    def get_pil_image(self, image_name: str) -> PILImageType:
-        try:
-            return self._services.image_files.get(image_name)
-        except ImageFileNotFoundException:
-            self._services.logger.error("Failed to get image file")
-            raise
-        except Exception as e:
-            self._services.logger.error("Problem getting image file")
-            raise e
-
-    def get_record(self, image_name: str) -> ImageRecord:
-        try:
-            return self._services.image_records.get(image_name)
-        except ImageRecordNotFoundException:
-            self._services.logger.error("Image record not found")
-            raise
-        except Exception as e:
-            self._services.logger.error("Problem getting image record")
-            raise e
-
-    def get_dto(self, image_name: str) -> ImageDTO:
-        try:
-            image_record = self._services.image_records.get(image_name)
-
-            image_dto = image_record_to_dto(
-                image_record,
-                self._services.urls.get_image_url(image_name),
-                self._services.urls.get_image_url(image_name, True),
-                self._services.board_image_records.get_board_for_image(image_name),
-            )
-
-            return image_dto
-        except ImageRecordNotFoundException:
-            self._services.logger.error("Image record not found")
-            raise
-        except Exception as e:
-            self._services.logger.error("Problem getting image DTO")
-            raise e
-
-    def get_path(self, image_name: str, thumbnail: bool = False) -> str:
-        try:
-            return self._services.image_files.get_path(image_name, thumbnail)
-        except Exception as e:
-            self._services.logger.error("Problem getting image path")
-            raise e
-
-    def validate_path(self, path: str) -> bool:
-        try:
-            return self._services.image_files.validate_path(path)
-        except Exception as e:
-            self._services.logger.error("Problem validating image path")
-            raise e
-
-    def get_url(self, image_name: str, thumbnail: bool = False) -> str:
-        try:
-            return self._services.urls.get_image_url(image_name, thumbnail)
-        except Exception as e:
-            self._services.logger.error("Problem getting image path")
-            raise e
-
-    def get_many(
-        self,
-        offset: int = 0,
-        limit: int = 10,
-        image_origin: Optional[ResourceOrigin] = None,
-        categories: Optional[list[ImageCategory]] = None,
-        is_intermediate: Optional[bool] = None,
-        board_id: Optional[str] = None,
-    ) -> OffsetPaginatedResults[ImageDTO]:
-        try:
-            results = self._services.image_records.get_many(
-                offset,
-                limit,
-                image_origin,
-                categories,
-                is_intermediate,
-                board_id,
-            )
-
-            image_dtos = list(
-                map(
-                    lambda r: image_record_to_dto(
-                        r,
-                        self._services.urls.get_image_url(r.image_name),
-                        self._services.urls.get_image_url(r.image_name, True),
-                        self._services.board_image_records.get_board_for_image(
-                            r.image_name
-                        ),
-                    ),
-                    results.items,
-                )
-            )
-
-            return OffsetPaginatedResults[ImageDTO](
-                items=image_dtos,
-                offset=results.offset,
-                limit=results.limit,
-                total=results.total,
-            )
-        except Exception as e:
-            self._services.logger.error("Problem getting paginated image DTOs")
-            raise e
-
-    def delete(self, image_name: str):
-        try:
-            self._services.image_files.delete(image_name)
-            self._services.image_records.delete(image_name)
-        except ImageRecordDeleteException:
-            self._services.logger.error(f"Failed to delete image record")
-            raise
-        except ImageFileDeleteException:
-            self._services.logger.error(f"Failed to delete image file")
-            raise
-        except Exception as e:
-            self._services.logger.error("Problem deleting image record and file")
-            raise e
-
-    def _get_metadata(
-        self, session_id: Optional[str] = None, node_id: Optional[str] = None
-    ) -> Union[ImageMetadata, None]:
-        """Get the metadata for a node."""
-        metadata = None
-
-        if node_id is not None and session_id is not None:
-            session = self._services.graph_execution_manager.get(session_id)
-            metadata = self._services.metadata.create_image_metadata(session, node_id)
-
-        return metadata

invokeai/app/services/invocation_services.py

@@ -1,67 +1,50 @@
-# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654) and the InvokeAI Team
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from logging import Logger
-    from invokeai.app.services.board_images import BoardImagesServiceABC
-    from invokeai.app.services.boards import BoardServiceABC
-    from invokeai.app.services.images import ImageServiceABC
-    from invokeai.backend import ModelManager
-    from invokeai.app.services.events import EventServiceBase
-    from invokeai.app.services.latent_storage import LatentsStorageBase
-    from invokeai.app.services.restoration_services import RestorationServices
-    from invokeai.app.services.invocation_queue import InvocationQueueABC
-    from invokeai.app.services.item_storage import ItemStorageABC
-    from invokeai.app.services.config import InvokeAISettings
-    from invokeai.app.services.graph import GraphExecutionState, LibraryGraph
-    from invokeai.app.services.invoker import InvocationProcessorABC
+# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
+from invokeai.app.services.metadata import MetadataServiceBase
+from invokeai.backend import ModelManager
 
+from .events import EventServiceBase
+from .latent_storage import LatentsStorageBase
+from .image_storage import ImageStorageBase
+from .restoration_services import RestorationServices
+from .invocation_queue import InvocationQueueABC
+from .item_storage import ItemStorageABC
 
 class InvocationServices:
     """Services that can be used by invocations"""
 
-    # TODO: Just forward-declared everything due to circular dependencies. Fix structure.
-    events: "EventServiceBase"
-    latents: "LatentsStorageBase"
-    queue: "InvocationQueueABC"
-    model_manager: "ModelManager"
-    restoration: "RestorationServices"
-    configuration: "InvokeAISettings"
-    images: "ImageServiceABC"
-    boards: "BoardServiceABC"
-    board_images: "BoardImagesServiceABC"
-    graph_library: "ItemStorageABC"["LibraryGraph"]
-    graph_execution_manager: "ItemStorageABC"["GraphExecutionState"]
+    events: EventServiceBase
+    latents: LatentsStorageBase
+    images: ImageStorageBase
+    metadata: MetadataServiceBase
+    queue: InvocationQueueABC
+    model_manager: ModelManager
+    restoration: RestorationServices
+
+    # NOTE: we must forward-declare any types that include invocations, since invocations can use services
+    graph_library: ItemStorageABC["LibraryGraph"]
+    graph_execution_manager: ItemStorageABC["GraphExecutionState"]
     processor: "InvocationProcessorABC"
 
     def __init__(
-        self,
-        model_manager: "ModelManager",
-        events: "EventServiceBase",
-        logger: "Logger",
-        latents: "LatentsStorageBase",
-        images: "ImageServiceABC",
-        boards: "BoardServiceABC",
-        board_images: "BoardImagesServiceABC",
-        queue: "InvocationQueueABC",
-        graph_library: "ItemStorageABC"["LibraryGraph"],
-        graph_execution_manager: "ItemStorageABC"["GraphExecutionState"],
-        processor: "InvocationProcessorABC",
-        restoration: "RestorationServices",
-        configuration: "InvokeAISettings",
+            self,
+            model_manager: ModelManager,
+            events: EventServiceBase,
+            latents: LatentsStorageBase,
+            images: ImageStorageBase,
+            metadata: MetadataServiceBase,
+            queue: InvocationQueueABC,
+            graph_library: ItemStorageABC["LibraryGraph"],
+            graph_execution_manager: ItemStorageABC["GraphExecutionState"],
+            processor: "InvocationProcessorABC",
+            restoration: RestorationServices,
     ):
         self.model_manager = model_manager
         self.events = events
-        self.logger = logger
         self.latents = latents
         self.images = images
-        self.boards = boards
-        self.board_images = board_images
+        self.metadata = metadata
         self.queue = queue
         self.graph_library = graph_library
         self.graph_execution_manager = graph_execution_manager
         self.processor = processor
         self.restoration = restoration
-        self.configuration = configuration
-        self.boards = boards

invokeai/app/services/invoker.py

@@ -22,8 +22,7 @@ class Invoker:
     def invoke(
         self, graph_execution_state: GraphExecutionState, invoke_all: bool = False
     ) -> str | None:
-        """Determines the next node to invoke and enqueues it, preparing if needed.
-        Returns the id of the queued node, or `None` if there are no nodes left to enqueue."""
+        """Determines the next node to invoke and returns the id of the invoked node, or None if there are no nodes to execute"""
 
         # Get the next invocation
         invocation = graph_execution_state.next()
@@ -50,7 +49,7 @@ class Invoker:
         new_state = GraphExecutionState(graph=Graph() if graph is None else graph)
         self.services.graph_execution_manager.set(new_state)
         return new_state
-
+    
     def cancel(self, graph_execution_state_id: str) -> None:
         """Cancels the given execution state"""
         self.services.queue.cancel(graph_execution_state_id)
@@ -72,12 +71,18 @@ class Invoker:
         for service in vars(self.services):
             self.__start_service(getattr(self.services, service))
 
+        for service in vars(self.services):
+            self.__start_service(getattr(self.services, service))
+
     def stop(self) -> None:
         """Stops the invoker. A new invoker will have to be created to execute further."""
         # First stop all services
         for service in vars(self.services):
             self.__stop_service(getattr(self.services, service))
 
+        for service in vars(self.services):
+            self.__stop_service(getattr(self.services, service))
+
         self.services.queue.put(None)
 
 

invokeai/app/services/latent_storage.py

@@ -1,5 +1,6 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
 
+import os
 from abc import ABC, abstractmethod
 from pathlib import Path
 from queue import Queue
@@ -15,7 +16,7 @@ class LatentsStorageBase(ABC):
         pass
 
     @abstractmethod
-    def save(self, name: str, data: torch.Tensor) -> None:
+    def set(self, name: str, data: torch.Tensor) -> None:
         pass
 
     @abstractmethod
@@ -46,8 +47,8 @@ class ForwardCacheLatentsStorage(LatentsStorageBase):
         self.__set_cache(name, latent)
         return latent
 
-    def save(self, name: str, data: torch.Tensor) -> None:
-        self.__underlying_storage.save(name, data)
+    def set(self, name: str, data: torch.Tensor) -> None:
+        self.__underlying_storage.set(name, data)
         self.__set_cache(name, data)
 
     def delete(self, name: str) -> None:
@@ -69,26 +70,24 @@ class ForwardCacheLatentsStorage(LatentsStorageBase):
 class DiskLatentsStorage(LatentsStorageBase):
     """Stores latents in a folder on disk without caching"""
 
-    __output_folder: str | Path
+    __output_folder: str
 
-    def __init__(self, output_folder: str | Path):
-        self.__output_folder = output_folder if isinstance(output_folder, Path) else Path(output_folder)
-        self.__output_folder.mkdir(parents=True, exist_ok=True)
+    def __init__(self, output_folder: str):
+        self.__output_folder = output_folder
+        Path(output_folder).mkdir(parents=True, exist_ok=True)
 
     def get(self, name: str) -> torch.Tensor:
         latent_path = self.get_path(name)
         return torch.load(latent_path)
 
-    def save(self, name: str, data: torch.Tensor) -> None:
-        self.__output_folder.mkdir(parents=True, exist_ok=True)
+    def set(self, name: str, data: torch.Tensor) -> None:
         latent_path = self.get_path(name)
         torch.save(data, latent_path)
 
     def delete(self, name: str) -> None:
         latent_path = self.get_path(name)
-        latent_path.unlink()
-        
+        os.remove(latent_path)
 
-    def get_path(self, name: str) -> Path:
-        return self.__output_folder / name
+    def get_path(self, name: str) -> str:
+        return os.path.join(self.__output_folder, name)
     

invokeai/app/services/metadata.py

@@ -1,142 +1,96 @@
+import json
 from abc import ABC, abstractmethod
-from typing import Any, Union
-import networkx as nx
+from typing import Any, Dict, Optional, TypedDict
+from PIL import Image, PngImagePlugin
+from pydantic import BaseModel
 
-from invokeai.app.models.metadata import ImageMetadata
-from invokeai.app.services.graph import Graph, GraphExecutionState
+from invokeai.app.models.image import ImageType, is_image_type
+
+
+class MetadataImageField(TypedDict):
+    """Pydantic-less ImageField, used for metadata parsing."""
+
+    image_type: ImageType
+    image_name: str
+
+
+class MetadataLatentsField(TypedDict):
+    """Pydantic-less LatentsField, used for metadata parsing."""
+
+    latents_name: str
+
+
+# TODO: This is a placeholder for `InvocationsUnion` pending resolution of circular imports
+NodeMetadata = Dict[
+    str, str | int | float | bool | MetadataImageField | MetadataLatentsField
+]
+
+
+class InvokeAIMetadata(TypedDict, total=False):
+    """InvokeAI-specific metadata format."""
+
+    session_id: Optional[str]
+    node: Optional[NodeMetadata]
+
+
+def build_invokeai_metadata_pnginfo(
+    metadata: InvokeAIMetadata | None,
+) -> PngImagePlugin.PngInfo:
+    """Builds a PngInfo object with key `"invokeai"` and value `metadata`"""
+    pnginfo = PngImagePlugin.PngInfo()
+
+    if metadata is not None:
+        pnginfo.add_text("invokeai", json.dumps(metadata))
+
+    return pnginfo
 
 
 class MetadataServiceBase(ABC):
-    """Handles building metadata for nodes, images, and outputs."""
+    @abstractmethod
+    def get_metadata(self, image: Image.Image) -> InvokeAIMetadata | None:
+        """Gets the InvokeAI metadata from a PIL Image, skipping invalid values"""
+        pass
 
     @abstractmethod
-    def create_image_metadata(
-        self, session: GraphExecutionState, node_id: str
-    ) -> ImageMetadata:
-        """Builds an ImageMetadata object for a node."""
+    def build_metadata(
+        self, session_id: str, node: BaseModel
+    ) -> InvokeAIMetadata | None:
+        """Builds an InvokeAIMetadata object"""
         pass
 
 
-class CoreMetadataService(MetadataServiceBase):
-    _ANCESTOR_TYPES = ["t2l", "l2l"]
-    """The ancestor types that contain the core metadata"""
+class PngMetadataService(MetadataServiceBase):
+    """Handles loading and building metadata for images."""
 
-    _ANCESTOR_PARAMS = ["type", "steps", "model", "cfg_scale", "scheduler", "strength"]
-    """The core metadata parameters in the ancestor types"""
+    # TODO: Use `InvocationsUnion` to **validate** metadata as representing a fully-functioning node
+    def _load_metadata(self, image: Image.Image) -> dict | None:
+        """Loads a specific info entry from a PIL Image."""
 
-    _NOISE_FIELDS = ["seed", "width", "height"]
-    """The core metadata parameters in the noise node"""
+        try:
+            info = image.info.get("invokeai")
 
-    def create_image_metadata(
-        self, session: GraphExecutionState, node_id: str
-    ) -> ImageMetadata:
-        metadata = self._build_metadata_from_graph(session, node_id)
+            if type(info) is not str:
+                return None
+
+            loaded_metadata = json.loads(info)
+
+            if type(loaded_metadata) is not dict:
+                return None
+
+            if len(loaded_metadata.items()) == 0:
+                return None
+
+            return loaded_metadata
+        except:
+            return None
+
+    def get_metadata(self, image: Image.Image) -> dict | None:
+        """Retrieves an image's metadata as a dict"""
+        loaded_metadata = self._load_metadata(image)
+
+        return loaded_metadata
+
+    def build_metadata(self, session_id: str, node: BaseModel) -> InvokeAIMetadata:
+        metadata = InvokeAIMetadata(session_id=session_id, node=node.dict())
 
         return metadata
-
-    def _find_nearest_ancestor(self, G: nx.DiGraph, node_id: str) -> Union[str, None]:
-        """
-        Finds the id of the nearest ancestor (of a valid type) of a given node.
-
-        Parameters:
-        G (nx.DiGraph): The execution graph, converted in to a networkx DiGraph. Its nodes must
-        have the same data as the execution graph.
-        node_id (str): The ID of the node.
-
-        Returns:
-        str | None: The ID of the nearest ancestor, or None if there are no valid ancestors.
-        """
-
-        # Retrieve the node from the graph
-        node = G.nodes[node_id]
-
-        # If the node type is one of the core metadata node types, return its id
-        if node.get("type") in self._ANCESTOR_TYPES:
-            return node.get("id")
-
-        # Else, look for the ancestor in the predecessor nodes
-        for predecessor in G.predecessors(node_id):
-            result = self._find_nearest_ancestor(G, predecessor)
-            if result:
-                return result
-
-        # If there are no valid ancestors, return None
-        return None
-
-    def _get_additional_metadata(
-        self, graph: Graph, node_id: str
-    ) -> Union[dict[str, Any], None]:
-        """
-        Returns additional metadata for a given node.
-
-        Parameters:
-        graph (Graph): The execution graph.
-        node_id (str): The ID of the node.
-
-        Returns:
-        dict[str, Any] | None: A dictionary of additional metadata.
-        """
-
-        metadata = {}
-
-        # Iterate over all edges in the graph
-        for edge in graph.edges:
-            dest_node_id = edge.destination.node_id
-            dest_field = edge.destination.field
-            source_node_dict = graph.nodes[edge.source.node_id].dict()
-
-            # If the destination node ID matches the given node ID, gather necessary metadata
-            if dest_node_id == node_id:
-                # Prompt
-                if dest_field == "positive_conditioning":
-                    metadata["positive_conditioning"] = source_node_dict.get("prompt")
-                # Negative prompt
-                if dest_field == "negative_conditioning":
-                    metadata["negative_conditioning"] = source_node_dict.get("prompt")
-                # Seed, width and height
-                if dest_field == "noise":
-                    for field in self._NOISE_FIELDS:
-                        metadata[field] = source_node_dict.get(field)
-        return metadata
-
-    def _build_metadata_from_graph(
-        self, session: GraphExecutionState, node_id: str
-    ) -> ImageMetadata:
-        """
-        Builds an ImageMetadata object for a node.
-
-        Parameters:
-        session (GraphExecutionState): The session.
-        node_id (str): The ID of the node.
-
-        Returns:
-        ImageMetadata: The metadata for the node.
-        """
-
-        # We need to do all the traversal on the execution graph
-        graph = session.execution_graph
-
-        # Find the nearest `t2l`/`l2l` ancestor of the given node
-        ancestor_id = self._find_nearest_ancestor(graph.nx_graph_with_data(), node_id)
-
-        # If no ancestor was found, return an empty ImageMetadata object
-        if ancestor_id is None:
-            return ImageMetadata()
-
-        ancestor_node = graph.get_node(ancestor_id)
-
-        # Grab all the core metadata from the ancestor node
-        ancestor_metadata = {
-            param: val
-            for param, val in ancestor_node.dict().items()
-            if param in self._ANCESTOR_PARAMS
-        }
-
-        # Get this image's prompts and noise parameters
-        addl_metadata = self._get_additional_metadata(graph, ancestor_id)
-
-        # If additional metadata was found, add it to the main metadata
-        if addl_metadata is not None:
-            ancestor_metadata.update(addl_metadata)
-
-        return ImageMetadata(**ancestor_metadata)

invokeai/app/services/model_manager_initializer.py

@@ -0,0 +1,120 @@
+import os
+import sys
+import torch
+from argparse import Namespace
+from invokeai.backend import Args
+from omegaconf import OmegaConf
+from pathlib import Path
+
+import invokeai.version
+from ...backend import ModelManager
+from ...backend.util import choose_precision, choose_torch_device
+from ...backend import Globals
+
+# TODO: Replace with an abstract class base ModelManagerBase
+def get_model_manager(config: Args) -> ModelManager:
+    if not config.conf:
+        config_file = os.path.join(Globals.root, "configs", "models.yaml")
+        if not os.path.exists(config_file):
+            report_model_error(
+                config, FileNotFoundError(f"The file {config_file} could not be found.")
+            )
+
+    print(f">> {invokeai.version.__app_name__}, version {invokeai.version.__version__}")
+    print(f'>> InvokeAI runtime directory is "{Globals.root}"')
+
+    # these two lines prevent a horrible warning message from appearing
+    # when the frozen CLIP tokenizer is imported
+    import transformers  # type: ignore
+
+    transformers.logging.set_verbosity_error()
+    import diffusers
+
+    diffusers.logging.set_verbosity_error()
+
+    # normalize the config directory relative to root
+    if not os.path.isabs(config.conf):
+        config.conf = os.path.normpath(os.path.join(Globals.root, config.conf))
+
+    if config.embeddings:
+        if not os.path.isabs(config.embedding_path):
+            embedding_path = os.path.normpath(
+                os.path.join(Globals.root, config.embedding_path)
+            )
+        else:
+            embedding_path = config.embedding_path
+    else:
+        embedding_path = None
+
+    # migrate legacy models
+    ModelManager.migrate_models()
+
+    # creating the model manager
+    try:
+        device = torch.device(choose_torch_device())
+        precision = 'float16' if config.precision=='float16' \
+        else 'float32' if config.precision=='float32' \
+        else choose_precision(device)
+        
+        model_manager = ModelManager(
+            OmegaConf.load(config.conf),
+            precision=precision,
+            device_type=device,
+            max_loaded_models=config.max_loaded_models,
+            embedding_path = Path(embedding_path),
+        )
+    except (FileNotFoundError, TypeError, AssertionError) as e:
+        report_model_error(config, e)
+    except (IOError, KeyError) as e:
+        print(f"{e}. Aborting.")
+        sys.exit(-1)
+
+    # try to autoconvert new models
+    # autoimport new .ckpt files
+    if path := config.autoconvert:
+        model_manager.autoconvert_weights(
+            conf_path=config.conf,
+            weights_directory=path,
+        )
+
+    return model_manager
+
+def report_model_error(opt: Namespace, e: Exception):
+    print(f'** An error occurred while attempting to initialize the model: "{str(e)}"')
+    print(
+        "** This can be caused by a missing or corrupted models file, and can sometimes be fixed by (re)installing the models."
+    )
+    yes_to_all = os.environ.get("INVOKE_MODEL_RECONFIGURE")
+    if yes_to_all:
+        print(
+            "** Reconfiguration is being forced by environment variable INVOKE_MODEL_RECONFIGURE"
+        )
+    else:
+        response = input(
+            "Do you want to run invokeai-configure script to select and/or reinstall models? [y] "
+        )
+        if response.startswith(("n", "N")):
+            return
+
+    print("invokeai-configure is launching....\n")
+
+    # Match arguments that were set on the CLI
+    # only the arguments accepted by the configuration script are parsed
+    root_dir = ["--root", opt.root_dir] if opt.root_dir is not None else []
+    config = ["--config", opt.conf] if opt.conf is not None else []
+    previous_config = sys.argv
+    sys.argv = ["invokeai-configure"]
+    sys.argv.extend(root_dir)
+    sys.argv.extend(config.to_dict())
+    if yes_to_all is not None:
+        for arg in yes_to_all.split():
+            sys.argv.append(arg)
+
+    from invokeai.frontend.install import invokeai_configure
+
+    invokeai_configure()
+    # TODO: Figure out how to restart
+    # print('** InvokeAI will now restart')
+    # sys.argv = previous_args
+    # main() # would rather do a os.exec(), but doesn't exist?
+    # sys.exit(0)

invokeai/app/services/model_manager_service.py

@@ -1,363 +0,0 @@
-# Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Team
-
-from __future__ import annotations
-
-import torch
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Optional, Union, Callable, List, Tuple, types, TYPE_CHECKING
-from dataclasses import dataclass
-
-from invokeai.backend.model_management.model_manager import (
-    ModelManager,
-    BaseModelType,
-    ModelType,
-    SubModelType,
-    ModelInfo,
-)
-from invokeai.app.models.exceptions import CanceledException
-from .config import InvokeAIAppConfig
-from ...backend.util import choose_precision, choose_torch_device
-
-if TYPE_CHECKING:
-    from ..invocations.baseinvocation import BaseInvocation, InvocationContext
-
-
-class ModelManagerServiceBase(ABC):
-    """Responsible for managing models on disk and in memory"""
-
-    @abstractmethod
-    def __init__(
-        self,
-        config: InvokeAIAppConfig,
-        logger: types.ModuleType,
-    ):
-        """
-        Initialize with the path to the models.yaml config file. 
-        Optional parameters are the torch device type, precision, max_models,
-        and sequential_offload boolean. Note that the default device
-        type and precision are set up for a CUDA system running at half precision.
-        """
-        pass
-    
-    @abstractmethod
-    def get_model(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-        submodel: Optional[SubModelType] = None,
-        node: Optional[BaseInvocation] = None,
-        context: Optional[InvocationContext] = None,
-    ) -> ModelInfo:
-        """Retrieve the indicated model with name and type. 
-        submodel can be used to get a part (such as the vae) 
-        of a diffusers pipeline."""
-        pass
-
-    @property
-    @abstractmethod
-    def logger(self):
-        pass
-
-    @abstractmethod
-    def model_exists(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-    ) -> bool:
-        pass
-
-    @abstractmethod
-    def model_info(self, model_name: str, base_model: BaseModelType, model_type: ModelType) -> dict:
-        """
-        Given a model name returns a dict-like (OmegaConf) object describing it.
-        """
-        pass
-
-    @abstractmethod
-    def model_names(self) -> List[Tuple[str, BaseModelType, ModelType]]:
-        """
-        Returns a list of all the model names known.
-        """
-        pass
-
-    @abstractmethod
-    def list_models(self, base_model: Optional[BaseModelType] = None, model_type: Optional[ModelType] = None) -> dict:
-        """
-        Return a dict of models in the format:
-        { model_type1:
-          { model_name1: {'status': 'active'|'cached'|'not loaded',
-                         'model_name' : name,
-                         'model_type' : SDModelType,
-                         'description': description,
-                         'format': 'folder'|'safetensors'|'ckpt'
-                         },
-            model_name2: { etc }
-          },
-          model_type2:
-            { model_name_n: etc
-        }
-        """
-        pass
-
-
-    @abstractmethod
-    def add_model(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-        model_attributes: dict,
-        clobber: bool = False
-    ) -> None:
-        """
-        Update the named model with a dictionary of attributes. Will fail with an
-        assertion error if the name already exists. Pass clobber=True to overwrite.
-        On a successful update, the config will be changed in memory. Will fail 
-        with an assertion error if provided attributes are incorrect or 
-        the model name is missing. Call commit() to write changes to disk.
-        """
-        pass
-
-    @abstractmethod
-    def del_model(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-    ):
-        """
-        Delete the named model from configuration. If delete_files is true, 
-        then the underlying weight file or diffusers directory will be deleted 
-        as well. Call commit() to write to disk.
-        """
-        pass
-
-    @abstractmethod
-    def commit(self, conf_file: Path = None) -> None:
-        """
-        Write current configuration out to the indicated file.
-        If no conf_file is provided, then replaces the
-        original file/database used to initialize the object.
-        """
-        pass
-
-# simple implementation
-class ModelManagerService(ModelManagerServiceBase):
-    """Responsible for managing models on disk and in memory"""
-    def __init__(
-        self,
-        config: InvokeAIAppConfig,
-        logger: types.ModuleType,
-    ):
-        """
-        Initialize with the path to the models.yaml config file. 
-        Optional parameters are the torch device type, precision, max_models,
-        and sequential_offload boolean. Note that the default device
-        type and precision are set up for a CUDA system running at half precision.
-        """
-        if config.model_conf_path and config.model_conf_path.exists():
-            config_file = config.model_conf_path
-        else:
-            config_file = config.root_dir / "configs/models.yaml"
-        if not config_file.exists():
-            raise IOError(f"The file {config_file} could not be found.")
-
-        logger.debug(f'config file={config_file}')
-
-        device = torch.device(choose_torch_device())
-        precision = config.precision
-        if precision == "auto":
-            precision = choose_precision(device)
-        dtype = torch.float32 if precision == 'float32' else torch.float16
-
-        # this is transitional backward compatibility
-        # support for the deprecated `max_loaded_models`
-        # configuration value. If present, then the
-        # cache size is set to 2.5 GB times
-        # the number of max_loaded_models. Otherwise
-        # use new `max_cache_size` config setting
-        max_cache_size = config.max_cache_size \
-            if hasattr(config,'max_cache_size') \
-               else config.max_loaded_models * 2.5
-
-        sequential_offload = config.sequential_guidance
-
-        self.mgr = ModelManager(
-            config=config_file,
-            device_type=device,
-            precision=dtype,
-            max_cache_size=max_cache_size,
-            sequential_offload=sequential_offload,
-            logger=logger,
-        )
-        logger.info('Model manager service initialized')
-
-    def get_model(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-        submodel: Optional[SubModelType] = None,
-        node: Optional[BaseInvocation] = None,
-        context: Optional[InvocationContext] = None,
-    ) -> ModelInfo:
-        """
-        Retrieve the indicated model. submodel can be used to get a
-        part (such as the vae) of a diffusers mode.
-        """
-
-        # if we are called from within a node, then we get to emit
-        # load start and complete events
-        if node and context:
-            self._emit_load_event(
-                node=node,
-                context=context,
-                model_name=model_name,
-                base_model=base_model,
-                model_type=model_type,
-                submodel=submodel,
-            )
-
-        model_info = self.mgr.get_model(
-            model_name,
-            base_model,
-            model_type,
-            submodel,
-        )
-
-        if node and context:
-            self._emit_load_event(
-                node=node,
-                context=context,
-                model_name=model_name,
-                base_model=base_model,
-                model_type=model_type,
-                submodel=submodel,
-                model_info=model_info
-            )
-            
-        return model_info
-
-    def model_exists(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-    ) -> bool:
-        """
-        Given a model name, returns True if it is a valid
-        identifier.
-        """
-        return self.mgr.model_exists(
-            model_name,
-            base_model,
-            model_type,
-        )
-
-    def model_info(self, model_name: str, base_model: BaseModelType, model_type: ModelType) -> dict:
-        """
-        Given a model name returns a dict-like (OmegaConf) object describing it.
-        """
-        return self.mgr.model_info(model_name, base_model, model_type)
-
-    def model_names(self) -> List[Tuple[str, BaseModelType, ModelType]]:
-        """
-        Returns a list of all the model names known.
-        """
-        return self.mgr.model_names()
-
-    def list_models(
-        self,
-        base_model: Optional[BaseModelType] = None,
-        model_type: Optional[ModelType] = None
-    ) -> list[dict]:
-    # ) -> dict:
-        """
-        Return a list of models.
-        """
-        return self.mgr.list_models(base_model, model_type)
-
-    def add_model(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-        model_attributes: dict,
-        clobber: bool = False,
-    )->None:
-        """
-        Update the named model with a dictionary of attributes. Will fail with an
-        assertion error if the name already exists. Pass clobber=True to overwrite.
-        On a successful update, the config will be changed in memory. Will fail 
-        with an assertion error if provided attributes are incorrect or 
-        the model name is missing. Call commit() to write changes to disk.
-        """
-        return self.mgr.add_model(model_name, base_model, model_type, model_attributes, clobber)
-
-
-    def del_model(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-    ):
-        """
-        Delete the named model from configuration. If delete_files is true, 
-        then the underlying weight file or diffusers directory will be deleted 
-        as well. Call commit() to write to disk.
-        """
-        self.mgr.del_model(model_name, base_model, model_type)
-
-
-    def commit(self, conf_file: Optional[Path]=None):
-        """
-        Write current configuration out to the indicated file.
-        If no conf_file is provided, then replaces the
-        original file/database used to initialize the object.
-        """
-        return self.mgr.commit(conf_file)
-
-    def _emit_load_event(
-        self,
-        node,
-        context,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-        submodel: SubModelType,
-        model_info: Optional[ModelInfo] = None,
-    ):
-        if context.services.queue.is_canceled(context.graph_execution_state_id):
-            raise CanceledException()
-        graph_execution_state = context.services.graph_execution_manager.get(context.graph_execution_state_id)
-        source_node_id = graph_execution_state.prepared_source_mapping[node.id]
-        if model_info:
-            context.services.events.emit_model_load_completed(
-                graph_execution_state_id=context.graph_execution_state_id,
-                node=node.dict(),
-                source_node_id=source_node_id,
-                model_name=model_name,
-                base_model=base_model,
-                model_type=model_type,
-                submodel=submodel,
-                model_info=model_info
-            )
-        else:
-            context.services.events.emit_model_load_started(
-                graph_execution_state_id=context.graph_execution_state_id,
-                node=node.dict(),
-                source_node_id=source_node_id,
-                model_name=model_name,
-                base_model=base_model,
-                model_type=model_type,
-                submodel=submodel,
-            )
-
-
-    @property
-    def logger(self):
-        return self.mgr.logger
-        

invokeai/app/services/models/board_record.py

@@ -1,62 +0,0 @@
-from typing import Optional, Union
-from datetime import datetime
-from pydantic import BaseModel, Extra, Field, StrictBool, StrictStr
-from invokeai.app.util.misc import get_iso_timestamp
-
-
-class BoardRecord(BaseModel):
-    """Deserialized board record."""
-
-    board_id: str = Field(description="The unique ID of the board.")
-    """The unique ID of the board."""
-    board_name: str = Field(description="The name of the board.")
-    """The name of the board."""
-    created_at: Union[datetime, str] = Field(
-        description="The created timestamp of the board."
-    )
-    """The created timestamp of the image."""
-    updated_at: Union[datetime, str] = Field(
-        description="The updated timestamp of the board."
-    )
-    """The updated timestamp of the image."""
-    deleted_at: Union[datetime, str, None] = Field(
-        description="The deleted timestamp of the board."
-    )
-    """The updated timestamp of the image."""
-    cover_image_name: Optional[str] = Field(
-        description="The name of the cover image of the board."
-    )
-    """The name of the cover image of the board."""
-
-
-class BoardDTO(BoardRecord):
-    """Deserialized board record with cover image URL and image count."""
-
-    cover_image_name: Optional[str] = Field(
-        description="The name of the board's cover image."
-    )
-    """The URL of the thumbnail of the most recent image in the board."""
-    image_count: int = Field(description="The number of images in the board.")
-    """The number of images in the board."""
-
-
-def deserialize_board_record(board_dict: dict) -> BoardRecord:
-    """Deserializes a board record."""
-
-    # Retrieve all the values, setting "reasonable" defaults if they are not present.
-
-    board_id = board_dict.get("board_id", "unknown")
-    board_name = board_dict.get("board_name", "unknown")
-    cover_image_name = board_dict.get("cover_image_name", "unknown")
-    created_at = board_dict.get("created_at", get_iso_timestamp())
-    updated_at = board_dict.get("updated_at", get_iso_timestamp())
-    deleted_at = board_dict.get("deleted_at", get_iso_timestamp())
-
-    return BoardRecord(
-        board_id=board_id,
-        board_name=board_name,
-        cover_image_name=cover_image_name,
-        created_at=created_at,
-        updated_at=updated_at,
-        deleted_at=deleted_at,
-    )

invokeai/app/services/models/image_record.py

@@ -1,151 +0,0 @@
-import datetime
-from typing import Optional, Union
-from pydantic import BaseModel, Extra, Field, StrictBool, StrictStr
-from invokeai.app.models.image import ImageCategory, ResourceOrigin
-from invokeai.app.models.metadata import ImageMetadata
-from invokeai.app.util.misc import get_iso_timestamp
-
-
-class ImageRecord(BaseModel):
-    """Deserialized image record."""
-
-    image_name: str = Field(description="The unique name of the image.")
-    """The unique name of the image."""
-    image_origin: ResourceOrigin = Field(description="The type of the image.")
-    """The origin of the image."""
-    image_category: ImageCategory = Field(description="The category of the image.")
-    """The category of the image."""
-    width: int = Field(description="The width of the image in px.")
-    """The actual width of the image in px. This may be different from the width in metadata."""
-    height: int = Field(description="The height of the image in px.")
-    """The actual height of the image in px. This may be different from the height in metadata."""
-    created_at: Union[datetime.datetime, str] = Field(
-        description="The created timestamp of the image."
-    )
-    """The created timestamp of the image."""
-    updated_at: Union[datetime.datetime, str] = Field(
-        description="The updated timestamp of the image."
-    )
-    """The updated timestamp of the image."""
-    deleted_at: Union[datetime.datetime, str, None] = Field(
-        description="The deleted timestamp of the image."
-    )
-    """The deleted timestamp of the image."""
-    is_intermediate: bool = Field(description="Whether this is an intermediate image.")
-    """Whether this is an intermediate image."""
-    session_id: Optional[str] = Field(
-        default=None,
-        description="The session ID that generated this image, if it is a generated image.",
-    )
-    """The session ID that generated this image, if it is a generated image."""
-    node_id: Optional[str] = Field(
-        default=None,
-        description="The node ID that generated this image, if it is a generated image.",
-    )
-    """The node ID that generated this image, if it is a generated image."""
-    metadata: Optional[ImageMetadata] = Field(
-        default=None,
-        description="A limited subset of the image's generation metadata. Retrieve the image's session for full metadata.",
-    )
-    """A limited subset of the image's generation metadata. Retrieve the image's session for full metadata."""
-
-
-class ImageRecordChanges(BaseModel, extra=Extra.forbid):
-    """A set of changes to apply to an image record.
-
-    Only limited changes are valid:
-      - `image_category`: change the category of an image
-      - `session_id`: change the session associated with an image
-      - `is_intermediate`: change the image's `is_intermediate` flag
-    """
-
-    image_category: Optional[ImageCategory] = Field(
-        description="The image's new category."
-    )
-    """The image's new category."""
-    session_id: Optional[StrictStr] = Field(
-        default=None,
-        description="The image's new session ID.",
-    )
-    """The image's new session ID."""
-    is_intermediate: Optional[StrictBool] = Field(
-        default=None, description="The image's new `is_intermediate` flag."
-    )
-    """The image's new `is_intermediate` flag."""
-
-
-class ImageUrlsDTO(BaseModel):
-    """The URLs for an image and its thumbnail."""
-
-    image_name: str = Field(description="The unique name of the image.")
-    """The unique name of the image."""
-    image_url: str = Field(description="The URL of the image.")
-    """The URL of the image."""
-    thumbnail_url: str = Field(description="The URL of the image's thumbnail.")
-    """The URL of the image's thumbnail."""
-
-
-class ImageDTO(ImageRecord, ImageUrlsDTO):
-    """Deserialized image record, enriched for the frontend."""
-
-    board_id: Union[str, None] = Field(
-        description="The id of the board the image belongs to, if one exists."
-    )
-    """The id of the board the image belongs to, if one exists."""
-    pass
-
-
-def image_record_to_dto(
-    image_record: ImageRecord, image_url: str, thumbnail_url: str, board_id: Union[str, None]
-) -> ImageDTO:
-    """Converts an image record to an image DTO."""
-    return ImageDTO(
-        **image_record.dict(),
-        image_url=image_url,
-        thumbnail_url=thumbnail_url,
-        board_id=board_id,
-    )
-
-
-def deserialize_image_record(image_dict: dict) -> ImageRecord:
-    """Deserializes an image record."""
-
-    # Retrieve all the values, setting "reasonable" defaults if they are not present.
-
-    image_name = image_dict.get("image_name", "unknown")
-    image_origin = ResourceOrigin(
-        image_dict.get("image_origin", ResourceOrigin.INTERNAL.value)
-    )
-    image_category = ImageCategory(
-        image_dict.get("image_category", ImageCategory.GENERAL.value)
-    )
-    width = image_dict.get("width", 0)
-    height = image_dict.get("height", 0)
-    session_id = image_dict.get("session_id", None)
-    node_id = image_dict.get("node_id", None)
-    created_at = image_dict.get("created_at", get_iso_timestamp())
-    updated_at = image_dict.get("updated_at", get_iso_timestamp())
-    deleted_at = image_dict.get("deleted_at", get_iso_timestamp())
-    is_intermediate = image_dict.get("is_intermediate", False)
-
-    raw_metadata = image_dict.get("metadata")
-
-    if raw_metadata is not None:
-        metadata = ImageMetadata.parse_raw(raw_metadata)
-    else:
-        metadata = None
-
-    return ImageRecord(
-        image_name=image_name,
-        image_origin=image_origin,
-        image_category=image_category,
-        width=width,
-        height=height,
-        session_id=session_id,
-        node_id=node_id,
-        metadata=metadata,
-        created_at=created_at,
-        updated_at=updated_at,
-        deleted_at=deleted_at,
-        is_intermediate=is_intermediate,
-    )

invokeai/app/services/processor.py

@@ -1,22 +1,17 @@
-import time
 import traceback
-from threading import Event, Thread, BoundedSemaphore
+from threading import Event, Thread
 
 from ..invocations.baseinvocation import InvocationContext
 from .invocation_queue import InvocationQueueItem
 from .invoker import InvocationProcessorABC, Invoker
 from ..models.exceptions import CanceledException
 
-import invokeai.backend.util.logging as logger
 class DefaultInvocationProcessor(InvocationProcessorABC):
     __invoker_thread: Thread
     __stop_event: Event
     __invoker: Invoker
-    __threadLimit: BoundedSemaphore
 
     def start(self, invoker) -> None:
-        # if we do want multithreading at some point, we could make this configurable
-        self.__threadLimit = BoundedSemaphore(1)
         self.__invoker = invoker
         self.__stop_event = Event()
         self.__invoker_thread = Thread(
@@ -25,7 +20,7 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
             kwargs=dict(stop_event=self.__stop_event),
         )
         self.__invoker_thread.daemon = (
-            True  # TODO: make async and do not use threads
+            True  # TODO: probably better to just not use threads?
         )
         self.__invoker_thread.start()
 
@@ -34,16 +29,9 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
 
     def __process(self, stop_event: Event):
         try:
-            self.__threadLimit.acquire()
             while not stop_event.is_set():
-                try:
-                    queue_item: InvocationQueueItem = self.__invoker.services.queue.get()
-                except Exception as e:
-                    logger.debug("Exception while getting from queue: %s" % e)
-
+                queue_item: InvocationQueueItem = self.__invoker.services.queue.get()
                 if not queue_item:  # Probably stopping
-                    # do not hammer the queue
-                    time.sleep(0.5)
                     continue
 
                 graph_execution_state = (
@@ -122,7 +110,7 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
                     )
 
                     pass
-
+                
                 # Check queue to see if this is canceled, and skip if so
                 if self.__invoker.services.queue.is_canceled(
                     graph_execution_state.id
@@ -132,22 +120,11 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
                 # Queue any further commands if invoking all
                 is_complete = graph_execution_state.is_complete()
                 if queue_item.invoke_all and not is_complete:
-                    try:
-                        self.__invoker.invoke(graph_execution_state, invoke_all=True)
-                    except Exception as e:
-                        logger.error("Error while invoking: %s" % e)
-                        self.__invoker.services.events.emit_invocation_error(
-                            graph_execution_state_id=graph_execution_state.id,
-                            node=invocation.dict(),
-                            source_node_id=source_node_id,
-                            error=traceback.format_exc()
-                        )
+                    self.__invoker.invoke(graph_execution_state, invoke_all=True)
                 elif is_complete:
                     self.__invoker.services.events.emit_graph_execution_complete(
                         graph_execution_state.id
                     )
 
         except KeyboardInterrupt:
-            pass  # Log something? KeyboardInterrupt is probably not going to be seen by the processor
-        finally:
-            self.__threadLimit.release()
+            ...  # Log something?

invokeai/app/services/resource_name.py

@@ -1,30 +0,0 @@
-from abc import ABC, abstractmethod
-from enum import Enum, EnumMeta
-import uuid
-
-
-class ResourceType(str, Enum, metaclass=EnumMeta):
-    """Enum for resource types."""
-
-    IMAGE = "image"
-    LATENT = "latent"
-
-
-class NameServiceBase(ABC):
-    """Low-level service responsible for naming resources (images, latents, etc)."""
-
-    # TODO: Add customizable naming schemes
-    @abstractmethod
-    def create_image_name(self) -> str:
-        """Creates a name for an image."""
-        pass
-
-
-class SimpleNameService(NameServiceBase):
-    """Creates image names from UUIDs."""
-
-    # TODO: Add customizable naming schemes
-    def create_image_name(self) -> str:
-        uuid_str = str(uuid.uuid4())
-        filename = f"{uuid_str}.png"
-        return filename

invokeai/app/services/restoration_services.py

@@ -1,7 +1,6 @@
 import sys
 import traceback
 import torch
-from typing import types
 from ...backend.restoration import Restoration
 from ...backend.util import choose_torch_device, CPU_DEVICE, MPS_DEVICE
 
@@ -11,33 +10,30 @@ from ...backend.util import choose_torch_device, CPU_DEVICE, MPS_DEVICE
 class RestorationServices:
     '''Face restoration and upscaling'''
     
-    def __init__(self,args,logger:types.ModuleType):
+    def __init__(self,args):
         try:
             gfpgan, codeformer, esrgan = None, None, None
             if args.restore or args.esrgan:
                 restoration = Restoration()
-                # TODO: redo for new model structure
-                if False and args.restore:
+                if args.restore:
                     gfpgan, codeformer = restoration.load_face_restore_models(
                         args.gfpgan_model_path
                     )
                 else:
-                    logger.info("Face restoration disabled")
-                    if False and args.esrgan:
+                    print(">> Face restoration disabled")
+                    if args.esrgan:
                         esrgan = restoration.load_esrgan(args.esrgan_bg_tile)
                     else:
-                        logger.info("Upscaling disabled")
+                        print(">> Upscaling disabled")
             else:
-                logger.info("Face restoration and upscaling disabled")
+                print(">> Face restoration and upscaling disabled")
         except (ModuleNotFoundError, ImportError):
             print(traceback.format_exc(), file=sys.stderr)
-            logger.info("You may need to install the ESRGAN and/or GFPGAN modules")
+            print(">> You may need to install the ESRGAN and/or GFPGAN modules")
         self.device = torch.device(choose_torch_device())
         self.gfpgan = gfpgan
         self.codeformer = codeformer
         self.esrgan = esrgan
-        self.logger = logger
-        self.logger.info('Face restoration initialized')
 
     # note that this one method does gfpgan and codepath reconstruction, as well as
     # esrgan upscaling
@@ -62,15 +58,15 @@ class RestorationServices:
                     if self.gfpgan is not None or self.codeformer is not None:
                         if facetool == "gfpgan":
                             if self.gfpgan is None:
-                                self.logger.info(
-                                    "GFPGAN not found. Face restoration is disabled."
+                                print(
+                                    ">> GFPGAN not found. Face restoration is disabled."
                                 )
                             else:
                                 image = self.gfpgan.process(image, strength, seed)
                         if facetool == "codeformer":
                             if self.codeformer is None:
-                                self.logger.info(
-                                    "CodeFormer not found. Face restoration is disabled."
+                                print(
+                                    ">> CodeFormer not found. Face restoration is disabled."
                                 )
                             else:
                                 cf_device = (
@@ -84,7 +80,7 @@ class RestorationServices:
                                     fidelity=codeformer_fidelity,
                                 )
                     else:
-                        self.logger.info("Face Restoration is disabled.")
+                        print(">> Face Restoration is disabled.")
                 if upscale is not None:
                     if self.esrgan is not None:
                         if len(upscale) < 2:
@@ -97,10 +93,10 @@ class RestorationServices:
                             denoise_str=upscale_denoise_str,
                         )
                     else:
-                        self.logger.info("ESRGAN is disabled. Image not upscaled.")
+                        print(">> ESRGAN is disabled. Image not upscaled.")
             except Exception as e:
-                self.logger.info(
-                    f"Error running RealESRGAN or GFPGAN. Your image was not upscaled.\n{e}"
+                print(
+                    f">> Error running RealESRGAN or GFPGAN. Your image was not upscaled.\n{e}"
                 )
 
             if image_callback is not None:

invokeai/app/services/sqlite.py

@@ -26,6 +26,7 @@ class SqliteItemStorage(ItemStorageABC, Generic[T]):
         self._table_name = table_name
         self._id_field = id_field  # TODO: validate that T has this field
         self._lock = Lock()
+
         self._conn = sqlite3.connect(
             self._filename, check_same_thread=False
         )  # TODO: figure out a better threading solution

invokeai/app/services/urls.py

@@ -1,25 +0,0 @@
-import os
-from abc import ABC, abstractmethod
-
-
-class UrlServiceBase(ABC):
-    """Responsible for building URLs for resources."""
-
-    @abstractmethod
-    def get_image_url(self, image_name: str, thumbnail: bool = False) -> str:
-        """Gets the URL for an image or thumbnail."""
-        pass
-
-
-class LocalUrlService(UrlServiceBase):
-    def __init__(self, base_url: str = "api/v1"):
-        self._base_url = base_url
-
-    def get_image_url(self, image_name: str, thumbnail: bool = False) -> str:
-        image_basename = os.path.basename(image_name)
-
-        # These paths are determined by the routes in invokeai/app/api/routers/images.py
-        if thumbnail:
-            return f"{self._base_url}/images/{image_basename}/thumbnail"
-
-        return f"{self._base_url}/images/{image_basename}"

invokeai/app/util/metaenum.py

@@ -1,15 +0,0 @@
-from enum import EnumMeta
-
-
-class MetaEnum(EnumMeta):
-    """Metaclass to support additional features in Enums.
-
-    - `in` operator support: `'value' in MyEnum -> bool`
-    """
-
-    def __contains__(cls, item):
-        try:
-            cls(item)
-        except ValueError:
-            return False
-        return True

invokeai/app/util/misc.py

@@ -1,21 +1,5 @@
 import datetime
-import numpy as np
 
 
 def get_timestamp():
     return int(datetime.datetime.now(datetime.timezone.utc).timestamp())
-
-
-def get_iso_timestamp() -> str:
-    return datetime.datetime.utcnow().isoformat()
-
-
-def get_datetime_from_iso_timestamp(iso_timestamp: str) -> datetime.datetime:
-    return datetime.datetime.fromisoformat(iso_timestamp)
-
-
-SEED_MAX = np.iinfo(np.int32).max
-
-
-def get_random_seed():
-    return np.random.randint(0, SEED_MAX)

invokeai/app/util/step_callback.py

@@ -1,5 +1,5 @@
+from invokeai.app.api.models.images import ProgressImage
 from invokeai.app.models.exceptions import CanceledException
-from invokeai.app.models.image import ProgressImage
 from ..invocations.baseinvocation import InvocationContext
 from ...backend.util.util import image_to_dataURL
 from ...backend.generator.base import Generator

invokeai/backend/__init__.py

@@ -1,15 +1,16 @@
 """
 Initialization file for invokeai.backend
 """
+from .generate import Generate
 from .generator import (
     InvokeAIGeneratorBasicParams,
     InvokeAIGenerator,
     InvokeAIGeneratorOutput,
+    Txt2Img,
     Img2Img,
     Inpaint
 )
-from .model_management import (
-    ModelManager, ModelCache, BaseModelType,
-    ModelType, SubModelType, ModelInfo
-    )
+from .model_management import ModelManager, SDModelComponent
 from .safety_checker import SafetyChecker
+from .args import Args
+from .globals import Globals

invokeai/backend/config/invokeai_configure.py

@@ -12,17 +12,17 @@ print("Loading Python libraries...\n",file=sys.stderr)
 import argparse
 import io
 import os
+import re
 import shutil
-import textwrap
 import traceback
 import warnings
 from argparse import Namespace
 from pathlib import Path
 from shutil import get_terminal_size
-from typing import get_type_hints
 from urllib import request
 
 import npyscreen
+import torch
 import transformers
 from diffusers import AutoencoderKL
 from huggingface_hub import HfFolder
@@ -35,53 +35,57 @@ from transformers import (
     CLIPTextModel,
     CLIPTokenizer,
 )
+
 import invokeai.configs as configs
 
-from invokeai.app.services.config import (
-    InvokeAIAppConfig,
-)
-from invokeai.backend.util.logging import InvokeAILogger
-from invokeai.frontend.install.model_install import addModelsForm, process_and_execute
-from invokeai.frontend.install.widgets import (
+from ...frontend.install.model_install import addModelsForm, process_and_execute
+from ...frontend.install.widgets import (
     CenteredButtonPress,
     IntTitleSlider,
     set_min_terminal_size,
-    CyclingForm,
-    MIN_COLS,
-    MIN_LINES,
 )
-from invokeai.backend.install.legacy_arg_parsing import legacy_parser
-from invokeai.backend.install.model_install_backend import (
+from ..args import PRECISION_CHOICES, Args
+from ..globals import Globals, global_cache_dir, global_config_dir, global_config_file
+from .model_install_backend import (
     default_dataset,
     download_from_hf,
     hf_download_with_resume,
     recommended_datasets,
-    UserSelections,
 )
 
 warnings.filterwarnings("ignore")
+
 transformers.logging.set_verbosity_error()
 
-
 # --------------------------globals-----------------------
-
-config = InvokeAIAppConfig.get_config()
-
 Model_dir = "models"
 Weights_dir = "ldm/stable-diffusion-v1/"
 
-Default_config_file = config.model_conf_path
-SD_Configs = config.legacy_conf_path
+# the initial "configs" dir is now bundled in the `invokeai.configs` package
+Dataset_path = Path(configs.__path__[0]) / "INITIAL_MODELS.yaml"
 
-PRECISION_CHOICES = ['auto','float16','float32','autocast']
+Default_config_file = Path(global_config_dir()) / "models.yaml"
+SD_Configs = Path(global_config_dir()) / "stable-diffusion"
+
+Datasets = OmegaConf.load(Dataset_path)
+
+# minimum size for the UI
+MIN_COLS = 135
+MIN_LINES = 45
 
 INIT_FILE_PREAMBLE = """# InvokeAI initialization file
 # This is the InvokeAI initialization file, which contains command-line default values.
 # Feel free to edit. If anything goes wrong, you can re-initialize this file by deleting
 # or renaming it and then running invokeai-configure again.
+# Place  frequently-used startup commands here, one or more per line.
+# Examples:
+# --outdir=D:\data\images
+# --no-nsfw_checker
+# --web --host=0.0.0.0
+# --steps=20
+# -Ak_euler_a -C10.0
 """
 
-logger=None
 
 # --------------------------------------------
 def postscript(errors: None):
@@ -92,13 +96,14 @@ If you installed manually from source or with 'pip install': activate the virtua
 then run one of the following commands to start InvokeAI.
 
 Web UI:
-   invokeai-web
+   invokeai --web # (connect to http://localhost:9090)
+   invokeai --web --host 0.0.0.0 # (connect to http://your-lan-ip:9090 from another computer on the local network)
 
-Command-line client:
+Command-line interface:
    invokeai
 
 If you installed using an installation script, run:
-  {config.root_path}/invoke.{"bat" if sys.platform == "win32" else "sh"}
+  {Globals.root}/invoke.{"bat" if sys.platform == "win32" else "sh"}
 
 Add the '--help' argument to see all of the command-line switches available for use.
 """
@@ -210,11 +215,16 @@ def download_realesrgan():
     model_url = "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth"
     wdn_model_url = "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-wdn-x4v3.pth"
 
-    model_dest = config.root_path / "models/realesrgan/realesr-general-x4v3.pth"
-    wdn_model_dest = config.root_path / "models/realesrgan/realesr-general-wdn-x4v3.pth"
+    model_dest = os.path.join(
+        Globals.root, "models/realesrgan/realesr-general-x4v3.pth"
+    )
 
-    download_with_progress_bar(model_url, str(model_dest), "RealESRGAN")
-    download_with_progress_bar(wdn_model_url, str(wdn_model_dest), "RealESRGANwdn")
+    wdn_model_dest = os.path.join(
+        Globals.root, "models/realesrgan/realesr-general-wdn-x4v3.pth"
+    )
+
+    download_with_progress_bar(model_url, model_dest, "RealESRGAN")
+    download_with_progress_bar(wdn_model_url, wdn_model_dest, "RealESRGANwdn")
 
 
 def download_gfpgan():
@@ -233,8 +243,8 @@ def download_gfpgan():
             "./models/gfpgan/weights/parsing_parsenet.pth",
         ],
     ):
-        model_url, model_dest = model[0], config.root_path / model[1]
-        download_with_progress_bar(model_url, str(model_dest), "GFPGAN weights")
+        model_url, model_dest = model[0], os.path.join(Globals.root, model[1])
+        download_with_progress_bar(model_url, model_dest, "GFPGAN weights")
 
 
 # ---------------------------------------------
@@ -243,8 +253,8 @@ def download_codeformer():
     model_url = (
         "https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/codeformer.pth"
     )
-    model_dest = config.root_path / "models/codeformer/codeformer.pth"
-    download_with_progress_bar(model_url, str(model_dest), "CodeFormer")
+    model_dest = os.path.join(Globals.root, "models/codeformer/codeformer.pth")
+    download_with_progress_bar(model_url, model_dest, "CodeFormer")
 
 
 # ---------------------------------------------
@@ -285,7 +295,7 @@ def download_vaes():
         # first the diffusers version
         repo_id = "stabilityai/sd-vae-ft-mse"
         args = dict(
-            cache_dir=config.cache_dir,
+            cache_dir=global_cache_dir("hub"),
         )
         if not AutoencoderKL.from_pretrained(repo_id, **args):
             raise Exception(f"download of {repo_id} failed")
@@ -296,7 +306,7 @@ def download_vaes():
         if not hf_download_with_resume(
             repo_id=repo_id,
             model_name=model_name,
-            model_dir=str(config.root_path / Model_dir / Weights_dir),
+            model_dir=str(Globals.root / Model_dir / Weights_dir),
         ):
             raise Exception(f"download of {model_name} failed")
     except Exception as e:
@@ -311,24 +321,25 @@ def get_root(root: str = None) -> str:
     elif os.environ.get("INVOKEAI_ROOT"):
         return os.environ.get("INVOKEAI_ROOT")
     else:
-        return str(config.root_path)
+        return Globals.root
+
 
 # -------------------------------------
-class editOptsForm(CyclingForm, npyscreen.FormMultiPage):
+class editOptsForm(npyscreen.FormMultiPage):
     # for responsive resizing - disabled
     # FIX_MINIMUM_SIZE_WHEN_CREATED = False
 
     def create(self):
         program_opts = self.parentApp.program_opts
         old_opts = self.parentApp.invokeai_opts
-        first_time = not (config.root_path / 'invokeai.yaml').exists()
+        first_time = not (Globals.root / Globals.initfile).exists()
         access_token = HfFolder.get_token()
         window_width, window_height = get_terminal_size()
-        label = """Configure startup settings. You can come back and change these later. 
-Use ctrl-N and ctrl-P to move to the <N>ext and <P>revious fields.
-Use cursor arrows to make a checkbox selection, and space to toggle.
-"""
-        for i in textwrap.wrap(label,width=window_width-6):
+        for i in [
+            "Configure startup settings. You can come back and change these later.",
+            "Use ctrl-N and ctrl-P to move to the <N>ext and <P>revious fields.",
+            "Use cursor arrows to make a checkbox selection, and space to toggle.",
+        ]:
             self.add_widget_intelligent(
                 npyscreen.FixedText,
                 value=i,
@@ -355,7 +366,7 @@ Use cursor arrows to make a checkbox selection, and space to toggle.
         self.outdir = self.add_widget_intelligent(
             npyscreen.TitleFilename,
             name="(<tab> autocompletes, ctrl-N advances):",
-            value=str(default_output_dir()),
+            value=old_opts.outdir or str(default_output_dir()),
             select_dir=True,
             must_exist=False,
             use_two_lines=False,
@@ -370,21 +381,22 @@ Use cursor arrows to make a checkbox selection, and space to toggle.
             editable=False,
             color="CONTROL",
         )
-        self.nsfw_checker = self.add_widget_intelligent(
+        self.safety_checker = self.add_widget_intelligent(
             npyscreen.Checkbox,
             name="NSFW checker",
-            value=old_opts.nsfw_checker,
+            value=old_opts.safety_checker,
             relx=5,
             scroll_exit=True,
         )
         self.nextrely += 1
-        label = """If you have an account at HuggingFace you may optionally paste your access token here
-to allow InvokeAI to download restricted styles & subjects from the "Concept Library". See https://huggingface.co/settings/tokens.
-"""
-        for line in textwrap.wrap(label,width=window_width-6):
+        for i in [
+            "If you have an account at HuggingFace you may paste your access token here",
+            'to allow InvokeAI to download styles & subjects from the "Concept Library".',
+            "See https://huggingface.co/settings/tokens",
+        ]:
             self.add_widget_intelligent(
                 npyscreen.FixedText,
-                value=line,
+                value=i,
                 editable=False,
                 color="CONTROL",
             )
@@ -423,10 +435,17 @@ to allow InvokeAI to download restricted styles & subjects from the "Concept Lib
             relx=5,
             scroll_exit=True,
         )
-        self.xformers_enabled = self.add_widget_intelligent(
+        self.xformers = self.add_widget_intelligent(
             npyscreen.Checkbox,
             name="Enable xformers support if available",
-            value=old_opts.xformers_enabled,
+            value=old_opts.xformers,
+            relx=5,
+            scroll_exit=True,
+        )
+        self.ckpt_convert = self.add_widget_intelligent(
+            npyscreen.Checkbox,
+            name="Load legacy checkpoint models into memory as diffusers models",
+            value=old_opts.ckpt_convert,
             relx=5,
             scroll_exit=True,
         )
@@ -461,41 +480,19 @@ to allow InvokeAI to download restricted styles & subjects from the "Concept Lib
         self.nextrely += 1
         self.add_widget_intelligent(
             npyscreen.FixedText,
-            value="Directories containing textual inversion, controlnet and LoRA models (<tab> autocompletes, ctrl-N advances):",
+            value="Directory containing embedding/textual inversion files:",
             editable=False,
             color="CONTROL",
         )
-        self.embedding_dir = self.add_widget_intelligent(
+        self.embedding_path = self.add_widget_intelligent(
             npyscreen.TitleFilename,
-            name=" Textual Inversion Embeddings:",
+            name="(<tab> autocompletes, ctrl-N advances):",
             value=str(default_embedding_dir()),
             select_dir=True,
             must_exist=False,
             use_two_lines=False,
             labelColor="GOOD",
-            begin_entry_at=32,
-            scroll_exit=True,
-        )
-        self.lora_dir = self.add_widget_intelligent(
-            npyscreen.TitleFilename,
-            name="             LoRA and LyCORIS:",
-            value=str(default_lora_dir()),
-            select_dir=True,
-            must_exist=False,
-            use_two_lines=False,
-            labelColor="GOOD",
-            begin_entry_at=32,
-            scroll_exit=True,
-        )
-        self.controlnet_dir = self.add_widget_intelligent(
-            npyscreen.TitleFilename,
-            name="             ControlNets:",
-            value=str(default_controlnet_dir()),
-            select_dir=True,
-            must_exist=False,
-            use_two_lines=False,
-            labelColor="GOOD",
-            begin_entry_at=32,
+            begin_entry_at=40,
             scroll_exit=True,
         )
         self.nextrely += 1
@@ -508,11 +505,11 @@ to allow InvokeAI to download restricted styles & subjects from the "Concept Lib
             scroll_exit=True,
         )
         self.nextrely -= 1
-        label = """BY DOWNLOADING THE STABLE DIFFUSION WEIGHT FILES, YOU AGREE TO HAVE READ
-AND ACCEPTED THE CREATIVEML RESPONSIBLE AI LICENSE LOCATED AT
-https://huggingface.co/spaces/CompVis/stable-diffusion-license
-"""
-        for i in textwrap.wrap(label,width=window_width-6):
+        for i in [
+            "BY DOWNLOADING THE STABLE DIFFUSION WEIGHT FILES, YOU AGREE TO HAVE READ",
+            "AND ACCEPTED THE CREATIVEML RESPONSIBLE AI LICENSE LOCATED AT",
+            "https://huggingface.co/spaces/CompVis/stable-diffusion-license",
+        ]:
             self.add_widget_intelligent(
                 npyscreen.FixedText,
                 value=i,
@@ -551,7 +548,7 @@ https://huggingface.co/spaces/CompVis/stable-diffusion-license
             self.editing = False
         else:
             self.editing = True
-            
+
     def validate_field_values(self, opt: Namespace) -> bool:
         bad_fields = []
         if not opt.license_acceptance:
@@ -562,9 +559,9 @@ https://huggingface.co/spaces/CompVis/stable-diffusion-license
             bad_fields.append(
                 f"The output directory does not seem to be valid. Please check that {str(Path(opt.outdir).parent)} is an existing directory."
             )
-        if not Path(opt.embedding_dir).parent.exists():
+        if not Path(opt.embedding_path).parent.exists():
             bad_fields.append(
-                f"The embedding directory does not seem to be valid. Please check that {str(Path(opt.embedding_dir).parent)} is an existing directory."
+                f"The embedding directory does not seem to be valid. Please check that {str(Path(opt.embedding_path).parent)} is an existing directory."
             )
         if len(bad_fields) > 0:
             message = "The following problems were detected and must be corrected:\n"
@@ -579,24 +576,20 @@ https://huggingface.co/spaces/CompVis/stable-diffusion-license
         new_opts = Namespace()
 
         for attr in [
-                "outdir",
-                "nsfw_checker",
-                "free_gpu_mem",
-                "max_loaded_models",
-                "xformers_enabled",
-                "always_use_cpu",
-                "embedding_dir",
-                "lora_dir",
-                "controlnet_dir",
+            "outdir",
+            "safety_checker",
+            "free_gpu_mem",
+            "max_loaded_models",
+            "xformers",
+            "always_use_cpu",
+            "embedding_path",
+            "ckpt_convert",
         ]:
             setattr(new_opts, attr, getattr(self, attr).value)
 
         new_opts.hf_token = self.hf_token.value
         new_opts.license_acceptance = self.license_acceptance.value
         new_opts.precision = PRECISION_CHOICES[self.precision.value[0]]
-        
-        # widget library workaround to make max_loaded_models an int rather than a float
-        new_opts.max_loaded_models = int(new_opts.max_loaded_models)
 
         return new_opts
 
@@ -615,7 +608,6 @@ class EditOptApplication(npyscreen.NPSAppManaged):
             "MAIN",
             editOptsForm,
             name="InvokeAI Startup Options",
-            cycle_widgets=True,
         )
         if not (self.program_opts.skip_sd_weights or self.program_opts.default_only):
             self.model_select = self.addForm(
@@ -623,7 +615,6 @@ class EditOptApplication(npyscreen.NPSAppManaged):
                 addModelsForm,
                 name="Install Stable Diffusion Models",
                 multipage=True,
-                cycle_widgets=True,
             )
 
     def new_opts(self):
@@ -637,14 +628,18 @@ def edit_opts(program_opts: Namespace, invokeai_opts: Namespace) -> argparse.Nam
 
 
 def default_startup_options(init_file: Path) -> Namespace:
-    opts = InvokeAIAppConfig.get_config()
+    opts = Args().parse_args([])
+    outdir = Path(opts.outdir)
+    if not outdir.is_absolute():
+        opts.outdir = str(Globals.root / opts.outdir)
     if not init_file.exists():
-        opts.nsfw_checker = True
+        opts.safety_checker = True
     return opts
 
-def default_user_selections(program_opts: Namespace) -> UserSelections:
-    return UserSelections(
-        install_models=default_dataset()
+
+def default_user_selections(program_opts: Namespace) -> Namespace:
+    return Namespace(
+        starter_models=default_dataset()
         if program_opts.default_only
         else recommended_datasets()
         if program_opts.yes_to_all
@@ -652,27 +647,26 @@ def default_user_selections(program_opts: Namespace) -> UserSelections:
         purge_deleted_models=False,
         scan_directory=None,
         autoscan_on_startup=None,
+        import_model_paths=None,
+        convert_to_diffusers=None,
     )
 
 
 # -------------------------------------
-def initialize_rootdir(root: Path, yes_to_all: bool = False):
+def initialize_rootdir(root: str, yes_to_all: bool = False):
     print("** INITIALIZING INVOKEAI RUNTIME DIRECTORY **")
 
     for name in (
-            "models",
-            "configs",
-            "embeddings",
-            "databases",
-            "loras",
-            "controlnets",
-            "text-inversion-output",
-            "text-inversion-training-data",
+        "models",
+        "configs",
+        "embeddings",
+        "text-inversion-output",
+        "text-inversion-training-data",
     ):
         os.makedirs(os.path.join(root, name), exist_ok=True)
 
     configs_src = Path(configs.__path__[0])
-    configs_dest = root / "configs"
+    configs_dest = Path(root) / "configs"
     if not os.path.samefile(configs_src, configs_dest):
         shutil.copytree(configs_src, configs_dest, dirs_exist_ok=True)
 
@@ -683,17 +677,8 @@ def run_console_ui(
 ) -> (Namespace, Namespace):
     # parse_args() will read from init file if present
     invokeai_opts = default_startup_options(initfile)
-    invokeai_opts.root = program_opts.root
 
-    # The third argument is needed in the Windows 11 environment to
-    # launch a console window running this program.
-    set_min_terminal_size(MIN_COLS, MIN_LINES,'invokeai-configure')
-
-    # the install-models application spawns a subprocess to install
-    # models, and will crash unless this is set before running.
-    import torch
-    torch.multiprocessing.set_start_method("spawn")
-    
+    set_min_terminal_size(MIN_COLS, MIN_LINES)
     editApp = EditOptApplication(program_opts, invokeai_opts)
     editApp.run()
     if editApp.user_cancelled:
@@ -705,66 +690,70 @@ def run_console_ui(
 # -------------------------------------
 def write_opts(opts: Namespace, init_file: Path):
     """
-    Update the invokeai.yaml file with values from current settings.
+    Update the invokeai.init file with values from opts Namespace
     """
-    # this will load current settings
-    new_config = InvokeAIAppConfig.get_config()
-    new_config.root = config.root
-    
-    for key,value in opts.__dict__.items():
-        if hasattr(new_config,key):
-            setattr(new_config,key,value)
+    # touch file if it doesn't exist
+    if not init_file.exists():
+        with open(init_file, "w") as f:
+            f.write(INIT_FILE_PREAMBLE)
+
+    # We want to write in the changed arguments without clobbering
+    # any other initialization values the user has entered. There is
+    # no good way to do this because of the one-way nature of
+    # argparse: i.e. --outdir could be --outdir, --out, or -o
+    # initfile needs to be replaced with a fully structured format
+    # such as yaml; this is a hack that will work much of the time
+    args_to_skip = re.compile(
+        "^--?(o|out|no-xformer|xformer|no-ckpt|ckpt|free|no-nsfw|nsfw|prec|max_load|embed|always|ckpt|free_gpu)"
+    )
+    # fix windows paths
+    opts.outdir = opts.outdir.replace("\\", "/")
+    opts.embedding_path = opts.embedding_path.replace("\\", "/")
+    new_file = f"{init_file}.new"
+    try:
+        lines = [x.strip() for x in open(init_file, "r").readlines()]
+        with open(new_file, "w") as out_file:
+            for line in lines:
+                if len(line) > 0 and not args_to_skip.match(line):
+                    out_file.write(line + "\n")
+            out_file.write(
+                f"""
+--outdir={opts.outdir}
+--embedding_path={opts.embedding_path}
+--precision={opts.precision}
+--max_loaded_models={int(opts.max_loaded_models)}
+--{'no-' if not opts.safety_checker else ''}nsfw_checker
+--{'no-' if not opts.xformers else ''}xformers
+--{'no-' if not opts.ckpt_convert else ''}ckpt_convert
+{'--free_gpu_mem' if opts.free_gpu_mem else ''}
+{'--always_use_cpu' if opts.always_use_cpu else ''}
+"""
+            )
+    except OSError as e:
+        print(f"** An error occurred while writing the init file: {str(e)}")
+
+    os.replace(new_file, init_file)
+
+    if opts.hf_token:
+        HfLogin(opts.hf_token)
 
-    with open(init_file,'w', encoding='utf-8') as file:
-        file.write(new_config.to_yaml())
 
 # -------------------------------------
 def default_output_dir() -> Path:
-    return config.root_path / "outputs"
+    return Globals.root / "outputs"
+
 
 # -------------------------------------
 def default_embedding_dir() -> Path:
-    return config.root_path / "embeddings"
+    return Globals.root / "embeddings"
 
-# -------------------------------------
-def default_lora_dir() -> Path:
-    return config.root_path / "loras"
-
-# -------------------------------------
-def default_controlnet_dir() -> Path:
-    return config.root_path / "controlnets"
 
 # -------------------------------------
 def write_default_options(program_opts: Namespace, initfile: Path):
     opt = default_startup_options(initfile)
+    opt.hf_token = HfFolder.get_token()
     write_opts(opt, initfile)
 
-# -------------------------------------
-# Here we bring in
-# the legacy Args object in order to parse
-# the old init file and write out the new
-# yaml format.
-def migrate_init_file(legacy_format:Path):
-    old = legacy_parser.parse_args([f'@{str(legacy_format)}'])
-    new = InvokeAIAppConfig.get_config()
-
-    fields = list(get_type_hints(InvokeAIAppConfig).keys())
-    for attr in fields:
-        if hasattr(old,attr):
-            setattr(new,attr,getattr(old,attr))
-
-    # a few places where the field names have changed and we have to
-    # manually add in the new names/values
-    new.nsfw_checker = old.safety_checker
-    new.xformers_enabled = old.xformers
-    new.conf_path = old.conf
-    new.embedding_dir = old.embedding_path
-
-    invokeai_yaml = legacy_format.parent / 'invokeai.yaml'
-    with open(invokeai_yaml,"w", encoding="utf-8") as outfile:
-        outfile.write(new.to_yaml())
-
-    legacy_format.replace(legacy_format.parent / 'invokeai.init.old')
 
 # -------------------------------------
 def main():
@@ -820,13 +809,8 @@ def main():
     )
     opt = parser.parse_args()
 
-    invoke_args = []
-    if opt.root:
-        invoke_args.extend(['--root',opt.root])
-    if opt.full_precision:
-        invoke_args.extend(['--precision','float32'])
-    config.parse_args(invoke_args)
-    logger = InvokeAILogger().getLogger(config=config)
+    # setting a global here
+    Globals.root = Path(os.path.expanduser(get_root(opt.root) or ""))
 
     errors = set()
 
@@ -834,26 +818,19 @@ def main():
         models_to_download = default_user_selections(opt)
 
         # We check for to see if the runtime directory is correctly initialized.
-        old_init_file = config.root_path / 'invokeai.init'
-        new_init_file = config.root_path / 'invokeai.yaml'
-        if old_init_file.exists() and not new_init_file.exists():
-            print('** Migrating invokeai.init to invokeai.yaml')
-            migrate_init_file(old_init_file)
-            # Load new init file into config
-            config.parse_args(argv=[],conf=OmegaConf.load(new_init_file))
-
-        if not config.model_conf_path.exists():
-            initialize_rootdir(config.root_path, opt.yes_to_all)
+        init_file = Path(Globals.root, Globals.initfile)
+        if not init_file.exists() or not global_config_file().exists():
+            initialize_rootdir(Globals.root, opt.yes_to_all)
 
         if opt.yes_to_all:
-            write_default_options(opt, new_init_file)
+            write_default_options(opt, init_file)
             init_options = Namespace(
                 precision="float32" if opt.full_precision else "float16"
             )
         else:
-            init_options, models_to_download = run_console_ui(opt, new_init_file)
+            init_options, models_to_download = run_console_ui(opt, init_file)
             if init_options:
-                write_opts(init_options, new_init_file)
+                write_opts(init_options, init_file)
             else:
                 print(
                     '\n** CANCELLED AT USER\'S REQUEST. USE THE "invoke.sh" LAUNCHER TO RUN LATER **\n'
@@ -863,7 +840,7 @@ def main():
         if opt.skip_support_models:
             print("\n** SKIPPING SUPPORT MODEL DOWNLOADS PER USER REQUEST **")
         else:
-            print("\n** CHECKING/UPDATING SUPPORT MODELS **")
+            print("\n** DOWNLOADING SUPPORT MODELS **")
             download_bert()
             download_sd1_clip()
             download_sd2_clip()
@@ -881,8 +858,6 @@ def main():
             process_and_execute(opt, models_to_download)
 
         postscript(errors=errors)
-        if not opt.yes_to_all:
-            input('Press any key to continue...')
     except KeyboardInterrupt:
         print("\nGoodbye! Come back soon.")
 

invokeai/backend/config/model_install_backend.py

@@ -6,30 +6,26 @@ import re
 import shutil
 import sys
 import warnings
-from dataclasses import dataclass,field
 from pathlib import Path
 from tempfile import TemporaryFile
-from typing import List, Dict, Callable
+from typing import List
 
 import requests
 from diffusers import AutoencoderKL
-from huggingface_hub import hf_hub_url, HfFolder
+from huggingface_hub import hf_hub_url
 from omegaconf import OmegaConf
 from omegaconf.dictconfig import DictConfig
 from tqdm import tqdm
 
 import invokeai.configs as configs
 
-
-from invokeai.app.services.config import InvokeAIAppConfig
+from ..globals import Globals, global_cache_dir, global_config_dir
+from ..model_management import ModelManager
 from ..stable_diffusion import StableDiffusionGeneratorPipeline
-from ..util.logging import InvokeAILogger
 
 warnings.filterwarnings("ignore")
 
 # --------------------------globals-----------------------
-config = InvokeAIAppConfig.get_config()
-
 Model_dir = "models"
 Weights_dir = "ldm/stable-diffusion-v1/"
 
@@ -39,9 +35,6 @@ Dataset_path = Path(configs.__path__[0]) / "INITIAL_MODELS.yaml"
 # initial models omegaconf
 Datasets = None
 
-# logger
-logger = InvokeAILogger.getLogger(name='InvokeAI')
-
 Config_preamble = """
 # This file describes the alternative machine learning models
 # available to InvokeAI script.
@@ -52,98 +45,58 @@ Config_preamble = """
 # was trained on.
 """
 
-@dataclass
-class ModelInstallList:
-    '''Class for listing models to be installed/removed'''
-    install_models: List[str] = field(default_factory=list)
-    remove_models: List[str] = field(default_factory=list)
 
-@dataclass
-class UserSelections():
-    install_models: List[str]= field(default_factory=list)
-    remove_models: List[str]=field(default_factory=list)
-    purge_deleted_models: bool=field(default_factory=list)
-    install_cn_models: List[str] = field(default_factory=list)
-    remove_cn_models: List[str] = field(default_factory=list)
-    install_lora_models: List[str] = field(default_factory=list)
-    remove_lora_models: List[str] = field(default_factory=list)
-    install_ti_models: List[str] = field(default_factory=list)
-    remove_ti_models: List[str] = field(default_factory=list)
-    scan_directory: Path = None
-    autoscan_on_startup: bool=False
-    import_model_paths: str=None
-        
 def default_config_file():
-    return config.model_conf_path
+    return Path(global_config_dir()) / "models.yaml"
+
 
 def sd_configs():
-    return config.legacy_conf_path
+    return Path(global_config_dir()) / "stable-diffusion"
+
 
 def initial_models():
     global Datasets
     if Datasets:
         return Datasets
-    return (Datasets := OmegaConf.load(Dataset_path)['diffusers'])
+    return (Datasets := OmegaConf.load(Dataset_path))
+
 
 def install_requested_models(
-        diffusers: ModelInstallList = None,
-        controlnet: ModelInstallList = None,
-        lora: ModelInstallList = None,
-        ti: ModelInstallList = None,
-        cn_model_map: Dict[str,str] = None, # temporary - move to model manager
-        scan_directory: Path = None,
-        external_models: List[str] = None,
-        scan_at_startup: bool = False,
-        precision: str = "float16",
-        purge_deleted: bool = False,
-        config_file_path: Path = None,
-        model_config_file_callback:  Callable[[Path],Path] = None
+    install_initial_models: List[str] = None,
+    remove_models: List[str] = None,
+    scan_directory: Path = None,
+    external_models: List[str] = None,
+    scan_at_startup: bool = False,
+    precision: str = "float16",
+    purge_deleted: bool = False,
+    config_file_path: Path = None,
 ):
     """
     Entry point for installing/deleting starter models, or installing external models.
     """
-    access_token = HfFolder.get_token()
     config_file_path = config_file_path or default_config_file()
     if not config_file_path.exists():
         open(config_file_path, "w")
 
-    # prevent circular import here
-    from ..model_management import ModelManager
     model_manager = ModelManager(OmegaConf.load(config_file_path), precision=precision)
-    if controlnet:
-        model_manager.install_controlnet_models(controlnet.install_models, access_token=access_token)
-        model_manager.delete_controlnet_models(controlnet.remove_models)
 
-    if lora:
-        model_manager.install_lora_models(lora.install_models, access_token=access_token)
-        model_manager.delete_lora_models(lora.remove_models)
+    if remove_models and len(remove_models) > 0:
+        print("== DELETING UNCHECKED STARTER MODELS ==")
+        for model in remove_models:
+            print(f"{model}...")
+            model_manager.del_model(model, delete_files=purge_deleted)
+        model_manager.commit(config_file_path)
 
-    if ti:
-        model_manager.install_ti_models(ti.install_models, access_token=access_token)
-        model_manager.delete_ti_models(ti.remove_models)
-
-    if diffusers:
-        # TODO: Replace next three paragraphs with calls into new model manager
-        if diffusers.remove_models and len(diffusers.remove_models) > 0:
-            logger.info("Processing requested deletions")
-            for model in diffusers.remove_models:
-                logger.info(f"{model}...")
-                model_manager.del_model(model, delete_files=purge_deleted)
-            model_manager.commit(config_file_path)
-
-        if diffusers.install_models and len(diffusers.install_models) > 0:
-            logger.info("Installing requested models")
-            downloaded_paths = download_weight_datasets(
-                models=diffusers.install_models,
-                access_token=None,
-                precision=precision,
-            )
-            successful = {x:v for x,v in downloaded_paths.items() if v is not None}
-            if len(successful) > 0:
-                update_config_file(successful, config_file_path)
-            if len(successful) < len(diffusers.install_models):
-                unsuccessful = [x for x in downloaded_paths if downloaded_paths[x] is None]
-                logger.warning(f"Some of the model downloads were not successful: {unsuccessful}")
+    if install_initial_models and len(install_initial_models) > 0:
+        print("== INSTALLING SELECTED STARTER MODELS ==")
+        successfully_downloaded = download_weight_datasets(
+            models=install_initial_models,
+            access_token=None,
+            precision=precision,
+        )  # FIX: for historical reasons, we don't use model manager here
+        update_config_file(successfully_downloaded, config_file_path)
+        if len(successfully_downloaded) < len(install_initial_models):
+            print("** Some of the model downloads were not successful")
 
     # due to above, we have to reload the model manager because conf file
     # was changed behind its back
@@ -154,14 +107,12 @@ def install_requested_models(
         external_models.append(str(scan_directory))
 
     if len(external_models) > 0:
-        logger.info("INSTALLING EXTERNAL MODELS")
+        print("== INSTALLING EXTERNAL MODELS ==")
         for path_url_or_repo in external_models:
             try:
-                logger.debug(f'In install_requested_models; callback = {model_config_file_callback}')
                 model_manager.heuristic_import(
                     path_url_or_repo,
                     commit_to_conf=config_file_path,
-                    config_file_callback = model_config_file_callback,
                 )
             except KeyboardInterrupt:
                 sys.exit(-1)
@@ -169,22 +120,17 @@ def install_requested_models(
                 pass
 
     if scan_at_startup and scan_directory.is_dir():
-        update_autoconvert_dir(scan_directory)
-    else:
-        update_autoconvert_dir(None)
-
-def update_autoconvert_dir(autodir: Path):
-    '''
-    Update the "autoconvert_dir" option in invokeai.yaml
-    '''
-    invokeai_config_path = config.init_file_path
-    conf = OmegaConf.load(invokeai_config_path)
-    conf.InvokeAI.Paths.autoconvert_dir = str(autodir) if autodir else None
-    yaml = OmegaConf.to_yaml(conf)
-    tmpfile = invokeai_config_path.parent / "new_config.tmp"
-    with open(tmpfile, "w", encoding="utf-8") as outfile:
-        outfile.write(yaml)
-    tmpfile.replace(invokeai_config_path)
+        argument = "--autoconvert"
+        initfile = Path(Globals.root, Globals.initfile)
+        replacement = Path(Globals.root, f"{Globals.initfile}.new")
+        directory = str(scan_directory).replace("\\", "/")
+        with open(initfile, "r") as input:
+            with open(replacement, "w") as output:
+                while line := input.readline():
+                    if not line.startswith(argument):
+                        output.writelines([line])
+                output.writelines([f"{argument} {directory}"])
+        os.replace(replacement, initfile)
 
 
 # -------------------------------------
@@ -196,21 +142,33 @@ def yes_or_no(prompt: str, default_yes=True):
     else:
         return response[0] in ("y", "Y")
 
+
+# -------------------------------------
+def get_root(root: str = None) -> str:
+    if root:
+        return root
+    elif os.environ.get("INVOKEAI_ROOT"):
+        return os.environ.get("INVOKEAI_ROOT")
+    else:
+        return Globals.root
+
+
 # ---------------------------------------------
-def recommended_datasets() -> List['str']:
-    datasets = set()
+def recommended_datasets() -> dict:
+    datasets = dict()
     for ds in initial_models().keys():
         if initial_models()[ds].get("recommended", False):
-            datasets.add(ds)
-    return list(datasets)
+            datasets[ds] = True
+    return datasets
+
 
 # ---------------------------------------------
 def default_dataset() -> dict:
-    datasets = set()
+    datasets = dict()
     for ds in initial_models().keys():
         if initial_models()[ds].get("default", False):
-            datasets.add(ds)
-    return list(datasets)
+            datasets[ds] = True
+    return datasets
 
 
 # ---------------------------------------------
@@ -225,14 +183,14 @@ def all_datasets() -> dict:
 # look for legacy model.ckpt in models directory and offer to
 # normalize its name
 def migrate_models_ckpt():
-    model_path = os.path.join(config.root_dir, Model_dir, Weights_dir)
+    model_path = os.path.join(Globals.root, Model_dir, Weights_dir)
     if not os.path.exists(os.path.join(model_path, "model.ckpt")):
         return
     new_name = initial_models()["stable-diffusion-1.4"]["file"]
-    logger.warning(
+    print(
         'The Stable Diffusion v4.1 "model.ckpt" is already installed. The name will be changed to {new_name} to avoid confusion.'
     )
-    logger.warning(f"model.ckpt => {new_name}")
+    print(f"model.ckpt => {new_name}")
     os.replace(
         os.path.join(model_path, "model.ckpt"), os.path.join(model_path, new_name)
     )
@@ -245,7 +203,7 @@ def download_weight_datasets(
     migrate_models_ckpt()
     successful = dict()
     for mod in models:
-        logger.info(f"Downloading {mod}:")
+        print(f"Downloading {mod}:")
         successful[mod] = _download_repo_or_file(
             initial_models()[mod], access_token, precision=precision
         )
@@ -266,10 +224,11 @@ def _download_repo_or_file(
             )
     return path
 
+
 def _download_ckpt_weights(mconfig: DictConfig, access_token: str) -> Path:
     repo_id = mconfig["repo_id"]
     filename = mconfig["file"]
-    cache_dir = os.path.join(config.root_dir, Model_dir, Weights_dir)
+    cache_dir = os.path.join(Globals.root, Model_dir, Weights_dir)
     return hf_download_with_resume(
         repo_id=repo_id,
         model_dir=cache_dir,
@@ -280,12 +239,9 @@ def _download_ckpt_weights(mconfig: DictConfig, access_token: str) -> Path:
 
 # ---------------------------------------------
 def download_from_hf(
-    model_class: object, model_name: str, **kwargs
+    model_class: object, model_name: str, cache_subdir: Path = Path("hub"), **kwargs
 ):
-    logger = InvokeAILogger.getLogger('InvokeAI')
-    logger.addFilter(lambda x: 'fp16 is not a valid' not in x.getMessage())
-    
-    path = config.cache_dir
+    path = global_cache_dir(cache_subdir)
     model = model_class.from_pretrained(
         model_name,
         cache_dir=path,
@@ -316,10 +272,10 @@ def _download_diffusion_weights(
                 **extra_args,
             )
         except OSError as e:
-            if 'Revision Not Found' in str(e):
+            if str(e).startswith("fp16 is not a valid"):
                 pass
             else:
-                logger.error(str(e))
+                print(f"An unexpected error occurred while downloading the model: {e})")
         if path:
             break
     return path
@@ -327,13 +283,9 @@ def _download_diffusion_weights(
 
 # ---------------------------------------------
 def hf_download_with_resume(
-        repo_id: str,
-        model_dir: str,
-        model_name: str,
-        model_dest: Path = None,
-        access_token: str = None,
+    repo_id: str, model_dir: str, model_name: str, access_token: str = None
 ) -> Path:
-    model_dest = model_dest or Path(os.path.join(model_dir, model_name))
+    model_dest = Path(os.path.join(model_dir, model_name))
     os.makedirs(model_dir, exist_ok=True)
 
     url = hf_hub_url(repo_id, model_name)
@@ -353,19 +305,20 @@ def hf_download_with_resume(
     if (
         resp.status_code == 416
     ):  # "range not satisfiable", which means nothing to return
-        logger.info(f"{model_name}: complete file found. Skipping.")
+        print(f"* {model_name}: complete file found. Skipping.")
         return model_dest
-    elif resp.status_code == 404:
-        logger.warning("File not found")
-        return None
     elif resp.status_code != 200:
-        logger.warning(f"{model_name}: {resp.reason}")
+        print(f"** An error occurred during downloading {model_name}: {resp.reason}")
     elif exist_size > 0:
-        logger.info(f"{model_name}: partial file found. Resuming...")
+        print(f"* {model_name}: partial file found. Resuming...")
     else:
-        logger.info(f"{model_name}: Downloading...")
+        print(f"* {model_name}: Downloading...")
 
     try:
+        if total < 2000:
+            print(f"*** ERROR DOWNLOADING {model_name}: {resp.text}")
+            return None
+
         with open(model_dest, open_mode) as file, tqdm(
             desc=model_name,
             initial=exist_size,
@@ -378,7 +331,7 @@ def hf_download_with_resume(
                 size = file.write(data)
                 bar.update(size)
     except Exception as e:
-        logger.error(f"An error occurred while downloading {model_name}: {str(e)}")
+        print(f"An error occurred while downloading {model_name}: {str(e)}")
         return None
     return model_dest
 
@@ -403,8 +356,8 @@ def update_config_file(successfully_downloaded: dict, config_file: Path):
     try:
         backup = None
         if os.path.exists(config_file):
-            logger.warning(
-                f"{config_file.name} exists. Renaming to {config_file.stem}.yaml.orig"
+            print(
+                f"** {config_file.name} exists. Renaming to {config_file.stem}.yaml.orig"
             )
             backup = config_file.with_suffix(".yaml.orig")
             ## Ugh. Windows is unable to overwrite an existing backup file, raises a WinError 183
@@ -421,16 +374,16 @@ def update_config_file(successfully_downloaded: dict, config_file: Path):
                 new_config.write(tmp.read())
 
     except Exception as e:
-        logger.error(f"Error creating config file {config_file}: {str(e)}")
+        print(f"**Error creating config file {config_file}: {str(e)} **")
         if backup is not None:
-            logger.info("restoring previous config file")
+            print("restoring previous config file")
             ## workaround, for WinError 183, see above
             if sys.platform == "win32" and config_file.is_file():
                 config_file.unlink()
             backup.rename(config_file)
         return
-    
-    logger.info(f"Successfully created new configuration file {config_file}")
+
+    print(f"Successfully created new configuration file {config_file}")
 
 
 # ---------------------------------------------
@@ -464,7 +417,7 @@ def new_config_file_contents(
             stanza["height"] = mod["height"]
         if "file" in mod:
             stanza["weights"] = os.path.relpath(
-                successfully_downloaded[model], start=config.root_dir
+                successfully_downloaded[model], start=Globals.root
             )
             stanza["config"] = os.path.normpath(
                 os.path.join(sd_configs(), mod["config"])
@@ -497,14 +450,14 @@ def delete_weights(model_name: str, conf_stanza: dict):
     if re.match("/VAE/", conf_stanza.get("config")):
         return
 
-    logger.warning(
-        f"\nThe checkpoint version of {model_name} is superseded by the diffusers version. Deleting the original file {weights}?"
+    print(
+        f"\n** The checkpoint version of {model_name} is superseded by the diffusers version. Deleting the original file {weights}?"
     )
 
     weights = Path(weights)
     if not weights.is_absolute():
-        weights = config.root_dir / weights
+        weights = Path(Globals.root) / weights
         try:
             weights.unlink()
         except OSError as e:
-            logger.error(str(e))
+            print(str(e))

invokeai/backend/generator/__init__.py

@@ -5,6 +5,7 @@ from .base import (
     InvokeAIGenerator,
     InvokeAIGeneratorBasicParams,
     InvokeAIGeneratorOutput,
+    Txt2Img,
     Img2Img,
     Inpaint,
     Generator,

invokeai/backend/generator/base.py

@@ -25,12 +25,11 @@ from typing import Callable, List, Iterator, Optional, Type
 from dataclasses import dataclass, field
 from diffusers.schedulers import SchedulerMixin as Scheduler
 
-import invokeai.backend.util.logging as logger
 from ..image_util import configure_model_padding
 from ..util.util import rand_perlin_2d
 from ..safety_checker import SafetyChecker
+from ..prompting.conditioning import get_uc_and_c_and_ec
 from ..stable_diffusion.diffusers_pipeline import StableDiffusionGeneratorPipeline
-from ..stable_diffusion.schedulers import SCHEDULER_MAP
 
 downsampling = 8
 
@@ -71,6 +70,19 @@ class InvokeAIGeneratorOutput:
 # we are interposing a wrapper around the original Generator classes so that
 # old code that calls Generate will continue to work.
 class InvokeAIGenerator(metaclass=ABCMeta):
+    scheduler_map = dict(
+        ddim=diffusers.DDIMScheduler,
+        dpmpp_2=diffusers.DPMSolverMultistepScheduler,
+        k_dpm_2=diffusers.KDPM2DiscreteScheduler,
+        k_dpm_2_a=diffusers.KDPM2AncestralDiscreteScheduler,
+        k_dpmpp_2=diffusers.DPMSolverMultistepScheduler,
+        k_euler=diffusers.EulerDiscreteScheduler,
+        k_euler_a=diffusers.EulerAncestralDiscreteScheduler,
+        k_heun=diffusers.HeunDiscreteScheduler,
+        k_lms=diffusers.LMSDiscreteScheduler,
+        plms=diffusers.PNDMScheduler,
+    )
+
     def __init__(self,
                  model_info: dict,
                  params: InvokeAIGeneratorBasicParams=InvokeAIGeneratorBasicParams(),
@@ -80,15 +92,13 @@ class InvokeAIGenerator(metaclass=ABCMeta):
         self.params=params
         self.kwargs = kwargs
 
-    def generate(
-        self,
-        conditioning: tuple,
-        scheduler,
-        callback: Optional[Callable]=None,
-        step_callback: Optional[Callable]=None,
-        iterations: int=1,
-        **keyword_args,
-    )->Iterator[InvokeAIGeneratorOutput]:
+    def generate(self,
+                 prompt: str='',
+                 callback: Optional[Callable]=None,
+                 step_callback: Optional[Callable]=None,
+                 iterations: int=1,
+                 **keyword_args,
+                 )->Iterator[InvokeAIGeneratorOutput]:
         '''
         Return an iterator across the indicated number of generations.
         Each time the iterator is called it will return an InvokeAIGeneratorOutput
@@ -114,46 +124,54 @@ class InvokeAIGenerator(metaclass=ABCMeta):
         generator_args.update(keyword_args)
 
         model_info = self.model_info
-        model_name = model_info.name
-        model_hash = model_info.hash
-        with model_info.context as model:
-            gen_class = self._generator_class()
-            generator = gen_class(model, self.params.precision, **self.kwargs)
-            if self.params.variation_amount > 0:
-                generator.set_variation(generator_args.get('seed'),
-                                        generator_args.get('variation_amount'),
-                                        generator_args.get('with_variations')
-                                        )
+        model_name = model_info['model_name']
+        model:StableDiffusionGeneratorPipeline = model_info['model']
+        model_hash = model_info['hash']
+        scheduler: Scheduler = self.get_scheduler(
+            model=model,
+            scheduler_name=generator_args.get('scheduler')
+        )
 
-            if isinstance(model, DiffusionPipeline):
-                for component in [model.unet, model.vae]:
-                    configure_model_padding(component,
-                                            generator_args.get('seamless',False),
-                                            generator_args.get('seamless_axes')
-                                            )
-            else:
-                configure_model_padding(model,
+        # get conditioning from prompt via Compel package
+        uc, c, extra_conditioning_info = get_uc_and_c_and_ec(prompt, model=model)
+
+        gen_class = self._generator_class()
+        generator = gen_class(model, self.params.precision, **self.kwargs)
+        if self.params.variation_amount > 0:
+            generator.set_variation(generator_args.get('seed'),
+                                    generator_args.get('variation_amount'),
+                                    generator_args.get('with_variations')
+                                    )
+
+        if isinstance(model, DiffusionPipeline):
+            for component in [model.unet, model.vae]:
+                configure_model_padding(component,
                                         generator_args.get('seamless',False),
                                         generator_args.get('seamless_axes')
                                         )
+        else:
+            configure_model_padding(model,
+                                    generator_args.get('seamless',False),
+                                    generator_args.get('seamless_axes')
+                                    )
 
-            iteration_count = range(iterations) if iterations else itertools.count(start=0, step=1)
-            for i in iteration_count:
-                results = generator.generate(
-                    conditioning=conditioning,
-                    step_callback=step_callback,
-                    sampler=scheduler,
-                    **generator_args,
-                )
-                output = InvokeAIGeneratorOutput(
-                    image=results[0][0],
-                    seed=results[0][1],
-                    attention_maps_images=results[0][2],
-                    model_hash = model_hash,
-                    params=Namespace(model_name=model_name,**generator_args),
-                )
-                if callback:
-                    callback(output)
+        iteration_count = range(iterations) if iterations else itertools.count(start=0, step=1)
+        for i in iteration_count:
+            results = generator.generate(prompt,
+                                         conditioning=(uc, c, extra_conditioning_info),
+                                         step_callback=step_callback,
+                                         sampler=scheduler,
+                                         **generator_args,
+                                         )
+            output = InvokeAIGeneratorOutput(
+                image=results[0][0],
+                seed=results[0][1],
+                attention_maps_images=results[0][2],
+                model_hash = model_hash,
+                params=Namespace(model_name=model_name,**generator_args),
+            )
+            if callback:
+                callback(output)
             yield output
 
     @classmethod
@@ -161,11 +179,19 @@ class InvokeAIGenerator(metaclass=ABCMeta):
         '''
         Return list of all the schedulers that we currently handle.
         '''
-        return list(SCHEDULER_MAP.keys())
+        return list(self.scheduler_map.keys())
 
     def load_generator(self, model: StableDiffusionGeneratorPipeline, generator_class: Type[Generator]):
         return generator_class(model, self.params.precision)
 
+    def get_scheduler(self, scheduler_name:str, model: StableDiffusionGeneratorPipeline)->Scheduler:
+        scheduler_class = self.scheduler_map.get(scheduler_name,'ddim')
+        scheduler = scheduler_class.from_config(model.scheduler.config)
+        # hack copied over from generate.py
+        if not hasattr(scheduler, 'uses_inpainting_model'):
+            scheduler.uses_inpainting_model = lambda: False
+        return scheduler
+
     @classmethod
     def _generator_class(cls)->Type[Generator]:
         '''
@@ -175,6 +201,13 @@ class InvokeAIGenerator(metaclass=ABCMeta):
         '''
         return Generator
 
+# ------------------------------------
+class Txt2Img(InvokeAIGenerator):
+    @classmethod
+    def _generator_class(cls):
+        from .txt2img import Txt2Img
+        return Txt2Img
+
 # ------------------------------------
 class Img2Img(InvokeAIGenerator):
     def generate(self,
@@ -197,10 +230,10 @@ class Inpaint(Img2Img):
     def generate(self,
                  mask_image: Image.Image | torch.FloatTensor,
                  # Seam settings - when 0, doesn't fill seam
-                 seam_size: int = 96,
-                 seam_blur: int = 16,
+                 seam_size: int = 0,
+                 seam_blur: int = 0,
                  seam_strength: float = 0.7,
-                 seam_steps: int = 30,
+                 seam_steps: int = 10,
                  tile_size: int = 32,
                  inpaint_replace=False,
                  infill_method=None,
@@ -228,6 +261,25 @@ class Inpaint(Img2Img):
         from .inpaint import Inpaint
         return Inpaint
 
+# ------------------------------------
+class Embiggen(Txt2Img):
+    def generate(
+            self,
+            embiggen: list=None,
+            embiggen_tiles: list = None,
+            strength: float=0.75,
+            **kwargs)->Iterator[InvokeAIGeneratorOutput]:
+        return super().generate(embiggen=embiggen,
+                                embiggen_tiles=embiggen_tiles,
+                                strength=strength,
+                                **kwargs)
+
+    @classmethod
+    def _generator_class(cls):
+        from .embiggen import Embiggen
+        return Embiggen
+
+
 class Generator:
     downsampling_factor: int
     latent_channels: int
@@ -238,7 +290,7 @@ class Generator:
         self.model = model
         self.precision = precision
         self.seed = None
-        self.latent_channels = model.unet.config.in_channels
+        self.latent_channels = model.channels
         self.downsampling_factor = downsampling  # BUG: should come from model or config
         self.safety_checker = None
         self.perlin = 0.0
@@ -249,7 +301,7 @@ class Generator:
         self.free_gpu_mem = None
 
     # this is going to be overridden in img2img.py, txt2img.py and inpaint.py
-    def get_make_image(self, **kwargs):
+    def get_make_image(self, prompt, **kwargs):
         """
         Returns a function returning an image derived from the prompt and the initial image
         Return value depends on the seed at the time you call it
@@ -265,6 +317,7 @@ class Generator:
 
     def generate(
         self,
+        prompt,
         width,
         height,
         sampler,
@@ -289,6 +342,7 @@ class Generator:
             saver.get_stacked_maps_image()
         )
         make_image = self.get_make_image(
+            prompt,
             sampler=sampler,
             init_image=init_image,
             width=width,
@@ -305,7 +359,6 @@ class Generator:
         seed = seed if seed is not None and seed >= 0 else self.new_seed()
         first_seed = seed
         seed, initial_noise = self.generate_initial_noise(seed, width, height)
-
         # There used to be an additional self.model.ema_scope() here, but it breaks
         # the inpaint-1.5 model. Not sure what it did.... ?
         with scope(self.model.device.type):
@@ -323,7 +376,7 @@ class Generator:
                     try:
                         x_T = self.get_noise(width, height)
                     except:
-                        logger.error("An error occurred while getting initial noise")
+                        print("** An error occurred while getting initial noise **")
                         print(traceback.format_exc())
 
                 # Pass on the seed in case a layer beneath us needs to generate noise on its own.
@@ -558,7 +611,7 @@ class Generator:
         image = self.sample_to_image(sample)
         dirname = os.path.dirname(filepath) or "."
         if not os.path.exists(dirname):
-            logger.info(f"creating directory {dirname}")
+            print(f"** creating directory {dirname}")
             os.makedirs(dirname, exist_ok=True)
         image.save(filepath, "PNG")
 

invokeai/backend/generator/embiggen.py

@@ -0,0 +1,558 @@
+"""
+invokeai.backend.generator.embiggen descends from .generator
+and generates with .generator.img2img
+"""
+
+import numpy as np
+import torch
+from PIL import Image
+from tqdm import trange
+
+from .base import Generator
+from .img2img import Img2Img
+
+
+class Embiggen(Generator):
+    def __init__(self, model, precision):
+        super().__init__(model, precision)
+        self.init_latent = None
+
+    # Replace generate because Embiggen doesn't need/use most of what it does normallly
+    def generate(
+        self,
+        prompt,
+        iterations=1,
+        seed=None,
+        image_callback=None,
+        step_callback=None,
+        **kwargs,
+    ):
+        make_image = self.get_make_image(prompt, step_callback=step_callback, **kwargs)
+        results = []
+        seed = seed if seed else self.new_seed()
+
+        # Noise will be generated by the Img2Img generator when called
+        for _ in trange(iterations, desc="Generating"):
+            # make_image will call Img2Img which will do the equivalent of get_noise itself
+            image = make_image()
+            results.append([image, seed])
+            if image_callback is not None:
+                image_callback(image, seed, prompt_in=prompt)
+            seed = self.new_seed()
+        return results
+
+    @torch.no_grad()
+    def get_make_image(
+        self,
+        prompt,
+        sampler,
+        steps,
+        cfg_scale,
+        ddim_eta,
+        conditioning,
+        init_img,
+        strength,
+        width,
+        height,
+        embiggen,
+        embiggen_tiles,
+        step_callback=None,
+        **kwargs,
+    ):
+        """
+        Returns a function returning an image derived from the prompt and multi-stage twice-baked potato layering over the img2img on the initial image
+        Return value depends on the seed at the time you call it
+        """
+        assert (
+            not sampler.uses_inpainting_model()
+        ), "--embiggen is not supported by inpainting models"
+
+        # Construct embiggen arg array, and sanity check arguments
+        if embiggen == None:  # embiggen can also be called with just embiggen_tiles
+            embiggen = [1.0]  # If not specified, assume no scaling
+        elif embiggen[0] < 0:
+            embiggen[0] = 1.0
+            print(
+                ">> Embiggen scaling factor cannot be negative, fell back to the default of 1.0 !"
+            )
+        if len(embiggen) < 2:
+            embiggen.append(0.75)
+        elif embiggen[1] > 1.0 or embiggen[1] < 0:
+            embiggen[1] = 0.75
+            print(
+                ">> Embiggen upscaling strength for ESRGAN must be between 0 and 1, fell back to the default of 0.75 !"
+            )
+        if len(embiggen) < 3:
+            embiggen.append(0.25)
+        elif embiggen[2] < 0:
+            embiggen[2] = 0.25
+            print(
+                ">> Overlap size for Embiggen must be a positive ratio between 0 and 1 OR a number of pixels, fell back to the default of 0.25 !"
+            )
+
+        # Convert tiles from their user-freindly count-from-one to count-from-zero, because we need to do modulo math
+        # and then sort them, because... people.
+        if embiggen_tiles:
+            embiggen_tiles = list(map(lambda n: n - 1, embiggen_tiles))
+            embiggen_tiles.sort()
+
+        if strength >= 0.5:
+            print(
+                f"* WARNING: Embiggen may produce mirror motifs if the strength (-f) is too high (currently {strength}). Try values between 0.35-0.45."
+            )
+
+        # Prep img2img generator, since we wrap over it
+        gen_img2img = Img2Img(self.model, self.precision)
+
+        # Open original init image (not a tensor) to manipulate
+        initsuperimage = Image.open(init_img)
+
+        with Image.open(init_img) as img:
+            initsuperimage = img.convert("RGB")
+
+        # Size of the target super init image in pixels
+        initsuperwidth, initsuperheight = initsuperimage.size
+
+        # Increase by scaling factor if not already resized, using ESRGAN as able
+        if embiggen[0] != 1.0:
+            initsuperwidth = round(initsuperwidth * embiggen[0])
+            initsuperheight = round(initsuperheight * embiggen[0])
+            if embiggen[1] > 0:  # No point in ESRGAN upscaling if strength is set zero
+                from ..restoration.realesrgan import ESRGAN
+
+                esrgan = ESRGAN()
+                print(
+                    f">> ESRGAN upscaling init image prior to cutting with Embiggen with strength {embiggen[1]}"
+                )
+                if embiggen[0] > 2:
+                    initsuperimage = esrgan.process(
+                        initsuperimage,
+                        embiggen[1],  # upscale strength
+                        self.seed,
+                        4,  # upscale scale
+                    )
+                else:
+                    initsuperimage = esrgan.process(
+                        initsuperimage,
+                        embiggen[1],  # upscale strength
+                        self.seed,
+                        2,  # upscale scale
+                    )
+            # We could keep recursively re-running ESRGAN for a requested embiggen[0] larger than 4x
+            #   but from personal experiance it doesn't greatly improve anything after 4x
+            # Resize to target scaling factor resolution
+            initsuperimage = initsuperimage.resize(
+                (initsuperwidth, initsuperheight), Image.Resampling.LANCZOS
+            )
+
+        # Use width and height as tile widths and height
+        # Determine buffer size in pixels
+        if embiggen[2] < 1:
+            if embiggen[2] < 0:
+                embiggen[2] = 0
+            overlap_size_x = round(embiggen[2] * width)
+            overlap_size_y = round(embiggen[2] * height)
+        else:
+            overlap_size_x = round(embiggen[2])
+            overlap_size_y = round(embiggen[2])
+
+        # With overall image width and height known, determine how many tiles we need
+        def ceildiv(a, b):
+            return -1 * (-a // b)
+
+        # X and Y needs to be determined independantly (we may have savings on one based on the buffer pixel count)
+        # (initsuperwidth - width) is the area remaining to the right that we need to layers tiles to fill
+        # (width - overlap_size_x) is how much new we can fill with a single tile
+        emb_tiles_x = 1
+        emb_tiles_y = 1
+        if (initsuperwidth - width) > 0:
+            emb_tiles_x = ceildiv(initsuperwidth - width, width - overlap_size_x) + 1
+        if (initsuperheight - height) > 0:
+            emb_tiles_y = ceildiv(initsuperheight - height, height - overlap_size_y) + 1
+        # Sanity
+        assert (
+            emb_tiles_x > 1 or emb_tiles_y > 1
+        ), f"ERROR: Based on the requested dimensions of {initsuperwidth}x{initsuperheight} and tiles of {width}x{height} you don't need to Embiggen! Check your arguments."
+
+        # Prep alpha layers --------------
+        # https://stackoverflow.com/questions/69321734/how-to-create-different-transparency-like-gradient-with-python-pil
+        # agradientL is Left-side transparent
+        agradientL = (
+            Image.linear_gradient("L").rotate(90).resize((overlap_size_x, height))
+        )
+        # agradientT is Top-side transparent
+        agradientT = Image.linear_gradient("L").resize((width, overlap_size_y))
+        # radial corner is the left-top corner, made full circle then cut to just the left-top quadrant
+        agradientC = Image.new("L", (256, 256))
+        for y in range(256):
+            for x in range(256):
+                # Find distance to lower right corner (numpy takes arrays)
+                distanceToLR = np.sqrt([(255 - x) ** 2 + (255 - y) ** 2])[0]
+                # Clamp values to max 255
+                if distanceToLR > 255:
+                    distanceToLR = 255
+                # Place the pixel as invert of distance
+                agradientC.putpixel((x, y), round(255 - distanceToLR))
+
+        # Create alternative asymmetric diagonal corner to use on "tailing" intersections to prevent hard edges
+        # Fits for a left-fading gradient on the bottom side and full opacity on the right side.
+        agradientAsymC = Image.new("L", (256, 256))
+        for y in range(256):
+            for x in range(256):
+                value = round(max(0, x - (255 - y)) * (255 / max(1, y)))
+                # Clamp values
+                value = max(0, value)
+                value = min(255, value)
+                agradientAsymC.putpixel((x, y), value)
+
+        # Create alpha layers default fully white
+        alphaLayerL = Image.new("L", (width, height), 255)
+        alphaLayerT = Image.new("L", (width, height), 255)
+        alphaLayerLTC = Image.new("L", (width, height), 255)
+        # Paste gradients into alpha layers
+        alphaLayerL.paste(agradientL, (0, 0))
+        alphaLayerT.paste(agradientT, (0, 0))
+        alphaLayerLTC.paste(agradientL, (0, 0))
+        alphaLayerLTC.paste(agradientT, (0, 0))
+        alphaLayerLTC.paste(agradientC.resize((overlap_size_x, overlap_size_y)), (0, 0))
+        # make masks with an asymmetric upper-right corner so when the curved transparent corner of the next tile
+        # to its right is placed it doesn't reveal a hard trailing semi-transparent edge in the overlapping space
+        alphaLayerTaC = alphaLayerT.copy()
+        alphaLayerTaC.paste(
+            agradientAsymC.rotate(270).resize((overlap_size_x, overlap_size_y)),
+            (width - overlap_size_x, 0),
+        )
+        alphaLayerLTaC = alphaLayerLTC.copy()
+        alphaLayerLTaC.paste(
+            agradientAsymC.rotate(270).resize((overlap_size_x, overlap_size_y)),
+            (width - overlap_size_x, 0),
+        )
+
+        if embiggen_tiles:
+            # Individual unconnected sides
+            alphaLayerR = Image.new("L", (width, height), 255)
+            alphaLayerR.paste(agradientL.rotate(180), (width - overlap_size_x, 0))
+            alphaLayerB = Image.new("L", (width, height), 255)
+            alphaLayerB.paste(agradientT.rotate(180), (0, height - overlap_size_y))
+            alphaLayerTB = Image.new("L", (width, height), 255)
+            alphaLayerTB.paste(agradientT, (0, 0))
+            alphaLayerTB.paste(agradientT.rotate(180), (0, height - overlap_size_y))
+            alphaLayerLR = Image.new("L", (width, height), 255)
+            alphaLayerLR.paste(agradientL, (0, 0))
+            alphaLayerLR.paste(agradientL.rotate(180), (width - overlap_size_x, 0))
+
+            # Sides and corner Layers
+            alphaLayerRBC = Image.new("L", (width, height), 255)
+            alphaLayerRBC.paste(agradientL.rotate(180), (width - overlap_size_x, 0))
+            alphaLayerRBC.paste(agradientT.rotate(180), (0, height - overlap_size_y))
+            alphaLayerRBC.paste(
+                agradientC.rotate(180).resize((overlap_size_x, overlap_size_y)),
+                (width - overlap_size_x, height - overlap_size_y),
+            )
+            alphaLayerLBC = Image.new("L", (width, height), 255)
+            alphaLayerLBC.paste(agradientL, (0, 0))
+            alphaLayerLBC.paste(agradientT.rotate(180), (0, height - overlap_size_y))
+            alphaLayerLBC.paste(
+                agradientC.rotate(90).resize((overlap_size_x, overlap_size_y)),
+                (0, height - overlap_size_y),
+            )
+            alphaLayerRTC = Image.new("L", (width, height), 255)
+            alphaLayerRTC.paste(agradientL.rotate(180), (width - overlap_size_x, 0))
+            alphaLayerRTC.paste(agradientT, (0, 0))
+            alphaLayerRTC.paste(
+                agradientC.rotate(270).resize((overlap_size_x, overlap_size_y)),
+                (width - overlap_size_x, 0),
+            )
+
+            # All but X layers
+            alphaLayerABT = Image.new("L", (width, height), 255)
+            alphaLayerABT.paste(alphaLayerLBC, (0, 0))
+            alphaLayerABT.paste(agradientL.rotate(180), (width - overlap_size_x, 0))
+            alphaLayerABT.paste(
+                agradientC.rotate(180).resize((overlap_size_x, overlap_size_y)),
+                (width - overlap_size_x, height - overlap_size_y),
+            )
+            alphaLayerABL = Image.new("L", (width, height), 255)
+            alphaLayerABL.paste(alphaLayerRTC, (0, 0))
+            alphaLayerABL.paste(agradientT.rotate(180), (0, height - overlap_size_y))
+            alphaLayerABL.paste(
+                agradientC.rotate(180).resize((overlap_size_x, overlap_size_y)),
+                (width - overlap_size_x, height - overlap_size_y),
+            )
+            alphaLayerABR = Image.new("L", (width, height), 255)
+            alphaLayerABR.paste(alphaLayerLBC, (0, 0))
+            alphaLayerABR.paste(agradientT, (0, 0))
+            alphaLayerABR.paste(
+                agradientC.resize((overlap_size_x, overlap_size_y)), (0, 0)
+            )
+            alphaLayerABB = Image.new("L", (width, height), 255)
+            alphaLayerABB.paste(alphaLayerRTC, (0, 0))
+            alphaLayerABB.paste(agradientL, (0, 0))
+            alphaLayerABB.paste(
+                agradientC.resize((overlap_size_x, overlap_size_y)), (0, 0)
+            )
+
+            # All-around layer
+            alphaLayerAA = Image.new("L", (width, height), 255)
+            alphaLayerAA.paste(alphaLayerABT, (0, 0))
+            alphaLayerAA.paste(agradientT, (0, 0))
+            alphaLayerAA.paste(
+                agradientC.resize((overlap_size_x, overlap_size_y)), (0, 0)
+            )
+            alphaLayerAA.paste(
+                agradientC.rotate(270).resize((overlap_size_x, overlap_size_y)),
+                (width - overlap_size_x, 0),
+            )
+
+        # Clean up temporary gradients
+        del agradientL
+        del agradientT
+        del agradientC
+
+        def make_image():
+            # Make main tiles -------------------------------------------------
+            if embiggen_tiles:
+                print(f">> Making {len(embiggen_tiles)} Embiggen tiles...")
+            else:
+                print(
+                    f">> Making {(emb_tiles_x * emb_tiles_y)} Embiggen tiles ({emb_tiles_x}x{emb_tiles_y})..."
+                )
+
+            emb_tile_store = []
+            # Although we could use the same seed for every tile for determinism, at higher strengths this may
+            # produce duplicated structures for each tile and make the tiling effect more obvious
+            # instead track and iterate a local seed we pass to Img2Img
+            seed = self.seed
+            seedintlimit = (
+                np.iinfo(np.uint32).max - 1
+            )  # only retreive this one from numpy
+
+            for tile in range(emb_tiles_x * emb_tiles_y):
+                # Don't iterate on first tile
+                if tile != 0:
+                    if seed < seedintlimit:
+                        seed += 1
+                    else:
+                        seed = 0
+
+                # Determine if this is a re-run and replace
+                if embiggen_tiles and not tile in embiggen_tiles:
+                    continue
+                # Get row and column entries
+                emb_row_i = tile // emb_tiles_x
+                emb_column_i = tile % emb_tiles_x
+                # Determine bounds to cut up the init image
+                # Determine upper-left point
+                if emb_column_i + 1 == emb_tiles_x:
+                    left = initsuperwidth - width
+                else:
+                    left = round(emb_column_i * (width - overlap_size_x))
+                if emb_row_i + 1 == emb_tiles_y:
+                    top = initsuperheight - height
+                else:
+                    top = round(emb_row_i * (height - overlap_size_y))
+                right = left + width
+                bottom = top + height
+
+                # Cropped image of above dimension (does not modify the original)
+                newinitimage = initsuperimage.crop((left, top, right, bottom))
+                # DEBUG:
+                # newinitimagepath = init_img[0:-4] + f'_emb_Ti{tile}.png'
+                # newinitimage.save(newinitimagepath)
+
+                if embiggen_tiles:
+                    print(
+                        f"Making tile #{tile + 1} ({embiggen_tiles.index(tile) + 1} of {len(embiggen_tiles)} requested)"
+                    )
+                else:
+                    print(f"Starting {tile + 1} of {(emb_tiles_x * emb_tiles_y)} tiles")
+
+                # create a torch tensor from an Image
+                newinitimage = np.array(newinitimage).astype(np.float32) / 255.0
+                newinitimage = newinitimage[None].transpose(0, 3, 1, 2)
+                newinitimage = torch.from_numpy(newinitimage)
+                newinitimage = 2.0 * newinitimage - 1.0
+                newinitimage = newinitimage.to(self.model.device)
+                clear_cuda_cache = (
+                    kwargs["clear_cuda_cache"] if "clear_cuda_cache" in kwargs else None
+                )
+
+                tile_results = gen_img2img.generate(
+                    prompt,
+                    iterations=1,
+                    seed=seed,
+                    sampler=sampler,
+                    steps=steps,
+                    cfg_scale=cfg_scale,
+                    conditioning=conditioning,
+                    ddim_eta=ddim_eta,
+                    image_callback=None,  # called only after the final image is generated
+                    step_callback=step_callback,  # called after each intermediate image is generated
+                    width=width,
+                    height=height,
+                    init_image=newinitimage,  # notice that init_image is different from init_img
+                    mask_image=None,
+                    strength=strength,
+                    clear_cuda_cache=clear_cuda_cache,
+                )
+
+                emb_tile_store.append(tile_results[0][0])
+                # DEBUG (but, also has other uses), worth saving if you want tiles without a transparency overlap to manually composite
+                # emb_tile_store[-1].save(init_img[0:-4] + f'_emb_To{tile}.png')
+                del newinitimage
+
+            # Sanity check we have them all
+            if len(emb_tile_store) == (emb_tiles_x * emb_tiles_y) or (
+                embiggen_tiles != [] and len(emb_tile_store) == len(embiggen_tiles)
+            ):
+                outputsuperimage = Image.new("RGBA", (initsuperwidth, initsuperheight))
+                if embiggen_tiles:
+                    outputsuperimage.alpha_composite(
+                        initsuperimage.convert("RGBA"), (0, 0)
+                    )
+                for tile in range(emb_tiles_x * emb_tiles_y):
+                    if embiggen_tiles:
+                        if tile in embiggen_tiles:
+                            intileimage = emb_tile_store.pop(0)
+                        else:
+                            continue
+                    else:
+                        intileimage = emb_tile_store[tile]
+                    intileimage = intileimage.convert("RGBA")
+                    # Get row and column entries
+                    emb_row_i = tile // emb_tiles_x
+                    emb_column_i = tile % emb_tiles_x
+                    if emb_row_i == 0 and emb_column_i == 0 and not embiggen_tiles:
+                        left = 0
+                        top = 0
+                    else:
+                        # Determine upper-left point
+                        if emb_column_i + 1 == emb_tiles_x:
+                            left = initsuperwidth - width
+                        else:
+                            left = round(emb_column_i * (width - overlap_size_x))
+                        if emb_row_i + 1 == emb_tiles_y:
+                            top = initsuperheight - height
+                        else:
+                            top = round(emb_row_i * (height - overlap_size_y))
+                        # Handle gradients for various conditions
+                        # Handle emb_rerun case
+                        if embiggen_tiles:
+                            # top of image
+                            if emb_row_i == 0:
+                                if emb_column_i == 0:
+                                    if (tile + 1) in embiggen_tiles:  # Look-ahead right
+                                        if (
+                                            tile + emb_tiles_x
+                                        ) not in embiggen_tiles:  # Look-ahead down
+                                            intileimage.putalpha(alphaLayerB)
+                                        # Otherwise do nothing on this tile
+                                    elif (
+                                        tile + emb_tiles_x
+                                    ) in embiggen_tiles:  # Look-ahead down only
+                                        intileimage.putalpha(alphaLayerR)
+                                    else:
+                                        intileimage.putalpha(alphaLayerRBC)
+                                elif emb_column_i == emb_tiles_x - 1:
+                                    if (
+                                        tile + emb_tiles_x
+                                    ) in embiggen_tiles:  # Look-ahead down
+                                        intileimage.putalpha(alphaLayerL)
+                                    else:
+                                        intileimage.putalpha(alphaLayerLBC)
+                                else:
+                                    if (tile + 1) in embiggen_tiles:  # Look-ahead right
+                                        if (
+                                            tile + emb_tiles_x
+                                        ) in embiggen_tiles:  # Look-ahead down
+                                            intileimage.putalpha(alphaLayerL)
+                                        else:
+                                            intileimage.putalpha(alphaLayerLBC)
+                                    elif (
+                                        tile + emb_tiles_x
+                                    ) in embiggen_tiles:  # Look-ahead down only
+                                        intileimage.putalpha(alphaLayerLR)
+                                    else:
+                                        intileimage.putalpha(alphaLayerABT)
+                            # bottom of image
+                            elif emb_row_i == emb_tiles_y - 1:
+                                if emb_column_i == 0:
+                                    if (tile + 1) in embiggen_tiles:  # Look-ahead right
+                                        intileimage.putalpha(alphaLayerTaC)
+                                    else:
+                                        intileimage.putalpha(alphaLayerRTC)
+                                elif emb_column_i == emb_tiles_x - 1:
+                                    # No tiles to look ahead to
+                                    intileimage.putalpha(alphaLayerLTC)
+                                else:
+                                    if (tile + 1) in embiggen_tiles:  # Look-ahead right
+                                        intileimage.putalpha(alphaLayerLTaC)
+                                    else:
+                                        intileimage.putalpha(alphaLayerABB)
+                            # vertical middle of image
+                            else:
+                                if emb_column_i == 0:
+                                    if (tile + 1) in embiggen_tiles:  # Look-ahead right
+                                        if (
+                                            tile + emb_tiles_x
+                                        ) in embiggen_tiles:  # Look-ahead down
+                                            intileimage.putalpha(alphaLayerTaC)
+                                        else:
+                                            intileimage.putalpha(alphaLayerTB)
+                                    elif (
+                                        tile + emb_tiles_x
+                                    ) in embiggen_tiles:  # Look-ahead down only
+                                        intileimage.putalpha(alphaLayerRTC)
+                                    else:
+                                        intileimage.putalpha(alphaLayerABL)
+                                elif emb_column_i == emb_tiles_x - 1:
+                                    if (
+                                        tile + emb_tiles_x
+                                    ) in embiggen_tiles:  # Look-ahead down
+                                        intileimage.putalpha(alphaLayerLTC)
+                                    else:
+                                        intileimage.putalpha(alphaLayerABR)
+                                else:
+                                    if (tile + 1) in embiggen_tiles:  # Look-ahead right
+                                        if (
+                                            tile + emb_tiles_x
+                                        ) in embiggen_tiles:  # Look-ahead down
+                                            intileimage.putalpha(alphaLayerLTaC)
+                                        else:
+                                            intileimage.putalpha(alphaLayerABR)
+                                    elif (
+                                        tile + emb_tiles_x
+                                    ) in embiggen_tiles:  # Look-ahead down only
+                                        intileimage.putalpha(alphaLayerABB)
+                                    else:
+                                        intileimage.putalpha(alphaLayerAA)
+                        # Handle normal tiling case (much simpler - since we tile left to right, top to bottom)
+                        else:
+                            if emb_row_i == 0 and emb_column_i >= 1:
+                                intileimage.putalpha(alphaLayerL)
+                            elif emb_row_i >= 1 and emb_column_i == 0:
+                                if (
+                                    emb_column_i + 1 == emb_tiles_x
+                                ):  # If we don't have anything that can be placed to the right
+                                    intileimage.putalpha(alphaLayerT)
+                                else:
+                                    intileimage.putalpha(alphaLayerTaC)
+                            else:
+                                if (
+                                    emb_column_i + 1 == emb_tiles_x
+                                ):  # If we don't have anything that can be placed to the right
+                                    intileimage.putalpha(alphaLayerLTC)
+                                else:
+                                    intileimage.putalpha(alphaLayerLTaC)
+                    # Layer tile onto final image
+                    outputsuperimage.alpha_composite(intileimage, (left, top))
+            else:
+                print(
+                    "Error: could not find all Embiggen output tiles in memory? Something must have gone wrong with img2img generation."
+                )
+
+            # after internal loops and patching up return Embiggen image
+            return outputsuperimage
+
+        # end of function declaration
+        return make_image

invokeai/backend/generator/img2img.py

@@ -22,6 +22,7 @@ class Img2Img(Generator):
 
     def get_make_image(
         self,
+        prompt,
         sampler,
         steps,
         cfg_scale,

invokeai/backend/generator/inpaint.py

@@ -4,7 +4,6 @@ invokeai.backend.generator.inpaint descends from .generator
 from __future__ import annotations
 
 import math
-from typing import Tuple, Union
 
 import cv2
 import numpy as np
@@ -60,7 +59,7 @@ class Inpaint(Img2Img):
             writeable=False,
         )
 
-    def infill_patchmatch(self, im: Image.Image) -> Image.Image:
+    def infill_patchmatch(self, im: Image.Image) -> Image:
         if im.mode != "RGBA":
             return im
 
@@ -76,18 +75,18 @@ class Inpaint(Img2Img):
         return im_patched
 
     def tile_fill_missing(
-        self, im: Image.Image, tile_size: int = 16, seed: Union[int, None] = None
-    ) -> Image.Image:
+        self, im: Image.Image, tile_size: int = 16, seed: int = None
+    ) -> Image:
         # Only fill if there's an alpha layer
         if im.mode != "RGBA":
             return im
 
         a = np.asarray(im, dtype=np.uint8)
 
-        tile_size_tuple = (tile_size, tile_size)
+        tile_size = (tile_size, tile_size)
 
         # Get the image as tiles of a specified size
-        tiles = self.get_tile_images(a, *tile_size_tuple).copy()
+        tiles = self.get_tile_images(a, *tile_size).copy()
 
         # Get the mask as tiles
         tiles_mask = tiles[:, :, :, :, 3]
@@ -128,9 +127,7 @@ class Inpaint(Img2Img):
 
         return si
 
-    def mask_edge(
-        self, mask: Image.Image, edge_size: int, edge_blur: int
-    ) -> Image.Image:
+    def mask_edge(self, mask: Image, edge_size: int, edge_blur: int) -> Image:
         npimg = np.asarray(mask, dtype=np.uint8)
 
         # Detect any partially transparent regions
@@ -161,7 +158,9 @@ class Inpaint(Img2Img):
         im: Image.Image,
         seam_size: int,
         seam_blur: int,
+        prompt,
         seed,
+        sampler,
         steps,
         cfg_scale,
         ddim_eta,
@@ -175,6 +174,8 @@ class Inpaint(Img2Img):
         mask = self.mask_edge(hard_mask, seam_size, seam_blur)
 
         make_image = self.get_make_image(
+            prompt,
+            sampler,
             steps,
             cfg_scale,
             ddim_eta,
@@ -192,26 +193,28 @@ class Inpaint(Img2Img):
 
         seam_noise = self.get_noise(im.width, im.height)
 
-        result = make_image(seam_noise, seed=None)
+        result = make_image(seam_noise, seed)
 
         return result
 
     @torch.no_grad()
     def get_make_image(
         self,
+        prompt,
+        sampler,
         steps,
         cfg_scale,
         ddim_eta,
         conditioning,
-        init_image: Image.Image | torch.FloatTensor,
-        mask_image: Image.Image | torch.FloatTensor,
+        init_image: PIL.Image.Image | torch.FloatTensor,
+        mask_image: PIL.Image.Image | torch.FloatTensor,
         strength: float,
         mask_blur_radius: int = 8,
         # Seam settings - when 0, doesn't fill seam
-        seam_size: int = 96,
-        seam_blur: int = 16,
+        seam_size: int = 0,
+        seam_blur: int = 0,
         seam_strength: float = 0.7,
-        seam_steps: int = 30,
+        seam_steps: int = 10,
         tile_size: int = 32,
         step_callback=None,
         inpaint_replace=False,
@@ -219,7 +222,7 @@ class Inpaint(Img2Img):
         infill_method=None,
         inpaint_width=None,
         inpaint_height=None,
-        inpaint_fill: Tuple[int, int, int, int] = (0x7F, 0x7F, 0x7F, 0xFF),
+        inpaint_fill: tuple(int) = (0x7F, 0x7F, 0x7F, 0xFF),
         attention_maps_callback=None,
         **kwargs,
     ):
@@ -236,7 +239,7 @@ class Inpaint(Img2Img):
         self.inpaint_width = inpaint_width
         self.inpaint_height = inpaint_height
 
-        if isinstance(init_image, Image.Image):
+        if isinstance(init_image, PIL.Image.Image):
             self.pil_image = init_image.copy()
 
             # Do infill
@@ -247,8 +250,8 @@ class Inpaint(Img2Img):
                     self.pil_image.copy(), seed=self.seed, tile_size=tile_size
                 )
             elif infill_method == "solid":
-                solid_bg = Image.new("RGBA", init_image.size, inpaint_fill)
-                init_filled = Image.alpha_composite(solid_bg, init_image)
+                solid_bg = PIL.Image.new("RGBA", init_image.size, inpaint_fill)
+                init_filled = PIL.Image.alpha_composite(solid_bg, init_image)
             else:
                 raise ValueError(
                     f"Non-supported infill type {infill_method}", infill_method
@@ -266,7 +269,7 @@ class Inpaint(Img2Img):
             # Create init tensor
             init_image = image_resized_to_grid_as_tensor(init_filled.convert("RGB"))
 
-        if isinstance(mask_image, Image.Image):
+        if isinstance(mask_image, PIL.Image.Image):
             self.pil_mask = mask_image.copy()
             debug_image(
                 mask_image,
@@ -300,6 +303,7 @@ class Inpaint(Img2Img):
 
         # noinspection PyTypeChecker
         pipeline: StableDiffusionGeneratorPipeline = self.model
+        pipeline.scheduler = sampler
 
         # todo: support cross-attention control
         uc, c, _ = conditioning
@@ -338,7 +342,9 @@ class Inpaint(Img2Img):
                     result,
                     seam_size,
                     seam_blur,
+                    prompt,
                     seed,
+                    sampler,
                     seam_steps,
                     cfg_scale,
                     ddim_eta,
@@ -351,6 +357,8 @@ class Inpaint(Img2Img):
 
                 # Restore original settings
                 self.get_make_image(
+                    prompt,
+                    sampler,
                     steps,
                     cfg_scale,
                     ddim_eta,

invokeai/backend/generator/txt2img.py

@@ -0,0 +1,125 @@
+"""
+invokeai.backend.generator.txt2img inherits from invokeai.backend.generator
+"""
+import PIL.Image
+import torch
+
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from diffusers.models.controlnet import ControlNetModel, ControlNetOutput
+from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
+
+from ..stable_diffusion import (
+    ConditioningData,
+    PostprocessingSettings,
+    StableDiffusionGeneratorPipeline,
+)
+from .base import Generator
+
+
+class Txt2Img(Generator):
+    def __init__(self, model, precision,
+                 control_model: Optional[Union[ControlNetModel, List[ControlNetModel]]] = None,
+                 **kwargs):
+        self.control_model = control_model
+        if isinstance(self.control_model, list):
+            self.control_model = MultiControlNetModel(self.control_model)
+        super().__init__(model, precision, **kwargs)
+
+    @torch.no_grad()
+    def get_make_image(
+        self,
+        prompt,
+        sampler,
+        steps,
+        cfg_scale,
+        ddim_eta,
+        conditioning,
+        width,
+        height,
+        step_callback=None,
+        threshold=0.0,
+        warmup=0.2,
+        perlin=0.0,
+        h_symmetry_time_pct=None,
+        v_symmetry_time_pct=None,
+        attention_maps_callback=None,
+        **kwargs,
+    ):
+        """
+        Returns a function returning an image derived from the prompt and the initial image
+        Return value depends on the seed at the time you call it
+        kwargs are 'width' and 'height'
+        """
+        self.perlin = perlin
+        control_image = kwargs.get("control_image", None)
+        do_classifier_free_guidance = cfg_scale > 1.0
+
+        # noinspection PyTypeChecker
+        pipeline: StableDiffusionGeneratorPipeline = self.model
+        pipeline.control_model = self.control_model
+        pipeline.scheduler = sampler
+
+        uc, c, extra_conditioning_info = conditioning
+        conditioning_data = ConditioningData(
+            uc,
+            c,
+            cfg_scale,
+            extra_conditioning_info,
+            postprocessing_settings=PostprocessingSettings(
+                threshold=threshold,
+                warmup=warmup,
+                h_symmetry_time_pct=h_symmetry_time_pct,
+                v_symmetry_time_pct=v_symmetry_time_pct,
+            ),
+        ).add_scheduler_args_if_applicable(pipeline.scheduler, eta=ddim_eta)
+
+        # FIXME: still need to test with different widths, heights, devices, dtypes
+        #        and add in batch_size, num_images_per_prompt?
+        if control_image is not None:
+            if isinstance(self.control_model, ControlNetModel):
+                control_image = pipeline.prepare_control_image(
+                    image=control_image,
+                    do_classifier_free_guidance=do_classifier_free_guidance,
+                    width=width,
+                    height=height,
+                    # batch_size=batch_size * num_images_per_prompt,
+                    # num_images_per_prompt=num_images_per_prompt,
+                    device=self.control_model.device,
+                    dtype=self.control_model.dtype,
+                )
+            elif isinstance(self.control_model, MultiControlNetModel):
+                images = []
+                for image_ in control_image:
+                    image_ = self.model.prepare_control_image(
+                        image=image_,
+                        do_classifier_free_guidance=do_classifier_free_guidance,
+                        width=width,
+                        height=height,
+                        # batch_size=batch_size * num_images_per_prompt,
+                        # num_images_per_prompt=num_images_per_prompt,
+                        device=self.control_model.device,
+                        dtype=self.control_model.dtype,
+                    )
+                    images.append(image_)
+                control_image = images
+            kwargs["control_image"] = control_image
+
+        def make_image(x_T: torch.Tensor, _: int) -> PIL.Image.Image:
+            pipeline_output = pipeline.image_from_embeddings(
+                latents=torch.zeros_like(x_T, dtype=self.torch_dtype()),
+                noise=x_T,
+                num_inference_steps=steps,
+                conditioning_data=conditioning_data,
+                callback=step_callback,
+                **kwargs,
+            )
+
+            if (
+                pipeline_output.attention_map_saver is not None
+                and attention_maps_callback is not None
+            ):
+                attention_maps_callback(pipeline_output.attention_map_saver)
+
+            return pipeline.numpy_to_pil(pipeline_output.images)[0]
+
+        return make_image

invokeai/backend/generator/txt2img2img.py

@@ -0,0 +1,207 @@
+"""
+invokeai.backend.generator.txt2img inherits from invokeai.backend.generator
+"""
+
+import math
+from typing import Callable, Optional
+
+import torch
+from diffusers.utils.logging import get_verbosity, set_verbosity, set_verbosity_error
+
+from ..stable_diffusion import PostprocessingSettings
+from .base import Generator
+from ..stable_diffusion.diffusers_pipeline import StableDiffusionGeneratorPipeline
+from ..stable_diffusion.diffusers_pipeline import ConditioningData
+from ..stable_diffusion.diffusers_pipeline import trim_to_multiple_of
+
+class Txt2Img2Img(Generator):
+    def __init__(self, model, precision):
+        super().__init__(model, precision)
+        self.init_latent = None  # for get_noise()
+
+    def get_make_image(
+        self,
+        prompt: str,
+        sampler,
+        steps: int,
+        cfg_scale: float,
+        ddim_eta,
+        conditioning,
+        width: int,
+        height: int,
+        strength: float,
+        step_callback: Optional[Callable] = None,
+        threshold=0.0,
+        warmup=0.2,
+        perlin=0.0,
+        h_symmetry_time_pct=None,
+        v_symmetry_time_pct=None,
+        attention_maps_callback=None,
+        **kwargs,
+    ):
+        """
+        Returns a function returning an image derived from the prompt and the initial image
+        Return value depends on the seed at the time you call it
+        kwargs are 'width' and 'height'
+        """
+        self.perlin = perlin
+
+        # noinspection PyTypeChecker
+        pipeline: StableDiffusionGeneratorPipeline = self.model
+        pipeline.scheduler = sampler
+
+        uc, c, extra_conditioning_info = conditioning
+        conditioning_data = ConditioningData(
+            uc,
+            c,
+            cfg_scale,
+            extra_conditioning_info,
+            postprocessing_settings=PostprocessingSettings(
+                threshold=threshold,
+                warmup=0.2,
+                h_symmetry_time_pct=h_symmetry_time_pct,
+                v_symmetry_time_pct=v_symmetry_time_pct,
+            ),
+        ).add_scheduler_args_if_applicable(pipeline.scheduler, eta=ddim_eta)
+
+        def make_image(x_T: torch.Tensor, _: int):
+            first_pass_latent_output, _ = pipeline.latents_from_embeddings(
+                latents=torch.zeros_like(x_T),
+                num_inference_steps=steps,
+                conditioning_data=conditioning_data,
+                noise=x_T,
+                callback=step_callback,
+            )
+
+            # Get our initial generation width and height directly from the latent output so
+            # the message below is accurate.
+            init_width = first_pass_latent_output.size()[3] * self.downsampling_factor
+            init_height = first_pass_latent_output.size()[2] * self.downsampling_factor
+            print(
+                f"\n>> Interpolating from {init_width}x{init_height} to {width}x{height} using DDIM sampling"
+            )
+
+            # resizing
+            resized_latents = torch.nn.functional.interpolate(
+                first_pass_latent_output,
+                size=(
+                    height // self.downsampling_factor,
+                    width // self.downsampling_factor,
+                ),
+                mode="bilinear",
+            )
+
+            # Free up memory from the last generation.
+            clear_cuda_cache = kwargs["clear_cuda_cache"] or None
+            if clear_cuda_cache is not None:
+                clear_cuda_cache()
+
+            second_pass_noise = self.get_noise_like(
+                resized_latents, override_perlin=True
+            )
+
+            # Clear symmetry for the second pass
+            from dataclasses import replace
+
+            new_postprocessing_settings = replace(
+                conditioning_data.postprocessing_settings, h_symmetry_time_pct=None
+            )
+            new_postprocessing_settings = replace(
+                new_postprocessing_settings, v_symmetry_time_pct=None
+            )
+            new_conditioning_data = replace(
+                conditioning_data, postprocessing_settings=new_postprocessing_settings
+            )
+
+            verbosity = get_verbosity()
+            set_verbosity_error()
+            pipeline_output = pipeline.img2img_from_latents_and_embeddings(
+                resized_latents,
+                num_inference_steps=steps,
+                conditioning_data=new_conditioning_data,
+                strength=strength,
+                noise=second_pass_noise,
+                callback=step_callback,
+            )
+            set_verbosity(verbosity)
+
+            if (
+                pipeline_output.attention_map_saver is not None
+                and attention_maps_callback is not None
+            ):
+                attention_maps_callback(pipeline_output.attention_map_saver)
+
+            return pipeline.numpy_to_pil(pipeline_output.images)[0]
+
+        # FIXME: do we really need something entirely different for the inpainting model?
+
+        # in the case of the inpainting model being loaded, the trick of
+        # providing an interpolated latent doesn't work, so we transiently
+        # create a 512x512 PIL image, upscale it, and run the inpainting
+        # over it in img2img mode. Because the inpaing model is so conservative
+        # it doesn't change the image (much)
+
+        return make_image
+
+    def get_noise_like(self, like: torch.Tensor, override_perlin: bool = False):
+        device = like.device
+        if device.type == "mps":
+            x = torch.randn_like(like, device="cpu", dtype=self.torch_dtype()).to(
+                device
+            )
+        else:
+            x = torch.randn_like(like, device=device, dtype=self.torch_dtype())
+        if self.perlin > 0.0 and override_perlin == False:
+            shape = like.shape
+            x = (1 - self.perlin) * x + self.perlin * self.get_perlin_noise(
+                shape[3], shape[2]
+            )
+        return x
+
+    # returns a tensor filled with random numbers from a normal distribution
+    def get_noise(self, width, height, scale=True):
+        # print(f"Get noise: {width}x{height}")
+        if scale:
+            # Scale the input width and height for the initial generation
+            # Make their area equivalent to the model's resolution area (e.g. 512*512 = 262144),
+            # while keeping the minimum dimension at least 0.5 * resolution (e.g. 512*0.5 = 256)
+
+            aspect = width / height
+            dimension = self.model.unet.config.sample_size * self.model.vae_scale_factor
+            min_dimension = math.floor(dimension * 0.5)
+            model_area = (
+                dimension * dimension
+            )  # hardcoded for now since all models are trained on square images
+
+            if aspect > 1.0:
+                init_height = max(min_dimension, math.sqrt(model_area / aspect))
+                init_width = init_height * aspect
+            else:
+                init_width = max(min_dimension, math.sqrt(model_area * aspect))
+                init_height = init_width / aspect
+
+            scaled_width, scaled_height = trim_to_multiple_of(
+                math.floor(init_width), math.floor(init_height)
+            )
+
+        else:
+            scaled_width = width
+            scaled_height = height
+
+        device = self.model.device
+        channels = self.latent_channels
+        if channels == 9:
+            channels = 4  # we don't really want noise for all the mask channels
+        shape = (
+            1,
+            channels,
+            scaled_height // self.downsampling_factor,
+            scaled_width // self.downsampling_factor,
+        )
+        if self.use_mps_noise or device.type == "mps":
+            tensor = torch.empty(size=shape, device="cpu")
+            tensor = self.get_noise_like(like=tensor).to(device)
+        else:
+            tensor = torch.empty(size=shape, device=device)
+            tensor = self.get_noise_like(like=tensor)
+        return tensor