Merge branch 'main' into dev/pytorch2

.github/CODEOWNERS

@@ -1,16 +1,16 @@
 # continuous integration
-/.github/workflows/  @lstein @blessedcoolant
+/.github/workflows/ @mauwii @lstein @blessedcoolant
 
 # documentation
-/docs/ @lstein @blessedcoolant @hipsterusername
-/mkdocs.yml @lstein  @blessedcoolant
+/docs/ @lstein @mauwii @tildebyte @blessedcoolant
+/mkdocs.yml @lstein @mauwii @blessedcoolant
 
 # nodes
 /invokeai/app/ @Kyle0654 @blessedcoolant
 
 # installation and configuration
-/pyproject.toml  @lstein @blessedcoolant
-/docker/  @lstein @blessedcoolant
+/pyproject.toml @mauwii @lstein @blessedcoolant
+/docker/ @mauwii @lstein @blessedcoolant
 /scripts/ @ebr @lstein
 /installer/ @lstein @ebr
 /invokeai/assets @lstein @ebr
@@ -18,17 +18,17 @@
 /invokeai/version @lstein @blessedcoolant
 
 # web ui
-/invokeai/frontend @blessedcoolant @psychedelicious @lstein @maryhipp
-/invokeai/backend @blessedcoolant @psychedelicious @lstein @maryhipp
+/invokeai/frontend @blessedcoolant @psychedelicious @lstein
+/invokeai/backend @blessedcoolant @psychedelicious @lstein
 
 # generation, model management, postprocessing
-/invokeai/backend  @damian0815 @lstein @blessedcoolant @jpphoto @gregghelt2 @StAlKeR7779
+/invokeai/backend @keturn @damian0815 @lstein @blessedcoolant @jpphoto
 
 # front ends
 /invokeai/frontend/CLI @lstein
-/invokeai/frontend/install @lstein @ebr  
-/invokeai/frontend/merge @lstein @blessedcoolant 
-/invokeai/frontend/training @lstein @blessedcoolant 
-/invokeai/frontend/web @psychedelicious @blessedcoolant @maryhipp 
+/invokeai/frontend/install @lstein @ebr @mauwii 
+/invokeai/frontend/merge @lstein @blessedcoolant @hipsterusername
+/invokeai/frontend/training @lstein @blessedcoolant @hipsterusername
+/invokeai/frontend/web @psychedelicious @blessedcoolant
 
 

.github/stale.yaml

@@ -1,19 +0,0 @@
-# Number of days of inactivity before an issue becomes stale
-daysUntilStale: 28
-# Number of days of inactivity before a stale issue is closed
-daysUntilClose: 14
-# Issues with these labels will never be considered stale
-exemptLabels:
-  - pinned
-  - security
-# Label to use when marking an issue as stale
-staleLabel: stale
-# Comment to post when marking an issue as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs. Please
-  update the ticket if this is still a problem on the latest release.
-# Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: >
-  Due to inactivity, this issue has been automatically closed. If this is
-  still a problem on the latest release, please recreate the issue.

.github/workflows/mkdocs-material.yml

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

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

@@ -80,6 +80,11 @@ jobs:
         uses: actions/checkout@v3
 
       - name: set test prompt to main branch validation
+        if: ${{ github.ref == 'refs/heads/main' }}
+        run: echo "TEST_PROMPTS=tests/preflight_prompts.txt" >> ${{ matrix.github-env }}
+
+      - name: set test prompt to Pull Request validation
+        if: ${{ github.ref != 'refs/heads/main' }}
         run: echo "TEST_PROMPTS=tests/validate_pr_prompt.txt" >> ${{ matrix.github-env }}
 
       - name: setup python
@@ -100,6 +105,12 @@ 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:
@@ -118,21 +129,15 @@ jobs:
           HF_HUB_OFFLINE: 1
           HF_DATASETS_OFFLINE: 1
           TRANSFORMERS_OFFLINE: 1
-          INVOKEAI_OUTDIR: ${{ github.workspace }}/results
         run: >
           invokeai
           --no-patchmatch
           --no-nsfw_checker
-          --precision=float32
-          --always_use_cpu
-          --use_memory_db
-          --outdir ${{ env.INVOKEAI_OUTDIR }}/${{ matrix.python-version }}/${{ matrix.pytorch }}
           --from_file ${{ env.TEST_PROMPTS }}
+          --outdir ${{ env.INVOKEAI_OUTDIR }}/${{ matrix.python-version }}/${{ matrix.pytorch }}
 
       - name: Archive results
         id: archive-results
-        env:
-          INVOKEAI_OUTDIR: ${{ github.workspace }}/results
         uses: actions/upload-artifact@v3
         with:
           name: results

.gitignore

@@ -9,8 +9,6 @@ models/ldm/stable-diffusion-v1/model.ckpt
 configs/models.user.yaml
 config/models.user.yml
 invokeai.init
-.version
-.last_model
 
 # ignore the Anaconda/Miniconda installer used while building Docker image
 anaconda.sh
@@ -201,8 +199,6 @@ checkpoints
 # If it's a Mac
 .DS_Store
 
