Merge branch 'main' into Convert-Model-Endpoint

# Application-wide configuration service

This PR creates a new `InvokeAIAppConfig` object that reads
application-wide settings from an init file, the environment, and the
command line.

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
    embedding_dir: embeddings
    lora_dir: loras
    autoconvert_dir: null
    gfpgan_model_dir: models/gfpgan/GFPGANv1.4.pth
  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
  Cross-Origin Resource Sharing:
    allow_origins: []
    allow_credentials: true
    allow_methods:
    - '*'
    allow_headers:
    - '*'
  Web Server:
    host: 127.0.0.1
    port: 8081

```

The default name of the configuration file is `invokeai.yaml`, located
in INVOKEAI_ROOT. You can use any OmegaConf dictionary by passing it to
the config object at initialization time:

```
 omegaconf = OmegaConf.load('/tmp/init.yaml')
 conf = InvokeAIAppConfig(conf=omegaconf)
```
The default name of the configuration file is `invokeai.yaml`, located
in INVOKEAI_ROOT. You can replace supersede this by providing
anyOmegaConf dictionary object initialization time:

```
omegaconf = OmegaConf.load('/tmp/init.yaml')
conf = InvokeAIAppConfig(conf=omegaconf)
```

By default, InvokeAIAppConfig 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 = InvokeAIAppConfig(arg=['--xformers_enabled'])
```

It is also possible to set a value at initialization time. This value
has highest priority.
```
conf = InvokeAIAppConfig(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:

```
from invokeai.app.services.config import InvokeAIAppConfig

# get global configuration and print its nsfw_checker value
conf = InvokeAIAppConfig()
print(conf.nsfw_checker)
```
Finally, the configuration object is able to recreate its (modified)
yaml file, by calling its `to_yaml()` method:

```
conf = InvokeAIAppConfig(outdir='/tmp', port=8080)
print(conf.to_yaml())
```

# Legacy code removal and porting

This PR replaces Globals with the InvokeAIAppConfig system throughout,
and therefore removes the `globals.py` and `args.py` modules. It also
removes `generate` and the legacy CLI. ***The old CLI and web servers
are now gone.***

I have ported the functionality of the configuration script, the model
installer, and the merge and textual inversion scripts. The `invokeai`
command will now launch `invokeai-node-cli`, and `invokeai-web` will
launch the web server.

I have changed the continuous invocation tests to accommodate the new
command syntax in `invokeai-node-cli`. As a convenience function, you
can also pass invocations to `invokeai-node-cli` (or its alias
`invokeai`) on the command line as as standard input:

```
invokeai-node-cli "t2i --positive_prompt 'banana sushi' --seed 42"
invokeai < invocation_commands.txt
```

.github/workflows/mkdocs-material.yml

@@ -2,8 +2,7 @@ name: mkdocs-material
 on:
   push:
     branches:
-      - 'main'
-      - 'development'
+      - 'refs/heads/v2.3'
 
 permissions:
     contents: write
@@ -12,6 +11,10 @@ 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
@@ -22,11 +25,15 @@ 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 -r docs/requirements-mkdocs.txt
+            pip install ".[docs]"
 
       - name: confirm buildability
         run: |
@@ -36,7 +43,7 @@ jobs:
             --verbose
 
       - name: deploy to gh-pages
-        if: ${{ github.ref == 'refs/heads/main' }}
+        if: ${{ github.ref == 'refs/heads/v2.3' }}
         run: |
           python -m \
             mkdocs gh-deploy \

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

@@ -80,12 +80,7 @@ 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 }}
+        run:echo "TEST_PROMPTS=tests/validate_pr_prompt.txt" >> ${{ matrix.github-env }}
 
       - name: setup python
         uses: actions/setup-python@v4
@@ -105,12 +100,6 @@ jobs:
         id: run-pytest
         run: pytest
 
-      - 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-configure
         id: run-preload-models
         env:
@@ -129,15 +118,20 @@ jobs:
           HF_HUB_OFFLINE: 1
           HF_DATASETS_OFFLINE: 1
           TRANSFORMERS_OFFLINE: 1
+          INVOKEAI_OUTDIR: ${{ github.workspace }}/results
         run: >
           invokeai
           --no-patchmatch
           --no-nsfw_checker
-          --from_file ${{ env.TEST_PROMPTS }}
+          --precision=float32
+          --always_use_cpu
           --outdir ${{ env.INVOKEAI_OUTDIR }}/${{ matrix.python-version }}/${{ matrix.pytorch }}
+          --from_file ${{ env.TEST_PROMPTS }}
 
       - name: Archive results
         id: archive-results
+        env:
+          INVOKEAI_OUTDIR: ${{ github.workspace }}/results
         uses: actions/upload-artifact@v3
         with:
           name: results

.gitignore

@@ -201,6 +201,8 @@ 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,6 +33,8 @@
 
 </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>]

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 python3.10 python3-pip python3.10-venv
+         sudo apt install -y python3.10 python3-pip python3.10-venv
          sudo update-alternatives --install /usr/local/bin/python python /usr/bin/python3.10 3
          ```
 

installer/lib/installer.py

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

invokeai/app/api/dependencies.py

@@ -1,15 +1,12 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
 import os
-from argparse import Namespace
 
-from invokeai.app.services.metadata import PngMetadataService, MetadataServiceBase
+import invokeai.backend.util.logging as logger
+from typing import types
 
 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
@@ -19,6 +16,7 @@ from ..services.invocation_services import InvocationServices
 from ..services.invoker import Invoker
 from ..services.processor import DefaultInvocationProcessor
 from ..services.sqlite import SqliteItemStorage
+from ..services.metadata import PngMetadataService
 from .events import FastAPIEventService
 
 
@@ -43,16 +41,8 @@ class ApiDependencies:
 
     invoker: Invoker = None
 
-    @staticmethod
-    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}")
+    def initialize(config, event_handler_id: int, logger: types.ModuleType=logger):
+        logger.info(f"Internet connectivity is {config.internet_available}")
 
         events = FastAPIEventService(event_handler_id)
 
@@ -70,7 +60,7 @@ class ApiDependencies:
         db_location = os.path.join(output_folder, "invokeai.db")
 
         services = InvocationServices(
-            model_manager=get_model_manager(config),
+            model_manager=get_model_manager(config,logger),
             events=events,
             latents=latents,
             images=images,
@@ -83,7 +73,9 @@ class ApiDependencies:
                 filename=db_location, table_name="graph_executions"
             ),
             processor=DefaultInvocationProcessor(),
-            restoration=RestorationServices(config),
+            restoration=RestorationServices(config,logger),
+            configuration=config,
+            logger=logger,
         )
 
         create_system_graphs(services.graph_library)

invokeai/app/api/models/images.py

@@ -32,3 +32,9 @@ class ProgressImage(BaseModel):
     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")
+
+
+class SavedImage(BaseModel):
+    image_name: str = Field(description="The name of the saved image")
+    thumbnail_name: str = Field(description="The name of the saved thumbnail")
+    created: int = Field(description="The created timestamp of the saved image")

invokeai/app/api/routers/images.py

@@ -6,12 +6,14 @@ import os
 from typing import Any
 import uuid
 
-from fastapi import HTTPException, Path, Query, Request, UploadFile
+from fastapi import Body, HTTPException, Path, Query, Request, UploadFile
 from fastapi.responses import FileResponse, Response
 from fastapi.routing import APIRouter
 from PIL import Image
-from invokeai.app.api.models.images import ImageResponse, ImageResponseMetadata
-from invokeai.app.services.metadata import InvokeAIMetadata
+from invokeai.app.api.models.images import (
+    ImageResponse,
+    ImageResponseMetadata,
+)
 from invokeai.app.services.item_storage import PaginatedResults
 
 from ...services.image_storage import ImageType
@@ -24,8 +26,8 @@ images_router = APIRouter(prefix="/v1/images", tags=["images"])
 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"""
+) -> FileResponse:
+    """Gets an image"""
 
     path = ApiDependencies.invoker.services.images.get_path(
         image_type=image_type, image_name=image_name
@@ -37,17 +39,29 @@ async def get_image(
         raise HTTPException(status_code=404)
 
 
+@images_router.delete("/{image_type}/{image_name}", operation_id="delete_image")
+async def delete_image(
+    image_type: ImageType = Path(description="The type of image to delete"),
+    image_name: str = Path(description="The name of the image to delete"),
+) -> None:
+    """Deletes an image and its thumbnail"""
+
+    ApiDependencies.invoker.services.images.delete(
+        image_type=image_type, image_name=image_name
+    )
+
+
 @images_router.get(
-    "/{image_type}/thumbnails/{image_name}", operation_id="get_thumbnail"
+    "/{thumbnail_type}/thumbnails/{thumbnail_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"),
+    thumbnail_type: ImageType = Path(description="The type of thumbnail to get"),
+    thumbnail_name: str = Path(description="The name of the thumbnail 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
+        image_type=thumbnail_type, image_name=thumbnail_name, is_thumbnail=True
     )
 
     if ApiDependencies.invoker.services.images.validate_path(path):
@@ -69,7 +83,7 @@ async def get_thumbnail(
     status_code=201,
 )
 async def upload_image(
-    file: UploadFile, request: Request, response: Response
+    file: UploadFile, image_type: ImageType, request: Request, response: Response
 ) -> ImageResponse:
     if not file.content_type.startswith("image"):
         raise HTTPException(status_code=415, detail="Not an image")
@@ -84,19 +98,27 @@ async def upload_image(
 
     filename = f"{uuid.uuid4()}_{str(int(datetime.now(timezone.utc).timestamp()))}.png"
 
-    (image_path, thumbnail_path, ctime) = ApiDependencies.invoker.services.images.save(
-        ImageType.UPLOAD, filename, img
+    saved_image = ApiDependencies.invoker.services.images.save(
+        image_type, filename, img
     )
 
     invokeai_metadata = ApiDependencies.invoker.services.metadata.get_metadata(img)
 
+    image_url = ApiDependencies.invoker.services.images.get_uri(
+        image_type, saved_image.image_name
+    )
+
+    thumbnail_url = ApiDependencies.invoker.services.images.get_uri(
+        image_type, saved_image.image_name, True
+    )
+
     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",
+        image_type=image_type,
+        image_name=saved_image.image_name,
+        image_url=image_url,
+        thumbnail_url=thumbnail_url,
         metadata=ImageResponseMetadata(
-            created=ctime,
+            created=saved_image.created,
             width=img.width,
             height=img.height,
             invokeai=invokeai_metadata,
@@ -104,9 +126,7 @@ async def upload_image(
     )
 
     response.status_code = 201
-    response.headers["Location"] = request.url_for(
-        "get_image", image_type=ImageType.UPLOAD.value, image_name=filename
-    )
+    response.headers["Location"] = image_url
 
     return res
 

invokeai/app/api/routers/models.py

@@ -1,17 +1,13 @@
-# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654) and 2023 Kent Keirsey (https://github.com/hipsterusername)
+# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654) and Kent Keirsey (https://github.com/hipsterusername)
 
 import shutil
-import asyncio
+import os
 from typing import Annotated, Any, List, Literal, Optional, Union
 
 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.globals import Globals, global_converted_ckpts_dir
-from invokeai.backend.args import Args
-
-
 
 models_router = APIRouter(prefix="/v1/models", tags=["models"])
 
@@ -51,9 +47,7 @@ class CreateModelResponse(BaseModel):
 
 class ConversionRequest(BaseModel):
     name: str = Field(description="The name of the new model")
-    info: CkptModelInfo = Field(description="The converted model info")
     save_location: str = Field(description="The path to save the converted model weights")
-    
 
 class ConvertedModelResponse(BaseModel):
     name: str = Field(description="The name of the new model")
@@ -112,22 +106,112 @@ 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
-    print(f">> Checking for model {model_name}...")
+    logger.info(f"Checking for model {model_name}...")
            
     if model_exists:
-        print(f">> Deleting Model: {model_name}")
+        logger.info(f"Deleting Model: {model_name}")
         ApiDependencies.invoker.services.model_manager.del_model(model_name, delete_files=True)
-        print(f">> Model Deleted: {model_name}")
+        logger.info(f"Model Deleted: {model_name}")
         raise HTTPException(status_code=204, detail=f"Model '{model_name}' deleted successfully")
     
     else:
-        print(f">> Model not found")
+        logger.error(f"Model not found")
         raise HTTPException(status_code=404, detail=f"Model '{model_name}' not found")
+
+# TODO: Refactor these support functions below to live somewhere more appropriate
+
+def get_model_info(model_name: str):
+    model_info = ApiDependencies.invoker.services.model_manager.model_info(
+        model_name=model_name
+    )
+    if not model_info:
+        raise HTTPException(status_code=404, detail=f"Unable to retrieve model info for '{model_name}'")
+    return model_info
+
+
+def ckpt_validate(model_info: dict, model_name: str):
+    if "weights" not in model_info:
+        raise HTTPException(status_code=404, detail=f"Model '{model_name}' is not a valid checkpoint model")
     
 
+def get_paths(model: ConversionRequest, root: Path) -> tuple:
+    model_info = get_model_info(model.name)
+    ckpt_path = Path(model_info.weights)
+    config_path = Path(model_info.config)
+
+    if not ckpt_path.is_absolute():
+        ckpt_path = Path(root, ckpt_path)
+
+    if config_path and not config_path.is_absolute():
+        config_path = Path(root, config_path)
+
+    return ckpt_path, config_path
+
+
+def get_diffusers_path(convert_request: ConversionRequest, model_name: str) -> Path:
+    if convert_request.save_location == "root":
+        diffusers_path = Path(global_converted_ckpts_dir(), f"{model_name}_diffusers")
+    elif convert_request.save_location == "custom" and convert_request.save_location is not None:
+        diffusers_path = Path(convert_request.save_location, f"{model_name}_diffusers")
+    else:
+        raise ValueError("Invalid save_location value")
+
+    if diffusers_path.exists():
+        shutil.rmtree(diffusers_path)
+
+    return diffusers_path
+
+
+@models_router.post(
+    "/{model_to_convert}",
+    operation_id="convert_model",
+    responses={
+        200: {
+            "model_response": "Model converted successfully.",
+        }
+    },
+)
+async def convert_model(convert_request: ConversionRequest) -> ConvertedModelResponse:
+    """Convert Model"""
+
+    opt=Args()
+    args = opt.parse_args()
+
+    # Set the root directory for static files and relative paths
+    args.root_dir = os.path.expanduser(args.root_dir or "..")
+    if not os.path.isabs(args.outdir):
+        args.outdir = os.path.join(args.root_dir, args.outdir)
+
+    # normalize the config directory relative to root
+    if not os.path.isabs(opt.conf):
+        opt.conf = os.path.normpath(os.path.join(Globals.root, opt.conf))
+    model_info = get_model_info(convert_request.name)
+    ckpt_validate(model_info, convert_request.name)
+    ckpt_path, original_config_file = get_paths(convert_request, Globals.root)
+    diffusers_path = get_diffusers_path(convert_request, convert_request.name)
+
+    ApiDependencies.invoker.services.model_manager.convert_and_import(
+        ckpt_path,
+        diffusers_path,
+        model_name=convert_request.name,
+        model_description=model_info.description,
+        vae=None,
+        original_config_file=original_config_file,
+        commit_to_conf=opt.conf,
+    )
+
+    model_info = get_model_info(convert_request.name)
+    convert_response = ConvertedModelResponse(name=f"{convert_request.name}_diffusers", info=model_info)
+    
+    print(f">> Model Converted: {convert_request.name}")
+
+    return convert_response
+
+    
             # @socketio.on("convertToDiffusers")
         # def convert_to_diffusers(model_to_convert: dict):
         #     try:
@@ -248,4 +332,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,8 +2,7 @@
 
 from typing import Annotated, List, Optional, Union
 
-from fastapi import Body, Path, Query
-from fastapi.responses import Response
+from fastapi import Body, HTTPException, Path, Query, Response
 from fastapi.routing import APIRouter
 from pydantic.fields import Field
 
@@ -76,7 +75,7 @@ async def get_session(
     """Gets a session"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        return Response(status_code=404)
+        raise HTTPException(status_code=404)
     else:
         return session
 
@@ -99,7 +98,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:
-        return Response(status_code=404)
+        raise HTTPException(status_code=404)
 
     try:
         session.add_node(node)
@@ -108,9 +107,9 @@ async def add_node(
         )  # TODO: can this be done automatically, or add node through an API?
         return session.id
     except NodeAlreadyExecutedError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
     except IndexError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
 
 
 @session_router.put(
@@ -132,7 +131,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:
-        return Response(status_code=404)
+        raise HTTPException(status_code=404)
 
     try:
         session.update_node(node_path, node)
@@ -141,9 +140,9 @@ async def update_node(
         )  # TODO: can this be done automatically, or add node through an API?
         return session
     except NodeAlreadyExecutedError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
     except IndexError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
 
 
 @session_router.delete(
@@ -162,7 +161,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:
-        return Response(status_code=404)
+        raise HTTPException(status_code=404)
 
     try:
         session.delete_node(node_path)
@@ -171,9 +170,9 @@ async def delete_node(
         )  # TODO: can this be done automatically, or add node through an API?
         return session
     except NodeAlreadyExecutedError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
     except IndexError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
 
 
 @session_router.post(
@@ -192,7 +191,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:
-        return Response(status_code=404)
+        raise HTTPException(status_code=404)
 
     try:
         session.add_edge(edge)
@@ -201,9 +200,9 @@ async def add_edge(
         )  # TODO: can this be done automatically, or add node through an API?
         return session
     except NodeAlreadyExecutedError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
     except IndexError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
 
 
 # TODO: the edge being in the path here is really ugly, find a better solution
@@ -226,7 +225,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:
-        return Response(status_code=404)
+        raise HTTPException(status_code=404)
 
     try:
         edge = Edge(
@@ -239,9 +238,9 @@ async def delete_edge(
         )  # TODO: can this be done automatically, or add node through an API?
         return session
     except NodeAlreadyExecutedError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
     except IndexError:
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
 
 
 @session_router.put(
@@ -259,14 +258,14 @@ async def invoke_session(
     all: bool = Query(
         default=False, description="Whether or not to invoke all remaining invocations"
     ),
-) -> None:
+) -> Response:
     """Invokes a session"""
     session = ApiDependencies.invoker.services.graph_execution_manager.get(session_id)
     if session is None:
-        return Response(status_code=404)
+        raise HTTPException(status_code=404)
 
     if session.is_complete():
-        return Response(status_code=400)
+        raise HTTPException(status_code=400)
 
     ApiDependencies.invoker.invoke(session, invoke_all=all)
     return Response(status_code=202)
@@ -281,7 +280,7 @@ async def invoke_session(
 )
 async def cancel_session_invoke(
     session_id: str = Path(description="The id of the session to cancel"),
-) -> None:
+) -> Response:
     """Invokes a session"""
     ApiDependencies.invoker.cancel(session_id)
     return Response(status_code=202)

invokeai/app/api_app.py

@@ -3,6 +3,7 @@ import asyncio
 from inspect import signature
 
 import uvicorn
+import invokeai.backend.util.logging as logger
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
@@ -12,12 +13,11 @@ from fastapi_events.handlers.local import local_handler
 from fastapi_events.middleware import EventHandlerASGIMiddleware
 from pydantic.schema import schema
 
-from ..backend import Args
 from .api.dependencies import ApiDependencies
 from .api.routers import images, sessions, models
 from .api.sockets import SocketIO
-from .invocations import *
 from .invocations.baseinvocation import BaseInvocation
+from .services.config import InvokeAIAppConfig
 
 # Create the app
 # TODO: create this all in a method so configuration/etc. can be passed in?
@@ -33,30 +33,25 @@ 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 = {}
-
+# initialize config
+# this is a module global
+app_config = InvokeAIAppConfig()
 
 # Add startup event to load dependencies
 @app.on_event("startup")
 async def startup_event():
-    config = Args()
-    config.parse_args()
+    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,
+    )
 
     ApiDependencies.initialize(
-        config=config, event_handler_id=event_handler_id
+        config=app_config, event_handler_id=event_handler_id, logger=logger
     )
 
 
@@ -126,7 +121,6 @@ app.openapi = custom_openapi
 # Override API doc favicons
 app.mount("/static", StaticFiles(directory="static/dream_web"), name="static")
 
-
 @app.get("/docs", include_in_schema=False)
 def overridden_swagger():
     return get_swagger_ui_html(
@@ -144,17 +138,16 @@ def overridden_redoc():
         redoc_favicon_url="/static/favicon.ico",
     )
 
+# Must mount *after* the other routes else it borks em
+app.mount("/", StaticFiles(directory="invokeai/frontend/web/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="0.0.0.0", port=9090, loop=loop)
+    config = uvicorn.Config(app=app, host=app_config.host, port=app_config.port, 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,14 +2,15 @@
 
 from abc import ABC, abstractmethod
 import argparse
-from typing import Any, Callable, Iterable, Literal, get_args, get_origin, get_type_hints
+from typing import Any, Callable, Iterable, Literal, Union, 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, GraphInvocation, Edge
+from ..services.graph import GraphExecutionState, LibraryGraph, Edge
 from ..services.invoker import Invoker
 
 
@@ -229,7 +230,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)
-            print(f"{entry_id}: {get_invocation_command(entry)}")
+            logger.info(f"{entry_id}: {get_invocation_command(entry)}")
 
 
 class SetDefaultCommand(BaseCommand):
@@ -284,3 +285,19 @@ 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,9 +10,11 @@ import shlex
 from pathlib import Path
 from typing import List, Dict, Literal, get_args, get_type_hints, get_origin
 
-from ...backend import ModelManager, Globals
+import invokeai.backend.util.logging as logger
+from ...backend import ModelManager
 from ..invocations.baseinvocation import BaseInvocation
 from .commands import BaseCommand
+from ..services.invocation_services import InvocationServices
 
 # singleton object, class variable
 completer = None
@@ -130,13 +132,13 @@ class Completer(object):
             readline.redisplay()
             self.linebuffer = None
     
-def set_autocompleter(model_manager: ModelManager) -> Completer:
+def set_autocompleter(services: InvocationServices) -> Completer:
     global completer
     
     if completer:
         return completer
     
-    completer = Completer(model_manager)
+    completer = Completer(services.model_manager)
 
     readline.set_completer(completer.complete)
     # pyreadline3 does not have a set_auto_history() method
@@ -152,7 +154,7 @@ def set_autocompleter(model_manager: ModelManager) -> Completer:
     readline.parse_and_bind("set skip-completed-text on")
     readline.parse_and_bind("set show-all-if-ambiguous on")
 
-    histfile = Path(Globals.root, ".invoke_history")
+    histfile = Path(services.configuration.root_dir / ".invoke_history")
     try:
         readline.read_history_file(histfile)
         readline.set_history_length(1000)
@@ -160,8 +162,8 @@ def set_autocompleter(model_manager: ModelManager) -> Completer:
         pass
     except OSError:  # file likely corrupted
         newname = f"{histfile}.old"
-        print(
-            f"## Your history file {histfile} couldn't be loaded and may be corrupted. Renaming it to {newname}"
+        logger.error(
+            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,30 +4,29 @@ import argparse
 import os
 import re
 import shlex
+import sys
 import time
 from typing import (
     Union,
     get_type_hints,
 )
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 from pydantic.fields import Field
 
+
+import invokeai.backend.util.logging as logger
 from invokeai.app.services.metadata import PngMetadataService
-
 from .services.default_graphs import create_system_graphs
-
 from .services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
 
-from ..backend import Args
-from .cli.commands import BaseCommand, CliContext, ExitCli, add_graph_parsers, add_parsers, get_graph_execution_history
+from .cli.commands import BaseCommand, CliContext, ExitCli, add_graph_parsers, add_parsers, SortedHelpFormatter
 from .cli.completer import set_autocompleter
-from .invocations import *
 from .invocations.baseinvocation import BaseInvocation
 from .services.events import EventServiceBase
 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.graph import Edge, EdgeConnection, 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
@@ -35,7 +34,7 @@ from .services.invocation_services import InvocationServices
 from .services.invoker import Invoker
 from .services.processor import DefaultInvocationProcessor
 from .services.sqlite import SqliteItemStorage
-
+from .services.config import get_invokeai_config
 
 class CliCommand(BaseModel):
     command: Union[BaseCommand.get_commands() + BaseInvocation.get_invocations()] = Field(discriminator="type")  # type: ignore
@@ -65,7 +64,7 @@ def add_invocation_args(command_parser):
 
 def get_command_parser(services: InvocationServices) -> argparse.ArgumentParser:
     # Create invocation parser
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(formatter_class=SortedHelpFormatter)
 
     def exit(*args, **kwargs):
         raise InvalidArgs
@@ -182,7 +181,7 @@ def invoke_all(context: CliContext):
     # Print any errors
     if context.session.has_error():
         for n in context.session.errors:
-            print(
+            context.invoker.services.logger.error(
                 f"Error in node {n} (source node {context.session.prepared_source_mapping[n]}): {context.session.errors[n]}"
             )
         
@@ -190,24 +189,25 @@ def invoke_all(context: CliContext):
 
 
 def invoke_cli():
-    config = Args()
-    config.parse_args()
-    model_manager = get_model_manager(config)
+    # this gets the basic configuration
+    config = get_invokeai_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)
+    # 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 = get_model_manager(config,logger=logger)
+    
     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?
     db_location = os.path.join(output_folder, "invokeai.db")
 
@@ -225,7 +225,9 @@ def invoke_cli():
             filename=db_location, table_name="graph_executions"
         ),
         processor=DefaultInvocationProcessor(),
-        restoration=RestorationServices(config),
+        restoration=RestorationServices(config,logger=logger),
+        logger=logger,
+        configuration=config,
     )
 
     system_graphs = create_system_graphs(services.graph_library)
@@ -241,10 +243,18 @@ def invoke_cli():
     # print(services.session_manager.list())
 
     context = CliContext(invoker, session, parser)
+    set_autocompleter(services)
 
-    while True:
+    command_line_args_exist = len(invocation_commands) > 0
+    done = False
+    
+    while not done:
         try:
-            cmd_input = input("invoke> ")
+            if command_line_args_exist:
+                cmd_input = invocation_commands.pop(0)
+                done = len(invocation_commands) == 0
+            else:
+                cmd_input = input("invoke> ")
         except (KeyboardInterrupt, EOFError):
             # Ctrl-c exits
             break
@@ -365,12 +375,15 @@ def invoke_cli():
             invoke_all(context)
 
         except InvalidArgs:
-            print('Invalid command, use "help" to list commands')
+            invoker.services.logger.warning('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
-            print("Session error: creating a new session")
+            invoker.services.logger.warning("Session error: creating a new session")
             context.reset()
 
         except ExitCli:

invokeai/app/invocations/collections.py

@@ -3,12 +3,12 @@
 from typing import Literal, Optional
 
 import numpy as np
-import numpy.random
 from pydantic import Field
 
+from invokeai.app.util.misc import SEED_MAX, get_random_seed
+
 from .baseinvocation import (
     BaseInvocation,
-    InvocationConfig,
     InvocationContext,
     BaseInvocationOutput,
 )
@@ -50,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: Optional[int] = Field(
+    seed: int = Field(
         ge=0,
-        le=np.iinfo(np.int32).max,
-        description="The seed for the RNG",
-        default_factory=lambda: numpy.random.randint(0, np.iinfo(np.int32).max),
+        le=SEED_MAX,
+        description="The seed for the RNG (omit for random)",
+        default_factory=get_random_seed,
     )
 
     def invoke(self, context: InvocationContext) -> IntCollectionOutput:

invokeai/app/invocations/compel.py

@@ -0,0 +1,244 @@
+from typing import Literal, Optional, Union
+from pydantic import BaseModel, Field
+
+from invokeai.app.invocations.util.choose_model import choose_model
+from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext, InvocationConfig
+
+from ...backend.util.devices import choose_torch_device, torch_dtype
+from ...backend.stable_diffusion.diffusion import InvokeAIDiffuserComponent
+from ...backend.stable_diffusion.textual_inversion_manager import TextualInversionManager
+
+from compel import Compel
+from compel.prompt_parser import (
+    Blend,
+    CrossAttentionControlSubstitute,
+    FlattenedPrompt,
+    Fragment,
+)
+
+
+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")
+    model: str = Field(default="", description="Model 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:
+
+        # TODO: load without model
+        model = choose_model(context.services.model_manager, self.model)
+        pipeline = model["model"]
+        tokenizer = pipeline.tokenizer
+        text_encoder = pipeline.text_encoder
+
+        # TODO: global? input?
+        #use_full_precision = precision == "float32" or precision == "autocast"
+        #use_full_precision = False
+
+        # TODO: redo TI when separate model loding implemented
+        #textual_inversion_manager = TextualInversionManager(
+        #    tokenizer=tokenizer,
+        #    text_encoder=text_encoder,
+        #    full_precision=use_full_precision,
+        #)
+
+        def load_huggingface_concepts(concepts: list[str]):
+            pipeline.textual_inversion_manager.load_huggingface_concepts(concepts)
+
+        # apply the concepts library to the prompt
+        prompt_str = pipeline.textual_inversion_manager.hf_concepts_library.replace_concepts_with_triggers(
+            self.prompt,
+            lambda concepts: load_huggingface_concepts(concepts),
+            pipeline.textual_inversion_manager.get_all_trigger_strings(),
+        )
+
+        # lazy-load any deferred textual inversions.
+        # this might take a couple of seconds the first time a textual inversion is used.
+        pipeline.textual_inversion_manager.create_deferred_token_ids_for_any_trigger_terms(
+            prompt_str
+        )
+
+        compel = Compel(
+            tokenizer=tokenizer,
+            text_encoder=text_encoder,
+            textual_inversion_manager=pipeline.textual_inversion_manager,
+            dtype_for_device_getter=torch_dtype,
+            truncate_long_prompts=True, # TODO:
+        )
+
+        # TODO: support legacy blend?
+
+        conjunction = Compel.parse_prompt_string(prompt_str)
+        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, prompt),
+            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.set(conditioning_name, (c, ec))
+
+        return CompelOutput(
+            conditioning=ConditioningField(
+                conditioning_name=conditioning_name,
+            ),
+        )
+
+
+def get_max_token_count(
+    tokenizer, prompt: Union[FlattenedPrompt, Blend], truncate_if_too_long=False
+) -> int:
+    if type(prompt) is Blend:
+        blend: Blend = prompt
+        return max(
+            [
+                get_max_token_count(tokenizer, c, truncate_if_too_long)
+                for c in blend.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_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/generate.py

@@ -1,17 +1,17 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
 from functools import partial
-from typing import Literal, Optional, Union
+from typing import Literal, Optional, Union, get_args
 
 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 ImageField, ImageType
+from invokeai.app.models.image import ColorField, ImageField, ImageType
 from invokeai.app.invocations.util.choose_model import choose_model
+from invokeai.app.util.misc import SEED_MAX, get_random_seed
+from invokeai.backend.generator.inpaint import infill_methods
 from .baseinvocation import BaseInvocation, InvocationContext, InvocationConfig
 from .image import ImageOutput, build_image_output
 from ...backend.generator import Txt2Img, Img2Img, Inpaint, InvokeAIGenerator
@@ -19,7 +19,8 @@ from ...backend.stable_diffusion import PipelineIntermediateState
 from ..util.step_callback import stable_diffusion_step_callback
 
 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'
 
 class SDImageInvocation(BaseModel):
     """Helper class to provide all Stable Diffusion raster image invocations with additional config"""
@@ -46,18 +47,13 @@ class TextToImageInvocation(BaseInvocation, SDImageInvocation):
     # 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", )
+    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="lms", description="The scheduler to use" )
     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
 
     # TODO: pass this an emitter method or something? or a session for dispatching?
@@ -75,36 +71,20 @@ class TextToImageInvocation(BaseInvocation, SDImageInvocation):
         )
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
+        # Handle invalid model parameter
         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(
+        outputs = Txt2Img(model).generate(
             prompt=self.prompt,
             step_callback=partial(self.dispatch_progress, context, source_node_id),
-            control_image=control_image,
             **self.dict(
-                exclude={"prompt", "control_image" }
+                exclude={"prompt"}
             ),  # Shorthand for passing all of the parameters above manually
         )
         # Outputs is an infinite iterator that will return a new InvokeAIGeneratorOutput object
@@ -169,7 +149,9 @@ class ImageToImageInvocation(TextToImageInvocation):
                 self.image.image_type, self.image.image_name
             )
         )
-        mask = None
+
+        if self.fit:
+            image = image.resize((self.width, self.height))
 
         # Handle invalid model parameter
         model = choose_model(context.services.model_manager, self.model)
@@ -183,7 +165,6 @@ class ImageToImageInvocation(TextToImageInvocation):
         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"}
@@ -215,7 +196,6 @@ class ImageToImageInvocation(TextToImageInvocation):
             image=result_image,
         )
 
-
 class InpaintInvocation(ImageToImageInvocation):
     """Generates an image using inpaint."""
 
@@ -223,6 +203,17 @@ class InpaintInvocation(ImageToImageInvocation):
 
     # 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,
@@ -268,8 +259,8 @@ class InpaintInvocation(ImageToImageInvocation):
 
         outputs = Inpaint(model).generate(
             prompt=self.prompt,
-            init_img=image,
-            init_mask=mask,
+            init_image=image,
+            mask_image=mask,
             step_callback=partial(self.dispatch_progress, context, source_node_id),
             **self.dict(
                 exclude={"prompt", "image", "mask"}

invokeai/app/invocations/image.py

@@ -1,5 +1,6 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
+import io
 from typing import Literal, Optional
 
 import numpy
@@ -32,14 +33,12 @@ class ImageOutput(BaseInvocationOutput):
     # fmt: off
     type: Literal["image"] = "image"
     image:      ImageField = Field(default=None, description="The output image")
-    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")
+    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", "mode"]
-        }
+        schema_extra = {"required": ["type", "image", "width", "height"]}
 
 
 def build_image_output(
@@ -54,7 +53,6 @@ def build_image_output(
         image=image_field,
         width=image.width,
         height=image.height,
-        mode=image.mode,
     )
 
 
@@ -151,7 +149,7 @@ class CropImageInvocation(BaseInvocation, PILInvocationConfig):
         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,
@@ -209,7 +207,7 @@ class PasteImageInvocation(BaseInvocation, PILInvocationConfig):
         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,

invokeai/app/invocations/infill.py

@@ -0,0 +1,233 @@
+# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
+
+from typing import Literal, Optional, 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, build_image_output
+from invokeai.app.util.misc import SEED_MAX, get_random_seed
+from invokeai.backend.image_util.patchmatch import PatchMatch
+
+from ..models.image import ColorField, ImageField, ImageType
+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: Optional[ImageField] = Field(default=None, description="The image to infill")
+    color: Optional[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(
+            self.image.image_type, self.image.image_name
+        )
+
+        solid_bg = Image.new("RGBA", image.size, self.color.tuple())
+        infilled = Image.alpha_composite(solid_bg, image)
+
+        infilled.paste(image, (0, 0), image.split()[-1])
+
+        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, infilled, metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=image,
+        )
+
+
+class InfillTileInvocation(BaseInvocation):
+    """Infills transparent areas of an image with tiles of the image"""
+
+    type: Literal["infill_tile"] = "infill_tile"
+
+    image: Optional[ImageField] = 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(
+            self.image.image_type, 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_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, infilled, metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=image,
+        )
+
+
+class InfillPatchMatchInvocation(BaseInvocation):
+    """Infills transparent areas of an image using the PatchMatch algorithm"""
+
+    type: Literal["infill_patchmatch"] = "infill_patchmatch"
+
+    image: Optional[ImageField] = Field(default=None, description="The image to infill")
+
+    def invoke(self, context: InvocationContext) -> ImageOutput:
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
+
+        if PatchMatch.patchmatch_available():
+            infilled = infill_patchmatch(image.copy())
+        else:
+            raise ValueError("PatchMatch is not available on this system")
+
+        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, infilled, metadata)
+        return build_image_output(
+            image_type=image_type,
+            image_name=image_name,
+            image=image,
+        )

invokeai/app/invocations/latent.py

@@ -1,11 +1,13 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
 
 import random
-from typing import Literal, Optional
+from typing import Literal, Optional, Union
+import einops
 from pydantic import BaseModel, Field
 import torch
 
 from invokeai.app.invocations.util.choose_model import choose_model
+from invokeai.app.util.misc import SEED_MAX, get_random_seed
 
 from invokeai.app.util.step_callback import stable_diffusion_step_callback
 
@@ -14,12 +16,14 @@ from ...backend.util.devices import choose_torch_device, torch_dtype
 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 ...backend.stable_diffusion.diffusers_pipeline import ConditioningData, StableDiffusionGeneratorPipeline, image_resized_to_grid_as_tensor
+from ...backend.stable_diffusion.schedulers import SCHEDULER_MAP
 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 .compel import ConditioningField
 from ...backend.stable_diffusion import PipelineIntermediateState
 from diffusers.schedulers import SchedulerMixin as Scheduler
 import diffusers
@@ -37,41 +41,55 @@ class LatentsField(BaseModel):
 class LatentsOutput(BaseInvocationOutput):
     """Base class for invocations that output latents"""
     #fmt: off
-    type: Literal["latent_output"] = "latent_output"
-    latents: LatentsField            = Field(default=None, description="The output latents")
+    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")
     #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"
+    type:  Literal["noise_output"] = "noise_output"
+
+    # Inputs
     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
 
-
-# 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,
-)
+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,
+      )
 
 
 SAMPLER_NAME_VALUES = Literal[
-    tuple(list(scheduler_map.keys()))
+    tuple(list(SCHEDULER_MAP.keys()))
 ]
 
 
 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)
+    scheduler_class, scheduler_extra_config = SCHEDULER_MAP.get(scheduler_name, SCHEDULER_MAP['ddim'])
+    
+    scheduler_config = model.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)
+    
     # hack copied over from generate.py
     if not hasattr(scheduler, 'uses_inpainting_model'):
         scheduler.uses_inpainting_model = lambda: False
@@ -102,19 +120,15 @@ def get_noise(width:int, height:int, device:torch.device, seed:int = 0, latent_c
     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=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", )
+    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", )
 
 
     # Schema customisation
@@ -131,32 +145,26 @@ class NoiseInvocation(BaseInvocation):
 
         name = f'{context.graph_execution_state_id}__{self.id}'
         context.services.latents.set(name, noise)
-        return NoiseOutput(
-            noise=LatentsField(latents_name=name)
-        )
+        return build_noise_output(latents_name=name, latents=noise)
 
 
 # Text to image
 class TextToLatentsInvocation(BaseInvocation):
-    """Generates latents from a prompt."""
+    """Generates latents from conditionings."""
 
     type: Literal["t2l"] = "t2l"
 
     # 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)", )
+    positive_conditioning: Optional[ConditioningField] = Field(description="Positive conditioning for generation")
+    negative_conditioning: Optional[ConditioningField] = Field(description="Negative conditioning for generation")
     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")
-    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" )
+    scheduler: SAMPLER_NAME_VALUES = Field(default="lms", description="The scheduler to use" )
+    model:       str = Field(default="", description="The model to use (currently ignored)")
     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
 
     # Schema customisation
@@ -206,8 +214,10 @@ class TextToLatentsInvocation(BaseInvocation):
         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)
+    def get_conditioning_data(self, context: InvocationContext, model: StableDiffusionGeneratorPipeline) -> ConditioningData:
+        c, extra_conditioning_info = context.services.latents.get(self.positive_conditioning.conditioning_name)
+        uc, _ = context.services.latents.get(self.negative_conditioning.conditioning_name)
+
         conditioning_data = ConditioningData(
             uc,
             c,
@@ -219,7 +229,7 @@ class TextToLatentsInvocation(BaseInvocation):
                 h_symmetry_time_pct=None,#h_symmetry_time_pct,
                 v_symmetry_time_pct=None#v_symmetry_time_pct,
             ),
-        ).add_scheduler_args_if_applicable(model.scheduler, eta=None)#ddim_eta)
+        ).add_scheduler_args_if_applicable(model.scheduler, eta=0.0)#ddim_eta)
         return conditioning_data
 
 
@@ -234,7 +244,7 @@ class TextToLatentsInvocation(BaseInvocation):
             self.dispatch_progress(context, source_node_id, state)
 
         model = self.get_model(context.services.model_manager)
-        conditioning_data = self.get_conditioning_data(model)
+        conditioning_data = self.get_conditioning_data(context, model)
 
         # TODO: Verify the noise is the right size
 
@@ -251,9 +261,7 @@ class TextToLatentsInvocation(BaseInvocation):
 
         name = f'{context.graph_execution_state_id}__{self.id}'
         context.services.latents.set(name, result_latents)
-        return LatentsOutput(
-            latents=LatentsField(latents_name=name)
-        )
+        return build_latents_output(latents_name=name, latents=result_latents)
 
 
 class LatentsToLatentsInvocation(TextToLatentsInvocation):
@@ -261,6 +269,10 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
 
     type: Literal["l2l"] = "l2l"
 
+    # 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")
+
     # Schema customisation
     class Config(InvocationConfig):
         schema_extra = {
@@ -272,10 +284,6 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
             },
         }
 
-    # 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)
@@ -288,7 +296,7 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
             self.dispatch_progress(context, source_node_id, state)
 
         model = self.get_model(context.services.model_manager)
-        conditioning_data = self.get_conditioning_data(model)
+        conditioning_data = self.get_conditioning_data(context, model)
 
         # TODO: Verify the noise is the right size
 
@@ -296,11 +304,7 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
             latent, device=model.device, dtype=latent.dtype
         )
 
-        timesteps, _ = model.get_img2img_timesteps(
-            self.steps,
-            self.strength,
-            device=model.device,
-        )
+        timesteps, _ = model.get_img2img_timesteps(self.steps, self.strength)
 
         result_latents, result_attention_map_saver = model.latents_from_embeddings(
             latents=initial_latents,
@@ -316,9 +320,7 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
 
         name = f'{context.graph_execution_state_id}__{self.id}'
         context.services.latents.set(name, result_latents)
-        return LatentsOutput(
-            latents=LatentsField(latents_name=name)
-        )
+        return build_latents_output(latents_name=name, latents=result_latents)
 
 
 # Latent to image
@@ -363,9 +365,118 @@ class LatentsToImageInvocation(BaseInvocation):
                 session_id=context.graph_execution_state_id, node=self
             )
 
+            torch.cuda.empty_cache()
+
             context.services.images.save(image_type, image_name, image, metadata)
             return build_image_output(
-                image_type=image_type,
-                image_name=image_name,
-                image=image
+                image_type=image_type, image_name=image_name, image=image
             )
+
+
+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)
+        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)
+        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")
+    model: str = Field(default="", description="The model to use")
+
+    # Schema customisation
+    class Config(InvocationConfig):
+        schema_extra = {
+            "ui": {
+                "tags": ["latents", "image"],
+                "type_hints": {"model": "model"},
+            },
+        }
+
+    @torch.no_grad()
+    def invoke(self, context: InvocationContext) -> LatentsOutput:
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
+        )
+
+        # TODO: this only really needs the vae
+        model_info = choose_model(context.services.model_manager, self.model)
+        model: StableDiffusionGeneratorPipeline = model_info["model"]
+
+        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")
+
+        latents = model.non_noised_latents_from_image(
+            image_tensor,
+            device=model._model_group.device_for(model.unet),
+            dtype=model.unet.dtype,
+        )
+
+        name = f"{context.graph_execution_state_id}__{self.id}"
+        context.services.latents.set(name, latents)
+        return build_latents_output(latents_name=name, latents=latents)

invokeai/app/invocations/math.py

@@ -3,8 +3,14 @@
 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):
@@ -21,19 +27,21 @@ 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
+    # 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)
@@ -41,11 +49,12 @@ 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)
@@ -53,11 +62,12 @@ 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)
@@ -65,11 +75,26 @@ 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/util/choose_model.py

@@ -3,12 +3,12 @@ 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:
+    logger = model_manager.logger
+    if model_name and not model_manager.valid_model(model_name):
+        default_model_name = model_manager.default_model()
+        logger.warning(f"\'{model_name}\' is not a valid model name. Using default model \'{default_model_name}\' instead.")
         model = model_manager.get_model()
-        print(
-            f"* Warning: '{model_name}' is not a valid model name. Using default model \'{model['model_name']}\' instead."
-        )
+    else:
+        model = model_manager.get_model(model_name)
 
     return model

invokeai/app/models/image.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Optional
+from typing import Optional, Tuple
 from pydantic import BaseModel, Field
 
 
@@ -27,3 +27,13 @@ class ImageField(BaseModel):
 
     class Config:
         schema_extra = {"required": ["image_type", "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)

invokeai/app/services/config.py

@@ -0,0 +1,521 @@
+# 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
+    embedding_dir: embeddings
+    lora_dir: loras
+    autoconvert_dir: null
+    gfpgan_model_dir: models/gfpgan/GFPGANv1.4.pth
+  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=omegaconf)
+
+By default, InvokeAIAppConfig 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 = InvokeAIAppConfig(arg=['--xformers_enabled'])
+
+It is also possible to set a value at initialization time. This value
+has highest priority.
+
+ conf = InvokeAIAppConfig(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:
+
+ from invokeai.app.services.config import InvokeAIAppConfig
+ from invokeai.invocations.generate import TextToImageInvocation
+
+ # get global configuration and print its nsfw_checker value
+ conf = InvokeAIAppConfig()
+ print(conf.nsfw_checker)
+
+ # get the text2image invocation and print its step value
+ text2image = TextToImageInvocation()
+ print(text2image.steps)
+
+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 get_invokeai_config() function
+does this:
+
+  config = get_invokeai_config()
+  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
+     ...
+'''
+import argparse
+import pydoc
+import typing
+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 Any, ClassVar, Dict, List, Literal, Type, Union, get_origin, get_type_hints, get_args
+
+INIT_FILE = Path('invokeai.yaml')
+LEGACY_INIT_FILE = Path('invokeai.init')
+
+# This global stores a singleton InvokeAIAppConfig configuration object
+global_config = None
+
+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_known_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>.
+     '''
+    #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')
+
+    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')
+    embedding_dir       : Path = Field(default='embeddings', description='Path to InvokeAI textual inversion aembeddings directory', category='Paths')
+    gfpgan_model_dir    : Path = Field(default="./models/gfpgan/GFPGANv1.4.pth", description='Path to GFPGAN models directory.', category='Paths')
+    legacy_conf_dir     : Path = Field(default='configs/stable-diffusion', description='Path to directory of legacy checkpoint config files', category='Paths')
+    lora_dir            : Path = Field(default='loras', description='Path to InvokeAI LoRA model 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')
+
+    model               : str = Field(default='stable-diffusion-1.5', description='Initial model name', category='Models')
+    embeddings          : bool = Field(default=True, description='Load contents of embeddings directory', category='Models')
+    #fmt: on
+
+    def __init__(self, conf: DictConfig = None, argv: List[str]=None, **kwargs):
+        '''
+        Initialize InvokeAIAppconfig.
+        :param conf: alternate Omegaconf dictionary object
+        :param argv: aternate sys.argv list
+        :param **kwargs: attributes to initialize with
+        '''
+        super().__init__(**kwargs)
+
+        # Set the runtime root directory. We parse command-line switches here
+        # in order to pick up the --root_dir option.
+        self.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
+        self.parse_args(argv)
+
+        # restore initialization values
+        hints = get_type_hints(self)
+        for k in kwargs:
+            setattr(self,k,parse_obj_as(hints[k],kwargs[k]))
+
+    @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 output_path(self)->Path:
+        '''
+        Path to defaults outputs directory.
+        '''
+        return self._resolve(self.outdir)
+
+    @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 cache_dir(self)->Path:
+        '''
+        Path to the global cache directory for HuggingFace hub-managed models
+        '''
+        return self.models_dir / "hub"
+
+    @property
+    def models_dir(self)->Path:
+        '''
+        Path to the models directory
+        '''
+        return self._resolve("models")
+
+    @property
+    def embedding_path(self)->Path:
+        '''
+        Path to the textual inversion embeddings directory.
+        '''
+        return self._resolve(self.embedding_dir) if self.embedding_dir else None
+
+    @property
+    def lora_path(self)->Path:
+        '''
+        Path to the LoRA models directory.
+        '''
+        return self._resolve(self.lora_dir) if self.lora_dir else None
+
+    @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
+
+    @property
+    def gfpgan_model_path(self)->Path:
+        '''
+        Path to the GFPGAN model.
+        '''
+        return self._resolve(self.gfpgan_model_dir) if self.gfpgan_model_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(cls:Type[InvokeAISettings]=InvokeAIAppConfig,**kwargs)->InvokeAISettings:
+    '''
+    This returns a singleton InvokeAIAppConfig configuration object.
+    '''
+    global global_config
+    if global_config is None or type(global_config)!=cls:
+        global_config = cls(**kwargs)
+    return global_config

invokeai/app/services/default_graphs.py

@@ -1,4 +1,5 @@
 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
@@ -16,38 +17,45 @@ 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': TextToLatentsInvocation(id='4'),
-                '5': LatentsToImageInvocation(id='5')
+                '4': CompelInvocation(id='4'),
+                '5': CompelInvocation(id='5'),
+                '6': TextToLatentsInvocation(id='6'),
+                '7': LatentsToImageInvocation(id='7'),
             },
             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='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')),
+                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')),
             ]
         ),
         exposed_inputs=[
-            ExposedNodeInput(node_path='4', field='prompt', alias='prompt'),
+            ExposedNodeInput(node_path='4', field='prompt', alias='positive_prompt'),
+            ExposedNodeInput(node_path='5', field='prompt', alias='negative_prompt'),
             ExposedNodeInput(node_path='width', field='a', alias='width'),
-            ExposedNodeInput(node_path='height', field='a', alias='height')
+            ExposedNodeInput(node_path='height', field='a', alias='height'),
+            ExposedNodeInput(node_path='seed', field='a', alias='seed'),
         ],
         exposed_outputs=[
-            ExposedNodeOutput(node_path='5', field='image', alias='image')
+            ExposedNodeOutput(node_path='7', 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/graph.py

@@ -135,6 +135,7 @@ 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
@@ -162,6 +163,7 @@ 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(

invokeai/app/services/image_storage.py

@@ -5,11 +5,16 @@ from glob import glob
 from abc import ABC, abstractmethod
 from pathlib import Path
 from queue import Queue
-from typing import Dict, List, Tuple
+from typing import Dict, List
 
 from PIL.Image import Image
 import PIL.Image as PILImage
-from invokeai.app.api.models.images import ImageResponse, ImageResponseMetadata
+from send2trash import send2trash
+from invokeai.app.api.models.images import (
+    ImageResponse,
+    ImageResponseMetadata,
+    SavedImage,
+)
 from invokeai.app.models.image import ImageType
 from invokeai.app.services.metadata import (
     InvokeAIMetadata,
@@ -41,7 +46,15 @@ class ImageStorageBase(ABC):
     def get_path(
         self, image_type: ImageType, image_name: str, is_thumbnail: bool = False
     ) -> str:
-        """Gets the path to an image or its thumbnail."""
+        """Gets the internal path to an image or its thumbnail."""
+        pass
+
+    # TODO: make this a bit more flexible for e.g. cloud storage
+    @abstractmethod
+    def get_uri(
+        self, image_type: ImageType, image_name: str, is_thumbnail: bool = False
+    ) -> str:
+        """Gets the external URI to an image or its thumbnail."""
         pass
 
     # TODO: make this a bit more flexible for e.g. cloud storage
@@ -57,8 +70,8 @@ class ImageStorageBase(ABC):
         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."""
+    ) -> SavedImage:
+        """Saves an image and a 256x256 WEBP thumbnail. Returns a tuple of the image name, thumbnail name, and created timestamp."""
         pass
 
     @abstractmethod
@@ -126,8 +139,8 @@ class DiskImageStorage(ImageStorageBase):
                     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",
+                    image_url=self.get_uri(image_type, filename),
+                    thumbnail_url=self.get_uri(image_type, filename, True),
                     # TODO: Creation of this object should happen elsewhere (?), just making it fit here so it works
                     metadata=ImageResponseMetadata(
                         created=int(os.path.getctime(path)),
@@ -174,7 +187,23 @@ class DiskImageStorage(ImageStorageBase):
         else:
             path = os.path.join(self.__output_folder, image_type, basename)
 
-        return path
+        abspath = os.path.abspath(path)
+
+        return abspath
+
+    def get_uri(
+        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:
+            thumbnail_basename = get_thumbnail_name(basename)
+            uri = f"api/v1/images/{image_type.value}/thumbnails/{thumbnail_basename}"
+        else:
+            uri = f"api/v1/images/{image_type.value}/{basename}"
+
+        return uri
 
     def validate_path(self, path: str) -> bool:
         try:
@@ -189,7 +218,7 @@ class DiskImageStorage(ImageStorageBase):
         image_name: str,
         image: Image,
         metadata: InvokeAIMetadata | None = None,
-    ) -> Tuple[str, str, int]:
+    ) -> SavedImage:
         image_path = self.get_path(image_type, image_name)
 
         # TODO: Reading the image and then saving it strips the metadata...
@@ -197,7 +226,7 @@ class DiskImageStorage(ImageStorageBase):
             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
+            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)
@@ -207,24 +236,30 @@ class DiskImageStorage(ImageStorageBase):
         self.__set_cache(image_path, image)
         self.__set_cache(thumbnail_path, thumbnail_image)
 
-        return (image_path, thumbnail_path, int(os.path.getctime(image_path)))
+        return SavedImage(
+            image_name=image_name,
+            thumbnail_name=thumbnail_name,
+            created=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)
+        basename = os.path.basename(image_name)
+        image_path = self.get_path(image_type, basename)
 
+        if os.path.exists(image_path):
+            send2trash(image_path)
         if image_path in self.__cache:
             del self.__cache[image_path]
 
-        if os.path.exists(thumbnail_path):
-            os.remove(thumbnail_path)
+        thumbnail_name = get_thumbnail_name(image_name)
+        thumbnail_path = self.get_path(image_type, thumbnail_name, True)
 
+        if os.path.exists(thumbnail_path):
+            send2trash(thumbnail_path)
         if thumbnail_path in self.__cache:
             del self.__cache[thumbnail_path]
 
-    def __get_cache(self, image_name: str) -> Image:
+    def __get_cache(self, image_name: str) -> Image | None:
         return None if image_name not in self.__cache else self.__cache[image_name]
 
     def __set_cache(self, image_name: str, image: Image):
@@ -235,4 +270,5 @@ class DiskImageStorage(ImageStorageBase):
             )  # 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]
+                if cache_id in self.__cache:
+                    del self.__cache[cache_id]

invokeai/app/services/invocation_services.py

@@ -1,4 +1,6 @@
-# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
+# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654) and the InvokeAI Team
+
+from typing import types
 from invokeai.app.services.metadata import MetadataServiceBase
 from invokeai.backend import ModelManager
 
@@ -8,6 +10,7 @@ from .image_storage import ImageStorageBase
 from .restoration_services import RestorationServices
 from .invocation_queue import InvocationQueueABC
 from .item_storage import ItemStorageABC
+from .config import InvokeAISettings
 
 class InvocationServices:
     """Services that can be used by invocations"""
@@ -19,7 +22,8 @@ class InvocationServices:
     queue: InvocationQueueABC
     model_manager: ModelManager
     restoration: RestorationServices
-
+    configuration: InvokeAISettings
+    
     # NOTE: we must forward-declare any types that include invocations, since invocations can use services
     graph_library: ItemStorageABC["LibraryGraph"]
     graph_execution_manager: ItemStorageABC["GraphExecutionState"]
@@ -29,6 +33,7 @@ class InvocationServices:
             self,
             model_manager: ModelManager,
             events: EventServiceBase,
+            logger: types.ModuleType,
             latents: LatentsStorageBase,
             images: ImageStorageBase,
             metadata: MetadataServiceBase,
@@ -37,9 +42,11 @@ class InvocationServices:
             graph_execution_manager: ItemStorageABC["GraphExecutionState"],
             processor: "InvocationProcessorABC",
             restoration: RestorationServices,
+            configuration: InvokeAISettings=None,
     ):
         self.model_manager = model_manager
         self.events = events
+        self.logger = logger
         self.latents = latents
         self.images = images
         self.metadata = metadata
@@ -48,3 +55,4 @@ class InvocationServices:
         self.graph_execution_manager = graph_execution_manager
         self.processor = processor
         self.restoration = restoration
+        self.configuration = configuration

invokeai/app/services/invoker.py

@@ -49,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)
@@ -71,18 +71,12 @@ 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/metadata.py

@@ -20,9 +20,18 @@ class MetadataLatentsField(TypedDict):
     latents_name: str
 
 
+class MetadataColorField(TypedDict):
+    """Pydantic-less ColorField, used for metadata parsing"""
+    r: int
+    g: int
+    b: int
+    a: int
+
+
+
 # TODO: This is a placeholder for `InvocationsUnion` pending resolution of circular imports
 NodeMetadata = Dict[
-    str, str | int | float | bool | MetadataImageField | MetadataLatentsField
+    str, None | str | int | float | bool | MetadataImageField | MetadataLatentsField | MetadataColorField
 ]
 
 

invokeai/app/services/model_manager_initializer.py

@@ -2,26 +2,25 @@ import os
 import sys
 import torch
 from argparse import Namespace
-from invokeai.backend import Args
 from omegaconf import OmegaConf
 from pathlib import Path
+from typing import types
 
 import invokeai.version
+from .config import InvokeAISettings
 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.")
-            )
+def get_model_manager(config: InvokeAISettings, logger: types.ModuleType) -> ModelManager:
+    model_config = config.model_conf_path
+    if not model_config.exists():
+        report_model_error(
+            config, FileNotFoundError(f"The file {model_config} could not be found."), logger
+        )
 
-    print(f">> {invokeai.version.__app_name__}, version {invokeai.version.__version__}")
-    print(f'>> InvokeAI runtime directory is "{Globals.root}"')
+    logger.info(f"{invokeai.version.__app_name__}, version {invokeai.version.__version__}")
+    logger.info(f'InvokeAI runtime directory is "{config.root}"')
 
     # these two lines prevent a horrible warning message from appearing
     # when the frozen CLIP tokenizer is imported
@@ -31,20 +30,7 @@ def get_model_manager(config: Args) -> ModelManager:
     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
+    embedding_path = config.embedding_path
 
     # migrate legacy models
     ModelManager.migrate_models()
@@ -57,37 +43,36 @@ def get_model_manager(config: Args) -> ModelManager:
         else choose_precision(device)
         
         model_manager = ModelManager(
-            OmegaConf.load(config.conf),
+            OmegaConf.load(config.model_conf_path),
             precision=precision,
             device_type=device,
             max_loaded_models=config.max_loaded_models,
-            embedding_path = Path(embedding_path),
+            embedding_path = embedding_path,
+            logger = logger,
         )
     except (FileNotFoundError, TypeError, AssertionError) as e:
-        report_model_error(config, e)
+        report_model_error(config, e, logger)
     except (IOError, KeyError) as e:
-        print(f"{e}. Aborting.")
+        logger.error(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,
+    if config.autoconvert_path:
+        model_manager.heuristic_import(
+            config.autoconvert_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."
+def report_model_error(opt: Namespace, e: Exception, logger: types.ModuleType):
+    logger.error(f'An error occurred while attempting to initialize the model: "{str(e)}"')
+    logger.error(
+        "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"
+        logger.warning(
+            "Reconfiguration is being forced by environment variable INVOKE_MODEL_RECONFIGURE"
         )
     else:
         response = input(
@@ -96,13 +81,12 @@ def report_model_error(opt: Namespace, e: Exception):
         if response.startswith(("n", "N")):
             return
 
-    print("invokeai-configure is launching....\n")
+    logger.info("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())

invokeai/app/services/processor.py

@@ -1,17 +1,22 @@
+import time
 import traceback
-from threading import Event, Thread
+from threading import Event, Thread, BoundedSemaphore
 
 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(
@@ -20,7 +25,7 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
             kwargs=dict(stop_event=self.__stop_event),
         )
         self.__invoker_thread.daemon = (
-            True  # TODO: probably better to just not use threads?
+            True  # TODO: make async and do not use threads
         )
         self.__invoker_thread.start()
 
@@ -29,9 +34,16 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
 
     def __process(self, stop_event: Event):
         try:
+            self.__threadLimit.acquire()
             while not stop_event.is_set():
-                queue_item: InvocationQueueItem = self.__invoker.services.queue.get()
+                try:
+                    queue_item: InvocationQueueItem = self.__invoker.services.queue.get()
+                except Exception as e:
+                    logger.debug("Exception while getting from queue: %s" % e)
+
                 if not queue_item:  # Probably stopping
+                    # do not hammer the queue
+                    time.sleep(0.5)
                     continue
 
                 graph_execution_state = (
@@ -110,7 +122,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
@@ -120,11 +132,22 @@ 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:
-                    self.__invoker.invoke(graph_execution_state, invoke_all=True)
+                    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()
+                        )
                 elif is_complete:
                     self.__invoker.services.events.emit_graph_execution_complete(
                         graph_execution_state.id
                     )
 
         except KeyboardInterrupt:
-            ...  # Log something?
+            pass  # Log something? KeyboardInterrupt is probably not going to be seen by the processor
+        finally:
+            self.__threadLimit.release()

invokeai/app/services/restoration_services.py

@@ -1,6 +1,7 @@
 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
 
@@ -10,7 +11,7 @@ from ...backend.util import choose_torch_device, CPU_DEVICE, MPS_DEVICE
 class RestorationServices:
     '''Face restoration and upscaling'''
     
-    def __init__(self,args):
+    def __init__(self,args,logger:types.ModuleType):
         try:
             gfpgan, codeformer, esrgan = None, None, None
             if args.restore or args.esrgan:
@@ -20,20 +21,22 @@ class RestorationServices:
                         args.gfpgan_model_path
                     )
                 else:
-                    print(">> Face restoration disabled")
+                    logger.info("Face restoration disabled")
                     if args.esrgan:
                         esrgan = restoration.load_esrgan(args.esrgan_bg_tile)
                     else:
-                        print(">> Upscaling disabled")
+                        logger.info("Upscaling disabled")
             else:
-                print(">> Face restoration and upscaling disabled")
+                logger.info("Face restoration and upscaling disabled")
         except (ModuleNotFoundError, ImportError):
             print(traceback.format_exc(), file=sys.stderr)
-            print(">> You may need to install the ESRGAN and/or GFPGAN modules")
+            logger.info("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
@@ -58,15 +61,15 @@ class RestorationServices:
                     if self.gfpgan is not None or self.codeformer is not None:
                         if facetool == "gfpgan":
                             if self.gfpgan is None:
-                                print(
-                                    ">> GFPGAN not found. Face restoration is disabled."
+                                self.logger.info(
+                                    "GFPGAN not found. Face restoration is disabled."
                                 )
                             else:
                                 image = self.gfpgan.process(image, strength, seed)
                         if facetool == "codeformer":
                             if self.codeformer is None:
-                                print(
-                                    ">> CodeFormer not found. Face restoration is disabled."
+                                self.logger.info(
+                                    "CodeFormer not found. Face restoration is disabled."
                                 )
                             else:
                                 cf_device = (
@@ -80,7 +83,7 @@ class RestorationServices:
                                     fidelity=codeformer_fidelity,
                                 )
                     else:
-                        print(">> Face Restoration is disabled.")
+                        self.logger.info("Face Restoration is disabled.")
                 if upscale is not None:
                     if self.esrgan is not None:
                         if len(upscale) < 2:
@@ -93,10 +96,10 @@ class RestorationServices:
                             denoise_str=upscale_denoise_str,
                         )
                     else:
-                        print(">> ESRGAN is disabled. Image not upscaled.")
+                        self.logger.info("ESRGAN is disabled. Image not upscaled.")
             except Exception as e:
-                print(
-                    f">> Error running RealESRGAN or GFPGAN. Your image was not upscaled.\n{e}"
+                self.logger.info(
+                    f"Error running RealESRGAN or GFPGAN. Your image was not upscaled.\n{e}"
                 )
 
             if image_callback is not None:

invokeai/app/util/misc.py

@@ -1,5 +1,13 @@
 import datetime
+import numpy as np
 
 
 def get_timestamp():
     return int(datetime.datetime.now(datetime.timezone.utc).timestamp())
+
+
+SEED_MAX = np.iinfo(np.int32).max
+
+
+def get_random_seed():
+    return np.random.randint(0, SEED_MAX)

invokeai/backend/__init__.py

@@ -1,7 +1,6 @@
 """
 Initialization file for invokeai.backend
 """
-from .generate import Generate
 from .generator import (
     InvokeAIGeneratorBasicParams,
     InvokeAIGenerator,
@@ -12,5 +11,3 @@ from .generator import (
 )
 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

@@ -19,10 +19,10 @@ 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
@@ -38,34 +38,40 @@ from transformers import (
 
 import invokeai.configs as configs
 
-from ...frontend.install.model_install import addModelsForm, process_and_execute
-from ...frontend.install.widgets import (
+from invokeai.frontend.install.model_install import addModelsForm, process_and_execute
+from invokeai.frontend.install.widgets import (
     CenteredButtonPress,
     IntTitleSlider,
     set_min_terminal_size,
 )
-from ..args import PRECISION_CHOICES, Args
-from ..globals import Globals, global_cache_dir, global_config_dir, global_config_file
-from .model_install_backend import (
+from invokeai.backend.config.legacy_arg_parsing import legacy_parser
+from invokeai.backend.config.model_install_backend import (
     default_dataset,
     download_from_hf,
     hf_download_with_resume,
     recommended_datasets,
 )
+from invokeai.app.services.config import (
+    get_invokeai_config,
+    InvokeAIAppConfig,
+)
 
 warnings.filterwarnings("ignore")
 
 transformers.logging.set_verbosity_error()
 
+
 # --------------------------globals-----------------------
+config = get_invokeai_config()
+
 Model_dir = "models"
 Weights_dir = "ldm/stable-diffusion-v1/"
 
 # the initial "configs" dir is now bundled in the `invokeai.configs` package
 Dataset_path = Path(configs.__path__[0]) / "INITIAL_MODELS.yaml"
 
-Default_config_file = Path(global_config_dir()) / "models.yaml"
-SD_Configs = Path(global_config_dir()) / "stable-diffusion"
+Default_config_file = config.model_conf_path
+SD_Configs = config.legacy_conf_path
 
 Datasets = OmegaConf.load(Dataset_path)
 
@@ -73,17 +79,12 @@ Datasets = OmegaConf.load(Dataset_path)
 MIN_COLS = 135
 MIN_LINES = 45
 
+PRECISION_CHOICES = ['auto','float16','float32','autocast']
+
 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
 """
 
 
@@ -96,14 +97,13 @@ 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 # (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)
+   invokeai-web
 
-Command-line interface:
+Command-line client:
    invokeai
 
 If you installed using an installation script, run:
-  {Globals.root}/invoke.{"bat" if sys.platform == "win32" else "sh"}
+  {config.root}/invoke.{"bat" if sys.platform == "win32" else "sh"}
 
 Add the '--help' argument to see all of the command-line switches available for use.
 """
@@ -216,11 +216,11 @@ def download_realesrgan():
     wdn_model_url = "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-wdn-x4v3.pth"
 
     model_dest = os.path.join(
-        Globals.root, "models/realesrgan/realesr-general-x4v3.pth"
+        config.root, "models/realesrgan/realesr-general-x4v3.pth"
     )
 
     wdn_model_dest = os.path.join(
-        Globals.root, "models/realesrgan/realesr-general-wdn-x4v3.pth"
+        config.root, "models/realesrgan/realesr-general-wdn-x4v3.pth"
     )
 
     download_with_progress_bar(model_url, model_dest, "RealESRGAN")
@@ -243,7 +243,7 @@ def download_gfpgan():
             "./models/gfpgan/weights/parsing_parsenet.pth",
         ],
     ):
-        model_url, model_dest = model[0], os.path.join(Globals.root, model[1])
+        model_url, model_dest = model[0], os.path.join(config.root, model[1])
         download_with_progress_bar(model_url, model_dest, "GFPGAN weights")
 
 
@@ -253,7 +253,7 @@ def download_codeformer():
     model_url = (
         "https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/codeformer.pth"
     )
-    model_dest = os.path.join(Globals.root, "models/codeformer/codeformer.pth")
+    model_dest = os.path.join(config.root, "models/codeformer/codeformer.pth")
     download_with_progress_bar(model_url, model_dest, "CodeFormer")
 
 
@@ -295,7 +295,7 @@ def download_vaes():
         # first the diffusers version
         repo_id = "stabilityai/sd-vae-ft-mse"
         args = dict(
-            cache_dir=global_cache_dir("hub"),
+            cache_dir=config.cache_dir,
         )
         if not AutoencoderKL.from_pretrained(repo_id, **args):
             raise Exception(f"download of {repo_id} failed")
@@ -306,7 +306,7 @@ def download_vaes():
         if not hf_download_with_resume(
             repo_id=repo_id,
             model_name=model_name,
-            model_dir=str(Globals.root / Model_dir / Weights_dir),
+            model_dir=str(config.root / Model_dir / Weights_dir),
         ):
             raise Exception(f"download of {model_name} failed")
     except Exception as e:
@@ -321,8 +321,7 @@ def get_root(root: str = None) -> str:
     elif os.environ.get("INVOKEAI_ROOT"):
         return os.environ.get("INVOKEAI_ROOT")
     else:
-        return Globals.root
-
+        return config.root
 
 # -------------------------------------
 class editOptsForm(npyscreen.FormMultiPage):
@@ -332,7 +331,7 @@ class editOptsForm(npyscreen.FormMultiPage):
     def create(self):
         program_opts = self.parentApp.program_opts
         old_opts = self.parentApp.invokeai_opts
-        first_time = not (Globals.root / Globals.initfile).exists()
+        first_time = not (config.root / 'invokeai.yaml').exists()
         access_token = HfFolder.get_token()
         window_width, window_height = get_terminal_size()
         for i in [
@@ -366,7 +365,7 @@ class editOptsForm(npyscreen.FormMultiPage):
         self.outdir = self.add_widget_intelligent(
             npyscreen.TitleFilename,
             name="(<tab> autocompletes, ctrl-N advances):",
-            value=old_opts.outdir or str(default_output_dir()),
+            value=str(old_opts.outdir) or str(default_output_dir()),
             select_dir=True,
             must_exist=False,
             use_two_lines=False,
@@ -381,17 +380,17 @@ class editOptsForm(npyscreen.FormMultiPage):
             editable=False,
             color="CONTROL",
         )
-        self.safety_checker = self.add_widget_intelligent(
+        self.nsfw_checker = self.add_widget_intelligent(
             npyscreen.Checkbox,
             name="NSFW checker",
-            value=old_opts.safety_checker,
+            value=old_opts.nsfw_checker,
             relx=5,
             scroll_exit=True,
         )
         self.nextrely += 1
         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".',
+            "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",
         ]:
             self.add_widget_intelligent(
@@ -435,17 +434,10 @@ class editOptsForm(npyscreen.FormMultiPage):
             relx=5,
             scroll_exit=True,
         )
-        self.xformers = self.add_widget_intelligent(
+        self.xformers_enabled = self.add_widget_intelligent(
             npyscreen.Checkbox,
             name="Enable xformers support if available",
-            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,
+            value=old_opts.xformers_enabled,
             relx=5,
             scroll_exit=True,
         )
@@ -480,19 +472,30 @@ class editOptsForm(npyscreen.FormMultiPage):
         self.nextrely += 1
         self.add_widget_intelligent(
             npyscreen.FixedText,
-            value="Directory containing embedding/textual inversion files:",
+            value="Directories containing textual inversion and LoRA models (<tab> autocompletes, ctrl-N advances):",
             editable=False,
             color="CONTROL",
         )
-        self.embedding_path = self.add_widget_intelligent(
+        self.embedding_dir = self.add_widget_intelligent(
             npyscreen.TitleFilename,
-            name="(<tab> autocompletes, ctrl-N advances):",
+            name=" Textual Inversion Embeddings:",
             value=str(default_embedding_dir()),
             select_dir=True,
             must_exist=False,
             use_two_lines=False,
             labelColor="GOOD",
-            begin_entry_at=40,
+            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.nextrely += 1
@@ -559,9 +562,9 @@ class editOptsForm(npyscreen.FormMultiPage):
             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_path).parent.exists():
+        if not Path(opt.embedding_dir).parent.exists():
             bad_fields.append(
-                f"The embedding directory does not seem to be valid. Please check that {str(Path(opt.embedding_path).parent)} is an existing directory."
+                f"The embedding directory does not seem to be valid. Please check that {str(Path(opt.embedding_dir).parent)} is an existing directory."
             )
         if len(bad_fields) > 0:
             message = "The following problems were detected and must be corrected:\n"
@@ -576,20 +579,23 @@ class editOptsForm(npyscreen.FormMultiPage):
         new_opts = Namespace()
 
         for attr in [
-            "outdir",
-            "safety_checker",
-            "free_gpu_mem",
-            "max_loaded_models",
-            "xformers",
-            "always_use_cpu",
-            "embedding_path",
-            "ckpt_convert",
+                "outdir",
+                "nsfw_checker",
+                "free_gpu_mem",
+                "max_loaded_models",
+                "xformers_enabled",
+                "always_use_cpu",
+                "embedding_dir",
+                "lora_dir",
         ]:
             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
 
@@ -628,15 +634,14 @@ def edit_opts(program_opts: Namespace, invokeai_opts: Namespace) -> argparse.Nam
 
 
 def default_startup_options(init_file: Path) -> Namespace:
-    opts = Args().parse_args([])
+    opts = InvokeAIAppConfig(argv=[])
     outdir = Path(opts.outdir)
     if not outdir.is_absolute():
-        opts.outdir = str(Globals.root / opts.outdir)
+        opts.outdir = str(config.root / opts.outdir)
     if not init_file.exists():
-        opts.safety_checker = True
+        opts.nsfw_checker = True
     return opts
 
-
 def default_user_selections(program_opts: Namespace) -> Namespace:
     return Namespace(
         starter_models=default_dataset()
@@ -690,70 +695,61 @@ def run_console_ui(
 # -------------------------------------
 def write_opts(opts: Namespace, init_file: Path):
     """
-    Update the invokeai.init file with values from opts Namespace
+    Update the invokeai.yaml file with values from current settings.
     """
-    # 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)
+    # this will load current settings
+    config = InvokeAIAppConfig()
+    for key,value in opts.__dict__.items():
+        if hasattr(config,key):
+            setattr(config,key,value)
 
+    with open(init_file,'w', encoding='utf-8') as file:
+        file.write(config.to_yaml())
 
 # -------------------------------------
 def default_output_dir() -> Path:
-    return Globals.root / "outputs"
-
+    return config.root / "outputs"
 
 # -------------------------------------
 def default_embedding_dir() -> Path:
-    return Globals.root / "embeddings"
+    return config.root / "embeddings"
 
+# -------------------------------------
+def default_lora_dir() -> Path:
+    return config.root / "loras"
 
 # -------------------------------------
 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(conf={})
+
+    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():
@@ -810,7 +806,8 @@ def main():
     opt = parser.parse_args()
 
     # setting a global here
-    Globals.root = Path(os.path.expanduser(get_root(opt.root) or ""))
+    global config
+    config.root = Path(os.path.expanduser(get_root(opt.root) or ""))
 
     errors = set()
 
@@ -818,19 +815,26 @@ def main():
         models_to_download = default_user_selections(opt)
 
         # We check for to see if the runtime directory is correctly initialized.
-        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)
+        old_init_file = Path(config.root, 'invokeai.init')
+        new_init_file = Path(config.root, '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)
+            config = get_invokeai_config()  # reread defaults
+
+
+        if not config.model_conf_path.exists():
+            initialize_rootdir(config.root, opt.yes_to_all)
 
         if opt.yes_to_all:
-            write_default_options(opt, init_file)
+            write_default_options(opt, new_init_file)
             init_options = Namespace(
                 precision="float32" if opt.full_precision else "float16"
             )
         else:
-            init_options, models_to_download = run_console_ui(opt, init_file)
+            init_options, models_to_download = run_console_ui(opt, new_init_file)
             if init_options:
-                write_opts(init_options, init_file)
+                write_opts(init_options, new_init_file)
             else:
                 print(
                     '\n** CANCELLED AT USER\'S REQUEST. USE THE "invoke.sh" LAUNCHER TO RUN LATER **\n'

invokeai/backend/config/legacy_arg_parsing.py

@@ -0,0 +1,390 @@
+# Copyright 2023 Lincoln D. Stein and the InvokeAI Team
+
+import argparse
+import shlex
+from argparse import ArgumentParser
+
+SAMPLER_CHOICES = [
+    "ddim",
+    "ddpm",
+    "deis",
+    "lms",
+    "pndm",
+    "heun",
+    "heun_k",
+    "euler",
+    "euler_k",
+    "euler_a",
+    "kdpm_2",
+    "kdpm_2_a",
+    "dpmpp_2s",
+    "dpmpp_2m",
+    "dpmpp_2m_k",
+    "unipc",
+]
+
+PRECISION_CHOICES = [
+    "auto",
+    "float32",
+    "autocast",
+    "float16",
+]
+
+class FileArgumentParser(ArgumentParser):
+    """
+    Supports reading defaults from an init file.
+    """
+    def convert_arg_line_to_args(self, arg_line):
+        return shlex.split(arg_line, comments=True)
+
+
+legacy_parser = FileArgumentParser(
+    description=
+    """
+Generate images using Stable Diffusion.
+    Use --web to launch the web interface.
+    Use --from_file to load prompts from a file path or standard input ("-").
+    Otherwise you will be dropped into an interactive command prompt (type -h for help.)
+    Other command-line arguments are defaults that can usually be overridden
+    prompt the command prompt.
+    """,
+    fromfile_prefix_chars='@',
+)
+general_group    = legacy_parser.add_argument_group('General')
+model_group      = legacy_parser.add_argument_group('Model selection')
+file_group       = legacy_parser.add_argument_group('Input/output')
+web_server_group = legacy_parser.add_argument_group('Web server')
+render_group     = legacy_parser.add_argument_group('Rendering')
+postprocessing_group     = legacy_parser.add_argument_group('Postprocessing')
+deprecated_group = legacy_parser.add_argument_group('Deprecated options')
+
+deprecated_group.add_argument('--laion400m')
+deprecated_group.add_argument('--weights') # deprecated
+general_group.add_argument(
+    '--version','-V',
+    action='store_true',
+    help='Print InvokeAI version number'
+)
+model_group.add_argument(
+    '--root_dir',
+    default=None,
+    help='Path to directory containing "models", "outputs" and "configs". If not present will read from environment variable INVOKEAI_ROOT. Defaults to ~/invokeai.',
+)
+model_group.add_argument(
+    '--config',
+    '-c',
+    '-config',
+    dest='conf',
+    default='./configs/models.yaml',
+    help='Path to configuration file for alternate models.',
+)
+model_group.add_argument(
+    '--model',
+    help='Indicates which diffusion model to load (defaults to "default" stanza in configs/models.yaml)',
+)
+model_group.add_argument(
+    '--weight_dirs',
+    nargs='+',
+    type=str,
+    help='List of one or more directories that will be auto-scanned for new model weights to import',
+)
+model_group.add_argument(
+    '--png_compression','-z',
+    type=int,
+    default=6,
+    choices=range(0,9),
+    dest='png_compression',
+    help='level of PNG compression, from 0 (none) to 9 (maximum). Default is 6.'
+)
+model_group.add_argument(
+    '-F',
+    '--full_precision',
+    dest='full_precision',
+    action='store_true',
+    help='Deprecated way to set --precision=float32',
+)
+model_group.add_argument(
+    '--max_loaded_models',
+    dest='max_loaded_models',
+    type=int,
+    default=2,
+    help='Maximum number of models to keep in memory for fast switching, including the one in GPU',
+)
+model_group.add_argument(
+    '--free_gpu_mem',
+    dest='free_gpu_mem',
+    action='store_true',
+    help='Force free gpu memory before final decoding',
+)
+model_group.add_argument(
+    '--sequential_guidance',
+    dest='sequential_guidance',
+    action='store_true',
+    help="Calculate guidance in serial instead of in parallel, lowering memory requirement "
+         "at the expense of speed",
+)
+model_group.add_argument(
+    '--xformers',
+    action=argparse.BooleanOptionalAction,
+    default=True,
+    help='Enable/disable xformers support (default enabled if installed)',
+)
+model_group.add_argument(
+    "--always_use_cpu",
+    dest="always_use_cpu",
+    action="store_true",
+    help="Force use of CPU even if GPU is available"
+)
+model_group.add_argument(
+    '--precision',
+    dest='precision',
+    type=str,
+    choices=PRECISION_CHOICES,
+    metavar='PRECISION',
+    help=f'Set model precision. Defaults to auto selected based on device. Options: {", ".join(PRECISION_CHOICES)}',
+    default='auto',
+)
+model_group.add_argument(
+    '--ckpt_convert',
+    action=argparse.BooleanOptionalAction,
+    dest='ckpt_convert',
+    default=True,
+    help='Deprecated option. Legacy ckpt files are now always converted to diffusers when loaded.'
+)
+model_group.add_argument(
+    '--internet',
+    action=argparse.BooleanOptionalAction,
+    dest='internet_available',
+    default=True,
+    help='Indicate whether internet is available for just-in-time model downloading (default: probe automatically).',
+)
+model_group.add_argument(
+    '--nsfw_checker',
+    '--safety_checker',
+    action=argparse.BooleanOptionalAction,
+    dest='safety_checker',
+    default=False,
+    help='Check for and blur potentially NSFW images. Use --no-nsfw_checker to disable.',
+)
+model_group.add_argument(
+    '--autoimport',
+    default=None,
+    type=str,
+    help='Check the indicated directory for .ckpt/.safetensors weights files at startup and import directly',
+)
+model_group.add_argument(
+    '--autoconvert',
+    default=None,
+    type=str,
+    help='Check the indicated directory for .ckpt/.safetensors weights files at startup and import as optimized diffuser models',
+)
+model_group.add_argument(
+    '--patchmatch',
+    action=argparse.BooleanOptionalAction,
+    default=True,
+    help='Load the patchmatch extension for outpainting. Use --no-patchmatch to disable.',
+)
+file_group.add_argument(
+    '--from_file',
+    dest='infile',
+    type=str,
+    help='If specified, load prompts from this file',
+)
+file_group.add_argument(
+    '--outdir',
+    '-o',
+    type=str,
+    help='Directory to save generated images and a log of prompts and seeds. Default: ROOTDIR/outputs',
+    default='outputs',
+)
+file_group.add_argument(
+    '--prompt_as_dir',
+    '-p',
+    action='store_true',
+    help='Place images in subdirectories named after the prompt.',
+)
+render_group.add_argument(
+    '--fnformat',
+    default='{prefix}.{seed}.png',
+    type=str,
+    help='Overwrite the filename format. You can use any argument as wildcard enclosed in curly braces. Default is {prefix}.{seed}.png',
+)
+render_group.add_argument(
+    '-s',
+    '--steps',
+    type=int,
+    default=50,
+    help='Number of steps'
+)
+render_group.add_argument(
+    '-W',
+    '--width',
+    type=int,
+    help='Image width, multiple of 64',
+)
+render_group.add_argument(
+    '-H',
+    '--height',
+    type=int,
+    help='Image height, multiple of 64',
+)
+render_group.add_argument(
+    '-C',
+    '--cfg_scale',
+    default=7.5,
+    type=float,
+    help='Classifier free guidance (CFG) scale - higher numbers cause generator to "try" harder.',
+)
+render_group.add_argument(
+    '--sampler',
+    '-A',
+    '-m',
+    dest='sampler_name',
+    type=str,
+    choices=SAMPLER_CHOICES,
+    metavar='SAMPLER_NAME',
+    help=f'Set the default sampler. Supported samplers: {", ".join(SAMPLER_CHOICES)}',
+    default='k_lms',
+)
+render_group.add_argument(
+    '--log_tokenization',
+    '-t',
+    action='store_true',
+    help='shows how the prompt is split into tokens'
+)
+render_group.add_argument(
+    '-f',
+    '--strength',
+    type=float,
+    help='img2img strength for noising/unnoising. 0.0 preserves image exactly, 1.0 replaces it completely',
+)
+render_group.add_argument(
+    '-T',
+    '-fit',
+    '--fit',
+    action=argparse.BooleanOptionalAction,
+    help='If specified, will resize the input image to fit within the dimensions of width x height (512x512 default)',
+)
+
+render_group.add_argument(
+    '--grid',
+    '-g',
+    action=argparse.BooleanOptionalAction,
+    help='generate a grid'
+)
+render_group.add_argument(
+    '--embedding_directory',
+    '--embedding_path',
+    dest='embedding_path',
+    default='embeddings',
+    type=str,
+    help='Path to a directory containing .bin and/or .pt files, or a single .bin/.pt file. You may use subdirectories. (default is ROOTDIR/embeddings)'
+)
+render_group.add_argument(
+    '--lora_directory',
+    dest='lora_path',
+    default='loras',
+    type=str,
+    help='Path to a directory containing LoRA files; subdirectories are not supported. (default is ROOTDIR/loras)'
+)
+render_group.add_argument(
+    '--embeddings',
+    action=argparse.BooleanOptionalAction,
+    default=True,
+    help='Enable embedding directory (default). Use --no-embeddings to disable.',
+)
+render_group.add_argument(
+    '--enable_image_debugging',
+    action='store_true',
+    help='Generates debugging image to display'
+)
+render_group.add_argument(
+    '--karras_max',
+    type=int,
+    default=None,
+    help="control the point at which the K* samplers will shift from using the Karras noise schedule (good for low step counts) to the LatentDiffusion noise schedule (good for high step counts). Set to 0 to use LatentDiffusion for all step values, and to a high value (e.g. 1000) to use Karras for all step values. [29]."
+)
+# Restoration related args
+postprocessing_group.add_argument(
+    '--no_restore',
+    dest='restore',
+    action='store_false',
+    help='Disable face restoration with GFPGAN or codeformer',
+)
+postprocessing_group.add_argument(
+    '--no_upscale',
+    dest='esrgan',
+    action='store_false',
+    help='Disable upscaling with ESRGAN',
+)
+postprocessing_group.add_argument(
+    '--esrgan_bg_tile',
+    type=int,
+    default=400,
+    help='Tile size for background sampler, 0 for no tile during testing. Default: 400.',
+)
+postprocessing_group.add_argument(
+    '--esrgan_denoise_str',
+    type=float,
+    default=0.75,
+    help='esrgan denoise str. 0 is no denoise, 1 is max denoise.  Default: 0.75',
+)
+postprocessing_group.add_argument(
+    '--gfpgan_model_path',
+    type=str,
+    default='./models/gfpgan/GFPGANv1.4.pth',
+    help='Indicates the path to the GFPGAN model',
+)
+web_server_group.add_argument(
+    '--web',
+    dest='web',
+    action='store_true',
+    help='Start in web server mode.',
+)
+web_server_group.add_argument(
+    '--web_develop',
+    dest='web_develop',
+    action='store_true',
+    help='Start in web server development mode.',
+)
+web_server_group.add_argument(
+    "--web_verbose",
+    action="store_true",
+    help="Enables verbose logging",
+)
+web_server_group.add_argument(
+    "--cors",
+    nargs="*",
+    type=str,
+    help="Additional allowed origins, comma-separated",
+)
+web_server_group.add_argument(
+    '--host',
+    type=str,
+    default='127.0.0.1',
+    help='Web server: Host or IP to listen on. Set to 0.0.0.0 to accept traffic from other devices on your network.'
+)
+web_server_group.add_argument(
+    '--port',
+    type=int,
+    default='9090',
+    help='Web server: Port to listen on'
+)
+web_server_group.add_argument(
+    '--certfile',
+    type=str,
+    default=None,
+    help='Web server: Path to certificate file to use for SSL. Use together with --keyfile'
+)
+web_server_group.add_argument(
+    '--keyfile',
+    type=str,
+    default=None,
+    help='Web server: Path to private key file to use for SSL. Use together with --certfile'
+)
+web_server_group.add_argument(
+    '--gui',
+    dest='gui',
+    action='store_true',
+    help='Start InvokeAI GUI',
+)

invokeai/backend/config/model_install_backend.py

@@ -19,13 +19,15 @@ from tqdm import tqdm
 
 import invokeai.configs as configs
 
-from ..globals import Globals, global_cache_dir, global_config_dir
+from invokeai.app.services.config import get_invokeai_config
 from ..model_management import ModelManager
 from ..stable_diffusion import StableDiffusionGeneratorPipeline
 
+
 warnings.filterwarnings("ignore")
 
 # --------------------------globals-----------------------
+config = get_invokeai_config()
 Model_dir = "models"
 Weights_dir = "ldm/stable-diffusion-v1/"
 
@@ -47,12 +49,11 @@ Config_preamble = """
 
 
 def default_config_file():
-    return Path(global_config_dir()) / "models.yaml"
+    return config.model_conf_path
 
 
 def sd_configs():
-    return Path(global_config_dir()) / "stable-diffusion"
-
+    return config.legacy_conf_path
 
 def initial_models():
     global Datasets
@@ -121,8 +122,9 @@ def install_requested_models(
 
     if scan_at_startup and scan_directory.is_dir():
         argument = "--autoconvert"
-        initfile = Path(Globals.root, Globals.initfile)
-        replacement = Path(Globals.root, f"{Globals.initfile}.new")
+        print('** The global initfile is no longer supported; rewrite to support new yaml format **')
+        initfile = Path(config.root, 'invokeai.init')
+        replacement = Path(config.root, f"invokeai.init.new")
         directory = str(scan_directory).replace("\\", "/")
         with open(initfile, "r") as input:
             with open(replacement, "w") as output:
@@ -150,7 +152,7 @@ def get_root(root: str = None) -> str:
     elif os.environ.get("INVOKEAI_ROOT"):
         return os.environ.get("INVOKEAI_ROOT")
     else:
-        return Globals.root
+        return config.root
 
 
 # ---------------------------------------------
@@ -183,7 +185,7 @@ 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(Globals.root, Model_dir, Weights_dir)
+    model_path = os.path.join(config.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"]
@@ -228,7 +230,7 @@ def _download_repo_or_file(
 def _download_ckpt_weights(mconfig: DictConfig, access_token: str) -> Path:
     repo_id = mconfig["repo_id"]
     filename = mconfig["file"]
-    cache_dir = os.path.join(Globals.root, Model_dir, Weights_dir)
+    cache_dir = os.path.join(config.root, Model_dir, Weights_dir)
     return hf_download_with_resume(
         repo_id=repo_id,
         model_dir=cache_dir,
@@ -239,9 +241,9 @@ def _download_ckpt_weights(mconfig: DictConfig, access_token: str) -> Path:
 
 # ---------------------------------------------
 def download_from_hf(
-    model_class: object, model_name: str, cache_subdir: Path = Path("hub"), **kwargs
+    model_class: object, model_name: str, **kwargs
 ):
-    path = global_cache_dir(cache_subdir)
+    path = config.cache_dir
     model = model_class.from_pretrained(
         model_name,
         cache_dir=path,
@@ -417,7 +419,7 @@ def new_config_file_contents(
             stanza["height"] = mod["height"]
         if "file" in mod:
             stanza["weights"] = os.path.relpath(
-                successfully_downloaded[model], start=Globals.root
+                successfully_downloaded[model], start=config.root
             )
             stanza["config"] = os.path.normpath(
                 os.path.join(sd_configs(), mod["config"])
@@ -456,7 +458,7 @@ def delete_weights(model_name: str, conf_stanza: dict):
 
     weights = Path(weights)
     if not weights.is_absolute():
-        weights = Path(Globals.root) / weights
+        weights = Path(config.root) / weights
         try:
             weights.unlink()
         except OSError as e:

invokeai/backend/generator/base.py

@@ -25,11 +25,13 @@ 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
 
@@ -70,27 +72,12 @@ 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(),
-                 **kwargs,
                  ):
         self.model_info=model_info
         self.params=params
-        self.kwargs = kwargs
 
     def generate(self,
                  prompt: str='',
@@ -131,12 +118,9 @@ class InvokeAIGenerator(metaclass=ABCMeta):
             model=model,
             scheduler_name=generator_args.get('scheduler')
         )
-
-        # get conditioning from prompt via Compel package
-        uc, c, extra_conditioning_info = get_uc_and_c_and_ec(prompt, model=model)
-
+        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)
+        generator = gen_class(model, self.params.precision)
         if self.params.variation_amount > 0:
             generator.set_variation(generator_args.get('seed'),
                                     generator_args.get('variation_amount'),
@@ -179,14 +163,20 @@ class InvokeAIGenerator(metaclass=ABCMeta):
         '''
         Return list of all the schedulers that we currently handle.
         '''
-        return list(self.scheduler_map.keys())
+        return list(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)
+        scheduler_class, scheduler_extra_config = SCHEDULER_MAP.get(scheduler_name, SCHEDULER_MAP['ddim'])
+        
+        scheduler_config = model.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)
+        
         # hack copied over from generate.py
         if not hasattr(scheduler, 'uses_inpainting_model'):
             scheduler.uses_inpainting_model = lambda: False
@@ -230,10 +220,10 @@ class Inpaint(Img2Img):
     def generate(self,
                  mask_image: Image.Image | torch.FloatTensor,
                  # Seam settings - when 0, doesn't fill seam
-                 seam_size: int = 0,
-                 seam_blur: int = 0,
+                 seam_size: int = 96,
+                 seam_blur: int = 16,
                  seam_strength: float = 0.7,
-                 seam_steps: int = 10,
+                 seam_steps: int = 30,
                  tile_size: int = 32,
                  inpaint_replace=False,
                  infill_method=None,
@@ -286,7 +276,7 @@ class Generator:
     precision: str
     model: DiffusionPipeline
 
-    def __init__(self, model: DiffusionPipeline, precision: str, **kwargs):
+    def __init__(self, model: DiffusionPipeline, precision: str):
         self.model = model
         self.precision = precision
         self.seed = None
@@ -359,6 +349,7 @@ 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):
@@ -376,7 +367,7 @@ class Generator:
                     try:
                         x_T = self.get_noise(width, height)
                     except:
-                        print("** An error occurred while getting initial noise **")
+                        logger.error("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.
@@ -611,7 +602,7 @@ class Generator:
         image = self.sample_to_image(sample)
         dirname = os.path.dirname(filepath) or "."
         if not os.path.exists(dirname):
-            print(f"** creating directory {dirname}")
+            logger.info(f"creating directory {dirname}")
             os.makedirs(dirname, exist_ok=True)
         image.save(filepath, "PNG")
 

invokeai/backend/generator/embiggen.py

@@ -8,10 +8,11 @@ import torch
 from PIL import Image
 from tqdm import trange
 
+import invokeai.backend.util.logging as logger
+
 from .base import Generator
 from .img2img import Img2Img
 
-
 class Embiggen(Generator):
     def __init__(self, model, precision):
         super().__init__(model, precision)
@@ -72,22 +73,22 @@ class Embiggen(Generator):
             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 !"
+            logger.warning(
+                "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 !"
+            logger.warning(
+                "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 !"
+            logger.warning(
+                "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
@@ -97,8 +98,8 @@ class Embiggen(Generator):
             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."
+            logger.warning(
+                f"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
@@ -121,8 +122,8 @@ class Embiggen(Generator):
                 from ..restoration.realesrgan import ESRGAN
 
                 esrgan = ESRGAN()
-                print(
-                    f">> ESRGAN upscaling init image prior to cutting with Embiggen with strength {embiggen[1]}"
+                logger.info(
+                    f"ESRGAN upscaling init image prior to cutting with Embiggen with strength {embiggen[1]}"
                 )
                 if embiggen[0] > 2:
                     initsuperimage = esrgan.process(
@@ -312,10 +313,10 @@ class Embiggen(Generator):
         def make_image():
             # Make main tiles -------------------------------------------------
             if embiggen_tiles:
-                print(f">> Making {len(embiggen_tiles)} Embiggen tiles...")
+                logger.info(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})..."
+                logger.info(
+                    f"Making {(emb_tiles_x * emb_tiles_y)} Embiggen tiles ({emb_tiles_x}x{emb_tiles_y})..."
                 )
 
             emb_tile_store = []
@@ -361,11 +362,11 @@ class Embiggen(Generator):
                 # newinitimage.save(newinitimagepath)
 
                 if embiggen_tiles:
-                    print(
+                    logger.debug(
                         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")
+                    logger.debug(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
@@ -547,8 +548,8 @@ class Embiggen(Generator):
                     # 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."
+                logger.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

invokeai/backend/generator/inpaint.py

@@ -4,6 +4,7 @@ invokeai.backend.generator.inpaint descends from .generator
 from __future__ import annotations
 
 import math
+from typing import Tuple, Union
 
 import cv2
 import numpy as np
@@ -59,7 +60,7 @@ class Inpaint(Img2Img):
             writeable=False,
         )
 
-    def infill_patchmatch(self, im: Image.Image) -> Image:
+    def infill_patchmatch(self, im: Image.Image) -> Image.Image:
         if im.mode != "RGBA":
             return im
 
@@ -75,18 +76,18 @@ class Inpaint(Img2Img):
         return im_patched
 
     def tile_fill_missing(
-        self, im: Image.Image, tile_size: int = 16, seed: int = None
-    ) -> Image:
+        self, 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 = (tile_size, tile_size)
+        tile_size_tuple = (tile_size, tile_size)
 
         # Get the image as tiles of a specified size
-        tiles = self.get_tile_images(a, *tile_size).copy()
+        tiles = self.get_tile_images(a, *tile_size_tuple).copy()
 
         # Get the mask as tiles
         tiles_mask = tiles[:, :, :, :, 3]
@@ -127,7 +128,9 @@ class Inpaint(Img2Img):
 
         return si
 
-    def mask_edge(self, mask: Image, edge_size: int, edge_blur: int) -> Image:
+    def mask_edge(
+        self, mask: Image.Image, edge_size: int, edge_blur: int
+    ) -> Image.Image:
         npimg = np.asarray(mask, dtype=np.uint8)
 
         # Detect any partially transparent regions
@@ -206,15 +209,15 @@ class Inpaint(Img2Img):
         cfg_scale,
         ddim_eta,
         conditioning,
-        init_image: PIL.Image.Image | torch.FloatTensor,
-        mask_image: PIL.Image.Image | torch.FloatTensor,
+        init_image: Image.Image | torch.FloatTensor,
+        mask_image: Image.Image | torch.FloatTensor,
         strength: float,
         mask_blur_radius: int = 8,
         # Seam settings - when 0, doesn't fill seam
-        seam_size: int = 0,
-        seam_blur: int = 0,
+        seam_size: int = 96,
+        seam_blur: int = 16,
         seam_strength: float = 0.7,
-        seam_steps: int = 10,
+        seam_steps: int = 30,
         tile_size: int = 32,
         step_callback=None,
         inpaint_replace=False,
@@ -222,7 +225,7 @@ class Inpaint(Img2Img):
         infill_method=None,
         inpaint_width=None,
         inpaint_height=None,
-        inpaint_fill: tuple(int) = (0x7F, 0x7F, 0x7F, 0xFF),
+        inpaint_fill: Tuple[int, int, int, int] = (0x7F, 0x7F, 0x7F, 0xFF),
         attention_maps_callback=None,
         **kwargs,
     ):
@@ -239,7 +242,7 @@ class Inpaint(Img2Img):
         self.inpaint_width = inpaint_width
         self.inpaint_height = inpaint_height
 
-        if isinstance(init_image, PIL.Image.Image):
+        if isinstance(init_image, Image.Image):
             self.pil_image = init_image.copy()
 
             # Do infill
@@ -250,8 +253,8 @@ class Inpaint(Img2Img):
                     self.pil_image.copy(), seed=self.seed, tile_size=tile_size
                 )
             elif infill_method == "solid":
-                solid_bg = PIL.Image.new("RGBA", init_image.size, inpaint_fill)
-                init_filled = PIL.Image.alpha_composite(solid_bg, init_image)
+                solid_bg = Image.new("RGBA", init_image.size, inpaint_fill)
+                init_filled = Image.alpha_composite(solid_bg, init_image)
             else:
                 raise ValueError(
                     f"Non-supported infill type {infill_method}", infill_method
@@ -269,7 +272,7 @@ class Inpaint(Img2Img):
             # Create init tensor
             init_image = image_resized_to_grid_as_tensor(init_filled.convert("RGB"))
 
-        if isinstance(mask_image, PIL.Image.Image):
+        if isinstance(mask_image, Image.Image):
             self.pil_mask = mask_image.copy()
             debug_image(
                 mask_image,

invokeai/backend/generator/txt2img.py

@@ -4,10 +4,6 @@ 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,
@@ -17,13 +13,8 @@ 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)
+    def __init__(self, model, precision):
+        super().__init__(model, precision)
 
     @torch.no_grad()
     def get_make_image(
@@ -51,12 +42,9 @@ class Txt2Img(Generator):
         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
@@ -73,37 +61,6 @@ class Txt2Img(Generator):
             ),
         ).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()),
@@ -111,7 +68,6 @@ class Txt2Img(Generator):
                 num_inference_steps=steps,
                 conditioning_data=conditioning_data,
                 callback=step_callback,
-                **kwargs,
             )
 
             if (

invokeai/backend/generator/txt2img2img.py

@@ -14,6 +14,8 @@ from ..stable_diffusion.diffusers_pipeline import StableDiffusionGeneratorPipeli
 from ..stable_diffusion.diffusers_pipeline import ConditioningData
 from ..stable_diffusion.diffusers_pipeline import trim_to_multiple_of
 
+import invokeai.backend.util.logging as logger
+
 class Txt2Img2Img(Generator):
     def __init__(self, model, precision):
         super().__init__(model, precision)
@@ -77,8 +79,8 @@ class Txt2Img2Img(Generator):
             # 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"
+            logger.info(
+                f"Interpolating from {init_width}x{init_height} to {width}x{height} using DDIM sampling"
             )
 
             # resizing

invokeai/backend/globals.py

@@ -1,122 +0,0 @@
-"""
-invokeai.backend.globals defines a small number of global variables that would
-otherwise have to be passed through long and complex call chains.
-
-It defines a Namespace object named "Globals" that contains
-the attributes:
-
-  - root           - the root directory under which "models" and "outputs" can be found
-  - initfile       - path to the initialization file
-  - try_patchmatch - option to globally disable loading of 'patchmatch' module
-  - always_use_cpu - force use of CPU even if GPU is available
-"""
-
-import os
-import os.path as osp
-from argparse import Namespace
-from pathlib import Path
-from typing import Union
-
-Globals = Namespace()
-
-# Where to look for the initialization file and other key components
-Globals.initfile = "invokeai.init"
-Globals.models_file = "models.yaml"
-Globals.models_dir = "models"
-Globals.config_dir = "configs"
-Globals.autoscan_dir = "weights"
-Globals.converted_ckpts_dir = "converted_ckpts"
-
-# Set the default root directory. This can be overwritten by explicitly
-# passing the `--root <directory>` argument on the command line.
-# logic is:
-# 1) use INVOKEAI_ROOT environment variable (no check for this being a valid directory)
-# 2) use VIRTUAL_ENV environment variable, with a check for initfile being there
-# 3) use ~/invokeai
-
-if os.environ.get("INVOKEAI_ROOT"):
-    Globals.root = osp.abspath(os.environ.get("INVOKEAI_ROOT"))
-elif (
-    os.environ.get("VIRTUAL_ENV")
-    and Path(os.environ.get("VIRTUAL_ENV"), "..", Globals.initfile).exists()
-):
-    Globals.root = osp.abspath(osp.join(os.environ.get("VIRTUAL_ENV"), ".."))
-else:
-    Globals.root = osp.abspath(osp.expanduser("~/invokeai"))
-
-# Try loading patchmatch
-Globals.try_patchmatch = True
-
-# Use CPU even if GPU is available (main use case is for debugging MPS issues)
-Globals.always_use_cpu = False
-
-# Whether the internet is reachable for dynamic downloads
-# The CLI will test connectivity at startup time.
-Globals.internet_available = True
-
-# Whether to disable xformers
-Globals.disable_xformers = False
-
-# Low-memory tradeoff for guidance calculations.
-Globals.sequential_guidance = False
-
-# whether we are forcing full precision
-Globals.full_precision = False
-
-# whether we should convert ckpt files into diffusers models on the fly
-Globals.ckpt_convert = True
-
-# logging tokenization everywhere
-Globals.log_tokenization = False
-
-
-def global_config_file() -> Path:
-    return Path(Globals.root, Globals.config_dir, Globals.models_file)
-
-
-def global_config_dir() -> Path:
-    return Path(Globals.root, Globals.config_dir)
-
-
-def global_models_dir() -> Path:
-    return Path(Globals.root, Globals.models_dir)
-
-
-def global_autoscan_dir() -> Path:
-    return Path(Globals.root, Globals.autoscan_dir)
-
-
-def global_converted_ckpts_dir() -> Path:
-    return Path(global_models_dir(), Globals.converted_ckpts_dir)
-
-
-def global_set_root(root_dir: Union[str, Path]):
-    Globals.root = root_dir
-
-
-def global_cache_dir(subdir: Union[str, Path] = "") -> Path:
-    """
-    Returns Path to the model cache directory. If a subdirectory
-    is provided, it will be appended to the end of the path, allowing
-    for Hugging Face-style conventions. Currently, Hugging Face has
-    moved all models into the "hub" subfolder, so for any pretrained
-    HF model, use:
-         global_cache_dir('hub')
-
-    The legacy location for transformers used to be global_cache_dir('transformers')
-    and global_cache_dir('diffusers') for diffusers.
-    """
-    home: str = os.getenv("HF_HOME")
-
-    if home is None:
-        home = os.getenv("XDG_CACHE_HOME")
-
-        if home is not None:
-            # Set `home` to $XDG_CACHE_HOME/huggingface, which is the default location mentioned in Hugging Face Hub Client Library.
-            # See: https://huggingface.co/docs/huggingface_hub/main/en/package_reference/environment_variables#xdgcachehome
-            home += os.sep + "huggingface"
-
-    if home is not None:
-        return Path(home, subdir)
-    else:
-        return Path(Globals.root, "models", subdir)

invokeai/backend/image_util/patchmatch.py

@@ -5,9 +5,8 @@ wraps the actual patchmatch object. It respects the global
 be suppressed or deferred
 """
 import numpy as np
-
-from invokeai.backend.globals import Globals
-
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
 
 class PatchMatch:
     """
@@ -22,18 +21,19 @@ class PatchMatch:
 
     @classmethod
     def _load_patch_match(self):
+        config = get_invokeai_config()
         if self.tried_load:
             return
-        if Globals.try_patchmatch:
+        if config.try_patchmatch:
             from patchmatch import patch_match as pm
 
             if pm.patchmatch_available:
-                print(">> Patchmatch initialized")
+                logger.info("Patchmatch initialized")
             else:
-                print(">> Patchmatch not loaded (nonfatal)")
+                logger.info("Patchmatch not loaded (nonfatal)")
             self.patch_match = pm
         else:
-            print(">> Patchmatch loading disabled")
+            logger.info("Patchmatch loading disabled")
         self.tried_load = True
 
     @classmethod

invokeai/backend/image_util/txt2mask.py

@@ -30,15 +30,14 @@ work fine.
 import numpy as np
 import torch
 from PIL import Image, ImageOps
-from torchvision import transforms
 from transformers import AutoProcessor, CLIPSegForImageSegmentation
 
-from invokeai.backend.globals import global_cache_dir
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
 
 CLIPSEG_MODEL = "CIDAS/clipseg-rd64-refined"
 CLIPSEG_SIZE = 352
 
-
 class SegmentedGrayscale(object):
     def __init__(self, image: Image, heatmap: torch.Tensor):
         self.heatmap = heatmap
@@ -83,15 +82,16 @@ class Txt2Mask(object):
     """
 
     def __init__(self, device="cpu", refined=False):
-        print(">> Initializing clipseg model for text to mask inference")
+        logger.info("Initializing clipseg model for text to mask inference")
+        config = get_invokeai_config()
 
         # BUG: we are not doing anything with the device option at this time
         self.device = device
         self.processor = AutoProcessor.from_pretrained(
-            CLIPSEG_MODEL, cache_dir=global_cache_dir("hub")
+            CLIPSEG_MODEL, cache_dir=config.cache_dir
         )
         self.model = CLIPSegForImageSegmentation.from_pretrained(
-            CLIPSEG_MODEL, cache_dir=global_cache_dir("hub")
+            CLIPSEG_MODEL, cache_dir=config.cache_dir
         )
 
     @torch.no_grad()
@@ -101,18 +101,6 @@ class Txt2Mask(object):
         provided image and returns a SegmentedGrayscale object in which the brighter
         pixels indicate where the object is inferred to be.
         """
-        transform = transforms.Compose(
-            [
-                transforms.ToTensor(),
-                transforms.Normalize(
-                    mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
-                ),
-                transforms.Resize(
-                    (CLIPSEG_SIZE, CLIPSEG_SIZE)
-                ),  # must be multiple of 64...
-            ]
-        )
-
         if type(image) is str:
             image = Image.open(image).convert("RGB")
 

invokeai/backend/model_management/convert_ckpt_to_diffusers.py

@@ -25,7 +25,8 @@ from typing import Union
 import torch
 from safetensors.torch import load_file
 
-from invokeai.backend.globals import global_cache_dir, global_config_dir
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
 
 from .model_manager import ModelManager, SDLegacyType
 
@@ -46,6 +47,7 @@ from diffusers import (
     LDMTextToImagePipeline,
     LMSDiscreteScheduler,
     PNDMScheduler,
+    UniPCMultistepScheduler,
     StableDiffusionPipeline,
     UNet2DConditionModel,
 )
@@ -72,7 +74,6 @@ from transformers import (
 
 from ..stable_diffusion import StableDiffusionGeneratorPipeline
 
-
 def shave_segments(path, n_shave_prefix_segments=1):
     """
     Removes segments. Positive values shave the first segments, negative shave the last segments.
@@ -372,9 +373,9 @@ def convert_ldm_unet_checkpoint(checkpoint, config, path=None, extract_ema=False
     unet_key = "model.diffusion_model."
     # at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
     if sum(k.startswith("model_ema") for k in keys) > 100:
-        print(f"   | Checkpoint {path} has both EMA and non-EMA weights.")
+        logger.debug(f"Checkpoint {path} has both EMA and non-EMA weights.")
         if extract_ema:
-            print("   | Extracting EMA weights (usually better for inference)")
+            logger.debug("Extracting EMA weights (usually better for inference)")
             for key in keys:
                 if key.startswith("model.diffusion_model"):
                     flat_ema_key = "model_ema." + "".join(key.split(".")[1:])
@@ -392,8 +393,8 @@ def convert_ldm_unet_checkpoint(checkpoint, config, path=None, extract_ema=False
                             key
                         )
         else:
-            print(
-                "   | Extracting only the non-EMA weights (usually better for fine-tuning)"
+            logger.debug(
+                "Extracting only the non-EMA weights (usually better for fine-tuning)"
             )
 
     for key in keys:
@@ -841,7 +842,7 @@ def convert_ldm_bert_checkpoint(checkpoint, config):
 
 def convert_ldm_clip_checkpoint(checkpoint):
     text_model = CLIPTextModel.from_pretrained(
-        "openai/clip-vit-large-patch14", cache_dir=global_cache_dir("hub")
+        "openai/clip-vit-large-patch14", cache_dir=get_invokeai_config().cache_dir
     )
 
     keys = list(checkpoint.keys())
@@ -896,7 +897,7 @@ textenc_pattern = re.compile("|".join(protected.keys()))
 
 
 def convert_paint_by_example_checkpoint(checkpoint):
-    cache_dir = global_cache_dir("hub")
+    cache_dir = get_invokeai_config().cache_dir
     config = CLIPVisionConfig.from_pretrained(
         "openai/clip-vit-large-patch14", cache_dir=cache_dir
     )
@@ -968,7 +969,7 @@ def convert_paint_by_example_checkpoint(checkpoint):
 
 
 def convert_open_clip_checkpoint(checkpoint):
-    cache_dir = global_cache_dir("hub")
+    cache_dir = get_invokeai_config().cache_dir
     text_model = CLIPTextModel.from_pretrained(
         "stabilityai/stable-diffusion-2", subfolder="text_encoder", cache_dir=cache_dir
     )
@@ -1091,7 +1092,7 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
     :param vae: A diffusers VAE to load into the pipeline.
     :param vae_path: Path to a checkpoint VAE that will be converted into diffusers and loaded into the pipeline.
     """
-
+    config = get_invokeai_config()
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         verbosity = dlogging.get_verbosity()
@@ -1104,7 +1105,7 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
         else:
             checkpoint = load_file(checkpoint_path)
 
-        cache_dir = global_cache_dir("hub")
+        cache_dir = config.cache_dir
         pipeline_class = (
             StableDiffusionGeneratorPipeline
             if return_generator_pipeline
@@ -1115,7 +1116,7 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
         if "global_step" in checkpoint:
             global_step = checkpoint["global_step"]
         else:
-            print("   | global_step key not found in model")
+            logger.debug("global_step key not found in model")
             global_step = None
 
         # sometimes there is a state_dict key and sometimes not
@@ -1128,25 +1129,23 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
 
             if model_type == SDLegacyType.V2_v:
                 original_config_file = (
-                    global_config_dir() / "stable-diffusion" / "v2-inference-v.yaml"
+                    config.legacy_conf_path / "v2-inference-v.yaml"
                 )
                 if global_step == 110000:
                     # v2.1 needs to upcast attention
                     upcast_attention = True
             elif model_type == SDLegacyType.V2_e:
                 original_config_file = (
-                    global_config_dir() / "stable-diffusion" / "v2-inference.yaml"
+                    config.legacy_conf_path / "v2-inference.yaml"
                 )
             elif model_type == SDLegacyType.V1_INPAINT:
                 original_config_file = (
-                    global_config_dir()
-                    / "stable-diffusion"
-                    / "v1-inpainting-inference.yaml"
+                    config.legacy_conf_path / "v1-inpainting-inference.yaml"
                 )
 
             elif model_type == SDLegacyType.V1:
                 original_config_file = (
-                    global_config_dir() / "stable-diffusion" / "v1-inference.yaml"
+                    config.legacy_conf_path / "v1-inference.yaml"
                 )
 
             else:
@@ -1208,6 +1207,8 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
             scheduler = EulerAncestralDiscreteScheduler.from_config(scheduler.config)
         elif scheduler_type == "dpm":
             scheduler = DPMSolverMultistepScheduler.from_config(scheduler.config)
+        elif scheduler_type == 'unipc':
+            scheduler = UniPCMultistepScheduler.from_config(scheduler.config)
         elif scheduler_type == "ddim":
             scheduler = scheduler
         else:
@@ -1229,15 +1230,15 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
         # If a replacement VAE path was specified, we'll incorporate that into
         # the checkpoint model and then convert it
         if vae_path:
-            print(f"   | Converting VAE {vae_path}")
+            logger.debug(f"Converting VAE {vae_path}")
             replace_checkpoint_vae(checkpoint,vae_path)
         # otherwise we use the original VAE, provided that
         # an externally loaded diffusers VAE was not passed
         elif not vae:
-            print("   | Using checkpoint model's original VAE")
+            logger.debug("Using checkpoint model's original VAE")
 
         if vae:
-            print("   | Using replacement diffusers VAE")
+            logger.debug("Using replacement diffusers VAE")
         else:  # convert the original or replacement VAE
             vae_config = create_vae_diffusers_config(
                 original_config, image_size=image_size
@@ -1296,7 +1297,7 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
             )
             safety_checker = StableDiffusionSafetyChecker.from_pretrained(
                 "CompVis/stable-diffusion-safety-checker",
-                cache_dir=global_cache_dir("hub"),
+                cache_dir=config.cache_dir,
             )
             feature_extractor = AutoFeatureExtractor.from_pretrained(
                 "CompVis/stable-diffusion-safety-checker", cache_dir=cache_dir

invokeai/backend/model_management/model_manager.py

@@ -18,25 +18,24 @@ import warnings
 from enum import Enum, auto
 from pathlib import Path
 from shutil import move, rmtree
-from typing import Any, Optional, Union, Callable
+from typing import Any, Optional, Union, Callable, types
 
 import safetensors
 import safetensors.torch
 import torch
 import transformers
+import invokeai.backend.util.logging as logger
 from diffusers import (
     AutoencoderKL,
     UNet2DConditionModel,
     SchedulerMixin,
     logging as dlogging,
-)    
+)
 from huggingface_hub import scan_cache_dir
 from omegaconf import OmegaConf
 from omegaconf.dictconfig import DictConfig
 from picklescan.scanner import scan_file_path
 
-from invokeai.backend.globals import Globals, global_cache_dir
-
 from transformers import (
     CLIPTextModel,
     CLIPTokenizer,
@@ -48,9 +47,9 @@ from diffusers.pipelines.stable_diffusion.safety_checker import (
 from ..stable_diffusion import (
     StableDiffusionGeneratorPipeline,
 )
+from invokeai.app.services.config import get_invokeai_config
 from ..util import CUDA_DEVICE, ask_user, download_with_resume
 
-
 class SDLegacyType(Enum):
     V1 = auto()
     V1_INPAINT = auto()
@@ -67,7 +66,7 @@ class SDModelComponent(Enum):
     scheduler="scheduler"
     safety_checker="safety_checker"
     feature_extractor="feature_extractor"
-    
+
 DEFAULT_MAX_MODELS = 2
 
 class ModelManager(object):
@@ -75,6 +74,8 @@ class ModelManager(object):
     Model manager handles loading, caching, importing, deleting, converting, and editing models.
     """
 
+    logger: types.ModuleType = logger
+
     def __init__(
         self,
         config: OmegaConf | Path,
@@ -83,6 +84,7 @@ class ModelManager(object):
         max_loaded_models=DEFAULT_MAX_MODELS,
         sequential_offload=False,
         embedding_path: Path = None,
+        logger: types.ModuleType = logger,
     ):
         """
         Initialize with the path to the models.yaml config file or
@@ -96,6 +98,7 @@ class ModelManager(object):
         if not isinstance(config, DictConfig):
             config = OmegaConf.load(config)
         self.config = config
+        self.globals = get_invokeai_config()
         self.precision = precision
         self.device = torch.device(device_type)
         self.max_loaded_models = max_loaded_models
@@ -104,6 +107,7 @@ class ModelManager(object):
         self.current_model = None
         self.sequential_offload = sequential_offload
         self.embedding_path = embedding_path
+        self.logger = logger
 
     def valid_model(self, model_name: str) -> bool:
         """
@@ -132,8 +136,8 @@ class ModelManager(object):
             )
 
         if not self.valid_model(model_name):
-            print(
-                f'** "{model_name}" is not a known model name. Please check your models.yaml file'
+            self.logger.error(
+                f'"{model_name}" is not a known model name. Please check your models.yaml file'
             )
             return self.current_model
 
@@ -144,7 +148,7 @@ class ModelManager(object):
 
         if model_name in self.models:
             requested_model = self.models[model_name]["model"]
-            print(f">> Retrieving model {model_name} from system RAM cache")
+            self.logger.info(f"Retrieving model {model_name} from system RAM cache")
             requested_model.ready()
             width = self.models[model_name]["width"]
             height = self.models[model_name]["height"]
@@ -177,7 +181,7 @@ class ModelManager(object):
         vae from the model currently in the GPU.
         """
         return self._get_sub_model(model_name, SDModelComponent.vae)
-                                   
+
     def get_model_tokenizer(self, model_name: str=None)->CLIPTokenizer:
         """Given a model name identified in models.yaml, load the model into
         GPU if necessary and return its assigned CLIPTokenizer. If no
@@ -185,12 +189,12 @@ class ModelManager(object):
         currently in the GPU.
         """
         return self._get_sub_model(model_name, SDModelComponent.tokenizer)
-                                   
+
     def get_model_unet(self, model_name: str=None)->UNet2DConditionModel:
         """Given a model name identified in models.yaml, load the model into
         GPU if necessary and return its assigned UNet2DConditionModel. If no model
         name is provided, return the UNet from the model
-        currently in the GPU.  
+        currently in the GPU.
         """
         return self._get_sub_model(model_name, SDModelComponent.unet)
 
@@ -217,7 +221,7 @@ class ModelManager(object):
         currently in the GPU.
         """
         return self._get_sub_model(model_name, SDModelComponent.scheduler)
-    
+
     def _get_sub_model(
             self,
             model_name: str=None,
@@ -287,7 +291,7 @@ class ModelManager(object):
         """
         # if we are converting legacy files automatically, then
         # there are no legacy ckpts!
-        if Globals.ckpt_convert:
+        if self.globals.ckpt_convert:
             return False
         info = self.model_info(model_name)
         if "weights" in info and info["weights"].endswith((".ckpt", ".safetensors")):
@@ -379,7 +383,7 @@ class ModelManager(object):
         """
         omega = self.config
         if model_name not in omega:
-            print(f"** Unknown model {model_name}")
+            self.logger.error(f"Unknown model {model_name}")
             return
         # save these for use in deletion later
         conf = omega[model_name]
@@ -392,13 +396,13 @@ class ModelManager(object):
             self.stack.remove(model_name)
         if delete_files:
             if weights:
-                print(f"** Deleting file {weights}")
+                self.logger.info(f"Deleting file {weights}")
                 Path(weights).unlink(missing_ok=True)
             elif path:
-                print(f"** Deleting directory {path}")
+                self.logger.info(f"Deleting directory {path}")
                 rmtree(path, ignore_errors=True)
             elif repo_id:
-                print(f"** Deleting the cached model directory for {repo_id}")
+                self.logger.info(f"Deleting the cached model directory for {repo_id}")
                 self._delete_model_from_cache(repo_id)
 
     def add_model(
@@ -439,7 +443,7 @@ class ModelManager(object):
     def _load_model(self, model_name: str):
         """Load and initialize the model from configuration variables passed at object creation time"""
         if model_name not in self.config:
-            print(
+            self.logger.error(
                 f'"{model_name}" is not a known model name. Please check your models.yaml file'
             )
             return
@@ -457,7 +461,7 @@ class ModelManager(object):
         model_format = mconfig.get("format", "ckpt")
         if model_format == "ckpt":
             weights = mconfig.weights
-            print(f">> Loading {model_name} from {weights}")
+            self.logger.info(f"Loading {model_name} from {weights}")
             model, width, height, model_hash = self._load_ckpt_model(
                 model_name, mconfig
             )
@@ -473,13 +477,15 @@ class ModelManager(object):
 
         # usage statistics
         toc = time.time()
-        print(">> Model loaded in", "%4.2fs" % (toc - tic))
+        self.logger.info("Model loaded in " + "%4.2fs" % (toc - tic))
         if self._has_cuda():
-            print(
-                ">> Max VRAM used to load the model:",
-                "%4.2fG" % (torch.cuda.max_memory_allocated() / 1e9),
-                "\n>> Current VRAM usage:"
-                "%4.2fG" % (torch.cuda.memory_allocated() / 1e9),
+            self.logger.info(
+                "Max VRAM used to load the model: "+
+                "%4.2fG" % (torch.cuda.max_memory_allocated() / 1e9)
+            )
+            self.logger.info(
+                "Current VRAM usage: "+
+                "%4.2fG" % (torch.cuda.memory_allocated() / 1e9)
             )
         return model, width, height, model_hash
 
@@ -487,21 +493,21 @@ class ModelManager(object):
         name_or_path = self.model_name_or_path(mconfig)
         using_fp16 = self.precision == "float16"
 
-        print(f">> Loading diffusers model from {name_or_path}")
+        self.logger.info(f"Loading diffusers model from {name_or_path}")
         if using_fp16:
-            print("   | Using faster float16 precision")
+            self.logger.debug("Using faster float16 precision")
         else:
-            print("   | Using more accurate float32 precision")
+            self.logger.debug("Using more accurate float32 precision")
 
         # TODO: scan weights maybe?
         pipeline_args: dict[str, Any] = dict(
-            safety_checker=None, local_files_only=not Globals.internet_available
+            safety_checker=None, local_files_only=not self.globals.internet_available
         )
         if "vae" in mconfig and mconfig["vae"] is not None:
             if vae := self._load_vae(mconfig["vae"]):
                 pipeline_args.update(vae=vae)
         if not isinstance(name_or_path, Path):
-            pipeline_args.update(cache_dir=global_cache_dir("hub"))
+            pipeline_args.update(cache_dir=self.globals.cache_dir)
         if using_fp16:
             pipeline_args.update(torch_dtype=torch.float16)
             fp_args_list = [{"revision": "fp16"}, {}]
@@ -523,8 +529,8 @@ class ModelManager(object):
                 if str(e).startswith("fp16 is not a valid"):
                     pass
                 else:
-                    print(
-                        f"** An unexpected error occurred while downloading the model: {e})"
+                    self.logger.error(
+                        f"An unexpected error occurred while downloading the model: {e})"
                     )
             if pipeline:
                 break
@@ -542,7 +548,7 @@ class ModelManager(object):
         # square images???
         width = pipeline.unet.config.sample_size * pipeline.vae_scale_factor
         height = width
-        print(f"   | Default image dimensions = {width} x {height}")
+        self.logger.debug(f"Default image dimensions = {width} x {height}")
 
         return pipeline, width, height, model_hash
 
@@ -553,29 +559,24 @@ class ModelManager(object):
         width = mconfig.width
         height = mconfig.height
 
-        if not os.path.isabs(config):
-            config = os.path.join(Globals.root, config)
-        if not os.path.isabs(weights):
-            weights = os.path.normpath(os.path.join(Globals.root, weights))
+        root_dir = self.globals.root_dir
+        config = str(root_dir / config)
+        weights = str(root_dir / weights)
 
         # Convert to diffusers and return a diffusers pipeline
-        print(f">> Converting legacy checkpoint {model_name} into a diffusers model...")
+        self.logger.info(f"Converting legacy checkpoint {model_name} into a diffusers model...")
 
         from . import load_pipeline_from_original_stable_diffusion_ckpt
 
         try:
             if self.list_models()[self.current_model]["status"] == "active":
                 self.offload_model(self.current_model)
-        except Exception as e:
+        except Exception:
             pass
 
         vae_path = None
         if vae:
-            vae_path = (
-                vae
-                if os.path.isabs(vae)
-                else os.path.normpath(os.path.join(Globals.root, vae))
-            )
+            vae_path = str(root_dir / vae)
         if self._has_cuda():
             torch.cuda.empty_cache()
         pipeline = load_pipeline_from_original_stable_diffusion_ckpt(
@@ -607,9 +608,7 @@ class ModelManager(object):
             )
 
         if "path" in mconfig and mconfig["path"] is not None:
-            path = Path(mconfig["path"])
-            if not path.is_absolute():
-                path = Path(Globals.root, path).resolve()
+            path = self.globals.root_dir / Path(mconfig["path"])
             return path
         elif "repo_id" in mconfig:
             return mconfig["repo_id"]
@@ -624,7 +623,7 @@ class ModelManager(object):
         if model_name not in self.models:
             return
 
-        print(f">> Offloading {model_name} to CPU")
+        self.logger.info(f"Offloading {model_name} to CPU")
         model = self.models[model_name]["model"]
         model.offload_all()
         self.current_model = None
@@ -640,30 +639,26 @@ class ModelManager(object):
         and option to exit if an infected file is identified.
         """
         # scan model
-        print(f"   | Scanning Model: {model_name}")
+        self.logger.debug(f"Scanning Model: {model_name}")
         scan_result = scan_file_path(checkpoint)
         if scan_result.infected_files != 0:
             if scan_result.infected_files == 1:
-                print(f"\n### Issues Found In Model: {scan_result.issues_count}")
-                print(
-                    "### WARNING: The model you are trying to load seems to be infected."
-                )
-                print("### For your safety, InvokeAI will not load this model.")
-                print("### Please use checkpoints from trusted sources.")
-                print("### Exiting InvokeAI")
+                self.logger.critical(f"Issues Found In Model: {scan_result.issues_count}")
+                self.logger.critical("The model you are trying to load seems to be infected.")
+                self.logger.critical("For your safety, InvokeAI will not load this model.")
+                self.logger.critical("Please use checkpoints from trusted sources.")
+                self.logger.critical("Exiting InvokeAI")
                 sys.exit()
             else:
-                print(
-                    "\n### WARNING: InvokeAI was unable to scan the model you are using."
-                )
+                self.logger.warning("InvokeAI was unable to scan the model you are using.")
                 model_safe_check_fail = ask_user(
                     "Do you want to to continue loading the model?", ["y", "n"]
                 )
                 if model_safe_check_fail.lower() != "y":
-                    print("### Exiting InvokeAI")
+                    self.logger.critical("Exiting InvokeAI")
                     sys.exit()
         else:
-            print("   | Model scanned ok")
+            self.logger.debug("Model scanned ok")
 
     def import_diffuser_model(
         self,
@@ -780,26 +775,24 @@ class ModelManager(object):
         model_path: Path = None
         thing = path_url_or_repo  # to save typing
 
-        print(f">> Probing {thing} for import")
+        self.logger.info(f"Probing {thing} for import")
 
         if thing.startswith(("http:", "https:", "ftp:")):
-            print(f"   | {thing} appears to be a URL")
+            self.logger.info(f"{thing} appears to be a URL")
             model_path = self._resolve_path(
                 thing, "models/ldm/stable-diffusion-v1"
             )  # _resolve_path does a download if needed
 
         elif Path(thing).is_file() and thing.endswith((".ckpt", ".safetensors")):
             if Path(thing).stem in ["model", "diffusion_pytorch_model"]:
-                print(
-                    f"   | {Path(thing).name} appears to be part of a diffusers model. Skipping import"
-                )
+                self.logger.debug(f"{Path(thing).name} appears to be part of a diffusers model. Skipping import")
                 return
             else:
-                print(f"   | {thing} appears to be a checkpoint file on disk")
+                self.logger.debug(f"{thing} appears to be a checkpoint file on disk")
                 model_path = self._resolve_path(thing, "models/ldm/stable-diffusion-v1")
 
         elif Path(thing).is_dir() and Path(thing, "model_index.json").exists():
-            print(f"   | {thing} appears to be a diffusers file on disk")
+            self.logger.debug(f"{thing} appears to be a diffusers file on disk")
             model_name = self.import_diffuser_model(
                 thing,
                 vae=dict(repo_id="stabilityai/sd-vae-ft-mse"),
@@ -810,34 +803,30 @@ class ModelManager(object):
 
         elif Path(thing).is_dir():
             if (Path(thing) / "model_index.json").exists():
-                print(f"   | {thing} appears to be a diffusers model.")
+                self.logger.debug(f"{thing} appears to be a diffusers model.")
                 model_name = self.import_diffuser_model(
                     thing, commit_to_conf=commit_to_conf
                 )
             else:
-                print(
-                    f"   |{thing} appears to be a directory. Will scan for models to import"
-                )
+                self.logger.debug(f"{thing} appears to be a directory. Will scan for models to import")
                 for m in list(Path(thing).rglob("*.ckpt")) + list(
                     Path(thing).rglob("*.safetensors")
                 ):
                     if model_name := self.heuristic_import(
                         str(m), commit_to_conf=commit_to_conf
                     ):
-                        print(f" >> {model_name} successfully imported")
+                        self.logger.info(f"{model_name} successfully imported")
                 return model_name
 
         elif re.match(r"^[\w.+-]+/[\w.+-]+$", thing):
-            print(f"   | {thing} appears to be a HuggingFace diffusers repo_id")
+            self.logger.debug(f"{thing} appears to be a HuggingFace diffusers repo_id")
             model_name = self.import_diffuser_model(
                 thing, commit_to_conf=commit_to_conf
             )
             pipeline, _, _, _ = self._load_diffusers_model(self.config[model_name])
             return model_name
         else:
-            print(
-                f"** {thing}: Unknown thing. Please provide a URL, file path, directory or HuggingFace repo_id"
-            )
+            self.logger.warning(f"{thing}: Unknown thing. Please provide a URL, file path, directory or HuggingFace repo_id")
 
         # Model_path is set in the event of a legacy checkpoint file.
         # If not set, we're all done
@@ -845,7 +834,7 @@ class ModelManager(object):
             return
 
         if model_path.stem in self.config:  # already imported
-            print("   | Already imported. Skipping")
+            self.logger.debug("Already imported. Skipping")
             return model_path.stem
 
         # another round of heuristics to guess the correct config file.
@@ -861,39 +850,30 @@ class ModelManager(object):
             # look for a like-named .yaml file in same directory
             if model_path.with_suffix(".yaml").exists():
                 model_config_file = model_path.with_suffix(".yaml")
-                print(f"   | Using config file {model_config_file.name}")
+                self.logger.debug(f"Using config file {model_config_file.name}")
 
             else:
                 model_type = self.probe_model_type(checkpoint)
                 if model_type == SDLegacyType.V1:
-                    print("   | SD-v1 model detected")
-                    model_config_file = Path(
-                        Globals.root, "configs/stable-diffusion/v1-inference.yaml"
-                    )
+                    self.logger.debug("SD-v1 model detected")
+                    model_config_file = self.globals.legacy_conf_path / "v1-inference.yaml"
                 elif model_type == SDLegacyType.V1_INPAINT:
-                    print("   | SD-v1 inpainting model detected")
-                    model_config_file = Path(
-                        Globals.root,
-                        "configs/stable-diffusion/v1-inpainting-inference.yaml",
-                    )
+                    self.logger.debug("SD-v1 inpainting model detected")
+                    model_config_file = self.globals.legacy_conf_path / "v1-inpainting-inference.yaml",
                 elif model_type == SDLegacyType.V2_v:
-                    print("   | SD-v2-v model detected")
-                    model_config_file = Path(
-                        Globals.root, "configs/stable-diffusion/v2-inference-v.yaml"
-                    )
+                    self.logger.debug("SD-v2-v model detected")
+                    model_config_file = self.globals.legacy_conf_path / "v2-inference-v.yaml"
                 elif model_type == SDLegacyType.V2_e:
-                    print("   | SD-v2-e model detected")
-                    model_config_file = Path(
-                        Globals.root, "configs/stable-diffusion/v2-inference.yaml"
-                    )
+                    self.logger.debug("SD-v2-e model detected")
+                    model_config_file = self.globals.legacy_conf_path / "v2-inference.yaml"
                 elif model_type == SDLegacyType.V2:
-                    print(
-                        f"** {thing} is a V2 checkpoint file, but its parameterization cannot be determined. Please provide configuration file path."
+                    self.logger.warning(
+                        f"{thing} is a V2 checkpoint file, but its parameterization cannot be determined. Please provide configuration file path."
                     )
                     return
                 else:
-                    print(
-                        f"** {thing} is a legacy checkpoint file but not a known Stable Diffusion model. Please provide configuration file path."
+                    self.logger.warning(
+                        f"{thing} is a legacy checkpoint file but not a known Stable Diffusion model. Please provide configuration file path."
                     )
                     return
 
@@ -909,12 +889,10 @@ class ModelManager(object):
         for suffix in ["pt", "ckpt", "safetensors"]:
             if (model_path.with_suffix(f".vae.{suffix}")).exists():
                 vae_path = model_path.with_suffix(f".vae.{suffix}")
-                print(f"   | Using VAE file {vae_path.name}")
+                self.logger.debug(f"Using VAE file {vae_path.name}")
         vae = None if vae_path else dict(repo_id="stabilityai/sd-vae-ft-mse")
 
-        diffuser_path = Path(
-            Globals.root, "models", Globals.converted_ckpts_dir, model_path.stem
-        )
+        diffuser_path = self.globals.root_dir / "models/converted_ckpts" / model_path.stem
         model_name = self.convert_and_import(
             model_path,
             diffusers_path=diffuser_path,
@@ -955,14 +933,14 @@ class ModelManager(object):
         from . import convert_ckpt_to_diffusers
 
         if diffusers_path.exists():
-            print(
-                f"ERROR: The path {str(diffusers_path)} already exists. Please move or remove it and try again."
+            self.logger.error(
+                f"The path {str(diffusers_path)} already exists. Please move or remove it and try again."
             )
             return
 
         model_name = model_name or diffusers_path.name
         model_description = model_description or f"Converted version of {model_name}"
-        print(f"   | Converting {model_name} to diffusers (30-60s)")
+        self.logger.debug(f"Converting {model_name} to diffusers (30-60s)")
         try:
             # By passing the specified VAE to the conversion function, the autoencoder
             # will be built into the model rather than tacked on afterward via the config file
@@ -979,10 +957,10 @@ class ModelManager(object):
                 vae_path=vae_path,
                 scan_needed=scan_needed,
             )
-            print(
-                f"   | Success. Converted model is now located at {str(diffusers_path)}"
+            self.logger.debug(
+                f"Success. Converted model is now located at {str(diffusers_path)}"
             )
-            print(f"   | Writing new config file entry for {model_name}")
+            self.logger.debug(f"Writing new config file entry for {model_name}")
             new_config = dict(
                 path=str(diffusers_path),
                 description=model_description,
@@ -993,17 +971,17 @@ class ModelManager(object):
             self.add_model(model_name, new_config, True)
             if commit_to_conf:
                 self.commit(commit_to_conf)
-            print("   | Conversion succeeded")
+            self.logger.debug("Conversion succeeded")
         except Exception as e:
-            print(f"** Conversion failed: {str(e)}")
-            print(
-                "** If you are trying to convert an inpainting or 2.X model, please indicate the correct config file (e.g. v1-inpainting-inference.yaml)"
+            self.logger.warning(f"Conversion failed: {str(e)}")
+            self.logger.warning(
+                "If you are trying to convert an inpainting or 2.X model, please indicate the correct config file (e.g. v1-inpainting-inference.yaml)"
             )
 
         return model_name
 
     def search_models(self, search_folder):
-        print(f">> Finding Models In: {search_folder}")
+        self.logger.info(f"Finding Models In: {search_folder}")
         models_folder_ckpt = Path(search_folder).glob("**/*.ckpt")
         models_folder_safetensors = Path(search_folder).glob("**/*.safetensors")
 
@@ -1027,8 +1005,8 @@ class ModelManager(object):
         num_loaded_models = len(self.models)
         if num_loaded_models >= self.max_loaded_models:
             least_recent_model = self._pop_oldest_model()
-            print(
-                f">> Cache limit (max={self.max_loaded_models}) reached. Purging {least_recent_model}"
+            self.logger.info(
+                f"Cache limit (max={self.max_loaded_models}) reached. Purging {least_recent_model}"
             )
             if least_recent_model is not None:
                 del self.models[least_recent_model]
@@ -1036,8 +1014,8 @@ class ModelManager(object):
 
     def print_vram_usage(self) -> None:
         if self._has_cuda:
-            print(
-                ">> Current VRAM usage: ",
+            self.logger.info(
+                "Current VRAM usage:"+
                 "%4.2fG" % (torch.cuda.memory_allocated() / 1e9),
             )
 
@@ -1047,9 +1025,7 @@ class ModelManager(object):
         """
         yaml_str = OmegaConf.to_yaml(self.config)
         if not os.path.isabs(config_file_path):
-            config_file_path = os.path.normpath(
-                os.path.join(Globals.root, config_file_path)
-            )
+            config_file_path = self.globals.model_conf_path
         tmpfile = os.path.join(os.path.dirname(config_file_path), "new_config.tmp")
         with open(tmpfile, "w", encoding="utf-8") as outfile:
             outfile.write(self.preamble())
@@ -1081,7 +1057,8 @@ class ModelManager(object):
         """
         # Three transformer models to check: bert, clip and safety checker, and
         # the diffusers as well
-        models_dir = Path(Globals.root, "models")
+        config = get_invokeai_config()
+        models_dir = config.root_dir / "models"
         legacy_locations = [
             Path(
                 models_dir,
@@ -1093,8 +1070,8 @@ class ModelManager(object):
                 "openai/clip-vit-large-patch14/models--openai--clip-vit-large-patch14",
             ),
         ]
-        legacy_locations.extend(list(global_cache_dir("diffusers").glob("*")))
-
+        legacy_cache_dir = config.cache_dir / "../diffusers"
+        legacy_locations.extend(list(legacy_cache_dir.glob("*")))
         legacy_layout = False
         for model in legacy_locations:
             legacy_layout = legacy_layout or model.exists()
@@ -1116,7 +1093,7 @@ class ModelManager(object):
 
         # transformer files get moved into the hub directory
         if cls._is_huggingface_hub_directory_present():
-            hub = global_cache_dir("hub")
+            hub = config.cache_dir
         else:
             hub = models_dir / "hub"
 
@@ -1126,10 +1103,10 @@ class ModelManager(object):
             dest = hub / model.stem
             if dest.exists() and not source.exists():
                 continue
-            print(f"** {source} => {dest}")
+            cls.logger.info(f"{source} => {dest}")
             if source.exists():
                 if dest.is_symlink():
-                    print(f"** Found symlink at {dest.name}. Not migrating.")
+                    logger.warning(f"Found symlink at {dest.name}. Not migrating.")
                 elif dest.exists():
                     if source.is_dir():
                         rmtree(source)
@@ -1146,7 +1123,7 @@ class ModelManager(object):
         ]
         for d in empty:
             os.rmdir(d)
-        print("** Migration is done. Continuing...")
+        cls.logger.info("Migration is done. Continuing...")
 
     def _resolve_path(
         self, source: Union[str, Path], dest_directory: str
@@ -1155,13 +1132,12 @@ class ModelManager(object):
         if str(source).startswith(("http:", "https:", "ftp:")):
             dest_directory = Path(dest_directory)
             if not dest_directory.is_absolute():
-                dest_directory = Globals.root / dest_directory
+                dest_directory = self.globals.root_dir / dest_directory
             dest_directory.mkdir(parents=True, exist_ok=True)
             resolved_path = download_with_resume(str(source), dest_directory)
         else:
-            if not os.path.isabs(source):
-                source = os.path.join(Globals.root, source)
-            resolved_path = Path(source)
+            source = self.globals.root_dir / source
+            resolved_path = source
         return resolved_path
 
     def _invalidate_cached_model(self, model_name: str) -> None:
@@ -1189,15 +1165,15 @@ class ModelManager(object):
 
     def _add_embeddings_to_model(self, model: StableDiffusionGeneratorPipeline):
         if self.embedding_path is not None:
-            print(f">> Loading embeddings from {self.embedding_path}")
+            self.logger.info(f"Loading embeddings from {self.embedding_path}")
             for root, _, files in os.walk(self.embedding_path):
                 for name in files:
                     ti_path = os.path.join(root, name)
                     model.textual_inversion_manager.load_textual_inversion(
                         ti_path, defer_injecting_tokens=True
                     )
-            print(
-                f'>> Textual inversion triggers: {", ".join(sorted(model.textual_inversion_manager.get_all_trigger_strings()))}'
+            self.logger.info(
+                f'Textual inversion triggers: {", ".join(sorted(model.textual_inversion_manager.get_all_trigger_strings()))}'
             )
 
     def _has_cuda(self) -> bool:
@@ -1211,7 +1187,7 @@ class ModelManager(object):
             path = name_or_path
         else:
             owner, repo = name_or_path.split("/")
-            path = Path(global_cache_dir("hub") / f"models--{owner}--{repo}")
+            path = self.globals.cache_dir / f"models--{owner}--{repo}"
         if not path.exists():
             return None
         hashpath = path / "checksum.sha256"
@@ -1219,7 +1195,7 @@ class ModelManager(object):
             with open(hashpath) as f:
                 hash = f.read()
             return hash
-        print("   | Calculating sha256 hash of model files")
+        self.logger.debug("Calculating sha256 hash of model files")
         tic = time.time()
         sha = hashlib.sha256()
         count = 0
@@ -1231,7 +1207,7 @@ class ModelManager(object):
                         sha.update(chunk)
         hash = sha.hexdigest()
         toc = time.time()
-        print(f"   | sha256 = {hash} ({count} files hashed in", "%4.2fs)" % (toc - tic))
+        self.logger.debug(f"sha256 = {hash} ({count} files hashed in {toc - tic:4.2f}s)")
         with open(hashpath, "w") as f:
             f.write(hash)
         return hash
@@ -1249,13 +1225,13 @@ class ModelManager(object):
                 hash = f.read()
             return hash
 
-        print("   | Calculating sha256 hash of weights file")
+        self.logger.debug("Calculating sha256 hash of weights file")
         tic = time.time()
         sha = hashlib.sha256()
         sha.update(data)
         hash = sha.hexdigest()
         toc = time.time()
-        print(f">> sha256 = {hash}", "(%4.2fs)" % (toc - tic))
+        self.logger.debug(f"sha256 = {hash} "+"(%4.2fs)" % (toc - tic))
 
         with open(hashpath, "w") as f:
             f.write(hash)
@@ -1272,16 +1248,16 @@ class ModelManager(object):
         using_fp16 = self.precision == "float16"
 
         vae_args.update(
-            cache_dir=global_cache_dir("hub"),
-            local_files_only=not Globals.internet_available,
+            cache_dir=self.globals.cache_dir,
+            local_files_only=not self.globals.internet_available,
         )
 
-        print(f"   | Loading diffusers VAE from {name_or_path}")
+        self.logger.debug(f"Loading diffusers VAE from {name_or_path}")
         if using_fp16:
             vae_args.update(torch_dtype=torch.float16)
             fp_args_list = [{"revision": "fp16"}, {}]
         else:
-            print("   | Using more accurate float32 precision")
+            self.logger.debug("Using more accurate float32 precision")
             fp_args_list = [{}]
 
         vae = None
@@ -1305,13 +1281,13 @@ class ModelManager(object):
                 break
 
         if not vae and deferred_error:
-            print(f"** Could not load VAE {name_or_path}: {str(deferred_error)}")
+            self.logger.warning(f"Could not load VAE {name_or_path}: {str(deferred_error)}")
 
         return vae
 
-    @staticmethod
-    def _delete_model_from_cache(repo_id):
-        cache_info = scan_cache_dir(global_cache_dir("hub"))
+    @classmethod
+    def _delete_model_from_cache(cls,repo_id):
+        cache_info = scan_cache_dir(get_invokeai_config().cache_dir)
 
         # I'm sure there is a way to do this with comprehensions
         # but the code quickly became incomprehensible!
@@ -1321,16 +1297,17 @@ class ModelManager(object):
                 for revision in repo.revisions:
                     hashes_to_delete.add(revision.commit_hash)
         strategy = cache_info.delete_revisions(*hashes_to_delete)
-        print(
-            f"** Deletion of this model is expected to free {strategy.expected_freed_size_str}"
+        cls.logger.warning(
+            f"Deletion of this model is expected to free {strategy.expected_freed_size_str}"
         )
         strategy.execute()
 
     @staticmethod
     def _abs_path(path: str | Path) -> Path:
+        globals = get_invokeai_config()
         if path is None or Path(path).is_absolute():
             return path
-        return Path(Globals.root, path).resolve()
+        return Path(globals.root_dir, path).resolve()
 
     @staticmethod
     def _is_huggingface_hub_directory_present() -> bool:

invokeai/backend/prompting/conditioning.py

@@ -16,66 +16,59 @@ from compel.prompt_parser import (
     FlattenedPrompt,
     Fragment,
     PromptParser,
+    Conjunction,
 )
 
-from invokeai.backend.globals import Globals
+import invokeai.backend.util.logging as logger
 
+from invokeai.app.services.config import get_invokeai_config
 from ..stable_diffusion import InvokeAIDiffuserComponent
 from ..util import torch_dtype
 
-
-def get_uc_and_c_and_ec(
-    prompt_string, model, log_tokens=False, skip_normalize_legacy_blend=False
-):
+def get_uc_and_c_and_ec(prompt_string,
+                        model: InvokeAIDiffuserComponent,
+                        log_tokens=False, skip_normalize_legacy_blend=False):
     # lazy-load any deferred textual inversions.
     # this might take a couple of seconds the first time a textual inversion is used.
-    model.textual_inversion_manager.create_deferred_token_ids_for_any_trigger_terms(
-        prompt_string
-    )
+    model.textual_inversion_manager.create_deferred_token_ids_for_any_trigger_terms(prompt_string)
 
-    tokenizer = model.tokenizer
-    compel = Compel(
-        tokenizer=tokenizer,
-        text_encoder=model.text_encoder,
-        textual_inversion_manager=model.textual_inversion_manager,
-        dtype_for_device_getter=torch_dtype,
-        truncate_long_prompts=False
-    )
+    compel = Compel(tokenizer=model.tokenizer,
+                    text_encoder=model.text_encoder,
+                    textual_inversion_manager=model.textual_inversion_manager,
+                    dtype_for_device_getter=torch_dtype,
+                    truncate_long_prompts=False,
+                    )
+    
+    config = get_invokeai_config()
 
     # get rid of any newline characters
     prompt_string = prompt_string.replace("\n", " ")
-    (
-        positive_prompt_string,
-        negative_prompt_string,
-    ) = split_prompt_to_positive_and_negative(prompt_string)
-    legacy_blend = try_parse_legacy_blend(
-        positive_prompt_string, skip_normalize_legacy_blend
-    )
-    positive_prompt: Union[FlattenedPrompt, Blend]
-    if legacy_blend is not None:
-        positive_prompt = legacy_blend
-    else:
-        positive_prompt = Compel.parse_prompt_string(positive_prompt_string)
-    negative_prompt: Union[FlattenedPrompt, Blend] = Compel.parse_prompt_string(
-        negative_prompt_string
-    )
+    positive_prompt_string, negative_prompt_string = split_prompt_to_positive_and_negative(prompt_string)
 
-    if log_tokens or getattr(Globals, "log_tokenization", False):
-        log_tokenization(positive_prompt, negative_prompt, tokenizer=tokenizer)
+    legacy_blend = try_parse_legacy_blend(positive_prompt_string, skip_normalize_legacy_blend)
+    positive_conjunction: Conjunction
+    if legacy_blend is not None:
+        positive_conjunction = legacy_blend
+    else:
+        positive_conjunction = Compel.parse_prompt_string(positive_prompt_string)
+    positive_prompt = positive_conjunction.prompts[0]
+
+    negative_conjunction = Compel.parse_prompt_string(negative_prompt_string)
+    negative_prompt: FlattenedPrompt | Blend = negative_conjunction.prompts[0]
+
+    tokens_count = get_max_token_count(model.tokenizer, positive_prompt)
+    if log_tokens or config.log_tokenization:
+        log_tokenization(positive_prompt, negative_prompt, tokenizer=model.tokenizer)
 
     c, options = compel.build_conditioning_tensor_for_prompt_object(positive_prompt)
     uc, _ = compel.build_conditioning_tensor_for_prompt_object(negative_prompt)
     [c, uc] = compel.pad_conditioning_tensors_to_same_length([c, uc])
 
-    tokens_count = get_max_token_count(tokenizer, positive_prompt)
-
-    ec = InvokeAIDiffuserComponent.ExtraConditioningInfo(
-        tokens_count_including_eos_bos=tokens_count,
-        cross_attention_control_args=options.get("cross_attention_control", None),
-    )
+    ec = InvokeAIDiffuserComponent.ExtraConditioningInfo(tokens_count_including_eos_bos=tokens_count,
+                                                         cross_attention_control_args=options.get(
+                                                             'cross_attention_control', None))
     return uc, c, ec
 
-
 def get_prompt_structure(
     prompt_string, skip_normalize_legacy_blend: bool = False
 ) -> (Union[FlattenedPrompt, Blend], FlattenedPrompt):
@@ -86,18 +79,17 @@ def get_prompt_structure(
     legacy_blend = try_parse_legacy_blend(
         positive_prompt_string, skip_normalize_legacy_blend
     )
-    positive_prompt: Union[FlattenedPrompt, Blend]
+    positive_prompt: Conjunction
     if legacy_blend is not None:
-        positive_prompt = legacy_blend
+        positive_conjunction = legacy_blend
     else:
-        positive_prompt = Compel.parse_prompt_string(positive_prompt_string)
-    negative_prompt: Union[FlattenedPrompt, Blend] = Compel.parse_prompt_string(
-        negative_prompt_string
-    )
+        positive_conjunction = Compel.parse_prompt_string(positive_prompt_string)
+    positive_prompt = positive_conjunction.prompts[0]
+    negative_conjunction = Compel.parse_prompt_string(negative_prompt_string)
+    negative_prompt: FlattenedPrompt|Blend = negative_conjunction.prompts[0]
 
     return positive_prompt, negative_prompt
 
-
 def get_max_token_count(
     tokenizer, prompt: Union[FlattenedPrompt, Blend], truncate_if_too_long=False
 ) -> int:
@@ -162,8 +154,8 @@ def log_tokenization(
     negative_prompt: Union[Blend, FlattenedPrompt],
     tokenizer,
 ):
-    print(f"\n>> [TOKENLOG] Parsed Prompt: {positive_prompt}")
-    print(f"\n>> [TOKENLOG] Parsed Negative Prompt: {negative_prompt}")
+    logger.info(f"[TOKENLOG] Parsed Prompt: {positive_prompt}")
+    logger.info(f"[TOKENLOG] Parsed Negative Prompt: {negative_prompt}")
 
     log_tokenization_for_prompt_object(positive_prompt, tokenizer)
     log_tokenization_for_prompt_object(
@@ -237,29 +229,28 @@ def log_tokenization_for_text(text, tokenizer, display_label=None, truncate_if_t
             usedTokens += 1
 
     if usedTokens > 0:
-        print(f'\n>> [TOKENLOG] Tokens {display_label or ""} ({usedTokens}):')
-        print(f"{tokenized}\x1b[0m")
+        logger.info(f'[TOKENLOG] Tokens {display_label or ""} ({usedTokens}):')
+        logger.debug(f"{tokenized}\x1b[0m")
 
     if discarded != "":
-        print(f"\n>> [TOKENLOG] Tokens Discarded ({totalTokens - usedTokens}):")
-        print(f"{discarded}\x1b[0m")
+        logger.info(f"[TOKENLOG] Tokens Discarded ({totalTokens - usedTokens}):")
+        logger.debug(f"{discarded}\x1b[0m")
 
-
-def try_parse_legacy_blend(text: str, skip_normalize: bool = False) -> Optional[Blend]:
+def try_parse_legacy_blend(text: str, skip_normalize: bool = False) -> Optional[Conjunction]:
     weighted_subprompts = split_weighted_subprompts(text, skip_normalize=skip_normalize)
     if len(weighted_subprompts) <= 1:
         return None
     strings = [x[0] for x in weighted_subprompts]
-    weights = [x[1] for x in weighted_subprompts]
 
     pp = PromptParser()
     parsed_conjunctions = [pp.parse_conjunction(x) for x in strings]
-    flattened_prompts = [x.prompts[0] for x in parsed_conjunctions]
-
-    return Blend(
-        prompts=flattened_prompts, weights=weights, normalize_weights=not skip_normalize
-    )
-
+    flattened_prompts = []
+    weights = []
+    for i, x in enumerate(parsed_conjunctions):
+        if len(x.prompts)>0:
+            flattened_prompts.append(x.prompts[0])
+            weights.append(weighted_subprompts[i][1])
+    return Conjunction([Blend(prompts=flattened_prompts, weights=weights, normalize_weights=not skip_normalize)])
 
 def split_weighted_subprompts(text, skip_normalize=False) -> list:
     """
@@ -295,8 +286,8 @@ def split_weighted_subprompts(text, skip_normalize=False) -> list:
         return parsed_prompts
     weight_sum = sum(map(lambda x: x[1], parsed_prompts))
     if weight_sum == 0:
-        print(
-            "* Warning: Subprompt weights add up to zero. Discarding and using even weights instead."
+        logger.warning(
+            "Subprompt weights add up to zero. Discarding and using even weights instead."
         )
         equal_weight = 1 / max(len(parsed_prompts), 1)
         return [(x[0], equal_weight) for x in parsed_prompts]

invokeai/backend/restoration/base.py

@@ -1,3 +1,5 @@
+import invokeai.backend.util.logging as logger
+
 class Restoration:
     def __init__(self) -> None:
         pass
@@ -8,17 +10,17 @@ class Restoration:
         # Load GFPGAN
         gfpgan = self.load_gfpgan(gfpgan_model_path)
         if gfpgan.gfpgan_model_exists:
-            print(">> GFPGAN Initialized")
+            logger.info("GFPGAN Initialized")
         else:
-            print(">> GFPGAN Disabled")
+            logger.info("GFPGAN Disabled")
             gfpgan = None
 
         # Load CodeFormer
         codeformer = self.load_codeformer()
         if codeformer.codeformer_model_exists:
-            print(">> CodeFormer Initialized")
+            logger.info("CodeFormer Initialized")
         else:
-            print(">> CodeFormer Disabled")
+            logger.info("CodeFormer Disabled")
             codeformer = None
 
         return gfpgan, codeformer
@@ -39,5 +41,5 @@ class Restoration:
         from .realesrgan import ESRGAN
 
         esrgan = ESRGAN(esrgan_bg_tile)
-        print(">> ESRGAN Initialized")
+        logger.info("ESRGAN Initialized")
         return esrgan

invokeai/backend/restoration/codeformer.py

@@ -5,7 +5,8 @@ import warnings
 import numpy as np
 import torch
 
-from ..globals import Globals
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
 
 pretrained_model_url = (
     "https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/codeformer.pth"
@@ -16,19 +17,19 @@ class CodeFormerRestoration:
     def __init__(
         self, codeformer_dir="models/codeformer", codeformer_model_path="codeformer.pth"
     ) -> None:
-        if not os.path.isabs(codeformer_dir):
-            codeformer_dir = os.path.join(Globals.root, codeformer_dir)
 
-        self.model_path = os.path.join(codeformer_dir, codeformer_model_path)
-        self.codeformer_model_exists = os.path.isfile(self.model_path)
+        self.globals = get_invokeai_config()
+        codeformer_dir = self.globals.root_dir / codeformer_dir
+        self.model_path = codeformer_dir / codeformer_model_path
+        self.codeformer_model_exists = self.model_path.exists()
 
         if not self.codeformer_model_exists:
-            print("## NOT FOUND: CodeFormer model not found at " + self.model_path)
+            logger.error("NOT FOUND: CodeFormer model not found at " + self.model_path)
         sys.path.append(os.path.abspath(codeformer_dir))
 
     def process(self, image, strength, device, seed=None, fidelity=0.75):
         if seed is not None:
-            print(f">> CodeFormer - Restoring Faces for image seed:{seed}")
+            logger.info(f"CodeFormer - Restoring Faces for image seed:{seed}")
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore", category=DeprecationWarning)
             warnings.filterwarnings("ignore", category=UserWarning)
@@ -70,9 +71,7 @@ class CodeFormerRestoration:
                 upscale_factor=1,
                 use_parse=True,
                 device=device,
-                model_rootpath=os.path.join(
-                    Globals.root, "models", "gfpgan", "weights"
-                ),
+                model_rootpath = self.globals.root_dir / "gfpgan" / "weights"
             )
             face_helper.clean_all()
             face_helper.read_image(bgr_image_array)
@@ -97,7 +96,7 @@ class CodeFormerRestoration:
                     del output
                     torch.cuda.empty_cache()
                 except RuntimeError as error:
-                    print(f"\tFailed inference for CodeFormer: {error}.")
+                    logger.error(f"Failed inference for CodeFormer: {error}.")
                     restored_face = cropped_face
 
                 restored_face = restored_face.astype("uint8")

invokeai/backend/restoration/gfpgan.py

@@ -6,20 +6,19 @@ import numpy as np
 import torch
 from PIL import Image
 
-from invokeai.backend.globals import Globals
-
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
 
 class GFPGAN:
     def __init__(self, gfpgan_model_path="models/gfpgan/GFPGANv1.4.pth") -> None:
+        self.globals = get_invokeai_config()
         if not os.path.isabs(gfpgan_model_path):
-            gfpgan_model_path = os.path.abspath(
-                os.path.join(Globals.root, gfpgan_model_path)
-            )
+            gfpgan_model_path = self.globals.root_dir / gfpgan_model_path
         self.model_path = gfpgan_model_path
         self.gfpgan_model_exists = os.path.isfile(self.model_path)
 
         if not self.gfpgan_model_exists:
-            print("## NOT FOUND: GFPGAN model not found at " + self.model_path)
+            logger.error("NOT FOUND: GFPGAN model not found at " + self.model_path)
             return None
 
     def model_exists(self):
@@ -27,13 +26,13 @@ class GFPGAN:
 
     def process(self, image, strength: float, seed: str = None):
         if seed is not None:
-            print(f">> GFPGAN - Restoring Faces for image seed:{seed}")
+            logger.info(f"GFPGAN - Restoring Faces for image seed:{seed}")
 
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore", category=DeprecationWarning)
             warnings.filterwarnings("ignore", category=UserWarning)
             cwd = os.getcwd()
-            os.chdir(os.path.join(Globals.root, "models"))
+            os.chdir(self.globals.root_dir / 'models')
             try:
                 from gfpgan import GFPGANer
 
@@ -47,14 +46,14 @@ class GFPGAN:
             except Exception:
                 import traceback
 
-                print(">> Error loading GFPGAN:", file=sys.stderr)
+                logger.error("Error loading GFPGAN:", file=sys.stderr)
                 print(traceback.format_exc(), file=sys.stderr)
             os.chdir(cwd)
 
         if self.gfpgan is None:
-            print(f">> WARNING: GFPGAN not initialized.")
-            print(
-                f">> Download https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth to {self.model_path}"
+            logger.warning("WARNING: GFPGAN not initialized.")
+            logger.warning(
+                f"Download https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth to {self.model_path}"
             )
 
         image = image.convert("RGB")

invokeai/backend/restoration/outcrop.py

@@ -1,7 +1,7 @@
 import math
 
 from PIL import Image
-
+import invokeai.backend.util.logging as logger
 
 class Outcrop(object):
     def __init__(
@@ -82,7 +82,7 @@ class Outcrop(object):
             pixels = extents[direction]
             # round pixels up to the nearest 64
             pixels = math.ceil(pixels / 64) * 64
-            print(f">> extending image {direction}ward by {pixels} pixels")
+            logger.info(f"extending image {direction}ward by {pixels} pixels")
             image = self._rotate(image, direction)
             image = self._extend(image, pixels)
             image = self._rotate(image, direction, reverse=True)

invokeai/backend/restoration/realesrgan.py

@@ -1,4 +1,3 @@
-import os
 import warnings
 
 import numpy as np
@@ -6,18 +5,14 @@ import torch
 from PIL import Image
 from PIL.Image import Image as ImageType
 
-from invokeai.backend.globals import Globals
-
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
+config = get_invokeai_config()
 
 class ESRGAN:
     def __init__(self, bg_tile_size=400) -> None:
         self.bg_tile_size = bg_tile_size
 
-        if not torch.cuda.is_available():  # CPU or MPS on M1
-            use_half_precision = False
-        else:
-            use_half_precision = True
-
     def load_esrgan_bg_upsampler(self, denoise_str):
         if not torch.cuda.is_available():  # CPU or MPS on M1
             use_half_precision = False
@@ -35,12 +30,8 @@ class ESRGAN:
             upscale=4,
             act_type="prelu",
         )
-        model_path = os.path.join(
-            Globals.root, "models/realesrgan/realesr-general-x4v3.pth"
-        )
-        wdn_model_path = os.path.join(
-            Globals.root, "models/realesrgan/realesr-general-wdn-x4v3.pth"
-        )
+        model_path = config.root_dir / "models/realesrgan/realesr-general-x4v3.pth"
+        wdn_model_path = config.root_dir / "models/realesrgan/realesr-general-wdn-x4v3.pth"
         scale = 4
 
         bg_upsampler = RealESRGANer(
@@ -74,16 +65,16 @@ class ESRGAN:
                 import sys
                 import traceback
 
-                print(">> Error loading Real-ESRGAN:", file=sys.stderr)
+                logger.error("Error loading Real-ESRGAN:")
                 print(traceback.format_exc(), file=sys.stderr)
 
         if upsampler_scale == 0:
-            print(">> Real-ESRGAN: Invalid scaling option. Image not upscaled.")
+            logger.warning("Real-ESRGAN: Invalid scaling option. Image not upscaled.")
             return image
 
         if seed is not None:
-            print(
-                f">> Real-ESRGAN Upscaling seed:{seed}, scale:{upsampler_scale}x, tile:{self.bg_tile_size}, denoise:{denoise_str}"
+            logger.info(
+                f"Real-ESRGAN Upscaling seed:{seed}, scale:{upsampler_scale}x, tile:{self.bg_tile_size}, denoise:{denoise_str}"
             )
         # ESRGAN outputs images with partial transparency if given RGBA images; convert to RGB
         image = image.convert("RGB")

invokeai/backend/safety_checker.py

@@ -14,7 +14,8 @@ from PIL import Image, ImageFilter
 from transformers import AutoFeatureExtractor
 
 import invokeai.assets.web as web_assets
-from .globals import global_cache_dir
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
 from .util import CPU_DEVICE
 
 class SafetyChecker(object):
@@ -25,10 +26,11 @@ class SafetyChecker(object):
         caution = Image.open(path)
         self.caution_img = caution.resize((caution.width // 2, caution.height // 2))
         self.device = device
-        
+        config = get_invokeai_config()
+
         try:
             safety_model_id = "CompVis/stable-diffusion-safety-checker"
-            safety_model_path = global_cache_dir("hub")
+            safety_model_path = config.cache_dir
             self.safety_checker = StableDiffusionSafetyChecker.from_pretrained(
                 safety_model_id,
                 local_files_only=True,
@@ -40,8 +42,8 @@ class SafetyChecker(object):
                 cache_dir=safety_model_path,
             )
         except Exception:
-            print(
-                "** An error was encountered while installing the safety checker:"
+            logger.error(
+                "An error was encountered while installing the safety checker:"
             )
             print(traceback.format_exc())
 
@@ -65,8 +67,8 @@ class SafetyChecker(object):
         )
         self.safety_checker.to(CPU_DEVICE) # offload
         if has_nsfw_concept[0]:
-            print(
-                "** An image with potential non-safe content has been detected. A blurred image will be returned. **"
+            logger.warning(
+                "An image with potential non-safe content has been detected. A blurred image will be returned."
             )
             return self.blur(image)
         else:

invokeai/backend/stable_diffusion/concepts_lib.py

@@ -17,15 +17,16 @@ from huggingface_hub import (
     hf_hub_url,
 )
 
-from invokeai.backend.globals import Globals
-
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
 
 class HuggingFaceConceptsLibrary(object):
     def __init__(self, root=None):
         """
         Initialize the Concepts object. May optionally pass a root directory.
         """
-        self.root = root or Globals.root
+        self.config = get_invokeai_config()
+        self.root = root or self.config.root
         self.hf_api = HfApi()
         self.local_concepts = dict()
         self.concept_list = None
@@ -57,7 +58,7 @@ class HuggingFaceConceptsLibrary(object):
                 self.concept_list.extend(list(local_concepts_to_add))
                 return self.concept_list
             return self.concept_list
-        elif Globals.internet_available is True:
+        elif self.config.internet_available is True:
             try:
                 models = self.hf_api.list_models(
                     filter=ModelFilter(model_name="sd-concepts-library/")
@@ -66,11 +67,11 @@ class HuggingFaceConceptsLibrary(object):
                 # when init, add all in dir. when not init, add only concepts added between init and now
                 self.concept_list.extend(list(local_concepts_to_add))
             except Exception as e:
-                print(
-                    f" ** WARNING: Hugging Face textual inversion concepts libraries could not be loaded. The error was {str(e)}."
+                logger.warning(
+                    f"Hugging Face textual inversion concepts libraries could not be loaded. The error was {str(e)}."
                 )
-                print(
-                    " ** You may load .bin and .pt file(s) manually using the --embedding_directory argument."
+                logger.warning(
+                    "You may load .bin and .pt file(s) manually using the --embedding_directory argument."
                 )
             return self.concept_list
         else: 
@@ -83,7 +84,7 @@ class HuggingFaceConceptsLibrary(object):
         be downloaded.
         """
         if not concept_name in self.list_concepts():
-            print(
+            logger.warning(
                 f"{concept_name} is not a local embedding trigger, nor is it a HuggingFace concept. Generation will continue without the concept."
             )
             return None
@@ -221,7 +222,7 @@ class HuggingFaceConceptsLibrary(object):
             if chunk == 0:
                 bytes += total
 
-        print(f">> Downloading {repo_id}...", end="")
+        logger.info(f"Downloading {repo_id}...", end="")
         try:
             for file in (
                 "README.md",
@@ -235,22 +236,22 @@ class HuggingFaceConceptsLibrary(object):
                 )
         except ul_error.HTTPError as e:
             if e.code == 404:
-                print(
+                logger.warning(
                     f"Concept {concept_name} is not known to the Hugging Face library. Generation will continue without the concept."
                 )
             else:
-                print(
+                logger.warning(
                     f"Failed to download {concept_name}/{file} ({str(e)}. Generation will continue without the concept.)"
                 )
             os.rmdir(dest)
             return False
         except ul_error.URLError as e:
-            print(
-                f"ERROR while downloading {concept_name}: {str(e)}. This may reflect a network issue. Generation will continue without the concept."
+            logger.error(
+                f"an error occurred while downloading {concept_name}: {str(e)}. This may reflect a network issue. Generation will continue without the concept."
             )
             os.rmdir(dest)
             return False
-        print("...{:.2f}Kb".format(bytes / 1024))
+        logger.info("...{:.2f}Kb".format(bytes / 1024))
         return succeeded
 
     def _concept_id(self, concept_name: str) -> str:

invokeai/backend/stable_diffusion/diffusers_pipeline.py

@@ -9,20 +9,16 @@ from typing import Any, Callable, Generic, List, Optional, Type, TypeVar, Union
 
 import einops
 import PIL.Image
-import numpy as np
 from accelerate.utils import set_seed
 import psutil
 import torch
 import torchvision.transforms as T
 from compel import EmbeddingsProvider
 from diffusers.models import AutoencoderKL, UNet2DConditionModel
-from diffusers.models.controlnet import ControlNetModel, ControlNetOutput
 from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
 from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import (
     StableDiffusionPipeline,
 )
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
-
 from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img import (
     StableDiffusionImg2ImgPipeline,
 )
@@ -31,15 +27,13 @@ from diffusers.pipelines.stable_diffusion.safety_checker import (
 )
 from diffusers.schedulers import KarrasDiffusionSchedulers
 from diffusers.schedulers.scheduling_utils import SchedulerMixin, SchedulerOutput
-from diffusers.utils import PIL_INTERPOLATION
 from diffusers.utils.import_utils import is_xformers_available
 from diffusers.utils.outputs import BaseOutput
 from torchvision.transforms.functional import resize as tv_resize
 from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
 from typing_extensions import ParamSpec
 
-from invokeai.backend.globals import Globals
-
+from invokeai.app.services.config import get_invokeai_config
 from ..util import CPU_DEVICE, normalize_device
 from .diffusion import (
     AttentionMapSaver,
@@ -49,7 +43,6 @@ from .diffusion import (
 from .offloading import FullyLoadedModelGroup, LazilyLoadedModelGroup, ModelGroup
 from .textual_inversion_manager import TextualInversionManager
 
-
 @dataclass
 class PipelineIntermediateState:
     run_id: str
@@ -309,7 +302,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         feature_extractor: Optional[CLIPFeatureExtractor],
         requires_safety_checker: bool = False,
         precision: str = "float32",
-        control_model: ControlNetModel = None,
     ):
         super().__init__(
             vae,
@@ -330,8 +322,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             scheduler=scheduler,
             safety_checker=safety_checker,
             feature_extractor=feature_extractor,
-            # FIXME: can't currently register control module
-            # control_model=control_model,
         )
         self.invokeai_diffuser = InvokeAIDiffuserComponent(
             self.unet, self._unet_forward, is_running_diffusers=True
@@ -351,16 +341,16 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
 
         self._model_group = FullyLoadedModelGroup(self.unet.device)
         self._model_group.install(*self._submodels)
-        self.control_model = control_model
 
     def _adjust_memory_efficient_attention(self, latents: torch.Tensor):
         """
         if xformers is available, use it, otherwise use sliced attention.
         """
+        config = get_invokeai_config()
         if (
             torch.cuda.is_available()
             and is_xformers_available()
-            and not Globals.disable_xformers
+            and not config.disable_xformers
         ):
             self.enable_xformers_memory_efficient_attention()
         else:
@@ -473,7 +463,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         noise: torch.Tensor,
         callback: Callable[[PipelineIntermediateState], None] = None,
         run_id=None,
-        **kwargs,
     ) -> InvokeAIStableDiffusionPipelineOutput:
         r"""
         Function invoked when calling the pipeline for generation.
@@ -494,7 +483,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             noise=noise,
             run_id=run_id,
             callback=callback,
-            **kwargs,
         )
         # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
         torch.cuda.empty_cache()
@@ -519,12 +507,14 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         additional_guidance: List[Callable] = None,
         run_id=None,
         callback: Callable[[PipelineIntermediateState], None] = None,
-        **kwargs,
     ) -> tuple[torch.Tensor, Optional[AttentionMapSaver]]:
+        if self.scheduler.config.get("cpu_only", False):
+            scheduler_device = torch.device('cpu')
+        else:
+            scheduler_device = self._model_group.device_for(self.unet)
+
         if timesteps is None:
-            self.scheduler.set_timesteps(
-                num_inference_steps, device=self._model_group.device_for(self.unet)
-            )
+            self.scheduler.set_timesteps(num_inference_steps, device=scheduler_device)
             timesteps = self.scheduler.timesteps
         infer_latents_from_embeddings = GeneratorToCallbackinator(
             self.generate_latents_from_embeddings, PipelineIntermediateState
@@ -537,7 +527,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             additional_guidance=additional_guidance,
             run_id=run_id,
             callback=callback,
-            **kwargs,
         )
         return result.latents, result.attention_map_saver
 
@@ -550,7 +539,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         noise: torch.Tensor,
         run_id: str = None,
         additional_guidance: List[Callable] = None,
-        **kwargs,
     ):
         self._adjust_memory_efficient_attention(latents)
         if run_id is None:
@@ -559,8 +547,9 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             additional_guidance = []
         extra_conditioning_info = conditioning_data.extra
         with self.invokeai_diffuser.custom_attention_context(
-            extra_conditioning_info=extra_conditioning_info,
-            step_count=len(self.scheduler.timesteps),
+                self.invokeai_diffuser.model,
+                extra_conditioning_info=extra_conditioning_info,
+                step_count=len(self.scheduler.timesteps),
         ):
             yield PipelineIntermediateState(
                 run_id=run_id,
@@ -589,7 +578,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
                     step_index=i,
                     total_step_count=len(timesteps),
                     additional_guidance=additional_guidance,
-                    **kwargs,
                 )
                 latents = step_output.prev_sample
 
@@ -630,7 +618,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         step_index: int,
         total_step_count: int,
         additional_guidance: List[Callable] = None,
-        **kwargs,
     ):
         # invokeai_diffuser has batched timesteps, but diffusers schedulers expect a single value
         timestep = t[0]
@@ -642,33 +629,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         #     i.e. before or after passing it to InvokeAIDiffuserComponent
         latent_model_input = self.scheduler.scale_model_input(latents, timestep)
 
-        if (self.control_model is not None) and (kwargs.get("control_image") is not None):
-            control_image = kwargs.get("control_image") # should be a processed tensor derived from the control image(s)
-            control_scale = kwargs.get("control_scale", 1.0)  # control_scale default is 1.0
-            # handling case where using multiple control models but only specifying single control_scale
-            #     so reshape control_scale to match number of control models
-            if isinstance(self.control_model, MultiControlNetModel) and isinstance(control_scale, float):
-                control_scale = [control_scale] * len(self.control_model.nets)
-            if conditioning_data.guidance_scale > 1.0:
-                # expand the latents input to control model if doing classifier free guidance
-                #    (which I think for now is always true, there is conditional elsewhere that stops execution if
-                #     classifier_free_guidance is <= 1.0 ?)
-                latent_control_input = torch.cat([latent_model_input] * 2)
-            else:
-                latent_control_input = latent_model_input
-            # controlnet inference
-            down_block_res_samples, mid_block_res_sample = self.control_model(
-                latent_control_input,
-                timestep,
-                encoder_hidden_states=torch.cat([conditioning_data.unconditioned_embeddings,
-                                                 conditioning_data.text_embeddings]),
-                controlnet_cond=control_image,
-                conditioning_scale=control_scale,
-                return_dict=False,
-            )
-        else:
-            down_block_res_samples, mid_block_res_sample = None, None
-
         # predict the noise residual
         noise_pred = self.invokeai_diffuser.do_diffusion_step(
             latent_model_input,
@@ -678,8 +638,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             conditioning_data.guidance_scale,
             step_index=step_index,
             total_step_count=total_step_count,
-            down_block_additional_residuals=down_block_res_samples,
-            mid_block_additional_residual=mid_block_res_sample,
         )
 
         # compute the previous noisy sample x_t -> x_t-1
@@ -701,7 +659,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         t,
         text_embeddings,
         cross_attention_kwargs: Optional[dict[str, Any]] = None,
-        **kwargs,
     ):
         """predict the noise residual"""
         if is_inpainting_model(self.unet) and latents.size(1) == 4:
@@ -721,8 +678,7 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
 
         # First three args should be positional, not keywords, so torch hooks can see them.
         return self.unet(
-            latents, t, text_embeddings, cross_attention_kwargs=cross_attention_kwargs,
-            **kwargs,
+            latents, t, text_embeddings, cross_attention_kwargs=cross_attention_kwargs
         ).sample
 
     def img2img_from_embeddings(
@@ -772,12 +728,8 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         noise: torch.Tensor,
         run_id=None,
         callback=None,
-    ) -> InvokeAIStableDiffusionPipelineOutput:
-        timesteps, _ = self.get_img2img_timesteps(
-            num_inference_steps,
-            strength,
-            device=self._model_group.device_for(self.unet),
-        )
+    ) -> InvokeAIStableDiffusionPipelineOutput:        
+        timesteps, _ = self.get_img2img_timesteps(num_inference_steps, strength)
         result_latents, result_attention_maps = self.latents_from_embeddings(
             latents=initial_latents if strength < 1.0 else torch.zeros_like(
                 initial_latents, device=initial_latents.device, dtype=initial_latents.dtype
@@ -803,13 +755,19 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             return self.check_for_safety(output, dtype=conditioning_data.dtype)
 
     def get_img2img_timesteps(
-        self, num_inference_steps: int, strength: float, device
+        self, num_inference_steps: int, strength: float, device=None
     ) -> (torch.Tensor, int):
         img2img_pipeline = StableDiffusionImg2ImgPipeline(**self.components)
         assert img2img_pipeline.scheduler is self.scheduler
-        img2img_pipeline.scheduler.set_timesteps(num_inference_steps, device=device)
+
+        if self.scheduler.config.get("cpu_only", False):
+            scheduler_device = torch.device('cpu')
+        else:
+            scheduler_device = self._model_group.device_for(self.unet)
+
+        img2img_pipeline.scheduler.set_timesteps(num_inference_steps, device=scheduler_device)
         timesteps, adjusted_steps = img2img_pipeline.get_timesteps(
-            num_inference_steps, strength, device=device
+            num_inference_steps, strength, device=scheduler_device
         )
         # Workaround for low strength resulting in zero timesteps.
         # TODO: submit upstream fix for zero-step img2img
@@ -843,9 +801,7 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         if init_image.dim() == 3:
             init_image = init_image.unsqueeze(0)
 
-        timesteps, _ = self.get_img2img_timesteps(
-            num_inference_steps, strength, device=device
-        )
+        timesteps, _ = self.get_img2img_timesteps(num_inference_steps, strength)
 
         # 6. Prepare latent variables
         # can't quite use upstream StableDiffusionImg2ImgPipeline.prepare_latents
@@ -984,48 +940,3 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             debug_image(
                 img, f"latents {msg} {i+1}/{len(decoded)}", debug_status=True
             )
-
-    # Copied from diffusers pipeline_stable_diffusion_controlnet.py
-    # Returns torch.Tensor of shape (batch_size, 3, height, width)
-    def prepare_control_image(
-        self,
-        image,
-        width=512,
-        height=512,
-        batch_size=1,
-        num_images_per_prompt=1,
-        device="cuda",
-        dtype=torch.float16,
-        do_classifier_free_guidance=True,
-    ):
-        if not isinstance(image, torch.Tensor):
-            if isinstance(image, PIL.Image.Image):
-                image = [image]
-
-            if isinstance(image[0], PIL.Image.Image):
-                images = []
-                for image_ in image:
-                    image_ = image_.convert("RGB")
-                    image_ = image_.resize((width, height), resample=PIL_INTERPOLATION["lanczos"])
-                    image_ = np.array(image_)
-                    image_ = image_[None, :]
-                    images.append(image_)
-                image = images
-                image = np.concatenate(image, axis=0)
-                image = np.array(image).astype(np.float32) / 255.0
-                image = image.transpose(0, 3, 1, 2)
-                image = torch.from_numpy(image)
-            elif isinstance(image[0], torch.Tensor):
-                image = torch.cat(image, dim=0)
-
-        image_batch_size = image.shape[0]
-        if image_batch_size == 1:
-            repeat_by = batch_size
-        else:
-            # image batch size is the same as prompt batch size
-            repeat_by = num_images_per_prompt
-        image = image.repeat_interleave(repeat_by, dim=0)
-        image = image.to(device=device, dtype=dtype)
-        if do_classifier_free_guidance:
-            image = torch.cat([image] * 2)
-        return image

invokeai/backend/stable_diffusion/diffusion/cross_attention_control.py

@@ -1,6 +1,7 @@
 # adapted from bloc97's CrossAttentionControl colab
 # https://github.com/bloc97/CrossAttentionControl
 
+
 import enum
 import math
 from typing import Callable, Optional
@@ -9,12 +10,13 @@ import diffusers
 import psutil
 import torch
 from compel.cross_attention_control import Arguments
+from diffusers.models.unet_2d_condition import UNet2DConditionModel
 from diffusers.models.attention_processor import AttentionProcessor
 from torch import nn
 
+import invokeai.backend.util.logging as logger
 from ...util import torch_dtype
 
-
 class CrossAttentionType(enum.Enum):
     SELF = 1
     TOKENS = 2
@@ -351,8 +353,7 @@ def restore_default_cross_attention(
     else:
         remove_attention_function(model)
 
-
-def override_cross_attention(model, context: Context, is_running_diffusers=False):
+def setup_cross_attention_control_attention_processors(unet: UNet2DConditionModel, context: Context):
     """
     Inject attention parameters and functions into the passed in model to enable cross attention editing.
 
@@ -371,37 +372,22 @@ def override_cross_attention(model, context: Context, is_running_diffusers=False
     indices = torch.arange(max_length, dtype=torch.long)
     for name, a0, a1, b0, b1 in context.arguments.edit_opcodes:
         if b0 < max_length:
-            if name == "equal":  # or (name == "replace" and a1 - a0 == b1 - b0):
+            if name == "equal":# or (name == "replace" and a1 - a0 == b1 - b0):
                 # these tokens have not been edited
                 indices[b0:b1] = indices_target[a0:a1]
                 mask[b0:b1] = 1
 
     context.cross_attention_mask = mask.to(device)
     context.cross_attention_index_map = indices.to(device)
-    if is_running_diffusers:
-        unet = model
-        old_attn_processors = unet.attn_processors
-        if torch.backends.mps.is_available():
-            # see note in StableDiffusionGeneratorPipeline.__init__ about borked slicing on MPS
-            unet.set_attn_processor(SwapCrossAttnProcessor())
-        else:
-            # try to re-use an existing slice size
-            default_slice_size = 4
-            slice_size = next(
-                (
-                    p.slice_size
-                    for p in old_attn_processors.values()
-                    if type(p) is SlicedAttnProcessor
-                ),
-                default_slice_size,
-            )
-            unet.set_attn_processor(SlicedSwapCrossAttnProcesser(slice_size=slice_size))
-        return old_attn_processors
+    old_attn_processors = unet.attn_processors
+    if torch.backends.mps.is_available():
+        # see note in StableDiffusionGeneratorPipeline.__init__ about borked slicing on MPS
+        unet.set_attn_processor(SwapCrossAttnProcessor())
     else:
-        context.register_cross_attention_modules(model)
-        inject_attention_function(model, context)
-        return None
-
+        # try to re-use an existing slice size
+        default_slice_size = 4
+        slice_size = next((p.slice_size for p in old_attn_processors.values() if type(p) is SlicedAttnProcessor), default_slice_size)
+        unet.set_attn_processor(SlicedSwapCrossAttnProcesser(slice_size=slice_size))
 
 def get_cross_attention_modules(
     model, which: CrossAttentionType
@@ -420,7 +406,7 @@ def get_cross_attention_modules(
     expected_count = 16
     if cross_attention_modules_in_model_count != expected_count:
         # non-fatal error but .swap() won't work.
-        print(
+        logger.error(
             f"Error! CrossAttentionControl found an unexpected number of {cross_attention_class} modules in the model "
             + f"(expected {expected_count}, found {cross_attention_modules_in_model_count}). Either monkey-patching failed "
             + "or some assumption has changed about the structure of the model itself. Please fix the monkey-patching, "

invokeai/backend/stable_diffusion/diffusion/shared_invokeai_diffusion.py

@@ -5,10 +5,12 @@ from typing import Any, Callable, Dict, Optional, Union
 
 import numpy as np
 import torch
+from diffusers import UNet2DConditionModel
 from diffusers.models.attention_processor import AttentionProcessor
 from typing_extensions import TypeAlias
 
-from invokeai.backend.globals import Globals
+import invokeai.backend.util.logging as logger
+from invokeai.app.services.config import get_invokeai_config
 
 from .cross_attention_control import (
     Arguments,
@@ -16,8 +18,8 @@ from .cross_attention_control import (
     CrossAttentionType,
     SwapCrossAttnContext,
     get_cross_attention_modules,
-    override_cross_attention,
     restore_default_cross_attention,
+    setup_cross_attention_control_attention_processors,
 )
 from .cross_attention_map_saving import AttentionMapSaver
 
@@ -30,7 +32,6 @@ ModelForwardCallback: TypeAlias = Union[
     Callable[[torch.Tensor, torch.Tensor, torch.Tensor], torch.Tensor],
 ]
 
-
 @dataclass(frozen=True)
 class PostprocessingSettings:
     threshold: float
@@ -71,31 +72,43 @@ class InvokeAIDiffuserComponent:
         :param model: the unet model to pass through to cross attention control
         :param model_forward_callback: a lambda with arguments (x, sigma, conditioning_to_apply). will be called repeatedly. most likely, this should simply call model.forward(x, sigma, conditioning)
         """
+        config = get_invokeai_config()
         self.conditioning = None
         self.model = model
         self.is_running_diffusers = is_running_diffusers
         self.model_forward_callback = model_forward_callback
         self.cross_attention_control_context = None
-        self.sequential_guidance = Globals.sequential_guidance
+        self.sequential_guidance = config.sequential_guidance
 
+    @classmethod
     @contextmanager
     def custom_attention_context(
-        self, extra_conditioning_info: Optional[ExtraConditioningInfo], step_count: int
+        cls,
+        unet: UNet2DConditionModel, # note: also may futz with the text encoder depending on requested LoRAs
+        extra_conditioning_info: Optional[ExtraConditioningInfo],
+        step_count: int
     ):
-        do_swap = (
-            extra_conditioning_info is not None
-            and extra_conditioning_info.wants_cross_attention_control
-        )
-        old_attn_processor = None
-        if do_swap:
-            old_attn_processor = self.override_cross_attention(
-                extra_conditioning_info, step_count=step_count
-            )
+        old_attn_processors = None
+        if extra_conditioning_info and (
+            extra_conditioning_info.wants_cross_attention_control
+        ):
+            old_attn_processors = unet.attn_processors
+            # Load lora conditions into the model
+            if extra_conditioning_info.wants_cross_attention_control:
+                cross_attention_control_context = Context(
+                    arguments=extra_conditioning_info.cross_attention_control_args,
+                    step_count=step_count,
+                )
+                setup_cross_attention_control_attention_processors(
+                    unet,
+                    cross_attention_control_context,
+                )
+
         try:
             yield None
         finally:
-            if old_attn_processor is not None:
-                self.restore_default_cross_attention(old_attn_processor)
+            if old_attn_processors is not None:
+                unet.set_attn_processor(old_attn_processors)
             # TODO resuscitate attention map saving
             # self.remove_attention_map_saving()
 
@@ -168,7 +181,6 @@ class InvokeAIDiffuserComponent:
         unconditional_guidance_scale: float,
         step_index: Optional[int] = None,
         total_step_count: Optional[int] = None,
-        **kwargs,
     ):
         """
         :param x: current latents
@@ -197,7 +209,7 @@ class InvokeAIDiffuserComponent:
 
         if wants_hybrid_conditioning:
             unconditioned_next_x, conditioned_next_x = self._apply_hybrid_conditioning(
-                x, sigma, unconditioning, conditioning, **kwargs,
+                x, sigma, unconditioning, conditioning
             )
         elif wants_cross_attention_control:
             (
@@ -209,14 +221,13 @@ class InvokeAIDiffuserComponent:
                 unconditioning,
                 conditioning,
                 cross_attention_control_types_to_do,
-                **kwargs,
             )
         elif self.sequential_guidance:
             (
                 unconditioned_next_x,
                 conditioned_next_x,
             ) = self._apply_standard_conditioning_sequentially(
-                x, sigma, unconditioning, conditioning, **kwargs,
+                x, sigma, unconditioning, conditioning
             )
 
         else:
@@ -224,7 +235,7 @@ class InvokeAIDiffuserComponent:
                 unconditioned_next_x,
                 conditioned_next_x,
             ) = self._apply_standard_conditioning(
-                x, sigma, unconditioning, conditioning, **kwargs,
+                x, sigma, unconditioning, conditioning
             )
 
         combined_next_x = self._combine(
@@ -271,13 +282,13 @@ class InvokeAIDiffuserComponent:
 
     # methods below are called from do_diffusion_step and should be considered private to this class.
 
-    def _apply_standard_conditioning(self, x, sigma, unconditioning, conditioning, **kwargs):
+    def _apply_standard_conditioning(self, x, sigma, unconditioning, conditioning):
         # fast batched path
         x_twice = torch.cat([x] * 2)
         sigma_twice = torch.cat([sigma] * 2)
         both_conditionings = torch.cat([unconditioning, conditioning])
         both_results = self.model_forward_callback(
-            x_twice, sigma_twice, both_conditionings, **kwargs,
+            x_twice, sigma_twice, both_conditionings
         )
         unconditioned_next_x, conditioned_next_x = both_results.chunk(2)
         if conditioned_next_x.device.type == "mps":
@@ -291,17 +302,16 @@ class InvokeAIDiffuserComponent:
         sigma,
         unconditioning: torch.Tensor,
         conditioning: torch.Tensor,
-        **kwargs,
     ):
         # low-memory sequential path
-        unconditioned_next_x = self.model_forward_callback(x, sigma, unconditioning, **kwargs)
-        conditioned_next_x = self.model_forward_callback(x, sigma, conditioning, **kwargs)
+        unconditioned_next_x = self.model_forward_callback(x, sigma, unconditioning)
+        conditioned_next_x = self.model_forward_callback(x, sigma, conditioning)
         if conditioned_next_x.device.type == "mps":
             # prevent a result filled with zeros. seems to be a torch bug.
             conditioned_next_x = conditioned_next_x.clone()
         return unconditioned_next_x, conditioned_next_x
 
-    def _apply_hybrid_conditioning(self, x, sigma, unconditioning, conditioning, **kwargs):
+    def _apply_hybrid_conditioning(self, x, sigma, unconditioning, conditioning):
         assert isinstance(conditioning, dict)
         assert isinstance(unconditioning, dict)
         x_twice = torch.cat([x] * 2)
@@ -316,7 +326,7 @@ class InvokeAIDiffuserComponent:
             else:
                 both_conditionings[k] = torch.cat([unconditioning[k], conditioning[k]])
         unconditioned_next_x, conditioned_next_x = self.model_forward_callback(
-            x_twice, sigma_twice, both_conditionings, **kwargs,
+            x_twice, sigma_twice, both_conditionings
         ).chunk(2)
         return unconditioned_next_x, conditioned_next_x
 
@@ -327,7 +337,6 @@ class InvokeAIDiffuserComponent:
         unconditioning,
         conditioning,
         cross_attention_control_types_to_do,
-        **kwargs,
     ):
         if self.is_running_diffusers:
             return self._apply_cross_attention_controlled_conditioning__diffusers(
@@ -336,7 +345,6 @@ class InvokeAIDiffuserComponent:
                 unconditioning,
                 conditioning,
                 cross_attention_control_types_to_do,
-                **kwargs,
             )
         else:
             return self._apply_cross_attention_controlled_conditioning__compvis(
@@ -345,7 +353,6 @@ class InvokeAIDiffuserComponent:
                 unconditioning,
                 conditioning,
                 cross_attention_control_types_to_do,
-                **kwargs,
             )
 
     def _apply_cross_attention_controlled_conditioning__diffusers(
@@ -355,7 +362,6 @@ class InvokeAIDiffuserComponent:
         unconditioning,
         conditioning,
         cross_attention_control_types_to_do,
-        **kwargs,
     ):
         context: Context = self.cross_attention_control_context
 
@@ -371,7 +377,6 @@ class InvokeAIDiffuserComponent:
             sigma,
             unconditioning,
             {"swap_cross_attn_context": cross_attn_processor_context},
-            **kwargs,
         )
 
         # do requested cross attention types for conditioning (positive prompt)
@@ -383,7 +388,6 @@ class InvokeAIDiffuserComponent:
             sigma,
             conditioning,
             {"swap_cross_attn_context": cross_attn_processor_context},
-            **kwargs,
         )
         return unconditioned_next_x, conditioned_next_x
 
@@ -394,7 +398,6 @@ class InvokeAIDiffuserComponent:
         unconditioning,
         conditioning,
         cross_attention_control_types_to_do,
-        **kwargs,
     ):
         # print('pct', percent_through, ': doing cross attention control on', cross_attention_control_types_to_do)
         # slower non-batched path (20% slower on mac MPS)
@@ -408,13 +411,13 @@ class InvokeAIDiffuserComponent:
         context: Context = self.cross_attention_control_context
 
         try:
-            unconditioned_next_x = self.model_forward_callback(x, sigma, unconditioning, **kwargs)
+            unconditioned_next_x = self.model_forward_callback(x, sigma, unconditioning)
 
             # process x using the original prompt, saving the attention maps
             # print("saving attention maps for", cross_attention_control_types_to_do)
             for ca_type in cross_attention_control_types_to_do:
                 context.request_save_attention_maps(ca_type)
-            _ = self.model_forward_callback(x, sigma, conditioning, **kwargs,)
+            _ = self.model_forward_callback(x, sigma, conditioning)
             context.clear_requests(cleanup=False)
 
             # process x again, using the saved attention maps to control where self.edited_conditioning will be applied
@@ -425,7 +428,7 @@ class InvokeAIDiffuserComponent:
                 self.conditioning.cross_attention_control_args.edited_conditioning
             )
             conditioned_next_x = self.model_forward_callback(
-                x, sigma, edited_conditioning, **kwargs,
+                x, sigma, edited_conditioning
             )
             context.clear_requests(cleanup=True)
 
@@ -476,10 +479,14 @@ class InvokeAIDiffuserComponent:
             outside = torch.count_nonzero(
                 (latents < -current_threshold) | (latents > current_threshold)
             )
-            print(
-                f"\nThreshold: %={percent_through} threshold={current_threshold:.3f} (of {threshold:.3f})\n"
-                f"  | min, mean, max = {minval:.3f}, {mean:.3f}, {maxval:.3f}\tstd={std}\n"
-                f"  | {outside / latents.numel() * 100:.2f}% values outside threshold"
+            logger.info(
+                f"Threshold: %={percent_through} threshold={current_threshold:.3f} (of {threshold:.3f})"
+                )
+            logger.debug(
+                f"min, mean, max = {minval:.3f}, {mean:.3f}, {maxval:.3f}\tstd={std}"
+            )
+            logger.debug(   
+                f"{outside / latents.numel() * 100:.2f}% values outside threshold"
             )
 
         if maxval < current_threshold and minval > -current_threshold:
@@ -506,9 +513,11 @@ class InvokeAIDiffuserComponent:
             )
 
         if self.debug_thresholding:
-            print(
-                f"  | min,     , max = {minval:.3f},        , {maxval:.3f}\t(scaled by {scale})\n"
-                f"  | {num_altered / latents.numel() * 100:.2f}% values altered"
+            logger.debug(
+                f"min,     , max = {minval:.3f},        , {maxval:.3f}\t(scaled by {scale})"
+            )
+            logger.debug(
+                f"{num_altered / latents.numel() * 100:.2f}% values altered"
             )
 
         return latents

invokeai/backend/stable_diffusion/image_degradation/utils_image.py

@@ -10,7 +10,7 @@ from torchvision.utils import make_grid
 
 # import matplotlib.pyplot as plt   # TODO: check with Dominik, also bsrgan.py vs bsrgan_light.py
 
-
+import invokeai.backend.util.logging as logger
 os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
 
 
@@ -191,7 +191,7 @@ def mkdirs(paths):
 def mkdir_and_rename(path):
     if os.path.exists(path):
         new_name = path + "_archived_" + get_timestamp()
-        print("Path already exists. Rename it to [{:s}]".format(new_name))
+        logger.error("Path already exists. Rename it to [{:s}]".format(new_name))
         os.replace(path, new_name)
     os.makedirs(path)
 

invokeai/backend/stable_diffusion/schedulers/__init__.py

@@ -0,0 +1 @@
+from .schedulers import SCHEDULER_MAP

invokeai/backend/stable_diffusion/schedulers/schedulers.py

@@ -0,0 +1,23 @@
+from diffusers import DDIMScheduler, DPMSolverMultistepScheduler, KDPM2DiscreteScheduler, \
+    KDPM2AncestralDiscreteScheduler, EulerDiscreteScheduler, EulerAncestralDiscreteScheduler, \
+    HeunDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, UniPCMultistepScheduler, \
+    DPMSolverSinglestepScheduler, DEISMultistepScheduler, DDPMScheduler
+
+SCHEDULER_MAP = dict(
+    ddim=(DDIMScheduler, dict()),
+    ddpm=(DDPMScheduler, dict()),
+    deis=(DEISMultistepScheduler, dict()),
+    lms=(LMSDiscreteScheduler, dict()),
+    pndm=(PNDMScheduler, dict()),
+    heun=(HeunDiscreteScheduler, dict(use_karras_sigmas=False)),
+    heun_k=(HeunDiscreteScheduler, dict(use_karras_sigmas=True)),
+    euler=(EulerDiscreteScheduler, dict(use_karras_sigmas=False)),
+    euler_k=(EulerDiscreteScheduler, dict(use_karras_sigmas=True)),
+    euler_a=(EulerAncestralDiscreteScheduler, dict()),
+    kdpm_2=(KDPM2DiscreteScheduler, dict()),
+    kdpm_2_a=(KDPM2AncestralDiscreteScheduler, dict()),
+    dpmpp_2s=(DPMSolverSinglestepScheduler, dict()),
+    dpmpp_2m=(DPMSolverMultistepScheduler, dict(use_karras_sigmas=False)),
+    dpmpp_2m_k=(DPMSolverMultistepScheduler, dict(use_karras_sigmas=True)),
+    unipc=(UniPCMultistepScheduler, dict(cpu_only=True))
+)

invokeai/backend/stable_diffusion/textual_inversion_manager.py

@@ -10,6 +10,7 @@ from compel.embeddings_provider import BaseTextualInversionManager
 from picklescan.scanner import scan_file_path
 from transformers import CLIPTextModel, CLIPTokenizer
 
+import invokeai.backend.util.logging as logger
 from .concepts_lib import HuggingFaceConceptsLibrary
 
 @dataclass
@@ -59,12 +60,12 @@ class TextualInversionManager(BaseTextualInversionManager):
                 or self.has_textual_inversion_for_trigger_string(concept_name)
                 or self.has_textual_inversion_for_trigger_string(f"<{concept_name}>")
             ):  # in case a token with literal angle brackets encountered
-                print(f">> Loaded local embedding for trigger {concept_name}")
+                logger.info(f"Loaded local embedding for trigger {concept_name}")
                 continue
             bin_file = self.hf_concepts_library.get_concept_model_path(concept_name)
             if not bin_file:
                 continue
-            print(f">> Loaded remote embedding for trigger {concept_name}")
+            logger.info(f"Loaded remote embedding for trigger {concept_name}")
             self.load_textual_inversion(bin_file)
             self.hf_concepts_library.concepts_loaded[concept_name] = True
 
@@ -85,8 +86,8 @@ class TextualInversionManager(BaseTextualInversionManager):
         embedding_list = self._parse_embedding(str(ckpt_path))
         for embedding_info in embedding_list:
             if (self.text_encoder.get_input_embeddings().weight.data[0].shape[0] != embedding_info.token_dim):
-                print(
-                    f"   ** Notice: {ckpt_path.parents[0].name}/{ckpt_path.name} was trained on a model with an incompatible token dimension: {self.text_encoder.get_input_embeddings().weight.data[0].shape[0]} vs {embedding_info.token_dim}."
+                logger.warning(
+                    f"Notice: {ckpt_path.parents[0].name}/{ckpt_path.name} was trained on a model with an incompatible token dimension: {self.text_encoder.get_input_embeddings().weight.data[0].shape[0]} vs {embedding_info.token_dim}."
                 )
                 continue
 
@@ -105,8 +106,8 @@ class TextualInversionManager(BaseTextualInversionManager):
                     if ckpt_path.name == "learned_embeds.bin"
                     else f"<{ckpt_path.stem}>"
                 )
-                print(
-                    f">> {sourcefile}: Trigger token '{trigger_str}' is already claimed by '{self.trigger_to_sourcefile[trigger_str]}'. Trigger this concept with {replacement_trigger_str}"
+                logger.info(
+                    f"{sourcefile}: Trigger token '{trigger_str}' is already claimed by '{self.trigger_to_sourcefile[trigger_str]}'. Trigger this concept with {replacement_trigger_str}"
                 )
                 trigger_str = replacement_trigger_str
 
@@ -120,8 +121,8 @@ class TextualInversionManager(BaseTextualInversionManager):
                 self.trigger_to_sourcefile[trigger_str] = sourcefile
 
             except ValueError as e:
-                print(f'   | Ignoring incompatible embedding {embedding_info["name"]}')
-                print(f"   | The error was {str(e)}")
+                logger.debug(f'Ignoring incompatible embedding {embedding_info["name"]}')
+                logger.debug(f"The error was {str(e)}")
 
     def _add_textual_inversion(
         self, trigger_str, embedding, defer_injecting_tokens=False
@@ -133,8 +134,8 @@ class TextualInversionManager(BaseTextualInversionManager):
         :return: The token id for the added embedding, either existing or newly-added.
         """
         if trigger_str in [ti.trigger_string for ti in self.textual_inversions]:
-            print(
-                f"** TextualInversionManager refusing to overwrite already-loaded token '{trigger_str}'"
+            logger.warning(
+                f"TextualInversionManager refusing to overwrite already-loaded token '{trigger_str}'"
             )
             return
         if not self.full_precision:
@@ -155,11 +156,11 @@ class TextualInversionManager(BaseTextualInversionManager):
 
         except ValueError as e:
             if str(e).startswith("Warning"):
-                print(f">> {str(e)}")
+                logger.warning(f"{str(e)}")
             else:
                 traceback.print_exc()
-                print(
-                    f"** TextualInversionManager was unable to add a textual inversion with trigger string {trigger_str}."
+                logger.error(
+                    f"TextualInversionManager was unable to add a textual inversion with trigger string {trigger_str}."
                 )
                 raise
 
@@ -219,16 +220,16 @@ class TextualInversionManager(BaseTextualInversionManager):
         for ti in self.textual_inversions:
             if ti.trigger_token_id is None and ti.trigger_string in prompt_string:
                 if ti.embedding_vector_length > 1:
-                    print(
-                        f">> Preparing tokens for textual inversion {ti.trigger_string}..."
+                    logger.info(
+                        f"Preparing tokens for textual inversion {ti.trigger_string}..."
                     )
                 try:
                     self._inject_tokens_and_assign_embeddings(ti)
                 except ValueError as e:
-                    print(
-                        f"   | Ignoring incompatible embedding trigger {ti.trigger_string}"
+                    logger.debug(
+                        f"Ignoring incompatible embedding trigger {ti.trigger_string}"
                     )
-                    print(f"   | The error was {str(e)}")
+                    logger.debug(f"The error was {str(e)}")
                     continue
                 injected_token_ids.append(ti.trigger_token_id)
                 injected_token_ids.extend(ti.pad_token_ids)
@@ -306,16 +307,16 @@ class TextualInversionManager(BaseTextualInversionManager):
             if suffix in [".pt",".ckpt",".bin"]:
                 scan_result = scan_file_path(embedding_file)
                 if scan_result.infected_files > 0:
-                    print(
-                        f"   ** Security Issues Found in Model: {scan_result.issues_count}"
+                    logger.critical(
+                        f"Security Issues Found in Model: {scan_result.issues_count}"
                     )
-                    print("   ** For your safety, InvokeAI will not load this embed.")
+                    logger.critical("For your safety, InvokeAI will not load this embed.")
                     return list()
                 ckpt = torch.load(embedding_file,map_location="cpu")
             else:
                 ckpt = safetensors.torch.load_file(embedding_file)
         except Exception as e:
-            print(f"   ** Notice: unrecognized embedding file format: {embedding_file}: {e}")
+            logger.warning(f"Notice: unrecognized embedding file format: {embedding_file}: {e}")
             return list()
         
         # try to figure out what kind of embedding file it is and parse accordingly
@@ -334,7 +335,7 @@ class TextualInversionManager(BaseTextualInversionManager):
 
     def _parse_embedding_v1(self, embedding_ckpt: dict, file_path: str)->List[EmbeddingInfo]:
         basename = Path(file_path).stem
-        print(f'   | Loading v1 embedding file: {basename}')
+        logger.debug(f'Loading v1 embedding file: {basename}')
 
         embeddings = list()
         token_counter = -1
@@ -342,7 +343,7 @@ class TextualInversionManager(BaseTextualInversionManager):
             if token_counter < 0:
                 trigger = embedding_ckpt["name"]
             elif token_counter == 0:
-                trigger = f'<basename>'
+                trigger = '<basename>'
             else:
                 trigger = f'<{basename}-{int(token_counter:=token_counter)}>'
             token_counter += 1
@@ -365,7 +366,7 @@ class TextualInversionManager(BaseTextualInversionManager):
         This handles embedding .pt file variant #2.
         """
         basename = Path(file_path).stem
-        print(f'   | Loading v2 embedding file: {basename}')
+        logger.debug(f'Loading v2 embedding file: {basename}')
         embeddings = list()
         
         if isinstance(
@@ -384,7 +385,7 @@ class TextualInversionManager(BaseTextualInversionManager):
                 )
                 embeddings.append(embedding_info)
         else:
-            print(f"   ** {basename}: Unrecognized embedding format")
+            logger.warning(f"{basename}: Unrecognized embedding format")
 
         return embeddings
 
@@ -393,7 +394,7 @@ class TextualInversionManager(BaseTextualInversionManager):
         Parse 'version 3' of the .pt textual inversion embedding files.
         """
         basename = Path(file_path).stem
-        print(f'   | Loading v3 embedding file: {basename}')
+        logger.debug(f'Loading v3 embedding file: {basename}')
         embedding = embedding_ckpt['emb_params']
         embedding_info = EmbeddingInfo(
             name = f'<{basename}>',
@@ -411,11 +412,11 @@ class TextualInversionManager(BaseTextualInversionManager):
         basename = Path(filepath).stem
         short_path = Path(filepath).parents[0].name+'/'+Path(filepath).name
         
-        print(f'   | Loading v4 embedding file: {short_path}')
+        logger.debug(f'Loading v4 embedding file: {short_path}')
         
         embeddings = list()
         if list(embedding_ckpt.keys()) == 0:
-            print(f"   ** Invalid embeddings file: {short_path}")
+            logger.warning(f"Invalid embeddings file: {short_path}")
         else:
             for token,embedding in embedding_ckpt.items():
                 embedding_info = EmbeddingInfo(

invokeai/backend/training/textual_inversion_training.py

@@ -7,7 +7,6 @@
 This is the backend to "textual_inversion.py"
 """
 
-import argparse
 import logging
 import math
 import os
@@ -47,8 +46,7 @@ from tqdm.auto import tqdm
 from transformers import CLIPTextModel, CLIPTokenizer
 
 # invokeai stuff
-from ..args import ArgFormatter, PagingArgumentParser
-from ..globals import Globals, global_cache_dir
+from invokeai.app.services.config import InvokeAIAppConfig,PagingArgumentParser
 
 if version.parse(version.parse(PIL.__version__).base_version) >= version.parse("9.1.0"):
     PIL_INTERPOLATION = {
@@ -90,8 +88,9 @@ def save_progress(
 
 
 def parse_args():
+    config = InvokeAIAppConfig(argv=[])
     parser = PagingArgumentParser(
-        description="Textual inversion training", formatter_class=ArgFormatter
+        description="Textual inversion training"
     )
     general_group = parser.add_argument_group("General")
     model_group = parser.add_argument_group("Models and Paths")
@@ -112,7 +111,7 @@ def parse_args():
         "--root_dir",
         "--root",
         type=Path,
-        default=Globals.root,
+        default=config.root,
         help="Path to the invokeai runtime directory",
     )
     general_group.add_argument(
@@ -127,7 +126,7 @@ def parse_args():
     general_group.add_argument(
         "--output_dir",
         type=Path,
-        default=f"{Globals.root}/text-inversion-model",
+        default=f"{config.root}/text-inversion-model",
         help="The output directory where the model predictions and checkpoints will be written.",
     )
     model_group.add_argument(
@@ -528,6 +527,7 @@ def get_full_repo_name(
 
 
 def do_textual_inversion_training(
+    config: InvokeAIAppConfig,
     model: str,
     train_data_dir: Path,
     output_dir: Path,
@@ -580,7 +580,7 @@ def do_textual_inversion_training(
 
     # setting up things the way invokeai expects them
     if not os.path.isabs(output_dir):
-        output_dir = os.path.join(Globals.root, output_dir)
+        output_dir = os.path.join(config.root, output_dir)
 
     logging_dir = output_dir / logging_dir
 
@@ -628,7 +628,7 @@ def do_textual_inversion_training(
         elif output_dir is not None:
             os.makedirs(output_dir, exist_ok=True)
 
-    models_conf = OmegaConf.load(os.path.join(Globals.root, "configs/models.yaml"))
+    models_conf = OmegaConf.load(config.model_conf_path)
     model_conf = models_conf.get(model, None)
     assert model_conf is not None, f"Unknown model: {model}"
     assert (
@@ -640,7 +640,7 @@ def do_textual_inversion_training(
     assert (
         pretrained_model_name_or_path
     ), f"models.yaml error: neither 'repo_id' nor 'path' is defined for {model}"
-    pipeline_args = dict(cache_dir=global_cache_dir("hub"))
+    pipeline_args = dict(cache_dir=config.cache_dir)
 
     # Load tokenizer
     if tokenizer_name:

invokeai/backend/util/devices.py

@@ -4,17 +4,16 @@ from contextlib import nullcontext
 
 import torch
 from torch import autocast
-
-from invokeai.backend.globals import Globals
+from invokeai.app.services.config import get_invokeai_config
 
 CPU_DEVICE = torch.device("cpu")
 CUDA_DEVICE = torch.device("cuda")
 MPS_DEVICE = torch.device("mps")
 
-
 def choose_torch_device() -> torch.device:
     """Convenience routine for guessing which GPU device to run model on"""
-    if Globals.always_use_cpu:
+    config = get_invokeai_config()    
+    if config.always_use_cpu:
         return CPU_DEVICE
     if torch.cuda.is_available():
         return torch.device("cuda")
@@ -33,7 +32,8 @@ def choose_precision(device: torch.device) -> str:
 
 
 def torch_dtype(device: torch.device) -> torch.dtype:
-    if Globals.full_precision:
+    config = get_invokeai_config()
+    if config.full_precision:
         return torch.float32
     if choose_precision(device) == "float16":
         return torch.float16

invokeai/backend/util/logging.py

@@ -0,0 +1,110 @@
+# Copyright (c) 2023 Lincoln D. Stein and The InvokeAI Development Team
+
+"""invokeai.util.logging
+
+Logging class for InvokeAI that produces console messages
+
+Usage:
+
+from invokeai.backend.util.logging import InvokeAILogger
+
+logger = InvokeAILogger.getLogger(name='InvokeAI') // Initialization
+(or)
+logger = InvokeAILogger.getLogger(__name__) // To use the filename
+
+logger.critical('this is critical') // Critical Message
+logger.error('this is an error') // Error Message
+logger.warning('this is a warning') // Warning Message
+logger.info('this is info') // Info Message
+logger.debug('this is debugging') // Debug Message
+
+Console messages:
+    [12-05-2023 20]::[InvokeAI]::CRITICAL --> This is an info message [In Bold Red]
+    [12-05-2023 20]::[InvokeAI]::ERROR --> This is an info message [In Red]
+    [12-05-2023 20]::[InvokeAI]::WARNING --> This is an info message [In Yellow]
+    [12-05-2023 20]::[InvokeAI]::INFO --> This is an info message [In Grey]
+    [12-05-2023 20]::[InvokeAI]::DEBUG --> This is an info message [In Grey]
+
+Alternate Method (in this case the logger name will be set to InvokeAI):
+import invokeai.backend.util.logging as IAILogger
+IAILogger.debug('this is a debugging message')
+"""
+
+import logging
+
+
+# module level functions
+def debug(msg, *args, **kwargs):
+    InvokeAILogger.getLogger().debug(msg, *args, **kwargs)
+
+def info(msg, *args, **kwargs):
+    InvokeAILogger.getLogger().info(msg, *args, **kwargs)
+
+def warning(msg, *args, **kwargs):
+    InvokeAILogger.getLogger().warning(msg, *args, **kwargs)
+
+def error(msg, *args, **kwargs):
+    InvokeAILogger.getLogger().error(msg, *args, **kwargs)
+
+def critical(msg, *args, **kwargs):
+    InvokeAILogger.getLogger().critical(msg, *args, **kwargs)
+
+def log(level, msg, *args, **kwargs):
+    InvokeAILogger.getLogger().log(level, msg, *args, **kwargs)
+
+def disable(level=logging.CRITICAL):
+    InvokeAILogger.getLogger().disable(level)
+
+def basicConfig(**kwargs):
+    InvokeAILogger.getLogger().basicConfig(**kwargs)
+
+def getLogger(name: str = None) -> logging.Logger:
+    return InvokeAILogger.getLogger(name)
+
+
+class InvokeAILogFormatter(logging.Formatter):
+    '''
+    Custom Formatting for the InvokeAI Logger
+    '''
+
+    # Color Codes
+    grey = "\x1b[38;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    cyan = "\x1b[36;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+
+    # Log Format
+    format = "[%(asctime)s]::[%(name)s]::%(levelname)s --> %(message)s"
+    ## More Formatting Options: %(pathname)s, %(filename)s, %(module)s, %(lineno)d
+
+    # Format Map
+    FORMATS = {
+        logging.DEBUG: cyan + format + reset,
+        logging.INFO: grey + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt, datefmt="%d-%m-%Y %H:%M:%S")
+        return formatter.format(record)
+
+
+class InvokeAILogger(object):
+    loggers = dict()
+
+    @classmethod
+    def getLogger(self, name: str = 'InvokeAI') -> logging.Logger:
+        if name not in self.loggers:
+            logger = logging.getLogger(name)
+            logger.setLevel(logging.DEBUG)
+            ch = logging.StreamHandler()
+            fmt = InvokeAILogFormatter()
+            ch.setFormatter(fmt)
+            logger.addHandler(ch)
+            self.loggers[name] = logger
+        return self.loggers[name]

invokeai/backend/util/util.py

@@ -18,6 +18,7 @@ import torch
 from PIL import Image, ImageDraw, ImageFont
 from tqdm import tqdm
 
+import invokeai.backend.util.logging as logger
 from .devices import torch_dtype
 
 
@@ -38,7 +39,7 @@ def log_txt_as_img(wh, xc, size=10):
         try:
             draw.text((0, 0), lines, fill="black", font=font)
         except UnicodeEncodeError:
-            print("Cant encode string for logging. Skipping.")
+            logger.warning("Cant encode string for logging. Skipping.")
 
         txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0
         txts.append(txt)
@@ -80,8 +81,8 @@ def mean_flat(tensor):
 def count_params(model, verbose=False):
     total_params = sum(p.numel() for p in model.parameters())
     if verbose:
-        print(
-            f"   | {model.__class__.__name__} has {total_params * 1.e-6:.2f} M params."
+        logger.debug(
+            f"{model.__class__.__name__} has {total_params * 1.e-6:.2f} M params."
         )
     return total_params
 
@@ -132,8 +133,8 @@ def parallel_data_prefetch(
         raise ValueError("list expected but function got ndarray.")
     elif isinstance(data, abc.Iterable):
         if isinstance(data, dict):
-            print(
-                'WARNING:"data" argument passed to parallel_data_prefetch is a dict: Using only its values and disregarding keys.'
+            logger.warning(
+                '"data" argument passed to parallel_data_prefetch is a dict: Using only its values and disregarding keys.'
             )
             data = list(data.values())
         if target_data_type == "ndarray":
@@ -175,7 +176,7 @@ def parallel_data_prefetch(
         processes += [p]
 
     # start processes
-    print("Start prefetching...")
+    logger.info("Start prefetching...")
     import time
 
     start = time.time()
@@ -194,7 +195,7 @@ def parallel_data_prefetch(
                 gather_res[res[0]] = res[1]
 
     except Exception as e:
-        print("Exception: ", e)
+        logger.error("Exception: ", e)
         for p in processes:
             p.terminate()
 
@@ -202,7 +203,7 @@ def parallel_data_prefetch(
     finally:
         for p in processes:
             p.join()
-        print(f"Prefetching complete. [{time.time() - start} sec.]")
+        logger.info(f"Prefetching complete. [{time.time() - start} sec.]")
 
     if target_data_type == "ndarray":
         if not isinstance(gather_res[0], np.ndarray):
@@ -318,23 +319,23 @@ def download_with_resume(url: str, dest: Path, access_token: str = None) -> Path
         resp = requests.get(url, headers=header, stream=True)  # new request with range
 
     if exist_size > content_length:
-        print("* corrupt existing file found. re-downloading")
+        logger.warning("corrupt existing file found. re-downloading")
         os.remove(dest)
         exist_size = 0
 
     if resp.status_code == 416 or exist_size == content_length:
-        print(f"* {dest}: complete file found. Skipping.")
+        logger.warning(f"{dest}: complete file found. Skipping.")
         return dest
     elif resp.status_code == 206 or exist_size > 0:
-        print(f"* {dest}: partial file found. Resuming...")
+        logger.warning(f"{dest}: partial file found. Resuming...")
     elif resp.status_code != 200:
-        print(f"** An error occurred during downloading {dest}: {resp.reason}")
+        logger.error(f"An error occurred during downloading {dest}: {resp.reason}")
     else:
-        print(f"* {dest}: Downloading...")
+        logger.error(f"{dest}: Downloading...")
 
     try:
         if content_length < 2000:
-            print(f"*** ERROR DOWNLOADING {url}: {resp.text}")
+            logger.error(f"ERROR DOWNLOADING {url}: {resp.text}")
             return None
 
         with open(dest, open_mode) as file, tqdm(
@@ -349,7 +350,7 @@ def download_with_resume(url: str, dest: Path, access_token: str = None) -> Path
                 size = file.write(data)
                 bar.update(size)
     except Exception as e:
-        print(f"An error occurred while downloading {dest}: {str(e)}")
+        logger.error(f"An error occurred while downloading {dest}: {str(e)}")
         return None
 
     return dest

invokeai/backend/web/invoke_ai_web_server.py

@@ -19,6 +19,7 @@ from PIL import Image
 from PIL.Image import Image as ImageType
 from werkzeug.utils import secure_filename
 
+import invokeai.backend.util.logging as logger
 import invokeai.frontend.web.dist as frontend
 
 from .. import Generate
@@ -77,7 +78,6 @@ class InvokeAIWebServer:
         mimetypes.add_type("application/javascript", ".js")
         mimetypes.add_type("text/css", ".css")
         # Socket IO
-        logger = True if args.web_verbose else False
         engineio_logger = True if args.web_verbose else False
         max_http_buffer_size = 10000000
 
@@ -213,7 +213,7 @@ class InvokeAIWebServer:
         self.load_socketio_listeners(self.socketio)
 
         if args.gui:
-            print(">> Launching Invoke AI GUI")
+            logger.info("Launching Invoke AI GUI")
             try:
                 from flaskwebgui import FlaskUI
 
@@ -231,17 +231,17 @@ class InvokeAIWebServer:
                 sys.exit(0)
         else:
             useSSL = args.certfile or args.keyfile
-            print(">> Started Invoke AI Web Server")
+            logger.info("Started Invoke AI Web Server")
             if self.host == "0.0.0.0":
-                print(
+                logger.info(
                     f"Point your browser at http{'s' if useSSL else ''}://localhost:{self.port} or use the host's DNS name or IP address."
                 )
             else:
-                print(
-                    ">> Default host address now 127.0.0.1 (localhost). Use --host 0.0.0.0 to bind any address."
+                logger.info(
+                    "Default host address now 127.0.0.1 (localhost). Use --host 0.0.0.0 to bind any address."
                 )
-                print(
-                    f">> Point your browser at http{'s' if useSSL else ''}://{self.host}:{self.port}"
+                logger.info(
+                    f"Point your browser at http{'s' if useSSL else ''}://{self.host}:{self.port}"
                 )
             if not useSSL:
                 self.socketio.run(app=self.app, host=self.host, port=self.port)
@@ -273,7 +273,7 @@ class InvokeAIWebServer:
         # path for thumbnail images
         self.thumbnail_image_path = os.path.join(self.result_path, "thumbnails/")
         # txt log
-        self.log_path = os.path.join(self.result_path, "invoke_log.txt")
+        self.log_path = os.path.join(self.result_path, "invoke_logger.txt")
         # make all output paths
         [
             os.makedirs(path, exist_ok=True)
@@ -290,7 +290,7 @@ class InvokeAIWebServer:
     def load_socketio_listeners(self, socketio):
         @socketio.on("requestSystemConfig")
         def handle_request_capabilities():
-            print(">> System config requested")
+            logger.info("System config requested")
             config = self.get_system_config()
             config["model_list"] = self.generate.model_manager.list_models()
             config["infill_methods"] = infill_methods()
@@ -330,7 +330,7 @@ class InvokeAIWebServer:
                 if model_name in current_model_list:
                     update = True
 
-                print(f">> Adding New Model: {model_name}")
+                logger.info(f"Adding New Model: {model_name}")
 
                 self.generate.model_manager.add_model(
                     model_name=model_name,
@@ -348,14 +348,14 @@ class InvokeAIWebServer:
                         "update": update,
                     },
                 )
-                print(f">> New Model Added: {model_name}")
+                logger.info(f"New Model Added: {model_name}")
             except Exception as e:
                 self.handle_exceptions(e)
 
         @socketio.on("deleteModel")
         def handle_delete_model(model_name: str):
             try:
-                print(f">> Deleting Model: {model_name}")
+                logger.info(f"Deleting Model: {model_name}")
                 self.generate.model_manager.del_model(model_name)
                 self.generate.model_manager.commit(opt.conf)
                 updated_model_list = self.generate.model_manager.list_models()
@@ -366,14 +366,14 @@ class InvokeAIWebServer:
                         "model_list": updated_model_list,
                     },
                 )
-                print(f">> Model Deleted: {model_name}")
+                logger.info(f"Model Deleted: {model_name}")
             except Exception as e:
                 self.handle_exceptions(e)
 
         @socketio.on("requestModelChange")
         def handle_set_model(model_name: str):
             try:
-                print(f">> Model change requested: {model_name}")
+                logger.info(f"Model change requested: {model_name}")
                 model = self.generate.set_model(model_name)
                 model_list = self.generate.model_manager.list_models()
                 if model is None:
@@ -454,7 +454,7 @@ class InvokeAIWebServer:
                         "update": True,
                     },
                 )
-                print(f">> Model Converted: {model_name}")
+                logger.info(f"Model Converted: {model_name}")
             except Exception as e:
                 self.handle_exceptions(e)
 
@@ -490,7 +490,7 @@ class InvokeAIWebServer:
                 if vae := self.generate.model_manager.config[models_to_merge[0]].get(
                     "vae", None
                 ):
-                    print(f">> Using configured VAE assigned to {models_to_merge[0]}")
+                    logger.info(f"Using configured VAE assigned to {models_to_merge[0]}")
                     merged_model_config.update(vae=vae)
 
                 self.generate.model_manager.import_diffuser_model(
@@ -507,8 +507,8 @@ class InvokeAIWebServer:
                         "update": True,
                     },
                 )
-                print(f">> Models Merged: {models_to_merge}")
-                print(f">> New Model Added: {model_merge_info['merged_model_name']}")
+                logger.info(f"Models Merged: {models_to_merge}")
+                logger.info(f"New Model Added: {model_merge_info['merged_model_name']}")
             except Exception as e:
                 self.handle_exceptions(e)
 
@@ -698,7 +698,7 @@ class InvokeAIWebServer:
                             }
                         )
                     except Exception as e:
-                        print(f">> Unable to load {path}")
+                        logger.info(f"Unable to load {path}")
                         socketio.emit(
                             "error", {"message": f"Unable to load {path}: {str(e)}"}
                         )
@@ -735,9 +735,9 @@ class InvokeAIWebServer:
                         printable_parameters["init_mask"][:64] + "..."
                     )
 
-                print(f"\n>> Image Generation Parameters:\n\n{printable_parameters}\n")
-                print(f">> ESRGAN Parameters: {esrgan_parameters}")
-                print(f">> Facetool Parameters: {facetool_parameters}")
+                logger.info(f"Image Generation Parameters:\n\n{printable_parameters}\n")
+                logger.info(f"ESRGAN Parameters: {esrgan_parameters}")
+                logger.info(f"Facetool Parameters: {facetool_parameters}")
 
                 self.generate_images(
                     generation_parameters,
@@ -750,8 +750,8 @@ class InvokeAIWebServer:
         @socketio.on("runPostprocessing")
         def handle_run_postprocessing(original_image, postprocessing_parameters):
             try:
-                print(
-                    f'>> Postprocessing requested for "{original_image["url"]}": {postprocessing_parameters}'
+                logger.info(
+                    f'Postprocessing requested for "{original_image["url"]}": {postprocessing_parameters}'
                 )
 
                 progress = Progress()
@@ -861,14 +861,14 @@ class InvokeAIWebServer:
 
         @socketio.on("cancel")
         def handle_cancel():
-            print(">> Cancel processing requested")
+            logger.info("Cancel processing requested")
             self.canceled.set()
 
         # TODO: I think this needs a safety mechanism.
         @socketio.on("deleteImage")
         def handle_delete_image(url, thumbnail, uuid, category):
             try:
-                print(f'>> Delete requested "{url}"')
+                logger.info(f'Delete requested "{url}"')
                 from send2trash import send2trash
 
                 path = self.get_image_path_from_url(url)
@@ -1263,7 +1263,7 @@ class InvokeAIWebServer:
                     image, os.path.basename(path), self.thumbnail_image_path
                 )
 
-                print(f'\n\n>> Image generated: "{path}"\n')
+                logger.info(f'Image generated: "{path}"\n')
                 self.write_log_message(f'[Generated] "{path}": {command}')
 
                 if progress.total_iterations > progress.current_iteration:
@@ -1329,7 +1329,7 @@ class InvokeAIWebServer:
         except Exception as e:
             # Clear the CUDA cache on an exception
             self.empty_cuda_cache()
-            print(e)
+            logger.error(e)
             self.handle_exceptions(e)
 
     def empty_cuda_cache(self):

invokeai/backend/web/modules/parameters.py

@@ -4,17 +4,21 @@ from .parse_seed_weights import parse_seed_weights
 
 SAMPLER_CHOICES = [
     "ddim",
-    "k_dpm_2_a",
-    "k_dpm_2",
-    "k_dpmpp_2_a",
-    "k_dpmpp_2",
-    "k_euler_a",
-    "k_euler",
-    "k_heun",
-    "k_lms",
-    "plms",
-    # diffusers:
+    "ddpm",
+    "deis",
+    "lms",
     "pndm",
+    "heun",
+    'heun_k',
+    "euler",
+    "euler_k",
+    "euler_a",
+    "kdpm_2",
+    "kdpm_2_a",
+    "dpmpp_2s",
+    "dpmpp_2m",
+    "dpmpp_2m_k",
+    "unipc",
 ]
 
 

invokeai/frontend/CLI/readline.py

@@ -1,497 +0,0 @@
-"""
-Readline helper functions for invoke.py.
-You may import the global singleton `completer` to get access to the
-completer object itself. This is useful when you want to autocomplete
-seeds:
-
- from invokeai.frontend.CLI.readline import completer
- completer.add_seed(18247566)
- completer.add_seed(9281839)
-"""
-import atexit
-import os
-import re
-
-from ...backend.args import Args
-from ...backend.globals import Globals
-from ...backend.stable_diffusion import HuggingFaceConceptsLibrary
-
-# ---------------readline utilities---------------------
-try:
-    import readline
-
-    readline_available = True
-except (ImportError, ModuleNotFoundError) as e:
-    print(f"** An error occurred when loading the readline module: {str(e)}")
-    readline_available = False
-
-IMG_EXTENSIONS = (".png", ".jpg", ".jpeg", ".PNG", ".JPG", ".JPEG", ".gif", ".GIF")
-WEIGHT_EXTENSIONS = (".ckpt", ".vae", ".safetensors")
-TEXT_EXTENSIONS = (".txt", ".TXT")
-CONFIG_EXTENSIONS = (".yaml", ".yml")
-COMMANDS = (
-    "--steps",
-    "-s",
-    "--seed",
-    "-S",
-    "--iterations",
-    "-n",
-    "--width",
-    "-W",
-    "--height",
-    "-H",
-    "--cfg_scale",
-    "-C",
-    "--threshold",
-    "--perlin",
-    "--grid",
-    "-g",
-    "--individual",
-    "-i",
-    "--save_intermediates",
-    "--init_img",
-    "-I",
-    "--init_mask",
-    "-M",
-    "--init_color",
-    "--strength",
-    "-f",
-    "--variants",
-    "-v",
-    "--outdir",
-    "-o",
-    "--sampler",
-    "-A",
-    "-m",
-    "--embedding_path",
-    "--device",
-    "--grid",
-    "-g",
-    "--facetool",
-    "-ft",
-    "--facetool_strength",
-    "-G",
-    "--codeformer_fidelity",
-    "-cf",
-    "--upscale",
-    "-U",
-    "-save_orig",
-    "--save_original",
-    "--log_tokenization",
-    "-t",
-    "--hires_fix",
-    "--inpaint_replace",
-    "-r",
-    "--png_compression",
-    "-z",
-    "--text_mask",
-    "-tm",
-    "--h_symmetry_time_pct",
-    "--v_symmetry_time_pct",
-    "!fix",
-    "!fetch",
-    "!replay",
-    "!history",
-    "!search",
-    "!clear",
-    "!models",
-    "!switch",
-    "!import_model",
-    "!optimize_model",
-    "!convert_model",
-    "!edit_model",
-    "!del_model",
-    "!mask",
-    "!triggers",
-)
-MODEL_COMMANDS = (
-    "!switch",
-    "!edit_model",
-    "!del_model",
-)
-CKPT_MODEL_COMMANDS = ("!optimize_model",)
-WEIGHT_COMMANDS = (
-    "!import_model",
-    "!convert_model",
-)
-IMG_PATH_COMMANDS = ("--outdir[=\s]",)
-TEXT_PATH_COMMANDS = ("!replay",)
-IMG_FILE_COMMANDS = (
-    "!fix",
-    "!fetch",
-    "!mask",
-    "--init_img[=\s]",
-    "-I",
-    "--init_mask[=\s]",
-    "-M",
-    "--init_color[=\s]",
-    "--embedding_path[=\s]",
-)
-
-path_regexp = "(" + "|".join(IMG_PATH_COMMANDS + IMG_FILE_COMMANDS) + ")\s*\S*$"
-weight_regexp = "(" + "|".join(WEIGHT_COMMANDS) + ")\s*\S*$"
-text_regexp = "(" + "|".join(TEXT_PATH_COMMANDS) + ")\s*\S*$"
-
-
-class Completer(object):
-    def __init__(self, options, models={}):
-        self.options = sorted(options)
-        self.models = models
-        self.seeds = set()
-        self.matches = list()
-        self.default_dir = None
-        self.linebuffer = None
-        self.auto_history_active = True
-        self.extensions = None
-        self.concepts = None
-        self.embedding_terms = set()
-        return
-
-    def complete(self, text, state):
-        """
-        Completes invoke command line.
-        BUG: it doesn't correctly complete files that have spaces in the name.
-        """
-        buffer = readline.get_line_buffer()
-
-        if state == 0:
-            # extensions defined, so go directly into path completion mode
-            if self.extensions is not None:
-                self.matches = self._path_completions(text, state, self.extensions)
-
-            # looking for an image file
-            elif re.search(path_regexp, buffer):
-                do_shortcut = re.search("^" + "|".join(IMG_FILE_COMMANDS), buffer)
-                self.matches = self._path_completions(
-                    text, state, IMG_EXTENSIONS, shortcut_ok=do_shortcut
-                )
-
-            # looking for a seed
-            elif re.search("(-S\s*|--seed[=\s])\d*$", buffer):
-                self.matches = self._seed_completions(text, state)
-
-            # looking for an embedding concept
-            elif re.search("<[\w-]*$", buffer):
-                self.matches = self._concept_completions(text, state)
-
-            # looking for a model
-            elif re.match("^" + "|".join(MODEL_COMMANDS), buffer):
-                self.matches = self._model_completions(text, state)
-
-            # looking for a ckpt model
-            elif re.match("^" + "|".join(CKPT_MODEL_COMMANDS), buffer):
-                self.matches = self._model_completions(text, state, ckpt_only=True)
-
-            elif re.search(weight_regexp, buffer):
-                self.matches = self._path_completions(
-                    text,
-                    state,
-                    WEIGHT_EXTENSIONS,
-                    default_dir=Globals.root,
-                )
-
-            elif re.search(text_regexp, buffer):
-                self.matches = self._path_completions(text, state, TEXT_EXTENSIONS)
-
-            # This is the first time for this text, so build a match list.
-            elif text:
-                self.matches = [s for s in self.options if s and s.startswith(text)]
-            else:
-                self.matches = self.options[:]
-
-        # Return the state'th item from the match list,
-        # if we have that many.
-        try:
-            response = self.matches[state]
-        except IndexError:
-            response = None
-        return response
-
-    def complete_extensions(self, extensions: list):
-        """
-        If called with a list of extensions, will force completer
-        to do file path completions.
-        """
-        self.extensions = extensions
-
-    def add_history(self, line):
-        """
-        Pass thru to readline
-        """
-        if not self.auto_history_active:
-            readline.add_history(line)
-
-    def clear_history(self):
-        """
-        Pass clear_history() thru to readline
-        """
-        readline.clear_history()
-
-    def search_history(self, match: str):
-        """
-        Like show_history() but only shows items that
-        contain the match string.
-        """
-        self.show_history(match)
-
-    def remove_history_item(self, pos):
-        readline.remove_history_item(pos)
-
-    def add_seed(self, seed):
-        """
-        Add a seed to the autocomplete list for display when -S is autocompleted.
-        """
-        if seed is not None:
-            self.seeds.add(str(seed))
-
-    def set_default_dir(self, path):
-        self.default_dir = path
-
-    def set_options(self, options):
-        self.options = options
-
-    def get_line(self, index):
-        try:
-            line = self.get_history_item(index)
-        except IndexError:
-            return None
-        return line
-
-    def get_current_history_length(self):
-        return readline.get_current_history_length()
-
-    def get_history_item(self, index):
-        return readline.get_history_item(index)
-
-    def show_history(self, match=None):
-        """
-        Print the session history using the pydoc pager
-        """
-        import pydoc
-
-        lines = list()
-        h_len = self.get_current_history_length()
-        if h_len < 1:
-            print("<empty history>")
-            return
-
-        for i in range(0, h_len):
-            line = self.get_history_item(i + 1)
-            if match and match not in line:
-                continue
-            lines.append(f"[{i+1}] {line}")
-        pydoc.pager("\n".join(lines))
-
-    def set_line(self, line) -> None:
-        """
-        Set the default string displayed in the next line of input.
-        """
-        self.linebuffer = line
-        readline.redisplay()
-
-    def update_models(self, models: dict) -> None:
-        """
-        update our list of models
-        """
-        self.models = models
-
-    def _seed_completions(self, text, state):
-        m = re.search("(-S\s?|--seed[=\s]?)(\d*)", text)
-        if m:
-            switch = m.groups()[0]
-            partial = m.groups()[1]
-        else:
-            switch = ""
-            partial = text
-
-        matches = list()
-        for s in self.seeds:
-            if s.startswith(partial):
-                matches.append(switch + s)
-        matches.sort()
-        return matches
-
-    def add_embedding_terms(self, terms: list[str]):
-        self.embedding_terms = set(terms)
-        if self.concepts:
-            self.embedding_terms.update(set(self.concepts.list_concepts()))
-
-    def _concept_completions(self, text, state):
-        if self.concepts is None:
-            # cache Concepts() instance so we can check for updates in concepts_list during runtime.
-            self.concepts = HuggingFaceConceptsLibrary()
-            self.embedding_terms.update(set(self.concepts.list_concepts()))
-        else:
-            self.embedding_terms.update(set(self.concepts.list_concepts()))
-
-        partial = text[1:]  # this removes the leading '<'
-        if len(partial) == 0:
-            return list(self.embedding_terms)  # whole dump - think if user wants this!
-
-        matches = list()
-        for concept in self.embedding_terms:
-            if concept.startswith(partial):
-                matches.append(f"<{concept}>")
-        matches.sort()
-        return matches
-
-    def _model_completions(self, text, state, ckpt_only=False):
-        m = re.search("(!switch\s+)(\w*)", text)
-        if m:
-            switch = m.groups()[0]
-            partial = m.groups()[1]
-        else:
-            switch = ""
-            partial = text
-        matches = list()
-        for s in self.models:
-            format = self.models[s]["format"]
-            if format == "vae":
-                continue
-            if ckpt_only and format != "ckpt":
-                continue
-            if s.startswith(partial):
-                matches.append(switch + s)
-        matches.sort()
-        return matches
-
-    def _pre_input_hook(self):
-        if self.linebuffer:
-            readline.insert_text(self.linebuffer)
-            readline.redisplay()
-            self.linebuffer = None
-
-    def _path_completions(
-        self, text, state, extensions, shortcut_ok=True, default_dir: str = ""
-    ):
-        # separate the switch from the partial path
-        match = re.search("^(-\w|--\w+=?)(.*)", text)
-        if match is None:
-            switch = None
-            partial_path = text
-        else:
-            switch, partial_path = match.groups()
-
-        partial_path = partial_path.lstrip()
-
-        matches = list()
-        path = os.path.expanduser(partial_path)
-
-        if os.path.isdir(path):
-            dir = path
-        elif os.path.dirname(path) != "":
-            dir = os.path.dirname(path)
-        else:
-            dir = default_dir if os.path.exists(default_dir) else ""
-            path = os.path.join(dir, path)
-
-        dir_list = os.listdir(dir or ".")
-        if shortcut_ok and os.path.exists(self.default_dir) and dir == "":
-            dir_list += os.listdir(self.default_dir)
-
-        for node in dir_list:
-            if node.startswith(".") and len(node) > 1:
-                continue
-            full_path = os.path.join(dir, node)
-
-            if not (node.endswith(extensions) or os.path.isdir(full_path)):
-                continue
-
-            if path and not full_path.startswith(path):
-                continue
-
-            if switch is None:
-                match_path = os.path.join(dir, node)
-                matches.append(
-                    match_path + "/" if os.path.isdir(full_path) else match_path
-                )
-            elif os.path.isdir(full_path):
-                matches.append(
-                    switch + os.path.join(os.path.dirname(full_path), node) + "/"
-                )
-            elif node.endswith(extensions):
-                matches.append(switch + os.path.join(os.path.dirname(full_path), node))
-
-        return matches
-
-
-class DummyCompleter(Completer):
-    def __init__(self, options):
-        super().__init__(options)
-        self.history = list()
-
-    def add_history(self, line):
-        self.history.append(line)
-
-    def clear_history(self):
-        self.history = list()
-
-    def get_current_history_length(self):
-        return len(self.history)
-
-    def get_history_item(self, index):
-        return self.history[index - 1]
-
-    def remove_history_item(self, index):
-        return self.history.pop(index - 1)
-
-    def set_line(self, line):
-        print(f"# {line}")
-
-
-def generic_completer(commands: list) -> Completer:
-    if readline_available:
-        completer = Completer(commands, [])
-        readline.set_completer(completer.complete)
-        readline.set_pre_input_hook(completer._pre_input_hook)
-        readline.set_completer_delims(" ")
-        readline.parse_and_bind("tab: complete")
-        readline.parse_and_bind("set print-completions-horizontally off")
-        readline.parse_and_bind("set page-completions on")
-        readline.parse_and_bind("set skip-completed-text on")
-        readline.parse_and_bind("set show-all-if-ambiguous on")
-    else:
-        completer = DummyCompleter(commands)
-    return completer
-
-
-def get_completer(opt: Args, models=[]) -> Completer:
-    if readline_available:
-        completer = Completer(COMMANDS, models)
-
-        readline.set_completer(completer.complete)
-        # pyreadline3 does not have a set_auto_history() method
-        try:
-            readline.set_auto_history(False)
-            completer.auto_history_active = False
-        except:
-            completer.auto_history_active = True
-        readline.set_pre_input_hook(completer._pre_input_hook)
-        readline.set_completer_delims(" ")
-        readline.parse_and_bind("tab: complete")
-        readline.parse_and_bind("set print-completions-horizontally off")
-        readline.parse_and_bind("set page-completions on")
-        readline.parse_and_bind("set skip-completed-text on")
-        readline.parse_and_bind("set show-all-if-ambiguous on")
-
-        outdir = os.path.expanduser(opt.outdir)
-        if os.path.isabs(outdir):
-            histfile = os.path.join(outdir, ".invoke_history")
-        else:
-            histfile = os.path.join(Globals.root, outdir, ".invoke_history")
-        try:
-            readline.read_history_file(histfile)
-            readline.set_history_length(1000)
-        except FileNotFoundError:
-            pass
-        except OSError:  # file likely corrupted
-            newname = f"{histfile}.old"
-            print(
-                f"## Your history file {histfile} couldn't be loaded and may be corrupted. Renaming it to {newname}"
-            )
-            os.replace(histfile, newname)
-        atexit.register(readline.write_history_file, histfile)
-
-    else:
-        completer = DummyCompleter(COMMANDS)
-    return completer

invokeai/frontend/CLI/sd_metadata.py

@@ -1,30 +0,0 @@
-'''
-This is a modularized version of the sd-metadata.py script,
-which retrieves and prints the metadata from a series of generated png files.
-'''
-import sys
-import json
-from invokeai.backend.image_util import retrieve_metadata
-
-
-def print_metadata():
-    if len(sys.argv) < 2:
-        print("Usage: file2prompt.py <file1.png> <file2.png> <file3.png>...")
-        print("This script opens up the indicated invoke.py-generated PNG file(s) and prints out their metadata.")
-        exit(-1)
-
-    filenames = sys.argv[1:]
-    for f in filenames:
-        try:
-            metadata = retrieve_metadata(f)
-            print(f'{f}:\n',json.dumps(metadata['sd-metadata'], indent=4))
-        except FileNotFoundError:
-            sys.stderr.write(f'{f} not found\n')
-            continue
-        except PermissionError:
-            sys.stderr.write(f'{f} could not be opened due to inadequate permissions\n')
-            continue
-
-if __name__== '__main__':
-    print_metadata()
-

invokeai/frontend/install/model_install.py

@@ -22,7 +22,7 @@ import torch
 from npyscreen import widget
 from omegaconf import OmegaConf
 
-from invokeai.backend.globals import Globals, global_config_dir
+import invokeai.backend.util.logging as logger
 
 from ...backend.config.model_install_backend import (
     Dataset_path,
@@ -40,11 +40,13 @@ from .widgets import (
     TextBox,
     set_min_terminal_size,
 )
+from invokeai.app.services.config import get_invokeai_config
 
 # minimum size for the UI
 MIN_COLS = 120
 MIN_LINES = 45
 
+config = get_invokeai_config()
 
 class addModelsForm(npyscreen.FormMultiPage):
     # for responsive resizing - disabled
@@ -452,11 +454,11 @@ def main():
     opt = parser.parse_args()
 
     # setting a global here
-    Globals.root = os.path.expanduser(get_root(opt.root) or "")
+    config.root = os.path.expanduser(get_root(opt.root) or "")
 
-    if not global_config_dir().exists():
-        print(
-            ">> Your InvokeAI root directory is not set up. Calling invokeai-configure."
+    if not (config.conf_path / '..' ).exists():
+        logger.info(
+            "Your InvokeAI root directory is not set up. Calling invokeai-configure."
         )
         from invokeai.frontend.install import invokeai_configure
 
@@ -466,18 +468,18 @@ def main():
     try:
         select_and_download_models(opt)
     except AssertionError as e:
-        print(str(e))
+        logger.error(e)
         sys.exit(-1)
     except KeyboardInterrupt:
-        print("\nGoodbye! Come back soon.")
+        logger.info("Goodbye! Come back soon.")
     except widget.NotEnoughSpaceForWidget as e:
         if str(e).startswith("Height of 1 allocated"):
-            print(
-                "** Insufficient vertical space for the interface. Please make your window taller and try again"
+            logger.error(
+                "Insufficient vertical space for the interface. Please make your window taller and try again"
             )
         elif str(e).startswith("addwstr"):
-            print(
-                "** Insufficient horizontal space for the interface. Please make your window wider and try again."
+            logger.error(
+                "Insufficient horizontal space for the interface. Please make your window wider and try again."
             )
 
 

invokeai/frontend/merge/merge_diffusers.py

@@ -8,7 +8,6 @@ import argparse
 import curses
 import os
 import sys
-import traceback
 import warnings
 from argparse import Namespace
 from pathlib import Path
@@ -20,18 +19,13 @@ from diffusers import logging as dlogging
 from npyscreen import widget
 from omegaconf import OmegaConf
 
-from ...backend.globals import (
-    Globals,
-    global_cache_dir,
-    global_config_file,
-    global_models_dir,
-    global_set_root,
-)
+import invokeai.backend.util.logging as logger
+from invokeai.services.config import get_invokeai_config
 from ...backend.model_management import ModelManager
 from ...frontend.install.widgets import FloatTitleSlider
 
 DEST_MERGED_MODEL_DIR = "merged_models"
-
+config = get_invokeai_config()
 
 def merge_diffusion_models(
     model_ids_or_paths: List[Union[str, Path]],
@@ -58,7 +52,7 @@ def merge_diffusion_models(
 
         pipe = DiffusionPipeline.from_pretrained(
             model_ids_or_paths[0],
-            cache_dir=kwargs.get("cache_dir", global_cache_dir()),
+            cache_dir=kwargs.get("cache_dir", config.cache_dir),
             custom_pipeline="checkpoint_merger",
         )
         merged_pipe = pipe.merge(
@@ -92,7 +86,7 @@ def merge_diffusion_models_and_commit(
     **kwargs - the default DiffusionPipeline.get_config_dict kwargs:
          cache_dir, resume_download, force_download, proxies, local_files_only, use_auth_token, revision, torch_dtype, device_map
     """
-    config_file = global_config_file()
+    config_file = config.model_conf_path
     model_manager = ModelManager(OmegaConf.load(config_file))
     for mod in models:
         assert mod in model_manager.model_names(), f'** Unknown model "{mod}"'
@@ -104,7 +98,7 @@ def merge_diffusion_models_and_commit(
     merged_pipe = merge_diffusion_models(
         model_ids_or_paths, alpha, interp, force, **kwargs
     )
-    dump_path = global_models_dir() / DEST_MERGED_MODEL_DIR
+    dump_path = config.models_dir / DEST_MERGED_MODEL_DIR
 
     os.makedirs(dump_path, exist_ok=True)
     dump_path = dump_path / merged_model_name
@@ -113,7 +107,7 @@ def merge_diffusion_models_and_commit(
         model_name=merged_model_name, description=f'Merge of models {", ".join(models)}'
     )
     if vae := model_manager.config[models[0]].get("vae", None):
-        print(f">> Using configured VAE assigned to {models[0]}")
+        logger.info(f"Using configured VAE assigned to {models[0]}")
         import_args.update(vae=vae)
     model_manager.import_diffuser_model(dump_path, **import_args)
     model_manager.commit(config_file)
@@ -124,7 +118,7 @@ def _parse_args() -> Namespace:
     parser.add_argument(
         "--root_dir",
         type=Path,
-        default=Globals.root,
+        default=config.root,
         help="Path to the invokeai runtime directory",
     )
     parser.add_argument(
@@ -391,14 +385,12 @@ class mergeModelsForm(npyscreen.FormMultiPageAction):
             for name in self.model_manager.model_names()
             if self.model_manager.model_info(name).get("format") == "diffusers"
         ]
-        print(model_names)
         return sorted(model_names)
 
-
 class Mergeapp(npyscreen.NPSAppManaged):
     def __init__(self):
         super().__init__()
-        conf = OmegaConf.load(global_config_file())
+        conf = OmegaConf.load(config.model_conf_path)
         self.model_manager = ModelManager(
             conf, "cpu", "float16"
         )  # precision doesn't really matter here
@@ -414,7 +406,7 @@ def run_gui(args: Namespace):
 
     args = mergeapp.merge_arguments
     merge_diffusion_models_and_commit(**args)
-    print(f'>> Models merged into new model: "{args["merged_model_name"]}".')
+    logger.info(f'Models merged into new model: "{args["merged_model_name"]}".')
 
 
 def run_cli(args: Namespace):
@@ -425,24 +417,24 @@ def run_cli(args: Namespace):
 
     if not args.merged_model_name:
         args.merged_model_name = "+".join(args.models)
-        print(
-            f'>> No --merged_model_name provided. Defaulting to "{args.merged_model_name}"'
+        logger.info(
+            f'No --merged_model_name provided. Defaulting to "{args.merged_model_name}"'
         )
 
-        model_manager = ModelManager(OmegaConf.load(global_config_file()))
+        model_manager = ModelManager(OmegaConf.load(config.model_conf_path))
         assert (
             args.clobber or args.merged_model_name not in model_manager.model_names()
         ), f'A model named "{args.merged_model_name}" already exists. Use --clobber to overwrite.'
 
         merge_diffusion_models_and_commit(**vars(args))
-        print(f'>> Models merged into new model: "{args.merged_model_name}".')
+        logger.info(f'Models merged into new model: "{args.merged_model_name}".')
 
 
 def main():
     args = _parse_args()
-    global_set_root(args.root_dir)
+    config.root = args.root_dir
 
-    cache_dir = str(global_cache_dir("hub"))
+    cache_dir = config.cache_dir
     os.environ[
         "HF_HOME"
     ] = cache_dir  # because not clear the merge pipeline is honoring cache_dir
@@ -455,17 +447,16 @@ def main():
             run_cli(args)
     except widget.NotEnoughSpaceForWidget as e:
         if str(e).startswith("Height of 1 allocated"):
-            print(
-                "** You need to have at least two diffusers models defined in models.yaml in order to merge"
+            logger.error(
+                "You need to have at least two diffusers models defined in models.yaml in order to merge"
             )
         else:
-            print(
-                "** Not enough room for the user interface. Try making this window larger."
+            logger.error(
+                "Not enough room for the user interface. Try making this window larger."
             )
         sys.exit(-1)
-    except Exception:
-        print(">> An error occurred:")
-        traceback.print_exc()
+    except Exception as e:
+        logger.error(e)
         sys.exit(-1)
     except KeyboardInterrupt:
         sys.exit(-1)

invokeai/frontend/training/textual_inversion.py

@@ -20,14 +20,18 @@ import npyscreen
 from npyscreen import widget
 from omegaconf import OmegaConf
 
-from invokeai.backend.globals import Globals, global_set_root
+import invokeai.backend.util.logging as logger
 
-from ...backend.training import do_textual_inversion_training, parse_args
+from invokeai.app.services.config import get_invokeai_config
+from ...backend.training import (
+    do_textual_inversion_training,
+    parse_args
+)
 
 TRAINING_DATA = "text-inversion-training-data"
 TRAINING_DIR = "text-inversion-output"
 CONF_FILE = "preferences.conf"
-
+config = None
 
 class textualInversionForm(npyscreen.FormMultiPageAction):
     resolutions = [512, 768, 1024]
@@ -121,7 +125,7 @@ class textualInversionForm(npyscreen.FormMultiPageAction):
             value=str(
                 saved_args.get(
                     "train_data_dir",
-                    Path(Globals.root) / TRAINING_DATA / default_placeholder_token,
+                    config.root_dir / TRAINING_DATA / default_placeholder_token,
                 )
             ),
             scroll_exit=True,
@@ -134,7 +138,7 @@ class textualInversionForm(npyscreen.FormMultiPageAction):
             value=str(
                 saved_args.get(
                     "output_dir",
-                    Path(Globals.root) / TRAINING_DIR / default_placeholder_token,
+                    config.root_dir / TRAINING_DIR / default_placeholder_token,
                 )
             ),
             scroll_exit=True,
@@ -240,9 +244,9 @@ class textualInversionForm(npyscreen.FormMultiPageAction):
         placeholder = self.placeholder_token.value
         self.prompt_token.value = f"(Trigger by using <{placeholder}> in your prompts)"
         self.train_data_dir.value = str(
-            Path(Globals.root) / TRAINING_DATA / placeholder
+            config.root_dir / TRAINING_DATA / placeholder
         )
-        self.output_dir.value = str(Path(Globals.root) / TRAINING_DIR / placeholder)
+        self.output_dir.value = str(config.root_dir / TRAINING_DIR / placeholder)
         self.resume_from_checkpoint.value = Path(self.output_dir.value).exists()
 
     def on_ok(self):
@@ -283,7 +287,7 @@ class textualInversionForm(npyscreen.FormMultiPageAction):
             return True
 
     def get_model_names(self) -> Tuple[List[str], int]:
-        conf = OmegaConf.load(os.path.join(Globals.root, "configs/models.yaml"))
+        conf = OmegaConf.load(config.root_dir / "configs/models.yaml")
         model_names = [
             idx
             for idx in sorted(list(conf.keys()))
@@ -366,23 +370,23 @@ def copy_to_embeddings_folder(args: dict):
     """
     source = Path(args["output_dir"], "learned_embeds.bin")
     dest_dir_name = args["placeholder_token"].strip("<>")
-    destination = Path(Globals.root, "embeddings", dest_dir_name)
+    destination = config.root_dir / "embeddings" / dest_dir_name
     os.makedirs(destination, exist_ok=True)
-    print(f">> Training completed. Copying learned_embeds.bin into {str(destination)}")
+    logger.info(f"Training completed. Copying learned_embeds.bin into {str(destination)}")
     shutil.copy(source, destination)
     if (
         input("Delete training logs and intermediate checkpoints? [y] ") or "y"
     ).startswith(("y", "Y")):
         shutil.rmtree(Path(args["output_dir"]))
     else:
-        print(f'>> Keeping {args["output_dir"]}')
+        logger.info(f'Keeping {args["output_dir"]}')
 
 
 def save_args(args: dict):
     """
     Save the current argument values to an omegaconf file
     """
-    dest_dir = Path(Globals.root) / TRAINING_DIR
+    dest_dir = config.root_dir / TRAINING_DIR
     os.makedirs(dest_dir, exist_ok=True)
     conf_file = dest_dir / CONF_FILE
     conf = OmegaConf.create(args)
@@ -393,7 +397,7 @@ def previous_args() -> dict:
     """
     Get the previous arguments used.
     """
-    conf_file = Path(Globals.root) / TRAINING_DIR / CONF_FILE
+    conf_file = config.root_dir / TRAINING_DIR / CONF_FILE
     try:
         conf = OmegaConf.load(conf_file)
         conf["placeholder_token"] = conf["placeholder_token"].strip("<>")
@@ -419,39 +423,46 @@ def do_front_end(args: Namespace):
         save_args(args)
 
         try:
-            do_textual_inversion_training(**args)
+            do_textual_inversion_training(get_invokeai_config(),**args)
             copy_to_embeddings_folder(args)
         except Exception as e:
-            print("** An exception occurred during training. The exception was:")
-            print(str(e))
-            print("** DETAILS:")
-            print(traceback.format_exc())
+            logger.error("An exception occurred during training. The exception was:")
+            logger.error(str(e))
+            logger.error("DETAILS:")
+            logger.error(traceback.format_exc())
 
 
 def main():
+    global config
+    
     args = parse_args()
-    global_set_root(args.root_dir or Globals.root)
+    config = get_invokeai_config(argv=[])
+
+    # change root if needed
+    if args.root_dir:
+        config.root = args.root_dir
+    
     try:
         if args.front_end:
             do_front_end(args)
         else:
-            do_textual_inversion_training(**vars(args))
+            do_textual_inversion_training(config,**vars(args))
     except AssertionError as e:
-        print(str(e))
+        logger.error(e)
         sys.exit(-1)
     except KeyboardInterrupt:
         pass
     except (widget.NotEnoughSpaceForWidget, Exception) as e:
         if str(e).startswith("Height of 1 allocated"):
-            print(
-                "** You need to have at least one diffusers models defined in models.yaml in order to train"
+            logger.error(
+                "You need to have at least one diffusers models defined in models.yaml in order to train"
             )
         elif str(e).startswith("addwstr"):
-            print(
-                "** Not enough window space for the interface. Please make your window larger and try again."
+            logger.error(
+                "Not enough window space for the interface. Please make your window larger and try again."
             )
         else:
-            print(f"** An error has occurred: {str(e)}")
+            logger.error(e)
         sys.exit(-1)
 
 

invokeai/frontend/web/.babelrc

@@ -1,13 +0,0 @@
-{
-  "plugins": [
-    [
-      "transform-imports",
-      {
-        "lodash": {
-          "transform": "lodash/${member}",
-          "preventFullImport": true
-        }
-      }
-    ]
-  ]
-}

invokeai/frontend/web/.gitignore

@@ -34,4 +34,8 @@ stats.html
 !.yarn/plugins
 !.yarn/releases
 !.yarn/sdks
-!.yarn/versions
+!.yarn/versions
+
+# Yalc
+.yalc
+yalc.lock

invokeai/frontend/web/config/vite.app.config.ts

@@ -0,0 +1,40 @@
+import react from '@vitejs/plugin-react-swc';
+import { visualizer } from 'rollup-plugin-visualizer';
+import { PluginOption, UserConfig } from 'vite';
+import eslint from 'vite-plugin-eslint';
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+export const appConfig: UserConfig = {
+  base: './',
+  plugins: [
+    react(),
+    eslint(),
+    tsconfigPaths(),
+    visualizer() as unknown as PluginOption,
+  ],
+  build: {
+    chunkSizeWarningLimit: 1500,
+  },
+  server: {
+    // Proxy HTTP requests to the flask server
+    proxy: {
+      // Proxy socket.io to the nodes socketio server
+      '/ws/socket.io': {
+        target: 'ws://127.0.0.1:9090',
+        ws: true,
+      },
+      // Proxy openapi schema definiton
+      '/openapi.json': {
+        target: 'http://127.0.0.1:9090/openapi.json',
+        rewrite: (path) => path.replace(/^\/openapi.json/, ''),
+        changeOrigin: true,
+      },
+      // proxy nodes api
+      '/api/v1': {
+        target: 'http://127.0.0.1:9090/api/v1',
+        rewrite: (path) => path.replace(/^\/api\/v1/, ''),
+        changeOrigin: true,
+      },
+    },
+  },
+};

invokeai/frontend/web/config/vite.package.config.ts

@@ -0,0 +1,50 @@
+import react from '@vitejs/plugin-react-swc';
+import path from 'path';
+import { visualizer } from 'rollup-plugin-visualizer';
+import { PluginOption, UserConfig } from 'vite';
+import dts from 'vite-plugin-dts';
+import eslint from 'vite-plugin-eslint';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import cssInjectedByJsPlugin from 'vite-plugin-css-injected-by-js';
+
+export const packageConfig: UserConfig = {
+  base: './',
+  plugins: [
+    react(),
+    eslint(),
+    tsconfigPaths(),
+    visualizer() as unknown as PluginOption,
+    dts({
+      insertTypesEntry: true,
+    }),
+    cssInjectedByJsPlugin(),
+  ],
+  build: {
+    cssCodeSplit: true,
+    lib: {
+      entry: path.resolve(__dirname, '../src/index.ts'),
+      name: 'InvokeAIUI',
+      fileName: (format) => `invoke-ai-ui.${format}.js`,
+    },
+    rollupOptions: {
+      external: ['react', 'react-dom', '@emotion/react'],
+      output: {
+        globals: {
+          react: 'React',
+          'react-dom': 'ReactDOM',
+          '@emotion/react': 'EmotionReact',
+        },
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      app: path.resolve(__dirname, '../src/app'),
+      assets: path.resolve(__dirname, '../src/assets'),
+      common: path.resolve(__dirname, '../src/common'),
+      features: path.resolve(__dirname, '../src/features'),
+      services: path.resolve(__dirname, '../src/services'),
+      theme: path.resolve(__dirname, '../src/theme'),
+    },
+  },
+};

invokeai/frontend/web/docs/PACKAGE_SCRIPTS.md

@@ -15,15 +15,3 @@ The `postinstall` script patches a few packages and runs the Chakra CLI to gener
 ### Patch `@chakra-ui/cli`
 
 See: <https://github.com/chakra-ui/chakra-ui/issues/7394>
-
-### Patch `redux-persist`
-
-We want to persist the canvas state to `localStorage` but many canvas operations change data very quickly, so we need to debounce the writes to `localStorage`.
-
-`redux-persist` is unfortunately unmaintained. The repo's current code is nonfunctional, but the last release's code depends on a package that was removed from `npm` for being malware, so we cannot just fork it.
-
-So, we have to patch it directly. Perhaps a better way would be to write a debounced storage adapter, but I couldn't figure out how to do that.
-
-### Patch `redux-deep-persist`
-
-This package makes blacklisting and whitelisting persist configs very simple, but we have to patch it to match `redux-persist` for the types to work.

invokeai/frontend/web/docs/README.md

@@ -37,7 +37,7 @@ From `invokeai/frontend/web/` run `yarn install` to get everything set up.
 Start everything in dev mode:
 
 1. Start the dev server: `yarn dev`
-2. Start the InvokeAI UI per usual: `invokeai --web`
+2. Start the InvokeAI Nodes backend: `python scripts/invokeai-new.py --web # run from the repo root`
 3. Point your browser to the dev server address e.g. <http://localhost:5173/>
 
 ### Production builds

invokeai/frontend/web/index.d.ts

@@ -1,98 +0,0 @@
-import React, { PropsWithChildren } from 'react';
-import { IAIPopoverProps } from '../web/src/common/components/IAIPopover';
-import { IAIIconButtonProps } from '../web/src/common/components/IAIIconButton';
-import { InvokeTabName } from 'features/ui/store/tabMap';
-
-export {};
-
-declare module 'redux-socket.io-middleware';
-
-declare global {
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  interface Array<T> {
-    /**
-     * Returns the value of the last element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate findLast calls predicate once for each element of the array, in descending
-     * order, until it finds one where predicate returns true. If such an element is found, findLast
-     * immediately returns that element value. Otherwise, findLast returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findLast<S extends T>(
-      predicate: (value: T, index: number, array: T[]) => value is S,
-      thisArg?: any
-    ): S | undefined;
-    findLast(
-      predicate: (value: T, index: number, array: T[]) => unknown,
-      thisArg?: any
-    ): T | undefined;
-
-    /**
-     * Returns the index of the last element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate findLastIndex calls predicate once for each element of the array, in descending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findLastIndex(
-      predicate: (value: T, index: number, array: T[]) => unknown,
-      thisArg?: any
-    ): number;
-  }
-  /* eslint-enable @typescript-eslint/no-explicit-any */
-}
-
-declare module '@invoke-ai/invoke-ai-ui' {
-  declare class ThemeChanger extends React.Component<ThemeChangerProps> {
-    public constructor(props: ThemeChangerProps);
-  }
-
-  declare class InvokeAiLogoComponent extends React.Component<InvokeAILogoComponentProps> {
-    public constructor(props: InvokeAILogoComponentProps);
-  }
-
-  declare class IAIPopover extends React.Component<IAIPopoverProps> {
-    public constructor(props: IAIPopoverProps);
-  }
-
-  declare class IAIIconButton extends React.Component<IAIIconButtonProps> {
-    public constructor(props: IAIIconButtonProps);
-  }
-
-  declare class SettingsModal extends React.Component<SettingsModalProps> {
-    public constructor(props: SettingsModalProps);
-  }
-
-  declare class StatusIndicator extends React.Component<StatusIndicatorProps> {
-    public constructor(props: StatusIndicatorProps);
-  }
-
-  declare class ModelSelect extends React.Component<ModelSelectProps> {
-    public constructor(props: ModelSelectProps);
-  }
-}
-
-interface InvokeProps extends PropsWithChildren {
-  apiUrl?: string;
-  disabledPanels?: string[];
-  disabledTabs?: InvokeTabName[];
-  token?: string;
-  shouldTransformUrls?: boolean;
-  shouldFetchImages?: boolean;
-}
-
-declare function Invoke(props: InvokeProps): JSX.Element;
-
-export {
-  ThemeChanger,
-  InvokeAiLogoComponent,
-  IAIPopover,
-  IAIIconButton,
-  SettingsModal,
-  StatusIndicator,
-  ModelSelect,
-};
-export = Invoke;

invokeai/frontend/web/package.json

@@ -1,11 +1,26 @@
 {
-  "name": "invoke-ai-ui",
+  "name": "@invoke-ai/invoke-ai-ui",
   "private": true,
   "version": "0.0.1",
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://npm.pkg.github.com"
+  },
+  "main": "./dist/invoke-ai-ui.umd.js",
+  "module": "./dist/invoke-ai-ui.es.js",
+  "exports": {
+    ".": {
+      "import": "./dist/invoke-ai-ui.es.js",
+      "require": "./dist/invoke-ai-ui.umd.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "prepare": "cd ../../../ && husky install invokeai/frontend/web/.husky",
     "dev": "concurrently \"vite dev\" \"yarn run theme:watch\"",
-    "dev:nodes": "concurrently \"vite dev --mode nodes\" \"yarn run theme:watch\"",
     "dev:host": "concurrently \"vite dev --host\" \"yarn run theme:watch\"",
     "build": "yarn run lint && vite build",
     "api:web": "openapi -i http://localhost:9090/openapi.json -o src/services/api --client axios --useOptions --useUnionTypes --exportSchemas true --indent 2 --request src/services/fixtures/request.ts",
@@ -40,80 +55,97 @@
   },
   "dependencies": {
     "@chakra-ui/anatomy": "^2.1.1",
-    "@chakra-ui/cli": "^2.3.0",
-    "@chakra-ui/icons": "^2.0.17",
-    "@chakra-ui/react": "^2.5.1",
-    "@chakra-ui/styled-system": "^2.6.1",
+    "@chakra-ui/icons": "^2.0.19",
+    "@chakra-ui/react": "^2.6.0",
+    "@chakra-ui/styled-system": "^2.9.0",
     "@chakra-ui/theme-tools": "^2.0.16",
     "@dagrejs/graphlib": "^2.1.12",
     "@emotion/react": "^11.10.6",
     "@emotion/styled": "^11.10.6",
+    "@floating-ui/react-dom": "^2.0.0",
     "@fontsource/inter": "^4.5.15",
-    "@reduxjs/toolkit": "^1.9.3",
+    "@reduxjs/toolkit": "^1.9.5",
+    "@roarr/browser-log-writer": "^1.1.5",
     "chakra-ui-contextmenu": "^1.0.5",
     "dateformat": "^5.0.3",
+    "downshift": "^7.6.0",
     "formik": "^2.2.9",
-    "framer-motion": "^9.0.4",
+    "framer-motion": "^10.12.4",
     "fuse.js": "^6.6.2",
-    "i18next": "^22.4.10",
+    "i18next": "^22.4.15",
     "i18next-browser-languagedetector": "^7.0.1",
-    "i18next-http-backend": "^2.1.1",
-    "konva": "^8.4.2",
-    "lodash": "^4.17.21",
-    "patch-package": "^6.5.1",
+    "i18next-http-backend": "^2.2.0",
+    "konva": "^9.0.1",
+    "lodash-es": "^4.17.21",
+    "overlayscrollbars": "^2.1.1",
+    "overlayscrollbars-react": "^0.5.0",
+    "patch-package": "^7.0.0",
     "re-resizable": "^6.9.9",
     "react": "^18.2.0",
     "react-colorful": "^5.6.1",
     "react-dom": "^18.2.0",
     "react-dropzone": "^14.2.3",
-    "react-hotkeys-hook": "4.3.5",
-    "react-i18next": "^12.1.5",
+    "react-hotkeys-hook": "4.4.0",
+    "react-i18next": "^12.2.2",
     "react-icons": "^4.7.1",
-    "react-konva": "^18.2.4",
-    "react-konva-utils": "^0.3.2",
+    "react-konva": "^18.2.7",
     "react-redux": "^8.0.5",
-    "react-transition-group": "^4.4.5",
-    "react-zoom-pan-pinch": "^2.6.1",
+    "react-resizable-panels": "^0.0.42",
+    "react-use": "^17.4.0",
+    "react-virtuoso": "^4.3.5",
+    "react-zoom-pan-pinch": "^3.0.7",
     "reactflow": "^11.7.0",
-    "redux-deep-persist": "^1.0.7",
     "redux-dynamic-middlewares": "^2.2.0",
-    "redux-persist": "^6.0.0",
+    "redux-remember": "^3.3.1",
+    "roarr": "^7.15.0",
+    "serialize-error": "^11.0.0",
     "socket.io-client": "^4.6.0",
     "use-image": "^1.1.0",
     "uuid": "^9.0.0"
   },
+  "peerDependencies": {
+    "@chakra-ui/cli": "^2.4.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "ts-toolbelt": "^9.6.0"
+  },
   "devDependencies": {
+    "@chakra-ui/cli": "^2.4.0",
     "@types/dateformat": "^5.0.0",
-    "@types/lodash": "^4.14.194",
-    "@types/react": "^18.0.28",
-    "@types/react-dom": "^18.0.11",
+    "@types/lodash-es": "^4.14.194",
+    "@types/node": "^18.16.2",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.1",
+    "@types/react-redux": "^7.1.25",
     "@types/react-transition-group": "^4.4.5",
     "@types/uuid": "^9.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.52.0",
-    "@typescript-eslint/parser": "^5.52.0",
-    "@vitejs/plugin-react-swc": "^3.2.0",
-    "axios": "^1.3.4",
+    "@typescript-eslint/eslint-plugin": "^5.59.1",
+    "@typescript-eslint/parser": "^5.59.1",
+    "@vitejs/plugin-react-swc": "^3.3.0",
+    "axios": "^1.4.0",
     "babel-plugin-transform-imports": "^2.0.0",
-    "concurrently": "^7.6.0",
-    "eslint": "^8.34.0",
-    "eslint-config-prettier": "^8.6.0",
+    "concurrently": "^8.0.1",
+    "eslint": "^8.39.0",
+    "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^4.2.1",
     "eslint-plugin-react": "^7.32.2",
     "eslint-plugin-react-hooks": "^4.6.0",
     "form-data": "^4.0.0",
     "husky": "^8.0.3",
-    "lint-staged": "^13.1.2",
+    "lint-staged": "^13.2.2",
     "madge": "^6.0.0",
     "openapi-types": "^12.1.0",
-    "openapi-typescript-codegen": "^0.23.0",
+    "openapi-typescript-codegen": "^0.24.0",
     "postinstall-postinstall": "^2.1.0",
-    "prettier": "^2.8.4",
+    "prettier": "^2.8.8",
     "rollup-plugin-visualizer": "^5.9.0",
-    "terser": "^5.16.4",
-    "typescript": "4.9.5",
-    "vite": "^4.1.2",
+    "terser": "^5.17.1",
+    "ts-toolbelt": "^9.6.0",
+    "vite": "^4.3.3",
+    "vite-plugin-css-injected-by-js": "^3.1.1",
+    "vite-plugin-dts": "^2.3.0",
     "vite-plugin-eslint": "^1.8.1",
-    "vite-tsconfig-paths": "^4.0.5",
+    "vite-tsconfig-paths": "^4.2.0",
     "yarn": "^1.22.19"
   }
 }

invokeai/frontend/web/patches/redux-deep-persist+1.0.7.patch

@@ -1,24 +0,0 @@
-diff --git a/node_modules/redux-deep-persist/lib/types.d.ts b/node_modules/redux-deep-persist/lib/types.d.ts
-index b67b8c2..7fc0fa1 100644
---- a/node_modules/redux-deep-persist/lib/types.d.ts
-+++ b/node_modules/redux-deep-persist/lib/types.d.ts
-@@ -35,6 +35,7 @@ export interface PersistConfig<S, RS = any, HSS = any, ESS = any> {
-     whitelist?: Array<string>;
-     transforms?: Array<Transform<HSS, ESS, S, RS>>;
-     throttle?: number;
-+    debounce?: number;
-     migrate?: PersistMigrate;
-     stateReconciler?: false | StateReconciler<S>;
-     getStoredState?: (config: PersistConfig<S, RS, HSS, ESS>) => Promise<PersistedState>;
-diff --git a/node_modules/redux-deep-persist/src/types.ts b/node_modules/redux-deep-persist/src/types.ts
-index 398ac19..cbc5663 100644
---- a/node_modules/redux-deep-persist/src/types.ts
-+++ b/node_modules/redux-deep-persist/src/types.ts
-@@ -91,6 +91,7 @@ export interface PersistConfig<S, RS = any, HSS = any, ESS = any> {
-     whitelist?: Array<string>;
-     transforms?: Array<Transform<HSS, ESS, S, RS>>;
-     throttle?: number;
-+    debounce?: number;
-     migrate?: PersistMigrate;
-     stateReconciler?: false | StateReconciler<S>;
-     /**

invokeai/frontend/web/patches/redux-persist+6.0.0.patch

@@ -1,116 +0,0 @@
-diff --git a/node_modules/redux-persist/es/createPersistoid.js b/node_modules/redux-persist/es/createPersistoid.js
-index 8b43b9a..184faab 100644
---- a/node_modules/redux-persist/es/createPersistoid.js
-+++ b/node_modules/redux-persist/es/createPersistoid.js
-@@ -6,6 +6,7 @@ export default function createPersistoid(config) {
-   var whitelist = config.whitelist || null;
-   var transforms = config.transforms || [];
-   var throttle = config.throttle || 0;
-+  var debounce = config.debounce || 0;
-   var storageKey = "".concat(config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX).concat(config.key);
-   var storage = config.storage;
-   var serialize;
-@@ -28,30 +29,37 @@ export default function createPersistoid(config) {
-   var timeIterator = null;
-   var writePromise = null;
- 
--  var update = function update(state) {
--    // add any changed keys to the queue
--    Object.keys(state).forEach(function (key) {
--      if (!passWhitelistBlacklist(key)) return; // is keyspace ignored? noop
-+  // Timer for debounced `update()`
-+  let timer = 0;
- 
--      if (lastState[key] === state[key]) return; // value unchanged? noop
-+  function update(state) {
-+    // Debounce the update
-+    clearTimeout(timer);
-+    timer = setTimeout(() => {
-+      // add any changed keys to the queue
-+      Object.keys(state).forEach(function (key) {
-+        if (!passWhitelistBlacklist(key)) return; // is keyspace ignored? noop
- 
--      if (keysToProcess.indexOf(key) !== -1) return; // is key already queued? noop
-+        if (lastState[key] === state[key]) return; // value unchanged? noop
- 
--      keysToProcess.push(key); // add key to queue
--    }); //if any key is missing in the new state which was present in the lastState,
--    //add it for processing too
-+        if (keysToProcess.indexOf(key) !== -1) return; // is key already queued? noop
- 
--    Object.keys(lastState).forEach(function (key) {
--      if (state[key] === undefined && passWhitelistBlacklist(key) && keysToProcess.indexOf(key) === -1 && lastState[key] !== undefined) {
--        keysToProcess.push(key);
--      }
--    }); // start the time iterator if not running (read: throttle)
-+        keysToProcess.push(key); // add key to queue
-+      }); //if any key is missing in the new state which was present in the lastState,
-+      //add it for processing too
- 
--    if (timeIterator === null) {
--      timeIterator = setInterval(processNextKey, throttle);
--    }
-+      Object.keys(lastState).forEach(function (key) {
-+        if (state[key] === undefined && passWhitelistBlacklist(key) && keysToProcess.indexOf(key) === -1 && lastState[key] !== undefined) {
-+          keysToProcess.push(key);
-+        }
-+      }); // start the time iterator if not running (read: throttle)
-+
-+      if (timeIterator === null) {
-+        timeIterator = setInterval(processNextKey, throttle);
-+      }
- 
--    lastState = state;
-+      lastState = state;
-+    }, debounce)
-   };
- 
-   function processNextKey() {
-diff --git a/node_modules/redux-persist/es/types.js.flow b/node_modules/redux-persist/es/types.js.flow
-index c50d3cd..39d8be2 100644
---- a/node_modules/redux-persist/es/types.js.flow
-+++ b/node_modules/redux-persist/es/types.js.flow
-@@ -19,6 +19,7 @@ export type PersistConfig = {
-   whitelist?: Array<string>,
-   transforms?: Array<Transform>,
-   throttle?: number,
-+  debounce?: number,
-   migrate?: (PersistedState, number) => Promise<PersistedState>,
-   stateReconciler?: false | Function,
-   getStoredState?: PersistConfig => Promise<PersistedState>, // used for migrations
-diff --git a/node_modules/redux-persist/lib/types.js.flow b/node_modules/redux-persist/lib/types.js.flow
-index c50d3cd..39d8be2 100644
---- a/node_modules/redux-persist/lib/types.js.flow
-+++ b/node_modules/redux-persist/lib/types.js.flow
-@@ -19,6 +19,7 @@ export type PersistConfig = {
-   whitelist?: Array<string>,
-   transforms?: Array<Transform>,
-   throttle?: number,
-+  debounce?: number,
-   migrate?: (PersistedState, number) => Promise<PersistedState>,
-   stateReconciler?: false | Function,
-   getStoredState?: PersistConfig => Promise<PersistedState>, // used for migrations
-diff --git a/node_modules/redux-persist/src/types.js b/node_modules/redux-persist/src/types.js
-index c50d3cd..39d8be2 100644
---- a/node_modules/redux-persist/src/types.js
-+++ b/node_modules/redux-persist/src/types.js
-@@ -19,6 +19,7 @@ export type PersistConfig = {
-   whitelist?: Array<string>,
-   transforms?: Array<Transform>,
-   throttle?: number,
-+  debounce?: number,
-   migrate?: (PersistedState, number) => Promise<PersistedState>,
-   stateReconciler?: false | Function,
-   getStoredState?: PersistConfig => Promise<PersistedState>, // used for migrations
-diff --git a/node_modules/redux-persist/types/types.d.ts b/node_modules/redux-persist/types/types.d.ts
-index b3733bc..2a1696c 100644
---- a/node_modules/redux-persist/types/types.d.ts
-+++ b/node_modules/redux-persist/types/types.d.ts
-@@ -35,6 +35,7 @@ declare module "redux-persist/es/types" {
-     whitelist?: Array<string>;
-     transforms?: Array<Transform<HSS, ESS, S, RS>>;
-     throttle?: number;
-+    debounce?: number;
-     migrate?: PersistMigrate;
-     stateReconciler?: false | StateReconciler<S>;
-     /**

invokeai/frontend/web/public/locales/en.json

@@ -25,7 +25,7 @@
     "common": {
         "hotkeysLabel": "Hotkeys",
         "themeLabel": "Theme",
-        "languagePickerLabel": "Language Picker",
+        "languagePickerLabel": "Language",
         "reportBugLabel": "Report Bug",
         "githubLabel": "Github",
         "discordLabel": "Discord",
@@ -54,7 +54,7 @@
         "img2img": "Image To Image",
         "unifiedCanvas": "Unified Canvas",
         "linear": "Linear",
-        "nodes": "Nodes",
+        "nodes": "Node Editor",
         "postprocessing": "Post Processing",
         "nodesDesc": "A node based system for the generation of images is under development currently. Stay tuned for updates about this amazing feature.",
         "postProcessing": "Post Processing",
@@ -63,7 +63,7 @@
         "postProcessDesc3": "The Invoke AI Command Line Interface offers various other features including Embiggen.",
         "training": "Training",
         "trainingDesc1": "A dedicated workflow for training your own embeddings and checkpoints using Textual Inversion and Dreambooth from the web interface.",
-        "trainingDesc2": "InvokeAI already supports training custom embeddings using Textual Inversion using the main script.",
+        "trainingDesc2": "InvokeAI already supports training custom embeddourings using Textual Inversion using the main script.",
         "upload": "Upload",
         "close": "Close",
         "cancel": "Cancel",
@@ -97,7 +97,13 @@
         "statusMergedModels": "Models Merged",
         "pinOptionsPanel": "Pin Options Panel",
         "loading": "Loading",
-        "loadingInvokeAI": "Loading Invoke AI"
+        "loadingInvokeAI": "Loading Invoke AI",
+        "random": "Random",
+        "generate": "Generate",
+        "openInNewTab": "Open in New Tab",
+        "dontAskMeAgain": "Don't ask me again",
+        "areYouSure": "Are you sure?",
+        "imagePrompt": "Image Prompt"
     },
     "gallery": {
         "generations": "Generations",
@@ -113,7 +119,10 @@
         "pinGallery": "Pin Gallery",
         "allImagesLoaded": "All Images Loaded",
         "loadMore": "Load More",
-        "noImagesInGallery": "No Images In Gallery"
+        "noImagesInGallery": "No Images In Gallery",
+        "deleteImage": "Delete Image",
+        "deleteImageBin": "Deleted images will be sent to your operating system's Bin.",
+        "deleteImagePermanent": "Deleted images cannot be restored."
     },
     "hotkeys": {
         "keyboardShortcuts": "Keyboard Shortcuts",
@@ -441,13 +450,14 @@
         "cfgScale": "CFG Scale",
         "width": "Width",
         "height": "Height",
-        "sampler": "Sampler",
+        "scheduler": "Scheduler",
         "seed": "Seed",
         "imageToImage": "Image to Image",
         "randomizeSeed": "Randomize Seed",
-        "shuffle": "Shuffle",
+        "shuffle": "Shuffle Seed",
         "noiseThreshold": "Noise Threshold",
         "perlinNoise": "Perlin Noise",
+        "noiseSettings": "Noise",
         "variations": "Variations",
         "variationAmount": "Variation Amount",
         "seedWeights": "Seed Weights",
@@ -462,6 +472,8 @@
         "scale": "Scale",
         "otherOptions": "Other Options",
         "seamlessTiling": "Seamless Tiling",
+        "seamlessXAxis": "X Axis",
+        "seamlessYAxis": "Y Axis",
         "hiresOptim": "High Res Optimization",
         "hiresStrength": "High Res Strength",
         "imageFit": "Fit Initial Image To Output Size",
@@ -505,7 +517,6 @@
         "useAll": "Use All",
         "useInitImg": "Use Initial Image",
         "info": "Info",
-        "deleteImage": "Delete Image",
         "initialImage": "Initial Image",
         "showOptionsPanel": "Show Options Panel",
         "hidePreview": "Hide Preview",
@@ -520,10 +531,19 @@
         "useCanvasBeta": "Use Canvas Beta Layout",
         "enableImageDebugging": "Enable Image Debugging",
         "useSlidersForAll": "Use Sliders For All Options",
+        "showProgressInViewer": "Show Progress Images in Viewer",
+        "antialiasProgressImages": "Antialias Progress Images",
         "resetWebUI": "Reset Web UI",
         "resetWebUIDesc1": "Resetting the web UI only resets the browser's local cache of your images and remembered settings. It does not delete any images from disk.",
         "resetWebUIDesc2": "If images aren't showing up in the gallery or something else isn't working, please try resetting before submitting an issue on GitHub.",
-        "resetComplete": "Web UI has been reset. Refresh the page to reload."
+        "resetComplete": "Web UI has been reset. Refresh the page to reload.",
+        "consoleLogLevel": "Log Level",
+        "shouldLogToConsole": "Console Logging",
+        "developer": "Developer",
+        "general": "General",
+        "generation": "Generation",
+        "ui": "User Interface",
+        "availableSchedulers": "Available Schedulers"
     },
     "toast": {
         "serverError": "Server Error",
@@ -532,13 +552,14 @@
         "canceled": "Processing Canceled",
         "tempFoldersEmptied": "Temp Folder Emptied",
         "uploadFailed": "Upload failed",
-        "uploadFailedMultipleImagesDesc": "Multiple images pasted, may only upload one image at a time",
         "uploadFailedUnableToLoadDesc": "Unable to load file",
+        "uploadFailedInvalidUploadDesc": "Must be single PNG or JPEG image",
         "downloadImageStarted": "Image Download Started",
         "imageCopied": "Image Copied",
         "imageLinkCopied": "Image Link Copied",
+        "problemCopyingImageLink": "Unable to Copy Image Link",
         "imageNotLoaded": "No Image Loaded",
-        "imageNotLoadedDesc": "No image found to send to image to image module",
+        "imageNotLoadedDesc": "Could not find image",
         "imageSavedToGallery": "Image Saved to Gallery",
         "canvasMerged": "Canvas Merged",
         "sentToImageToImage": "Sent To Image To Image",
@@ -633,6 +654,11 @@
         "betaClear": "Clear",
         "betaDarkenOutside": "Darken Outside",
         "betaLimitToBox": "Limit To Box",
-        "betaPreserveMasked": "Preserve Masked"
+        "betaPreserveMasked": "Preserve Masked",
+        "antialiasing": "Antialiasing"
+    },
+    "ui": {
+        "showProgressImages": "Show Progress Images",
+        "hideProgressImages": "Hide Progress Images"
     }
 }

invokeai/frontend/web/src/Loading.tsx

@@ -1,39 +0,0 @@
-import { Flex, Spinner, Text } from '@chakra-ui/react';
-import { useTranslation } from 'react-i18next';
-
-interface LoaderProps {
-  showText?: boolean;
-  text?: string;
-}
-
-// This component loads before the theme so we cannot use theme tokens here
-
-const Loading = (props: LoaderProps) => {
-  const { t } = useTranslation();
-  const { showText = false, text = t('common.loadingInvokeAI') } = props;
-
-  return (
-    <Flex
-      width="100vw"
-      height="100vh"
-      alignItems="center"
-      justifyContent="center"
-      bg="#121212"
-      flexDirection="column"
-      rowGap={4}
-    >
-      <Spinner color="grey" w="5rem" h="5rem" />
-      {showText && (
-        <Text
-          color="grey"
-          fontWeight="semibold"
-          fontFamily="'Inter', sans-serif"
-        >
-          {text}
-        </Text>
-      )}
-    </Flex>
-  );
-};
-
-export default Loading;

invokeai/frontend/web/src/app/App.tsx

@@ -1,100 +0,0 @@
-import ImageUploader from 'common/components/ImageUploader';
-import Console from 'features/system/components/Console';
-import ProgressBar from 'features/system/components/ProgressBar';
-import SiteHeader from 'features/system/components/SiteHeader';
-import InvokeTabs from 'features/ui/components/InvokeTabs';
-import { keepGUIAlive } from './utils';
-
-import useToastWatcher from 'features/system/hooks/useToastWatcher';
-
-import FloatingGalleryButton from 'features/ui/components/FloatingGalleryButton';
-import FloatingParametersPanelButtons from 'features/ui/components/FloatingParametersPanelButtons';
-import { Box, Flex, Grid, Portal, useColorMode } from '@chakra-ui/react';
-import { APP_HEIGHT, APP_WIDTH } from 'theme/util/constants';
-import ImageGalleryPanel from 'features/gallery/components/ImageGalleryPanel';
-import Lightbox from 'features/lightbox/components/Lightbox';
-import { useAppDispatch, useAppSelector } from './storeHooks';
-import { PropsWithChildren, useEffect } from 'react';
-import { setDisabledPanels, setDisabledTabs } from 'features/ui/store/uiSlice';
-import { InvokeTabName } from 'features/ui/store/tabMap';
-import { shouldTransformUrlsChanged } from 'features/system/store/systemSlice';
-import { setShouldFetchImages } from 'features/gallery/store/resultsSlice';
-
-keepGUIAlive();
-
-interface Props extends PropsWithChildren {
-  options: {
-    disabledPanels: string[];
-    disabledTabs: InvokeTabName[];
-    shouldTransformUrls?: boolean;
-    shouldFetchImages: boolean;
-  };
-}
-
-const App = (props: Props) => {
-  useToastWatcher();
-
-  const currentTheme = useAppSelector((state) => state.ui.currentTheme);
-  const { setColorMode } = useColorMode();
-  const dispatch = useAppDispatch();
-
-  useEffect(() => {
-    dispatch(setDisabledPanels(props.options.disabledPanels));
-  }, [dispatch, props.options.disabledPanels]);
-
-  useEffect(() => {
-    dispatch(setDisabledTabs(props.options.disabledTabs));
-  }, [dispatch, props.options.disabledTabs]);
-
-  useEffect(() => {
-    dispatch(
-      shouldTransformUrlsChanged(Boolean(props.options.shouldTransformUrls))
-    );
-  }, [dispatch, props.options.shouldTransformUrls]);
-
-  useEffect(() => {
-    dispatch(setShouldFetchImages(props.options.shouldFetchImages));
-  }, [dispatch, props.options.shouldFetchImages]);
-
-  useEffect(() => {
-    setColorMode(['light'].includes(currentTheme) ? 'light' : 'dark');
-  }, [setColorMode, currentTheme]);
-
-  return (
-    <Grid w="100vw" h="100vh">
-      <Lightbox />
-      <ImageUploader>
-        <ProgressBar />
-        <Grid
-          gap={4}
-          p={4}
-          gridAutoRows="min-content auto"
-          w={APP_WIDTH}
-          h={APP_HEIGHT}
-        >
-          {props.children || <SiteHeader />}
-          <Flex
-            gap={4}
-            w={{ base: '100vw', xl: 'full' }}
-            h="full"
-            flexDir={{ base: 'column', xl: 'row' }}
-          >
-            <InvokeTabs />
-            <ImageGalleryPanel />
-          </Flex>
-        </Grid>
-        <Box>
-          <Console />
-        </Box>
-      </ImageUploader>
-      <Portal>
-        <FloatingParametersPanelButtons />
-      </Portal>
-      <Portal>
-        <FloatingGalleryButton />
-      </Portal>
-    </Grid>
-  );
-};
-
-export default App;

invokeai/frontend/web/src/app/components/App.tsx

@@ -0,0 +1,141 @@
+import ImageUploader from 'common/components/ImageUploader';
+import SiteHeader from 'features/system/components/SiteHeader';
+import ProgressBar from 'features/system/components/ProgressBar';
+import InvokeTabs from 'features/ui/components/InvokeTabs';
+import FloatingGalleryButton from 'features/ui/components/FloatingGalleryButton';
+import FloatingParametersPanelButtons from 'features/ui/components/FloatingParametersPanelButtons';
+import { Box, Flex, Grid, Portal } from '@chakra-ui/react';
+import { APP_HEIGHT, APP_WIDTH } from 'theme/util/constants';
+import GalleryDrawer from 'features/gallery/components/GalleryPanel';
+import Lightbox from 'features/lightbox/components/Lightbox';
+import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
+import { memo, ReactNode, useCallback, useEffect, useState } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import Loading from 'common/components/Loading/Loading';
+import { useIsApplicationReady } from 'features/system/hooks/useIsApplicationReady';
+import { PartialAppConfig } from 'app/types/invokeai';
+import { configChanged } from 'features/system/store/configSlice';
+import { useFeatureStatus } from 'features/system/hooks/useFeatureStatus';
+import { useLogger } from 'app/logging/useLogger';
+import ParametersDrawer from 'features/ui/components/ParametersDrawer';
+import { languageSelector } from 'features/system/store/systemSelectors';
+import i18n from 'i18n';
+import Toaster from './Toaster';
+import GlobalHotkeys from './GlobalHotkeys';
+
+const DEFAULT_CONFIG = {};
+
+interface Props {
+  config?: PartialAppConfig;
+  headerComponent?: ReactNode;
+  setIsReady?: (isReady: boolean) => void;
+}
+
+const App = ({
+  config = DEFAULT_CONFIG,
+  headerComponent,
+  setIsReady,
+}: Props) => {
+  const language = useAppSelector(languageSelector);
+
+  const log = useLogger();
+
+  const isLightboxEnabled = useFeatureStatus('lightbox').isFeatureEnabled;
+
+  const isApplicationReady = useIsApplicationReady();
+
+  const [loadingOverridden, setLoadingOverridden] = useState(false);
+
+  const dispatch = useAppDispatch();
+
+  useEffect(() => {
+    i18n.changeLanguage(language);
+  }, [language]);
+
+  useEffect(() => {
+    log.info({ namespace: 'App', data: config }, 'Received config');
+    dispatch(configChanged(config));
+  }, [dispatch, config, log]);
+
+  const handleOverrideClicked = useCallback(() => {
+    setLoadingOverridden(true);
+  }, []);
+
+  useEffect(() => {
+    if (isApplicationReady && setIsReady) {
+      setIsReady(true);
+    }
+
+    return () => {
+      setIsReady && setIsReady(false);
+    };
+  }, [isApplicationReady, setIsReady]);
+
+  return (
+    <>
+      <Grid w="100vw" h="100vh" position="relative" overflow="hidden">
+        {isLightboxEnabled && <Lightbox />}
+        <ImageUploader>
+          <ProgressBar />
+          <Grid
+            gap={4}
+            p={4}
+            gridAutoRows="min-content auto"
+            w={APP_WIDTH}
+            h={APP_HEIGHT}
+          >
+            {headerComponent || <SiteHeader />}
+            <Flex
+              gap={4}
+              w={{ base: '100vw', xl: 'full' }}
+              h="full"
+              flexDir={{ base: 'column', xl: 'row' }}
+            >
+              <InvokeTabs />
+            </Flex>
+          </Grid>
+        </ImageUploader>
+
+        <GalleryDrawer />
+        <ParametersDrawer />
+
+        <AnimatePresence>
+          {!isApplicationReady && !loadingOverridden && (
+            <motion.div
+              key="loading"
+              initial={{ opacity: 1 }}
+              animate={{ opacity: 1 }}
+              exit={{ opacity: 0 }}
+              transition={{ duration: 0.3 }}
+              style={{ zIndex: 3 }}
+            >
+              <Box position="absolute" top={0} left={0} w="100vw" h="100vh">
+                <Loading />
+              </Box>
+              <Box
+                onClick={handleOverrideClicked}
+                position="absolute"
+                top={0}
+                right={0}
+                cursor="pointer"
+                w="2rem"
+                h="2rem"
+              />
+            </motion.div>
+          )}
+        </AnimatePresence>
+
+        <Portal>
+          <FloatingParametersPanelButtons />
+        </Portal>
+        <Portal>
+          <FloatingGalleryButton />
+        </Portal>
+      </Grid>
+      <Toaster />
+      <GlobalHotkeys />
+    </>
+  );
+};
+
+export default memo(App);

invokeai/frontend/web/src/app/components/AuxiliaryProgressIndicator.tsx

@@ -0,0 +1,44 @@
+import { Flex, Spinner, Tooltip } from '@chakra-ui/react';
+import { createSelector } from '@reduxjs/toolkit';
+import { useAppSelector } from 'app/store/storeHooks';
+import { systemSelector } from 'features/system/store/systemSelectors';
+import { memo } from 'react';
+
+const selector = createSelector(systemSelector, (system) => {
+  const { isUploading } = system;
+
+  let tooltip = '';
+
+  if (isUploading) {
+    tooltip = 'Uploading...';
+  }
+
+  return {
+    tooltip,
+    shouldShow: isUploading,
+  };
+});
+
+export const AuxiliaryProgressIndicator = () => {
+  const { shouldShow, tooltip } = useAppSelector(selector);
+
+  if (!shouldShow) {
+    return null;
+  }
+
+  return (
+    <Flex
+      sx={{
+        alignItems: 'center',
+        justifyContent: 'center',
+        color: 'base.600',
+      }}
+    >
+      <Tooltip label={tooltip} placement="right" hasArrow>
+        <Spinner />
+      </Tooltip>
+    </Flex>
+  );
+};
+
+export default memo(AuxiliaryProgressIndicator);

invokeai/frontend/web/src/app/components/GlobalHotkeys.ts

@@ -0,0 +1,87 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { RootState } from 'app/store/store';
+import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
+import { shiftKeyPressed } from 'features/ui/store/hotkeysSlice';
+import {
+  setActiveTab,
+  toggleGalleryPanel,
+  toggleParametersPanel,
+  togglePinGalleryPanel,
+  togglePinParametersPanel,
+} from 'features/ui/store/uiSlice';
+import { isEqual } from 'lodash-es';
+import React, { memo } from 'react';
+import { isHotkeyPressed, useHotkeys } from 'react-hotkeys-hook';
+
+const globalHotkeysSelector = createSelector(
+  (state: RootState) => state.hotkeys,
+  (hotkeys) => {
+    const { shift } = hotkeys;
+    return { shift };
+  },
+  {
+    memoizeOptions: {
+      resultEqualityCheck: isEqual,
+    },
+  }
+);
+
+// TODO: Does not catch keypresses while focused in an input. Maybe there is a way?
+
+/**
+ * Logical component. Handles app-level global hotkeys.
+ * @returns null
+ */
+const GlobalHotkeys: React.FC = () => {
+  const dispatch = useAppDispatch();
+  const { shift } = useAppSelector(globalHotkeysSelector);
+
+  useHotkeys(
+    '*',
+    () => {
+      if (isHotkeyPressed('shift')) {
+        !shift && dispatch(shiftKeyPressed(true));
+      } else {
+        shift && dispatch(shiftKeyPressed(false));
+      }
+    },
+    { keyup: true, keydown: true },
+    [shift]
+  );
+
+  useHotkeys('o', () => {
+    dispatch(toggleParametersPanel());
+  });
+
+  useHotkeys(['shift+o'], () => {
+    dispatch(togglePinParametersPanel());
+  });
+
+  useHotkeys('g', () => {
+    dispatch(toggleGalleryPanel());
+  });
+
+  useHotkeys(['shift+g'], () => {
+    dispatch(togglePinGalleryPanel());
+  });
+
+  useHotkeys('1', () => {
+    dispatch(setActiveTab('txt2img'));
+  });
+
+  useHotkeys('2', () => {
+    dispatch(setActiveTab('img2img'));
+  });
+
+  useHotkeys('3', () => {
+    dispatch(setActiveTab('unifiedCanvas'));
+  });
+
+  useHotkeys('4', () => {
+    dispatch(setActiveTab('nodes'));
+  });
+
+  return null;
+};
+
+export default memo(GlobalHotkeys);

invokeai/frontend/web/src/app/components/InvokeAIUI.tsx

@@ -0,0 +1,77 @@
+import React, {
+  lazy,
+  memo,
+  PropsWithChildren,
+  ReactNode,
+  useEffect,
+} from 'react';
+import { Provider } from 'react-redux';
+import { store } from 'app/store/store';
+import { OpenAPI } from 'services/api';
+
+import Loading from '../../common/components/Loading/Loading';
+import { addMiddleware, resetMiddlewares } from 'redux-dynamic-middlewares';
+import { PartialAppConfig } from 'app/types/invokeai';
+
+import '../../i18n';
+import { socketMiddleware } from 'services/events/middleware';
+
+const App = lazy(() => import('./App'));
+const ThemeLocaleProvider = lazy(() => import('./ThemeLocaleProvider'));
+
+interface Props extends PropsWithChildren {
+  apiUrl?: string;
+  token?: string;
+  config?: PartialAppConfig;
+  headerComponent?: ReactNode;
+  setIsReady?: (isReady: boolean) => void;
+}
+
+const InvokeAIUI = ({
+  apiUrl,
+  token,
+  config,
+  headerComponent,
+  setIsReady,
+}: Props) => {
+  useEffect(() => {
+    // configure API client token
+    if (token) {
+      OpenAPI.TOKEN = token;
+    }
+
+    // configure API client base url
+    if (apiUrl) {
+      OpenAPI.BASE = apiUrl;
+    }
+
+    // reset dynamically added middlewares
+    resetMiddlewares();
+
+    // TODO: at this point, after resetting the middleware, we really ought to clean up the socket
+    // stuff by calling `dispatch(socketReset())`. but we cannot dispatch from here as we are
+    // outside the provider. it's not needed until there is the possibility that we will change
+    // the `apiUrl`/`token` dynamically.
+
+    // rebuild socket middleware with token and apiUrl
+    addMiddleware(socketMiddleware());
+  }, [apiUrl, token]);
+
+  return (
+    <React.StrictMode>
+      <Provider store={store}>
+        <React.Suspense fallback={<Loading />}>
+          <ThemeLocaleProvider>
+            <App
+              config={config}
+              headerComponent={headerComponent}
+              setIsReady={setIsReady}
+            />
+          </ThemeLocaleProvider>
+        </React.Suspense>
+      </Provider>
+    </React.StrictMode>
+  );
+};
+
+export default memo(InvokeAIUI);

invokeai/frontend/web/src/app/components/ThemeLocaleProvider.tsx

@@ -1,23 +1,22 @@
-import { ChakraProvider, extendTheme } from '@chakra-ui/react';
+import {
+  ChakraProvider,
+  createLocalStorageManager,
+  extendTheme,
+} from '@chakra-ui/react';
 import { ReactNode, useEffect } from 'react';
 import { useTranslation } from 'react-i18next';
 import { theme as invokeAITheme } from 'theme/theme';
-import { RootState } from './store';
-import { useAppSelector } from './storeHooks';
+import { RootState } from 'app/store/store';
+import { useAppSelector } from 'app/store/storeHooks';
 
 import { greenTeaThemeColors } from 'theme/colors/greenTea';
 import { invokeAIThemeColors } from 'theme/colors/invokeAI';
 import { lightThemeColors } from 'theme/colors/lightTheme';
 import { oceanBlueColors } from 'theme/colors/oceanBlue';
-import '@fontsource/inter/100.css';
-import '@fontsource/inter/200.css';
-import '@fontsource/inter/300.css';
-import '@fontsource/inter/400.css';
-import '@fontsource/inter/500.css';
-import '@fontsource/inter/600.css';
-import '@fontsource/inter/700.css';
-import '@fontsource/inter/800.css';
-import '@fontsource/inter/900.css';
+
+import '@fontsource/inter/variable.css';
+import 'overlayscrollbars/overlayscrollbars.css';
+import 'theme/css/overlayscrollbars.css';
 
 type ThemeLocaleProviderProps = {
   children: ReactNode;
@@ -30,6 +29,8 @@ const THEMES = {
   ocean: oceanBlueColors,
 };
 
+const manager = createLocalStorageManager('@@invokeai-color-mode');
+
 function ThemeLocaleProvider({ children }: ThemeLocaleProviderProps) {
   const { i18n } = useTranslation();
 
@@ -49,7 +50,11 @@ function ThemeLocaleProvider({ children }: ThemeLocaleProviderProps) {
     document.body.dir = direction;
   }, [direction]);
 
-  return <ChakraProvider theme={theme}>{children}</ChakraProvider>;
+  return (
+    <ChakraProvider theme={theme} colorModeManager={manager}>
+      {children}
+    </ChakraProvider>
+  );
 }
 
 export default ThemeLocaleProvider;

invokeai/frontend/web/src/app/components/Toaster.ts

@@ -0,0 +1,65 @@
+import { useToast, UseToastOptions } from '@chakra-ui/react';
+import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
+import { toastQueueSelector } from 'features/system/store/systemSelectors';
+import { addToast, clearToastQueue } from 'features/system/store/systemSlice';
+import { useCallback, useEffect } from 'react';
+
+export type MakeToastArg = string | UseToastOptions;
+
+/**
+ * Makes a toast from a string or a UseToastOptions object.
+ * If a string is passed, the toast will have the status 'info' and will be closable with a duration of 2500ms.
+ */
+export const makeToast = (arg: MakeToastArg): UseToastOptions => {
+  if (typeof arg === 'string') {
+    return {
+      title: arg,
+      status: 'info',
+      isClosable: true,
+      duration: 2500,
+    };
+  }
+
+  return { status: 'info', isClosable: true, duration: 2500, ...arg };
+};
+
+/**
+ * Logical component. Watches the toast queue and makes toasts when the queue is not empty.
+ * @returns null
+ */
+const Toaster = () => {
+  const dispatch = useAppDispatch();
+  const toastQueue = useAppSelector(toastQueueSelector);
+  const toast = useToast();
+  useEffect(() => {
+    toastQueue.forEach((t) => {
+      toast(t);
+    });
+    toastQueue.length > 0 && dispatch(clearToastQueue());
+  }, [dispatch, toast, toastQueue]);
+
+  return null;
+};
+
+/**
+ * Returns a function that can be used to make a toast.
+ * @example
+ * const toaster = useAppToaster();
+ * toaster('Hello world!');
+ * toaster({ title: 'Hello world!', status: 'success' });
+ * @returns A function that can be used to make a toast.
+ * @see makeToast
+ * @see MakeToastArg
+ * @see UseToastOptions
+ */
+export const useAppToaster = () => {
+  const dispatch = useAppDispatch();
+  const toaster = useCallback(
+    (arg: MakeToastArg) => dispatch(addToast(makeToast(arg))),
+    [dispatch]
+  );
+
+  return toaster;
+};
+
+export default Toaster;

invokeai/frontend/web/src/app/constants.ts

@@ -1,34 +1,28 @@
 // TODO: use Enums?
 
-import { InProgressImageType } from 'features/system/store/systemSlice';
-
-// Valid samplers
-export const SAMPLERS: Array<string> = [
+export const SCHEDULERS = [
   'ddim',
-  'plms',
-  'k_lms',
-  'k_dpm_2',
-  'k_dpm_2_a',
-  'k_dpmpp_2',
-  'k_dpmpp_2_a',
-  'k_euler',
-  'k_euler_a',
-  'k_heun',
-];
+  'lms',
+  'euler',
+  'euler_k',
+  'euler_a',
+  'dpmpp_2s',
+  'dpmpp_2m',
+  'dpmpp_2m_k',
+  'kdpm_2',
+  'kdpm_2_a',
+  'deis',
+  'ddpm',
+  'pndm',
+  'heun',
+  'heun_k',
+  'unipc',
+] as const;
 
-// Valid Diffusers Samplers
-export const DIFFUSERS_SAMPLERS: Array<string> = [
-  'ddim',
-  'plms',
-  'k_lms',
-  'dpmpp_2',
-  'k_dpm_2',
-  'k_dpm_2_a',
-  'k_dpmpp_2',
-  'k_euler',
-  'k_euler_a',
-  'k_heun',
-];
+export type Scheduler = (typeof SCHEDULERS)[number];
+
+export const isScheduler = (x: string): x is Scheduler =>
+  SCHEDULERS.includes(x as Scheduler);
 
 // Valid image widths
 export const WIDTHS: Array<number> = Array.from(Array(64)).map(
@@ -48,17 +42,8 @@ export const UPSCALING_LEVELS: Array<{ key: string; value: number }> = [
 
 export const NUMPY_RAND_MIN = 0;
 
-export const NUMPY_RAND_MAX = 4294967295;
+export const NUMPY_RAND_MAX = 2147483647;
 
 export const FACETOOL_TYPES = ['gfpgan', 'codeformer'] as const;
 
-export const IN_PROGRESS_IMAGE_TYPES: Array<{
-  key: string;
-  value: InProgressImageType;
-}> = [
-  { key: 'None', value: 'none' },
-  { key: 'Fast', value: 'latents' },
-  { key: 'Accurate', value: 'full-res' },
-];
-
 export const NODE_MIN_WIDTH = 250;

invokeai/frontend/web/src/app/invokeai.d.ts

@@ -1,336 +0,0 @@
-/**
- * Types for images, the things they are made of, and the things
- * they make up.
- *
- * Generated images are txt2img and img2img images. They may have
- * had additional postprocessing done on them when they were first
- * generated.
- *
- * Postprocessed images are images which were not generated here
- * but only postprocessed by the app. They only get postprocessing
- * metadata and have a different image type, e.g. 'esrgan' or
- * 'gfpgan'.
- */
-
-import { InvokeTabName } from 'features/ui/store/tabMap';
-import { IRect } from 'konva/lib/types';
-import { ImageMetadata, ImageType } from 'services/api';
-import { AnyInvocation } from 'services/events/types';
-
-/**
- * TODO:
- * Once an image has been generated, if it is postprocessed again,
- * additional postprocessing steps are added to its postprocessing
- * array.
- *
- * TODO: Better documentation of types.
- */
-
-export declare type PromptItem = {
-  prompt: string;
-  weight: number;
-};
-
-// TECHDEBT: We need to retain compatibility with plain prompt strings and the structure Prompt type
-export declare type Prompt = Array<PromptItem> | string;
-
-export declare type SeedWeightPair = {
-  seed: number;
-  weight: number;
-};
-
-export declare type SeedWeights = Array<SeedWeightPair>;
-
-// All generated images contain these metadata.
-export declare type CommonGeneratedImageMetadata = {
-  postprocessing: null | Array<ESRGANMetadata | GFPGANMetadata>;
-  sampler:
-    | 'ddim'
-    | 'k_dpm_2_a'
-    | 'k_dpm_2'
-    | 'k_dpmpp_2_a'
-    | 'k_dpmpp_2'
-    | 'k_euler_a'
-    | 'k_euler'
-    | 'k_heun'
-    | 'k_lms'
-    | 'plms';
-  prompt: Prompt;
-  seed: number;
-  variations: SeedWeights;
-  steps: number;
-  cfg_scale: number;
-  width: number;
-  height: number;
-  seamless: boolean;
-  hires_fix: boolean;
-  extra: null | Record<string, never>; // Pending development of RFC #266
-};
-
-// txt2img and img2img images have some unique attributes.
-export declare type Txt2ImgMetadata = GeneratedImageMetadata & {
-  type: 'txt2img';
-};
-
-export declare type Img2ImgMetadata = GeneratedImageMetadata & {
-  type: 'img2img';
-  orig_hash: string;
-  strength: number;
-  fit: boolean;
-  init_image_path: string;
-  mask_image_path?: string;
-};
-
-// Superset of  generated image metadata types.
-export declare type GeneratedImageMetadata = Txt2ImgMetadata | Img2ImgMetadata;
-
-// All post processed images contain these metadata.
-export declare type CommonPostProcessedImageMetadata = {
-  orig_path: string;
-  orig_hash: string;
-};
-
-// esrgan and gfpgan images have some unique attributes.
-export declare type ESRGANMetadata = CommonPostProcessedImageMetadata & {
-  type: 'esrgan';
-  scale: 2 | 4;
-  strength: number;
-  denoise_str: number;
-};
-
-export declare type FacetoolMetadata = CommonPostProcessedImageMetadata & {
-  type: 'gfpgan' | 'codeformer';
-  strength: number;
-  fidelity?: number;
-};
-
-// Superset of all postprocessed image metadata types..
-export declare type PostProcessedImageMetadata =
-  | ESRGANMetadata
-  | FacetoolMetadata;
-
-// Metadata includes the system config and image metadata.
-export declare type Metadata = SystemGenerationMetadata & {
-  image: GeneratedImageMetadata | PostProcessedImageMetadata;
-};
-
-// An Image has a UUID, url, modified timestamp, width, height and maybe metadata
-export declare type _Image = {
-  uuid: string;
-  url: string;
-  thumbnail: string;
-  mtime: number;
-  metadata?: Metadata;
-  width: number;
-  height: number;
-  category: GalleryCategory;
-  isBase64?: boolean;
-  dreamPrompt?: 'string';
-  name?: string;
-};
-
-/**
- * ResultImage
- */
-export declare type Image = {
-  name: string;
-  type: ImageType;
-  url: string;
-  thumbnail: string;
-  metadata: ImageMetadata;
-};
-
-// GalleryImages is an array of Image.
-export declare type GalleryImages = {
-  images: Array<_Image>;
-};
-
-/**
- * Types related to the system status.
- */
-
-// This represents the processing status of the backend.
-export declare type SystemStatus = {
-  isProcessing: boolean;
-  currentStep: number;
-  totalSteps: number;
-  currentIteration: number;
-  totalIterations: number;
-  currentStatus: string;
-  currentStatusHasSteps: boolean;
-  hasError: boolean;
-};
-
-export declare type SystemGenerationMetadata = {
-  model: string;
-  model_weights?: string;
-  model_id?: string;
-  model_hash: string;
-  app_id: string;
-  app_version: string;
-};
-
-export declare type SystemConfig = SystemGenerationMetadata & {
-  model_list: ModelList;
-  infill_methods: string[];
-};
-
-export declare type ModelStatus = 'active' | 'cached' | 'not loaded';
-
-export declare type Model = {
-  status: ModelStatus;
-  description: string;
-  weights: string;
-  config?: string;
-  vae?: string;
-  width?: number;
-  height?: number;
-  default?: boolean;
-  format?: string;
-};
-
-export declare type DiffusersModel = {
-  status: ModelStatus;
-  description: string;
-  repo_id?: string;
-  path?: string;
-  vae?: {
-    repo_id?: string;
-    path?: string;
-  };
-  format?: string;
-  default?: boolean;
-};
-
-export declare type ModelList = Record<string, Model & DiffusersModel>;
-
-export declare type FoundModel = {
-  name: string;
-  location: string;
-};
-
-export declare type InvokeModelConfigProps = {
-  name: string | undefined;
-  description: string | undefined;
-  config: string | undefined;
-  weights: string | undefined;
-  vae: string | undefined;
-  width: number | undefined;
-  height: number | undefined;
-  default: boolean | undefined;
-  format: string | undefined;
-};
-
-export declare type InvokeDiffusersModelConfigProps = {
-  name: string | undefined;
-  description: string | undefined;
-  repo_id: string | undefined;
-  path: string | undefined;
-  default: boolean | undefined;
-  format: string | undefined;
-  vae: {
-    repo_id: string | undefined;
-    path: string | undefined;
-  };
-};
-
-export declare type InvokeModelConversionProps = {
-  model_name: string;
-  save_location: string;
-  custom_location: string | null;
-};
-
-export declare type InvokeModelMergingProps = {
-  models_to_merge: string[];
-  alpha: number;
-  interp: 'weighted_sum' | 'sigmoid' | 'inv_sigmoid' | 'add_difference';
-  force: boolean;
-  merged_model_name: string;
-  model_merge_save_path: string | null;
-};
-
-/**
- * These types type data received from the server via socketio.
- */
-
-export declare type ModelChangeResponse = {
-  model_name: string;
-  model_list: ModelList;
-};
-
-export declare type ModelConvertedResponse = {
-  converted_model_name: string;
-  model_list: ModelList;
-};
-
-export declare type ModelsMergedResponse = {
-  merged_models: string[];
-  merged_model_name: string;
-  model_list: ModelList;
-};
-
-export declare type ModelAddedResponse = {
-  new_model_name: string;
-  model_list: ModelList;
-  update: boolean;
-};
-
-export declare type ModelDeletedResponse = {
-  deleted_model_name: string;
-  model_list: ModelList;
-};
-
-export declare type FoundModelResponse = {
-  search_folder: string;
-  found_models: FoundModel[];
-};
-
-export declare type SystemStatusResponse = SystemStatus;
-
-export declare type SystemConfigResponse = SystemConfig;
-
-export declare type ImageResultResponse = Omit<_Image, 'uuid'> & {
-  boundingBox?: IRect;
-  generationMode: InvokeTabName;
-};
-
-export declare type ImageUploadResponse = {
-  // image: Omit<Image, 'uuid' | 'metadata' | 'category'>;
-  url: string;
-  mtime: number;
-  width: number;
-  height: number;
-  thumbnail: string;
-  // bbox: [number, number, number, number];
-};
-
-export declare type ErrorResponse = {
-  message: string;
-  additionalData?: string;
-};
-
-export declare type GalleryImagesResponse = {
-  images: Array<Omit<_Image, 'uuid'>>;
-  areMoreImagesAvailable: boolean;
-  category: GalleryCategory;
-};
-
-export declare type ImageDeletedResponse = {
-  uuid: string;
-  url: string;
-  category: GalleryCategory;
-};
-
-export declare type ImageUrlResponse = {
-  url: string;
-};
-
-export declare type UploadImagePayload = {
-  file: File;
-  destination?: ImageUploadDestination;
-};
-
-export declare type UploadOutpaintingMergeImagePayload = {
-  dataURL: string;
-  name: string;
-};