-invokeai/frontend/web/dist/*
-
 # Let the frontend manage its own gitignore
 !invokeai/frontend/web/*
 

README.md

@@ -33,8 +33,6 @@
 
 </div>
 
-_**Note: The UI is not fully functional on `main`. If you need a stable UI based on `main`, use the `pre-nodes` tag while we [migrate to a new backend](https://github.com/invoke-ai/InvokeAI/discussions/3246).**_
-
 InvokeAI is a leading creative engine built to empower professionals and enthusiasts alike. Generate and create stunning visual media using the latest AI-driven technologies. InvokeAI offers an industry leading Web Interface, interactive Command Line Interface, and also serves as the foundation for multiple commercial products.
 
 **Quick links**: [[How to Install](https://invoke-ai.github.io/InvokeAI/#installation)] [<a href="https://discord.gg/ZmtBAhwWhy">Discord Server</a>] [<a href="https://invoke-ai.github.io/InvokeAI/">Documentation and Tutorials</a>] [<a href="https://github.com/invoke-ai/InvokeAI/">Code and Downloads</a>] [<a href="https://github.com/invoke-ai/InvokeAI/issues">Bug Reports</a>] [<a href="https://github.com/invoke-ai/InvokeAI/discussions">Discussion, Ideas & Q&A</a>]
@@ -86,7 +84,7 @@ installing lots of models.
 
 6. Wait while the installer does its thing. After installing the software,
 the installer will launch a script that lets you configure InvokeAI and
-select a set of starting image generation models.
+select a set of starting image generaiton models.
 
 7. Find the folder that InvokeAI was installed into (it is not the
 same as the unpacked zip file directory!) The default location of this
@@ -150,11 +148,6 @@ not supported.
     pip install InvokeAI --use-pep517 --extra-index-url https://download.pytorch.org/whl/rocm5.4.2
     ```
 
-    _For non-GPU systems:_
-    ```terminal
-    pip install InvokeAI --use-pep517 --extra-index-url https://download.pytorch.org/whl/cpu
-    ``` 
-
     _For Macintoshes, either Intel or M1/M2:_
 
     ```sh

docs/contributing/INVOCATIONS.md

@@ -1,18 +1,10 @@
 # Invocations
 
-Invocations represent a single operation, its inputs, and its outputs. These
-operations and their outputs can be chained together to generate and modify
-images.
+Invocations represent a single operation, its inputs, and its outputs. These operations and their outputs can be chained together to generate and modify images.
 
 ## Creating a new invocation
 
-To create a new invocation, either find the appropriate module file in
-`/ldm/invoke/app/invocations` to add your invocation to, or create a new one in
-that folder. All invocations in that folder will be discovered and made
-available to the CLI and API automatically. Invocations make use of
-[typing](https://docs.python.org/3/library/typing.html) and
-[pydantic](https://pydantic-docs.helpmanual.io/) for validation and integration
-into the CLI and API.
+To create a new invocation, either find the appropriate module file in `/ldm/invoke/app/invocations` to add your invocation to, or create a new one in that folder. All invocations in that folder will be discovered and made available to the CLI and API automatically. Invocations make use of [typing](https://docs.python.org/3/library/typing.html) and [pydantic](https://pydantic-docs.helpmanual.io/) for validation and integration into the CLI and API.
 
 An invocation looks like this:
 
@@ -49,54 +41,34 @@ class UpscaleInvocation(BaseInvocation):
 Each portion is important to implement correctly.
 
 ### Class definition and type
-
 ```py
 class UpscaleInvocation(BaseInvocation):
     """Upscales an image."""
     type: Literal['upscale'] = 'upscale'
 ```
-
-All invocations must derive from `BaseInvocation`. They should have a docstring
-that declares what they do in a single, short line. They should also have a
-`type` with a type hint that's `Literal["command_name"]`, where `command_name`
-is what the user will type on the CLI or use in the API to create this
-invocation. The `command_name` must be unique. The `type` must be assigned to
-the value of the literal in the type hint.
+All invocations must derive from `BaseInvocation`. They should have a docstring that declares what they do in a single, short line. They should also have a `type` with a type hint that's `Literal["command_name"]`, where `command_name` is what the user will type on the CLI or use in the API to create this invocation. The `command_name` must be unique. The `type` must be assigned to the value of the literal in the type hint.
 
 ### Inputs
-
 ```py
     # Inputs
     image: Union[ImageField,None] = Field(description="The input image")
     strength: float               = Field(default=0.75, gt=0, le=1, description="The strength")
     level: Literal[2,4]           = Field(default=2, description="The upscale level")
 ```
+Inputs consist of three parts: a name, a type hint, and a `Field` with default, description, and validation information. For example:
+| Part | Value | Description |
+| ---- | ----- | ----------- |
+| Name | `strength` | This field is referred to as `strength` |
+| Type Hint | `float` | This field must be of type `float` |
+| Field | `Field(default=0.75, gt=0, le=1, description="The strength")` | The default value is `0.75`, the value must be in the range (0,1], and help text will show "The strength" for this field. |
 
-Inputs consist of three parts: a name, a type hint, and a `Field` with default,
-description, and validation information. For example:
+Notice that `image` has type `Union[ImageField,None]`. The `Union` allows this field to be parsed with `None` as a value, which enables linking to previous invocations. All fields should either provide a default value or allow `None` as a value, so that they can be overwritten with a linked output from another invocation.
 
-| Part      | Value                                                         | Description                                                                                                               |
-| --------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| Name      | `strength`                                                    | This field is referred to as `strength`                                                                                   |
-| Type Hint | `float`                                                       | This field must be of type `float`                                                                                        |
-| Field     | `Field(default=0.75, gt=0, le=1, description="The strength")` | The default value is `0.75`, the value must be in the range (0,1], and help text will show "The strength" for this field. |
+The special type `ImageField` is also used here. All images are passed as `ImageField`, which protects them from pydantic validation errors (since images only ever come from links).
 
-Notice that `image` has type `Union[ImageField,None]`. The `Union` allows this
-field to be parsed with `None` as a value, which enables linking to previous
-invocations. All fields should either provide a default value or allow `None` as
-a value, so that they can be overwritten with a linked output from another
-invocation.
-
-The special type `ImageField` is also used here. All images are passed as
-`ImageField`, which protects them from pydantic validation errors (since images
-only ever come from links).
-
-Finally, note that for all linking, the `type` of the linked fields must match.
-If the `name` also matches, then the field can be **automatically linked** to a
-previous invocation by name and matching.
+Finally, note that for all linking, the `type` of the linked fields must match. If the `name` also matches, then the field can be **automatically linked** to a previous invocation by name and matching.
 
 ### Invoke Function
-
 ```py
     def invoke(self, context: InvocationContext) -> ImageOutput:
         image = context.services.images.get(self.image.image_type, self.image.image_name)
@@ -116,22 +88,13 @@ previous invocation by name and matching.
             image = ImageField(image_type = image_type, image_name = image_name)
         )
 ```
+The `invoke` function is the last portion of an invocation. It is provided an `InvocationContext` which contains services to perform work as well as a `session_id` for use as needed. It should return a class with output values that derives from `BaseInvocationOutput`.
 
-The `invoke` function is the last portion of an invocation. It is provided an
-`InvocationContext` which contains services to perform work as well as a
-`session_id` for use as needed. It should return a class with output values that
-derives from `BaseInvocationOutput`.
+Before being called, the invocation will have all of its fields set from defaults, inputs, and finally links (overriding in that order).
 
-Before being called, the invocation will have all of its fields set from
-defaults, inputs, and finally links (overriding in that order).
-
-Assume that this invocation may be running simultaneously with other
-invocations, may be running on another machine, or in other interesting
-scenarios. If you need functionality, please provide it as a service in the
-`InvocationServices` class, and make sure it can be overridden.
+Assume that this invocation may be running simultaneously with other invocations, may be running on another machine, or in other interesting scenarios. If you need functionality, please provide it as a service in the `InvocationServices` class, and make sure it can be overridden.
 
 ### Outputs
-
 ```py
 class ImageOutput(BaseInvocationOutput):
     """Base class for invocations that output an image"""
@@ -139,64 +102,4 @@ class ImageOutput(BaseInvocationOutput):
 
     image: ImageField = Field(default=None, description="The output image")
 ```
-
-Output classes look like an invocation class without the invoke method. Prefer
-to use an existing output class if available, and prefer to name inputs the same
-as outputs when possible, to promote automatic invocation linking.
-
-## Schema Generation
-
-Invocation, output and related classes are used to generate an OpenAPI schema.
-
-### Required Properties
-
-The schema generation treat all properties with default values as optional. This
-makes sense internally, but when when using these classes via the generated
-schema, we end up with e.g. the `ImageOutput` class having its `image` property
-marked as optional.
-
-We know that this property will always be present, so the additional logic
-needed to always check if the property exists adds a lot of extraneous cruft.
-
-To fix this, we can leverage `pydantic`'s
-[schema customisation](https://docs.pydantic.dev/usage/schema/#schema-customization)
-to mark properties that we know will always be present as required.
-
-Here's that `ImageOutput` class, without the needed schema customisation:
-
-```python
-class ImageOutput(BaseInvocationOutput):
-    """Base class for invocations that output an image"""
-
-    type: Literal["image"] = "image"
-    image:      ImageField = Field(default=None, description="The output image")
-```
-
-The generated OpenAPI schema, and all clients/types generated from it, will have
-the `type` and `image` properties marked as optional, even though we know they
-will always have a value by the time we can interact with them via the API.
-
-Here's the same class, but with the schema customisation added:
-
-```python
-class ImageOutput(BaseInvocationOutput):
-    """Base class for invocations that output an image"""
-
-    type: Literal["image"] = "image"
-    image:      ImageField = Field(default=None, description="The output image")
-
-    class Config:
-        schema_extra = {
-            'required': [
-                'type',
-                'image',
-            ]
-        }
-```
-
-The resultant schema (and any API client or types generated from it) will now
-have see `type` as string literal `"image"` and `image` as an `ImageField`
-object.
-
-See this `pydantic` issue for discussion on this solution:
-<https://github.com/pydantic/pydantic/discussions/4577>
+Output classes look like an invocation class without the invoke method. Prefer to use an existing output class if available, and prefer to name inputs the same as outputs when possible, to promote automatic invocation linking.

docs/features/NSFW.md

@@ -32,7 +32,7 @@ turned on and off on the command line using `--nsfw_checker` and
 At installation time, InvokeAI will ask whether the checker should be
 activated by default (neither argument given on the command line). The
 response is stored in the InvokeAI initialization file (usually
-`invokeai.init` in your home directory). You can change the default at any
+`.invokeai` in your home directory). You can change the default at any
 time by opening this file in a text editor and commenting or
 uncommenting the line `--nsfw_checker`.
 

docs/installation/010_INSTALL_AUTOMATED.md

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

docs/installation/020_INSTALL_MANUAL.md

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

docs/installation/050_INSTALLING_MODELS.md

@@ -50,7 +50,7 @@ subset that are currently installed are found in
 |stable-diffusion-1.5|runwayml/stable-diffusion-v1-5|Stable Diffusion version 1.5 diffusers model (4.27 GB)|https://huggingface.co/runwayml/stable-diffusion-v1-5 |
 |sd-inpainting-1.5|runwayml/stable-diffusion-inpainting|RunwayML SD 1.5 model optimized for inpainting, diffusers version (4.27 GB)|https://huggingface.co/runwayml/stable-diffusion-inpainting |
 |stable-diffusion-2.1|stabilityai/stable-diffusion-2-1|Stable Diffusion version 2.1 diffusers model, trained on 768 pixel images (5.21 GB)|https://huggingface.co/stabilityai/stable-diffusion-2-1 |
-|sd-inpainting-2.0|stabilityai/stable-diffusion-2-inpainting|Stable Diffusion version 2.0 inpainting model (5.21 GB)|https://huggingface.co/stabilityai/stable-diffusion-2-inpainting |
+|sd-inpainting-2.0|stabilityai/stable-diffusion-2-1|Stable Diffusion version 2.0 inpainting model (5.21 GB)|https://huggingface.co/stabilityai/stable-diffusion-2-1 |
 |analog-diffusion-1.0|wavymulder/Analog-Diffusion|An SD-1.5 model trained on diverse analog photographs (2.13 GB)|https://huggingface.co/wavymulder/Analog-Diffusion |
 |deliberate-1.0|XpucT/Deliberate|Versatile model that produces detailed images up to 768px (4.27 GB)|https://huggingface.co/XpucT/Deliberate |
 |d&d-diffusion-1.0|0xJustin/Dungeons-and-Diffusion|Dungeons & Dragons characters (2.13 GB)|https://huggingface.co/0xJustin/Dungeons-and-Diffusion |

installer/lib/installer.py

@@ -247,8 +247,8 @@ class InvokeAiInstance:
             pip[
                 "install",
                 "--require-virtualenv",
-                "torch~=2.0.0",
-                "torchvision>=0.14.1",
+                "torch",
+                "torchvision",
                 "--force-reinstall",
                 "--find-links" if find_links is not None else None,
                 find_links,
@@ -461,8 +461,7 @@ def get_torch_source() -> (Union[str, None],str):
             url = "https://download.pytorch.org/whl/cpu"
 
     if device == 'cuda':
-        url = 'https://download.pytorch.org/whl/cu117'
-        optional_modules = '[xformers]'
+        url = 'https://download.pytorch.org/whl/cu118'
 
     # in all other cases, Torch wheels should be coming from PyPi as of Torch 1.13
 

invokeai/app/api/dependencies.py

@@ -1,20 +1,15 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-from logging import Logger
 import os
-from invokeai.app.services.image_record_storage import SqliteImageRecordStorage
-from invokeai.app.services.images import ImageService
-from invokeai.app.services.metadata import CoreMetadataService
-from invokeai.app.services.resource_name import SimpleNameService
-from invokeai.app.services.urls import LocalUrlService
-from invokeai.backend.util.logging import InvokeAILogger
+from argparse import Namespace
 
-from ..services.default_graphs import create_system_graphs
 from ..services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
+
+from ...backend import Globals
 from ..services.model_manager_initializer import get_model_manager
 from ..services.restoration_services import RestorationServices
-from ..services.graph import GraphExecutionState, LibraryGraph
-from ..services.image_file_storage import DiskImageFileStorage
+from ..services.graph import GraphExecutionState
+from ..services.image_storage import DiskImageStorage
 from ..services.invocation_queue import MemoryInvocationQueue
 from ..services.invocation_services import InvocationServices
 from ..services.invoker import Invoker
@@ -39,17 +34,21 @@ def check_internet() -> bool:
         return False
 
 
-logger = InvokeAILogger.getLogger()
-
-
 class ApiDependencies:
     """Contains and initializes all dependencies for the API"""
 
     invoker: Invoker = None
 
     @staticmethod
-    def initialize(config, event_handler_id: int, logger: Logger = logger):
-        logger.info(f"Internet connectivity is {config.internet_available}")
+    def initialize(config, event_handler_id: int):
+        Globals.try_patchmatch = config.patchmatch
+        Globals.always_use_cpu = config.always_use_cpu
+        Globals.internet_available = config.internet_available and check_internet()
+        Globals.disable_xformers = not config.xformers
+        Globals.ckpt_convert = config.ckpt_convert
+
+        # TODO: Use a logger
+        print(f">> Internet connectivity is {Globals.internet_available}")
 
         events = FastAPIEventService(event_handler_id)
 
@@ -57,50 +56,26 @@ class ApiDependencies:
             os.path.join(os.path.dirname(__file__), "../../../../outputs")
         )
 
+        latents = ForwardCacheLatentsStorage(DiskLatentsStorage(f'{output_folder}/latents'))
+
+        images = DiskImageStorage(f'{output_folder}/images')
+
         # TODO: build a file/path manager?
         db_location = os.path.join(output_folder, "invokeai.db")
 
-        graph_execution_manager = SqliteItemStorage[GraphExecutionState](
-            filename=db_location, table_name="graph_executions"
-        )
-
-        urls = LocalUrlService()
-        metadata = CoreMetadataService()
-        image_record_storage = SqliteImageRecordStorage(db_location)
-        image_file_storage = DiskImageFileStorage(f"{output_folder}/images")
-        names = SimpleNameService()
-        latents = ForwardCacheLatentsStorage(
-            DiskLatentsStorage(f"{output_folder}/latents")
-        )
-
-        images = ImageService(
-            image_record_storage=image_record_storage,
-            image_file_storage=image_file_storage,
-            metadata=metadata,
-            url=urls,
-            logger=logger,
-            names=names,
-            graph_execution_manager=graph_execution_manager,
-        )
-
         services = InvocationServices(
-            model_manager=get_model_manager(config, logger),
+            model_manager=get_model_manager(config),
             events=events,
             latents=latents,
             images=images,
             queue=MemoryInvocationQueue(),
-            graph_library=SqliteItemStorage[LibraryGraph](
-                filename=db_location, table_name="graphs"
+            graph_execution_manager=SqliteItemStorage[GraphExecutionState](
+                filename=db_location, table_name="graph_executions"
             ),
-            graph_execution_manager=graph_execution_manager,
             processor=DefaultInvocationProcessor(),
-            restoration=RestorationServices(config, logger),
-            configuration=config,
-            logger=logger,
+            restoration=RestorationServices(config),
         )
 
-        create_system_graphs(services.graph_library)
-
         ApiDependencies.invoker = Invoker(services)
 
     @staticmethod

invokeai/app/api/events.py

@@ -45,7 +45,7 @@ class FastAPIEventService(EventServiceBase):
                 )
 
             except Empty:
-                await asyncio.sleep(0.1)
+                await asyncio.sleep(0.001)
                 pass
 
             except asyncio.CancelledError as e:

invokeai/app/api/routers/images.py

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

invokeai/app/api/routers/models.py

@@ -1,12 +1,10 @@
-# 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)
 
-import shutil
-import asyncio
 from typing import Annotated, Any, List, Literal, Optional, Union
 
-from fastapi.routing import APIRouter, HTTPException
+from fastapi.routing import APIRouter
 from pydantic import BaseModel, Field, parse_obj_as
-from pathlib import Path
+
 from ..dependencies import ApiDependencies
 
 models_router = APIRouter(prefix="/v1/models", tags=["models"])
@@ -17,9 +15,11 @@ class VaeRepo(BaseModel):
     path: Optional[str] = Field(description="The path to the VAE")
     subfolder: Optional[str] = Field(description="The subfolder to use for this VAE")
 
+
 class ModelInfo(BaseModel):
     description: Optional[str] = Field(description="A description of the model")
     
+
 class CkptModelInfo(ModelInfo):
     format: Literal['ckpt'] = 'ckpt'
 
@@ -29,6 +29,7 @@ class CkptModelInfo(ModelInfo):
     width: Optional[int] = Field(description="The width of the model")
     height: Optional[int] = Field(description="The height of the model")
 
+
 class DiffusersModelInfo(ModelInfo):
     format: Literal['diffusers'] = 'diffusers'
 
@@ -36,29 +37,12 @@ class DiffusersModelInfo(ModelInfo):
     repo_id: Optional[str] = Field(description="The repo ID to use for this model")
     path: Optional[str] = Field(description="The path to the model")
 
-class CreateModelRequest(BaseModel):
-    name: str = Field(description="The name of the model")
-    info: Union[CkptModelInfo, DiffusersModelInfo] = Field(discriminator="format", description="The model info")
-
-class CreateModelResponse(BaseModel):
-    name: str = Field(description="The name of the new model")
-    info: Union[CkptModelInfo, DiffusersModelInfo] = Field(discriminator="format", description="The model info")
-    status: str = Field(description="The status of the API response")
-
-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")
-    info: DiffusersModelInfo = Field(description="The converted model info")
 
 class ModelsList(BaseModel):
     models: dict[str, Annotated[Union[(CkptModelInfo,DiffusersModelInfo)], Field(discriminator="format")]]
 
 
+
 @models_router.get(
     "/",
     operation_id="list_models",
@@ -70,62 +54,108 @@ async def list_models() -> ModelsList:
     models = parse_obj_as(ModelsList, { "models": models_raw })
     return models
 
+        # @socketio.on("requestSystemConfig")
+        # def handle_request_capabilities():
+        #     print(">> System config requested")
+        #     config = self.get_system_config()
+        #     config["model_list"] = self.generate.model_manager.list_models()
+        #     config["infill_methods"] = infill_methods()
+        #     socketio.emit("systemConfig", config)
 
-@models_router.post(
-    "/",
-    operation_id="update_model",
-    responses={200: {"status": "success"}},
-)
-async def update_model(
-    model_request: CreateModelRequest
-) -> CreateModelResponse:
-    """ Add Model """
-    model_request_info = model_request.info
-    info_dict = model_request_info.dict()
-    model_response = CreateModelResponse(name=model_request.name, info=model_request.info, status="success")
+        # @socketio.on("searchForModels")
+        # def handle_search_models(search_folder: str):
+        #     try:
+        #         if not search_folder:
+        #             socketio.emit(
+        #                 "foundModels",
+        #                 {"search_folder": None, "found_models": None},
+        #             )
+        #         else:
+        #             (
+        #                 search_folder,
+        #                 found_models,
+        #             ) = self.generate.model_manager.search_models(search_folder)
+        #             socketio.emit(
+        #                 "foundModels",
+        #                 {"search_folder": search_folder, "found_models": found_models},
+        #             )
+        #     except Exception as e:
+        #         self.handle_exceptions(e)
+        #         print("\n")
 
-    ApiDependencies.invoker.services.model_manager.add_model(
-        model_name=model_request.name,
-        model_attributes=info_dict,
-        clobber=True,
-    )
+        # @socketio.on("addNewModel")
+        # def handle_add_model(new_model_config: dict):
+        #     try:
+        #         model_name = new_model_config["name"]
+        #         del new_model_config["name"]
+        #         model_attributes = new_model_config
+        #         if len(model_attributes["vae"]) == 0:
+        #             del model_attributes["vae"]
+        #         update = False
+        #         current_model_list = self.generate.model_manager.list_models()
+        #         if model_name in current_model_list:
+        #             update = True
 
-    return model_response
+        #         print(f">> Adding New Model: {model_name}")
 
+        #         self.generate.model_manager.add_model(
+        #             model_name=model_name,
+        #             model_attributes=model_attributes,
+        #             clobber=True,
+        #         )
+        #         self.generate.model_manager.commit(opt.conf)
 
-@models_router.delete(
-    "/{model_name}",
-    operation_id="del_model",
-    responses={
-        204: {
-        "description": "Model deleted successfully"
-        }, 
-        404: {
-        "description": "Model not found"
-        }
-    },
-)
-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
+        #         new_model_list = self.generate.model_manager.list_models()
+        #         socketio.emit(
+        #             "newModelAdded",
+        #             {
+        #                 "new_model_name": model_name,
+        #                 "model_list": new_model_list,
+        #                 "update": update,
+        #             },
+        #         )
+        #         print(f">> New Model Added: {model_name}")
+        #     except Exception as e:
+        #         self.handle_exceptions(e)
 
-    # check if model exists
-    logger.info(f"Checking for model {model_name}...")
-           
-    if model_exists:
-        logger.info(f"Deleting Model: {model_name}")
-        ApiDependencies.invoker.services.model_manager.del_model(model_name, delete_files=True)
-        logger.info(f"Model Deleted: {model_name}")
-        raise HTTPException(status_code=204, detail=f"Model '{model_name}' deleted successfully")
-    
-    else:
-        logger.error(f"Model not found")
-        raise HTTPException(status_code=404, detail=f"Model '{model_name}' not found")
-    
+        # @socketio.on("deleteModel")
+        # def handle_delete_model(model_name: str):
+        #     try:
+        #         print(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()
+        #         socketio.emit(
+        #             "modelDeleted",
+        #             {
+        #                 "deleted_model_name": model_name,
+        #                 "model_list": updated_model_list,
+        #             },
+        #         )
+        #         print(f">> Model Deleted: {model_name}")
+        #     except Exception as e:
+        #         self.handle_exceptions(e)
 
-            # @socketio.on("convertToDiffusers")
+        # @socketio.on("requestModelChange")
+        # def handle_set_model(model_name: str):
+        #     try:
+        #         print(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:
+        #             socketio.emit(
+        #                 "modelChangeFailed",
+        #                 {"model_name": model_name, "model_list": model_list},
+        #             )
+        #         else:
+        #             socketio.emit(
+        #                 "modelChanged",
+        #                 {"model_name": model_name, "model_list": model_list},
+        #             )
+        #     except Exception as e:
+        #         self.handle_exceptions(e)
+
+        # @socketio.on("convertToDiffusers")
         # def convert_to_diffusers(model_to_convert: dict):
         #     try:
         #         if model_info := self.generate.model_manager.model_info(
@@ -246,3 +276,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:
+        #         self.handle_exceptions(e)

invokeai/app/api/routers/sessions.py

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

invokeai/app/api_app.py

@@ -3,7 +3,6 @@ import asyncio
 from inspect import signature
 
 import uvicorn
-from invokeai.backend.util.logging import InvokeAILogger
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
@@ -13,13 +12,12 @@ 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 sessions, models, images
+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
-
-logger = InvokeAILogger.getLogger()
 
 # Create the app
 # TODO: create this all in a method so configuration/etc. can be passed in?
@@ -35,25 +33,30 @@ app.add_middleware(
     middleware_id=event_handler_id,
 )
 
+# Add CORS
+# TODO: use configuration for this
+origins = []
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 socket_io = SocketIO(app)
 
-# initialize config
-# this is a module global
-app_config = InvokeAIAppConfig()
+config = {}
+
 
 # Add startup event to load dependencies
 @app.on_event("startup")
 async def startup_event():
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=app_config.allow_origins,
-        allow_credentials=app_config.allow_credentials,
-        allow_methods=app_config.allow_methods,
-        allow_headers=app_config.allow_headers,
-    )
+    config = Args()
+    config.parse_args()
 
     ApiDependencies.initialize(
-        config=app_config, event_handler_id=event_handler_id, logger=logger
+        config=config, event_handler_id=event_handler_id
     )
 
 
@@ -71,9 +74,10 @@ async def shutdown_event():
 
 app.include_router(sessions.session_router, prefix="/api")
 
+app.include_router(images.images_router, prefix="/api")
+
 app.include_router(models.models_router, prefix="/api")
 
-app.include_router(images.images_router, prefix="/api")
 
 # Build a custom OpenAPI to include all outputs
 # TODO: can outputs be included on metadata of invocation schemas somehow?
@@ -141,19 +145,16 @@ def overridden_redoc():
     )
 
 
-# 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=app_config.host, port=app_config.port, loop=loop)
+    config = uvicorn.Config(app=app, host="0.0.0.0", port=9090, loop=loop)
     # Use access_log to turn off logging
+
     server = uvicorn.Server(config)
     loop.run_until_complete(server.serve())
 
+
 if __name__ == "__main__":
     invoke_api()

invokeai/app/cli/commands.py

@@ -2,46 +2,15 @@
 
 from abc import ABC, abstractmethod
 import argparse
-from typing import Any, Callable, Iterable, Literal, Union, get_args, get_origin, get_type_hints
+from typing import Any, Callable, Iterable, Literal, get_args, get_origin, get_type_hints
 from pydantic import BaseModel, Field
 import networkx as nx
 import matplotlib.pyplot as plt
-
-import invokeai.backend.util.logging as logger
-from ..invocations.baseinvocation import BaseInvocation
 from ..invocations.image import ImageField
-from ..services.graph import GraphExecutionState, LibraryGraph, Edge
+from ..services.graph import GraphExecutionState
 from ..services.invoker import Invoker
 
 
-def add_field_argument(command_parser, name: str, field, default_override = None):
-    default = default_override if default_override is not None else field.default if field.default_factory is None else field.default_factory()
-    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
-
-        command_parser.add_argument(
-            f"--{name}",
-            dest=name,
-            type=field_type,
-            default=default,
-            choices=allowed_values,
-            help=field.field_info.description,
-        )
-    else:
-        command_parser.add_argument(
-            f"--{name}",
-            dest=name,
-            type=field.type_,
-            default=default,
-            help=field.field_info.description,
-        )
-
-
 def add_parsers(
     subparsers,
     commands: list[type],
@@ -66,26 +35,30 @@ def add_parsers(
             if name in exclude_fields:
                 continue
 
-            add_field_argument(command_parser, name, field)
+            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
 
-
-def add_graph_parsers(
-    subparsers,
-    graphs: list[LibraryGraph],
-    add_arguments: Callable[[argparse.ArgumentParser], None]|None = None
-):
-    for graph in graphs:
-        command_parser = subparsers.add_parser(graph.name, help=graph.description)
-        
-        if add_arguments is not None:
-            add_arguments(command_parser)
-
-        # Add arguments for inputs
-        for exposed_input in graph.exposed_inputs:
-            node = graph.graph.get_node(exposed_input.node_path)
-            field = node.__fields__[exposed_input.field]
-            default_override = getattr(node, exposed_input.field)
-            add_field_argument(command_parser, exposed_input.alias, field, default_override)
+                command_parser.add_argument(
+                    f"--{name}",
+                    dest=name,
+                    type=field_type,
+                    default=field.default if field.default_factory is None else field.default_factory(),
+                    choices=allowed_values,
+                    help=field.field_info.description,
+                )
+            else:
+                command_parser.add_argument(
+                    f"--{name}",
+                    dest=name,
+                    type=field.type_,
+                    default=field.default if field.default_factory is None else field.default_factory(),
+                    help=field.field_info.description,
+                )
 
 
 class CliContext:
@@ -93,38 +66,17 @@ class CliContext:
     session: GraphExecutionState
     parser: argparse.ArgumentParser
     defaults: dict[str, Any]
-    graph_nodes: dict[str, str]
-    nodes_added: list[str]
 
     def __init__(self, invoker: Invoker, session: GraphExecutionState, parser: argparse.ArgumentParser):
         self.invoker = invoker
         self.session = session
         self.parser = parser
         self.defaults = dict()
-        self.graph_nodes = dict()
-        self.nodes_added = list()
 
     def get_session(self):
         self.session = self.invoker.services.graph_execution_manager.get(self.session.id)
         return self.session
 
-    def reset(self):
-        self.session = self.invoker.create_execution_state()
-        self.graph_nodes = dict()
-        self.nodes_added = list()
-        # Leave defaults unchanged
-
-    def add_node(self, node: BaseInvocation):
-        self.get_session()
-        self.session.graph.add_node(node)
-        self.nodes_added.append(node.id)
-        self.invoker.services.graph_execution_manager.set(self.session)
-
-    def add_edge(self, edge: Edge):
-        self.get_session()
-        self.session.add_edge(edge)
-        self.invoker.services.graph_execution_manager.set(self.session)
-
 
 class ExitCli(Exception):
     """Exception to exit the CLI"""
@@ -230,7 +182,7 @@ class HistoryCommand(BaseCommand):
         for i in range(min(self.count, len(history))):
             entry_id = history[-1 - i]
             entry = context.get_session().graph.get_node(entry_id)
-            logger.info(f"{entry_id}: {get_invocation_command(entry)}")
+            print(f"{entry_id}: {get_invocation_command(entry)}")
 
 
 class SetDefaultCommand(BaseCommand):
@@ -285,19 +237,3 @@ class DrawExecutionGraphCommand(BaseCommand):
         nx.draw_networkx_labels(nxgraph, pos, font_size=20, font_family="sans-serif")
         plt.axis("off")
         plt.show()
-
-class SortedHelpFormatter(argparse.HelpFormatter):
-    def _iter_indented_subactions(self, action):
-        try:
-            get_subactions = action._get_subactions
-        except AttributeError:
-            pass
-        else:
-            self._indent()
-            if isinstance(action, argparse._SubParsersAction):
-                for subaction in sorted(get_subactions(), key=lambda x: x.dest):
-                    yield subaction
-            else:
-                for subaction in get_subactions():
-                    yield subaction
-                self._dedent()

invokeai/app/cli/completer.py

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

invokeai/app/cli_app.py

@@ -4,41 +4,33 @@ import argparse
 import os
 import re
 import shlex
-import sys
 import time
 from typing import (
     Union,
     get_type_hints,
 )
 
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel
 from pydantic.fields import Field
-from invokeai.app.services.image_record_storage import SqliteImageRecordStorage
-from invokeai.app.services.images import ImageService
-from invokeai.app.services.metadata import CoreMetadataService
-from invokeai.app.services.resource_name import SimpleNameService
-from invokeai.app.services.urls import LocalUrlService
 
-
-import invokeai.backend.util.logging as logger
-from .services.default_graphs import create_system_graphs
 from .services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
 
-from .cli.commands import BaseCommand, CliContext, ExitCli, add_graph_parsers, add_parsers, SortedHelpFormatter
+from ..backend import Args
+from .cli.commands import BaseCommand, CliContext, ExitCli, add_parsers, get_graph_execution_history
 from .cli.completer import set_autocompleter
+from .invocations import *
 from .invocations.baseinvocation import BaseInvocation
 from .services.events import EventServiceBase
 from .services.model_manager_initializer import get_model_manager
 from .services.restoration_services import RestorationServices
-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_file_storage import DiskImageFileStorage
+from .services.graph import Edge, EdgeConnection, GraphExecutionState, are_connection_types_compatible
+from .services.image_storage import DiskImageStorage
 from .services.invocation_queue import MemoryInvocationQueue
 from .services.invocation_services import InvocationServices
 from .services.invoker import Invoker
 from .services.processor import DefaultInvocationProcessor
 from .services.sqlite import SqliteItemStorage
-from .services.config import get_invokeai_config
+
 
 class CliCommand(BaseModel):
     command: Union[BaseCommand.get_commands() + BaseInvocation.get_invocations()] = Field(discriminator="type")  # type: ignore
@@ -66,9 +58,9 @@ def add_invocation_args(command_parser):
     )
 
 
-def get_command_parser(services: InvocationServices) -> argparse.ArgumentParser:
+def get_command_parser() -> argparse.ArgumentParser:
     # Create invocation parser
-    parser = argparse.ArgumentParser(formatter_class=SortedHelpFormatter)
+    parser = argparse.ArgumentParser()
 
     def exit(*args, **kwargs):
         raise InvalidArgs
@@ -84,72 +76,20 @@ def get_command_parser(services: InvocationServices) -> argparse.ArgumentParser:
     commands = BaseCommand.get_all_subclasses()
     add_parsers(subparsers, commands, exclude_fields=["type"])
 
-    # Create subparsers for exposed CLI graphs
-    # TODO: add a way to identify these graphs
-    text_to_image = services.graph_library.get(default_text_to_image_graph_id)
-    add_graph_parsers(subparsers, [text_to_image], add_arguments=add_invocation_args)
-
     return parser
 
 
-class NodeField():
-    alias: str
-    node_path: str
-    field: str
-    field_type: type
-
-    def __init__(self, alias: str, node_path: str, field: str, field_type: type):
-        self.alias = alias
-        self.node_path = node_path
-        self.field = field
-        self.field_type = field_type
-
-
-def fields_from_type_hints(hints: dict[str, type], node_path: str) -> dict[str,NodeField]:
-    return {k:NodeField(alias=k, node_path=node_path, field=k, field_type=v) for k, v in hints.items()}
-
-
-def get_node_input_field(graph: LibraryGraph, field_alias: str, node_id: str) -> NodeField:
-    """Gets the node field for the specified field alias"""
-    exposed_input = next(e for e in graph.exposed_inputs if e.alias == field_alias)
-    node_type = type(graph.graph.get_node(exposed_input.node_path))
-    return NodeField(alias=exposed_input.alias, node_path=f'{node_id}.{exposed_input.node_path}', field=exposed_input.field, field_type=get_type_hints(node_type)[exposed_input.field])
-
-
-def get_node_output_field(graph: LibraryGraph, field_alias: str, node_id: str) -> NodeField:
-    """Gets the node field for the specified field alias"""
-    exposed_output = next(e for e in graph.exposed_outputs if e.alias == field_alias)
-    node_type = type(graph.graph.get_node(exposed_output.node_path))
-    node_output_type = node_type.get_output_type()
-    return NodeField(alias=exposed_output.alias, node_path=f'{node_id}.{exposed_output.node_path}', field=exposed_output.field, field_type=get_type_hints(node_output_type)[exposed_output.field])
-
-
-def get_node_inputs(invocation: BaseInvocation, context: CliContext) -> dict[str, NodeField]:
-    """Gets the inputs for the specified invocation from the context"""
-    node_type = type(invocation)
-    if node_type is not GraphInvocation:
-        return fields_from_type_hints(get_type_hints(node_type), invocation.id)
-    else:
-        graph: LibraryGraph = context.invoker.services.graph_library.get(context.graph_nodes[invocation.id])
-        return {e.alias: get_node_input_field(graph, e.alias, invocation.id) for e in graph.exposed_inputs}
-
-
-def get_node_outputs(invocation: BaseInvocation, context: CliContext) -> dict[str, NodeField]:
-    """Gets the outputs for the specified invocation from the context"""
-    node_type = type(invocation)
-    if node_type is not GraphInvocation:
-        return fields_from_type_hints(get_type_hints(node_type.get_output_type()), invocation.id)
-    else:
-        graph: LibraryGraph = context.invoker.services.graph_library.get(context.graph_nodes[invocation.id])
-        return {e.alias: get_node_output_field(graph, e.alias, invocation.id) for e in graph.exposed_outputs}
-
-
 def generate_matching_edges(
-    a: BaseInvocation, b: BaseInvocation, context: CliContext
+    a: BaseInvocation, b: BaseInvocation
 ) -> list[Edge]:
     """Generates all possible edges between two invocations"""
-    afields = get_node_outputs(a, context)
-    bfields = get_node_inputs(b, context)
+    atype = type(a)
+    btype = type(b)
+
+    aoutputtype = atype.get_output_type()
+
+    afields = get_type_hints(aoutputtype)
+    bfields = get_type_hints(btype)
 
     matching_fields = set(afields.keys()).intersection(bfields.keys())
 
@@ -158,14 +98,14 @@ def generate_matching_edges(
     matching_fields = matching_fields.difference(invalid_fields)
 
     # Validate types
-    matching_fields = [f for f in matching_fields if are_connection_types_compatible(afields[f].field_type, bfields[f].field_type)]
+    matching_fields = [f for f in matching_fields if are_connection_types_compatible(afields[f], bfields[f])]
 
     edges = [
         Edge(
-            source=EdgeConnection(node_id=afields[alias].node_path, field=afields[alias].field),
-            destination=EdgeConnection(node_id=bfields[alias].node_path, field=bfields[alias].field)
+            source=EdgeConnection(node_id=a.id, field=field),
+            destination=EdgeConnection(node_id=b.id, field=field)
         )
-        for alias in matching_fields
+        for field in matching_fields
     ]
     return edges
 
@@ -185,85 +125,49 @@ def invoke_all(context: CliContext):
     # Print any errors
     if context.session.has_error():
         for n in context.session.errors:
-            context.invoker.services.logger.error(
+            print(
                 f"Error in node {n} (source node {context.session.prepared_source_mapping[n]}): {context.session.errors[n]}"
             )
         
         raise SessionError()
 
 
-logger = logger.InvokeAILogger.getLogger()
-
-
 def invoke_cli():
-    # this gets the basic configuration
-    config = get_invokeai_config()
+    config = Args()
+    config.parse_args()
+    model_manager = get_model_manager(config)
 
-    # 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
+    # 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 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
+
+    output_folder = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "../../../outputs")
+    )
 
     # TODO: build a file/path manager?
-    if config.use_memory_db:
-        db_location = ":memory:"
-    else:
-        db_location = os.path.join(output_folder, "invokeai.db")
-
-    logger.info(f'InvokeAI database location is "{db_location}"')
-
-    graph_execution_manager = SqliteItemStorage[GraphExecutionState](
-            filename=db_location, table_name="graph_executions"
-        )
-
-    urls = LocalUrlService()
-    metadata = CoreMetadataService()
-    image_record_storage = SqliteImageRecordStorage(db_location)
-    image_file_storage = DiskImageFileStorage(f"{output_folder}/images")
-    names = SimpleNameService()
-
-    images = ImageService(
-        image_record_storage=image_record_storage,
-        image_file_storage=image_file_storage,
-        metadata=metadata,
-        url=urls,
-        logger=logger,
-        names=names,
-        graph_execution_manager=graph_execution_manager,
-    )
+    db_location = os.path.join(output_folder, "invokeai.db")
 
     services = InvocationServices(
         model_manager=model_manager,
         events=events,
         latents = ForwardCacheLatentsStorage(DiskLatentsStorage(f'{output_folder}/latents')),
-        images=images,
+        images=DiskImageStorage(f'{output_folder}/images'),
         queue=MemoryInvocationQueue(),
-        graph_library=SqliteItemStorage[LibraryGraph](
-            filename=db_location, table_name="graphs"
+        graph_execution_manager=SqliteItemStorage[GraphExecutionState](
+            filename=db_location, table_name="graph_executions"
         ),
-        graph_execution_manager=graph_execution_manager,
         processor=DefaultInvocationProcessor(),
-        restoration=RestorationServices(config,logger=logger),
-        logger=logger,
-        configuration=config,
+        restoration=RestorationServices(config),
     )
 
-    system_graphs = create_system_graphs(services.graph_library)
-    system_graph_names = set([g.name for g in system_graphs])
-
     invoker = Invoker(services)
     session: GraphExecutionState = invoker.create_execution_state()
-    parser = get_command_parser(services)
+    parser = get_command_parser()
 
     re_negid = re.compile('^-[0-9]+$')
 
@@ -271,30 +175,21 @@ def invoke_cli():
     # print(services.session_manager.list())
 
     context = CliContext(invoker, session, parser)
-    set_autocompleter(services)
 
-    command_line_args_exist = len(invocation_commands) > 0
-    done = False
-    
-    while not done:
+    while True:
         try:
-            if command_line_args_exist:
-                cmd_input = invocation_commands.pop(0)
-                done = len(invocation_commands) == 0
-            else:
-                cmd_input = input("invoke> ")
+            cmd_input = input("invoke> ")
         except (KeyboardInterrupt, EOFError):
             # Ctrl-c exits
             break
 
         try:
             # Refresh the state of the session
-            #history = list(get_graph_execution_history(context.session))
-            history = list(reversed(context.nodes_added))
+            history = list(get_graph_execution_history(context.session))
 
             # Split the command for piping
             cmds = cmd_input.split("|")
-            start_id = len(context.nodes_added)
+            start_id = len(history)
             current_id = start_id
             new_invocations = list()
             for cmd in cmds:
@@ -310,24 +205,8 @@ def invoke_cli():
                         args[field_name] = field_default
 
                 # Parse invocation
-                command: CliCommand = None # type:ignore
-                system_graph: LibraryGraph|None = None
-                if args['type'] in system_graph_names:
-                    system_graph = next(filter(lambda g: g.name == args['type'], system_graphs))
-                    invocation = GraphInvocation(graph=system_graph.graph, id=str(current_id))
-                    for exposed_input in system_graph.exposed_inputs:
-                        if exposed_input.alias in args:
-                            node = invocation.graph.get_node(exposed_input.node_path)
-                            field = exposed_input.field
-                            setattr(node, field, args[exposed_input.alias])
-                    command = CliCommand(command = invocation)
-                    context.graph_nodes[invocation.id] = system_graph.id
-                else:
-                    args["id"] = current_id
-                    command = CliCommand(command=args)
-
-                if command is None:
-                    continue
+                args["id"] = current_id
+                command = CliCommand(command=args)
 
                 # Run any CLI commands immediately
                 if isinstance(command.command, BaseCommand):
@@ -338,7 +217,6 @@ def invoke_cli():
                     command.command.run(context)
                     continue
 
-                # TODO: handle linking with library graphs
                 # Pipe previous command output (if there was a previous command)
                 edges: list[Edge] = list()
                 if len(history) > 0 or current_id != start_id:
@@ -351,7 +229,7 @@ def invoke_cli():
                         else context.session.graph.get_node(from_id)
                     )
                     matching_edges = generate_matching_edges(
-                        from_node, command.command, context
+                        from_node, command.command
                     )
                     edges.extend(matching_edges)
 
@@ -364,7 +242,7 @@ def invoke_cli():
 
                         link_node = context.session.graph.get_node(node_id)
                         matching_edges = generate_matching_edges(
-                            link_node, command.command, context
+                            link_node, command.command
                         )
                         matching_destinations = [e.destination for e in matching_edges]
                         edges = [e for e in edges if e.destination not in matching_destinations]
@@ -378,14 +256,12 @@ def invoke_cli():
                         if re_negid.match(node_id):
                             node_id = str(current_id + int(node_id))
 
-                        # TODO: handle missing input/output
-                        node_output = get_node_outputs(context.session.graph.get_node(node_id), context)[link[1]]
-                        node_input = get_node_inputs(command.command, context)[link[2]]
-
                         edges.append(
                             Edge(
-                                source=EdgeConnection(node_id=node_output.node_path, field=node_output.field),
-                                destination=EdgeConnection(node_id=node_input.node_path, field=node_input.field)
+                                source=EdgeConnection(node_id=node_id, field=link[1]),
+                                destination=EdgeConnection(
+                                    node_id=command.command.id, field=link[2]
+                                )
                             )
                         )
 
@@ -394,25 +270,22 @@ def invoke_cli():
                 current_id = current_id + 1
 
                 # Add the node to the session
-                context.add_node(command.command)
+                context.session.add_node(command.command)
                 for edge in edges:
                     print(edge)
-                    context.add_edge(edge)
+                    context.session.add_edge(edge)
 
             # Execute all remaining nodes
             invoke_all(context)
 
         except InvalidArgs:
-            invoker.services.logger.warning('Invalid command, use "help" to list commands')
+            print('Invalid command, use "help" to list commands')
             continue
 
-        except ValidationError:
-            invoker.services.logger.warning('Invalid command arguments, run "<command> --help" for summary')
-
         except SessionError:
             # Start a new session
-            invoker.services.logger.warning("Session error: creating a new session")
-            context.reset()
+            print("Session error: creating a new session")
+            context.session = context.invoker.create_execution_state()
 
         except ExitCli:
             break

invokeai/app/invocations/baseinvocation.py

@@ -1,15 +1,12 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-from __future__ import annotations
-
 from abc import ABC, abstractmethod
 from inspect import signature
-from typing import get_args, get_type_hints, Dict, List, Literal, TypedDict, TYPE_CHECKING
+from typing import get_args, get_type_hints
 
 from pydantic import BaseModel, Field
 
-if TYPE_CHECKING:
-    from ..services.invocation_services import InvocationServices
+from ..services.invocation_services import InvocationServices
 
 
 class InvocationContext:
@@ -78,59 +75,4 @@ class BaseInvocation(ABC, BaseModel):
     
     #fmt: off
     id: str = Field(description="The id of this node. Must be unique among all nodes.")
-    is_intermediate: bool = Field(default=False, description="Whether or not this node is an intermediate node.")
     #fmt: on
-
-
-# TODO: figure out a better way to provide these hints
-# TODO: when we can upgrade to python 3.11, we can use the`NotRequired` type instead of `total=False`
-class UIConfig(TypedDict, total=False):
-    type_hints: Dict[
-        str,
-        Literal[
-            "integer",
-            "float",
-            "boolean",
-            "string",
-            "enum",
-            "image",
-            "latents",
-            "model",
-            "control",
-        ],
-    ]
-    tags: List[str]
-    title: str
-
-class CustomisedSchemaExtra(TypedDict):
-    ui: UIConfig
-
-
-class InvocationConfig(BaseModel.Config):
-    """Customizes pydantic's BaseModel.Config class for use by Invocations.
-
-    Provide `schema_extra` a `ui` dict to add hints for generated UIs.
-
-    `tags`
-    - A list of strings, used to categorise invocations.
-
-    `type_hints`
-    - A dict of field types which override the types in the invocation definition.
-    - Each key should be the name of one of the invocation's fields.
-    - Each value should be one of the valid types:
-      - `integer`, `float`, `boolean`, `string`, `enum`, `image`, `latents`, `model`
-
-    ```python
-    class Config(InvocationConfig):
-      schema_extra = {
-          "ui": {
-              "tags": ["stable-diffusion", "image"],
-              "type_hints": {
-                  "initial_image": "image",
-              },
-          },
-      }
-    ```
-    """
-
-    schema_extra: CustomisedSchemaExtra

invokeai/app/invocations/collections.py

@@ -1,17 +1,16 @@
-# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654) and the InvokeAI Team
+# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
 
 from typing import Literal
 
+import cv2 as cv
 import numpy as np
-from pydantic import Field, validator
+import numpy.random
+from PIL import Image, ImageOps
+from pydantic import Field
 
-from invokeai.app.util.misc import SEED_MAX, get_random_seed
-
-from .baseinvocation import (
-    BaseInvocation,
-    InvocationContext,
-    BaseInvocationOutput,
-)
+from ..services.image_storage import ImageType
+from .baseinvocation import BaseInvocation, InvocationContext, BaseInvocationOutput
+from .image import ImageField, ImageOutput
 
 
 class IntCollectionOutput(BaseInvocationOutput):
@@ -22,17 +21,9 @@ class IntCollectionOutput(BaseInvocationOutput):
     # Outputs
     collection: list[int] = Field(default=[], description="The int collection")
 
-class FloatCollectionOutput(BaseInvocationOutput):
-    """A collection of floats"""
-
-    type: Literal["float_collection"] = "float_collection"
-
-    # Outputs
-    collection: list[float] = Field(default=[], description="The float collection")
-
 
 class RangeInvocation(BaseInvocation):
-    """Creates a range of numbers from start to stop with step"""
+    """Creates a range"""
 
     type: Literal["range"] = "range"
 
@@ -41,32 +32,8 @@ class RangeInvocation(BaseInvocation):
     stop: int = Field(default=10, description="The stop of the range")
     step: int = Field(default=1, description="The step of the range")
 
-    @validator("stop")
-    def stop_gt_start(cls, v, values):
-        if "start" in values and v <= values["start"]:
-            raise ValueError("stop must be greater than start")
-        return v
-
     def invoke(self, context: InvocationContext) -> IntCollectionOutput:
-        return IntCollectionOutput(
-            collection=list(range(self.start, self.stop, self.step))
-        )
-
-
-class RangeOfSizeInvocation(BaseInvocation):
-    """Creates a range from start to start + size with step"""
-
-    type: Literal["range_of_size"] = "range_of_size"
-
-    # Inputs
-    start: int = Field(default=0, description="The start of the range")
-    size: int = Field(default=1, description="The number of values")
-    step: int = Field(default=1, description="The step of the range")
-
-    def invoke(self, context: InvocationContext) -> IntCollectionOutput:
-        return IntCollectionOutput(
-            collection=list(range(self.start, self.start + self.size, self.step))
-        )
+        return IntCollectionOutput(collection=list(range(self.start, self.stop, self.step)))
 
 
 class RandomRangeInvocation(BaseInvocation):
@@ -76,19 +43,8 @@ class RandomRangeInvocation(BaseInvocation):
 
     # Inputs
     low: int = Field(default=0, description="The inclusive low value")
-    high: int = Field(
-        default=np.iinfo(np.int32).max, description="The exclusive high value"
-    )
+    high: int = Field(default=np.iinfo(np.int32).max, description="The exclusive high value")
     size: int = Field(default=1, description="The number of values to generate")
-    seed: int = Field(
-        ge=0,
-        le=SEED_MAX,
-        description="The seed for the RNG (omit for random)",
-        default_factory=get_random_seed,
-    )
 
     def invoke(self, context: InvocationContext) -> IntCollectionOutput:
-        rng = np.random.default_rng(self.seed)
-        return IntCollectionOutput(
-            collection=list(rng.integers(low=self.low, high=self.high, size=self.size))
-        )
+        return IntCollectionOutput(collection=list(numpy.random.randint(self.low, self.high, size=self.size)))

invokeai/app/invocations/compel.py

@@ -1,244 +0,0 @@
-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.save(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/controlnet_image_processors.py

@@ -1,428 +0,0 @@
-# InvokeAI nodes for ControlNet image preprocessors
-# initial implementation by Gregg Helt, 2023
-# heavily leverages controlnet_aux package: https://github.com/patrickvonplaten/controlnet_aux
-
-import numpy as np
-from typing import Literal, Optional, Union, List
-from PIL import Image, ImageFilter, ImageOps
-from pydantic import BaseModel, Field
-
-from ..models.image import ImageField, ImageCategory, ResourceOrigin
-from .baseinvocation import (
-    BaseInvocation,
-    BaseInvocationOutput,
-    InvocationContext,
-    InvocationConfig,
-)
-from controlnet_aux import (
-    CannyDetector,
-    HEDdetector,
-    LineartDetector,
-    LineartAnimeDetector,
-    MidasDetector,
-    MLSDdetector,
-    NormalBaeDetector,
-    OpenposeDetector,
-    PidiNetDetector,
-    ContentShuffleDetector,
-    ZoeDetector,
-    MediapipeFaceDetector,
-)
-
-from .image import ImageOutput, PILInvocationConfig
-
-CONTROLNET_DEFAULT_MODELS = [
-    ###########################################
-    # lllyasviel sd v1.5, ControlNet v1.0 models
-    ##############################################
-    "lllyasviel/sd-controlnet-canny",
-    "lllyasviel/sd-controlnet-depth",
-    "lllyasviel/sd-controlnet-hed",
-    "lllyasviel/sd-controlnet-seg",
-    "lllyasviel/sd-controlnet-openpose",
-    "lllyasviel/sd-controlnet-scribble",
-    "lllyasviel/sd-controlnet-normal",
-    "lllyasviel/sd-controlnet-mlsd",
-
-    #############################################
-    # lllyasviel sd v1.5, ControlNet v1.1 models
-    #############################################
-    "lllyasviel/control_v11p_sd15_canny",
-    "lllyasviel/control_v11p_sd15_openpose",
-    "lllyasviel/control_v11p_sd15_seg",
-    # "lllyasviel/control_v11p_sd15_depth",  # broken
-    "lllyasviel/control_v11f1p_sd15_depth",
-    "lllyasviel/control_v11p_sd15_normalbae",
-    "lllyasviel/control_v11p_sd15_scribble",
-    "lllyasviel/control_v11p_sd15_mlsd",
-    "lllyasviel/control_v11p_sd15_softedge",
-    "lllyasviel/control_v11p_sd15s2_lineart_anime",
-    "lllyasviel/control_v11p_sd15_lineart",
-    "lllyasviel/control_v11p_sd15_inpaint",
-    # "lllyasviel/control_v11u_sd15_tile",
-    # problem (temporary?) with huffingface "lllyasviel/control_v11u_sd15_tile",
-    # so for now replace  "lllyasviel/control_v11f1e_sd15_tile",
-    "lllyasviel/control_v11e_sd15_shuffle",
-    "lllyasviel/control_v11e_sd15_ip2p",
-    "lllyasviel/control_v11f1e_sd15_tile",
-
-     #################################################
-     #  thibaud sd v2.1 models (ControlNet v1.0? or v1.1?
-     ##################################################
-     "thibaud/controlnet-sd21-openpose-diffusers",
-     "thibaud/controlnet-sd21-canny-diffusers",
-     "thibaud/controlnet-sd21-depth-diffusers",
-     "thibaud/controlnet-sd21-scribble-diffusers",
-     "thibaud/controlnet-sd21-hed-diffusers",
-     "thibaud/controlnet-sd21-zoedepth-diffusers",
-     "thibaud/controlnet-sd21-color-diffusers",
-     "thibaud/controlnet-sd21-openposev2-diffusers",
-     "thibaud/controlnet-sd21-lineart-diffusers",
-     "thibaud/controlnet-sd21-normalbae-diffusers",
-     "thibaud/controlnet-sd21-ade20k-diffusers",
-
-     ##############################################
-     #  ControlNetMediaPipeface, ControlNet v1.1
-     ##############################################
-     # ["CrucibleAI/ControlNetMediaPipeFace", "diffusion_sd15"],  # SD 1.5
-     #    diffusion_sd15 needs to be passed to from_pretrained() as subfolder arg
-     #    hacked t2l to split to model & subfolder if format is "model,subfolder"
-     "CrucibleAI/ControlNetMediaPipeFace,diffusion_sd15",  # SD 1.5
-     "CrucibleAI/ControlNetMediaPipeFace",  # SD 2.1?
-]
-
-CONTROLNET_NAME_VALUES = Literal[tuple(CONTROLNET_DEFAULT_MODELS)]
-
-class ControlField(BaseModel):
-    image: ImageField = Field(default=None, description="processed image")
-    control_model: Optional[str] = Field(default=None, description="control model used")
-    control_weight: Optional[float] = Field(default=1, description="weight given to controlnet")
-    begin_step_percent: float = Field(default=0, ge=0, le=1,
-                                                description="% of total steps at which controlnet is first applied")
-    end_step_percent: float = Field(default=1, ge=0, le=1,
-                                    description="% of total steps at which controlnet is last applied")
-
-    class Config:
-        schema_extra = {
-            "required": ["image", "control_model", "control_weight", "begin_step_percent", "end_step_percent"]
-        }
-
-
-class ControlOutput(BaseInvocationOutput):
-    """node output for ControlNet info"""
-    # fmt: off
-    type: Literal["control_output"] = "control_output"
-    control: ControlField = Field(default=None, description="The control info dict")
-    # fmt: on
-
-
-class ControlNetInvocation(BaseInvocation):
-    """Collects ControlNet info to pass to other nodes"""
-    # fmt: off
-    type: Literal["controlnet"] = "controlnet"
-    # Inputs
-    image: ImageField = Field(default=None, description="image to process")
-    control_model: CONTROLNET_NAME_VALUES = Field(default="lllyasviel/sd-controlnet-canny",
-                                                  description="control model used")
-    control_weight: float = Field(default=1.0, ge=0, le=1, description="weight given to controlnet")
-    # TODO: add support in backend core for begin_step_percent, end_step_percent, guess_mode
-    begin_step_percent: float = Field(default=0, ge=0, le=1,
-                                        description="% of total steps at which controlnet is first applied")
-    end_step_percent: float = Field(default=1, ge=0, le=1,
-                                      description="% of total steps at which controlnet is last applied")
-    # fmt: on
-
-
-    def invoke(self, context: InvocationContext) -> ControlOutput:
-
-        return ControlOutput(
-            control=ControlField(
-                image=self.image,
-                control_model=self.control_model,
-                control_weight=self.control_weight,
-                begin_step_percent=self.begin_step_percent,
-                end_step_percent=self.end_step_percent,
-            ),
-        )
-
-# TODO: move image processors to separate file (image_analysis.py
-class ImageProcessorInvocation(BaseInvocation, PILInvocationConfig):
-    """Base class for invocations that preprocess images for ControlNet"""
-
-    # fmt: off
-    type: Literal["image_processor"] = "image_processor"
-    # Inputs
-    image: ImageField = Field(default=None, description="image to process")
-    # fmt: on
-
-
-    def run_processor(self, image):
-        # superclass just passes through image without processing
-        return image
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-
-        raw_image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
-        )
-        # image type should be PIL.PngImagePlugin.PngImageFile ?
-        processed_image = self.run_processor(raw_image)
-
-        # FIXME: what happened to image metadata?
-        # metadata = context.services.metadata.build_metadata(
-        #     session_id=context.graph_execution_state_id, node=self
-        # )
-
-        # currently can't see processed image in node UI without a showImage node,
-        #    so for now setting image_type to RESULT instead of INTERMEDIATE so will get saved in gallery
-        image_dto = context.services.images.create(
-            image=processed_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.CONTROL,
-            session_id=context.graph_execution_state_id,
-            node_id=self.id,
-            is_intermediate=self.is_intermediate
-        )
-
-        """Builds an ImageOutput and its ImageField"""
-        processed_image_field = ImageField(
-            image_name=image_dto.image_name,
-            image_origin=image_dto.image_origin,
-        )
-        return ImageOutput(
-            image=processed_image_field,
-            # width=processed_image.width,
-            width = image_dto.width,
-            # height=processed_image.height,
-            height = image_dto.height,
-            # mode=processed_image.mode,
-        )
-
-
-class CannyImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Canny edge detection for ControlNet"""
-    # fmt: off
-    type: Literal["canny_image_processor"] = "canny_image_processor"
-    # Input
-    low_threshold: float = Field(default=100, ge=0, description="low threshold of Canny pixel gradient")
-    high_threshold: float = Field(default=200, ge=0, description="high threshold of Canny pixel gradient")
-    # fmt: on
-
-    def run_processor(self, image):
-        canny_processor = CannyDetector()
-        processed_image = canny_processor(image, self.low_threshold, self.high_threshold)
-        return processed_image
-
-
-class HedImageprocessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies HED edge detection to image"""
-    # fmt: off
-    type: Literal["hed_image_processor"] = "hed_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="pixel resolution for edge detection")
-    image_resolution: int = Field(default=512, ge=0, description="pixel resolution for output image")
-    # safe not supported in controlnet_aux v0.0.3
-    # safe: bool = Field(default=False, description="whether to use safe mode")
-    scribble: bool = Field(default=False, description="whether to use scribble mode")
-    # fmt: on
-
-    def run_processor(self, image):
-        hed_processor = HEDdetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = hed_processor(image,
-                                        detect_resolution=self.detect_resolution,
-                                        image_resolution=self.image_resolution,
-                                        # safe not supported in controlnet_aux v0.0.3
-                                        # safe=self.safe,
-                                        scribble=self.scribble,
-                                        )
-        return processed_image
-
-
-class LineartImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies line art processing to image"""
-    # fmt: off
-    type: Literal["lineart_image_processor"] = "lineart_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="pixel resolution for edge detection")
-    image_resolution: int = Field(default=512, ge=0, description="pixel resolution for output image")
-    coarse: bool = Field(default=False, description="whether to use coarse mode")
-    # fmt: on
-
-    def run_processor(self, image):
-        lineart_processor = LineartDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = lineart_processor(image,
-                                            detect_resolution=self.detect_resolution,
-                                            image_resolution=self.image_resolution,
-                                            coarse=self.coarse)
-        return processed_image
-
-
-class LineartAnimeImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies line art anime processing to image"""
-    # fmt: off
-    type: Literal["lineart_anime_image_processor"] = "lineart_anime_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="pixel resolution for edge detection")
-    image_resolution: int = Field(default=512, ge=0, description="pixel resolution for output image")
-    # fmt: on
-
-    def run_processor(self, image):
-        processor = LineartAnimeDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = processor(image,
-                                    detect_resolution=self.detect_resolution,
-                                    image_resolution=self.image_resolution,
-                                    )
-        return processed_image
-
-
-class OpenposeImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies Openpose processing to image"""
-    # fmt: off
-    type: Literal["openpose_image_processor"] = "openpose_image_processor"
-    # Inputs
-    hand_and_face: bool = Field(default=False, description="whether to use hands and face mode")
-    detect_resolution: int = Field(default=512, ge=0, description="pixel resolution for edge detection")
-    image_resolution: int = Field(default=512, ge=0, description="pixel resolution for output image")
-    # fmt: on
-
-    def run_processor(self, image):
-        openpose_processor = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = openpose_processor(image,
-                                             detect_resolution=self.detect_resolution,
-                                             image_resolution=self.image_resolution,
-                                             hand_and_face=self.hand_and_face,
-                                             )
-        return processed_image
-
-
-class MidasDepthImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies Midas depth processing to image"""
-    # fmt: off
-    type: Literal["midas_depth_image_processor"] = "midas_depth_image_processor"
-    # Inputs
-    a_mult: float = Field(default=2.0, ge=0, description="Midas parameter a = amult * PI")
-    bg_th: float = Field(default=0.1, ge=0, description="Midas parameter bg_th")
-    # depth_and_normal not supported in controlnet_aux v0.0.3
-    # depth_and_normal: bool = Field(default=False, description="whether to use depth and normal mode")
-    # fmt: on
-
-    def run_processor(self, image):
-        midas_processor = MidasDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = midas_processor(image,
-                                          a=np.pi * self.a_mult,
-                                          bg_th=self.bg_th,
-                                          # dept_and_normal not supported in controlnet_aux v0.0.3
-                                          # depth_and_normal=self.depth_and_normal,
-                                          )
-        return processed_image
-
-
-class NormalbaeImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies NormalBae processing to image"""
-    # fmt: off
-    type: Literal["normalbae_image_processor"] = "normalbae_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="pixel resolution for edge detection")
-    image_resolution: int = Field(default=512, ge=0, description="pixel resolution for output image")
-    # fmt: on
-
-    def run_processor(self, image):
-        normalbae_processor = NormalBaeDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = normalbae_processor(image,
-                                              detect_resolution=self.detect_resolution,
-                                              image_resolution=self.image_resolution)
-        return processed_image
-
-
-class MlsdImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies MLSD processing to image"""
-    # fmt: off
-    type: Literal["mlsd_image_processor"] = "mlsd_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="pixel resolution for edge detection")
-    image_resolution: int = Field(default=512, ge=0, description="pixel resolution for output image")
-    thr_v: float = Field(default=0.1, ge=0, description="MLSD parameter thr_v")
-    thr_d: float = Field(default=0.1, ge=0, description="MLSD parameter thr_d")
-    # fmt: on
-
-    def run_processor(self, image):
-        mlsd_processor = MLSDdetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = mlsd_processor(image,
-                                         detect_resolution=self.detect_resolution,
-                                         image_resolution=self.image_resolution,
-                                         thr_v=self.thr_v,
-                                         thr_d=self.thr_d)
-        return processed_image
-
-
-class PidiImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies PIDI processing to image"""
-    # fmt: off
-    type: Literal["pidi_image_processor"] = "pidi_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="pixel resolution for edge detection")
-    image_resolution: int = Field(default=512, ge=0, description="pixel resolution for output image")
-    safe: bool = Field(default=False, description="whether to use safe mode")
-    scribble: bool = Field(default=False, description="whether to use scribble mode")
-    # fmt: on
-
-    def run_processor(self, image):
-        pidi_processor = PidiNetDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = pidi_processor(image,
-                                         detect_resolution=self.detect_resolution,
-                                         image_resolution=self.image_resolution,
-                                         safe=self.safe,
-                                         scribble=self.scribble)
-        return processed_image
-
-
-class ContentShuffleImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies content shuffle processing to image"""
-    # fmt: off
-    type: Literal["content_shuffle_image_processor"] = "content_shuffle_image_processor"
-    # Inputs
-    detect_resolution: int = Field(default=512, ge=0, description="pixel resolution for edge detection")
-    image_resolution: int = Field(default=512, ge=0, description="pixel resolution for output image")
-    h: Union[int | None] = Field(default=512, ge=0, description="content shuffle h parameter")
-    w: Union[int | None] = Field(default=512, ge=0, description="content shuffle w parameter")
-    f: Union[int | None] = Field(default=256, ge=0, description="cont")
-    # fmt: on
-
-    def run_processor(self, image):
-        content_shuffle_processor = ContentShuffleDetector()
-        processed_image = content_shuffle_processor(image,
-                                                    detect_resolution=self.detect_resolution,
-                                                    image_resolution=self.image_resolution,
-                                                    h=self.h,
-                                                    w=self.w,
-                                                    f=self.f
-                                                    )
-        return processed_image
-
-
-# should work with controlnet_aux >= 0.0.4 and timm <= 0.6.13
-class ZoeDepthImageProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies Zoe depth processing to image"""
-    # fmt: off
-    type: Literal["zoe_depth_image_processor"] = "zoe_depth_image_processor"
-    # fmt: on
-
-    def run_processor(self, image):
-        zoe_depth_processor = ZoeDetector.from_pretrained("lllyasviel/Annotators")
-        processed_image = zoe_depth_processor(image)
-        return processed_image
-
-
-class MediapipeFaceProcessorInvocation(ImageProcessorInvocation, PILInvocationConfig):
-    """Applies mediapipe face processing to image"""
-    # fmt: off
-    type: Literal["mediapipe_face_processor"] = "mediapipe_face_processor"
-    # Inputs
-    max_faces: int = Field(default=1, ge=1, description="maximum number of faces to detect")
-    min_confidence: float = Field(default=0.5, ge=0, le=1, description="minimum confidence for face detection")
-    # fmt: on
-
-    def run_processor(self, image):
-        mediapipe_face_processor = MediapipeFaceDetector()
-        processed_image = mediapipe_face_processor(image, max_faces=self.max_faces, min_confidence=self.min_confidence)
-        return processed_image

invokeai/app/invocations/cv.py

@@ -5,48 +5,33 @@ from typing import Literal
 import cv2 as cv
 import numpy
 from PIL import Image, ImageOps
-from pydantic import BaseModel, Field
+from pydantic import Field
 
-from invokeai.app.models.image import ImageCategory, ImageField, ResourceOrigin
-from .baseinvocation import BaseInvocation, InvocationContext, InvocationConfig
-from .image import ImageOutput
+from ..services.image_storage import ImageType
+from .baseinvocation import BaseInvocation, InvocationContext
+from .image import ImageField, ImageOutput
 
 
-class CvInvocationConfig(BaseModel):
-    """Helper class to provide all OpenCV invocations with additional config"""
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["cv", "image"],
-            },
-        }
-
-
-class CvInpaintInvocation(BaseInvocation, CvInvocationConfig):
+class CvInpaintInvocation(BaseInvocation):
     """Simple inpaint using opencv."""
-
-    # fmt: off
+    #fmt: off
     type: Literal["cv_inpaint"] = "cv_inpaint"
 
     # Inputs
     image: ImageField = Field(default=None, description="The image to inpaint")
     mask: ImageField = Field(default=None, description="The mask to use when inpainting")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
-        )
-        mask = context.services.images.get_pil_image(
-            self.mask.image_origin, self.mask.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
+        mask = context.services.images.get(self.mask.image_type, self.mask.image_name)
 
         # Convert to cv image/mask
         # TODO: consider making these utility functions
         cv_image = cv.cvtColor(numpy.array(image.convert("RGB")), cv.COLOR_RGB2BGR)
-        cv_mask = numpy.array(ImageOps.invert(mask.convert("L")))
+        cv_mask = numpy.array(ImageOps.invert(mask))
 
         # Inpaint
         cv_inpainted = cv.inpaint(cv_image, cv_mask, 3, cv.INPAINT_TELEA)
@@ -55,20 +40,11 @@ class CvInpaintInvocation(BaseInvocation, CvInvocationConfig):
         # TODO: consider making a utility function
         image_inpainted = Image.fromarray(cv.cvtColor(cv_inpainted, cv.COLOR_BGR2RGB))
 
-        image_dto = context.services.images.create(
-            image=image_inpainted,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
-
+        context.services.images.save(image_type, image_name, image_inpainted)
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )

invokeai/app/invocations/generate.py

@@ -1,50 +1,26 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
 from functools import partial
-from typing import Literal, Optional, Union, get_args
+from typing import Literal, Optional, Union
 
 import numpy as np
-from diffusers import ControlNetModel
 from torch import Tensor
-import torch
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 
-from invokeai.app.models.image import ColorField, ImageField, ResourceOrigin
-from invokeai.app.invocations.util.choose_model import choose_model
-from invokeai.app.models.image import ImageCategory, ResourceOrigin
-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
+from ..services.image_storage import ImageType
+from .baseinvocation import BaseInvocation, InvocationContext
+from .image import ImageField, ImageOutput
 from ...backend.generator import Txt2Img, Img2Img, Inpaint, InvokeAIGenerator
 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"""
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["stable-diffusion", "image"],
-                "type_hints": {
-                    "model": "model",
-                },
-            },
-        }
+from ..util.util import diffusers_step_callback_adapter, CanceledException
 
+SAMPLER_NAME_VALUES = Literal[
+    tuple(InvokeAIGenerator.schedulers())
+]
 
 # Text to image
-class TextToImageInvocation(BaseInvocation, SDImageInvocation):
+class TextToImageInvocation(BaseInvocation):
     """Generates an image using text2img."""
 
     type: Literal["txt2img"] = "txt2img"
@@ -53,87 +29,66 @@ 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(ge=0, le=SEED_MAX, description="The seed to use (omit for random)", default_factory=get_random_seed)
-    steps:       int = Field(default=30, gt=0, description="The number of steps to use to generate the image")
-    width:       int = Field(default=512, multiple_of=8, gt=0, description="The width of the resulting image", )
-    height:      int = Field(default=512, multiple_of=8, gt=0, description="The height of the resulting image", )
-    cfg_scale: float = Field(default=7.5, ge=1, description="The Classifier-Free Guidance, higher values may result in a result closer to the prompt", )
-    scheduler: SAMPLER_NAME_VALUES = Field(default="euler", description="The scheduler to use" )
+    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", )
+    sampler_name: SAMPLER_NAME_VALUES = Field(default="k_lms", description="The sampler to use" )
+    seamless:   bool = Field(default=False, description="Whether or not to generate an image that can tile without seams", )
     model:       str = Field(default="", description="The model to use (currently ignored)")
     progress_images: bool = Field(default=False, description="Whether or not to produce progress images during generation",  )
-    control_model: Optional[str] = Field(default=None, description="The control model to use")
-    control_image: Optional[ImageField] = Field(default=None, description="The processed control image")
     # fmt: on
 
     # TODO: pass this an emitter method or something? or a session for dispatching?
     def dispatch_progress(
-        self,
-        context: InvocationContext,
-        source_node_id: str,
-        intermediate_state: PipelineIntermediateState,
+        self, context: InvocationContext, intermediate_state: PipelineIntermediateState
     ) -> None:
-        stable_diffusion_step_callback(
-            context=context,
-            intermediate_state=intermediate_state,
-            node=self.dict(),
-            source_node_id=source_node_id,
-        )
+        if (context.services.queue.is_canceled(context.graph_execution_state_id)):
+            raise CanceledException
+
+        step = intermediate_state.step
+        if intermediate_state.predicted_original is not None:
+            # Some schedulers report not only the noisy latents at the current timestep,
+            # but also their estimate so far of what the de-noised latents will be.
+            sample = intermediate_state.predicted_original
+        else:
+            sample = intermediate_state.latents
+        
+        diffusers_step_callback_adapter(sample, step, steps=self.steps, id=self.id, context=context)
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
+        # def step_callback(state: PipelineIntermediateState):
+        #     if (context.services.queue.is_canceled(context.graph_execution_state_id)):
+        #         raise CanceledException
+        #     self.dispatch_progress(context, state.latents, state.step)
+
         # 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_pil_image(
-                self.control_image.image_origin, 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?
-            # FIXME: generalize so don't have to hardcode torch_dtype and device
-            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(
+        # TODO: figure out if this can be done via a validator that uses the model_cache
+        # TODO: How to get the default model name now?
+        #       (right now uses whatever current model is set in model manager)
+        model= context.services.model_manager.get_model()
+        outputs = Txt2Img(model).generate(
             prompt=self.prompt,
-            step_callback=partial(self.dispatch_progress, context, source_node_id),
-            control_image=control_image,
+            step_callback=partial(self.dispatch_progress, context),
             **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
         # each time it is called. We only need the first one.
         generate_output = next(outputs)
 
-        image_dto = context.services.images.create(
-            image=generate_output.image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            session_id=context.graph_execution_state_id,
-            node_id=self.id,
-            is_intermediate=self.is_intermediate,
+        # Results are image and seed, unwrap for now and ignore the seed
+        # TODO: pre-seed?
+        # TODO: can this return multiple results? Should it?
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
-
+        context.services.images.save(image_type, image_name, generate_output.image)
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )
 
 
@@ -153,71 +108,63 @@ class ImageToImageInvocation(TextToImageInvocation):
     )
 
     def dispatch_progress(
-        self,
-        context: InvocationContext,
-        source_node_id: str,
-        intermediate_state: PipelineIntermediateState,
-    ) -> None:
-        stable_diffusion_step_callback(
-            context=context,
-            intermediate_state=intermediate_state,
-            node=self.dict(),
-            source_node_id=source_node_id,
-        )
+        self, context: InvocationContext, intermediate_state: PipelineIntermediateState
+    ) -> None:  
+        if (context.services.queue.is_canceled(context.graph_execution_state_id)):
+            raise CanceledException
+
+        step = intermediate_state.step
+        if intermediate_state.predicted_original is not None:
+            # Some schedulers report not only the noisy latents at the current timestep,
+            # but also their estimate so far of what the de-noised latents will be.
+            sample = intermediate_state.predicted_original
+        else:
+            sample = intermediate_state.latents
+
+        diffusers_step_callback_adapter(sample, step, steps=self.steps, id=self.id, context=context)
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
         image = (
             None
             if self.image is None
-            else context.services.images.get_pil_image(
-                self.image.image_origin, self.image.image_name
+            else context.services.images.get(
+                self.image.image_type, self.image.image_name
             )
         )
-
-        if self.fit:
-            image = image.resize((self.width, self.height))
+        mask = None
 
         # Handle invalid model parameter
-        model = choose_model(context.services.model_manager, self.model)
-
-        # Get the source node id (we are invoking the prepared node)
-        graph_execution_state = context.services.graph_execution_manager.get(
-            context.graph_execution_state_id
-        )
-        source_node_id = graph_execution_state.prepared_source_mapping[self.id]
-
+        # TODO: figure out if this can be done via a validator that uses the model_cache
+        # TODO: How to get the default model name now?
+        model = context.services.model_manager.get_model()
         outputs = Img2Img(model).generate(
-            prompt=self.prompt,
-            init_image=image,
-            step_callback=partial(self.dispatch_progress, context, source_node_id),
-            **self.dict(
-                exclude={"prompt", "image", "mask"}
-            ),  # Shorthand for passing all of the parameters above manually
-        )
+                prompt=self.prompt,
+                init_image=image,
+                init_mask=mask,
+                step_callback=partial(self.dispatch_progress, context),
+                **self.dict(
+                    exclude={"prompt", "image", "mask"}
+                ),  # Shorthand for passing all of the parameters above manually
+            )
 
         # Outputs is an infinite iterator that will return a new InvokeAIGeneratorOutput object
         # each time it is called. We only need the first one.
         generator_output = next(outputs)
 
-        image_dto = context.services.images.create(
-            image=generator_output.image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            session_id=context.graph_execution_state_id,
-            node_id=self.id,
-            is_intermediate=self.is_intermediate,
-        )
+        result_image = generator_output.image
 
+        # Results are image and seed, unwrap for now and ignore the seed
+        # TODO: pre-seed?
+        # TODO: can this return multiple results? Should it?
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
+        )
+        context.services.images.save(image_type, image_name, result_image)
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )
 
-
 class InpaintInvocation(ImageToImageInvocation):
     """Generates an image using inpaint."""
 
@@ -225,39 +172,6 @@ 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,
@@ -266,69 +180,63 @@ class InpaintInvocation(ImageToImageInvocation):
     )
 
     def dispatch_progress(
-        self,
-        context: InvocationContext,
-        source_node_id: str,
-        intermediate_state: PipelineIntermediateState,
-    ) -> None:
-        stable_diffusion_step_callback(
-            context=context,
-            intermediate_state=intermediate_state,
-            node=self.dict(),
-            source_node_id=source_node_id,
-        )
+        self, context: InvocationContext, intermediate_state: PipelineIntermediateState
+    ) -> None:  
+        if (context.services.queue.is_canceled(context.graph_execution_state_id)):
+            raise CanceledException
+
+        step = intermediate_state.step
+        if intermediate_state.predicted_original is not None:
+            # Some schedulers report not only the noisy latents at the current timestep,
+            # but also their estimate so far of what the de-noised latents will be.
+            sample = intermediate_state.predicted_original
+        else:
+            sample = intermediate_state.latents
+
+        diffusers_step_callback_adapter(sample, step, steps=self.steps, id=self.id, context=context)
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
         image = (
             None
             if self.image is None
-            else context.services.images.get_pil_image(
-                self.image.image_origin, self.image.image_name
+            else context.services.images.get(
+                self.image.image_type, self.image.image_name
             )
         )
         mask = (
             None
             if self.mask is None
-            else context.services.images.get_pil_image(self.mask.image_origin, self.mask.image_name)
+            else context.services.images.get(self.mask.image_type, self.mask.image_name)
         )
 
         # Handle invalid model parameter
-        model = choose_model(context.services.model_manager, self.model)
-
-        # Get the source node id (we are invoking the prepared node)
-        graph_execution_state = context.services.graph_execution_manager.get(
-            context.graph_execution_state_id
-        )
-        source_node_id = graph_execution_state.prepared_source_mapping[self.id]
-
+        # TODO: figure out if this can be done via a validator that uses the model_cache
+        # TODO: How to get the default model name now?
+        model = context.services.model_manager.get_model()
         outputs = Inpaint(model).generate(
-            prompt=self.prompt,
-            init_image=image,
-            mask_image=mask,
-            step_callback=partial(self.dispatch_progress, context, source_node_id),
-            **self.dict(
-                exclude={"prompt", "image", "mask"}
-            ),  # Shorthand for passing all of the parameters above manually
-        )
+                prompt=self.prompt,
+                init_img=image,
+                init_mask=mask,
+                step_callback=partial(self.dispatch_progress, context),
+                **self.dict(
+                    exclude={"prompt", "image", "mask"}
+                ),  # Shorthand for passing all of the parameters above manually
+            )
 
         # Outputs is an infinite iterator that will return a new InvokeAIGeneratorOutput object
         # each time it is called. We only need the first one.
         generator_output = next(outputs)
 
-        image_dto = context.services.images.create(
-            image=generator_output.image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            session_id=context.graph_execution_state_id,
-            node_id=self.id,
-            is_intermediate=self.is_intermediate,
-        )
+        result_image = generator_output.image
 
-        return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+        # Results are image and seed, unwrap for now and ignore the seed
+        # TODO: pre-seed?
+        # TODO: can this return multiple results? Should it?
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
+        )
+        context.services.images.save(image_type, image_name, result_image)
+        return ImageOutput(
+            image=ImageField(image_type=image_type, image_name=image_name)
         )

invokeai/app/invocations/image.py

@@ -1,86 +1,70 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-import io
-from typing import Literal, Optional, Union
+from datetime import datetime, timezone
+from typing import Literal, Optional
 
 import numpy
-from PIL import Image, ImageFilter, ImageOps, ImageChops
+from PIL import Image, ImageFilter, ImageOps
 from pydantic import BaseModel, Field
 
-from ..models.image import ImageCategory, ImageField, ResourceOrigin
-from .baseinvocation import (
-    BaseInvocation,
-    BaseInvocationOutput,
-    InvocationContext,
-    InvocationConfig,
-)
+from ..services.image_storage import ImageType
+from ..services.invocation_services import InvocationServices
+from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext
 
 
-class PILInvocationConfig(BaseModel):
-    """Helper class to provide all PIL invocations with additional config"""
+class ImageField(BaseModel):
+    """An image field used for passing image objects between invocations"""
 
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["PIL", "image"],
-            },
-        }
+    image_type: str = Field(
+        default=ImageType.RESULT, description="The type of the image"
+    )
+    image_name: Optional[str] = Field(default=None, description="The name of the image")
 
 
 class ImageOutput(BaseInvocationOutput):
     """Base class for invocations that output an image"""
-
-    # fmt: off
-    type: Literal["image_output"] = "image_output"
+    #fmt: off
+    type: Literal["image"] = "image"
     image:      ImageField = Field(default=None, description="The output image")
-    width:             int = Field(description="The width of the image in pixels")
-    height:            int = Field(description="The height of the image in pixels")
-    # fmt: on
-
-    class Config:
-        schema_extra = {"required": ["type", "image", "width", "height"]}
-
-
-class MaskOutput(BaseInvocationOutput):
-    """Base class for invocations that output a mask"""
-
-    # fmt: off
-    type: Literal["mask"] = "mask"
-    mask:      ImageField = Field(default=None, description="The output mask")
-    width:            int = Field(description="The width of the mask in pixels")
-    height:           int = Field(description="The height of the mask in pixels")
-    # fmt: on
+    #fmt: on
 
     class Config:
         schema_extra = {
-            "required": [
-                "type",
-                "mask",
+            'required': [
+                'type',
+                'image',
             ]
         }
 
+class MaskOutput(BaseInvocationOutput):
+    """Base class for invocations that output a mask"""
+    #fmt: off
+    type: Literal["mask"] = "mask"
+    mask:      ImageField = Field(default=None, description="The output mask")
+    #fmt: on
 
+    class Config:
+        schema_extra = {
+            'required': [
+                'type',
+                'mask',
+            ]
+        }
+
+# TODO: this isn't really necessary anymore
 class LoadImageInvocation(BaseInvocation):
-    """Load an image and provide it as output."""
-
-    # fmt: off
+    """Load an image from a filename and provide it as output."""
+    #fmt: off
     type: Literal["load_image"] = "load_image"
 
     # Inputs
-    image: Union[ImageField, None] = Field(
-        default=None, description="The image to load"
-    )
-    # fmt: on
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(self.image.image_origin, self.image.image_name)
+    image_type: ImageType = Field(description="The type of the image")
+    image_name:       str = Field(description="The name of the image")
+    #fmt: on
 
+    def invoke(self, context: InvocationContext) -> ImageOutput:
         return ImageOutput(
-            image=ImageField(
-                image_name=self.image.image_name,
-                image_origin=self.image.image_origin,
-            ),
-            width=image.width,
-            height=image.height,
+            image=ImageField(image_type=self.image_type, image_name=self.image_name)
         )
 
 
@@ -90,13 +74,11 @@ class ShowImageInvocation(BaseInvocation):
     type: Literal["show_image"] = "show_image"
 
     # Inputs
-    image: Union[ImageField, None] = Field(
-        default=None, description="The image to show"
-    )
+    image: ImageField = Field(default=None, description="The image to show")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
         if image:
             image.show()
@@ -105,31 +87,27 @@ class ShowImageInvocation(BaseInvocation):
 
         return ImageOutput(
             image=ImageField(
-                image_name=self.image.image_name,
-                image_origin=self.image.image_origin,
-            ),
-            width=image.width,
-            height=image.height,
+                image_type=self.image.image_type, image_name=self.image.image_name
+            )
         )
 
 
-class ImageCropInvocation(BaseInvocation, PILInvocationConfig):
+class CropImageInvocation(BaseInvocation):
     """Crops an image to a specified box. The box can be outside of the image."""
-
-    # fmt: off
-    type: Literal["img_crop"] = "img_crop"
+    #fmt: off
+    type: Literal["crop"] = "crop"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to crop")
+    image: ImageField = Field(default=None, description="The image to crop")
     x:      int = Field(default=0, description="The left x coordinate of the crop rectangle")
     y:      int = Field(default=0, description="The top y coordinate of the crop rectangle")
     width:  int = Field(default=512, gt=0, description="The width of the crop rectangle")
     height: int = Field(default=512, gt=0, description="The height of the crop rectangle")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
 
         image_crop = Image.new(
@@ -137,53 +115,41 @@ class ImageCropInvocation(BaseInvocation, PILInvocationConfig):
         )
         image_crop.paste(image, (-self.x, -self.y))
 
-        image_dto = context.services.images.create(
-            image=image_crop,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
-
+        context.services.images.save(image_type, image_name, image_crop)
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )
 
 
-class ImagePasteInvocation(BaseInvocation, PILInvocationConfig):
+class PasteImageInvocation(BaseInvocation):
     """Pastes an image into another image."""
-
-    # fmt: off
-    type: Literal["img_paste"] = "img_paste"
+    #fmt: off
+    type: Literal["paste"] = "paste"
 
     # Inputs
-    base_image:     Union[ImageField, None]  = Field(default=None, description="The base image")
-    image:          Union[ImageField, None]  = Field(default=None, description="The image to paste")
+    base_image:     ImageField = Field(default=None, description="The base image")
+    image:          ImageField = Field(default=None, description="The image to paste")
     mask: Optional[ImageField] = Field(default=None, description="The mask to use when pasting")
     x:                     int = Field(default=0, description="The left x coordinate at which to paste the image")
     y:                     int = Field(default=0, description="The top y coordinate at which to paste the image")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        base_image = context.services.images.get_pil_image(
-            self.base_image.image_origin, self.base_image.image_name
+        base_image = context.services.images.get(
+            self.base_image.image_type, self.base_image.image_name
         )
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
         mask = (
             None
             if self.mask is None
             else ImageOps.invert(
-                context.services.images.get_pil_image(
-                    self.mask.image_origin, self.mask.image_name
-                )
+                services.images.get(self.mask.image_type, self.mask.image_name)
             )
         )
         # TODO: probably shouldn't invert mask here... should user be required to do it?
@@ -199,195 +165,58 @@ class ImagePasteInvocation(BaseInvocation, PILInvocationConfig):
         new_image.paste(base_image, (abs(min_x), abs(min_y)))
         new_image.paste(image, (max(0, self.x), max(0, self.y)), mask=mask)
 
-        image_dto = context.services.images.create(
-            image=new_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
-
+        context.services.images.save(image_type, image_name, new_image)
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )
 
 
-class MaskFromAlphaInvocation(BaseInvocation, PILInvocationConfig):
+class MaskFromAlphaInvocation(BaseInvocation):
     """Extracts the alpha channel of an image as a mask."""
-
-    # fmt: off
+    #fmt: off
     type: Literal["tomask"] = "tomask"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to create the mask from")
+    image: ImageField = Field(default=None, description="The image to create the mask from")
     invert:      bool = Field(default=False, description="Whether or not to invert the mask")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> MaskOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
 
         image_mask = image.split()[-1]
         if self.invert:
             image_mask = ImageOps.invert(image_mask)
 
-        image_dto = context.services.images.create(
-            image=image_mask,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.MASK,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return MaskOutput(
-            mask=ImageField(
-                image_origin=image_dto.image_origin, image_name=image_dto.image_name
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
+        context.services.images.save(image_type, image_name, image_mask)
+        return MaskOutput(mask=ImageField(image_type=image_type, image_name=image_name))
 
 
-class ImageMultiplyInvocation(BaseInvocation, PILInvocationConfig):
-    """Multiplies two images together using `PIL.ImageChops.multiply()`."""
-
-    # fmt: off
-    type: Literal["img_mul"] = "img_mul"
-
-    # Inputs
-    image1: Union[ImageField, None]  = Field(default=None, description="The first image to multiply")
-    image2: Union[ImageField, None]  = Field(default=None, description="The second image to multiply")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image1 = context.services.images.get_pil_image(
-            self.image1.image_origin, self.image1.image_name
-        )
-        image2 = context.services.images.get_pil_image(
-            self.image2.image_origin, self.image2.image_name
-        )
-
-        multiply_image = ImageChops.multiply(image1, image2)
-
-        image_dto = context.services.images.create(
-            image=multiply_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(
-                image_origin=image_dto.image_origin, image_name=image_dto.image_name
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-IMAGE_CHANNELS = Literal["A", "R", "G", "B"]
-
-
-class ImageChannelInvocation(BaseInvocation, PILInvocationConfig):
-    """Gets a channel from an image."""
-
-    # fmt: off
-    type: Literal["img_chan"] = "img_chan"
-
-    # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to get the channel from")
-    channel: IMAGE_CHANNELS  = Field(default="A", description="The channel to get")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
-        )
-
-        channel_image = image.getchannel(self.channel)
-
-        image_dto = context.services.images.create(
-            image=channel_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(
-                image_origin=image_dto.image_origin, image_name=image_dto.image_name
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-IMAGE_MODES = Literal["L", "RGB", "RGBA", "CMYK", "YCbCr", "LAB", "HSV", "I", "F"]
-
-
-class ImageConvertInvocation(BaseInvocation, PILInvocationConfig):
-    """Converts an image to a different mode."""
-
-    # fmt: off
-    type: Literal["img_conv"] = "img_conv"
-
-    # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to convert")
-    mode: IMAGE_MODES  = Field(default="L", description="The mode to convert to")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
-        )
-
-        converted_image = image.convert(self.mode)
-
-        image_dto = context.services.images.create(
-            image=converted_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(
-                image_origin=image_dto.image_origin, image_name=image_dto.image_name
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-class ImageBlurInvocation(BaseInvocation, PILInvocationConfig):
+class BlurInvocation(BaseInvocation):
     """Blurs an image"""
 
-    # fmt: off
-    type: Literal["img_blur"] = "img_blur"
+    #fmt: off
+    type: Literal["blur"] = "blur"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to blur")
+    image: ImageField = Field(default=None, description="The image to blur")
     radius:     float = Field(default=8.0, ge=0, description="The blur radius")
     blur_type: Literal["gaussian", "box"] = Field(default="gaussian", description="The type of blur")
-    # fmt: on
-
+    #fmt: on
+    
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
 
         blur = (
@@ -397,149 +226,30 @@ class ImageBlurInvocation(BaseInvocation, PILInvocationConfig):
         )
         blur_image = image.filter(blur)
 
-        image_dto = context.services.images.create(
-            image=blur_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
-
+        context.services.images.save(image_type, image_name, blur_image)
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )
 
 
-PIL_RESAMPLING_MODES = Literal[
-    "nearest",
-    "box",
-    "bilinear",
-    "hamming",
-    "bicubic",
-    "lanczos",
-]
-
-
-PIL_RESAMPLING_MAP = {
-    "nearest": Image.Resampling.NEAREST,
-    "box": Image.Resampling.BOX,
-    "bilinear": Image.Resampling.BILINEAR,
-    "hamming": Image.Resampling.HAMMING,
-    "bicubic": Image.Resampling.BICUBIC,
-    "lanczos": Image.Resampling.LANCZOS,
-}
-
-
-class ImageResizeInvocation(BaseInvocation, PILInvocationConfig):
-    """Resizes an image to specific dimensions"""
-
-    # fmt: off
-    type: Literal["img_resize"] = "img_resize"
-
-    # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to resize")
-    width:                         int = Field(ge=64, multiple_of=8, description="The width to resize to (px)")
-    height:                        int = Field(ge=64, multiple_of=8, description="The height to resize to (px)")
-    resample_mode:  PIL_RESAMPLING_MODES = Field(default="bicubic", description="The resampling mode")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
-        )
-
-        resample_mode = PIL_RESAMPLING_MAP[self.resample_mode]
-
-        resize_image = image.resize(
-            (self.width, self.height),
-            resample=resample_mode,
-        )
-
-        image_dto = context.services.images.create(
-            image=resize_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-class ImageScaleInvocation(BaseInvocation, PILInvocationConfig):
-    """Scales an image by a factor"""
-
-    # fmt: off
-    type: Literal["img_scale"] = "img_scale"
-
-    # Inputs
-    image:       Union[ImageField, None] = Field(default=None, description="The image to scale")
-    scale_factor:                  float = Field(gt=0, description="The factor by which to scale the image")
-    resample_mode:  PIL_RESAMPLING_MODES = Field(default="bicubic", description="The resampling mode")
-    # fmt: on
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
-        )
-
-        resample_mode = PIL_RESAMPLING_MAP[self.resample_mode]
-        width = int(image.width * self.scale_factor)
-        height = int(image.height * self.scale_factor)
-
-        resize_image = image.resize(
-            (width, height),
-            resample=resample_mode,
-        )
-
-        image_dto = context.services.images.create(
-            image=resize_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
-        )
-
-        return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
-
-class ImageLerpInvocation(BaseInvocation, PILInvocationConfig):
+class LerpInvocation(BaseInvocation):
     """Linear interpolation of all pixels of an image"""
-
-    # fmt: off
-    type: Literal["img_lerp"] = "img_lerp"
+    #fmt: off
+    type: Literal["lerp"] = "lerp"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to lerp")
+    image: ImageField = Field(default=None, description="The image to lerp")
     min: int = Field(default=0, ge=0, le=255, description="The minimum output value")
     max: int = Field(default=255, ge=0, le=255, description="The maximum output value")
-    # fmt: on
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
 
         image_arr = numpy.asarray(image, dtype=numpy.float32) / 255
@@ -547,40 +257,30 @@ class ImageLerpInvocation(BaseInvocation, PILInvocationConfig):
 
         lerp_image = Image.fromarray(numpy.uint8(image_arr))
 
-        image_dto = context.services.images.create(
-            image=lerp_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
-
+        context.services.images.save(image_type, image_name, lerp_image)
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )
 
 
-class ImageInverseLerpInvocation(BaseInvocation, PILInvocationConfig):
+class InverseLerpInvocation(BaseInvocation):
     """Inverse linear interpolation of all pixels of an image"""
-
-    # fmt: off
-    type: Literal["img_ilerp"] = "img_ilerp"
+    #fmt: off
+    type: Literal["ilerp"] = "ilerp"
 
     # Inputs
-    image: Union[ImageField, None]  = Field(default=None, description="The image to lerp")
+    image: ImageField = Field(default=None, description="The image to lerp")
     min: int = Field(default=0, ge=0, le=255, description="The minimum input value")
     max: int = Field(default=255, ge=0, le=255, description="The maximum input value")
-    # fmt: on
-
+    #fmt: on
+    
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
 
         image_arr = numpy.asarray(image, dtype=numpy.float32)
@@ -593,20 +293,11 @@ class ImageInverseLerpInvocation(BaseInvocation, PILInvocationConfig):
 
         ilerp_image = Image.fromarray(numpy.uint8(image_arr))
 
-        image_dto = context.services.images.create(
-            image=ilerp_image,
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.INTERMEDIATE
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
-
+        context.services.images.save(image_type, image_name, ilerp_image)
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )

invokeai/app/invocations/infill.py

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

invokeai/app/invocations/latent.py

@@ -1,41 +1,28 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
 
-import random
-import einops
-from typing import Literal, Optional, Union, List
-
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
-
-from pydantic import BaseModel, Field, validator
+from typing import Literal, Optional
+from pydantic import BaseModel, Field
+from torch import Tensor
 import torch
 
-from invokeai.app.invocations.util.choose_model import choose_model
-from invokeai.app.models.image import ImageCategory
-from invokeai.app.util.misc import SEED_MAX, get_random_seed
-
-from invokeai.app.util.step_callback import stable_diffusion_step_callback
-from .controlnet_image_processors import ControlField
-
 from ...backend.model_management.model_manager import ModelManager
-from ...backend.util.devices import choose_torch_device, torch_dtype
+from ...backend.util.devices import CUDA_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, image_resized_to_grid_as_tensor
-from ...backend.stable_diffusion.schedulers import SCHEDULER_MAP
-from ...backend.stable_diffusion.diffusers_pipeline import ControlNetData
-
-from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext, InvocationConfig
+from ...backend.stable_diffusion.diffusers_pipeline import ConditioningData, StableDiffusionGeneratorPipeline
+from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext
 import numpy as np
-from ..services.image_file_storage import ResourceOrigin
+from accelerate.utils import set_seed
+from ..services.image_storage import ImageType
 from .baseinvocation import BaseInvocation, InvocationContext
 from .image import ImageField, ImageOutput
-from .compel import ConditioningField
+from ...backend.generator import Generator
 from ...backend.stable_diffusion import PipelineIntermediateState
+from ...backend.util.util import image_to_dataURL
 from diffusers.schedulers import SchedulerMixin as Scheduler
 import diffusers
-from diffusers import DiffusionPipeline, ControlNetModel
+from diffusers import DiffusionPipeline
 
 
 class LatentsField(BaseModel):
@@ -43,61 +30,45 @@ class LatentsField(BaseModel):
 
     latents_name: Optional[str] = Field(default=None, description="The name of the latents")
 
-    class Config:
-        schema_extra = {"required": ["latents_name"]}
 
 class LatentsOutput(BaseInvocationOutput):
     """Base class for invocations that output latents"""
     #fmt: off
-    type: Literal["latents_output"] = "latents_output"
-
-    # Inputs
-    latents: LatentsField          = Field(default=None, description="The output latents")
-    width:                     int = Field(description="The width of the latents in pixels")
-    height:                    int = Field(description="The height of the latents in pixels")
+    type: Literal["latent_output"] = "latent_output"
+    latents: LatentsField            = Field(default=None, description="The output latents")
     #fmt: on
 
-
-def build_latents_output(latents_name: str, latents: torch.Tensor):
-      return LatentsOutput(
-          latents=LatentsField(latents_name=latents_name),
-          width=latents.size()[3] * 8,
-          height=latents.size()[2] * 8,
-      )
-
 class NoiseOutput(BaseInvocationOutput):
     """Invocation noise output"""
     #fmt: off
-    type:  Literal["noise_output"] = "noise_output"
-
-    # Inputs
+    type: Literal["noise_output"] = "noise_output"
     noise: LatentsField            = Field(default=None, description="The output noise")
-    width:                     int = Field(description="The width of the noise in pixels")
-    height:                    int = Field(description="The height of the noise in pixels")
     #fmt: on
 
-def build_noise_output(latents_name: str, latents: torch.Tensor):
-      return NoiseOutput(
-          noise=LatentsField(latents_name=latents_name),
-          width=latents.size()[3] * 8,
-          height=latents.size()[2] * 8,
-      )
+
+# TODO: this seems like a hack
+scheduler_map = dict(
+    ddim=diffusers.DDIMScheduler,
+    dpmpp_2=diffusers.DPMSolverMultistepScheduler,
+    k_dpm_2=diffusers.KDPM2DiscreteScheduler,
+    k_dpm_2_a=diffusers.KDPM2AncestralDiscreteScheduler,
+    k_dpmpp_2=diffusers.DPMSolverMultistepScheduler,
+    k_euler=diffusers.EulerDiscreteScheduler,
+    k_euler_a=diffusers.EulerAncestralDiscreteScheduler,
+    k_heun=diffusers.HeunDiscreteScheduler,
+    k_lms=diffusers.LMSDiscreteScheduler,
+    plms=diffusers.PNDMScheduler,
+)
 
 
 SAMPLER_NAME_VALUES = Literal[
-    tuple(list(SCHEDULER_MAP.keys()))
+    tuple(list(scheduler_map.keys()))
 ]
 
 
 def get_scheduler(scheduler_name:str, model: StableDiffusionGeneratorPipeline)->Scheduler:
-    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)
-
+    scheduler_class = scheduler_map.get(scheduler_name,'ddim')
+    scheduler = scheduler_class.from_config(model.scheduler.config)
     # hack copied over from generate.py
     if not hasattr(scheduler, 'uses_inpainting_model'):
         scheduler.uses_inpainting_model = lambda: False
@@ -134,105 +105,96 @@ class NoiseInvocation(BaseInvocation):
     type: Literal["noise"] = "noise"
 
     # Inputs
-    seed:       int = Field(ge=0, le=SEED_MAX, description="The seed to use", default_factory=get_random_seed)
-    width:       int = Field(default=512, multiple_of=8, gt=0, description="The width of the resulting noise", )
-    height:      int = Field(default=512, multiple_of=8, gt=0, description="The height of the resulting noise", )
-
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["latents", "noise"],
-            },
-        }
-
-    @validator("seed", pre=True)
-    def modulo_seed(cls, v):
-        """Returns the seed modulo SEED_MAX to ensure it is within the valid range."""
-        return v % SEED_MAX
+    seed:        int = Field(default=0, ge=0, le=np.iinfo(np.uint32).max, description="The seed to use", )
+    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", )
 
     def invoke(self, context: InvocationContext) -> NoiseOutput:
-        device = torch.device(choose_torch_device())
+        device = torch.device(CUDA_DEVICE)
         noise = get_noise(self.width, self.height, device, self.seed)
 
         name = f'{context.graph_execution_state_id}__{self.id}'
-        context.services.latents.save(name, noise)
-        return build_noise_output(latents_name=name, latents=noise)
+        context.services.latents.set(name, noise)
+        return NoiseOutput(
+            noise=LatentsField(latents_name=name)
+        )
 
 
 # Text to image
 class TextToLatentsInvocation(BaseInvocation):
-    """Generates latents from conditionings."""
+    """Generates latents from a prompt."""
 
     type: Literal["t2l"] = "t2l"
 
     # Inputs
+    # TODO: consider making prompt optional to enable providing prompt through a link
     # fmt: off
-    positive_conditioning: Optional[ConditioningField] = Field(description="Positive conditioning for generation")
-    negative_conditioning: Optional[ConditioningField] = Field(description="Negative conditioning for generation")
+    prompt: Optional[str] = Field(description="The prompt to generate an image from")
+    seed:        int = Field(default=-1,ge=-1, le=np.iinfo(np.uint32).max, description="The seed to use (-1 for a random seed)", )
     noise: Optional[LatentsField] = Field(description="The noise to use")
     steps:       int = Field(default=10, gt=0, description="The number of steps to use to generate the image")
-    cfg_scale: float = Field(default=7.5, ge=1, description="The Classifier-Free Guidance, higher values may result in a result closer to the prompt", )
-    scheduler: SAMPLER_NAME_VALUES = Field(default="euler", description="The scheduler to use" )
+    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", )
+    sampler_name: SAMPLER_NAME_VALUES = Field(default="k_lms", description="The sampler to use" )
+    seamless:   bool = Field(default=False, description="Whether or not to generate an image that can tile without seams", )
+    seamless_axes: str = Field(default="", description="The axes to tile the image on, 'x' and/or 'y'")
     model:       str = Field(default="", description="The model to use (currently ignored)")
-    control: Union[ControlField, list[ControlField]] = Field(default=None, description="The control to use")
-    # seamless:   bool = Field(default=False, description="Whether or not to generate an image that can tile without seams", )
-    # seamless_axes: str = Field(default="", description="The axes to tile the image on, 'x' and/or 'y'")
+    progress_images: bool = Field(default=False, description="Whether or not to produce progress images during generation",  )
     # fmt: on
 
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["latents", "image"],
-                "type_hints": {
-                  "model": "model",
-                  "control": "control",
-                }
-            },
-        }
-
     # TODO: pass this an emitter method or something? or a session for dispatching?
     def dispatch_progress(
-        self, context: InvocationContext, source_node_id: str, intermediate_state: PipelineIntermediateState
-    ) -> None:
-        stable_diffusion_step_callback(
-            context=context,
-            intermediate_state=intermediate_state,
-            node=self.dict(),
-            source_node_id=source_node_id,
-        )
+        self, context: InvocationContext, sample: Tensor, step: int
+    ) -> None:  
+        # TODO: only output a preview image when requested
+        image = Generator.sample_to_lowres_estimated_image(sample)
 
+        (width, height) = image.size
+        width *= 8
+        height *= 8
+
+        dataURL = image_to_dataURL(image, image_format="JPEG")
+
+        context.services.events.emit_generator_progress(
+            context.graph_execution_state_id,
+            self.id,
+            {
+                "width": width,
+                "height": height,
+                "dataURL": dataURL
+            },
+            step,
+            self.steps,
+        )
+    
     def get_model(self, model_manager: ModelManager) -> StableDiffusionGeneratorPipeline:
-        model_info = choose_model(model_manager, self.model)
+        model_info = model_manager.get_model(self.model)
         model_name = model_info['model_name']
         model_hash = model_info['hash']
         model: StableDiffusionGeneratorPipeline = model_info['model']
         model.scheduler = get_scheduler(
             model=model,
-            scheduler_name=self.scheduler
+            scheduler_name=self.sampler_name
         )
-
-        # if isinstance(model, DiffusionPipeline):
-        #     for component in [model.unet, model.vae]:
-        #         configure_model_padding(component,
-        #                                 self.seamless,
-        #                                 self.seamless_axes
-        #                                 )
-        # else:
-        #     configure_model_padding(model,
-        #                             self.seamless,
-        #                             self.seamless_axes
-        #                             )
+        
+        if isinstance(model, DiffusionPipeline):
+            for component in [model.unet, model.vae]:
+                configure_model_padding(component,
+                                        self.seamless,
+                                        self.seamless_axes
+                                        )
+        else:
+            configure_model_padding(model,
+                                    self.seamless,
+                                    self.seamless_axes
+                                    )
 
         return model
 
 
-    def get_conditioning_data(self, 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)
-
+    def get_conditioning_data(self, model: StableDiffusionGeneratorPipeline) -> ConditioningData:
+        uc, c, extra_conditioning_info = get_uc_and_c_and_ec(self.prompt, model=model)
         conditioning_data = ConditioningData(
             uc,
             c,
@@ -244,119 +206,37 @@ 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=0.0)#ddim_eta)
+        ).add_scheduler_args_if_applicable(model.scheduler, eta=None)#ddim_eta)
         return conditioning_data
 
-    def prep_control_data(self,
-                          context: InvocationContext,
-                          model: StableDiffusionGeneratorPipeline, # really only need model for dtype and device
-                          control_input: List[ControlField],
-                          latents_shape: List[int],
-                          do_classifier_free_guidance: bool = True,
-                          ) -> List[ControlNetData]:
-        # assuming fixed dimensional scaling of 8:1 for image:latents
-        control_height_resize = latents_shape[2] * 8
-        control_width_resize = latents_shape[3] * 8
-        if control_input is None:
-            # print("control input is None")
-            control_list = None
-        elif isinstance(control_input, list) and len(control_input) == 0:
-            # print("control input is empty list")
-            control_list = None
-        elif isinstance(control_input, ControlField):
-            # print("control input is ControlField")
-            control_list = [control_input]
-        elif isinstance(control_input, list) and len(control_input) > 0 and isinstance(control_input[0], ControlField):
-            # print("control input is list[ControlField]")
-            control_list = control_input
-        else:
-            # print("input control is unrecognized:", type(self.control))
-            control_list = None
-        if (control_list is None):
-            control_data = None
-            # from above handling, any control that is not None should now be of type list[ControlField]
-        else:
-            # FIXME: add checks to skip entry if model or image is None
-            #        and if weight is None, populate with default 1.0?
-            control_data = []
-            control_models = []
-            for control_info in control_list:
-                # handle control models
-                if ("," in control_info.control_model):
-                    control_model_split = control_info.control_model.split(",")
-                    control_name = control_model_split[0]
-                    control_subfolder = control_model_split[1]
-                    print("Using HF model subfolders")
-                    print("    control_name: ", control_name)
-                    print("    control_subfolder: ", control_subfolder)
-                    control_model = ControlNetModel.from_pretrained(control_name,
-                                                                    subfolder=control_subfolder,
-                                                                    torch_dtype=model.unet.dtype).to(model.device)
-                else:
-                    control_model = ControlNetModel.from_pretrained(control_info.control_model,
-                                                                    torch_dtype=model.unet.dtype).to(model.device)
-                control_models.append(control_model)
-                control_image_field = control_info.image
-                input_image = context.services.images.get_pil_image(control_image_field.image_origin,
-                                                                    control_image_field.image_name)
-                # self.image.image_type, self.image.image_name
-                # FIXME: still need to test with different widths, heights, devices, dtypes
-                #        and add in batch_size, num_images_per_prompt?
-                #        and do real check for classifier_free_guidance?
-                # prepare_control_image should return torch.Tensor of shape(batch_size, 3, height, width)
-                control_image = model.prepare_control_image(
-                    image=input_image,
-                    do_classifier_free_guidance=do_classifier_free_guidance,
-                    width=control_width_resize,
-                    height=control_height_resize,
-                    # batch_size=batch_size * num_images_per_prompt,
-                    # num_images_per_prompt=num_images_per_prompt,
-                    device=control_model.device,
-                    dtype=control_model.dtype,
-                )
-                control_item = ControlNetData(model=control_model,
-                                              image_tensor=control_image,
-                                              weight=control_info.control_weight,
-                                              begin_step_percent=control_info.begin_step_percent,
-                                              end_step_percent=control_info.end_step_percent)
-                control_data.append(control_item)
-                # MultiControlNetModel has been refactored out, just need list[ControlNetData]
-        return control_data
 
     def invoke(self, context: InvocationContext) -> LatentsOutput:
         noise = context.services.latents.get(self.noise.latents_name)
 
-        # 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]
-
         def step_callback(state: PipelineIntermediateState):
-            self.dispatch_progress(context, source_node_id, state)
+            self.dispatch_progress(context, state.latents, state.step)
 
         model = self.get_model(context.services.model_manager)
-        conditioning_data = self.get_conditioning_data(context, model)
-
-        print("type of control input: ", type(self.control))
-        control_data = self.prep_control_data(model=model, context=context, control_input=self.control,
-                                              latents_shape=noise.shape,
-                                              do_classifier_free_guidance=(self.cfg_scale >= 1.0))
+        conditioning_data = self.get_conditioning_data(model)
 
         # TODO: Verify the noise is the right size
+
         result_latents, result_attention_map_saver = model.latents_from_embeddings(
             latents=torch.zeros_like(noise, dtype=torch_dtype(model.device)),
             noise=noise,
             num_inference_steps=self.steps,
             conditioning_data=conditioning_data,
-            control_data=control_data,  # list[ControlNetData]
-            callback=step_callback,
+            callback=step_callback
         )
 
         # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
         torch.cuda.empty_cache()
 
         name = f'{context.graph_execution_state_id}__{self.id}'
-        context.services.latents.save(name, result_latents)
-        return build_latents_output(latents_name=name, latents=result_latents)
+        context.services.latents.set(name, result_latents)
+        return LatentsOutput(
+            latents=LatentsField(latents_name=name)
+        )
 
 
 class LatentsToLatentsInvocation(TextToLatentsInvocation):
@@ -366,46 +246,29 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
 
     # Inputs
     latents: Optional[LatentsField] = Field(description="The latents to use as a base image")
-    strength: float = Field(default=0.7, ge=0, le=1, description="The strength of the latents to use")
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["latents"],
-                "type_hints": {
-                    "model": "model",
-                    "control": "control",
-                }
-            },
-        }
+    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)
 
-        # 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]
-
         def step_callback(state: PipelineIntermediateState):
-            self.dispatch_progress(context, source_node_id, state)
+            self.dispatch_progress(context, state.latents, state.step)
 
         model = self.get_model(context.services.model_manager)
-        conditioning_data = self.get_conditioning_data(context, model)
-
-        print("type of control input: ", type(self.control))
-        control_data = self.prep_control_data(model=model, context=context, control_input=self.control,
-                                              latents_shape=noise.shape,
-                                              do_classifier_free_guidance=(self.cfg_scale >= 1.0))
+        conditioning_data = self.get_conditioning_data(model)
 
         # TODO: Verify the noise is the right size
 
         initial_latents = latent if self.strength < 1.0 else torch.zeros_like(
             latent, device=model.device, dtype=latent.dtype
         )
-
-        timesteps, _ = model.get_img2img_timesteps(self.steps, self.strength)
+        
+        timesteps, _ = model.get_img2img_timesteps(
+            self.steps,
+            self.strength,
+            device=model.device,
+        )
 
         result_latents, result_attention_map_saver = model.latents_from_embeddings(
             latents=initial_latents,
@@ -413,7 +276,6 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
             noise=noise,
             num_inference_steps=self.steps,
             conditioning_data=conditioning_data,
-            control_data=control_data,  # list[ControlNetData]
             callback=step_callback
         )
 
@@ -421,8 +283,10 @@ class LatentsToLatentsInvocation(TextToLatentsInvocation):
         torch.cuda.empty_cache()
 
         name = f'{context.graph_execution_state_id}__{self.id}'
-        context.services.latents.save(name, result_latents)
-        return build_latents_output(latents_name=name, latents=result_latents)
+        context.services.latents.set(name, result_latents)
+        return LatentsOutput(
+            latents=LatentsField(latents_name=name)
+        )
 
 
 # Latent to image
@@ -435,166 +299,23 @@ class LatentsToImageInvocation(BaseInvocation):
     latents: Optional[LatentsField] = Field(description="The latents to generate an image from")
     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) -> ImageOutput:
         latents = context.services.latents.get(self.latents.latents_name)
 
         # TODO: this only really needs the vae
-        model_info = choose_model(context.services.model_manager, self.model)
+        model_info = context.services.model_manager.get_model(self.model)
         model: StableDiffusionGeneratorPipeline = model_info['model']
 
         with torch.inference_mode():
             np_image = model.decode_latents(latents)
             image = model.numpy_to_pil(np_image)[0]
 
-            # what happened to metadata?
-            # metadata = context.services.metadata.build_metadata(
-            #     session_id=context.graph_execution_state_id, node=self
-
-            torch.cuda.empty_cache()
-
-            # new (post Image service refactor) way of using services to save image
-            #     and gnenerate unique image_name
-            image_dto = context.services.images.create(
-                image=image,
-                image_origin=ResourceOrigin.INTERNAL,
-                image_category=ImageCategory.GENERAL,
-                session_id=context.graph_execution_state_id,
-                node_id=self.id,
-                is_intermediate=self.is_intermediate
+            image_type = ImageType.RESULT
+            image_name = context.services.images.create_name(
+                context.graph_execution_state_id, self.id
             )
-
+            context.services.images.save(image_type, image_name, image)
             return ImageOutput(
-                image=ImageField(
-                    image_name=image_dto.image_name,
-                    image_origin=image_dto.image_origin,
-                ),
-                width=image_dto.width,
-                height=image_dto.height,
+                image=ImageField(image_type=image_type, image_name=image_name)
             )
-
-
-LATENTS_INTERPOLATION_MODE = Literal[
-    "nearest", "linear", "bilinear", "bicubic", "trilinear", "area", "nearest-exact"
-]
-
-
-class ResizeLatentsInvocation(BaseInvocation):
-    """Resizes latents to explicit width/height (in pixels). Provided dimensions are floor-divided by 8."""
-
-    type: Literal["lresize"] = "lresize"
-
-    # Inputs
-    latents:    Optional[LatentsField] = Field(description="The latents to resize")
-    width:                         int = Field(ge=64, multiple_of=8, description="The width to resize to (px)")
-    height:                        int = Field(ge=64, multiple_of=8, description="The height to resize to (px)")
-    mode:   LATENTS_INTERPOLATION_MODE = Field(default="bilinear", description="The interpolation mode")
-    antialias:                    bool = Field(default=False, description="Whether or not to antialias (applied in bilinear and bicubic modes only)")
-
-    def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = context.services.latents.get(self.latents.latents_name)
-
-        resized_latents = torch.nn.functional.interpolate(
-            latents,
-            size=(self.height // 8, self.width // 8),
-            mode=self.mode,
-            antialias=self.antialias if self.mode in ["bilinear", "bicubic"] else False,
-        )
-
-        # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
-        torch.cuda.empty_cache()
-
-        name = f"{context.graph_execution_state_id}__{self.id}"
-        # context.services.latents.set(name, resized_latents)
-        context.services.latents.save(name, resized_latents)
-        return build_latents_output(latents_name=name, latents=resized_latents)
-
-
-class ScaleLatentsInvocation(BaseInvocation):
-    """Scales latents by a given factor."""
-
-    type: Literal["lscale"] = "lscale"
-
-    # Inputs
-    latents:   Optional[LatentsField] = Field(description="The latents to scale")
-    scale_factor:               float = Field(gt=0, description="The factor by which to scale the latents")
-    mode:  LATENTS_INTERPOLATION_MODE = Field(default="bilinear", description="The interpolation mode")
-    antialias:                   bool = Field(default=False, description="Whether or not to antialias (applied in bilinear and bicubic modes only)")
-
-    def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = context.services.latents.get(self.latents.latents_name)
-
-        # resizing
-        resized_latents = torch.nn.functional.interpolate(
-            latents,
-            scale_factor=self.scale_factor,
-            mode=self.mode,
-            antialias=self.antialias if self.mode in ["bilinear", "bicubic"] else False,
-        )
-
-        # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
-        torch.cuda.empty_cache()
-
-        name = f"{context.graph_execution_state_id}__{self.id}"
-        # context.services.latents.set(name, resized_latents)
-        context.services.latents.save(name, resized_latents)
-        return build_latents_output(latents_name=name, latents=resized_latents)
-
-
-class ImageToLatentsInvocation(BaseInvocation):
-    """Encodes an image into latents."""
-
-    type: Literal["i2l"] = "i2l"
-
-    # Inputs
-    image: Union[ImageField, None] = Field(description="The image to encode")
-    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
-        # )
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, 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)
-        context.services.latents.save(name, latents)
-        return build_latents_output(latents_name=name, latents=latents)

invokeai/app/invocations/math.py

@@ -1,109 +1,68 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
 
-from typing import Literal
+from datetime import datetime, timezone
+from typing import Literal, Optional
 
+import numpy
+from PIL import Image, ImageFilter, ImageOps
 from pydantic import BaseModel, Field
-import numpy as np
 
-from .baseinvocation import (
-    BaseInvocation,
-    BaseInvocationOutput,
-    InvocationContext,
-    InvocationConfig,
-)
-
-
-class MathInvocationConfig(BaseModel):
-    """Helper class to provide all math invocations with additional config"""
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["math"],
-            }
-        }
+from ..services.image_storage import ImageType
+from ..services.invocation_services import InvocationServices
+from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext
 
 
 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 FloatOutput(BaseInvocationOutput):
-    """A float output"""
-
-    # fmt: off
-    type: Literal["float_output"] = "float_output"
-    param: float = Field(default=None, description="The output float")
-    # fmt: on
-
-
-class AddInvocation(BaseInvocation, MathInvocationConfig):
+class AddInvocation(BaseInvocation):
     """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)
 
 
-class SubtractInvocation(BaseInvocation, MathInvocationConfig):
+class SubtractInvocation(BaseInvocation):
     """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)
 
 
-class MultiplyInvocation(BaseInvocation, MathInvocationConfig):
+class MultiplyInvocation(BaseInvocation):
     """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)
 
 
-class DivideInvocation(BaseInvocation, MathInvocationConfig):
+class DivideInvocation(BaseInvocation):
     """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/params.py

@@ -1,28 +0,0 @@
-# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
-
-from typing import Literal
-from pydantic import Field
-from .baseinvocation import BaseInvocation, BaseInvocationOutput, InvocationContext
-from .math import IntOutput, FloatOutput
-
-# Pass-through parameter nodes - used by subgraphs
-
-class ParamIntInvocation(BaseInvocation):
-    """An integer parameter"""
-    #fmt: off
-    type: Literal["param_int"] = "param_int"
-    a: int = Field(default=0, description="The integer value")
-    #fmt: on
-
-    def invoke(self, context: InvocationContext) -> IntOutput:
-        return IntOutput(a=self.a)
-
-class ParamFloatInvocation(BaseInvocation):
-    """A float parameter"""
-    #fmt: off
-    type: Literal["param_float"] = "param_float"
-    param: float = Field(default=0.0, description="The float value")
-    #fmt: on
-
-    def invoke(self, context: InvocationContext) -> FloatOutput:
-        return FloatOutput(param=self.param)

invokeai/app/invocations/reconstruct.py

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

invokeai/app/invocations/upscale.py

@@ -1,37 +1,30 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
+from datetime import datetime, timezone
 from typing import Literal, Union
 
 from pydantic import Field
 
-from invokeai.app.models.image import ImageCategory, ImageField, ResourceOrigin
-from .baseinvocation import BaseInvocation, InvocationContext, InvocationConfig
-from .image import ImageOutput
+from ..services.image_storage import ImageType
+from ..services.invocation_services import InvocationServices
+from .baseinvocation import BaseInvocation, InvocationContext
+from .image import ImageField, ImageOutput
 
 
 class UpscaleInvocation(BaseInvocation):
     """Upscales an image."""
-
-    # fmt: off
+    #fmt: off
     type: Literal["upscale"] = "upscale"
 
     # Inputs
     image: Union[ImageField, None] = Field(description="The input image", default=None)
     strength: float = Field(default=0.75, gt=0, le=1, description="The strength")
     level: Literal[2, 4] = Field(default=2, description="The upscale level")
-    # fmt: on
-
-    # Schema customisation
-    class Config(InvocationConfig):
-        schema_extra = {
-            "ui": {
-                "tags": ["upscaling", "image"],
-            },
-        }
+    #fmt: on
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.services.images.get_pil_image(
-            self.image.image_origin, self.image.image_name
+        image = context.services.images.get(
+            self.image.image_type, self.image.image_name
         )
         results = context.services.restoration.upscale_and_reconstruct(
             image_list=[[image, 0]],
@@ -43,20 +36,11 @@ class UpscaleInvocation(BaseInvocation):
 
         # Results are image and seed, unwrap for now
         # TODO: can this return multiple results?
-        image_dto = context.services.images.create(
-            image=results[0][0],
-            image_origin=ResourceOrigin.INTERNAL,
-            image_category=ImageCategory.GENERAL,
-            node_id=self.id,
-            session_id=context.graph_execution_state_id,
-            is_intermediate=self.is_intermediate,
+        image_type = ImageType.RESULT
+        image_name = context.services.images.create_name(
+            context.graph_execution_state_id, self.id
         )
-
+        context.services.images.save(image_type, image_name, results[0][0])
         return ImageOutput(
-            image=ImageField(
-                image_name=image_dto.image_name,
-                image_origin=image_dto.image_origin,
-            ),
-            width=image_dto.width,
-            height=image_dto.height,
+            image=ImageField(image_type=image_type, image_name=image_name)
         )

invokeai/app/invocations/util/choose_model.py

@@ -1,14 +0,0 @@
-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."""
-    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()
-    else:
-        model = model_manager.get_model(model_name)
-
-    return model

invokeai/app/models/exceptions.py

@@ -1,3 +0,0 @@
-class CanceledException(Exception):
-    """Execution canceled by user."""
-    pass

invokeai/app/models/image.py

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

invokeai/app/models/metadata.py

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

invokeai/app/services/config.py

@@ -1,523 +0,0 @@
-# Copyright (c) 2023 Lincoln Stein (https://github.com/lstein) and the InvokeAI Development Team
-
-'''Invokeai configuration system.
-
-Arguments and fields are taken from the pydantic definition of the
-model.  Defaults can be set by creating a yaml configuration file that
-has a top-level key of "InvokeAI" and subheadings for each of the
-categories returned by `invokeai --help`. The file looks like this:
-
-[file: invokeai.yaml]
-
-InvokeAI:
-  Paths:
-    root: /home/lstein/invokeai-main
-    conf_path: configs/models.yaml
-    legacy_conf_dir: configs/stable-diffusion
-    outdir: outputs
-    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')
-    use_memory_db       : bool = Field(default=False, description='Use in-memory database for storing image metadata', category='Paths')
-
-    model               : str = Field(default='stable-diffusion-1.5', description='Initial model name', category='Models')
-    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)->InvokeAIAppConfig:
-    '''
-    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,64 +0,0 @@
-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
-
-
-default_text_to_image_graph_id = '539b2af5-2b4d-4d8c-8071-e54a3255fc74'
-
-
-def create_text_to_image() -> LibraryGraph:
-    return LibraryGraph(
-        id=default_text_to_image_graph_id,
-        name='t2i',
-        description='Converts text to an image',
-        graph=Graph(
-            nodes={
-                'width': ParamIntInvocation(id='width', a=512),
-                'height': ParamIntInvocation(id='height', a=512),
-                'seed': ParamIntInvocation(id='seed', a=-1),
-                '3': NoiseInvocation(id='3'),
-                '4': CompelInvocation(id='4'),
-                '5': CompelInvocation(id='5'),
-                '6': TextToLatentsInvocation(id='6'),
-                '7': LatentsToImageInvocation(id='7'),
-            },
-            edges=[
-                Edge(source=EdgeConnection(node_id='width', field='a'), destination=EdgeConnection(node_id='3', field='width')),
-                Edge(source=EdgeConnection(node_id='height', field='a'), destination=EdgeConnection(node_id='3', field='height')),
-                Edge(source=EdgeConnection(node_id='seed', field='a'), destination=EdgeConnection(node_id='3', field='seed')),
-                Edge(source=EdgeConnection(node_id='3', field='noise'), destination=EdgeConnection(node_id='6', field='noise')),
-                Edge(source=EdgeConnection(node_id='6', field='latents'), destination=EdgeConnection(node_id='7', field='latents')),
-                Edge(source=EdgeConnection(node_id='4', field='conditioning'), destination=EdgeConnection(node_id='6', field='positive_conditioning')),
-                Edge(source=EdgeConnection(node_id='5', field='conditioning'), destination=EdgeConnection(node_id='6', field='negative_conditioning')),
-            ]
-        ),
-        exposed_inputs=[
-            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='seed', field='a', alias='seed'),
-        ],
-        exposed_outputs=[
-            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)
-    
-    # # 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)
-
-    graphs.append(text_to_image)
-
-    return graphs

invokeai/app/services/events.py

@@ -1,9 +1,10 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-from typing import Any
-from invokeai.app.models.image import ProgressImage
-from invokeai.app.util.misc import get_timestamp
+from typing import Any, Dict, TypedDict
 
+ProgressImage = TypedDict(
+    "ProgressImage", {"dataURL": str, "width": int, "height": int}
+)
 
 class EventServiceBase:
     session_event: str = "session_event"
@@ -13,8 +14,7 @@ class EventServiceBase:
     def dispatch(self, event_name: str, payload: Any) -> None:
         pass
 
-    def __emit_session_event(self, event_name: str, payload: dict) -> None:
-        payload["timestamp"] = get_timestamp()
+    def __emit_session_event(self, event_name: str, payload: Dict) -> None:
         self.dispatch(
             event_name=EventServiceBase.session_event,
             payload=dict(event=event_name, data=payload),
@@ -25,8 +25,7 @@ class EventServiceBase:
     def emit_generator_progress(
         self,
         graph_execution_state_id: str,
-        node: dict,
-        source_node_id: str,
+        invocation_id: str,
         progress_image: ProgressImage | None,
         step: int,
         total_steps: int,
@@ -36,60 +35,48 @@ class EventServiceBase:
             event_name="generator_progress",
             payload=dict(
                 graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
-                progress_image=progress_image.dict() if progress_image is not None else None,
+                invocation_id=invocation_id,
+                progress_image=progress_image,
                 step=step,
                 total_steps=total_steps,
             ),
         )
 
     def emit_invocation_complete(
-        self,
-        graph_execution_state_id: str,
-        result: dict,
-        node: dict,
-        source_node_id: str,
+        self, graph_execution_state_id: str, invocation_id: str, result: Dict
     ) -> None:
         """Emitted when an invocation has completed"""
         self.__emit_session_event(
             event_name="invocation_complete",
             payload=dict(
                 graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
+                invocation_id=invocation_id,
                 result=result,
             ),
         )
 
     def emit_invocation_error(
-        self,
-        graph_execution_state_id: str,
-        node: dict,
-        source_node_id: str,
-        error: str,
+        self, graph_execution_state_id: str, invocation_id: str, error: str
     ) -> None:
         """Emitted when an invocation has completed"""
         self.__emit_session_event(
             event_name="invocation_error",
             payload=dict(
                 graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
+                invocation_id=invocation_id,
                 error=error,
             ),
         )
 
     def emit_invocation_started(
-        self, graph_execution_state_id: str, node: dict, source_node_id: str
+        self, graph_execution_state_id: str, invocation_id: str
     ) -> None:
         """Emitted when an invocation has started"""
         self.__emit_session_event(
             event_name="invocation_started",
             payload=dict(
                 graph_execution_state_id=graph_execution_state_id,
-                node=node,
-                source_node_id=source_node_id,
+                invocation_id=invocation_id,
             ),
         )
 
@@ -97,7 +84,5 @@ class EventServiceBase:
         """Emitted when a session has completed all invocations"""
         self.__emit_session_event(
             event_name="graph_execution_state_complete",
-            payload=dict(
-                graph_execution_state_id=graph_execution_state_id,
-            ),
+            payload=dict(graph_execution_state_id=graph_execution_state_id),
         )

invokeai/app/services/graph.py

@@ -2,6 +2,7 @@
 
 import copy
 import itertools
+import traceback
 import uuid
 from types import NoneType
 from typing import (
@@ -16,7 +17,7 @@ from typing import (
 )
 
 import networkx as nx
-from pydantic import BaseModel, root_validator, validator
+from pydantic import BaseModel, validator
 from pydantic.fields import Field
 
 from ..invocations import *
@@ -25,6 +26,7 @@ from ..invocations.baseinvocation import (
     BaseInvocationOutput,
     InvocationContext,
 )
+from .invocation_services import InvocationServices
 
 
 class EdgeConnection(BaseModel):
@@ -60,35 +62,6 @@ def get_input_field(node: BaseInvocation, field: str) -> Any:
     node_input_field = node_inputs.get(field) or None
     return node_input_field
 
-from typing import Optional, Union, List, get_args
-
-def is_union_subtype(t1, t2):
-    t1_args = get_args(t1)
-    t2_args = get_args(t2)
-    
-    if not t1_args:
-        # t1 is a single type
-        return t1 in t2_args
-    else:
-        # t1 is a Union, check that all of its types are in t2_args
-        return all(arg in t2_args for arg in t1_args)
-
-def is_list_or_contains_list(t):
-    t_args = get_args(t)
-
-    # If the type is a List
-    if get_origin(t) is list:
-        return True
-
-    # If the type is a Union
-    elif t_args:
-        # Check if any of the types in the Union is a List
-        for arg in t_args:
-            if get_origin(arg) is list:
-                return True
-                
-    return False
-
 
 def are_connection_types_compatible(from_type: Any, to_type: Any) -> bool:
     if not from_type:
@@ -114,8 +87,7 @@ def are_connection_types_compatible(from_type: Any, to_type: Any) -> bool:
         if to_type in get_args(from_type):
             return True
 
-        # if not issubclass(from_type, to_type):
-        if not is_union_subtype(from_type, to_type):
+        if not issubclass(from_type, to_type):
             return False
     else:
         return False
@@ -165,7 +137,6 @@ class GraphInvocationOutput(BaseInvocationOutput):
 
 # TODO: Fill this out and move to invocations
 class GraphInvocation(BaseInvocation):
-    """Execute a graph"""
     type: Literal["graph"] = "graph"
 
     # TODO: figure out how to create a default here
@@ -193,7 +164,6 @@ class IterateInvocationOutput(BaseInvocationOutput):
 
 # TODO: Fill this out and move to invocations
 class IterateInvocation(BaseInvocation):
-    """Iterates over a list of items"""
     type: Literal["iterate"] = "iterate"
 
     collection: list[Any] = Field(
@@ -245,7 +215,7 @@ InvocationOutputsUnion = Union[BaseInvocationOutput.get_all_subclasses_tuple()]
 
 
 class Graph(BaseModel):
-    id: str = Field(description="The id of this graph", default_factory=lambda: uuid.uuid4().__str__())
+    id: str = Field(description="The id of this graph", default_factory=uuid.uuid4)
     # TODO: use a list (and never use dict in a BaseModel) because pydantic/fastapi hates me
     nodes: dict[str, Annotated[InvocationsUnion, Field(discriminator="type")]] = Field(
         description="The nodes in this graph", default_factory=dict
@@ -313,8 +283,7 @@ class Graph(BaseModel):
         :raises InvalidEdgeError: the provided edge is invalid.
         """
 
-        self._validate_edge(edge)
-        if edge not in self.edges:
+        if self._is_edge_valid(edge) and edge not in self.edges:
             self.edges.append(edge)
         else:
             raise InvalidEdgeError()
@@ -385,7 +354,7 @@ class Graph(BaseModel):
 
         return True
 
-    def _validate_edge(self, edge: Edge):
+    def _is_edge_valid(self, edge: Edge) -> bool:
         """Validates that a new edge doesn't create a cycle in the graph"""
 
         # Validate that the nodes exist (edges may contain node paths, so we can't just check for nodes directly)
@@ -393,53 +362,54 @@ class Graph(BaseModel):
             from_node = self.get_node(edge.source.node_id)
             to_node = self.get_node(edge.destination.node_id)
         except NodeNotFoundError:
-            raise InvalidEdgeError("One or both nodes don't exist")
+            return False
 
         # Validate that an edge to this node+field doesn't already exist
         input_edges = self._get_input_edges(edge.destination.node_id, edge.destination.field)
         if len(input_edges) > 0 and not isinstance(to_node, CollectInvocation):
-            raise InvalidEdgeError(f'Edge to node {edge.destination.node_id} field {edge.destination.field} already exists')
+            return False
 
         # Validate that no cycles would be created
         g = self.nx_graph_flat()
         g.add_edge(edge.source.node_id, edge.destination.node_id)
         if not nx.is_directed_acyclic_graph(g):
-            raise InvalidEdgeError(f'Edge creates a cycle in the graph')
+            return False
 
         # Validate that the field types are compatible
         if not are_connections_compatible(
             from_node, edge.source.field, to_node, edge.destination.field
         ):
-            raise InvalidEdgeError(f'Fields are incompatible')
+            return False
 
         # Validate if iterator output type matches iterator input type (if this edge results in both being set)
         if isinstance(to_node, IterateInvocation) and edge.destination.field == "collection":
             if not self._is_iterator_connection_valid(
                 edge.destination.node_id, new_input=edge.source
             ):
-                raise InvalidEdgeError(f'Iterator input type does not match iterator output type')
+                return False
 
         # Validate if iterator input type matches output type (if this edge results in both being set)
         if isinstance(from_node, IterateInvocation) and edge.source.field == "item":
             if not self._is_iterator_connection_valid(
                 edge.source.node_id, new_output=edge.destination
             ):
-                raise InvalidEdgeError(f'Iterator output type does not match iterator input type')
+                return False
 
         # Validate if collector input type matches output type (if this edge results in both being set)
         if isinstance(to_node, CollectInvocation) and edge.destination.field == "item":
             if not self._is_collector_connection_valid(
                 edge.destination.node_id, new_input=edge.source
             ):
-                raise InvalidEdgeError(f'Collector output type does not match collector input type')
+                return False
 
         # Validate if collector output type matches input type (if this edge results in both being set)
         if isinstance(from_node, CollectInvocation) and edge.source.field == "collection":
             if not self._is_collector_connection_valid(
                 edge.source.node_id, new_output=edge.destination
             ):
-                raise InvalidEdgeError(f'Collector input type does not match collector output type')
+                return False
 
+        return True
 
     def has_node(self, node_path: str) -> bool:
         """Determines whether or not a node exists in the graph."""
@@ -724,11 +694,7 @@ class Graph(BaseModel):
         input_root_type = next(t[0] for t in type_degrees if t[1] == 0)  # type: ignore
 
         # Verify that all outputs are lists
-        # if not all((get_origin(f) == list for f in output_fields)):
-        #     return False
-
-        # Verify that all outputs are lists
-        if not all(is_list_or_contains_list(f) for f in output_fields):
+        if not all((get_origin(f) == list for f in output_fields)):
             return False
 
         # Verify that all outputs match the input type (are a base class or the same class)
@@ -747,13 +713,6 @@ class Graph(BaseModel):
         g.add_edges_from(set([(e.source.node_id, e.destination.node_id) for e in self.edges]))
         return g
 
-    def nx_graph_with_data(self) -> nx.DiGraph:
-        """Returns a NetworkX DiGraph representing the data and layout of this graph"""
-        g = nx.DiGraph()
-        g.add_nodes_from([n for n in self.nodes.items()])
-        g.add_edges_from(set([(e.source.node_id, e.destination.node_id) for e in self.edges]))
-        return g
-
     def nx_graph_flat(
         self, nx_graph: Optional[nx.DiGraph] = None, prefix: Optional[str] = None
     ) -> nx.DiGraph:
@@ -774,7 +733,7 @@ class Graph(BaseModel):
         for sgn in (
             gn for gn in self.nodes.values() if isinstance(gn, GraphInvocation)
         ):
-            g = sgn.graph.nx_graph_flat(g, self._get_node_path(sgn.id, prefix))
+            sgn.graph.nx_graph_flat(g, self._get_node_path(sgn.id, prefix))
 
         # TODO: figure out if iteration nodes need to be expanded
 
@@ -791,7 +750,9 @@ class Graph(BaseModel):
 class GraphExecutionState(BaseModel):
     """Tracks the state of a graph execution"""
 
-    id: str = Field(description="The id of the execution state", default_factory=lambda: uuid.uuid4().__str__())
+    id: str = Field(
+        description="The id of the execution state", default_factory=uuid.uuid4
+    )
 
     # TODO: Store a reference to the graph instead of the actual graph?
     graph: Graph = Field(description="The graph being executed")
@@ -833,6 +794,9 @@ class GraphExecutionState(BaseModel):
         default_factory=dict,
     )
 
+    # Declare all fields as required; necessary for OpenAPI schema generation build.
+    # Technically only fields without a `default_factory` need to be listed here.
+    # See: https://github.com/pydantic/pydantic/discussions/4577
     class Config:
         schema_extra = {
             'required': [
@@ -897,8 +861,7 @@ class GraphExecutionState(BaseModel):
 
     def is_complete(self) -> bool:
         """Returns true if the graph is complete"""
-        node_ids = set(self.graph.nx_graph_flat().nodes)
-        return self.has_error() or all((k in self.executed for k in node_ids))
+        return self.has_error() or all((k in self.executed for k in self.graph.nodes))
 
     def has_error(self) -> bool:
         """Returns true if the graph has any errors"""
@@ -986,11 +949,11 @@ class GraphExecutionState(BaseModel):
 
     def _iterator_graph(self) -> nx.DiGraph:
         """Gets a DiGraph with edges to collectors removed so an ancestor search produces all active iterators for any node"""
-        g = self.graph.nx_graph_flat()
+        g = self.graph.nx_graph()
         collectors = (
             n
             for n in self.graph.nodes
-            if isinstance(self.graph.get_node(n), CollectInvocation)
+            if isinstance(self.graph.nodes[n], CollectInvocation)
         )
         for c in collectors:
             g.remove_edges_from(list(g.in_edges(c)))
@@ -1002,7 +965,7 @@ class GraphExecutionState(BaseModel):
         iterators = [
             n
             for n in nx.ancestors(g, node_id)
-            if isinstance(self.graph.get_node(n), IterateInvocation)
+            if isinstance(self.graph.nodes[n], IterateInvocation)
         ]
         return iterators
 
@@ -1138,9 +1101,7 @@ class GraphExecutionState(BaseModel):
 
     # TODO: Add API for modifying underlying graph that checks if the change will be valid given the current execution state
     def _is_edge_valid(self, edge: Edge) -> bool:
-        try:
-            self.graph._validate_edge(edge)
-        except InvalidEdgeError:
+        if not self._is_edge_valid(edge):
             return False
 
         # Invalid if destination has already been prepared or executed
@@ -1186,52 +1147,4 @@ class GraphExecutionState(BaseModel):
         self.graph.delete_edge(edge)
 
 
-class ExposedNodeInput(BaseModel):
-    node_path: str = Field(description="The node path to the node with the input")
-    field: str = Field(description="The field name of the input")
-    alias: str = Field(description="The alias of the input")
-
-
-class ExposedNodeOutput(BaseModel):
-    node_path: str = Field(description="The node path to the node with the output")
-    field: str = Field(description="The field name of the output")
-    alias: str = Field(description="The alias of the output")
-
-class LibraryGraph(BaseModel):
-    id: str = Field(description="The unique identifier for this library graph", default_factory=uuid.uuid4)
-    graph: Graph = Field(description="The graph")
-    name: str = Field(description="The name of the graph")
-    description: str = Field(description="The description of the graph")
-    exposed_inputs: list[ExposedNodeInput] = Field(description="The inputs exposed by this graph", default_factory=list)
-    exposed_outputs: list[ExposedNodeOutput] = Field(description="The outputs exposed by this graph", default_factory=list)
-
-    @validator('exposed_inputs', 'exposed_outputs')
-    def validate_exposed_aliases(cls, v):
-        if len(v) != len(set(i.alias for i in v)):
-            raise ValueError("Duplicate exposed alias")
-        return v
-
-    @root_validator
-    def validate_exposed_nodes(cls, values):
-        graph = values['graph']
-
-        # Validate exposed inputs
-        for exposed_input in values['exposed_inputs']:
-            if not graph.has_node(exposed_input.node_path):
-                raise ValueError(f"Exposed input node {exposed_input.node_path} does not exist")
-            node = graph.get_node(exposed_input.node_path)
-            if get_input_field(node, exposed_input.field) is None:
-                raise ValueError(f"Exposed input field {exposed_input.field} does not exist on node {exposed_input.node_path}")
-
-        # Validate exposed outputs
-        for exposed_output in values['exposed_outputs']:
-            if not graph.has_node(exposed_output.node_path):
-                raise ValueError(f"Exposed output node {exposed_output.node_path} does not exist")
-            node = graph.get_node(exposed_output.node_path)
-            if get_output_field(node, exposed_output.field) is None:
-                raise ValueError(f"Exposed output field {exposed_output.field} does not exist on node {exposed_output.node_path}")
-
-        return values
-
-
 GraphInvocation.update_forward_refs()

invokeai/app/services/image_file_storage.py

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

invokeai/app/services/image_record_storage.py

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

invokeai/app/services/image_storage.py

@@ -0,0 +1,121 @@
+# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
+
+import datetime
+import os
+from abc import ABC, abstractmethod
+from enum import Enum
+from pathlib import Path
+from queue import Queue
+from typing import Dict
+
+from PIL.Image import Image
+from invokeai.app.util.save_thumbnail import save_thumbnail
+
+from invokeai.backend.image_util import PngWriter
+
+
+class ImageType(str, Enum):
+    RESULT = "results"
+    INTERMEDIATE = "intermediates"
+    UPLOAD = "uploads"
+
+
+class ImageStorageBase(ABC):
+    """Responsible for storing and retrieving images."""
+
+    @abstractmethod
+    def get(self, image_type: ImageType, image_name: str) -> Image:
+        pass
+
+    # TODO: make this a bit more flexible for e.g. cloud storage
+    @abstractmethod
+    def get_path(self, image_type: ImageType, image_name: str) -> str:
+        pass
+
+    @abstractmethod
+    def save(self, image_type: ImageType, image_name: str, image: Image) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, image_type: ImageType, image_name: str) -> None:
+        pass
+
+    def create_name(self, context_id: str, node_id: str) -> str:
+        return f"{context_id}_{node_id}_{str(int(datetime.datetime.now(datetime.timezone.utc).timestamp()))}.png"
+
+
+class DiskImageStorage(ImageStorageBase):
+    """Stores images on disk"""
+
+    __output_folder: str
+    __pngWriter: PngWriter
+    __cache_ids: Queue  # TODO: this is an incredibly naive cache
+    __cache: Dict[str, Image]
+    __max_cache_size: int
+
+    def __init__(self, output_folder: str):
+        self.__output_folder = output_folder
+        self.__pngWriter = PngWriter(output_folder)
+        self.__cache = dict()
+        self.__cache_ids = Queue()
+        self.__max_cache_size = 10  # TODO: get this from config
+
+        Path(output_folder).mkdir(parents=True, exist_ok=True)
+
+        # TODO: don't hard-code. get/save/delete should maybe take subpath?
+        for image_type in ImageType:
+            Path(os.path.join(output_folder, image_type)).mkdir(
+                parents=True, exist_ok=True
+            )
+            Path(os.path.join(output_folder, image_type, "thumbnails")).mkdir(
+                parents=True, exist_ok=True
+            )
+
+    def get(self, image_type: ImageType, image_name: str) -> Image:
+        image_path = self.get_path(image_type, image_name)
+        cache_item = self.__get_cache(image_path)
+        if cache_item:
+            return cache_item
+
+        image = Image.open(image_path)
+        self.__set_cache(image_path, image)
+        return image
+
+    # TODO: make this a bit more flexible for e.g. cloud storage
+    def get_path(self, image_type: ImageType, image_name: str) -> str:
+        path = os.path.join(self.__output_folder, image_type, image_name)
+        return path
+
+    def save(self, image_type: ImageType, image_name: str, image: Image) -> None:
+        image_subpath = os.path.join(image_type, image_name)
+        self.__pngWriter.save_image_and_prompt_to_png(
+            image, "", image_subpath, None
+        )  # TODO: just pass full path to png writer
+        save_thumbnail(
+            image=image,
+            filename=image_name,
+            path=os.path.join(self.__output_folder, image_type, "thumbnails"),
+        )
+        image_path = self.get_path(image_type, image_name)
+        self.__set_cache(image_path, image)
+
+    def delete(self, image_type: ImageType, image_name: str) -> None:
+        image_path = self.get_path(image_type, image_name)
+        if os.path.exists(image_path):
+            os.remove(image_path)
+
+        if image_path in self.__cache:
+            del self.__cache[image_path]
+
+    def __get_cache(self, image_name: str) -> Image:
+        return None if image_name not in self.__cache else self.__cache[image_name]
+
+    def __set_cache(self, image_name: str, image: Image):
+        if not image_name in self.__cache:
+            self.__cache[image_name] = image
+            self.__cache_ids.put(
+                image_name
+            )  # TODO: this should refresh position for LRU cache
+            if len(self.__cache) > self.__max_cache_size:
+                cache_id = self.__cache_ids.get()
+                del self.__cache[cache_id]

invokeai/app/services/images.py

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

invokeai/app/services/invocation_queue.py

@@ -1,17 +1,30 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
-import time
 from abc import ABC, abstractmethod
 from queue import Queue
-
-from pydantic import BaseModel, Field
+import time
 
 
-class InvocationQueueItem(BaseModel):
-    graph_execution_state_id: str = Field(description="The ID of the graph execution state")
-    invocation_id: str = Field(description="The ID of the node being invoked")
-    invoke_all: bool = Field(default=False)
-    timestamp: float = Field(default_factory=time.time)
+# TODO: make this serializable
+class InvocationQueueItem:
+    # session_id: str
+    graph_execution_state_id: str
+    invocation_id: str
+    invoke_all: bool
+    timestamp: float
+
+    def __init__(
+        self,
+        # session_id: str,
+        graph_execution_state_id: str,
+        invocation_id: str,
+        invoke_all: bool = False,
+    ):
+        # self.session_id = session_id
+        self.graph_execution_state_id = graph_execution_state_id
+        self.invocation_id = invocation_id
+        self.invoke_all = invoke_all
+        self.timestamp = time.time()
 
 
 class InvocationQueueABC(ABC):

invokeai/app/services/invocation_services.py

@@ -1,60 +1,43 @@
-# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654) and the InvokeAI Team
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from logging import Logger
-    from invokeai.app.services.images import ImageService
-    from invokeai.backend import ModelManager
-    from invokeai.app.services.events import EventServiceBase
-    from invokeai.app.services.latent_storage import LatentsStorageBase
-    from invokeai.app.services.restoration_services import RestorationServices
-    from invokeai.app.services.invocation_queue import InvocationQueueABC
-    from invokeai.app.services.item_storage import ItemStorageABC
-    from invokeai.app.services.config import InvokeAISettings
-    from invokeai.app.services.graph import GraphExecutionState, LibraryGraph
-    from invokeai.app.services.invoker import InvocationProcessorABC
+# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
+from invokeai.backend import ModelManager
 
+from .events import EventServiceBase
+from .latent_storage import LatentsStorageBase
+from .image_storage import ImageStorageBase
+from .restoration_services import RestorationServices
+from .invocation_queue import InvocationQueueABC
+from .item_storage import ItemStorageABC
 
 class InvocationServices:
     """Services that can be used by invocations"""
 
-    # TODO: Just forward-declared everything due to circular dependencies. Fix structure.
-    events: "EventServiceBase"
-    latents: "LatentsStorageBase"
-    queue: "InvocationQueueABC"
-    model_manager: "ModelManager"
-    restoration: "RestorationServices"
-    configuration: "InvokeAISettings"
-    images: "ImageService"
+    events: EventServiceBase
+    latents: LatentsStorageBase
+    images: ImageStorageBase
+    queue: InvocationQueueABC
+    model_manager: ModelManager
+    restoration: RestorationServices
 
     # NOTE: we must forward-declare any types that include invocations, since invocations can use services
-    graph_library: "ItemStorageABC"["LibraryGraph"]
-    graph_execution_manager: "ItemStorageABC"["GraphExecutionState"]
+    graph_execution_manager: ItemStorageABC["GraphExecutionState"]
     processor: "InvocationProcessorABC"
 
     def __init__(
-        self,
-        model_manager: "ModelManager",
-        events: "EventServiceBase",
-        logger: "Logger",
-        latents: "LatentsStorageBase",
-        images: "ImageService",
-        queue: "InvocationQueueABC",
-        graph_library: "ItemStorageABC"["LibraryGraph"],
-        graph_execution_manager: "ItemStorageABC"["GraphExecutionState"],
-        processor: "InvocationProcessorABC",
-        restoration: "RestorationServices",
-        configuration: "InvokeAISettings",
+            self,
+            model_manager: ModelManager,
+            events: EventServiceBase,
+            latents: LatentsStorageBase,
+            images: ImageStorageBase,
+            queue: InvocationQueueABC,
+            graph_execution_manager: ItemStorageABC["GraphExecutionState"],
+            processor: "InvocationProcessorABC",
+            restoration: RestorationServices,
     ):
         self.model_manager = model_manager
         self.events = events
-        self.logger = logger
         self.latents = latents
         self.images = images
         self.queue = queue
-        self.graph_library = graph_library
         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,12 +71,18 @@ class Invoker:
         for service in vars(self.services):
             self.__start_service(getattr(self.services, service))
 
+        for service in vars(self.services):
+            self.__start_service(getattr(self.services, service))
+
     def stop(self) -> None:
         """Stops the invoker. A new invoker will have to be created to execute further."""
         # First stop all services
         for service in vars(self.services):
             self.__stop_service(getattr(self.services, service))
 
+        for service in vars(self.services):
+            self.__stop_service(getattr(self.services, service))
+
         self.services.queue.put(None)
 
 

invokeai/app/services/latent_storage.py

@@ -16,7 +16,7 @@ class LatentsStorageBase(ABC):
         pass
 
     @abstractmethod
-    def save(self, name: str, data: torch.Tensor) -> None:
+    def set(self, name: str, data: torch.Tensor) -> None:
         pass
 
     @abstractmethod
@@ -47,8 +47,8 @@ class ForwardCacheLatentsStorage(LatentsStorageBase):
         self.__set_cache(name, latent)
         return latent
 
-    def save(self, name: str, data: torch.Tensor) -> None:
-        self.__underlying_storage.save(name, data)
+    def set(self, name: str, data: torch.Tensor) -> None:
+        self.__underlying_storage.set(name, data)
         self.__set_cache(name, data)
 
     def delete(self, name: str) -> None:
@@ -80,7 +80,7 @@ class DiskLatentsStorage(LatentsStorageBase):
         latent_path = self.get_path(name)
         return torch.load(latent_path)
 
-    def save(self, name: str, data: torch.Tensor) -> None:
+    def set(self, name: str, data: torch.Tensor) -> None:
         latent_path = self.get_path(name)
         torch.save(data, latent_path)
 

invokeai/app/services/metadata.py

@@ -1,142 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Union
-import networkx as nx
-
-from invokeai.app.models.metadata import ImageMetadata
-from invokeai.app.services.graph import Graph, GraphExecutionState
-
-
-class MetadataServiceBase(ABC):
-    """Handles building metadata for nodes, images, and outputs."""
-
-    @abstractmethod
-    def create_image_metadata(
-        self, session: GraphExecutionState, node_id: str
-    ) -> ImageMetadata:
-        """Builds an ImageMetadata object for a node."""
-        pass
-
-
-class CoreMetadataService(MetadataServiceBase):
-    _ANCESTOR_TYPES = ["t2l", "l2l"]
-    """The ancestor types that contain the core metadata"""
-
-    _ANCESTOR_PARAMS = ["type", "steps", "model", "cfg_scale", "scheduler", "strength"]
-    """The core metadata parameters in the ancestor types"""
-
-    _NOISE_FIELDS = ["seed", "width", "height"]
-    """The core metadata parameters in the noise node"""
-
-    def create_image_metadata(
-        self, session: GraphExecutionState, node_id: str
-    ) -> ImageMetadata:
-        metadata = self._build_metadata_from_graph(session, node_id)
-
-        return metadata
-
-    def _find_nearest_ancestor(self, G: nx.DiGraph, node_id: str) -> Union[str, None]:
-        """
-        Finds the id of the nearest ancestor (of a valid type) of a given node.
-
-        Parameters:
-        G (nx.DiGraph): The execution graph, converted in to a networkx DiGraph. Its nodes must
-        have the same data as the execution graph.
-        node_id (str): The ID of the node.
-
-        Returns:
-        str | None: The ID of the nearest ancestor, or None if there are no valid ancestors.
-        """
-
-        # Retrieve the node from the graph
-        node = G.nodes[node_id]
-
-        # If the node type is one of the core metadata node types, return its id
-        if node.get("type") in self._ANCESTOR_TYPES:
-            return node.get("id")
-
-        # Else, look for the ancestor in the predecessor nodes
-        for predecessor in G.predecessors(node_id):
-            result = self._find_nearest_ancestor(G, predecessor)
-            if result:
-                return result
-
-        # If there are no valid ancestors, return None
-        return None
-
-    def _get_additional_metadata(
-        self, graph: Graph, node_id: str
-    ) -> Union[dict[str, Any], None]:
-        """
-        Returns additional metadata for a given node.
-
-        Parameters:
-        graph (Graph): The execution graph.
-        node_id (str): The ID of the node.
-
-        Returns:
-        dict[str, Any] | None: A dictionary of additional metadata.
-        """
-
-        metadata = {}
-
-        # Iterate over all edges in the graph
-        for edge in graph.edges:
-            dest_node_id = edge.destination.node_id
-            dest_field = edge.destination.field
-            source_node_dict = graph.nodes[edge.source.node_id].dict()
-
-            # If the destination node ID matches the given node ID, gather necessary metadata
-            if dest_node_id == node_id:
-                # Prompt
-                if dest_field == "positive_conditioning":
-                    metadata["positive_conditioning"] = source_node_dict.get("prompt")
-                # Negative prompt
-                if dest_field == "negative_conditioning":
-                    metadata["negative_conditioning"] = source_node_dict.get("prompt")
-                # Seed, width and height
-                if dest_field == "noise":
-                    for field in self._NOISE_FIELDS:
-                        metadata[field] = source_node_dict.get(field)
-        return metadata
-
-    def _build_metadata_from_graph(
-        self, session: GraphExecutionState, node_id: str
-    ) -> ImageMetadata:
-        """
-        Builds an ImageMetadata object for a node.
-
-        Parameters:
-        session (GraphExecutionState): The session.
-        node_id (str): The ID of the node.
-
-        Returns:
-        ImageMetadata: The metadata for the node.
-        """
-
-        # We need to do all the traversal on the execution graph
-        graph = session.execution_graph
-
-        # Find the nearest `t2l`/`l2l` ancestor of the given node
-        ancestor_id = self._find_nearest_ancestor(graph.nx_graph_with_data(), node_id)
-
-        # If no ancestor was found, return an empty ImageMetadata object
-        if ancestor_id is None:
-            return ImageMetadata()
-
-        ancestor_node = graph.get_node(ancestor_id)
-
-        # Grab all the core metadata from the ancestor node
-        ancestor_metadata = {
-            param: val
-            for param, val in ancestor_node.dict().items()
-            if param in self._ANCESTOR_PARAMS
-        }
-
-        # Get this image's prompts and noise parameters
-        addl_metadata = self._get_additional_metadata(graph, ancestor_id)
-
-        # If additional metadata was found, add it to the main metadata
-        if addl_metadata is not None:
-            ancestor_metadata.update(addl_metadata)
-
-        return ImageMetadata(**ancestor_metadata)

invokeai/app/services/model_manager_initializer.py

@@ -2,25 +2,26 @@ 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: 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
-        )
+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.")
+            )
 
-    logger.info(f"{invokeai.version.__app_name__}, version {invokeai.version.__version__}")
-    logger.info(f'InvokeAI runtime directory is "{config.root}"')
+    print(f">> {invokeai.version.__app_name__}, version {invokeai.version.__version__}")
+    print(f'>> InvokeAI runtime directory is "{Globals.root}"')
 
     # these two lines prevent a horrible warning message from appearing
     # when the frozen CLIP tokenizer is imported
@@ -30,7 +31,20 @@ def get_model_manager(config: InvokeAISettings, logger: types.ModuleType) -> Mod
     import diffusers
 
     diffusers.logging.set_verbosity_error()
-    embedding_path = config.embedding_path
+
+    # normalize the config directory relative to root
+    if not os.path.isabs(config.conf):
+        config.conf = os.path.normpath(os.path.join(Globals.root, config.conf))
+
+    if config.embeddings:
+        if not os.path.isabs(config.embedding_path):
+            embedding_path = os.path.normpath(
+                os.path.join(Globals.root, config.embedding_path)
+            )
+        else:
+            embedding_path = config.embedding_path
+    else:
+        embedding_path = None
 
     # migrate legacy models
     ModelManager.migrate_models()
@@ -43,36 +57,37 @@ def get_model_manager(config: InvokeAISettings, logger: types.ModuleType) -> Mod
         else choose_precision(device)
         
         model_manager = ModelManager(
-            OmegaConf.load(config.model_conf_path),
+            OmegaConf.load(config.conf),
             precision=precision,
             device_type=device,
             max_loaded_models=config.max_loaded_models,
-            embedding_path = embedding_path,
-            logger = logger,
+            embedding_path = Path(embedding_path),
         )
     except (FileNotFoundError, TypeError, AssertionError) as e:
-        report_model_error(config, e, logger)
+        report_model_error(config, e)
     except (IOError, KeyError) as e:
-        logger.error(f"{e}. Aborting.")
+        print(f"{e}. Aborting.")
         sys.exit(-1)
 
     # try to autoconvert new models
     # autoimport new .ckpt files
-    if config.autoconvert_path:
-        model_manager.heuristic_import(
-            config.autoconvert_path,
+    if path := config.autoconvert:
+        model_manager.autoconvert_weights(
+            conf_path=config.conf,
+            weights_directory=path,
         )
+
     return model_manager
 
-def report_model_error(opt: Namespace, e: Exception, 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."
+def report_model_error(opt: Namespace, e: Exception):
+    print(f'** An error occurred while attempting to initialize the model: "{str(e)}"')
+    print(
+        "** This can be caused by a missing or corrupted models file, and can sometimes be fixed by (re)installing the models."
     )
     yes_to_all = os.environ.get("INVOKE_MODEL_RECONFIGURE")
     if yes_to_all:
-        logger.warning(
-            "Reconfiguration is being forced by environment variable INVOKE_MODEL_RECONFIGURE"
+        print(
+            "** Reconfiguration is being forced by environment variable INVOKE_MODEL_RECONFIGURE"
         )
     else:
         response = input(
@@ -81,12 +96,13 @@ def report_model_error(opt: Namespace, e: Exception, logger: types.ModuleType):
         if response.startswith(("n", "N")):
             return
 
-    logger.info("invokeai-configure is launching....\n")
+    print("invokeai-configure is launching....\n")
 
     # Match arguments that were set on the CLI
     # only the arguments accepted by the configuration script are parsed
     root_dir = ["--root", opt.root_dir] if opt.root_dir is not None else []
     config = ["--config", opt.conf] if opt.conf is not None else []
+    previous_config = sys.argv
     sys.argv = ["invokeai-configure"]
     sys.argv.extend(root_dir)
     sys.argv.extend(config.to_dict())

invokeai/app/services/models/image_record.py

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

invokeai/app/services/processor.py

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

invokeai/app/services/resource_name.py

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

invokeai/app/services/restoration_services.py

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

invokeai/app/services/urls.py

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

invokeai/app/util/metaenum.py

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

invokeai/app/util/misc.py

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

invokeai/app/util/save_thumbnail.py

@@ -0,0 +1,25 @@
+import os
+from PIL import Image
+
+
+def save_thumbnail(
+    image: Image.Image,
+    filename: str,
+    path: str,
+    size: int = 256,
+) -> str:
+    """
+    Saves a thumbnail of an image, returning its path.
+    """
+    base_filename = os.path.splitext(filename)[0]
+    thumbnail_path = os.path.join(path, base_filename + ".webp")
+
+    if os.path.exists(thumbnail_path):
+        return thumbnail_path
+
+    image_copy = image.copy()
+    image_copy.thumbnail(size=(size, size))
+
+    image_copy.save(thumbnail_path, "WEBP")
+
+    return thumbnail_path

invokeai/app/util/step_callback.py

@@ -1,55 +0,0 @@
-from invokeai.app.models.exceptions import CanceledException
-from invokeai.app.models.image import ProgressImage
-from ..invocations.baseinvocation import InvocationContext
-from ...backend.util.util import image_to_dataURL
-from ...backend.generator.base import Generator
-from ...backend.stable_diffusion import PipelineIntermediateState
-
-
-def stable_diffusion_step_callback(
-    context: InvocationContext,
-    intermediate_state: PipelineIntermediateState,
-    node: dict,
-    source_node_id: str,
-):
-    if context.services.queue.is_canceled(context.graph_execution_state_id):
-        raise CanceledException
-
-    # Some schedulers report not only the noisy latents at the current timestep,
-    # but also their estimate so far of what the de-noised latents will be. Use
-    # that estimate if it is available.
-    if intermediate_state.predicted_original is not None:
-        sample = intermediate_state.predicted_original
-    else:
-        sample = intermediate_state.latents
-
-    # TODO: This does not seem to be needed any more?
-    # # txt2img provides a Tensor in the step_callback
-    # # img2img provides a PipelineIntermediateState
-    # if isinstance(sample, PipelineIntermediateState):
-    #     # this was an img2img
-    #     print('img2img')
-    #     latents = sample.latents
-    #     step = sample.step
-    # else:
-    #     print('txt2img')
-    #     latents = sample
-    #     step = intermediate_state.step
-
-    # TODO: only output a preview image when requested
-    image = Generator.sample_to_lowres_estimated_image(sample)
-
-    (width, height) = image.size
-    width *= 8
-    height *= 8
-
-    dataURL = image_to_dataURL(image, image_format="JPEG")
-
-    context.services.events.emit_generator_progress(
-        graph_execution_state_id=context.graph_execution_state_id,
-        node=node,
-        source_node_id=source_node_id,
-        progress_image=ProgressImage(width=width, height=height, dataURL=dataURL),
-        step=intermediate_state.step,
-        total_steps=node["steps"],
-    )

invokeai/app/util/thumbnails.py

@@ -1,15 +0,0 @@
-import os
-from PIL import Image
-
-
-def get_thumbnail_name(image_name: str) -> str:
-    """Formats given an image name, returns the appropriate thumbnail image name"""
-    thumbnail_name = os.path.splitext(image_name)[0] + ".webp"
-    return thumbnail_name
-
-
-def make_thumbnail(image: Image.Image, size: int = 256) -> Image.Image:
-    """Makes a thumbnail from a PIL Image"""
-    thumbnail = image.copy()
-    thumbnail.thumbnail(size=(size, size))
-    return thumbnail

invokeai/app/util/util.py

@@ -0,0 +1,42 @@
+import torch
+from PIL import Image
+from ..invocations.baseinvocation import InvocationContext
+from ...backend.util.util import image_to_dataURL
+from ...backend.generator.base import Generator
+from ...backend.stable_diffusion import PipelineIntermediateState
+
+class CanceledException(Exception):
+    pass
+
+def fast_latents_step_callback(sample: torch.Tensor, step: int, steps: int, id: str, context: InvocationContext, ):
+    # TODO: only output a preview image when requested
+    image = Generator.sample_to_lowres_estimated_image(sample)
+
+    (width, height) = image.size
+    width *= 8
+    height *= 8
+
+    dataURL = image_to_dataURL(image, image_format="JPEG")
+
+    context.services.events.emit_generator_progress(
+        context.graph_execution_state_id,
+        id,
+        {
+            "width": width,
+            "height": height,
+            "dataURL": dataURL
+        },
+        step,
+        steps,
+    )
+
+def diffusers_step_callback_adapter(*cb_args, **kwargs):
+    """
+    txt2img gives us a Tensor in the step_callbak, while img2img gives us a PipelineIntermediateState.
+    This adapter grabs the needed data and passes it along to the callback function.
+    """
+    if isinstance(cb_args[0], PipelineIntermediateState):
+        progress_state: PipelineIntermediateState = cb_args[0]
+        return fast_latents_step_callback(progress_state.latents, progress_state.step, **kwargs)
+    else:
+        return fast_latents_step_callback(*cb_args, **kwargs)

invokeai/backend/__init__.py

@@ -1,6 +1,7 @@
 """
 Initialization file for invokeai.backend
 """
+from .generate import Generate
 from .generator import (
     InvokeAIGeneratorBasicParams,
     InvokeAIGenerator,
@@ -9,5 +10,7 @@ from .generator import (
     Img2Img,
     Inpaint
 )
-from .model_management import ModelManager, SDModelComponent
+from .model_management import ModelManager
 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,40 +38,34 @@ from transformers import (
 
 import invokeai.configs as configs
 
-from invokeai.frontend.install.model_install import addModelsForm, process_and_execute
-from invokeai.frontend.install.widgets import (
+from ...frontend.install.model_install import addModelsForm, process_and_execute
+from ...frontend.install.widgets import (
     CenteredButtonPress,
     IntTitleSlider,
     set_min_terminal_size,
 )
-from invokeai.backend.config.legacy_arg_parsing import legacy_parser
-from invokeai.backend.config.model_install_backend import (
+from ..args import PRECISION_CHOICES, Args
+from ..globals import Globals, global_cache_dir, global_config_dir, global_config_file
+from .model_install_backend import (
     default_dataset,
     download_from_hf,
     hf_download_with_resume,
     recommended_datasets,
 )
-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 = config.model_conf_path
-SD_Configs = config.legacy_conf_path
+Default_config_file = Path(global_config_dir()) / "models.yaml"
+SD_Configs = Path(global_config_dir()) / "stable-diffusion"
 
 Datasets = OmegaConf.load(Dataset_path)
 
@@ -79,12 +73,17 @@ 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
 """
 
 
@@ -97,13 +96,14 @@ If you installed manually from source or with 'pip install': activate the virtua
 then run one of the following commands to start InvokeAI.
 
 Web UI:
-   invokeai-web
+   invokeai --web # (connect to http://localhost:9090)
+   invokeai --web --host 0.0.0.0 # (connect to http://your-lan-ip:9090 from another computer on the local network)
 
-Command-line client:
+Command-line interface:
    invokeai
 
 If you installed using an installation script, run:
-  {config.root}/invoke.{"bat" if sys.platform == "win32" else "sh"}
+  {Globals.root}/invoke.{"bat" if sys.platform == "win32" else "sh"}
 
 Add the '--help' argument to see all of the command-line switches available for use.
 """
@@ -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(
-        config.root, "models/realesrgan/realesr-general-x4v3.pth"
+        Globals.root, "models/realesrgan/realesr-general-x4v3.pth"
     )
 
     wdn_model_dest = os.path.join(
-        config.root, "models/realesrgan/realesr-general-wdn-x4v3.pth"
+        Globals.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(config.root, model[1])
+        model_url, model_dest = model[0], os.path.join(Globals.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(config.root, "models/codeformer/codeformer.pth")
+    model_dest = os.path.join(Globals.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=config.cache_dir,
+            cache_dir=global_cache_dir("hub"),
         )
         if not AutoencoderKL.from_pretrained(repo_id, **args):
             raise Exception(f"download of {repo_id} failed")
@@ -306,7 +306,7 @@ def download_vaes():
         if not hf_download_with_resume(
             repo_id=repo_id,
             model_name=model_name,
-            model_dir=str(config.root / Model_dir / Weights_dir),
+            model_dir=str(Globals.root / Model_dir / Weights_dir),
         ):
             raise Exception(f"download of {model_name} failed")
     except Exception as e:
@@ -321,7 +321,8 @@ def get_root(root: str = None) -> str:
     elif os.environ.get("INVOKEAI_ROOT"):
         return os.environ.get("INVOKEAI_ROOT")
     else:
-        return config.root
+        return Globals.root
+
 
 # -------------------------------------
 class editOptsForm(npyscreen.FormMultiPage):
@@ -331,7 +332,7 @@ class editOptsForm(npyscreen.FormMultiPage):
     def create(self):
         program_opts = self.parentApp.program_opts
         old_opts = self.parentApp.invokeai_opts
-        first_time = not (config.root / 'invokeai.yaml').exists()
+        first_time = not (Globals.root / Globals.initfile).exists()
         access_token = HfFolder.get_token()
         window_width, window_height = get_terminal_size()
         for i in [
@@ -365,7 +366,7 @@ class editOptsForm(npyscreen.FormMultiPage):
         self.outdir = self.add_widget_intelligent(
             npyscreen.TitleFilename,
             name="(<tab> autocompletes, ctrl-N advances):",
-            value=str(old_opts.outdir) or str(default_output_dir()),
+            value=old_opts.outdir or str(default_output_dir()),
             select_dir=True,
             must_exist=False,
             use_two_lines=False,
@@ -380,17 +381,17 @@ class editOptsForm(npyscreen.FormMultiPage):
             editable=False,
             color="CONTROL",
         )
-        self.nsfw_checker = self.add_widget_intelligent(
+        self.safety_checker = self.add_widget_intelligent(
             npyscreen.Checkbox,
             name="NSFW checker",
-            value=old_opts.nsfw_checker,
+            value=old_opts.safety_checker,
             relx=5,
             scroll_exit=True,
         )
         self.nextrely += 1
         for i in [
-            "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".',
+            "If you have an account at HuggingFace you may paste your access token here",
+            'to allow InvokeAI to download styles & subjects from the "Concept Library".',
             "See https://huggingface.co/settings/tokens",
         ]:
             self.add_widget_intelligent(
@@ -434,10 +435,17 @@ class editOptsForm(npyscreen.FormMultiPage):
             relx=5,
             scroll_exit=True,
         )
-        self.xformers_enabled = self.add_widget_intelligent(
+        self.xformers = self.add_widget_intelligent(
             npyscreen.Checkbox,
             name="Enable xformers support if available",
-            value=old_opts.xformers_enabled,
+            value=old_opts.xformers,
+            relx=5,
+            scroll_exit=True,
+        )
+        self.ckpt_convert = self.add_widget_intelligent(
+            npyscreen.Checkbox,
+            name="Load legacy checkpoint models into memory as diffusers models",
+            value=old_opts.ckpt_convert,
             relx=5,
             scroll_exit=True,
         )
@@ -472,30 +480,19 @@ class editOptsForm(npyscreen.FormMultiPage):
         self.nextrely += 1
         self.add_widget_intelligent(
             npyscreen.FixedText,
-            value="Directories containing textual inversion and LoRA models (<tab> autocompletes, ctrl-N advances):",
+            value="Directory containing embedding/textual inversion files:",
             editable=False,
             color="CONTROL",
         )
-        self.embedding_dir = self.add_widget_intelligent(
+        self.embedding_path = self.add_widget_intelligent(
             npyscreen.TitleFilename,
-            name=" Textual Inversion Embeddings:",
+            name="(<tab> autocompletes, ctrl-N advances):",
             value=str(default_embedding_dir()),
             select_dir=True,
             must_exist=False,
             use_two_lines=False,
             labelColor="GOOD",
-            begin_entry_at=32,
-            scroll_exit=True,
-        )
-        self.lora_dir = self.add_widget_intelligent(
-            npyscreen.TitleFilename,
-            name="             LoRA and LyCORIS:",
-            value=str(default_lora_dir()),
-            select_dir=True,
-            must_exist=False,
-            use_two_lines=False,
-            labelColor="GOOD",
-            begin_entry_at=32,
+            begin_entry_at=40,
             scroll_exit=True,
         )
         self.nextrely += 1
@@ -562,9 +559,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_dir).parent.exists():
+        if not Path(opt.embedding_path).parent.exists():
             bad_fields.append(
-                f"The embedding directory does not seem to be valid. Please check that {str(Path(opt.embedding_dir).parent)} is an existing directory."
+                f"The embedding directory does not seem to be valid. Please check that {str(Path(opt.embedding_path).parent)} is an existing directory."
             )
         if len(bad_fields) > 0:
             message = "The following problems were detected and must be corrected:\n"
@@ -579,23 +576,20 @@ class editOptsForm(npyscreen.FormMultiPage):
         new_opts = Namespace()
 
         for attr in [
-                "outdir",
-                "nsfw_checker",
-                "free_gpu_mem",
-                "max_loaded_models",
-                "xformers_enabled",
-                "always_use_cpu",
-                "embedding_dir",
-                "lora_dir",
+            "outdir",
+            "safety_checker",
+            "free_gpu_mem",
+            "max_loaded_models",
+            "xformers",
+            "always_use_cpu",
+            "embedding_path",
+            "ckpt_convert",
         ]:
             setattr(new_opts, attr, getattr(self, attr).value)
 
         new_opts.hf_token = self.hf_token.value
         new_opts.license_acceptance = self.license_acceptance.value
         new_opts.precision = PRECISION_CHOICES[self.precision.value[0]]
-        
-        # widget library workaround to make max_loaded_models an int rather than a float
-        new_opts.max_loaded_models = int(new_opts.max_loaded_models)
 
         return new_opts
 
@@ -634,14 +628,15 @@ def edit_opts(program_opts: Namespace, invokeai_opts: Namespace) -> argparse.Nam
 
 
 def default_startup_options(init_file: Path) -> Namespace:
-    opts = InvokeAIAppConfig(argv=[])
+    opts = Args().parse_args([])
     outdir = Path(opts.outdir)
     if not outdir.is_absolute():
-        opts.outdir = str(config.root / opts.outdir)
+        opts.outdir = str(Globals.root / opts.outdir)
     if not init_file.exists():
-        opts.nsfw_checker = True
+        opts.safety_checker = True
     return opts
 
+
 def default_user_selections(program_opts: Namespace) -> Namespace:
     return Namespace(
         starter_models=default_dataset()
@@ -695,61 +690,70 @@ def run_console_ui(
 # -------------------------------------
 def write_opts(opts: Namespace, init_file: Path):
     """
-    Update the invokeai.yaml file with values from current settings.
+    Update the invokeai.init file with values from opts Namespace
     """
+    # touch file if it doesn't exist
+    if not init_file.exists():
+        with open(init_file, "w") as f:
+            f.write(INIT_FILE_PREAMBLE)
 
-    # this will load current settings
-    config = InvokeAIAppConfig()
-    for key,value in opts.__dict__.items():
-        if hasattr(config,key):
-            setattr(config,key,value)
+    # We want to write in the changed arguments without clobbering
+    # any other initialization values the user has entered. There is
+    # no good way to do this because of the one-way nature of
+    # argparse: i.e. --outdir could be --outdir, --out, or -o
+    # initfile needs to be replaced with a fully structured format
+    # such as yaml; this is a hack that will work much of the time
+    args_to_skip = re.compile(
+        "^--?(o|out|no-xformer|xformer|no-ckpt|ckpt|free|no-nsfw|nsfw|prec|max_load|embed|always|ckpt|free_gpu)"
+    )
+    # fix windows paths
+    opts.outdir = opts.outdir.replace("\\", "/")
+    opts.embedding_path = opts.embedding_path.replace("\\", "/")
+    new_file = f"{init_file}.new"
+    try:
+        lines = [x.strip() for x in open(init_file, "r").readlines()]
+        with open(new_file, "w") as out_file:
+            for line in lines:
+                if len(line) > 0 and not args_to_skip.match(line):
+                    out_file.write(line + "\n")
+            out_file.write(
+                f"""
+--outdir={opts.outdir}
+--embedding_path={opts.embedding_path}
+--precision={opts.precision}
+--max_loaded_models={int(opts.max_loaded_models)}
+--{'no-' if not opts.safety_checker else ''}nsfw_checker
+--{'no-' if not opts.xformers else ''}xformers
+--{'no-' if not opts.ckpt_convert else ''}ckpt_convert
+{'--free_gpu_mem' if opts.free_gpu_mem else ''}
+{'--always_use_cpu' if opts.always_use_cpu else ''}
+"""
+            )
+    except OSError as e:
+        print(f"** An error occurred while writing the init file: {str(e)}")
+
+    os.replace(new_file, init_file)
+
+    if opts.hf_token:
+        HfLogin(opts.hf_token)
 
-    with open(init_file,'w', encoding='utf-8') as file:
-        file.write(config.to_yaml())
 
 # -------------------------------------
 def default_output_dir() -> Path:
-    return config.root / "outputs"
+    return Globals.root / "outputs"
+
 
 # -------------------------------------
 def default_embedding_dir() -> Path:
-    return config.root / "embeddings"
+    return Globals.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():
@@ -806,8 +810,7 @@ def main():
     opt = parser.parse_args()
 
     # setting a global here
-    global config
-    config.root = Path(os.path.expanduser(get_root(opt.root) or ""))
+    Globals.root = Path(os.path.expanduser(get_root(opt.root) or ""))
 
     errors = set()
 
@@ -815,26 +818,19 @@ def main():
         models_to_download = default_user_selections(opt)
 
         # We check for to see if the runtime directory is correctly initialized.
-        old_init_file = 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)
+        init_file = Path(Globals.root, Globals.initfile)
+        if not init_file.exists() or not global_config_file().exists():
+            initialize_rootdir(Globals.root, opt.yes_to_all)
 
         if opt.yes_to_all:
-            write_default_options(opt, new_init_file)
+            write_default_options(opt, init_file)
             init_options = Namespace(
                 precision="float32" if opt.full_precision else "float16"
             )
         else:
-            init_options, models_to_download = run_console_ui(opt, new_init_file)
+            init_options, models_to_download = run_console_ui(opt, init_file)
             if init_options:
-                write_opts(init_options, new_init_file)
+                write_opts(init_options, init_file)
             else:
                 print(
                     '\n** CANCELLED AT USER\'S REQUEST. USE THE "invoke.sh" LAUNCHER TO RUN LATER **\n'

invokeai/backend/config/legacy_arg_parsing.py

@@ -1,390 +0,0 @@
-# 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,15 +19,13 @@ from tqdm import tqdm
 
 import invokeai.configs as configs
 
-from invokeai.app.services.config import get_invokeai_config
+from ..globals import Globals, global_cache_dir, global_config_dir
 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/"
 
@@ -49,11 +47,12 @@ Config_preamble = """
 
 
 def default_config_file():
-    return config.model_conf_path
+    return Path(global_config_dir()) / "models.yaml"
 
 
 def sd_configs():
-    return config.legacy_conf_path
+    return Path(global_config_dir()) / "stable-diffusion"
+
 
 def initial_models():
     global Datasets
@@ -68,6 +67,7 @@ def install_requested_models(
     scan_directory: Path = None,
     external_models: List[str] = None,
     scan_at_startup: bool = False,
+    convert_to_diffusers: bool = False,
     precision: str = "float16",
     purge_deleted: bool = False,
     config_file_path: Path = None,
@@ -113,6 +113,7 @@ def install_requested_models(
             try:
                 model_manager.heuristic_import(
                     path_url_or_repo,
+                    convert=convert_to_diffusers,
                     commit_to_conf=config_file_path,
                 )
             except KeyboardInterrupt:
@@ -121,10 +122,9 @@ def install_requested_models(
                 pass
 
     if scan_at_startup and scan_directory.is_dir():
-        argument = "--autoconvert"
-        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")
+        argument = "--autoconvert" if convert_to_diffusers else "--autoimport"
+        initfile = Path(Globals.root, Globals.initfile)
+        replacement = Path(Globals.root, f"{Globals.initfile}.new")
         directory = str(scan_directory).replace("\\", "/")
         with open(initfile, "r") as input:
             with open(replacement, "w") as output:
@@ -152,7 +152,7 @@ def get_root(root: str = None) -> str:
     elif os.environ.get("INVOKEAI_ROOT"):
         return os.environ.get("INVOKEAI_ROOT")
     else:
-        return config.root
+        return Globals.root
 
 
 # ---------------------------------------------
@@ -185,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(config.root, Model_dir, Weights_dir)
+    model_path = os.path.join(Globals.root, Model_dir, Weights_dir)
     if not os.path.exists(os.path.join(model_path, "model.ckpt")):
         return
     new_name = initial_models()["stable-diffusion-1.4"]["file"]
@@ -230,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(config.root, Model_dir, Weights_dir)
+    cache_dir = os.path.join(Globals.root, Model_dir, Weights_dir)
     return hf_download_with_resume(
         repo_id=repo_id,
         model_dir=cache_dir,
@@ -241,9 +241,9 @@ def _download_ckpt_weights(mconfig: DictConfig, access_token: str) -> Path:
 
 # ---------------------------------------------
 def download_from_hf(
-    model_class: object, model_name: str, **kwargs
+    model_class: object, model_name: str, cache_subdir: Path = Path("hub"), **kwargs
 ):
-    path = config.cache_dir
+    path = global_cache_dir(cache_subdir)
     model = model_class.from_pretrained(
         model_name,
         cache_dir=path,
@@ -419,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=config.root
+                successfully_downloaded[model], start=Globals.root
             )
             stanza["config"] = os.path.normpath(
                 os.path.join(sd_configs(), mod["config"])
@@ -458,7 +458,7 @@ def delete_weights(model_name: str, conf_stanza: dict):
 
     weights = Path(weights)
     if not weights.is_absolute():
-        weights = Path(config.root) / weights
+        weights = Path(Globals.root) / weights
         try:
             weights.unlink()
         except OSError as e:

invokeai/backend/generator/base.py

@@ -25,13 +25,11 @@ from typing import Callable, List, Iterator, Optional, Type
 from dataclasses import dataclass, field
 from diffusers.schedulers import SchedulerMixin as Scheduler
 
-import invokeai.backend.util.logging as logger
 from ..image_util import configure_model_padding
 from ..util.util import rand_perlin_2d
 from ..safety_checker import SafetyChecker
 from ..prompting.conditioning import get_uc_and_c_and_ec
 from ..stable_diffusion.diffusers_pipeline import StableDiffusionGeneratorPipeline
-from ..stable_diffusion.schedulers import SCHEDULER_MAP
 
 downsampling = 8
 
@@ -72,14 +70,25 @@ 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='',
@@ -120,12 +129,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'),
@@ -168,20 +174,14 @@ class InvokeAIGenerator(metaclass=ABCMeta):
         '''
         Return list of all the schedulers that we currently handle.
         '''
-        return list(SCHEDULER_MAP.keys())
+        return list(self.scheduler_map.keys())
 
     def load_generator(self, model: StableDiffusionGeneratorPipeline, generator_class: Type[Generator]):
         return generator_class(model, self.params.precision)
 
     def get_scheduler(self, scheduler_name:str, model: StableDiffusionGeneratorPipeline)->Scheduler:
-        scheduler_class, 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)
-        
+        scheduler_class = self.scheduler_map.get(scheduler_name,'ddim')
+        scheduler = scheduler_class.from_config(model.scheduler.config)
         # hack copied over from generate.py
         if not hasattr(scheduler, 'uses_inpainting_model'):
             scheduler.uses_inpainting_model = lambda: False
@@ -225,10 +225,10 @@ class Inpaint(Img2Img):
     def generate(self,
                  mask_image: Image.Image | torch.FloatTensor,
                  # Seam settings - when 0, doesn't fill seam
-                 seam_size: int = 96,
-                 seam_blur: int = 16,
+                 seam_size: int = 0,
+                 seam_blur: int = 0,
                  seam_strength: float = 0.7,
-                 seam_steps: int = 30,
+                 seam_steps: int = 10,
                  tile_size: int = 32,
                  inpaint_replace=False,
                  infill_method=None,
@@ -281,7 +281,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
@@ -372,7 +372,7 @@ class Generator:
                     try:
                         x_T = self.get_noise(width, height)
                     except:
-                        logger.error("An error occurred while getting initial noise")
+                        print("** An error occurred while getting initial noise **")
                         print(traceback.format_exc())
 
                 # Pass on the seed in case a layer beneath us needs to generate noise on its own.
@@ -607,7 +607,7 @@ class Generator:
         image = self.sample_to_image(sample)
         dirname = os.path.dirname(filepath) or "."
         if not os.path.exists(dirname):
-            logger.info(f"creating directory {dirname}")
+            print(f"** creating directory {dirname}")
             os.makedirs(dirname, exist_ok=True)
         image.save(filepath, "PNG")
 

invokeai/backend/generator/embiggen.py

@@ -8,11 +8,10 @@ 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)
@@ -73,22 +72,22 @@ class Embiggen(Generator):
             embiggen = [1.0]  # If not specified, assume no scaling
         elif embiggen[0] < 0:
             embiggen[0] = 1.0
-            logger.warning(
-                "Embiggen scaling factor cannot be negative, fell back to the default of 1.0 !"
+            print(
+                ">> Embiggen scaling factor cannot be negative, fell back to the default of 1.0 !"
             )
         if len(embiggen) < 2:
             embiggen.append(0.75)
         elif embiggen[1] > 1.0 or embiggen[1] < 0:
             embiggen[1] = 0.75
-            logger.warning(
-                "Embiggen upscaling strength for ESRGAN must be between 0 and 1, fell back to the default of 0.75 !"
+            print(
+                ">> Embiggen upscaling strength for ESRGAN must be between 0 and 1, fell back to the default of 0.75 !"
             )
         if len(embiggen) < 3:
             embiggen.append(0.25)
         elif embiggen[2] < 0:
             embiggen[2] = 0.25
-            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 !"
+            print(
+                ">> Overlap size for Embiggen must be a positive ratio between 0 and 1 OR a number of pixels, fell back to the default of 0.25 !"
             )
 
         # Convert tiles from their user-freindly count-from-one to count-from-zero, because we need to do modulo math
@@ -98,8 +97,8 @@ class Embiggen(Generator):
             embiggen_tiles.sort()
 
         if strength >= 0.5:
-            logger.warning(
-                f"Embiggen may produce mirror motifs if the strength (-f) is too high (currently {strength}). Try values between 0.35-0.45."
+            print(
+                f"* WARNING: Embiggen may produce mirror motifs if the strength (-f) is too high (currently {strength}). Try values between 0.35-0.45."
             )
 
         # Prep img2img generator, since we wrap over it
@@ -122,8 +121,8 @@ class Embiggen(Generator):
                 from ..restoration.realesrgan import ESRGAN
 
                 esrgan = ESRGAN()
-                logger.info(
-                    f"ESRGAN upscaling init image prior to cutting with Embiggen with strength {embiggen[1]}"
+                print(
+                    f">> ESRGAN upscaling init image prior to cutting with Embiggen with strength {embiggen[1]}"
                 )
                 if embiggen[0] > 2:
                     initsuperimage = esrgan.process(
@@ -313,10 +312,10 @@ class Embiggen(Generator):
         def make_image():
             # Make main tiles -------------------------------------------------
             if embiggen_tiles:
-                logger.info(f"Making {len(embiggen_tiles)} Embiggen tiles...")
+                print(f">> Making {len(embiggen_tiles)} Embiggen tiles...")
             else:
-                logger.info(
-                    f"Making {(emb_tiles_x * emb_tiles_y)} Embiggen tiles ({emb_tiles_x}x{emb_tiles_y})..."
+                print(
+                    f">> Making {(emb_tiles_x * emb_tiles_y)} Embiggen tiles ({emb_tiles_x}x{emb_tiles_y})..."
                 )
 
             emb_tile_store = []
@@ -362,11 +361,11 @@ class Embiggen(Generator):
                 # newinitimage.save(newinitimagepath)
 
                 if embiggen_tiles:
-                    logger.debug(
+                    print(
                         f"Making tile #{tile + 1} ({embiggen_tiles.index(tile) + 1} of {len(embiggen_tiles)} requested)"
                     )
                 else:
-                    logger.debug(f"Starting {tile + 1} of {(emb_tiles_x * emb_tiles_y)} tiles")
+                    print(f"Starting {tile + 1} of {(emb_tiles_x * emb_tiles_y)} tiles")
 
                 # create a torch tensor from an Image
                 newinitimage = np.array(newinitimage).astype(np.float32) / 255.0
@@ -548,8 +547,8 @@ class Embiggen(Generator):
                     # Layer tile onto final image
                     outputsuperimage.alpha_composite(intileimage, (left, top))
             else:
-                logger.error(
-                    "Could not find all Embiggen output tiles in memory? Something must have gone wrong with img2img generation."
+                print(
+                    "Error: could not find all Embiggen output tiles in memory? Something must have gone wrong with img2img generation."
                 )
 
             # after internal loops and patching up return Embiggen image

invokeai/backend/generator/inpaint.py

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

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,8 +14,6 @@ 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)
@@ -79,8 +77,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
-            logger.info(
-                f"Interpolating from {init_width}x{init_height} to {width}x{height} using DDIM sampling"
+            print(
+                f"\n>> Interpolating from {init_width}x{init_height} to {width}x{height} using DDIM sampling"
             )
 
             # resizing

invokeai/backend/globals.py

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

invokeai/backend/image_util/txt2mask.py

@@ -30,14 +30,15 @@ work fine.
 import numpy as np
 import torch
 from PIL import Image, ImageOps
+from torchvision import transforms
 from transformers import AutoProcessor, CLIPSegForImageSegmentation
 
-import invokeai.backend.util.logging as logger
-from invokeai.app.services.config import get_invokeai_config
+from invokeai.backend.globals import global_cache_dir
 
 CLIPSEG_MODEL = "CIDAS/clipseg-rd64-refined"
 CLIPSEG_SIZE = 352
 
+
 class SegmentedGrayscale(object):
     def __init__(self, image: Image, heatmap: torch.Tensor):
         self.heatmap = heatmap
@@ -82,16 +83,15 @@ class Txt2Mask(object):
     """
 
     def __init__(self, device="cpu", refined=False):
-        logger.info("Initializing clipseg model for text to mask inference")
-        config = get_invokeai_config()
+        print(">> Initializing clipseg model for text to mask inference")
 
         # 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=config.cache_dir
+            CLIPSEG_MODEL, cache_dir=global_cache_dir("hub")
         )
         self.model = CLIPSegForImageSegmentation.from_pretrained(
-            CLIPSEG_MODEL, cache_dir=config.cache_dir
+            CLIPSEG_MODEL, cache_dir=global_cache_dir("hub")
         )
 
     @torch.no_grad()
@@ -101,6 +101,18 @@ 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/__init__.py

@@ -5,7 +5,5 @@ from .convert_ckpt_to_diffusers import (
     convert_ckpt_to_diffusers,
     load_pipeline_from_original_stable_diffusion_ckpt,
 )
-from .model_manager import ModelManager,SDModelComponent
-
-
+from .model_manager import ModelManager
 

invokeai/backend/model_management/convert_ckpt_to_diffusers.py

@@ -25,8 +25,7 @@ from typing import Union
 import torch
 from safetensors.torch import load_file
 
-import invokeai.backend.util.logging as logger
-from invokeai.app.services.config import get_invokeai_config
+from invokeai.backend.globals import global_cache_dir, global_config_dir
 
 from .model_manager import ModelManager, SDLegacyType
 
@@ -47,7 +46,6 @@ from diffusers import (
     LDMTextToImagePipeline,
     LMSDiscreteScheduler,
     PNDMScheduler,
-    UniPCMultistepScheduler,
     StableDiffusionPipeline,
     UNet2DConditionModel,
 )
@@ -74,6 +72,7 @@ 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.
@@ -373,9 +372,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:
-        logger.debug(f"Checkpoint {path} has both EMA and non-EMA weights.")
+        print(f"   | Checkpoint {path} has both EMA and non-EMA weights.")
         if extract_ema:
-            logger.debug("Extracting EMA weights (usually better for inference)")
+            print("   | 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:])
@@ -393,8 +392,8 @@ def convert_ldm_unet_checkpoint(checkpoint, config, path=None, extract_ema=False
                             key
                         )
         else:
-            logger.debug(
-                "Extracting only the non-EMA weights (usually better for fine-tuning)"
+            print(
+                "   | Extracting only the non-EMA weights (usually better for fine-tuning)"
             )
 
     for key in keys:
@@ -842,7 +841,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=get_invokeai_config().cache_dir
+        "openai/clip-vit-large-patch14", cache_dir=global_cache_dir("hub")
     )
 
     keys = list(checkpoint.keys())
@@ -897,7 +896,7 @@ textenc_pattern = re.compile("|".join(protected.keys()))
 
 
 def convert_paint_by_example_checkpoint(checkpoint):
-    cache_dir = get_invokeai_config().cache_dir
+    cache_dir = global_cache_dir("hub")
     config = CLIPVisionConfig.from_pretrained(
         "openai/clip-vit-large-patch14", cache_dir=cache_dir
     )
@@ -969,7 +968,7 @@ def convert_paint_by_example_checkpoint(checkpoint):
 
 
 def convert_open_clip_checkpoint(checkpoint):
-    cache_dir = get_invokeai_config().cache_dir
+    cache_dir = global_cache_dir("hub")
     text_model = CLIPTextModel.from_pretrained(
         "stabilityai/stable-diffusion-2", subfolder="text_encoder", cache_dir=cache_dir
     )
@@ -1092,7 +1091,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()
@@ -1105,7 +1104,7 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
         else:
             checkpoint = load_file(checkpoint_path)
 
-        cache_dir = config.cache_dir
+        cache_dir = global_cache_dir("hub")
         pipeline_class = (
             StableDiffusionGeneratorPipeline
             if return_generator_pipeline
@@ -1116,7 +1115,7 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
         if "global_step" in checkpoint:
             global_step = checkpoint["global_step"]
         else:
-            logger.debug("global_step key not found in model")
+            print("   | global_step key not found in model")
             global_step = None
 
         # sometimes there is a state_dict key and sometimes not
@@ -1129,23 +1128,25 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
 
             if model_type == SDLegacyType.V2_v:
                 original_config_file = (
-                    config.legacy_conf_path / "v2-inference-v.yaml"
+                    global_config_dir() / "stable-diffusion" / "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 = (
-                    config.legacy_conf_path / "v2-inference.yaml"
+                    global_config_dir() / "stable-diffusion" / "v2-inference.yaml"
                 )
             elif model_type == SDLegacyType.V1_INPAINT:
                 original_config_file = (
-                    config.legacy_conf_path / "v1-inpainting-inference.yaml"
+                    global_config_dir()
+                    / "stable-diffusion"
+                    / "v1-inpainting-inference.yaml"
                 )
 
             elif model_type == SDLegacyType.V1:
                 original_config_file = (
-                    config.legacy_conf_path / "v1-inference.yaml"
+                    global_config_dir() / "stable-diffusion" / "v1-inference.yaml"
                 )
 
             else:
@@ -1207,8 +1208,6 @@ 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:
@@ -1230,15 +1229,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:
-            logger.debug(f"Converting VAE {vae_path}")
+            print(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:
-            logger.debug("Using checkpoint model's original VAE")
+            print("   | Using checkpoint model's original VAE")
 
         if vae:
-            logger.debug("Using replacement diffusers VAE")
+            print("   | Using replacement diffusers VAE")
         else:  # convert the original or replacement VAE
             vae_config = create_vae_diffusers_config(
                 original_config, image_size=image_size
@@ -1297,7 +1296,7 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
             )
             safety_checker = StableDiffusionSafetyChecker.from_pretrained(
                 "CompVis/stable-diffusion-safety-checker",
-                cache_dir=config.cache_dir,
+                cache_dir=global_cache_dir("hub"),
             )
             feature_extractor = AutoFeatureExtractor.from_pretrained(
                 "CompVis/stable-diffusion-safety-checker", cache_dir=cache_dir

invokeai/backend/model_management/model_manager.py

@@ -1,4 +1,4 @@
-"""enum
+"""
 Manage a cache of Stable Diffusion model files for fast switching.
 They are moved between GPU and CPU as necessary. If CPU memory falls
 below a preset minimum, the least recently used model will be
@@ -15,82 +15,55 @@ import sys
 import textwrap
 import time
 import warnings
-from enum import Enum, auto
+from enum import Enum
 from pathlib import Path
 from shutil import move, rmtree
-from typing import Any, Optional, Union, Callable, types
+from typing import Any, Optional, Union, Callable
 
 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 diffusers import AutoencoderKL
+from diffusers import 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 transformers import (
-    CLIPTextModel,
-    CLIPTokenizer,
-    CLIPFeatureExtractor,
-)
-from diffusers.pipelines.stable_diffusion.safety_checker import (
-    StableDiffusionSafetyChecker,
-    )
-from ..stable_diffusion import (
-    StableDiffusionGeneratorPipeline,
-)
-from invokeai.app.services.config import get_invokeai_config
+from invokeai.backend.globals import Globals, global_cache_dir
+
+from ..stable_diffusion import StableDiffusionGeneratorPipeline
 from ..util import CUDA_DEVICE, ask_user, download_with_resume
 
 class SDLegacyType(Enum):
-    V1 = auto()
-    V1_INPAINT = auto()
-    V2 = auto()
-    V2_e = auto()
-    V2_v = auto()
-    UNKNOWN = auto()
-
-class SDModelComponent(Enum):
-    vae="vae"
-    text_encoder="text_encoder"
-    tokenizer="tokenizer"
-    unet="unet"
-    scheduler="scheduler"
-    safety_checker="safety_checker"
-    feature_extractor="feature_extractor"
+    V1 = 1
+    V1_INPAINT = 2
+    V2   = 3
+    V2_e = 4
+    V2_v = 5
+    UNKNOWN = 99
 
 DEFAULT_MAX_MODELS = 2
 
 class ModelManager(object):
-    """
+    '''
     Model manager handles loading, caching, importing, deleting, converting, and editing models.
-    """
-
-    logger: types.ModuleType = logger
-
+    '''
     def __init__(
-        self,
-        config: OmegaConf | Path,
-        device_type: torch.device = CUDA_DEVICE,
-        precision: str = "float16",
-        max_loaded_models=DEFAULT_MAX_MODELS,
-        sequential_offload=False,
-        embedding_path: Path = None,
-        logger: types.ModuleType = logger,
+            self,
+            config: OmegaConf|Path,
+            device_type: torch.device = CUDA_DEVICE,
+            precision: str = "float16",
+            max_loaded_models=DEFAULT_MAX_MODELS,
+            sequential_offload=False,
+            embedding_path: Path=None,
     ):
         """
         Initialize with the path to the models.yaml config file or
         an initialized OmegaConf dictionary. Optional parameters
         are the torch device type, precision, max_loaded_models,
-        and sequential_offload boolean. Note that the default device
+        and sequential_offload boolean. Note that the default device 
         type and precision are set up for a CUDA system running at half precision.
         """
         # prevent nasty-looking CLIP log message
@@ -98,7 +71,6 @@ 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
@@ -107,7 +79,6 @@ 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:
         """
@@ -116,28 +87,18 @@ class ModelManager(object):
         """
         return model_name in self.config
 
-    def get_model(self, model_name: str = None) -> dict:
-        """Given a model named identified in models.yaml, return a dict
-        containing the model object and some of its key features. If
-        in RAM will load into GPU VRAM.  If on disk, will load from
-        there.
-        The dict has the following keys:
-        'model': The StableDiffusionGeneratorPipeline object
-        'model_name': The name of the model in models.yaml
-        'width': The width of images trained by this model
-        'height': The height of images trained by this model
-        'hash': A unique hash of this model's files on disk.
+    def get_model(self, model_name: str=None)->dict:
+        """
+        Given a model named identified in models.yaml, return
+        the model object. If in RAM will load into GPU VRAM.
+        If on disk, will load from there.
         """
         if not model_name:
-            return (
-                self.get_model(self.current_model)
-                if self.current_model
-                else self.get_model(self.default_model())
-            )
-
+            return self.get_model(self.current_model) if self.current_model else self.get_model(self.default_model())
+        
         if not self.valid_model(model_name):
-            self.logger.error(
-                f'"{model_name}" is not a known model name. Please check your models.yaml file'
+            print(
+                f'** "{model_name}" is not a known model name. Please check your models.yaml file'
             )
             return self.current_model
 
@@ -148,7 +109,7 @@ class ModelManager(object):
 
         if model_name in self.models:
             requested_model = self.models[model_name]["model"]
-            self.logger.info(f"Retrieving model {model_name} from system RAM cache")
+            print(f">> Retrieving model {model_name} from system RAM cache")
             requested_model.ready()
             width = self.models[model_name]["width"]
             height = self.models[model_name]["height"]
@@ -174,81 +135,6 @@ class ModelManager(object):
             "hash": hash,
         }
 
-    def get_model_vae(self, model_name: str=None)->AutoencoderKL:
-        """Given a model name identified in models.yaml, load the model into
-        GPU if necessary and return its assigned VAE as an
-        AutoencoderKL object. If no model name is provided, return the
-        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
-        model name is provided, return the tokenizer from the model
-        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.
-        """
-        return self._get_sub_model(model_name, SDModelComponent.unet)
-
-    def get_model_text_encoder(self, model_name: str=None)->CLIPTextModel:
-        """Given a model name identified in models.yaml, load the model into
-        GPU if necessary and return its assigned CLIPTextModel. If no
-        model name is provided, return the text encoder from the model
-        currently in the GPU.
-        """
-        return self._get_sub_model(model_name, SDModelComponent.text_encoder)
-
-    def get_model_feature_extractor(self, model_name: str=None)->CLIPFeatureExtractor:
-        """Given a model name identified in models.yaml, load the model into
-        GPU if necessary and return its assigned CLIPFeatureExtractor. If no
-        model name is provided, return the text encoder from the model
-        currently in the GPU.
-        """
-        return self._get_sub_model(model_name, SDModelComponent.feature_extractor)
-
-    def get_model_scheduler(self, model_name: str=None)->SchedulerMixin:
-        """Given a model name identified in models.yaml, load the model into
-        GPU if necessary and return its assigned scheduler. If no
-        model name is provided, return the text encoder from the model
-        currently in the GPU.
-        """
-        return self._get_sub_model(model_name, SDModelComponent.scheduler)
-
-    def _get_sub_model(
-            self,
-            model_name: str=None,
-            model_part: SDModelComponent=SDModelComponent.vae,
-    ) -> Union[
-        AutoencoderKL,
-        CLIPTokenizer,
-        CLIPFeatureExtractor,
-        UNet2DConditionModel,
-        CLIPTextModel,
-        StableDiffusionSafetyChecker,
-    ]:
-        """Given a model name identified in models.yaml, and the part of the
-        model you wish to retrieve, return that part. Parts are in an Enum
-        class named SDModelComponent, and consist of:
-        SDModelComponent.vae
-        SDModelComponent.text_encoder
-        SDModelComponent.tokenizer
-        SDModelComponent.unet
-        SDModelComponent.scheduler
-        SDModelComponent.safety_checker
-        SDModelComponent.feature_extractor
-        """
-        model_dict = self.get_model(model_name)
-        model = model_dict["model"]
-        return getattr(model, model_part.value)
-
     def default_model(self) -> str | None:
         """
         Returns the name of the default model, or None
@@ -291,7 +177,7 @@ class ModelManager(object):
         """
         # if we are converting legacy files automatically, then
         # there are no legacy ckpts!
-        if self.globals.ckpt_convert:
+        if Globals.ckpt_convert:
             return False
         info = self.model_info(model_name)
         if "weights" in info and info["weights"].endswith((".ckpt", ".safetensors")):
@@ -383,7 +269,7 @@ class ModelManager(object):
         """
         omega = self.config
         if model_name not in omega:
-            self.logger.error(f"Unknown model {model_name}")
+            print(f"** Unknown model {model_name}")
             return
         # save these for use in deletion later
         conf = omega[model_name]
@@ -396,13 +282,13 @@ class ModelManager(object):
             self.stack.remove(model_name)
         if delete_files:
             if weights:
-                self.logger.info(f"Deleting file {weights}")
+                print(f"** Deleting file {weights}")
                 Path(weights).unlink(missing_ok=True)
             elif path:
-                self.logger.info(f"Deleting directory {path}")
+                print(f"** Deleting directory {path}")
                 rmtree(path, ignore_errors=True)
             elif repo_id:
-                self.logger.info(f"Deleting the cached model directory for {repo_id}")
+                print(f"** Deleting the cached model directory for {repo_id}")
                 self._delete_model_from_cache(repo_id)
 
     def add_model(
@@ -443,7 +329,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:
-            self.logger.error(
+            print(
                 f'"{model_name}" is not a known model name. Please check your models.yaml file'
             )
             return
@@ -461,7 +347,7 @@ class ModelManager(object):
         model_format = mconfig.get("format", "ckpt")
         if model_format == "ckpt":
             weights = mconfig.weights
-            self.logger.info(f"Loading {model_name} from {weights}")
+            print(f">> Loading {model_name} from {weights}")
             model, width, height, model_hash = self._load_ckpt_model(
                 model_name, mconfig
             )
@@ -474,18 +360,16 @@ class ModelManager(object):
                 f"Unknown model format {model_name}: {model_format}"
             )
         self._add_embeddings_to_model(model)
-
+        
         # usage statistics
         toc = time.time()
-        self.logger.info("Model loaded in " + "%4.2fs" % (toc - tic))
+        print(">> Model loaded in", "%4.2fs" % (toc - tic))
         if self._has_cuda():
-            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)
+            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),
             )
         return model, width, height, model_hash
 
@@ -493,21 +377,21 @@ class ModelManager(object):
         name_or_path = self.model_name_or_path(mconfig)
         using_fp16 = self.precision == "float16"
 
-        self.logger.info(f"Loading diffusers model from {name_or_path}")
+        print(f">> Loading diffusers model from {name_or_path}")
         if using_fp16:
-            self.logger.debug("Using faster float16 precision")
+            print("   | Using faster float16 precision")
         else:
-            self.logger.debug("Using more accurate float32 precision")
+            print("   | Using more accurate float32 precision")
 
         # TODO: scan weights maybe?
         pipeline_args: dict[str, Any] = dict(
-            safety_checker=None, local_files_only=not self.globals.internet_available
+            safety_checker=None, local_files_only=not 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=self.globals.cache_dir)
+            pipeline_args.update(cache_dir=global_cache_dir("hub"))
         if using_fp16:
             pipeline_args.update(torch_dtype=torch.float16)
             fp_args_list = [{"revision": "fp16"}, {}]
@@ -529,8 +413,8 @@ class ModelManager(object):
                 if str(e).startswith("fp16 is not a valid"):
                     pass
                 else:
-                    self.logger.error(
-                        f"An unexpected error occurred while downloading the model: {e})"
+                    print(
+                        f"** An unexpected error occurred while downloading the model: {e})"
                     )
             if pipeline:
                 break
@@ -548,8 +432,8 @@ class ModelManager(object):
         # square images???
         width = pipeline.unet.config.sample_size * pipeline.vae_scale_factor
         height = width
-        self.logger.debug(f"Default image dimensions = {width} x {height}")
-
+        print(f"   | Default image dimensions = {width} x {height}")
+        
         return pipeline, width, height, model_hash
 
     def _load_ckpt_model(self, model_name, mconfig):
@@ -559,24 +443,25 @@ class ModelManager(object):
         width = mconfig.width
         height = mconfig.height
 
-        root_dir = self.globals.root_dir
-        config = str(root_dir / config)
-        weights = str(root_dir / weights)
+        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))
 
         # Convert to diffusers and return a diffusers pipeline
-        self.logger.info(f"Converting legacy checkpoint {model_name} into a diffusers model...")
+        print(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":
+            if self.list_models()[self.current_model]['status'] == 'active':
                 self.offload_model(self.current_model)
-        except Exception:
+        except Exception as e:
             pass
-
+        
         vae_path = None
         if vae:
-            vae_path = str(root_dir / vae)
+            vae_path = vae if os.path.isabs(vae) else os.path.normpath(os.path.join(Globals.root, vae))
         if self._has_cuda():
             torch.cuda.empty_cache()
         pipeline = load_pipeline_from_original_stable_diffusion_ckpt(
@@ -608,7 +493,9 @@ class ModelManager(object):
             )
 
         if "path" in mconfig and mconfig["path"] is not None:
-            path = self.globals.root_dir / Path(mconfig["path"])
+            path = Path(mconfig["path"])
+            if not path.is_absolute():
+                path = Path(Globals.root, path).resolve()
             return path
         elif "repo_id" in mconfig:
             return mconfig["repo_id"]
@@ -623,7 +510,7 @@ class ModelManager(object):
         if model_name not in self.models:
             return
 
-        self.logger.info(f"Offloading {model_name} to CPU")
+        print(f">> Offloading {model_name} to CPU")
         model = self.models[model_name]["model"]
         model.offload_all()
         self.current_model = None
@@ -639,26 +526,30 @@ class ModelManager(object):
         and option to exit if an infected file is identified.
         """
         # scan model
-        self.logger.debug(f"Scanning Model: {model_name}")
+        print(f"   | Scanning Model: {model_name}")
         scan_result = scan_file_path(checkpoint)
         if scan_result.infected_files != 0:
             if scan_result.infected_files == 1:
-                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")
+                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")
                 sys.exit()
             else:
-                self.logger.warning("InvokeAI was unable to scan the model you are using.")
+                print(
+                    "\n### 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":
-                    self.logger.critical("Exiting InvokeAI")
+                    print("### Exiting InvokeAI")
                     sys.exit()
         else:
-            self.logger.debug("Model scanned ok")
+            print("   | Model scanned ok")
 
     def import_diffuser_model(
         self,
@@ -680,7 +571,9 @@ class ModelManager(object):
         models.yaml file.
         """
         model_name = model_name or Path(repo_or_path).stem
-        model_description = description or f"Imported diffusers model {model_name}"
+        model_description = (
+            description or f"Imported diffusers model {model_name}"
+        )
         new_config = dict(
             description=model_description,
             vae=vae,
@@ -709,7 +602,7 @@ class ModelManager(object):
         SDLegacyType.V2_v   (V2 using 'v_prediction' prediction type)
         SDLegacyType.UNKNOWN
         """
-        global_step = checkpoint.get("global_step")
+        global_step = checkpoint.get('global_step')
         state_dict = checkpoint.get("state_dict") or checkpoint
 
         try:
@@ -735,13 +628,13 @@ class ModelManager(object):
             return SDLegacyType.UNKNOWN
 
     def heuristic_import(
-        self,
-        path_url_or_repo: str,
-        model_name: str = None,
-        description: str = None,
-        model_config_file: Path = None,
-        commit_to_conf: Path = None,
-        config_file_callback: Callable[[Path], Path] = None,
+            self,
+            path_url_or_repo: str,
+            model_name: str = None,
+            description: str = None,
+            model_config_file: Path = None,
+            commit_to_conf: Path = None,
+            config_file_callback: Callable[[Path], Path] = None,
     ) -> str:
         """Accept a string which could be:
            - a HF diffusers repo_id
@@ -775,24 +668,26 @@ class ModelManager(object):
         model_path: Path = None
         thing = path_url_or_repo  # to save typing
 
-        self.logger.info(f"Probing {thing} for import")
+        print(f">> Probing {thing} for import")
 
         if thing.startswith(("http:", "https:", "ftp:")):
-            self.logger.info(f"{thing} appears to be a URL")
+            print(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"]:
-                self.logger.debug(f"{Path(thing).name} appears to be part of a diffusers model. Skipping import")
+                print(
+                    f"   | {Path(thing).name} appears to be part of a diffusers model. Skipping import"
+                )
                 return
             else:
-                self.logger.debug(f"{thing} appears to be a checkpoint file on disk")
+                print(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():
-            self.logger.debug(f"{thing} appears to be a diffusers file on disk")
+            print(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"),
@@ -803,30 +698,34 @@ class ModelManager(object):
 
         elif Path(thing).is_dir():
             if (Path(thing) / "model_index.json").exists():
-                self.logger.debug(f"{thing} appears to be a diffusers model.")
+                print(f"   | {thing} appears to be a diffusers model.")
                 model_name = self.import_diffuser_model(
                     thing, commit_to_conf=commit_to_conf
                 )
             else:
-                self.logger.debug(f"{thing} appears to be a directory. Will scan for models to import")
+                print(
+                    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
                     ):
-                        self.logger.info(f"{model_name} successfully imported")
+                        print(f" >> {model_name} successfully imported")
                 return model_name
 
         elif re.match(r"^[\w.+-]+/[\w.+-]+$", thing):
-            self.logger.debug(f"{thing} appears to be a HuggingFace diffusers repo_id")
+            print(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:
-            self.logger.warning(f"{thing}: Unknown thing. Please provide a URL, file path, directory or HuggingFace repo_id")
+            print(
+                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
@@ -834,13 +733,13 @@ class ModelManager(object):
             return
 
         if model_path.stem in self.config:  # already imported
-            self.logger.debug("Already imported. Skipping")
+            print("   | Already imported. Skipping")
             return model_path.stem
 
         # another round of heuristics to guess the correct config file.
         checkpoint = None
-        if model_path.suffix in [".ckpt", ".pt"]:
-            self.scan_model(model_path, model_path)
+        if model_path.suffix in [".ckpt",".pt"]:
+            self.scan_model(model_path,model_path)
             checkpoint = torch.load(model_path)
         else:
             checkpoint = safetensors.torch.load_file(model_path)
@@ -850,30 +749,42 @@ 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")
-                self.logger.debug(f"Using config file {model_config_file.name}")
+                print(f"   | Using config file {model_config_file.name}")
 
             else:
                 model_type = self.probe_model_type(checkpoint)
                 if model_type == SDLegacyType.V1:
-                    self.logger.debug("SD-v1 model detected")
-                    model_config_file = self.globals.legacy_conf_path / "v1-inference.yaml"
+                    print("   | SD-v1 model detected")
+                    model_config_file = Path(
+                        Globals.root, "configs/stable-diffusion/v1-inference.yaml"
+                    )
                 elif model_type == SDLegacyType.V1_INPAINT:
-                    self.logger.debug("SD-v1 inpainting model detected")
-                    model_config_file = self.globals.legacy_conf_path / "v1-inpainting-inference.yaml",
+                    print("   | SD-v1 inpainting model detected")
+                    model_config_file = Path(
+                        Globals.root, "configs/stable-diffusion/v1-inpainting-inference.yaml"
+                    )
                 elif model_type == SDLegacyType.V2_v:
-                    self.logger.debug("SD-v2-v model detected")
-                    model_config_file = self.globals.legacy_conf_path / "v2-inference-v.yaml"
+                    print(
+                        "   | SD-v2-v model detected"
+                    )
+                    model_config_file = Path(
+                        Globals.root, "configs/stable-diffusion/v2-inference-v.yaml"
+                    )
                 elif model_type == SDLegacyType.V2_e:
-                    self.logger.debug("SD-v2-e model detected")
-                    model_config_file = self.globals.legacy_conf_path / "v2-inference.yaml"
+                    print(
+                        "   | SD-v2-e model detected"
+                    )
+                    model_config_file = Path(
+                        Globals.root, "configs/stable-diffusion/v2-inference.yaml"
+                    )
                 elif model_type == SDLegacyType.V2:
-                    self.logger.warning(
-                        f"{thing} is a V2 checkpoint file, but its parameterization cannot be determined. Please provide configuration file path."
+                    print(
+                        f"** {thing} is a V2 checkpoint file, but its parameterization cannot be determined. Please provide configuration file path."
                     )
                     return
                 else:
-                    self.logger.warning(
-                        f"{thing} is a legacy checkpoint file but not a known Stable Diffusion model. Please provide configuration file path."
+                    print(
+                        f"** {thing} is a legacy checkpoint file but not a known Stable Diffusion model. Please provide configuration file path."
                     )
                     return
 
@@ -889,10 +800,12 @@ 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}")
-                self.logger.debug(f"Using VAE file {vae_path.name}")
+                print(f"   | Using VAE file {vae_path.name}")
         vae = None if vae_path else dict(repo_id="stabilityai/sd-vae-ft-mse")
 
-        diffuser_path = self.globals.root_dir / "models/converted_ckpts" / model_path.stem
+        diffuser_path = Path(
+            Globals.root, "models", Globals.converted_ckpts_dir, model_path.stem
+        )
         model_name = self.convert_and_import(
             model_path,
             diffusers_path=diffuser_path,
@@ -907,16 +820,16 @@ class ModelManager(object):
         return model_name
 
     def convert_and_import(
-        self,
-        ckpt_path: Path,
-        diffusers_path: Path,
-        model_name=None,
-        model_description=None,
-        vae: dict = None,
-        vae_path: Path = None,
-        original_config_file: Path = None,
-        commit_to_conf: Path = None,
-        scan_needed: bool = True,
+            self,
+            ckpt_path: Path,
+            diffusers_path: Path,
+            model_name=None,
+            model_description=None,
+            vae:dict=None,
+            vae_path:Path=None,
+            original_config_file: Path = None,
+            commit_to_conf: Path = None,
+            scan_needed: bool=True,
     ) -> str:
         """
         Convert a legacy ckpt weights file to diffuser model and import
@@ -933,21 +846,21 @@ class ModelManager(object):
         from . import convert_ckpt_to_diffusers
 
         if diffusers_path.exists():
-            self.logger.error(
-                f"The path {str(diffusers_path)} already exists. Please move or remove it and try again."
+            print(
+                f"ERROR: 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}"
-        self.logger.debug(f"Converting {model_name} to diffusers (30-60s)")
+        print(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
-            vae_model = None
+            vae_model=None
             if vae:
-                vae_model = self._load_vae(vae)
-                vae_path = None
+                vae_model=self._load_vae(vae)
+                vae_path=None
             convert_ckpt_to_diffusers(
                 ckpt_path,
                 diffusers_path,
@@ -957,10 +870,10 @@ class ModelManager(object):
                 vae_path=vae_path,
                 scan_needed=scan_needed,
             )
-            self.logger.debug(
-                f"Success. Converted model is now located at {str(diffusers_path)}"
+            print(
+                f"   | Success. Converted model is now located at {str(diffusers_path)}"
             )
-            self.logger.debug(f"Writing new config file entry for {model_name}")
+            print(f"   | Writing new config file entry for {model_name}")
             new_config = dict(
                 path=str(diffusers_path),
                 description=model_description,
@@ -971,17 +884,17 @@ class ModelManager(object):
             self.add_model(model_name, new_config, True)
             if commit_to_conf:
                 self.commit(commit_to_conf)
-            self.logger.debug("Conversion succeeded")
+            print("   | Conversion succeeded")
         except Exception as e:
-            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)"
+            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)"
             )
 
         return model_name
 
     def search_models(self, search_folder):
-        self.logger.info(f"Finding Models In: {search_folder}")
+        print(f">> Finding Models In: {search_folder}")
         models_folder_ckpt = Path(search_folder).glob("**/*.ckpt")
         models_folder_safetensors = Path(search_folder).glob("**/*.safetensors")
 
@@ -1005,8 +918,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()
-            self.logger.info(
-                f"Cache limit (max={self.max_loaded_models}) reached. Purging {least_recent_model}"
+            print(
+                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]
@@ -1014,8 +927,8 @@ class ModelManager(object):
 
     def print_vram_usage(self) -> None:
         if self._has_cuda:
-            self.logger.info(
-                "Current VRAM usage:"+
+            print(
+                ">> Current VRAM usage: ",
                 "%4.2fG" % (torch.cuda.memory_allocated() / 1e9),
             )
 
@@ -1025,7 +938,9 @@ class ModelManager(object):
         """
         yaml_str = OmegaConf.to_yaml(self.config)
         if not os.path.isabs(config_file_path):
-            config_file_path = self.globals.model_conf_path
+            config_file_path = os.path.normpath(
+                os.path.join(Globals.root, config_file_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())
@@ -1057,21 +972,20 @@ class ModelManager(object):
         """
         # Three transformer models to check: bert, clip and safety checker, and
         # the diffusers as well
-        config = get_invokeai_config()
-        models_dir = config.root_dir / "models"
+        models_dir = Path(Globals.root, "models")
         legacy_locations = [
             Path(
                 models_dir,
-                "CompVis/stable-diffusion-safety-checker/models--CompVis--stable-diffusion-safety-checker",
+                "CompVis/stable-diffusion-safety-checker/models--CompVis--stable-diffusion-safety-checker"
             ),
             Path(models_dir, "bert-base-uncased/models--bert-base-uncased"),
             Path(
                 models_dir,
-                "openai/clip-vit-large-patch14/models--openai--clip-vit-large-patch14",
+                "openai/clip-vit-large-patch14/models--openai--clip-vit-large-patch14"
             ),
         ]
-        legacy_cache_dir = config.cache_dir / "../diffusers"
-        legacy_locations.extend(list(legacy_cache_dir.glob("*")))
+        legacy_locations.extend(list(global_cache_dir("diffusers").glob('*')))
+        
         legacy_layout = False
         for model in legacy_locations:
             legacy_layout = legacy_layout or model.exists()
@@ -1089,11 +1003,11 @@ class ModelManager(object):
 >> make adjustments, please press ctrl-C now to abort and relaunch InvokeAI when you are ready.
 >> Otherwise press <enter> to continue."""
         )
-        input("continue> ")
+        input('continue> ')
 
         # transformer files get moved into the hub directory
         if cls._is_huggingface_hub_directory_present():
-            hub = config.cache_dir
+            hub = global_cache_dir("hub")
         else:
             hub = models_dir / "hub"
 
@@ -1103,10 +1017,10 @@ class ModelManager(object):
             dest = hub / model.stem
             if dest.exists() and not source.exists():
                 continue
-            cls.logger.info(f"{source} => {dest}")
+            print(f"** {source} => {dest}")
             if source.exists():
                 if dest.is_symlink():
-                    logger.warning(f"Found symlink at {dest.name}. Not migrating.")
+                    print(f"** Found symlink at {dest.name}. Not migrating.")
                 elif dest.exists():
                     if source.is_dir():
                         rmtree(source)
@@ -1123,7 +1037,7 @@ class ModelManager(object):
         ]
         for d in empty:
             os.rmdir(d)
-        cls.logger.info("Migration is done. Continuing...")
+        print("** Migration is done. Continuing...")
 
     def _resolve_path(
         self, source: Union[str, Path], dest_directory: str
@@ -1132,12 +1046,13 @@ class ModelManager(object):
         if str(source).startswith(("http:", "https:", "ftp:")):
             dest_directory = Path(dest_directory)
             if not dest_directory.is_absolute():
-                dest_directory = self.globals.root_dir / dest_directory
+                dest_directory = Globals.root / dest_directory
             dest_directory.mkdir(parents=True, exist_ok=True)
             resolved_path = download_with_resume(str(source), dest_directory)
         else:
-            source = self.globals.root_dir / source
-            resolved_path = source
+            if not os.path.isabs(source):
+                source = os.path.join(Globals.root, source)
+            resolved_path = Path(source)
         return resolved_path
 
     def _invalidate_cached_model(self, model_name: str) -> None:
@@ -1165,29 +1080,29 @@ class ModelManager(object):
 
     def _add_embeddings_to_model(self, model: StableDiffusionGeneratorPipeline):
         if self.embedding_path is not None:
-            self.logger.info(f"Loading embeddings from {self.embedding_path}")
+            print(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
                     )
-            self.logger.info(
-                f'Textual inversion triggers: {", ".join(sorted(model.textual_inversion_manager.get_all_trigger_strings()))}'
+            print(
+                f'>> Textual inversion triggers: {", ".join(sorted(model.textual_inversion_manager.get_all_trigger_strings()))}'
             )
-
+            
     def _has_cuda(self) -> bool:
         return self.device.type == "cuda"
 
     def _diffuser_sha256(
-        self, name_or_path: Union[str, Path], chunksize=16777216
+        self, name_or_path: Union[str, Path], chunksize=4096
     ) -> Union[str, bytes]:
         path = None
         if isinstance(name_or_path, Path):
             path = name_or_path
         else:
             owner, repo = name_or_path.split("/")
-            path = self.globals.cache_dir / f"models--{owner}--{repo}"
+            path = Path(global_cache_dir("hub") / f"models--{owner}--{repo}")
         if not path.exists():
             return None
         hashpath = path / "checksum.sha256"
@@ -1195,7 +1110,7 @@ class ModelManager(object):
             with open(hashpath) as f:
                 hash = f.read()
             return hash
-        self.logger.debug("Calculating sha256 hash of model files")
+        print("   | Calculating sha256 hash of model files")
         tic = time.time()
         sha = hashlib.sha256()
         count = 0
@@ -1207,7 +1122,7 @@ class ModelManager(object):
                         sha.update(chunk)
         hash = sha.hexdigest()
         toc = time.time()
-        self.logger.debug(f"sha256 = {hash} ({count} files hashed in {toc - tic:4.2f}s)")
+        print(f"   | sha256 = {hash} ({count} files hashed in", "%4.2fs)" % (toc - tic))
         with open(hashpath, "w") as f:
             f.write(hash)
         return hash
@@ -1225,13 +1140,13 @@ class ModelManager(object):
                 hash = f.read()
             return hash
 
-        self.logger.debug("Calculating sha256 hash of weights file")
+        print("   | Calculating sha256 hash of weights file")
         tic = time.time()
         sha = hashlib.sha256()
         sha.update(data)
         hash = sha.hexdigest()
         toc = time.time()
-        self.logger.debug(f"sha256 = {hash} "+"(%4.2fs)" % (toc - tic))
+        print(f">> sha256 = {hash}", "(%4.2fs)" % (toc - tic))
 
         with open(hashpath, "w") as f:
             f.write(hash)
@@ -1248,16 +1163,16 @@ class ModelManager(object):
         using_fp16 = self.precision == "float16"
 
         vae_args.update(
-            cache_dir=self.globals.cache_dir,
-            local_files_only=not self.globals.internet_available,
+            cache_dir=global_cache_dir("hub"),
+            local_files_only=not Globals.internet_available,
         )
 
-        self.logger.debug(f"Loading diffusers VAE from {name_or_path}")
+        print(f"   | Loading diffusers VAE from {name_or_path}")
         if using_fp16:
             vae_args.update(torch_dtype=torch.float16)
             fp_args_list = [{"revision": "fp16"}, {}]
         else:
-            self.logger.debug("Using more accurate float32 precision")
+            print("   | Using more accurate float32 precision")
             fp_args_list = [{}]
 
         vae = None
@@ -1281,13 +1196,13 @@ class ModelManager(object):
                 break
 
         if not vae and deferred_error:
-            self.logger.warning(f"Could not load VAE {name_or_path}: {str(deferred_error)}")
+            print(f"** Could not load VAE {name_or_path}: {str(deferred_error)}")
 
         return vae
 
-    @classmethod
-    def _delete_model_from_cache(cls,repo_id):
-        cache_info = scan_cache_dir(get_invokeai_config().cache_dir)
+    @staticmethod
+    def _delete_model_from_cache(repo_id):
+        cache_info = scan_cache_dir(global_cache_dir("hub"))
 
         # I'm sure there is a way to do this with comprehensions
         # but the code quickly became incomprehensible!
@@ -1297,17 +1212,16 @@ class ModelManager(object):
                 for revision in repo.revisions:
                     hashes_to_delete.add(revision.commit_hash)
         strategy = cache_info.delete_revisions(*hashes_to_delete)
-        cls.logger.warning(
-            f"Deletion of this model is expected to free {strategy.expected_freed_size_str}"
+        print(
+            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_dir, path).resolve()
+        return Path(Globals.root, path).resolve()
 
     @staticmethod
     def _is_huggingface_hub_directory_present() -> bool:

invokeai/backend/prompting/conditioning.py

@@ -16,59 +16,66 @@ from compel.prompt_parser import (
     FlattenedPrompt,
     Fragment,
     PromptParser,
-    Conjunction,
 )
 
-import invokeai.backend.util.logging as logger
+from invokeai.backend.globals import Globals
 
-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: InvokeAIDiffuserComponent,
-                        log_tokens=False, skip_normalize_legacy_blend=False):
+
+def get_uc_and_c_and_ec(
+    prompt_string, model, 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
+    )
 
-    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()
+    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
+    )
 
     # 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_conjunction: Conjunction
+    (
+        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_conjunction = legacy_blend
+        positive_prompt = legacy_blend
     else:
-        positive_conjunction = Compel.parse_prompt_string(positive_prompt_string)
-    positive_prompt = positive_conjunction.prompts[0]
+        positive_prompt = Compel.parse_prompt_string(positive_prompt_string)
+    negative_prompt: Union[FlattenedPrompt, Blend] = Compel.parse_prompt_string(
+        negative_prompt_string
+    )
 
-    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)
+    if log_tokens or getattr(Globals, "log_tokenization", False):
+        log_tokenization(positive_prompt, negative_prompt, tokenizer=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])
 
-    ec = InvokeAIDiffuserComponent.ExtraConditioningInfo(tokens_count_including_eos_bos=tokens_count,
-                                                         cross_attention_control_args=options.get(
-                                                             'cross_attention_control', None))
+    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),
+    )
     return uc, c, ec
 
+
 def get_prompt_structure(
     prompt_string, skip_normalize_legacy_blend: bool = False
 ) -> (Union[FlattenedPrompt, Blend], FlattenedPrompt):
@@ -79,17 +86,18 @@ def get_prompt_structure(
     legacy_blend = try_parse_legacy_blend(
         positive_prompt_string, skip_normalize_legacy_blend
     )
-    positive_prompt: Conjunction
+    positive_prompt: Union[FlattenedPrompt, Blend]
     if legacy_blend is not None:
-        positive_conjunction = legacy_blend
+        positive_prompt = 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]
+        positive_prompt = Compel.parse_prompt_string(positive_prompt_string)
+    negative_prompt: Union[FlattenedPrompt, Blend] = Compel.parse_prompt_string(
+        negative_prompt_string
+    )
 
     return positive_prompt, negative_prompt
 
+
 def get_max_token_count(
     tokenizer, prompt: Union[FlattenedPrompt, Blend], truncate_if_too_long=False
 ) -> int:
@@ -154,8 +162,8 @@ def log_tokenization(
     negative_prompt: Union[Blend, FlattenedPrompt],
     tokenizer,
 ):
-    logger.info(f"[TOKENLOG] Parsed Prompt: {positive_prompt}")
-    logger.info(f"[TOKENLOG] Parsed Negative Prompt: {negative_prompt}")
+    print(f"\n>> [TOKENLOG] Parsed Prompt: {positive_prompt}")
+    print(f"\n>> [TOKENLOG] Parsed Negative Prompt: {negative_prompt}")
 
     log_tokenization_for_prompt_object(positive_prompt, tokenizer)
     log_tokenization_for_prompt_object(
@@ -229,28 +237,29 @@ def log_tokenization_for_text(text, tokenizer, display_label=None, truncate_if_t
             usedTokens += 1
 
     if usedTokens > 0:
-        logger.info(f'[TOKENLOG] Tokens {display_label or ""} ({usedTokens}):')
-        logger.debug(f"{tokenized}\x1b[0m")
+        print(f'\n>> [TOKENLOG] Tokens {display_label or ""} ({usedTokens}):')
+        print(f"{tokenized}\x1b[0m")
 
     if discarded != "":
-        logger.info(f"[TOKENLOG] Tokens Discarded ({totalTokens - usedTokens}):")
-        logger.debug(f"{discarded}\x1b[0m")
+        print(f"\n>> [TOKENLOG] Tokens Discarded ({totalTokens - usedTokens}):")
+        print(f"{discarded}\x1b[0m")
 
-def try_parse_legacy_blend(text: str, skip_normalize: bool = False) -> Optional[Conjunction]:
+
+def try_parse_legacy_blend(text: str, skip_normalize: bool = False) -> Optional[Blend]:
     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 = []
-    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)])
+    flattened_prompts = [x.prompts[0] for x in parsed_conjunctions]
+
+    return Blend(
+        prompts=flattened_prompts, weights=weights, normalize_weights=not skip_normalize
+    )
+
 
 def split_weighted_subprompts(text, skip_normalize=False) -> list:
     """
@@ -286,8 +295,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:
-        logger.warning(
-            "Subprompt weights add up to zero. Discarding and using even weights instead."
+        print(
+            "* 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,5 +1,3 @@
-import invokeai.backend.util.logging as logger
-
 class Restoration:
     def __init__(self) -> None:
         pass
@@ -10,17 +8,17 @@ class Restoration:
         # Load GFPGAN
         gfpgan = self.load_gfpgan(gfpgan_model_path)
         if gfpgan.gfpgan_model_exists:
-            logger.info("GFPGAN Initialized")
+            print(">> GFPGAN Initialized")
         else:
-            logger.info("GFPGAN Disabled")
+            print(">> GFPGAN Disabled")
             gfpgan = None
 
         # Load CodeFormer
         codeformer = self.load_codeformer()
         if codeformer.codeformer_model_exists:
-            logger.info("CodeFormer Initialized")
+            print(">> CodeFormer Initialized")
         else:
-            logger.info("CodeFormer Disabled")
+            print(">> CodeFormer Disabled")
             codeformer = None
 
         return gfpgan, codeformer
@@ -41,5 +39,5 @@ class Restoration:
         from .realesrgan import ESRGAN
 
         esrgan = ESRGAN(esrgan_bg_tile)
-        logger.info("ESRGAN Initialized")
+        print(">> ESRGAN Initialized")
         return esrgan

invokeai/backend/restoration/codeformer.py

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

invokeai/backend/restoration/gfpgan.py

@@ -6,19 +6,20 @@ import numpy as np
 import torch
 from PIL import Image
 
-import invokeai.backend.util.logging as logger
-from invokeai.app.services.config import get_invokeai_config
+from invokeai.backend.globals import Globals
+
 
 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 = self.globals.root_dir / gfpgan_model_path
+            gfpgan_model_path = os.path.abspath(
+                os.path.join(Globals.root, 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:
-            logger.error("NOT FOUND: GFPGAN model not found at " + self.model_path)
+            print("## NOT FOUND: GFPGAN model not found at " + self.model_path)
             return None
 
     def model_exists(self):
@@ -26,13 +27,13 @@ class GFPGAN:
 
     def process(self, image, strength: float, seed: str = None):
         if seed is not None:
-            logger.info(f"GFPGAN - Restoring Faces for image seed:{seed}")
+            print(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(self.globals.root_dir / 'models')
+            os.chdir(os.path.join(Globals.root, "models"))
             try:
                 from gfpgan import GFPGANer
 
@@ -46,14 +47,14 @@ class GFPGAN:
             except Exception:
                 import traceback
 
-                logger.error("Error loading GFPGAN:", file=sys.stderr)
+                print(">> Error loading GFPGAN:", file=sys.stderr)
                 print(traceback.format_exc(), file=sys.stderr)
             os.chdir(cwd)
 
         if self.gfpgan is None:
-            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}"
+            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}"
             )
 
         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
-            logger.info(f"extending image {direction}ward by {pixels} pixels")
+            print(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,3 +1,4 @@
+import os
 import warnings
 
 import numpy as np
@@ -5,14 +6,18 @@ import torch
 from PIL import Image
 from PIL.Image import Image as ImageType
 
-import invokeai.backend.util.logging as logger
-from invokeai.app.services.config import get_invokeai_config
-config = get_invokeai_config()
+from invokeai.backend.globals import Globals
+
 
 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
@@ -30,8 +35,12 @@ class ESRGAN:
             upscale=4,
             act_type="prelu",
         )
-        model_path = config.root_dir / "models/realesrgan/realesr-general-x4v3.pth"
-        wdn_model_path = config.root_dir / "models/realesrgan/realesr-general-wdn-x4v3.pth"
+        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"
+        )
         scale = 4
 
         bg_upsampler = RealESRGANer(
@@ -65,16 +74,16 @@ class ESRGAN:
                 import sys
                 import traceback
 
-                logger.error("Error loading Real-ESRGAN:")
+                print(">> Error loading Real-ESRGAN:", file=sys.stderr)
                 print(traceback.format_exc(), file=sys.stderr)
 
         if upsampler_scale == 0:
-            logger.warning("Real-ESRGAN: Invalid scaling option. Image not upscaled.")
+            print(">> Real-ESRGAN: Invalid scaling option. Image not upscaled.")
             return image
 
         if seed is not None:
-            logger.info(
-                f"Real-ESRGAN Upscaling seed:{seed}, scale:{upsampler_scale}x, tile:{self.bg_tile_size}, denoise:{denoise_str}"
+            print(
+                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,8 +14,7 @@ from PIL import Image, ImageFilter
 from transformers import AutoFeatureExtractor
 
 import invokeai.assets.web as web_assets
-import invokeai.backend.util.logging as logger
-from invokeai.app.services.config import get_invokeai_config
+from .globals import global_cache_dir
 from .util import CPU_DEVICE
 
 class SafetyChecker(object):
@@ -26,11 +25,10 @@ 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 = config.cache_dir
+            safety_model_path = global_cache_dir("hub")
             self.safety_checker = StableDiffusionSafetyChecker.from_pretrained(
                 safety_model_id,
                 local_files_only=True,
@@ -42,8 +40,8 @@ class SafetyChecker(object):
                 cache_dir=safety_model_path,
             )
         except Exception:
-            logger.error(
-                "An error was encountered while installing the safety checker:"
+            print(
+                "** An error was encountered while installing the safety checker:"
             )
             print(traceback.format_exc())
 
@@ -67,8 +65,8 @@ class SafetyChecker(object):
         )
         self.safety_checker.to(CPU_DEVICE) # offload
         if has_nsfw_concept[0]:
-            logger.warning(
-                "An image with potential non-safe content has been detected. A blurred image will be returned."
+            print(
+                "** 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,16 +17,15 @@ from huggingface_hub import (
     hf_hub_url,
 )
 
-import invokeai.backend.util.logging as logger
-from invokeai.app.services.config import get_invokeai_config
+from invokeai.backend.globals import Globals
+
 
 class HuggingFaceConceptsLibrary(object):
     def __init__(self, root=None):
         """
         Initialize the Concepts object. May optionally pass a root directory.
         """
-        self.config = get_invokeai_config()
-        self.root = root or self.config.root
+        self.root = root or Globals.root
         self.hf_api = HfApi()
         self.local_concepts = dict()
         self.concept_list = None
@@ -58,7 +57,7 @@ class HuggingFaceConceptsLibrary(object):
                 self.concept_list.extend(list(local_concepts_to_add))
                 return self.concept_list
             return self.concept_list
-        elif self.config.internet_available is True:
+        else:
             try:
                 models = self.hf_api.list_models(
                     filter=ModelFilter(model_name="sd-concepts-library/")
@@ -67,15 +66,13 @@ 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:
-                logger.warning(
-                    f"Hugging Face textual inversion concepts libraries could not be loaded. The error was {str(e)}."
+                print(
+                    f" ** WARNING: Hugging Face textual inversion concepts libraries could not be loaded. The error was {str(e)}."
                 )
-                logger.warning(
-                    "You may load .bin and .pt file(s) manually using the --embedding_directory argument."
+                print(
+                    " ** You may load .bin and .pt file(s) manually using the --embedding_directory argument."
                 )
             return self.concept_list
-        else: 
-            return self.concept_list
 
     def get_concept_model_path(self, concept_name: str) -> str:
         """
@@ -84,7 +81,7 @@ class HuggingFaceConceptsLibrary(object):
         be downloaded.
         """
         if not concept_name in self.list_concepts():
-            logger.warning(
+            print(
                 f"{concept_name} is not a local embedding trigger, nor is it a HuggingFace concept. Generation will continue without the concept."
             )
             return None
@@ -222,7 +219,7 @@ class HuggingFaceConceptsLibrary(object):
             if chunk == 0:
                 bytes += total
 
-        logger.info(f"Downloading {repo_id}...", end="")
+        print(f">> Downloading {repo_id}...", end="")
         try:
             for file in (
                 "README.md",
@@ -236,22 +233,22 @@ class HuggingFaceConceptsLibrary(object):
                 )
         except ul_error.HTTPError as e:
             if e.code == 404:
-                logger.warning(
+                print(
                     f"Concept {concept_name} is not known to the Hugging Face library. Generation will continue without the concept."
                 )
             else:
-                logger.warning(
+                print(
                     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:
-            logger.error(
-                f"an error occurred while downloading {concept_name}: {str(e)}. This may reflect a network issue. Generation will continue without the concept."
+            print(
+                f"ERROR while downloading {concept_name}: {str(e)}. This may reflect a network issue. Generation will continue without the concept."
             )
             os.rmdir(dest)
             return False
-        logger.info("...{:.2f}Kb".format(bytes / 1024))
+        print("...{:.2f}Kb".format(bytes / 1024))
         return succeeded
 
     def _concept_id(self, concept_name: str) -> str:

invokeai/backend/stable_diffusion/diffusers_pipeline.py

@@ -2,29 +2,23 @@ from __future__ import annotations
 
 import dataclasses
 import inspect
-import math
 import secrets
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import Any, Callable, Generic, List, Optional, Type, TypeVar, Union
-from pydantic import BaseModel, Field
 
 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,
 )
@@ -33,14 +27,14 @@ 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.app.services.config import get_invokeai_config
+from invokeai.backend.globals import Globals
+
 from ..util import CPU_DEVICE, normalize_device
 from .diffusion import (
     AttentionMapSaver,
@@ -50,6 +44,7 @@ from .diffusion import (
 from .offloading import FullyLoadedModelGroup, LazilyLoadedModelGroup, ModelGroup
 from .textual_inversion_manager import TextualInversionManager
 
+
 @dataclass
 class PipelineIntermediateState:
     run_id: str
@@ -75,10 +70,10 @@ class AddsMaskLatents:
     initial_image_latents: torch.Tensor
 
     def __call__(
-        self, latents: torch.Tensor, t: torch.Tensor, text_embeddings: torch.Tensor, **kwargs,
+        self, latents: torch.Tensor, t: torch.Tensor, text_embeddings: torch.Tensor
     ) -> torch.Tensor:
         model_input = self.add_mask_channels(latents)
-        return self.forward(model_input, t, text_embeddings, **kwargs)
+        return self.forward(model_input, t, text_embeddings)
 
     def add_mask_channels(self, latents):
         batch_size = latents.size(0)
@@ -214,13 +209,6 @@ class GeneratorToCallbackinator(Generic[ParamType, ReturnType, CallbackType]):
             raise AssertionError("why was that an empty generator?")
         return result
 
-@dataclass
-class ControlNetData:
-    model: ControlNetModel = Field(default=None)
-    image_tensor: torch.Tensor= Field(default=None)
-    weight: float = Field(default=1.0)
-    begin_step_percent: float = Field(default=0.0)
-    end_step_percent: float = Field(default=1.0)
 
 @dataclass(frozen=True)
 class ConditioningData:
@@ -316,7 +304,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         feature_extractor: Optional[CLIPFeatureExtractor],
         requires_safety_checker: bool = False,
         precision: str = "float32",
-        control_model: ControlNetModel = None,
     ):
         super().__init__(
             vae,
@@ -337,8 +324,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
@@ -358,17 +343,15 @@ 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 config.disable_xformers
+            and not Globals.disable_xformers
         ):
             self.enable_xformers_memory_efficient_attention()
         else:
@@ -462,15 +445,8 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
     @property
     def _submodels(self) -> Sequence[torch.nn.Module]:
         module_names, _, _ = self.extract_init_dict(dict(self.config))
-        submodels = []
-        for name in module_names.keys():
-            if hasattr(self, name):
-                value = getattr(self, name)
-            else:
-                value = getattr(self.config, name)
-            if isinstance(value, torch.nn.Module):
-                submodels.append(value)
-        return submodels
+        values = [getattr(self, name) for name in module_names.keys()]
+        return [m for m in values if isinstance(m, torch.nn.Module)]
 
     def image_from_embeddings(
         self,
@@ -481,7 +457,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.
@@ -502,7 +477,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()
@@ -527,16 +501,11 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         additional_guidance: List[Callable] = None,
         run_id=None,
         callback: Callable[[PipelineIntermediateState], None] = None,
-        control_data: List[ControlNetData] = 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=scheduler_device)
+            self.scheduler.set_timesteps(
+                num_inference_steps, device=self._model_group.device_for(self.unet)
+            )
             timesteps = self.scheduler.timesteps
         infer_latents_from_embeddings = GeneratorToCallbackinator(
             self.generate_latents_from_embeddings, PipelineIntermediateState
@@ -549,8 +518,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             additional_guidance=additional_guidance,
             run_id=run_id,
             callback=callback,
-            control_data=control_data,
-            **kwargs,
         )
         return result.latents, result.attention_map_saver
 
@@ -563,24 +530,22 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         noise: torch.Tensor,
         run_id: str = None,
         additional_guidance: List[Callable] = None,
-        control_data: List[ControlNetData] = None,
-        **kwargs,
     ):
-        self._adjust_memory_efficient_attention(latents)
+        # FIXME: do we still use any slicing now that PyTorch 2.0 has scaled dot-product attention on all platforms?
+        #   self._adjust_memory_efficient_attention(latents)
         if run_id is None:
             run_id = secrets.token_urlsafe(self.ID_LENGTH)
         if additional_guidance is None:
             additional_guidance = []
         extra_conditioning_info = conditioning_data.extra
         with self.invokeai_diffuser.custom_attention_context(
-                self.invokeai_diffuser.model,
-                extra_conditioning_info=extra_conditioning_info,
-                step_count=len(self.scheduler.timesteps),
+            extra_conditioning_info=extra_conditioning_info,
+            step_count=len(self.scheduler.timesteps),
         ):
             yield PipelineIntermediateState(
                 run_id=run_id,
                 step=-1,
-                timestep=self.scheduler.config.num_train_timesteps,
+                timestep=self.scheduler.num_train_timesteps,
                 latents=latents,
             )
 
@@ -594,7 +559,7 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             latents = self.scheduler.add_noise(latents, noise, batched_t)
 
             attention_map_saver: Optional[AttentionMapSaver] = None
-            # print("timesteps:", timesteps)
+
             for i, t in enumerate(self.progress_bar(timesteps)):
                 batched_t.fill_(t)
                 step_output = self.step(
@@ -604,8 +569,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
                     step_index=i,
                     total_step_count=len(timesteps),
                     additional_guidance=additional_guidance,
-                    control_data=control_data,
-                    **kwargs,
                 )
                 latents = step_output.prev_sample
 
@@ -646,11 +609,10 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         step_index: int,
         total_step_count: int,
         additional_guidance: List[Callable] = None,
-        control_data: List[ControlNetData] = None,
-        **kwargs,
     ):
         # invokeai_diffuser has batched timesteps, but diffusers schedulers expect a single value
         timestep = t[0]
+
         if additional_guidance is None:
             additional_guidance = []
 
@@ -658,48 +620,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         #     i.e. before or after passing it to InvokeAIDiffuserComponent
         latent_model_input = self.scheduler.scale_model_input(latents, timestep)
 
-        # default is no controlnet, so set controlnet processing output to None
-        down_block_res_samples, mid_block_res_sample = None, None
-
-        if control_data is not None:
-            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
-            # control_data should be type List[ControlNetData]
-            # this loop covers both ControlNet (one ControlNetData in list)
-            #      and MultiControlNet (multiple ControlNetData in list)
-            for i, control_datum in enumerate(control_data):
-                # print("controlnet", i, "==>", type(control_datum))
-                first_control_step = math.floor(control_datum.begin_step_percent * total_step_count)
-                last_control_step = math.ceil(control_datum.end_step_percent * total_step_count)
-                # only apply controlnet if current step is within the controlnet's begin/end step range
-                if step_index >= first_control_step and step_index <= last_control_step:
-                    # print("running controlnet", i, "for step", step_index)
-                    down_samples, mid_sample = control_datum.model(
-                        sample=latent_control_input,
-                        timestep=timestep,
-                        encoder_hidden_states=torch.cat([conditioning_data.unconditioned_embeddings,
-                                                         conditioning_data.text_embeddings]),
-                        controlnet_cond=control_datum.image_tensor,
-                        conditioning_scale=control_datum.weight,
-                        # cross_attention_kwargs,
-                        guess_mode=False,
-                        return_dict=False,
-                    )
-                    if down_block_res_samples is None and mid_block_res_sample is None:
-                        down_block_res_samples, mid_block_res_sample = down_samples, mid_sample
-                    else:
-                        # add controlnet outputs together if have multiple controlnets
-                        down_block_res_samples = [
-                            samples_prev + samples_curr
-                            for samples_prev, samples_curr in zip(down_block_res_samples, down_samples)
-                        ]
-                        mid_block_res_sample += mid_sample
-
         # predict the noise residual
         noise_pred = self.invokeai_diffuser.do_diffusion_step(
             latent_model_input,
@@ -709,8 +629,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,  # from controlnet(s)
-            mid_block_additional_residual=mid_block_res_sample,      # from controlnet(s)
         )
 
         # compute the previous noisy sample x_t -> x_t-1
@@ -732,7 +650,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:
@@ -752,8 +669,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(
@@ -804,7 +720,11 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         run_id=None,
         callback=None,
     ) -> InvokeAIStableDiffusionPipelineOutput:
-        timesteps, _ = self.get_img2img_timesteps(num_inference_steps, strength)
+        timesteps, _ = self.get_img2img_timesteps(
+            num_inference_steps,
+            strength,
+            device=self._model_group.device_for(self.unet),
+        )
         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
@@ -830,19 +750,13 @@ 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=None
+        self, num_inference_steps: int, strength: float, device
     ) -> (torch.Tensor, int):
         img2img_pipeline = StableDiffusionImg2ImgPipeline(**self.components)
         assert img2img_pipeline.scheduler is self.scheduler
-
-        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)
+        img2img_pipeline.scheduler.set_timesteps(num_inference_steps, device=device)
         timesteps, adjusted_steps = img2img_pipeline.get_timesteps(
-            num_inference_steps, strength, device=scheduler_device
+            num_inference_steps, strength, device=device
         )
         # Workaround for low strength resulting in zero timesteps.
         # TODO: submit upstream fix for zero-step img2img
@@ -876,7 +790,9 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         if init_image.dim() == 3:
             init_image = init_image.unsqueeze(0)
 
-        timesteps, _ = self.get_img2img_timesteps(num_inference_steps, strength)
+        timesteps, _ = self.get_img2img_timesteps(
+            num_inference_steps, strength, device=device
+        )
 
         # 6. Prepare latent variables
         # can't quite use upstream StableDiffusionImg2ImgPipeline.prepare_latents
@@ -1000,7 +916,7 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
     @property
     def channels(self) -> int:
         """Compatible with DiffusionWrapper"""
-        return self.unet.config.in_channels
+        return self.unet.in_channels
 
     def decode_latents(self, latents):
         # Explicit call to get the vae loaded, since `decode` isn't the forward method.
@@ -1015,51 +931,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,
-        # FIXME: need to fix hardwiring of width and height, change to basing on latents dimensions?
-        # latents,
-        width=512,  # should be 8 * latent.shape[3]
-        height=512, # should be 8 * latent height[2]
-        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

@@ -10,13 +10,13 @@ import diffusers
 import psutil
 import torch
 from compel.cross_attention_control import Arguments
+from diffusers.models.cross_attention import AttnProcessor
 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
@@ -188,7 +188,7 @@ class Context:
 
 class InvokeAICrossAttentionMixin:
     """
-    Enable InvokeAI-flavoured Attention calculation, which does aggressive low-memory slicing and calls
+    Enable InvokeAI-flavoured CrossAttention calculation, which does aggressive low-memory slicing and calls
     through both to an attention_slice_wrangler and a slicing_strategy_getter for custom attention map wrangling
     and dymamic slicing strategy selection.
     """
@@ -209,7 +209,7 @@ class InvokeAICrossAttentionMixin:
         Set custom attention calculator to be called when attention is calculated
         :param wrangler: Callback, with args (module, suggested_attention_slice, dim, offset, slice_size),
         which returns either the suggested_attention_slice or an adjusted equivalent.
-            `module` is the current Attention module for which the callback is being invoked.
+            `module` is the current CrossAttention module for which the callback is being invoked.
             `suggested_attention_slice` is the default-calculated attention slice
             `dim` is -1 if the attenion map has not been sliced, or 0 or 1 for dimension-0 or dimension-1 slicing.
                 If `dim` is >= 0, `offset` and `slice_size` specify the slice start and length.
@@ -345,15 +345,16 @@ class InvokeAICrossAttentionMixin:
 def restore_default_cross_attention(
     model,
     is_running_diffusers: bool,
-    restore_attention_processor: Optional[AttentionProcessor] = None,
+    restore_attention_processor: Optional[AttnProcessor] = None,
 ):
     if is_running_diffusers:
         unet = model
-        unet.set_attn_processor(restore_attention_processor or AttnProcessor())
+        unet.set_attn_processor(restore_attention_processor or CrossAttnProcessor())
     else:
         remove_attention_function(model)
 
-def setup_cross_attention_control_attention_processors(unet: UNet2DConditionModel, context: Context):
+
+def override_cross_attention(model, context: Context, is_running_diffusers=False):
     """
     Inject attention parameters and functions into the passed in model to enable cross attention editing.
 
@@ -372,29 +373,47 @@ def setup_cross_attention_control_attention_processors(unet: UNet2DConditionMode
     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)
-    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())
+    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
     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))
+        context.register_cross_attention_modules(model)
+        inject_attention_function(model, context)
+        return None
+
 
 def get_cross_attention_modules(
     model, which: CrossAttentionType
 ) -> list[tuple[str, InvokeAICrossAttentionMixin]]:
+    from ldm.modules.attention import CrossAttention  # avoid circular import
 
     cross_attention_class: type = (
         InvokeAIDiffusersCrossAttention
+        if isinstance(model, UNet2DConditionModel)
+        else CrossAttention
     )
     which_attn = "attn1" if which is CrossAttentionType.SELF else "attn2"
     attention_module_tuples = [
@@ -406,13 +425,13 @@ 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.
-        logger.error(
+        print(
             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, "
+            + f"or some assumption has changed about the structure of the model itself. Please fix the monkey-patching, "
             + f"and/or update the {expected_count} above to an appropriate number, and/or find and inform someone who knows "
-            + "what it means. This error is non-fatal, but it is likely that .swap() and attention map display will not "
-            + "work properly until it is fixed."
+            + f"what it means. This error is non-fatal, but it is likely that .swap() and attention map display will not "
+            + f"work properly until it is fixed."
         )
     return attention_module_tuples
 
@@ -531,7 +550,7 @@ def get_mem_free_total(device):
 
 
 class InvokeAIDiffusersCrossAttention(
-    diffusers.models.attention.Attention, InvokeAICrossAttentionMixin
+    diffusers.models.attention.CrossAttention, InvokeAICrossAttentionMixin
 ):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -553,8 +572,8 @@ class InvokeAIDiffusersCrossAttention(
 """
 # base implementation
 
-class AttnProcessor:
-    def __call__(self, attn: Attention, hidden_states, encoder_hidden_states=None, attention_mask=None):
+class CrossAttnProcessor:
+    def __call__(self, attn: CrossAttention, hidden_states, encoder_hidden_states=None, attention_mask=None):
         batch_size, sequence_length, _ = hidden_states.shape
         attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length)
 
@@ -582,9 +601,9 @@ class AttnProcessor:
 from dataclasses import dataclass, field
 
 import torch
-from diffusers.models.attention_processor import (
-    Attention,
-    AttnProcessor,
+from diffusers.models.cross_attention import (
+    CrossAttention,
+    CrossAttnProcessor,
     SlicedAttnProcessor,
 )
 
@@ -634,7 +653,7 @@ class SlicedSwapCrossAttnProcesser(SlicedAttnProcessor):
 
     def __call__(
         self,
-        attn: Attention,
+        attn: CrossAttention,
         hidden_states,
         encoder_hidden_states=None,
         attention_mask=None,

invokeai/backend/stable_diffusion/diffusion/shared_invokeai_diffusion.py

@@ -5,12 +5,10 @@ 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 diffusers.models.cross_attention import AttnProcessor
 from typing_extensions import TypeAlias
 
-import invokeai.backend.util.logging as logger
-from invokeai.app.services.config import get_invokeai_config
+from invokeai.backend.globals import Globals
 
 from .cross_attention_control import (
     Arguments,
@@ -18,8 +16,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
 
@@ -32,6 +30,7 @@ ModelForwardCallback: TypeAlias = Union[
     Callable[[torch.Tensor, torch.Tensor, torch.Tensor], torch.Tensor],
 ]
 
+
 @dataclass(frozen=True)
 class PostprocessingSettings:
     threshold: float
@@ -72,49 +71,37 @@ 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 = config.sequential_guidance
+        self.sequential_guidance = Globals.sequential_guidance
 
-    @classmethod
     @contextmanager
     def custom_attention_context(
-        cls,
-        unet: UNet2DConditionModel, # note: also may futz with the text encoder depending on requested LoRAs
-        extra_conditioning_info: Optional[ExtraConditioningInfo],
-        step_count: int
+        self, extra_conditioning_info: Optional[ExtraConditioningInfo], step_count: int
     ):
-        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,
-                )
-
+        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
+            )
         try:
             yield None
         finally:
-            if old_attn_processors is not None:
-                unet.set_attn_processor(old_attn_processors)
+            if old_attn_processor is not None:
+                self.restore_default_cross_attention(old_attn_processor)
             # TODO resuscitate attention map saving
             # self.remove_attention_map_saving()
 
     def override_cross_attention(
         self, conditioning: ExtraConditioningInfo, step_count: int
-    ) -> Dict[str, AttentionProcessor]:
+    ) -> Dict[str, AttnProcessor]:
         """
         setup cross attention .swap control. for diffusers this replaces the attention processor, so
         the previous attention processor is returned so that the caller can restore it later.
@@ -131,7 +118,7 @@ class InvokeAIDiffuserComponent:
         )
 
     def restore_default_cross_attention(
-        self, restore_attention_processor: Optional["AttentionProcessor"] = None
+        self, restore_attention_processor: Optional["AttnProcessor"] = None
     ):
         self.conditioning = None
         self.cross_attention_control_context = None
@@ -181,7 +168,6 @@ class InvokeAIDiffuserComponent:
         unconditional_guidance_scale: float,
         step_index: Optional[int] = None,
         total_step_count: Optional[int] = None,
-        **kwargs,
     ):
         """
         :param x: current latents
@@ -210,7 +196,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:
             (
@@ -222,14 +208,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:
@@ -237,7 +222,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(
@@ -277,20 +262,20 @@ class InvokeAIDiffuserComponent:
             # TODO remove when compvis codepath support is dropped
             if step_index is None and sigma is None:
                 raise ValueError(
-                    "Either step_index or sigma is required when doing cross attention control, but both are None."
+                    f"Either step_index or sigma is required when doing cross attention control, but both are None."
                 )
             percent_through = self.estimate_percent_through(step_index, sigma)
         return percent_through
 
     # 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":
@@ -304,17 +289,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)
@@ -329,7 +313,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
 
@@ -340,7 +324,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(
@@ -349,7 +332,6 @@ class InvokeAIDiffuserComponent:
                 unconditioning,
                 conditioning,
                 cross_attention_control_types_to_do,
-                **kwargs,
             )
         else:
             return self._apply_cross_attention_controlled_conditioning__compvis(
@@ -358,7 +340,6 @@ class InvokeAIDiffuserComponent:
                 unconditioning,
                 conditioning,
                 cross_attention_control_types_to_do,
-                **kwargs,
             )
 
     def _apply_cross_attention_controlled_conditioning__diffusers(
@@ -368,7 +349,6 @@ class InvokeAIDiffuserComponent:
         unconditioning,
         conditioning,
         cross_attention_control_types_to_do,
-        **kwargs,
     ):
         context: Context = self.cross_attention_control_context
 
@@ -384,7 +364,6 @@ class InvokeAIDiffuserComponent:
             sigma,
             unconditioning,
             {"swap_cross_attn_context": cross_attn_processor_context},
-            **kwargs,
         )
 
         # do requested cross attention types for conditioning (positive prompt)
@@ -396,7 +375,6 @@ class InvokeAIDiffuserComponent:
             sigma,
             conditioning,
             {"swap_cross_attn_context": cross_attn_processor_context},
-            **kwargs,
         )
         return unconditioned_next_x, conditioned_next_x
 
@@ -407,7 +385,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)
@@ -421,13 +398,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
@@ -438,7 +415,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)
 
@@ -489,14 +466,10 @@ class InvokeAIDiffuserComponent:
             outside = torch.count_nonzero(
                 (latents < -current_threshold) | (latents > current_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"
+            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"
             )
 
         if maxval < current_threshold and minval > -current_threshold:
@@ -523,11 +496,9 @@ class InvokeAIDiffuserComponent:
             )
 
         if self.debug_thresholding:
-            logger.debug(
-                f"min,     , max = {minval:.3f},        , {maxval:.3f}\t(scaled by {scale})"
-            )
-            logger.debug(
-                f"{num_altered / latents.numel() * 100:.2f}% values altered"
+            print(
+                f"  | min,     , max = {minval:.3f},        , {maxval:.3f}\t(scaled by {scale})\n"
+                f"  | {num_altered / latents.numel() * 100:.2f}% values altered"
             )
 
         return latents
@@ -628,6 +599,7 @@ class InvokeAIDiffuserComponent:
         )
 
         # below is fugly omg
+        num_actual_conditionings = len(c_or_weighted_c_list)
         conditionings = [uc] + [c for c, weight in weighted_cond_list]
         weights = [1] + [weight for c, weight in weighted_cond_list]
         chunk_count = ceil(len(conditionings) / 2)

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()
-        logger.error("Path already exists. Rename it to [{:s}]".format(new_name))
+        print("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

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

invokeai/backend/stable_diffusion/schedulers/schedulers.py

@@ -1,23 +0,0 @@
-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,7 +10,6 @@ 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
@@ -60,12 +59,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
-                logger.info(f"Loaded local embedding for trigger {concept_name}")
+                print(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
-            logger.info(f"Loaded remote embedding for trigger {concept_name}")
+            print(f">> Loaded remote embedding for trigger {concept_name}")
             self.load_textual_inversion(bin_file)
             self.hf_concepts_library.concepts_loaded[concept_name] = True
 
@@ -86,8 +85,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):
-                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}."
+                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}."
                 )
                 continue
 
@@ -106,8 +105,8 @@ class TextualInversionManager(BaseTextualInversionManager):
                     if ckpt_path.name == "learned_embeds.bin"
                     else f"<{ckpt_path.stem}>"
                 )
-                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}"
+                print(
+                    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
 
@@ -121,8 +120,8 @@ class TextualInversionManager(BaseTextualInversionManager):
                 self.trigger_to_sourcefile[trigger_str] = sourcefile
 
             except ValueError as e:
-                logger.debug(f'Ignoring incompatible embedding {embedding_info["name"]}')
-                logger.debug(f"The error was {str(e)}")
+                print(f'   | Ignoring incompatible embedding {embedding_info["name"]}')
+                print(f"   | The error was {str(e)}")
 
     def _add_textual_inversion(
         self, trigger_str, embedding, defer_injecting_tokens=False
@@ -134,8 +133,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]:
-            logger.warning(
-                f"TextualInversionManager refusing to overwrite already-loaded token '{trigger_str}'"
+            print(
+                f"** TextualInversionManager refusing to overwrite already-loaded token '{trigger_str}'"
             )
             return
         if not self.full_precision:
@@ -156,11 +155,11 @@ class TextualInversionManager(BaseTextualInversionManager):
 
         except ValueError as e:
             if str(e).startswith("Warning"):
-                logger.warning(f"{str(e)}")
+                print(f">> {str(e)}")
             else:
                 traceback.print_exc()
-                logger.error(
-                    f"TextualInversionManager was unable to add a textual inversion with trigger string {trigger_str}."
+                print(
+                    f"** TextualInversionManager was unable to add a textual inversion with trigger string {trigger_str}."
                 )
                 raise
 
@@ -220,16 +219,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:
-                    logger.info(
-                        f"Preparing tokens for textual inversion {ti.trigger_string}..."
+                    print(
+                        f">> Preparing tokens for textual inversion {ti.trigger_string}..."
                     )
                 try:
                     self._inject_tokens_and_assign_embeddings(ti)
                 except ValueError as e:
-                    logger.debug(
-                        f"Ignoring incompatible embedding trigger {ti.trigger_string}"
+                    print(
+                        f"   | Ignoring incompatible embedding trigger {ti.trigger_string}"
                     )
-                    logger.debug(f"The error was {str(e)}")
+                    print(f"   | The error was {str(e)}")
                     continue
                 injected_token_ids.append(ti.trigger_token_id)
                 injected_token_ids.extend(ti.pad_token_ids)
@@ -307,16 +306,16 @@ class TextualInversionManager(BaseTextualInversionManager):
             if suffix in [".pt",".ckpt",".bin"]:
                 scan_result = scan_file_path(embedding_file)
                 if scan_result.infected_files > 0:
-                    logger.critical(
-                        f"Security Issues Found in Model: {scan_result.issues_count}"
+                    print(
+                        f"   ** Security Issues Found in Model: {scan_result.issues_count}"
                     )
-                    logger.critical("For your safety, InvokeAI will not load this embed.")
+                    print("   ** 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:
-            logger.warning(f"Notice: unrecognized embedding file format: {embedding_file}: {e}")
+            print(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
@@ -335,7 +334,7 @@ class TextualInversionManager(BaseTextualInversionManager):
 
     def _parse_embedding_v1(self, embedding_ckpt: dict, file_path: str)->List[EmbeddingInfo]:
         basename = Path(file_path).stem
-        logger.debug(f'Loading v1 embedding file: {basename}')
+        print(f'   | Loading v1 embedding file: {basename}')
 
         embeddings = list()
         token_counter = -1
@@ -343,7 +342,7 @@ class TextualInversionManager(BaseTextualInversionManager):
             if token_counter < 0:
                 trigger = embedding_ckpt["name"]
             elif token_counter == 0:
-                trigger = '<basename>'
+                trigger = f'<basename>'
             else:
                 trigger = f'<{basename}-{int(token_counter:=token_counter)}>'
             token_counter += 1
@@ -366,7 +365,7 @@ class TextualInversionManager(BaseTextualInversionManager):
         This handles embedding .pt file variant #2.
         """
         basename = Path(file_path).stem
-        logger.debug(f'Loading v2 embedding file: {basename}')
+        print(f'   | Loading v2 embedding file: {basename}')
         embeddings = list()
         
         if isinstance(
@@ -385,7 +384,7 @@ class TextualInversionManager(BaseTextualInversionManager):
                 )
                 embeddings.append(embedding_info)
         else:
-            logger.warning(f"{basename}: Unrecognized embedding format")
+            print(f"   ** {basename}: Unrecognized embedding format")
 
         return embeddings
 
@@ -394,7 +393,7 @@ class TextualInversionManager(BaseTextualInversionManager):
         Parse 'version 3' of the .pt textual inversion embedding files.
         """
         basename = Path(file_path).stem
-        logger.debug(f'Loading v3 embedding file: {basename}')
+        print(f'   | Loading v3 embedding file: {basename}')
         embedding = embedding_ckpt['emb_params']
         embedding_info = EmbeddingInfo(
             name = f'<{basename}>',
@@ -412,11 +411,11 @@ class TextualInversionManager(BaseTextualInversionManager):
         basename = Path(filepath).stem
         short_path = Path(filepath).parents[0].name+'/'+Path(filepath).name
         
-        logger.debug(f'Loading v4 embedding file: {short_path}')
+        print(f'   | Loading v4 embedding file: {short_path}')
         
         embeddings = list()
         if list(embedding_ckpt.keys()) == 0:
-            logger.warning(f"Invalid embeddings file: {short_path}")
+            print(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,6 +7,7 @@
 This is the backend to "textual_inversion.py"
 """
 
+import argparse
 import logging
 import math
 import os
@@ -46,7 +47,8 @@ from tqdm.auto import tqdm
 from transformers import CLIPTextModel, CLIPTokenizer
 
 # invokeai stuff
-from invokeai.app.services.config import InvokeAIAppConfig,PagingArgumentParser
+from ..args import ArgFormatter, PagingArgumentParser
+from ..globals import Globals, global_cache_dir
 
 if version.parse(version.parse(PIL.__version__).base_version) >= version.parse("9.1.0"):
     PIL_INTERPOLATION = {
@@ -88,9 +90,8 @@ def save_progress(
 
 
 def parse_args():
-    config = InvokeAIAppConfig(argv=[])
     parser = PagingArgumentParser(
-        description="Textual inversion training"
+        description="Textual inversion training", formatter_class=ArgFormatter
     )
     general_group = parser.add_argument_group("General")
     model_group = parser.add_argument_group("Models and Paths")
@@ -111,7 +112,7 @@ def parse_args():
         "--root_dir",
         "--root",
         type=Path,
-        default=config.root,
+        default=Globals.root,
         help="Path to the invokeai runtime directory",
     )
     general_group.add_argument(
@@ -126,7 +127,7 @@ def parse_args():
     general_group.add_argument(
         "--output_dir",
         type=Path,
-        default=f"{config.root}/text-inversion-model",
+        default=f"{Globals.root}/text-inversion-model",
         help="The output directory where the model predictions and checkpoints will be written.",
     )
     model_group.add_argument(
@@ -527,7 +528,6 @@ 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(config.root, output_dir)
+        output_dir = os.path.join(Globals.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(config.model_conf_path)
+    models_conf = OmegaConf.load(os.path.join(Globals.root, "configs/models.yaml"))
     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=config.cache_dir)
+    pipeline_args = dict(cache_dir=global_cache_dir("hub"))
 
     # Load tokenizer
     if tokenizer_name:

invokeai/backend/util/devices.py

@@ -4,16 +4,17 @@ from contextlib import nullcontext
 
 import torch
 from torch import autocast
-from invokeai.app.services.config import get_invokeai_config
+
+from invokeai.backend.globals import Globals
 
 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"""
-    config = get_invokeai_config()    
-    if config.always_use_cpu:
+    if Globals.always_use_cpu:
         return CPU_DEVICE
     if torch.cuda.is_available():
         return torch.device("cuda")
@@ -32,8 +33,7 @@ def choose_precision(device: torch.device) -> str:
 
 
 def torch_dtype(device: torch.device) -> torch.dtype:
-    config = get_invokeai_config()
-    if config.full_precision:
+    if Globals.full_precision:
         return torch.float32
     if choose_precision(device) == "float16":
         return torch.float16

invokeai/backend/util/logging.py

@@ -1,110 +0,0 @@
-# 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
-    log_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 + log_format + reset,
-        logging.INFO: grey + log_format + reset,
-        logging.WARNING: yellow + log_format + reset,
-        logging.ERROR: red + log_format + reset,
-        logging.CRITICAL: bold_red + log_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(cls, name: str = 'InvokeAI') -> logging.Logger:
-        if name not in cls.loggers:
-            logger = logging.getLogger(name)
-            logger.setLevel(logging.DEBUG)
-            ch = logging.StreamHandler()
-            fmt = InvokeAILogFormatter()
-            ch.setFormatter(fmt)
-            logger.addHandler(ch)
-            cls.loggers[name] = logger
-        return cls.loggers[name]