final tidying before marking PR as ready for review

- Replace AnyModelLoader with ModelLoaderRegistry
- Fix type check errors in multiple files
- Remove apparently unneeded `get_model_config_enum()` method from model manager
- Remove last vestiges of old model manager
- Updated tests and documentation

resolve conflict with seamless.py

docker/Dockerfile

@@ -18,8 +18,8 @@ ENV INVOKEAI_SRC=/opt/invokeai
 ENV VIRTUAL_ENV=/opt/venv/invokeai
 
 ENV PATH="$VIRTUAL_ENV/bin:$PATH"
-ARG TORCH_VERSION=2.1.2
-ARG TORCHVISION_VERSION=0.16.2
+ARG TORCH_VERSION=2.1.0
+ARG TORCHVISION_VERSION=0.16
 ARG GPU_DRIVER=cuda
 ARG TARGETPLATFORM="linux/amd64"
 # unused but available
@@ -35,7 +35,7 @@ RUN --mount=type=cache,target=/root/.cache/pip \
     if [ "$TARGETPLATFORM" = "linux/arm64" ] || [ "$GPU_DRIVER" = "cpu" ]; then \
         extra_index_url_arg="--extra-index-url https://download.pytorch.org/whl/cpu"; \
     elif [ "$GPU_DRIVER" = "rocm" ]; then \
-        extra_index_url_arg="--extra-index-url https://download.pytorch.org/whl/rocm5.6"; \
+        extra_index_url_arg="--index-url https://download.pytorch.org/whl/rocm5.6"; \
     else \
         extra_index_url_arg="--extra-index-url https://download.pytorch.org/whl/cu121"; \
     fi &&\
@@ -54,7 +54,7 @@ RUN --mount=type=cache,target=/root/.cache/pip \
     if [ "$GPU_DRIVER" = "cuda" ] && [ "$TARGETPLATFORM" = "linux/amd64" ]; then \
         pip install -e ".[xformers]"; \
     else \
-        pip install $extra_index_url_arg -e "."; \
+        pip install -e "."; \
     fi
 
 # #### Build the Web UI ------------------------------------

docker/README.md

@@ -28,7 +28,7 @@ This is done via Docker Desktop preferences
 
 ### Configure Invoke environment
 
-1. Make a copy of `.env.sample` and name it `.env` (`cp .env.sample .env` (Mac/Linux) or `copy example.env .env` (Windows)). Make changes as necessary. Set `INVOKEAI_ROOT` to an absolute path to:
+1. Make a copy of `env.sample` and name it `.env` (`cp env.sample .env` (Mac/Linux) or `copy example.env .env` (Windows)). Make changes as necessary. Set `INVOKEAI_ROOT` to an absolute path to:
     a. the desired location of the InvokeAI runtime directory, or
     b. an existing, v3.0.0 compatible runtime directory.
 1. Execute `run.sh`

docker/run.sh

@@ -21,7 +21,7 @@ run() {
     printf "%s\n" "$build_args"
   fi
 
-  docker compose build $build_args $service_name
+  docker compose build $build_args
   unset build_args
 
   printf "%s\n" "starting service $service_name"

docs/contributing/INVOCATIONS.md

@@ -9,15 +9,11 @@ complex functionality.
 
 ## Invocations Directory
 
-InvokeAI Nodes can be found in the `invokeai/app/invocations` directory. These
-can be used as examples to create your own nodes.
+InvokeAI Nodes can be found in the `invokeai/app/invocations` directory. These can be used as examples to create your own nodes.
 
-New nodes should be added to a subfolder in `nodes` direction found at the root
-level of the InvokeAI installation location. Nodes added to this folder will be
-able to be used upon application startup.
-
-Example `nodes` subfolder structure:
+New nodes should be added to a subfolder in `nodes` direction found at the root level of the InvokeAI installation location. Nodes added to this folder will be able to be used upon application startup. 
 
+Example `nodes`  subfolder structure:
 ```py
 ├── __init__.py # Invoke-managed custom node loader
 │
@@ -34,14 +30,14 @@ Example `nodes` subfolder structure:
         └── fancy_node.py
 ```
 
-Each node folder must have an `__init__.py` file that imports its nodes. Only
-nodes imported in the `__init__.py` file are loaded. See the README in the nodes
-folder for more examples:
+Each node folder must have an `__init__.py` file that imports its nodes. Only nodes imported in the `__init__.py` file are loaded.
+ See the README in the nodes folder for more examples: 
 
 ```py
 from .cool_node import CoolInvocation
 ```
 
+
 ## Creating A New Invocation
 
 In order to understand the process of creating a new Invocation, let us actually
@@ -135,6 +131,7 @@ from invokeai.app.invocations.primitives import ImageField
 class ResizeInvocation(BaseInvocation):
     '''Resizes an image'''
 
+    # Inputs
     image: ImageField = InputField(description="The input image")
     width: int = InputField(default=512, ge=64, le=2048, description="Width of the new image")
     height: int = InputField(default=512, ge=64, le=2048, description="Height of the new image")
@@ -170,6 +167,7 @@ from invokeai.app.invocations.primitives import ImageField
 class ResizeInvocation(BaseInvocation):
     '''Resizes an image'''
 
+    # Inputs
     image: ImageField = InputField(description="The input image")
     width: int = InputField(default=512, ge=64, le=2048, description="Width of the new image")
     height: int = InputField(default=512, ge=64, le=2048, description="Height of the new image")
@@ -199,6 +197,7 @@ from invokeai.app.invocations.image import ImageOutput
 class ResizeInvocation(BaseInvocation):
     '''Resizes an image'''
 
+    # Inputs
     image: ImageField = InputField(description="The input image")
     width: int = InputField(default=512, ge=64, le=2048, description="Width of the new image")
     height: int = InputField(default=512, ge=64, le=2048, description="Height of the new image")
@@ -230,17 +229,30 @@ class ResizeInvocation(BaseInvocation):
     height: int = InputField(default=512, ge=64, le=2048, description="Height of the new image")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        # Load the input image as a PIL image
-        image = context.images.get_pil(self.image.image_name)
+        # Load the image using InvokeAI's predefined Image Service. Returns the PIL image.
+        image = context.services.images.get_pil_image(self.image.image_name)
 
-        # Resize the image
+        # Resizing the image
         resized_image = image.resize((self.width, self.height))
 
-        # Save the image
-        image_dto = context.images.save(image=resized_image)
+        # Save the image using InvokeAI's predefined Image Service. Returns the prepared PIL image.
+        output_image = context.services.images.create(
+            image=resized_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 an ImageOutput
-        return ImageOutput.build(image_dto)
+        # Returning the Image
+        return ImageOutput(
+            image=ImageField(
+                image_name=output_image.image_name,
+            ),
+            width=output_image.width,
+            height=output_image.height,
+        )
 ```
 
 **Note:** Do not be overwhelmed by the `ImageOutput` process. InvokeAI has a
@@ -331,25 +343,27 @@ class ImageColorStringOutput(BaseInvocationOutput):
 
 That's all there is to it.
 
+<!-- TODO: DANGER - we probably do not want people to create their own field types, because this requires a lot of work on the frontend to accomodate.
+
 ### Custom Input Fields
 
 Now that you know how to create your own Invocations, let us dive into slightly
 more advanced topics.
 
 While creating your own Invocations, you might run into a scenario where the
-existing fields in InvokeAI do not meet your requirements. In such cases, you
-can create your own fields.
+existing input types in InvokeAI do not meet your requirements. In such cases,
+you can create your own input types.
 
 Let us create one as an example. Let us say we want to create a color input
 field that represents a color code. But before we start on that here are some
 general good practices to keep in mind.
 
-### Best Practices
+**Good Practices**
 
 - There is no naming convention for input fields but we highly recommend that
   you name it something appropriate like `ColorField`.
 - It is not mandatory but it is heavily recommended to add a relevant
-  `docstring` to describe your field.
+  `docstring` to describe your input field.
 - Keep your field in the same file as the Invocation that it is made for or in
   another file where it is relevant.
 
@@ -364,13 +378,10 @@ class ColorField(BaseModel):
     pass
 ```
 
-Perfect. Now let us create the properties for our field. This is similar to how
-you created input fields for your Invocation. All the same rules apply. Let us
-create four fields representing the _red(r)_, _blue(b)_, _green(g)_ and
-_alpha(a)_ channel of the color.
-
-> Technically, the properties are _also_ called fields - but in this case, it
-> refers to a `pydantic` field.
+Perfect. Now let us create our custom inputs for our field. This is exactly
+similar how you created input fields for your Invocation. All the same rules
+apply. Let us create four fields representing the _red(r)_, _blue(b)_,
+_green(g)_ and _alpha(a)_ channel of the color.
 
 ```python
 class ColorField(BaseModel):
@@ -385,11 +396,25 @@ That's it. We now have a new input field type that we can use in our Invocations
 like this.
 
 ```python
-color: ColorField = InputField(default=ColorField(r=0, g=0, b=0, a=0), description='Background color of an image')
+color: ColorField = Field(default=ColorField(r=0, g=0, b=0, a=0), description='Background color of an image')
 ```
 
-### Using the custom field
+### Custom Components For Frontend
 
-When you start the UI, your custom field will be automatically recognized.
+Every backend input type should have a corresponding frontend component so the
+UI knows what to render when you use a particular field type.
 
-Custom fields only support connection inputs in the Workflow Editor.
+If you are using existing field types, we already have components for those. So
+you don't have to worry about creating anything new. But this might not always
+be the case. Sometimes you might want to create new field types and have the
+frontend UI deal with it in a different way.
+
+This is where we venture into the world of React and Javascript and create our
+own new components for our Invocations. Do not fear the world of JS. It's
+actually pretty straightforward.
+
+Let us create a new component for our custom color field we created above. When
+we use a color field, let us say we want the UI to display a color picker for
+the user to pick from rather than entering values. That is what we will build
+now.
+-->

docs/features/CONTROLNET.md

@@ -94,8 +94,6 @@ A model that helps generate creative QR codes that still scan. Can also be used
 **Openpose**: 
 The OpenPose control model allows for the identification of the general pose of a character by pre-processing an existing image with a clear human structure. With advanced options, Openpose can also detect the face or hands in the image. 
 
-*Note:* The DWPose Processor has replaced the OpenPose processor in Invoke. Workflows and generations that relied on the OpenPose Processor will need to be updated to use the DWPose Processor instead.
-
 **Mediapipe Face**:
 
 The MediaPipe Face identification processor is able to clearly identify facial features in order to capture vivid expressions of human faces.

docs/installation/020_INSTALL_MANUAL.md

@@ -230,13 +230,13 @@ manager, please follow these steps:
         === "local Webserver"
 
             ```bash
-            invokeai-web
+            invokeai --web
             ```
 
         === "Public Webserver"
 
             ```bash
-            invokeai-web --host 0.0.0.0
+            invokeai --web --host 0.0.0.0
             ```
 
         === "CLI"
@@ -402,4 +402,4 @@ environment variable INVOKEAI_ROOT to point to the installation directory.
 Note that if you run into problems with the Conda installation, the InvokeAI
 staff will **not** be able to help you out. Caveat Emptor!
 
-[dev-chat]: https://discord.com/channels/1020123559063990373/1049495067846524939
+[dev-chat]: https://discord.com/channels/1020123559063990373/1049495067846524939

docs/installation/040_INSTALL_DOCKER.md

@@ -69,7 +69,7 @@ a token and copy it, since you will need in for the next step.
 
 ### Setup
 
-Set up your environmnent variables. In the `docker` directory, make a copy of `.env.sample` and name it `.env`. Make changes as necessary.
+Set up your environmnent variables. In the `docker` directory, make a copy of `env.sample` and name it `.env`. Make changes as necessary.
 
 Any environment variables supported by InvokeAI can be set here - please see the [CONFIGURATION](../features/CONFIGURATION.md) for further detail.
 

docs/nodes/defaultNodes.md

@@ -81,7 +81,7 @@ their descriptions.
 | ONNX Text to Latents                                          | Generates latents from conditionings.                                                                                                                |
 | ONNX Model Loader                                             | Loads a main model, outputting its submodels.                                                                                                        |
 | OpenCV Inpaint                                                | Simple inpaint using opencv.                                                                                                                         |
-| DW Openpose Processor                                            | Applies Openpose processing to image                                                                                                                 |
+| Openpose Processor                                            | Applies Openpose processing to image                                                                                                                 |
 | PIDI Processor                                                | Applies PIDI processing to image                                                                                                                     |
 | Prompts from File                                             | Loads prompts from a text file                                                                                                                       |
 | Random Integer                                                | Outputs a single random integer.                                                                                                                     |

installer/lib/messages.py

@@ -91,7 +91,8 @@ def choose_version(available_releases: tuple | None = None) -> str:
         complete_while_typing=True,
         completer=FuzzyWordCompleter(choices),
     )
-    console.print(f"   Version {choices[0] if response == '' else response} will be installed.")
+
+    console.print(f"   Version {choices[0] if response == "" else response} will be installed.")
 
     console.line()
 

invokeai/app/api/dependencies.py

@@ -2,13 +2,8 @@
 
 from logging import Logger
 
-import torch
-
 from invokeai.app.services.item_storage.item_storage_memory import ItemStorageMemory
-from invokeai.app.services.object_serializer.object_serializer_disk import ObjectSerializerDisk
-from invokeai.app.services.object_serializer.object_serializer_forward_cache import ObjectSerializerForwardCache
 from invokeai.app.services.shared.sqlite.sqlite_util import init_db
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import ConditioningFieldData
 from invokeai.backend.util.logging import InvokeAILogger
 from invokeai.version.invokeai_version import __version__
 
@@ -27,6 +22,8 @@ from ..services.invocation_queue.invocation_queue_memory import MemoryInvocation
 from ..services.invocation_services import InvocationServices
 from ..services.invocation_stats.invocation_stats_default import InvocationStatsService
 from ..services.invoker import Invoker
+from ..services.latents_storage.latents_storage_disk import DiskLatentsStorage
+from ..services.latents_storage.latents_storage_forward_cache import ForwardCacheLatentsStorage
 from ..services.model_manager.model_manager_default import ModelManagerService
 from ..services.model_metadata import ModelMetadataStoreSQL
 from ..services.model_records import ModelRecordServiceSQL
@@ -70,9 +67,6 @@ class ApiDependencies:
         logger.debug(f"Internet connectivity is {config.internet_available}")
 
         output_folder = config.output_path
-        if output_folder is None:
-            raise ValueError("Output folder is not set")
-
         image_files = DiskImageFileStorage(f"{output_folder}/images")
 
         db = init_db(config=config, logger=logger, image_files=image_files)
@@ -89,12 +83,7 @@ class ApiDependencies:
         image_records = SqliteImageRecordStorage(db=db)
         images = ImageService()
         invocation_cache = MemoryInvocationCache(max_cache_size=config.node_cache_size)
-        tensors = ObjectSerializerForwardCache(
-            ObjectSerializerDisk[torch.Tensor](output_folder / "tensors", ephemeral=True)
-        )
-        conditioning = ObjectSerializerForwardCache(
-            ObjectSerializerDisk[ConditioningFieldData](output_folder / "conditioning", ephemeral=True)
-        )
+        latents = ForwardCacheLatentsStorage(DiskLatentsStorage(f"{output_folder}/latents"))
         download_queue_service = DownloadQueueService(event_bus=events)
         model_metadata_service = ModelMetadataStoreSQL(db=db)
         model_manager = ModelManagerService.build_model_manager(
@@ -124,6 +113,7 @@ class ApiDependencies:
             image_records=image_records,
             images=images,
             invocation_cache=invocation_cache,
+            latents=latents,
             logger=logger,
             model_manager=model_manager,
             download_queue=download_queue_service,
@@ -135,8 +125,6 @@ class ApiDependencies:
             session_queue=session_queue,
             urls=urls,
             workflow_records=workflow_records,
-            tensors=tensors,
-            conditioning=conditioning,
         )
 
         ApiDependencies.invoker = Invoker(services)

invokeai/app/api/routers/images.py

@@ -8,7 +8,7 @@ from fastapi.routing import APIRouter
 from PIL import Image
 from pydantic import BaseModel, Field, ValidationError
 
-from invokeai.app.invocations.fields import MetadataField, MetadataFieldValidator
+from invokeai.app.invocations.baseinvocation import MetadataField, MetadataFieldValidator
 from invokeai.app.services.image_records.image_records_common import ImageCategory, ImageRecordChanges, ResourceOrigin
 from invokeai.app.services.images.images_common import ImageDTO, ImageUrlsDTO
 from invokeai.app.services.shared.pagination import OffsetPaginatedResults

invokeai/app/api_app.py

@@ -6,7 +6,6 @@ import sys
 from invokeai.app.api.no_cache_staticfiles import NoCacheStaticFiles
 from invokeai.version.invokeai_version import __version__
 
-from .invocations.fields import InputFieldJSONSchemaExtra, OutputFieldJSONSchemaExtra
 from .services.config import InvokeAIAppConfig
 
 app_config = InvokeAIAppConfig.get_config()
@@ -57,6 +56,8 @@ if True:  # hack to make flake8 happy with imports coming after setting up the c
     from .api.sockets import SocketIO
     from .invocations.baseinvocation import (
         BaseInvocation,
+        InputFieldJSONSchemaExtra,
+        OutputFieldJSONSchemaExtra,
         UIConfigBase,
     )
 

invokeai/app/invocations/baseinvocation.py

@@ -12,16 +12,13 @@ from types import UnionType
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterable, Literal, Optional, Type, TypeVar, Union, cast
 
 import semver
-from pydantic import BaseModel, ConfigDict, Field, create_model
-from pydantic.fields import FieldInfo
+from pydantic import BaseModel, ConfigDict, Field, RootModel, TypeAdapter, create_model
+from pydantic.fields import FieldInfo, _Unset
 from pydantic_core import PydanticUndefined
 
-from invokeai.app.invocations.fields import (
-    FieldKind,
-    Input,
-)
 from invokeai.app.services.config.config_default import InvokeAIAppConfig
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.services.workflow_records.workflow_records_common import WorkflowWithoutID
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.util.metaenum import MetaEnum
 from invokeai.app.util.misc import uuid_string
 from invokeai.backend.util.logging import InvokeAILogger
@@ -55,6 +52,393 @@ class Classification(str, Enum, metaclass=MetaEnum):
     Prototype = "prototype"
 
 
+class Input(str, Enum, metaclass=MetaEnum):
+    """
+    The type of input a field accepts.
+    - `Input.Direct`: The field must have its value provided directly, when the invocation and field \
+      are instantiated.
+    - `Input.Connection`: The field must have its value provided by a connection.
+    - `Input.Any`: The field may have its value provided either directly or by a connection.
+    """
+
+    Connection = "connection"
+    Direct = "direct"
+    Any = "any"
+
+
+class FieldKind(str, Enum, metaclass=MetaEnum):
+    """
+    The kind of field.
+    - `Input`: An input field on a node.
+    - `Output`: An output field on a node.
+    - `Internal`: A field which is treated as an input, but cannot be used in node definitions. Metadata is
+    one example. It is provided to nodes via the WithMetadata class, and we want to reserve the field name
+    "metadata" for this on all nodes. `FieldKind` is used to short-circuit the field name validation logic,
+    allowing "metadata" for that field.
+    - `NodeAttribute`: The field is a node attribute. These are fields which are not inputs or outputs,
+    but which are used to store information about the node. For example, the `id` and `type` fields are node
+    attributes.
+
+    The presence of this in `json_schema_extra["field_kind"]` is used when initializing node schemas on app
+    startup, and when generating the OpenAPI schema for the workflow editor.
+    """
+
+    Input = "input"
+    Output = "output"
+    Internal = "internal"
+    NodeAttribute = "node_attribute"
+
+
+class UIType(str, Enum, metaclass=MetaEnum):
+    """
+    Type hints for the UI for situations in which the field type is not enough to infer the correct UI type.
+
+    - Model Fields
+    The most common node-author-facing use will be for model fields. Internally, there is no difference
+    between SD-1, SD-2 and SDXL model fields - they all use the class `MainModelField`. To ensure the
+    base-model-specific UI is rendered, use e.g. `ui_type=UIType.SDXLMainModelField` to indicate that
+    the field is an SDXL main model field.
+
+    - Any Field
+    We cannot infer the usage of `typing.Any` via schema parsing, so you *must* use `ui_type=UIType.Any` to
+    indicate that the field accepts any type. Use with caution. This cannot be used on outputs.
+
+    - Scheduler Field
+    Special handling in the UI is needed for this field, which otherwise would be parsed as a plain enum field.
+
+    - Internal Fields
+    Similar to the Any Field, the `collect` and `iterate` nodes make use of `typing.Any`. To facilitate
+    handling these types in the client, we use `UIType._Collection` and `UIType._CollectionItem`. These
+    should not be used by node authors.
+
+    - DEPRECATED Fields
+    These types are deprecated and should not be used by node authors. A warning will be logged if one is
+    used, and the type will be ignored. They are included here for backwards compatibility.
+    """
+
+    # region Model Field Types
+    SDXLMainModel = "SDXLMainModelField"
+    SDXLRefinerModel = "SDXLRefinerModelField"
+    ONNXModel = "ONNXModelField"
+    VaeModel = "VAEModelField"
+    LoRAModel = "LoRAModelField"
+    ControlNetModel = "ControlNetModelField"
+    IPAdapterModel = "IPAdapterModelField"
+    # endregion
+
+    # region Misc Field Types
+    Scheduler = "SchedulerField"
+    Any = "AnyField"
+    # endregion
+
+    # region Internal Field Types
+    _Collection = "CollectionField"
+    _CollectionItem = "CollectionItemField"
+    # endregion
+
+    # region DEPRECATED
+    Boolean = "DEPRECATED_Boolean"
+    Color = "DEPRECATED_Color"
+    Conditioning = "DEPRECATED_Conditioning"
+    Control = "DEPRECATED_Control"
+    Float = "DEPRECATED_Float"
+    Image = "DEPRECATED_Image"
+    Integer = "DEPRECATED_Integer"
+    Latents = "DEPRECATED_Latents"
+    String = "DEPRECATED_String"
+    BooleanCollection = "DEPRECATED_BooleanCollection"
+    ColorCollection = "DEPRECATED_ColorCollection"
+    ConditioningCollection = "DEPRECATED_ConditioningCollection"
+    ControlCollection = "DEPRECATED_ControlCollection"
+    FloatCollection = "DEPRECATED_FloatCollection"
+    ImageCollection = "DEPRECATED_ImageCollection"
+    IntegerCollection = "DEPRECATED_IntegerCollection"
+    LatentsCollection = "DEPRECATED_LatentsCollection"
+    StringCollection = "DEPRECATED_StringCollection"
+    BooleanPolymorphic = "DEPRECATED_BooleanPolymorphic"
+    ColorPolymorphic = "DEPRECATED_ColorPolymorphic"
+    ConditioningPolymorphic = "DEPRECATED_ConditioningPolymorphic"
+    ControlPolymorphic = "DEPRECATED_ControlPolymorphic"
+    FloatPolymorphic = "DEPRECATED_FloatPolymorphic"
+    ImagePolymorphic = "DEPRECATED_ImagePolymorphic"
+    IntegerPolymorphic = "DEPRECATED_IntegerPolymorphic"
+    LatentsPolymorphic = "DEPRECATED_LatentsPolymorphic"
+    StringPolymorphic = "DEPRECATED_StringPolymorphic"
+    MainModel = "DEPRECATED_MainModel"
+    UNet = "DEPRECATED_UNet"
+    Vae = "DEPRECATED_Vae"
+    CLIP = "DEPRECATED_CLIP"
+    Collection = "DEPRECATED_Collection"
+    CollectionItem = "DEPRECATED_CollectionItem"
+    Enum = "DEPRECATED_Enum"
+    WorkflowField = "DEPRECATED_WorkflowField"
+    IsIntermediate = "DEPRECATED_IsIntermediate"
+    BoardField = "DEPRECATED_BoardField"
+    MetadataItem = "DEPRECATED_MetadataItem"
+    MetadataItemCollection = "DEPRECATED_MetadataItemCollection"
+    MetadataItemPolymorphic = "DEPRECATED_MetadataItemPolymorphic"
+    MetadataDict = "DEPRECATED_MetadataDict"
+    # endregion
+
+
+class UIComponent(str, Enum, metaclass=MetaEnum):
+    """
+    The type of UI component to use for a field, used to override the default components, which are
+    inferred from the field type.
+    """
+
+    None_ = "none"
+    Textarea = "textarea"
+    Slider = "slider"
+
+
+class InputFieldJSONSchemaExtra(BaseModel):
+    """
+    Extra attributes to be added to input fields and their OpenAPI schema. Used during graph execution,
+    and by the workflow editor during schema parsing and UI rendering.
+    """
+
+    input: Input
+    orig_required: bool
+    field_kind: FieldKind
+    default: Optional[Any] = None
+    orig_default: Optional[Any] = None
+    ui_hidden: bool = False
+    ui_type: Optional[UIType] = None
+    ui_component: Optional[UIComponent] = None
+    ui_order: Optional[int] = None
+    ui_choice_labels: Optional[dict[str, str]] = None
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        json_schema_serialization_defaults_required=True,
+    )
+
+
+class OutputFieldJSONSchemaExtra(BaseModel):
+    """
+    Extra attributes to be added to input fields and their OpenAPI schema. Used by the workflow editor
+    during schema parsing and UI rendering.
+    """
+
+    field_kind: FieldKind
+    ui_hidden: bool
+    ui_type: Optional[UIType]
+    ui_order: Optional[int]
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        json_schema_serialization_defaults_required=True,
+    )
+
+
+def InputField(
+    # copied from pydantic's Field
+    # TODO: Can we support default_factory?
+    default: Any = _Unset,
+    default_factory: Callable[[], Any] | None = _Unset,
+    title: str | None = _Unset,
+    description: str | None = _Unset,
+    pattern: str | None = _Unset,
+    strict: bool | None = _Unset,
+    gt: float | None = _Unset,
+    ge: float | None = _Unset,
+    lt: float | None = _Unset,
+    le: float | None = _Unset,
+    multiple_of: float | None = _Unset,
+    allow_inf_nan: bool | None = _Unset,
+    max_digits: int | None = _Unset,
+    decimal_places: int | None = _Unset,
+    min_length: int | None = _Unset,
+    max_length: int | None = _Unset,
+    # custom
+    input: Input = Input.Any,
+    ui_type: Optional[UIType] = None,
+    ui_component: Optional[UIComponent] = None,
+    ui_hidden: bool = False,
+    ui_order: Optional[int] = None,
+    ui_choice_labels: Optional[dict[str, str]] = None,
+) -> Any:
+    """
+    Creates an input field for an invocation.
+
+    This is a wrapper for Pydantic's [Field](https://docs.pydantic.dev/latest/api/fields/#pydantic.fields.Field) \
+    that adds a few extra parameters to support graph execution and the node editor UI.
+
+    :param Input input: [Input.Any] The kind of input this field requires. \
+      `Input.Direct` means a value must be provided on instantiation. \
+      `Input.Connection` means the value must be provided by a connection. \
+      `Input.Any` means either will do.
+
+    :param UIType ui_type: [None] Optionally provides an extra type hint for the UI. \
+      In some situations, the field's type is not enough to infer the correct UI type. \
+      For example, model selection fields should render a dropdown UI component to select a model. \
+      Internally, there is no difference between SD-1, SD-2 and SDXL model fields, they all use \
+      `MainModelField`. So to ensure the base-model-specific UI is rendered, you can use \
+      `UIType.SDXLMainModelField` to indicate that the field is an SDXL main model field.
+
+    :param UIComponent ui_component: [None] Optionally specifies a specific component to use in the UI. \
+      The UI will always render a suitable component, but sometimes you want something different than the default. \
+      For example, a `string` field will default to a single-line input, but you may want a multi-line textarea instead. \
+      For this case, you could provide `UIComponent.Textarea`.
+
+    :param bool ui_hidden: [False] Specifies whether or not this field should be hidden in the UI.
+
+    :param int ui_order: [None] Specifies the order in which this field should be rendered in the UI.
+
+    :param dict[str, str] ui_choice_labels: [None] Specifies the labels to use for the choices in an enum field.
+    """
+
+    json_schema_extra_ = InputFieldJSONSchemaExtra(
+        input=input,
+        ui_type=ui_type,
+        ui_component=ui_component,
+        ui_hidden=ui_hidden,
+        ui_order=ui_order,
+        ui_choice_labels=ui_choice_labels,
+        field_kind=FieldKind.Input,
+        orig_required=True,
+    )
+
+    """
+    There is a conflict between the typing of invocation definitions and the typing of an invocation's
+    `invoke()` function.
+
+    On instantiation of a node, the invocation definition is used to create the python class. At this time,
+    any number of fields may be optional, because they may be provided by connections.
+
+    On calling of `invoke()`, however, those fields may be required.
+
+    For example, consider an ResizeImageInvocation with an `image: ImageField` field.
+
+    `image` is required during the call to `invoke()`, but when the python class is instantiated,
+    the field may not be present. This is fine, because that image field will be provided by a
+    connection from an ancestor node, which outputs an image.
+
+    This means we want to type the `image` field as optional for the node class definition, but required
+    for the `invoke()` function.
+
+    If we use `typing.Optional` in the node class definition, the field will be typed as optional in the
+    `invoke()` method, and we'll have to do a lot of runtime checks to ensure the field is present - or
+    any static type analysis tools will complain.
+
+    To get around this, in node class definitions, we type all fields correctly for the `invoke()` function,
+    but secretly make them optional in `InputField()`. We also store the original required bool and/or default
+    value. When we call `invoke()`, we use this stored information to do an additional check on the class.
+    """
+
+    if default_factory is not _Unset and default_factory is not None:
+        default = default_factory()
+        logger.warn('"default_factory" is not supported, calling it now to set "default"')
+
+    # These are the args we may wish pass to the pydantic `Field()` function
+    field_args = {
+        "default": default,
+        "title": title,
+        "description": description,
+        "pattern": pattern,
+        "strict": strict,
+        "gt": gt,
+        "ge": ge,
+        "lt": lt,
+        "le": le,
+        "multiple_of": multiple_of,
+        "allow_inf_nan": allow_inf_nan,
+        "max_digits": max_digits,
+        "decimal_places": decimal_places,
+        "min_length": min_length,
+        "max_length": max_length,
+    }
+
+    # We only want to pass the args that were provided, otherwise the `Field()`` function won't work as expected
+    provided_args = {k: v for (k, v) in field_args.items() if v is not PydanticUndefined}
+
+    # Because we are manually making fields optional, we need to store the original required bool for reference later
+    json_schema_extra_.orig_required = default is PydanticUndefined
+
+    # Make Input.Any and Input.Connection fields optional, providing None as a default if the field doesn't already have one
+    if input is Input.Any or input is Input.Connection:
+        default_ = None if default is PydanticUndefined else default
+        provided_args.update({"default": default_})
+        if default is not PydanticUndefined:
+            # Before invoking, we'll check for the original default value and set it on the field if the field has no value
+            json_schema_extra_.default = default
+            json_schema_extra_.orig_default = default
+    elif default is not PydanticUndefined:
+        default_ = default
+        provided_args.update({"default": default_})
+        json_schema_extra_.orig_default = default_
+
+    return Field(
+        **provided_args,
+        json_schema_extra=json_schema_extra_.model_dump(exclude_none=True),
+    )
+
+
+def OutputField(
+    # copied from pydantic's Field
+    default: Any = _Unset,
+    title: str | None = _Unset,
+    description: str | None = _Unset,
+    pattern: str | None = _Unset,
+    strict: bool | None = _Unset,
+    gt: float | None = _Unset,
+    ge: float | None = _Unset,
+    lt: float | None = _Unset,
+    le: float | None = _Unset,
+    multiple_of: float | None = _Unset,
+    allow_inf_nan: bool | None = _Unset,
+    max_digits: int | None = _Unset,
+    decimal_places: int | None = _Unset,
+    min_length: int | None = _Unset,
+    max_length: int | None = _Unset,
+    # custom
+    ui_type: Optional[UIType] = None,
+    ui_hidden: bool = False,
+    ui_order: Optional[int] = None,
+) -> Any:
+    """
+    Creates an output field for an invocation output.
+
+    This is a wrapper for Pydantic's [Field](https://docs.pydantic.dev/1.10/usage/schema/#field-customization) \
+    that adds a few extra parameters to support graph execution and the node editor UI.
+
+    :param UIType ui_type: [None] Optionally provides an extra type hint for the UI. \
+      In some situations, the field's type is not enough to infer the correct UI type. \
+      For example, model selection fields should render a dropdown UI component to select a model. \
+      Internally, there is no difference between SD-1, SD-2 and SDXL model fields, they all use \
+      `MainModelField`. So to ensure the base-model-specific UI is rendered, you can use \
+      `UIType.SDXLMainModelField` to indicate that the field is an SDXL main model field.
+
+    :param bool ui_hidden: [False] Specifies whether or not this field should be hidden in the UI. \
+
+    :param int ui_order: [None] Specifies the order in which this field should be rendered in the UI. \
+    """
+    return Field(
+        default=default,
+        title=title,
+        description=description,
+        pattern=pattern,
+        strict=strict,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        multiple_of=multiple_of,
+        allow_inf_nan=allow_inf_nan,
+        max_digits=max_digits,
+        decimal_places=decimal_places,
+        min_length=min_length,
+        max_length=max_length,
+        json_schema_extra=OutputFieldJSONSchemaExtra(
+            ui_type=ui_type,
+            ui_hidden=ui_hidden,
+            ui_order=ui_order,
+            field_kind=FieldKind.Output,
+        ).model_dump(exclude_none=True),
+    )
+
+
 class UIConfigBase(BaseModel):
     """
     Provides additional node configuration to the UI.
@@ -76,6 +460,33 @@ class UIConfigBase(BaseModel):
     )
 
 
+class InvocationContext:
+    """Initialized and provided to on execution of invocations."""
+
+    services: InvocationServices
+    graph_execution_state_id: str
+    queue_id: str
+    queue_item_id: int
+    queue_batch_id: str
+    workflow: Optional[WorkflowWithoutID]
+
+    def __init__(
+        self,
+        services: InvocationServices,
+        queue_id: str,
+        queue_item_id: int,
+        queue_batch_id: str,
+        graph_execution_state_id: str,
+        workflow: Optional[WorkflowWithoutID],
+    ):
+        self.services = services
+        self.graph_execution_state_id = graph_execution_state_id
+        self.queue_id = queue_id
+        self.queue_item_id = queue_item_id
+        self.queue_batch_id = queue_batch_id
+        self.workflow = workflow
+
+
 class BaseInvocationOutput(BaseModel):
     """
     Base class for all invocation outputs.
@@ -221,7 +632,7 @@ class BaseInvocation(ABC, BaseModel):
         """Invoke with provided context and return outputs."""
         pass
 
-    def invoke_internal(self, context: InvocationContext, services: "InvocationServices") -> BaseInvocationOutput:
+    def invoke_internal(self, context: InvocationContext) -> BaseInvocationOutput:
         """
         Internal invoke method, calls `invoke()` after some prep.
         Handles optional fields that are required to call `invoke()` and invocation cache.
@@ -246,23 +657,23 @@ class BaseInvocation(ABC, BaseModel):
                     raise MissingInputException(self.model_fields["type"].default, field_name)
 
         # skip node cache codepath if it's disabled
-        if services.configuration.node_cache_size == 0:
+        if context.services.configuration.node_cache_size == 0:
             return self.invoke(context)
 
         output: BaseInvocationOutput
         if self.use_cache:
-            key = services.invocation_cache.create_key(self)
-            cached_value = services.invocation_cache.get(key)
+            key = context.services.invocation_cache.create_key(self)
+            cached_value = context.services.invocation_cache.get(key)
             if cached_value is None:
-                services.logger.debug(f'Invocation cache miss for type "{self.get_type()}": {self.id}')
+                context.services.logger.debug(f'Invocation cache miss for type "{self.get_type()}": {self.id}')
                 output = self.invoke(context)
-                services.invocation_cache.save(key, output)
+                context.services.invocation_cache.save(key, output)
                 return output
             else:
-                services.logger.debug(f'Invocation cache hit for type "{self.get_type()}": {self.id}')
+                context.services.logger.debug(f'Invocation cache hit for type "{self.get_type()}": {self.id}')
                 return cached_value
         else:
-            services.logger.debug(f'Skipping invocation cache for "{self.get_type()}": {self.id}')
+            context.services.logger.debug(f'Skipping invocation cache for "{self.get_type()}": {self.id}')
             return self.invoke(context)
 
     id: str = Field(
@@ -303,7 +714,9 @@ RESERVED_NODE_ATTRIBUTE_FIELD_NAMES = {
     "workflow",
 }
 
-RESERVED_INPUT_FIELD_NAMES = {"metadata", "board"}
+RESERVED_INPUT_FIELD_NAMES = {
+    "metadata",
+}
 
 RESERVED_OUTPUT_FIELD_NAMES = {"type"}
 
@@ -513,3 +926,37 @@ def invocation_output(
         return cls
 
     return wrapper
+
+
+class MetadataField(RootModel):
+    """
+    Pydantic model for metadata with custom root of type dict[str, Any].
+    Metadata is stored without a strict schema.
+    """
+
+    root: dict[str, Any] = Field(description="The metadata")
+
+
+MetadataFieldValidator = TypeAdapter(MetadataField)
+
+
+class WithMetadata(BaseModel):
+    metadata: Optional[MetadataField] = Field(
+        default=None,
+        description=FieldDescriptions.metadata,
+        json_schema_extra=InputFieldJSONSchemaExtra(
+            field_kind=FieldKind.Internal,
+            input=Input.Connection,
+            orig_required=False,
+        ).model_dump(exclude_none=True),
+    )
+
+
+class WithWorkflow:
+    workflow = None
+
+    def __init_subclass__(cls) -> None:
+        logger.warn(
+            f"{cls.__module__.split('.')[0]}.{cls.__name__}: WithWorkflow is deprecated. Use `context.workflow` to access the workflow."
+        )
+        super().__init_subclass__()

invokeai/app/invocations/collections.py

@@ -5,11 +5,9 @@ import numpy as np
 from pydantic import ValidationInfo, field_validator
 
 from invokeai.app.invocations.primitives import IntegerCollectionOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.misc import SEED_MAX
 
-from .baseinvocation import BaseInvocation, invocation
-from .fields import InputField
+from .baseinvocation import BaseInvocation, InputField, InvocationContext, invocation
 
 
 @invocation(

invokeai/app/invocations/compel.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from typing import Iterator, List, Optional, Tuple, Union
 
 import torch
@@ -6,23 +7,15 @@ from compel.prompt_parser import Blend, Conjunction, CrossAttentionControlSubsti
 from transformers import CLIPTokenizer
 
 import invokeai.backend.util.logging as logger
-from invokeai.app.invocations.fields import (
-    FieldDescriptions,
-    Input,
-    InputField,
-    OutputField,
-    UIComponent,
-)
-from invokeai.app.invocations.primitives import ConditioningOutput
+from invokeai.app.invocations.primitives import ConditioningField, ConditioningOutput
 from invokeai.app.services.model_records import UnknownModelException
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.util.ti_utils import extract_ti_triggers_from_prompt
 from invokeai.backend.lora import LoRAModelRaw
 from invokeai.backend.model_manager import ModelType
 from invokeai.backend.model_patcher import ModelPatcher
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
     BasicConditioningInfo,
-    ConditioningFieldData,
     ExtraConditioningInfo,
     SDXLConditioningInfo,
 )
@@ -32,12 +25,21 @@ from invokeai.backend.util.devices import torch_dtype
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
+    UIComponent,
     invocation,
     invocation_output,
 )
 from .model import ClipField
 
-# unconditioned: Optional[torch.Tensor]
+
+@dataclass
+class ConditioningFieldData:
+    conditionings: List[BasicConditioningInfo]
+    # unconditioned: Optional[torch.Tensor]
 
 
 # class ConditioningAlgo(str, Enum):
@@ -51,7 +53,7 @@ from .model import ClipField
     title="Prompt",
     tags=["prompt", "compel"],
     category="conditioning",
-    version="1.0.1",
+    version="1.0.0",
 )
 class CompelInvocation(BaseInvocation):
     """Parse prompt using compel package to conditioning."""
@@ -69,24 +71,35 @@ class CompelInvocation(BaseInvocation):
 
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> ConditioningOutput:
-        tokenizer_info = context.models.load(**self.clip.tokenizer.model_dump())
-        text_encoder_info = context.models.load(**self.clip.text_encoder.model_dump())
+        tokenizer_info = context.services.model_manager.load_model_by_key(
+            **self.clip.tokenizer.model_dump(),
+            context=context,
+        )
+        text_encoder_info = context.services.model_manager.load_model_by_key(
+            **self.clip.text_encoder.model_dump(),
+            context=context,
+        )
 
         def _lora_loader() -> Iterator[Tuple[LoRAModelRaw, float]]:
             for lora in self.clip.loras:
-                lora_info = context.models.load(**lora.model_dump(exclude={"weight"}))
+                lora_info = context.services.model_manager.load_model_by_key(
+                    **lora.model_dump(exclude={"weight"}), context=context
+                )
                 assert isinstance(lora_info.model, LoRAModelRaw)
                 yield (lora_info.model, lora.weight)
                 del lora_info
             return
 
-        # loras = [(context.models.get(**lora.dict(exclude={"weight"})).context.model, lora.weight) for lora in self.clip.loras]
+        # loras = [(context.services.model_manager.get_model(**lora.dict(exclude={"weight"})).context.model, lora.weight) for lora in self.clip.loras]
 
         ti_list = []
         for trigger in extract_ti_triggers_from_prompt(self.prompt):
             name = trigger[1:-1]
             try:
-                loaded_model = context.models.load(**self.clip.text_encoder.model_dump()).model
+                loaded_model = context.services.model_manager.load_model_by_key(
+                    **self.clip.text_encoder.model_dump(),
+                    context=context,
+                ).model
                 assert isinstance(loaded_model, TextualInversionModelRaw)
                 ti_list.append((name, loaded_model))
             except UnknownModelException:
@@ -116,7 +129,7 @@ class CompelInvocation(BaseInvocation):
 
             conjunction = Compel.parse_prompt_string(self.prompt)
 
-            if context.config.get().log_tokenization:
+            if context.services.configuration.log_tokenization:
                 log_tokenization_for_conjunction(conjunction, tokenizer)
 
             c, options = compel.build_conditioning_tensor_for_conjunction(conjunction)
@@ -137,9 +150,14 @@ class CompelInvocation(BaseInvocation):
             ]
         )
 
-        conditioning_name = context.conditioning.save(conditioning_data)
+        conditioning_name = f"{context.graph_execution_state_id}_{self.id}_conditioning"
+        context.services.latents.save(conditioning_name, conditioning_data)  # TODO: fix type mismatch here
 
-        return ConditioningOutput.build(conditioning_name)
+        return ConditioningOutput(
+            conditioning=ConditioningField(
+                conditioning_name=conditioning_name,
+            ),
+        )
 
 
 class SDXLPromptInvocationBase:
@@ -154,8 +172,14 @@ class SDXLPromptInvocationBase:
         lora_prefix: str,
         zero_on_empty: bool,
     ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[ExtraConditioningInfo]]:
-        tokenizer_info = context.models.load(**clip_field.tokenizer.model_dump())
-        text_encoder_info = context.models.load(**clip_field.text_encoder.model_dump())
+        tokenizer_info = context.services.model_manager.load_model_by_key(
+            **clip_field.tokenizer.model_dump(),
+            context=context,
+        )
+        text_encoder_info = context.services.model_manager.load_model_by_key(
+            **clip_field.text_encoder.model_dump(),
+            context=context,
+        )
 
         # return zero on empty
         if prompt == "" and zero_on_empty:
@@ -180,21 +204,26 @@ class SDXLPromptInvocationBase:
 
         def _lora_loader() -> Iterator[Tuple[LoRAModelRaw, float]]:
             for lora in clip_field.loras:
-                lora_info = context.models.load(**lora.model_dump(exclude={"weight"}))
+                lora_info = context.services.model_manager.load_model_by_key(
+                    **lora.model_dump(exclude={"weight"}), context=context
+                )
                 lora_model = lora_info.model
                 assert isinstance(lora_model, LoRAModelRaw)
                 yield (lora_model, lora.weight)
                 del lora_info
             return
 
-        # loras = [(context.models.get(**lora.dict(exclude={"weight"})).context.model, lora.weight) for lora in self.clip.loras]
+        # loras = [(context.services.model_manager.get_model(**lora.dict(exclude={"weight"})).context.model, lora.weight) for lora in self.clip.loras]
 
         ti_list = []
         for trigger in extract_ti_triggers_from_prompt(prompt):
             name = trigger[1:-1]
             try:
-                ti_model = context.models.load_by_attrs(
-                    model_name=name, base_model=text_encoder_info.config.base, model_type=ModelType.TextualInversion
+                ti_model = context.services.model_manager.load_model_by_attr(
+                    model_name=name,
+                    base_model=text_encoder_info.config.base,
+                    model_type=ModelType.TextualInversion,
+                    context=context,
                 ).model
                 assert isinstance(ti_model, TextualInversionModelRaw)
                 ti_list.append((name, ti_model))
@@ -229,7 +258,7 @@ class SDXLPromptInvocationBase:
 
             conjunction = Compel.parse_prompt_string(prompt)
 
-            if context.config.get().log_tokenization:
+            if context.services.configuration.log_tokenization:
                 # TODO: better logging for and syntax
                 log_tokenization_for_conjunction(conjunction, tokenizer)
 
@@ -262,7 +291,7 @@ class SDXLPromptInvocationBase:
     title="SDXL Prompt",
     tags=["sdxl", "compel", "prompt"],
     category="conditioning",
-    version="1.0.1",
+    version="1.0.0",
 )
 class SDXLCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase):
     """Parse prompt using compel package to conditioning."""
@@ -345,9 +374,14 @@ class SDXLCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase):
             ]
         )
 
-        conditioning_name = context.conditioning.save(conditioning_data)
+        conditioning_name = f"{context.graph_execution_state_id}_{self.id}_conditioning"
+        context.services.latents.save(conditioning_name, conditioning_data)
 
-        return ConditioningOutput.build(conditioning_name)
+        return ConditioningOutput(
+            conditioning=ConditioningField(
+                conditioning_name=conditioning_name,
+            ),
+        )
 
 
 @invocation(
@@ -355,7 +389,7 @@ class SDXLCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase):
     title="SDXL Refiner Prompt",
     tags=["sdxl", "compel", "prompt"],
     category="conditioning",
-    version="1.0.1",
+    version="1.0.0",
 )
 class SDXLRefinerCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase):
     """Parse prompt using compel package to conditioning."""
@@ -394,9 +428,14 @@ class SDXLRefinerCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase
             ]
         )
 
-        conditioning_name = context.conditioning.save(conditioning_data)
+        conditioning_name = f"{context.graph_execution_state_id}_{self.id}_conditioning"
+        context.services.latents.save(conditioning_name, conditioning_data)
 
-        return ConditioningOutput.build(conditioning_name)
+        return ConditioningOutput(
+            conditioning=ConditioningField(
+                conditioning_name=conditioning_name,
+            ),
+        )
 
 
 @invocation_output("clip_skip_output")

invokeai/app/invocations/constants.py

@@ -1,17 +0,0 @@
-from typing import Literal
-
-from invokeai.backend.stable_diffusion.schedulers import SCHEDULER_MAP
-
-LATENT_SCALE_FACTOR = 8
-"""
-HACK: Many nodes are currently hard-coded to use a fixed latent scale factor of 8. This is fragile, and will need to
-be addressed if future models use a different latent scale factor. Also, note that there may be places where the scale
-factor is hard-coded to a literal '8' rather than using this constant.
-The ratio of image:latent dimensions is LATENT_SCALE_FACTOR:1, or 8:1.
-"""
-
-SCHEDULER_NAME_VALUES = Literal[tuple(SCHEDULER_MAP.keys())]
-"""A literal type representing the valid scheduler names."""
-
-IMAGE_MODES = Literal["L", "RGB", "RGBA", "CMYK", "YCbCr", "LAB", "HSV", "I", "F"]
-"""A literal type for PIL image modes supported by Invoke"""

invokeai/app/invocations/controlnet_image_processors.py

@@ -17,6 +17,7 @@ from controlnet_aux import (
     MidasDetector,
     MLSDdetector,
     NormalBaeDetector,
+    OpenposeDetector,
     PidiNetDetector,
     SamDetector,
     ZoeDetector,
@@ -25,22 +26,23 @@ from controlnet_aux.util import HWC3, ade_palette
 from PIL import Image
 from pydantic import BaseModel, Field, field_validator, model_validator
 
-from invokeai.app.invocations.fields import (
-    FieldDescriptions,
-    ImageField,
+from invokeai.app.invocations.primitives import ImageField, ImageOutput
+from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
+from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
+from invokeai.app.shared.fields import FieldDescriptions
+from invokeai.backend.image_util.depth_anything import DepthAnythingDetector
+
+from .baseinvocation import (
+    BaseInvocation,
+    BaseInvocationOutput,
     Input,
     InputField,
+    InvocationContext,
     OutputField,
-    WithBoard,
     WithMetadata,
+    invocation,
+    invocation_output,
 )
-from invokeai.app.invocations.primitives import ImageOutput
-from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
-from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.image_util.depth_anything import DepthAnythingDetector
-from invokeai.backend.image_util.dw_openpose import DWOpenposeDetector
-
-from .baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
 
 CONTROLNET_MODE_VALUES = Literal["balanced", "more_prompt", "more_control", "unbalanced"]
 CONTROLNET_RESIZE_VALUES = Literal[
@@ -134,7 +136,7 @@ class ControlNetInvocation(BaseInvocation):
 
 
 # This invocation exists for other invocations to subclass it - do not register with @invocation!
-class ImageProcessorInvocation(BaseInvocation, WithMetadata, WithBoard):
+class ImageProcessorInvocation(BaseInvocation, WithMetadata):
     """Base class for invocations that preprocess images for ControlNet"""
 
     image: ImageField = InputField(description="The image to process")
@@ -143,18 +145,23 @@ class ImageProcessorInvocation(BaseInvocation, WithMetadata, WithBoard):
         # superclass just passes through image without processing
         return image
 
-    def load_image(self, context: InvocationContext) -> Image.Image:
-        # allows override for any special formatting specific to the preprocessor
-        return context.images.get_pil(self.image.image_name, "RGB")
-
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        raw_image = self.load_image(context)
+        raw_image = context.services.images.get_pil_image(self.image.image_name)
         # image type should be PIL.PngImagePlugin.PngImageFile ?
         processed_image = self.run_processor(raw_image)
 
         # currently can't see processed image in node UI without a showImage node,
         #    so for now setting image_type to RESULT instead of INTERMEDIATE so will get saved in gallery
-        image_dto = context.images.save(image=processed_image)
+        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,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
 
         """Builds an ImageOutput and its ImageField"""
         processed_image_field = ImageField(image_name=image_dto.image_name)
@@ -173,7 +180,7 @@ class ImageProcessorInvocation(BaseInvocation, WithMetadata, WithBoard):
     title="Canny Processor",
     tags=["controlnet", "canny"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class CannyImageProcessorInvocation(ImageProcessorInvocation):
     """Canny edge detection for ControlNet"""
@@ -185,10 +192,6 @@ class CannyImageProcessorInvocation(ImageProcessorInvocation):
         default=200, ge=0, le=255, description="The high threshold of the Canny pixel gradient (0-255)"
     )
 
-    def load_image(self, context: InvocationContext) -> Image.Image:
-        # Keep alpha channel for Canny processing to detect edges of transparent areas
-        return context.images.get_pil(self.image.image_name, "RGBA")
-
     def run_processor(self, image):
         canny_processor = CannyDetector()
         processed_image = canny_processor(image, self.low_threshold, self.high_threshold)
@@ -200,7 +203,7 @@ class CannyImageProcessorInvocation(ImageProcessorInvocation):
     title="HED (softedge) Processor",
     tags=["controlnet", "hed", "softedge"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class HedImageProcessorInvocation(ImageProcessorInvocation):
     """Applies HED edge detection to image"""
@@ -229,7 +232,7 @@ class HedImageProcessorInvocation(ImageProcessorInvocation):
     title="Lineart Processor",
     tags=["controlnet", "lineart"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class LineartImageProcessorInvocation(ImageProcessorInvocation):
     """Applies line art processing to image"""
@@ -251,7 +254,7 @@ class LineartImageProcessorInvocation(ImageProcessorInvocation):
     title="Lineart Anime Processor",
     tags=["controlnet", "lineart", "anime"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class LineartAnimeImageProcessorInvocation(ImageProcessorInvocation):
     """Applies line art anime processing to image"""
@@ -269,12 +272,37 @@ class LineartAnimeImageProcessorInvocation(ImageProcessorInvocation):
         return processed_image
 
 
+@invocation(
+    "openpose_image_processor",
+    title="Openpose Processor",
+    tags=["controlnet", "openpose", "pose"],
+    category="controlnet",
+    version="1.2.0",
+)
+class OpenposeImageProcessorInvocation(ImageProcessorInvocation):
+    """Applies Openpose processing to image"""
+
+    hand_and_face: bool = InputField(default=False, description="Whether to use hands and face mode")
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
+
+    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
+
+
 @invocation(
     "midas_depth_image_processor",
     title="Midas Depth Processor",
     tags=["controlnet", "midas"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class MidasDepthImageProcessorInvocation(ImageProcessorInvocation):
     """Applies Midas depth processing to image"""
@@ -301,7 +329,7 @@ class MidasDepthImageProcessorInvocation(ImageProcessorInvocation):
     title="Normal BAE Processor",
     tags=["controlnet"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class NormalbaeImageProcessorInvocation(ImageProcessorInvocation):
     """Applies NormalBae processing to image"""
@@ -318,7 +346,7 @@ class NormalbaeImageProcessorInvocation(ImageProcessorInvocation):
 
 
 @invocation(
-    "mlsd_image_processor", title="MLSD Processor", tags=["controlnet", "mlsd"], category="controlnet", version="1.2.1"
+    "mlsd_image_processor", title="MLSD Processor", tags=["controlnet", "mlsd"], category="controlnet", version="1.2.0"
 )
 class MlsdImageProcessorInvocation(ImageProcessorInvocation):
     """Applies MLSD processing to image"""
@@ -341,7 +369,7 @@ class MlsdImageProcessorInvocation(ImageProcessorInvocation):
 
 
 @invocation(
-    "pidi_image_processor", title="PIDI Processor", tags=["controlnet", "pidi"], category="controlnet", version="1.2.1"
+    "pidi_image_processor", title="PIDI Processor", tags=["controlnet", "pidi"], category="controlnet", version="1.2.0"
 )
 class PidiImageProcessorInvocation(ImageProcessorInvocation):
     """Applies PIDI processing to image"""
@@ -368,7 +396,7 @@ class PidiImageProcessorInvocation(ImageProcessorInvocation):
     title="Content Shuffle Processor",
     tags=["controlnet", "contentshuffle"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class ContentShuffleImageProcessorInvocation(ImageProcessorInvocation):
     """Applies content shuffle processing to image"""
@@ -398,7 +426,7 @@ class ContentShuffleImageProcessorInvocation(ImageProcessorInvocation):
     title="Zoe (Depth) Processor",
     tags=["controlnet", "zoe", "depth"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class ZoeDepthImageProcessorInvocation(ImageProcessorInvocation):
     """Applies Zoe depth processing to image"""
@@ -414,7 +442,7 @@ class ZoeDepthImageProcessorInvocation(ImageProcessorInvocation):
     title="Mediapipe Face Processor",
     tags=["controlnet", "mediapipe", "face"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class MediapipeFaceProcessorInvocation(ImageProcessorInvocation):
     """Applies mediapipe face processing to image"""
@@ -423,6 +451,10 @@ class MediapipeFaceProcessorInvocation(ImageProcessorInvocation):
     min_confidence: float = InputField(default=0.5, ge=0, le=1, description="Minimum confidence for face detection")
 
     def run_processor(self, image):
+        # MediaPipeFaceDetector throws an error if image has alpha channel
+        #     so convert to RGB if needed
+        if image.mode == "RGBA":
+            image = image.convert("RGB")
         mediapipe_face_processor = MediapipeFaceDetector()
         processed_image = mediapipe_face_processor(image, max_faces=self.max_faces, min_confidence=self.min_confidence)
         return processed_image
@@ -433,7 +465,7 @@ class MediapipeFaceProcessorInvocation(ImageProcessorInvocation):
     title="Leres (Depth) Processor",
     tags=["controlnet", "leres", "depth"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class LeresImageProcessorInvocation(ImageProcessorInvocation):
     """Applies leres processing to image"""
@@ -462,7 +494,7 @@ class LeresImageProcessorInvocation(ImageProcessorInvocation):
     title="Tile Resample Processor",
     tags=["controlnet", "tile"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class TileResamplerProcessorInvocation(ImageProcessorInvocation):
     """Tile resampler processor"""
@@ -502,7 +534,7 @@ class TileResamplerProcessorInvocation(ImageProcessorInvocation):
     title="Segment Anything Processor",
     tags=["controlnet", "segmentanything"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class SegmentAnythingProcessorInvocation(ImageProcessorInvocation):
     """Applies segment anything processing to image"""
@@ -544,7 +576,7 @@ class SamDetectorReproducibleColors(SamDetector):
     title="Color Map Processor",
     tags=["controlnet"],
     category="controlnet",
-    version="1.2.1",
+    version="1.2.0",
 )
 class ColorMapImageProcessorInvocation(ImageProcessorInvocation):
     """Generates a color map from the provided image"""
@@ -552,6 +584,7 @@ class ColorMapImageProcessorInvocation(ImageProcessorInvocation):
     color_map_tile_size: int = InputField(default=64, ge=0, description=FieldDescriptions.tile_size)
 
     def run_processor(self, image: Image.Image):
+        image = image.convert("RGB")
         np_image = np.array(image, dtype=np.uint8)
         height, width = np_image.shape[:2]
 
@@ -587,36 +620,12 @@ class DepthAnythingImageProcessorInvocation(ImageProcessorInvocation):
     resolution: int = InputField(default=512, ge=64, multiple_of=64, description=FieldDescriptions.image_res)
     offload: bool = InputField(default=False)
 
-    def run_processor(self, image: Image.Image):
+    def run_processor(self, image):
         depth_anything_detector = DepthAnythingDetector()
         depth_anything_detector.load_model(model_size=self.model_size)
 
+        if image.mode == "RGBA":
+            image = image.convert("RGB")
+
         processed_image = depth_anything_detector(image=image, resolution=self.resolution, offload=self.offload)
         return processed_image
-
-
-@invocation(
-    "dw_openpose_image_processor",
-    title="DW Openpose Image Processor",
-    tags=["controlnet", "dwpose", "openpose"],
-    category="controlnet",
-    version="1.0.0",
-)
-class DWOpenposeImageProcessorInvocation(ImageProcessorInvocation):
-    """Generates an openpose pose from an image using DWPose"""
-
-    draw_body: bool = InputField(default=True)
-    draw_face: bool = InputField(default=False)
-    draw_hands: bool = InputField(default=False)
-    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
-
-    def run_processor(self, image: Image.Image):
-        dw_openpose = DWOpenposeDetector()
-        processed_image = dw_openpose(
-            image,
-            draw_face=self.draw_face,
-            draw_hands=self.draw_hands,
-            draw_body=self.draw_body,
-            resolution=self.image_resolution,
-        )
-        return processed_image

invokeai/app/invocations/cv.py

@@ -5,24 +5,22 @@ import cv2 as cv
 import numpy
 from PIL import Image, ImageOps
 
-from invokeai.app.invocations.fields import ImageField
-from invokeai.app.invocations.primitives import ImageOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.invocations.primitives import ImageField, ImageOutput
+from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
 
-from .baseinvocation import BaseInvocation, invocation
-from .fields import InputField, WithBoard, WithMetadata
+from .baseinvocation import BaseInvocation, InputField, InvocationContext, WithMetadata, invocation
 
 
-@invocation("cv_inpaint", title="OpenCV Inpaint", tags=["opencv", "inpaint"], category="inpaint", version="1.2.1")
-class CvInpaintInvocation(BaseInvocation, WithMetadata, WithBoard):
+@invocation("cv_inpaint", title="OpenCV Inpaint", tags=["opencv", "inpaint"], category="inpaint", version="1.2.0")
+class CvInpaintInvocation(BaseInvocation, WithMetadata):
     """Simple inpaint using opencv."""
 
     image: ImageField = InputField(description="The image to inpaint")
     mask: ImageField = InputField(description="The mask to use when inpainting")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name)
-        mask = context.images.get_pil(self.mask.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
+        mask = context.services.images.get_pil_image(self.mask.image_name)
 
         # Convert to cv image/mask
         # TODO: consider making these utility functions
@@ -36,6 +34,18 @@ class CvInpaintInvocation(BaseInvocation, WithMetadata, WithBoard):
         # TODO: consider making a utility function
         image_inpainted = Image.fromarray(cv.cvtColor(cv_inpainted, cv.COLOR_BGR2RGB))
 
-        image_dto = context.images.save(image=image_inpainted)
+        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,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )

invokeai/app/invocations/facetools.py

@@ -13,13 +13,15 @@ from pydantic import field_validator
 import invokeai.assets.fonts as font_assets
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
+    InputField,
+    InvocationContext,
+    OutputField,
+    WithMetadata,
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import ImageField, InputField, OutputField, WithBoard, WithMetadata
-from invokeai.app.invocations.primitives import ImageOutput
-from invokeai.app.services.image_records.image_records_common import ImageCategory
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.invocations.primitives import ImageField, ImageOutput
+from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
 
 
 @invocation_output("face_mask_output")
@@ -304,37 +306,37 @@ def extract_face(
 
     # Adjust the crop boundaries to stay within the original image's dimensions
     if x_min < 0:
-        context.logger.warning("FaceTools --> -X-axis padding reached image edge.")
+        context.services.logger.warning("FaceTools --> -X-axis padding reached image edge.")
         x_max -= x_min
         x_min = 0
     elif x_max > mask.width:
-        context.logger.warning("FaceTools --> +X-axis padding reached image edge.")
+        context.services.logger.warning("FaceTools --> +X-axis padding reached image edge.")
         x_min -= x_max - mask.width
         x_max = mask.width
 
     if y_min < 0:
-        context.logger.warning("FaceTools --> +Y-axis padding reached image edge.")
+        context.services.logger.warning("FaceTools --> +Y-axis padding reached image edge.")
         y_max -= y_min
         y_min = 0
     elif y_max > mask.height:
-        context.logger.warning("FaceTools --> -Y-axis padding reached image edge.")
+        context.services.logger.warning("FaceTools --> -Y-axis padding reached image edge.")
         y_min -= y_max - mask.height
         y_max = mask.height
 
     # Ensure the crop is square and adjust the boundaries if needed
     if x_max - x_min != crop_size:
-        context.logger.warning("FaceTools --> Limiting x-axis padding to constrain bounding box to a square.")
+        context.services.logger.warning("FaceTools --> Limiting x-axis padding to constrain bounding box to a square.")
         diff = crop_size - (x_max - x_min)
         x_min -= diff // 2
         x_max += diff - diff // 2
 
     if y_max - y_min != crop_size:
-        context.logger.warning("FaceTools --> Limiting y-axis padding to constrain bounding box to a square.")
+        context.services.logger.warning("FaceTools --> Limiting y-axis padding to constrain bounding box to a square.")
         diff = crop_size - (y_max - y_min)
         y_min -= diff // 2
         y_max += diff - diff // 2
 
-    context.logger.info(f"FaceTools --> Calculated bounding box (8 multiple): {crop_size}")
+    context.services.logger.info(f"FaceTools --> Calculated bounding box (8 multiple): {crop_size}")
 
     # Crop the output image to the specified size with the center of the face mesh as the center.
     mask = mask.crop((x_min, y_min, x_max, y_max))
@@ -366,7 +368,7 @@ def get_faces_list(
 
     # Generate the face box mask and get the center of the face.
     if not should_chunk:
-        context.logger.info("FaceTools --> Attempting full image face detection.")
+        context.services.logger.info("FaceTools --> Attempting full image face detection.")
         result = generate_face_box_mask(
             context=context,
             minimum_confidence=minimum_confidence,
@@ -378,7 +380,7 @@ def get_faces_list(
             draw_mesh=draw_mesh,
         )
     if should_chunk or len(result) == 0:
-        context.logger.info("FaceTools --> Chunking image (chunk toggled on, or no face found in full image).")
+        context.services.logger.info("FaceTools --> Chunking image (chunk toggled on, or no face found in full image).")
         width, height = image.size
         image_chunks = []
         x_offsets = []
@@ -397,7 +399,7 @@ def get_faces_list(
                 x_offsets.append(x)
                 y_offsets.append(0)
                 fx += increment
-                context.logger.info(f"FaceTools --> Chunk starting at x = {x}")
+                context.services.logger.info(f"FaceTools --> Chunk starting at x = {x}")
         elif height > width:
             # Portrait - slice the image vertically
             fy = 0.0
@@ -409,10 +411,10 @@ def get_faces_list(
                 x_offsets.append(0)
                 y_offsets.append(y)
                 fy += increment
-                context.logger.info(f"FaceTools --> Chunk starting at y = {y}")
+                context.services.logger.info(f"FaceTools --> Chunk starting at y = {y}")
 
         for idx in range(len(image_chunks)):
-            context.logger.info(f"FaceTools --> Evaluating faces in chunk {idx}")
+            context.services.logger.info(f"FaceTools --> Evaluating faces in chunk {idx}")
             result = result + generate_face_box_mask(
                 context=context,
                 minimum_confidence=minimum_confidence,
@@ -426,7 +428,7 @@ def get_faces_list(
 
         if len(result) == 0:
             # Give up
-            context.logger.warning(
+            context.services.logger.warning(
                 "FaceTools --> No face detected in chunked input image. Passing through original image."
             )
 
@@ -435,7 +437,7 @@ def get_faces_list(
     return all_faces
 
 
-@invocation("face_off", title="FaceOff", tags=["image", "faceoff", "face", "mask"], category="image", version="1.2.1")
+@invocation("face_off", title="FaceOff", tags=["image", "faceoff", "face", "mask"], category="image", version="1.2.0")
 class FaceOffInvocation(BaseInvocation, WithMetadata):
     """Bound, extract, and mask a face from an image using MediaPipe detection"""
 
@@ -468,11 +470,11 @@ class FaceOffInvocation(BaseInvocation, WithMetadata):
         )
 
         if len(all_faces) == 0:
-            context.logger.warning("FaceOff --> No faces detected. Passing through original image.")
+            context.services.logger.warning("FaceOff --> No faces detected. Passing through original image.")
             return None
 
         if self.face_id > len(all_faces) - 1:
-            context.logger.warning(
+            context.services.logger.warning(
                 f"FaceOff --> Face ID {self.face_id} is outside of the number of faces detected ({len(all_faces)}). Passing through original image."
             )
             return None
@@ -484,7 +486,7 @@ class FaceOffInvocation(BaseInvocation, WithMetadata):
         return face_data
 
     def invoke(self, context: InvocationContext) -> FaceOffOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
         result = self.faceoff(context=context, image=image)
 
         if result is None:
@@ -498,9 +500,24 @@ class FaceOffInvocation(BaseInvocation, WithMetadata):
             x = result["x_min"]
             y = result["y_min"]
 
-        image_dto = context.images.save(image=result_image)
+        image_dto = context.services.images.create(
+            image=result_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,
+            workflow=context.workflow,
+        )
 
-        mask_dto = context.images.save(image=result_mask, image_category=ImageCategory.MASK)
+        mask_dto = context.services.images.create(
+            image=result_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,
+        )
 
         output = FaceOffOutput(
             image=ImageField(image_name=image_dto.image_name),
@@ -514,7 +531,7 @@ class FaceOffInvocation(BaseInvocation, WithMetadata):
         return output
 
 
-@invocation("face_mask_detection", title="FaceMask", tags=["image", "face", "mask"], category="image", version="1.2.1")
+@invocation("face_mask_detection", title="FaceMask", tags=["image", "face", "mask"], category="image", version="1.2.0")
 class FaceMaskInvocation(BaseInvocation, WithMetadata):
     """Face mask creation using mediapipe face detection"""
 
@@ -563,7 +580,7 @@ class FaceMaskInvocation(BaseInvocation, WithMetadata):
 
             if len(intersected_face_ids) == 0:
                 id_range_str = ",".join([str(id) for id in id_range])
-                context.logger.warning(
+                context.services.logger.warning(
                     f"Face IDs must be in range of detected faces - requested {self.face_ids}, detected {id_range_str}. Passing through original image."
                 )
                 return FaceMaskResult(
@@ -599,12 +616,27 @@ class FaceMaskInvocation(BaseInvocation, WithMetadata):
         )
 
     def invoke(self, context: InvocationContext) -> FaceMaskOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
         result = self.facemask(context=context, image=image)
 
-        image_dto = context.images.save(image=result["image"])
+        image_dto = context.services.images.create(
+            image=result["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,
+            workflow=context.workflow,
+        )
 
-        mask_dto = context.images.save(image=result["mask"], image_category=ImageCategory.MASK)
+        mask_dto = context.services.images.create(
+            image=result["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,
+        )
 
         output = FaceMaskOutput(
             image=ImageField(image_name=image_dto.image_name),
@@ -617,9 +649,9 @@ class FaceMaskInvocation(BaseInvocation, WithMetadata):
 
 
 @invocation(
-    "face_identifier", title="FaceIdentifier", tags=["image", "face", "identifier"], category="image", version="1.2.1"
+    "face_identifier", title="FaceIdentifier", tags=["image", "face", "identifier"], category="image", version="1.2.0"
 )
-class FaceIdentifierInvocation(BaseInvocation, WithMetadata, WithBoard):
+class FaceIdentifierInvocation(BaseInvocation, WithMetadata):
     """Outputs an image with detected face IDs printed on each face. For use with other FaceTools."""
 
     image: ImageField = InputField(description="Image to face detect")
@@ -673,9 +705,21 @@ class FaceIdentifierInvocation(BaseInvocation, WithMetadata, WithBoard):
         return image
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
         result_image = self.faceidentifier(context=context, image=image)
 
-        image_dto = context.images.save(image=result_image)
+        image_dto = context.services.images.create(
+            image=result_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,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )

invokeai/app/invocations/fields.py

@@ -1,565 +0,0 @@
-from enum import Enum
-from typing import Any, Callable, Optional, Tuple
-
-from pydantic import BaseModel, ConfigDict, Field, RootModel, TypeAdapter
-from pydantic.fields import _Unset
-from pydantic_core import PydanticUndefined
-
-from invokeai.app.util.metaenum import MetaEnum
-from invokeai.backend.util.logging import InvokeAILogger
-
-logger = InvokeAILogger.get_logger()
-
-
-class UIType(str, Enum, metaclass=MetaEnum):
-    """
-    Type hints for the UI for situations in which the field type is not enough to infer the correct UI type.
-
-    - Model Fields
-    The most common node-author-facing use will be for model fields. Internally, there is no difference
-    between SD-1, SD-2 and SDXL model fields - they all use the class `MainModelField`. To ensure the
-    base-model-specific UI is rendered, use e.g. `ui_type=UIType.SDXLMainModelField` to indicate that
-    the field is an SDXL main model field.
-
-    - Any Field
-    We cannot infer the usage of `typing.Any` via schema parsing, so you *must* use `ui_type=UIType.Any` to
-    indicate that the field accepts any type. Use with caution. This cannot be used on outputs.
-
-    - Scheduler Field
-    Special handling in the UI is needed for this field, which otherwise would be parsed as a plain enum field.
-
-    - Internal Fields
-    Similar to the Any Field, the `collect` and `iterate` nodes make use of `typing.Any`. To facilitate
-    handling these types in the client, we use `UIType._Collection` and `UIType._CollectionItem`. These
-    should not be used by node authors.
-
-    - DEPRECATED Fields
-    These types are deprecated and should not be used by node authors. A warning will be logged if one is
-    used, and the type will be ignored. They are included here for backwards compatibility.
-    """
-
-    # region Model Field Types
-    SDXLMainModel = "SDXLMainModelField"
-    SDXLRefinerModel = "SDXLRefinerModelField"
-    ONNXModel = "ONNXModelField"
-    VaeModel = "VAEModelField"
-    LoRAModel = "LoRAModelField"
-    ControlNetModel = "ControlNetModelField"
-    IPAdapterModel = "IPAdapterModelField"
-    # endregion
-
-    # region Misc Field Types
-    Scheduler = "SchedulerField"
-    Any = "AnyField"
-    # endregion
-
-    # region Internal Field Types
-    _Collection = "CollectionField"
-    _CollectionItem = "CollectionItemField"
-    # endregion
-
-    # region DEPRECATED
-    Boolean = "DEPRECATED_Boolean"
-    Color = "DEPRECATED_Color"
-    Conditioning = "DEPRECATED_Conditioning"
-    Control = "DEPRECATED_Control"
-    Float = "DEPRECATED_Float"
-    Image = "DEPRECATED_Image"
-    Integer = "DEPRECATED_Integer"
-    Latents = "DEPRECATED_Latents"
-    String = "DEPRECATED_String"
-    BooleanCollection = "DEPRECATED_BooleanCollection"
-    ColorCollection = "DEPRECATED_ColorCollection"
-    ConditioningCollection = "DEPRECATED_ConditioningCollection"
-    ControlCollection = "DEPRECATED_ControlCollection"
-    FloatCollection = "DEPRECATED_FloatCollection"
-    ImageCollection = "DEPRECATED_ImageCollection"
-    IntegerCollection = "DEPRECATED_IntegerCollection"
-    LatentsCollection = "DEPRECATED_LatentsCollection"
-    StringCollection = "DEPRECATED_StringCollection"
-    BooleanPolymorphic = "DEPRECATED_BooleanPolymorphic"
-    ColorPolymorphic = "DEPRECATED_ColorPolymorphic"
-    ConditioningPolymorphic = "DEPRECATED_ConditioningPolymorphic"
-    ControlPolymorphic = "DEPRECATED_ControlPolymorphic"
-    FloatPolymorphic = "DEPRECATED_FloatPolymorphic"
-    ImagePolymorphic = "DEPRECATED_ImagePolymorphic"
-    IntegerPolymorphic = "DEPRECATED_IntegerPolymorphic"
-    LatentsPolymorphic = "DEPRECATED_LatentsPolymorphic"
-    StringPolymorphic = "DEPRECATED_StringPolymorphic"
-    MainModel = "DEPRECATED_MainModel"
-    UNet = "DEPRECATED_UNet"
-    Vae = "DEPRECATED_Vae"
-    CLIP = "DEPRECATED_CLIP"
-    Collection = "DEPRECATED_Collection"
-    CollectionItem = "DEPRECATED_CollectionItem"
-    Enum = "DEPRECATED_Enum"
-    WorkflowField = "DEPRECATED_WorkflowField"
-    IsIntermediate = "DEPRECATED_IsIntermediate"
-    BoardField = "DEPRECATED_BoardField"
-    MetadataItem = "DEPRECATED_MetadataItem"
-    MetadataItemCollection = "DEPRECATED_MetadataItemCollection"
-    MetadataItemPolymorphic = "DEPRECATED_MetadataItemPolymorphic"
-    MetadataDict = "DEPRECATED_MetadataDict"
-
-
-class UIComponent(str, Enum, metaclass=MetaEnum):
-    """
-    The type of UI component to use for a field, used to override the default components, which are
-    inferred from the field type.
-    """
-
-    None_ = "none"
-    Textarea = "textarea"
-    Slider = "slider"
-
-
-class FieldDescriptions:
-    denoising_start = "When to start denoising, expressed a percentage of total steps"
-    denoising_end = "When to stop denoising, expressed a percentage of total steps"
-    cfg_scale = "Classifier-Free Guidance scale"
-    cfg_rescale_multiplier = "Rescale multiplier for CFG guidance, used for models trained with zero-terminal SNR"
-    scheduler = "Scheduler to use during inference"
-    positive_cond = "Positive conditioning tensor"
-    negative_cond = "Negative conditioning tensor"
-    noise = "Noise tensor"
-    clip = "CLIP (tokenizer, text encoder, LoRAs) and skipped layer count"
-    unet = "UNet (scheduler, LoRAs)"
-    vae = "VAE"
-    cond = "Conditioning tensor"
-    controlnet_model = "ControlNet model to load"
-    vae_model = "VAE model to load"
-    lora_model = "LoRA model to load"
-    main_model = "Main model (UNet, VAE, CLIP) to load"
-    sdxl_main_model = "SDXL Main model (UNet, VAE, CLIP1, CLIP2) to load"
-    sdxl_refiner_model = "SDXL Refiner Main Modde (UNet, VAE, CLIP2) to load"
-    onnx_main_model = "ONNX Main model (UNet, VAE, CLIP) to load"
-    lora_weight = "The weight at which the LoRA is applied to each model"
-    compel_prompt = "Prompt to be parsed by Compel to create a conditioning tensor"
-    raw_prompt = "Raw prompt text (no parsing)"
-    sdxl_aesthetic = "The aesthetic score to apply to the conditioning tensor"
-    skipped_layers = "Number of layers to skip in text encoder"
-    seed = "Seed for random number generation"
-    steps = "Number of steps to run"
-    width = "Width of output (px)"
-    height = "Height of output (px)"
-    control = "ControlNet(s) to apply"
-    ip_adapter = "IP-Adapter to apply"
-    t2i_adapter = "T2I-Adapter(s) to apply"
-    denoised_latents = "Denoised latents tensor"
-    latents = "Latents tensor"
-    strength = "Strength of denoising (proportional to steps)"
-    metadata = "Optional metadata to be saved with the image"
-    metadata_collection = "Collection of Metadata"
-    metadata_item_polymorphic = "A single metadata item or collection of metadata items"
-    metadata_item_label = "Label for this metadata item"
-    metadata_item_value = "The value for this metadata item (may be any type)"
-    workflow = "Optional workflow to be saved with the image"
-    interp_mode = "Interpolation mode"
-    torch_antialias = "Whether or not to apply antialiasing (bilinear or bicubic only)"
-    fp32 = "Whether or not to use full float32 precision"
-    precision = "Precision to use"
-    tiled = "Processing using overlapping tiles (reduce memory consumption)"
-    detect_res = "Pixel resolution for detection"
-    image_res = "Pixel resolution for output image"
-    safe_mode = "Whether or not to use safe mode"
-    scribble_mode = "Whether or not to use scribble mode"
-    scale_factor = "The factor by which to scale"
-    blend_alpha = (
-        "Blending factor. 0.0 = use input A only, 1.0 = use input B only, 0.5 = 50% mix of input A and input B."
-    )
-    num_1 = "The first number"
-    num_2 = "The second number"
-    mask = "The mask to use for the operation"
-    board = "The board to save the image to"
-    image = "The image to process"
-    tile_size = "Tile size"
-    inclusive_low = "The inclusive low value"
-    exclusive_high = "The exclusive high value"
-    decimal_places = "The number of decimal places to round to"
-    freeu_s1 = 'Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to mitigate the "oversmoothing effect" in the enhanced denoising process.'
-    freeu_s2 = 'Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to mitigate the "oversmoothing effect" in the enhanced denoising process.'
-    freeu_b1 = "Scaling factor for stage 1 to amplify the contributions of backbone features."
-    freeu_b2 = "Scaling factor for stage 2 to amplify the contributions of backbone features."
-
-
-class ImageField(BaseModel):
-    """An image primitive field"""
-
-    image_name: str = Field(description="The name of the image")
-
-
-class BoardField(BaseModel):
-    """A board primitive field"""
-
-    board_id: str = Field(description="The id of the board")
-
-
-class DenoiseMaskField(BaseModel):
-    """An inpaint mask field"""
-
-    mask_name: str = Field(description="The name of the mask image")
-    masked_latents_name: Optional[str] = Field(default=None, description="The name of the masked image latents")
-
-
-class LatentsField(BaseModel):
-    """A latents tensor primitive field"""
-
-    latents_name: str = Field(description="The name of the latents")
-    seed: Optional[int] = Field(default=None, description="Seed used to generate this latents")
-
-
-class ColorField(BaseModel):
-    """A color primitive field"""
-
-    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 ConditioningField(BaseModel):
-    """A conditioning tensor primitive value"""
-
-    conditioning_name: str = Field(description="The name of conditioning tensor")
-    # endregion
-
-
-class MetadataField(RootModel):
-    """
-    Pydantic model for metadata with custom root of type dict[str, Any].
-    Metadata is stored without a strict schema.
-    """
-
-    root: dict[str, Any] = Field(description="The metadata")
-
-
-MetadataFieldValidator = TypeAdapter(MetadataField)
-
-
-class Input(str, Enum, metaclass=MetaEnum):
-    """
-    The type of input a field accepts.
-    - `Input.Direct`: The field must have its value provided directly, when the invocation and field \
-      are instantiated.
-    - `Input.Connection`: The field must have its value provided by a connection.
-    - `Input.Any`: The field may have its value provided either directly or by a connection.
-    """
-
-    Connection = "connection"
-    Direct = "direct"
-    Any = "any"
-
-
-class FieldKind(str, Enum, metaclass=MetaEnum):
-    """
-    The kind of field.
-    - `Input`: An input field on a node.
-    - `Output`: An output field on a node.
-    - `Internal`: A field which is treated as an input, but cannot be used in node definitions. Metadata is
-    one example. It is provided to nodes via the WithMetadata class, and we want to reserve the field name
-    "metadata" for this on all nodes. `FieldKind` is used to short-circuit the field name validation logic,
-    allowing "metadata" for that field.
-    - `NodeAttribute`: The field is a node attribute. These are fields which are not inputs or outputs,
-    but which are used to store information about the node. For example, the `id` and `type` fields are node
-    attributes.
-
-    The presence of this in `json_schema_extra["field_kind"]` is used when initializing node schemas on app
-    startup, and when generating the OpenAPI schema for the workflow editor.
-    """
-
-    Input = "input"
-    Output = "output"
-    Internal = "internal"
-    NodeAttribute = "node_attribute"
-
-
-class InputFieldJSONSchemaExtra(BaseModel):
-    """
-    Extra attributes to be added to input fields and their OpenAPI schema. Used during graph execution,
-    and by the workflow editor during schema parsing and UI rendering.
-    """
-
-    input: Input
-    orig_required: bool
-    field_kind: FieldKind
-    default: Optional[Any] = None
-    orig_default: Optional[Any] = None
-    ui_hidden: bool = False
-    ui_type: Optional[UIType] = None
-    ui_component: Optional[UIComponent] = None
-    ui_order: Optional[int] = None
-    ui_choice_labels: Optional[dict[str, str]] = None
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        json_schema_serialization_defaults_required=True,
-    )
-
-
-class WithMetadata(BaseModel):
-    """
-    Inherit from this class if your node needs a metadata input field.
-    """
-
-    metadata: Optional[MetadataField] = Field(
-        default=None,
-        description=FieldDescriptions.metadata,
-        json_schema_extra=InputFieldJSONSchemaExtra(
-            field_kind=FieldKind.Internal,
-            input=Input.Connection,
-            orig_required=False,
-        ).model_dump(exclude_none=True),
-    )
-
-
-class WithWorkflow:
-    workflow = None
-
-    def __init_subclass__(cls) -> None:
-        logger.warn(
-            f"{cls.__module__.split('.')[0]}.{cls.__name__}: WithWorkflow is deprecated. Use `context.workflow` to access the workflow."
-        )
-        super().__init_subclass__()
-
-
-class WithBoard(BaseModel):
-    """
-    Inherit from this class if your node needs a board input field.
-    """
-
-    board: Optional[BoardField] = Field(
-        default=None,
-        description=FieldDescriptions.board,
-        json_schema_extra=InputFieldJSONSchemaExtra(
-            field_kind=FieldKind.Internal,
-            input=Input.Direct,
-            orig_required=False,
-        ).model_dump(exclude_none=True),
-    )
-
-
-class OutputFieldJSONSchemaExtra(BaseModel):
-    """
-    Extra attributes to be added to input fields and their OpenAPI schema. Used by the workflow editor
-    during schema parsing and UI rendering.
-    """
-
-    field_kind: FieldKind
-    ui_hidden: bool
-    ui_type: Optional[UIType]
-    ui_order: Optional[int]
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        json_schema_serialization_defaults_required=True,
-    )
-
-
-def InputField(
-    # copied from pydantic's Field
-    # TODO: Can we support default_factory?
-    default: Any = _Unset,
-    default_factory: Callable[[], Any] | None = _Unset,
-    title: str | None = _Unset,
-    description: str | None = _Unset,
-    pattern: str | None = _Unset,
-    strict: bool | None = _Unset,
-    gt: float | None = _Unset,
-    ge: float | None = _Unset,
-    lt: float | None = _Unset,
-    le: float | None = _Unset,
-    multiple_of: float | None = _Unset,
-    allow_inf_nan: bool | None = _Unset,
-    max_digits: int | None = _Unset,
-    decimal_places: int | None = _Unset,
-    min_length: int | None = _Unset,
-    max_length: int | None = _Unset,
-    # custom
-    input: Input = Input.Any,
-    ui_type: Optional[UIType] = None,
-    ui_component: Optional[UIComponent] = None,
-    ui_hidden: bool = False,
-    ui_order: Optional[int] = None,
-    ui_choice_labels: Optional[dict[str, str]] = None,
-) -> Any:
-    """
-    Creates an input field for an invocation.
-
-    This is a wrapper for Pydantic's [Field](https://docs.pydantic.dev/latest/api/fields/#pydantic.fields.Field) \
-    that adds a few extra parameters to support graph execution and the node editor UI.
-
-    :param Input input: [Input.Any] The kind of input this field requires. \
-      `Input.Direct` means a value must be provided on instantiation. \
-      `Input.Connection` means the value must be provided by a connection. \
-      `Input.Any` means either will do.
-
-    :param UIType ui_type: [None] Optionally provides an extra type hint for the UI. \
-      In some situations, the field's type is not enough to infer the correct UI type. \
-      For example, model selection fields should render a dropdown UI component to select a model. \
-      Internally, there is no difference between SD-1, SD-2 and SDXL model fields, they all use \
-      `MainModelField`. So to ensure the base-model-specific UI is rendered, you can use \
-      `UIType.SDXLMainModelField` to indicate that the field is an SDXL main model field.
-
-    :param UIComponent ui_component: [None] Optionally specifies a specific component to use in the UI. \
-      The UI will always render a suitable component, but sometimes you want something different than the default. \
-      For example, a `string` field will default to a single-line input, but you may want a multi-line textarea instead. \
-      For this case, you could provide `UIComponent.Textarea`.
-
-    :param bool ui_hidden: [False] Specifies whether or not this field should be hidden in the UI.
-
-    :param int ui_order: [None] Specifies the order in which this field should be rendered in the UI.
-
-    :param dict[str, str] ui_choice_labels: [None] Specifies the labels to use for the choices in an enum field.
-    """
-
-    json_schema_extra_ = InputFieldJSONSchemaExtra(
-        input=input,
-        ui_type=ui_type,
-        ui_component=ui_component,
-        ui_hidden=ui_hidden,
-        ui_order=ui_order,
-        ui_choice_labels=ui_choice_labels,
-        field_kind=FieldKind.Input,
-        orig_required=True,
-    )
-
-    """
-    There is a conflict between the typing of invocation definitions and the typing of an invocation's
-    `invoke()` function.
-
-    On instantiation of a node, the invocation definition is used to create the python class. At this time,
-    any number of fields may be optional, because they may be provided by connections.
-
-    On calling of `invoke()`, however, those fields may be required.
-
-    For example, consider an ResizeImageInvocation with an `image: ImageField` field.
-
-    `image` is required during the call to `invoke()`, but when the python class is instantiated,
-    the field may not be present. This is fine, because that image field will be provided by a
-    connection from an ancestor node, which outputs an image.
-
-    This means we want to type the `image` field as optional for the node class definition, but required
-    for the `invoke()` function.
-
-    If we use `typing.Optional` in the node class definition, the field will be typed as optional in the
-    `invoke()` method, and we'll have to do a lot of runtime checks to ensure the field is present - or
-    any static type analysis tools will complain.
-
-    To get around this, in node class definitions, we type all fields correctly for the `invoke()` function,
-    but secretly make them optional in `InputField()`. We also store the original required bool and/or default
-    value. When we call `invoke()`, we use this stored information to do an additional check on the class.
-    """
-
-    if default_factory is not _Unset and default_factory is not None:
-        default = default_factory()
-        logger.warn('"default_factory" is not supported, calling it now to set "default"')
-
-    # These are the args we may wish pass to the pydantic `Field()` function
-    field_args = {
-        "default": default,
-        "title": title,
-        "description": description,
-        "pattern": pattern,
-        "strict": strict,
-        "gt": gt,
-        "ge": ge,
-        "lt": lt,
-        "le": le,
-        "multiple_of": multiple_of,
-        "allow_inf_nan": allow_inf_nan,
-        "max_digits": max_digits,
-        "decimal_places": decimal_places,
-        "min_length": min_length,
-        "max_length": max_length,
-    }
-
-    # We only want to pass the args that were provided, otherwise the `Field()`` function won't work as expected
-    provided_args = {k: v for (k, v) in field_args.items() if v is not PydanticUndefined}
-
-    # Because we are manually making fields optional, we need to store the original required bool for reference later
-    json_schema_extra_.orig_required = default is PydanticUndefined
-
-    # Make Input.Any and Input.Connection fields optional, providing None as a default if the field doesn't already have one
-    if input is Input.Any or input is Input.Connection:
-        default_ = None if default is PydanticUndefined else default
-        provided_args.update({"default": default_})
-        if default is not PydanticUndefined:
-            # Before invoking, we'll check for the original default value and set it on the field if the field has no value
-            json_schema_extra_.default = default
-            json_schema_extra_.orig_default = default
-    elif default is not PydanticUndefined:
-        default_ = default
-        provided_args.update({"default": default_})
-        json_schema_extra_.orig_default = default_
-
-    return Field(
-        **provided_args,
-        json_schema_extra=json_schema_extra_.model_dump(exclude_none=True),
-    )
-
-
-def OutputField(
-    # copied from pydantic's Field
-    default: Any = _Unset,
-    title: str | None = _Unset,
-    description: str | None = _Unset,
-    pattern: str | None = _Unset,
-    strict: bool | None = _Unset,
-    gt: float | None = _Unset,
-    ge: float | None = _Unset,
-    lt: float | None = _Unset,
-    le: float | None = _Unset,
-    multiple_of: float | None = _Unset,
-    allow_inf_nan: bool | None = _Unset,
-    max_digits: int | None = _Unset,
-    decimal_places: int | None = _Unset,
-    min_length: int | None = _Unset,
-    max_length: int | None = _Unset,
-    # custom
-    ui_type: Optional[UIType] = None,
-    ui_hidden: bool = False,
-    ui_order: Optional[int] = None,
-) -> Any:
-    """
-    Creates an output field for an invocation output.
-
-    This is a wrapper for Pydantic's [Field](https://docs.pydantic.dev/1.10/usage/schema/#field-customization) \
-    that adds a few extra parameters to support graph execution and the node editor UI.
-
-    :param UIType ui_type: [None] Optionally provides an extra type hint for the UI. \
-      In some situations, the field's type is not enough to infer the correct UI type. \
-      For example, model selection fields should render a dropdown UI component to select a model. \
-      Internally, there is no difference between SD-1, SD-2 and SDXL model fields, they all use \
-      `MainModelField`. So to ensure the base-model-specific UI is rendered, you can use \
-      `UIType.SDXLMainModelField` to indicate that the field is an SDXL main model field.
-
-    :param bool ui_hidden: [False] Specifies whether or not this field should be hidden in the UI. \
-
-    :param int ui_order: [None] Specifies the order in which this field should be rendered in the UI. \
-    """
-    return Field(
-        default=default,
-        title=title,
-        description=description,
-        pattern=pattern,
-        strict=strict,
-        gt=gt,
-        ge=ge,
-        lt=lt,
-        le=le,
-        multiple_of=multiple_of,
-        allow_inf_nan=allow_inf_nan,
-        max_digits=max_digits,
-        decimal_places=decimal_places,
-        min_length=min_length,
-        max_length=max_length,
-        json_schema_extra=OutputFieldJSONSchemaExtra(
-            ui_type=ui_type,
-            ui_hidden=ui_hidden,
-            ui_order=ui_order,
-            field_kind=FieldKind.Output,
-        ).model_dump(exclude_none=True),
-    )

invokeai/app/invocations/infill.py

@@ -6,16 +6,14 @@ from typing import Literal, Optional, get_args
 import numpy as np
 from PIL import Image, ImageOps
 
-from invokeai.app.invocations.fields import ColorField, ImageField
-from invokeai.app.invocations.primitives import ImageOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.invocations.primitives import ColorField, ImageField, ImageOutput
+from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
 from invokeai.app.util.misc import SEED_MAX
 from invokeai.backend.image_util.cv2_inpaint import cv2_inpaint
 from invokeai.backend.image_util.lama import LaMA
 from invokeai.backend.image_util.patchmatch import PatchMatch
 
-from .baseinvocation import BaseInvocation, invocation
-from .fields import InputField, WithBoard, WithMetadata
+from .baseinvocation import BaseInvocation, InputField, InvocationContext, WithMetadata, invocation
 from .image import PIL_RESAMPLING_MAP, PIL_RESAMPLING_MODES
 
 
@@ -120,8 +118,8 @@ def tile_fill_missing(im: Image.Image, tile_size: int = 16, seed: Optional[int]
     return si
 
 
-@invocation("infill_rgba", title="Solid Color Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.1")
-class InfillColorInvocation(BaseInvocation, WithMetadata, WithBoard):
+@invocation("infill_rgba", title="Solid Color Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.0")
+class InfillColorInvocation(BaseInvocation, WithMetadata):
     """Infills transparent areas of an image with a solid color"""
 
     image: ImageField = InputField(description="The image to infill")
@@ -131,20 +129,33 @@ class InfillColorInvocation(BaseInvocation, WithMetadata, WithBoard):
     )
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
 
         solid_bg = Image.new("RGBA", image.size, self.color.tuple())
         infilled = Image.alpha_composite(solid_bg, image.convert("RGBA"))
 
         infilled.paste(image, (0, 0), image.split()[-1])
 
-        image_dto = context.images.save(image=infilled)
+        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,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )
 
 
-@invocation("infill_tile", title="Tile Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.2")
-class InfillTileInvocation(BaseInvocation, WithMetadata, WithBoard):
+@invocation("infill_tile", title="Tile Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.1")
+class InfillTileInvocation(BaseInvocation, WithMetadata):
     """Infills transparent areas of an image with tiles of the image"""
 
     image: ImageField = InputField(description="The image to infill")
@@ -157,20 +168,33 @@ class InfillTileInvocation(BaseInvocation, WithMetadata, WithBoard):
     )
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
 
         infilled = tile_fill_missing(image.copy(), seed=self.seed, tile_size=self.tile_size)
         infilled.paste(image, (0, 0), image.split()[-1])
 
-        image_dto = context.images.save(image=infilled)
+        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,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )
 
 
 @invocation(
-    "infill_patchmatch", title="PatchMatch Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.1"
+    "infill_patchmatch", title="PatchMatch Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.0"
 )
-class InfillPatchMatchInvocation(BaseInvocation, WithMetadata, WithBoard):
+class InfillPatchMatchInvocation(BaseInvocation, WithMetadata):
     """Infills transparent areas of an image using the PatchMatch algorithm"""
 
     image: ImageField = InputField(description="The image to infill")
@@ -178,7 +202,7 @@ class InfillPatchMatchInvocation(BaseInvocation, WithMetadata, WithBoard):
     resample_mode: PIL_RESAMPLING_MODES = InputField(default="bicubic", description="The resampling mode")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name).convert("RGBA")
+        image = context.services.images.get_pil_image(self.image.image_name).convert("RGBA")
 
         resample_mode = PIL_RESAMPLING_MAP[self.resample_mode]
 
@@ -203,38 +227,77 @@ class InfillPatchMatchInvocation(BaseInvocation, WithMetadata, WithBoard):
         infilled.paste(image, (0, 0), mask=image.split()[-1])
         # image.paste(infilled, (0, 0), mask=image.split()[-1])
 
-        image_dto = context.images.save(image=infilled)
+        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,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )
 
 
-@invocation("infill_lama", title="LaMa Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.1")
-class LaMaInfillInvocation(BaseInvocation, WithMetadata, WithBoard):
+@invocation("infill_lama", title="LaMa Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.0")
+class LaMaInfillInvocation(BaseInvocation, WithMetadata):
     """Infills transparent areas of an image using the LaMa model"""
 
     image: ImageField = InputField(description="The image to infill")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
 
         infilled = infill_lama(image.copy())
 
-        image_dto = context.images.save(image=infilled)
+        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,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )
 
 
-@invocation("infill_cv2", title="CV2 Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.1")
-class CV2InfillInvocation(BaseInvocation, WithMetadata, WithBoard):
+@invocation("infill_cv2", title="CV2 Infill", tags=["image", "inpaint"], category="inpaint", version="1.2.0")
+class CV2InfillInvocation(BaseInvocation, WithMetadata):
     """Infills transparent areas of an image using OpenCV Inpainting"""
 
     image: ImageField = InputField(description="The image to infill")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
 
         infilled = infill_cv2(image.copy())
 
-        image_dto = context.images.save(image=infilled)
+        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,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )

invokeai/app/invocations/ip_adapter.py

@@ -7,14 +7,17 @@ from typing_extensions import Self
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
 from invokeai.app.invocations.primitives import ImageField
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
-from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.config import BaseModelType, ModelType
+from invokeai.app.shared.fields import FieldDescriptions
+from invokeai.backend.model_manager import BaseModelType, ModelType
 
 
 # LS: Consider moving these two classes into model.py
@@ -56,7 +59,7 @@ class IPAdapterOutput(BaseInvocationOutput):
     ip_adapter: IPAdapterField = OutputField(description=FieldDescriptions.ip_adapter, title="IP-Adapter")
 
 
-@invocation("ip_adapter", title="IP-Adapter", tags=["ip_adapter", "control"], category="ip_adapter", version="1.1.2")
+@invocation("ip_adapter", title="IP-Adapter", tags=["ip_adapter", "control"], category="ip_adapter", version="1.1.1")
 class IPAdapterInvocation(BaseInvocation):
     """Collects IP-Adapter info to pass to other nodes."""
 
@@ -89,10 +92,10 @@ class IPAdapterInvocation(BaseInvocation):
 
     def invoke(self, context: InvocationContext) -> IPAdapterOutput:
         # Lookup the CLIP Vision encoder that is intended to be used with the IP-Adapter model.
-        ip_adapter_info = context.models.get_config(self.ip_adapter_model.key)
+        ip_adapter_info = context.services.model_manager.store.get_model(self.ip_adapter_model.key)
         image_encoder_model_id = ip_adapter_info.image_encoder_model_id
         image_encoder_model_name = image_encoder_model_id.split("/")[-1].strip()
-        image_encoder_models = context.models.search_by_attrs(
+        image_encoder_models = context.services.model_manager.store.search_by_attr(
             model_name=image_encoder_model_name, base_model=BaseModelType.Any, model_type=ModelType.CLIPVision
         )
         assert len(image_encoder_models) == 1

invokeai/app/invocations/latent.py

@@ -27,29 +27,21 @@ from PIL import Image
 from pydantic import field_validator
 from torchvision.transforms.functional import resize as tv_resize
 
-from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR, SCHEDULER_NAME_VALUES
-from invokeai.app.invocations.fields import (
-    ConditioningField,
-    DenoiseMaskField,
-    FieldDescriptions,
-    ImageField,
-    Input,
-    InputField,
-    LatentsField,
-    OutputField,
-    UIType,
-    WithBoard,
-    WithMetadata,
-)
 from invokeai.app.invocations.ip_adapter import IPAdapterField
 from invokeai.app.invocations.primitives import (
+    DenoiseMaskField,
     DenoiseMaskOutput,
+    ImageField,
     ImageOutput,
+    LatentsField,
     LatentsOutput,
+    build_latents_output,
 )
 from invokeai.app.invocations.t2i_adapter import T2IAdapterField
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.util.controlnet_utils import prepare_control_image
+from invokeai.app.util.step_callback import stable_diffusion_step_callback
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter, IPAdapterPlus
 from invokeai.backend.lora import LoRAModelRaw
 from invokeai.backend.model_manager import BaseModelType, LoadedModel
@@ -71,9 +63,16 @@ from ...backend.util.devices import choose_precision, choose_torch_device
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
+    UIType,
+    WithMetadata,
     invocation,
     invocation_output,
 )
+from .compel import ConditioningField
 from .controlnet_image_processors import ControlField
 from .model import ModelInfo, UNetField, VaeField
 
@@ -82,10 +81,20 @@ if choose_torch_device() == torch.device("mps"):
 
 DEFAULT_PRECISION = choose_precision(choose_torch_device())
 
+SAMPLER_NAME_VALUES = Literal[
+    tuple(SCHEDULER_MAP.keys())
+]  # FIXME: "Invalid type alias". This defeats static type checking.
+
+# HACK: Many nodes are currently hard-coded to use a fixed latent scale factor of 8. This is fragile, and will need to
+# be addressed if future models use a different latent scale factor. Also, note that there may be places where the scale
+# factor is hard-coded to a literal '8' rather than using this constant.
+# The ratio of image:latent dimensions is LATENT_SCALE_FACTOR:1, or 8:1.
+LATENT_SCALE_FACTOR = 8
+
 
 @invocation_output("scheduler_output")
 class SchedulerOutput(BaseInvocationOutput):
-    scheduler: SCHEDULER_NAME_VALUES = OutputField(description=FieldDescriptions.scheduler, ui_type=UIType.Scheduler)
+    scheduler: SAMPLER_NAME_VALUES = OutputField(description=FieldDescriptions.scheduler, ui_type=UIType.Scheduler)
 
 
 @invocation(
@@ -98,7 +107,7 @@ class SchedulerOutput(BaseInvocationOutput):
 class SchedulerInvocation(BaseInvocation):
     """Selects a scheduler."""
 
-    scheduler: SCHEDULER_NAME_VALUES = InputField(
+    scheduler: SAMPLER_NAME_VALUES = InputField(
         default="euler",
         description=FieldDescriptions.scheduler,
         ui_type=UIType.Scheduler,
@@ -113,7 +122,7 @@ class SchedulerInvocation(BaseInvocation):
     title="Create Denoise Mask",
     tags=["mask", "denoise"],
     category="latents",
-    version="1.0.1",
+    version="1.0.0",
 )
 class CreateDenoiseMaskInvocation(BaseInvocation):
     """Creates mask for denoising model run."""
@@ -141,7 +150,7 @@ class CreateDenoiseMaskInvocation(BaseInvocation):
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> DenoiseMaskOutput:
         if self.image is not None:
-            image = context.images.get_pil(self.image.image_name)
+            image = context.services.images.get_pil_image(self.image.image_name)
             image_tensor = image_resized_to_grid_as_tensor(image.convert("RGB"))
             if image_tensor.dim() == 3:
                 image_tensor = image_tensor.unsqueeze(0)
@@ -149,26 +158,33 @@ class CreateDenoiseMaskInvocation(BaseInvocation):
             image_tensor = None
 
         mask = self.prep_mask_tensor(
-            context.images.get_pil(self.mask.image_name),
+            context.services.images.get_pil_image(self.mask.image_name),
         )
 
         if image_tensor is not None:
-            vae_info = context.models.load(**self.vae.vae.model_dump())
+            vae_info = context.services.model_manager.load_model_by_key(
+                **self.vae.vae.model_dump(),
+                context=context,
+            )
 
             img_mask = tv_resize(mask, image_tensor.shape[-2:], T.InterpolationMode.BILINEAR, antialias=False)
             masked_image = image_tensor * torch.where(img_mask < 0.5, 0.0, 1.0)
             # TODO:
             masked_latents = ImageToLatentsInvocation.vae_encode(vae_info, self.fp32, self.tiled, masked_image.clone())
 
-            masked_latents_name = context.tensors.save(tensor=masked_latents)
+            masked_latents_name = f"{context.graph_execution_state_id}__{self.id}_masked_latents"
+            context.services.latents.save(masked_latents_name, masked_latents)
         else:
             masked_latents_name = None
 
-        mask_name = context.tensors.save(tensor=mask)
+        mask_name = f"{context.graph_execution_state_id}__{self.id}_mask"
+        context.services.latents.save(mask_name, mask)
 
-        return DenoiseMaskOutput.build(
-            mask_name=mask_name,
-            masked_latents_name=masked_latents_name,
+        return DenoiseMaskOutput(
+            denoise_mask=DenoiseMaskField(
+                mask_name=mask_name,
+                masked_latents_name=masked_latents_name,
+            ),
         )
 
 
@@ -179,7 +195,10 @@ def get_scheduler(
     seed: int,
 ) -> Scheduler:
     scheduler_class, scheduler_extra_config = SCHEDULER_MAP.get(scheduler_name, SCHEDULER_MAP["ddim"])
-    orig_scheduler_info = context.models.load(**scheduler_info.model_dump())
+    orig_scheduler_info = context.services.model_manager.load_model_by_key(
+        **scheduler_info.model_dump(),
+        context=context,
+    )
     with orig_scheduler_info as orig_scheduler:
         scheduler_config = orig_scheduler.config
 
@@ -209,7 +228,7 @@ def get_scheduler(
     title="Denoise Latents",
     tags=["latents", "denoise", "txt2img", "t2i", "t2l", "img2img", "i2i", "l2l"],
     category="latents",
-    version="1.5.2",
+    version="1.5.1",
 )
 class DenoiseLatentsInvocation(BaseInvocation):
     """Denoises noisy latents to decodable images"""
@@ -237,7 +256,7 @@ class DenoiseLatentsInvocation(BaseInvocation):
         description=FieldDescriptions.denoising_start,
     )
     denoising_end: float = InputField(default=1.0, ge=0, le=1, description=FieldDescriptions.denoising_end)
-    scheduler: SCHEDULER_NAME_VALUES = InputField(
+    scheduler: SAMPLER_NAME_VALUES = InputField(
         default="euler",
         description=FieldDescriptions.scheduler,
         ui_type=UIType.Scheduler,
@@ -295,6 +314,22 @@ class DenoiseLatentsInvocation(BaseInvocation):
                 raise ValueError("cfg_scale must be greater than 1")
         return v
 
+    # 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,
+        base_model: BaseModelType,
+    ) -> None:
+        stable_diffusion_step_callback(
+            context=context,
+            intermediate_state=intermediate_state,
+            node=self.model_dump(),
+            source_node_id=source_node_id,
+            base_model=base_model,
+        )
+
     def get_conditioning_data(
         self,
         context: InvocationContext,
@@ -302,11 +337,11 @@ class DenoiseLatentsInvocation(BaseInvocation):
         unet: UNet2DConditionModel,
         seed: int,
     ) -> ConditioningData:
-        positive_cond_data = context.conditioning.load(self.positive_conditioning.conditioning_name)
+        positive_cond_data = context.services.latents.get(self.positive_conditioning.conditioning_name)
         c = positive_cond_data.conditionings[0].to(device=unet.device, dtype=unet.dtype)
         extra_conditioning_info = c.extra_conditioning
 
-        negative_cond_data = context.conditioning.load(self.negative_conditioning.conditioning_name)
+        negative_cond_data = context.services.latents.get(self.negative_conditioning.conditioning_name)
         uc = negative_cond_data.conditionings[0].to(device=unet.device, dtype=unet.dtype)
 
         conditioning_data = ConditioningData(
@@ -393,11 +428,16 @@ class DenoiseLatentsInvocation(BaseInvocation):
         #        and if weight is None, populate with default 1.0?
         controlnet_data = []
         for control_info in control_list:
-            control_model = exit_stack.enter_context(context.models.load(key=control_info.control_model.key))
+            control_model = exit_stack.enter_context(
+                context.services.model_manager.load_model_by_key(
+                    key=control_info.control_model.key,
+                    context=context,
+                )
+            )
 
             # control_models.append(control_model)
             control_image_field = control_info.image
-            input_image = context.images.get_pil(control_image_field.image_name)
+            input_image = context.services.images.get_pil_image(control_image_field.image_name)
             # self.image.image_type, self.image.image_name
             # FIXME: still need to test with different widths, heights, devices, dtypes
             #        and add in batch_size, num_images_per_prompt?
@@ -455,17 +495,25 @@ class DenoiseLatentsInvocation(BaseInvocation):
         conditioning_data.ip_adapter_conditioning = []
         for single_ip_adapter in ip_adapter:
             ip_adapter_model: Union[IPAdapter, IPAdapterPlus] = exit_stack.enter_context(
-                context.models.load(key=single_ip_adapter.ip_adapter_model.key)
+                context.services.model_manager.load_model_by_key(
+                    key=single_ip_adapter.ip_adapter_model.key,
+                    context=context,
+                )
             )
 
-            image_encoder_model_info = context.models.load(key=single_ip_adapter.image_encoder_model.key)
+            image_encoder_model_info = context.services.model_manager.load_model_by_key(
+                key=single_ip_adapter.image_encoder_model.key,
+                context=context,
+            )
 
             # `single_ip_adapter.image` could be a list or a single ImageField. Normalize to a list here.
             single_ipa_image_fields = single_ip_adapter.image
             if not isinstance(single_ipa_image_fields, list):
                 single_ipa_image_fields = [single_ipa_image_fields]
 
-            single_ipa_images = [context.images.get_pil(image.image_name) for image in single_ipa_image_fields]
+            single_ipa_images = [
+                context.services.images.get_pil_image(image.image_name) for image in single_ipa_image_fields
+            ]
 
             # TODO(ryand): With some effort, the step of running the CLIP Vision encoder could be done before any other
             # models are needed in memory. This would help to reduce peak memory utilization in low-memory environments.
@@ -509,20 +557,22 @@ class DenoiseLatentsInvocation(BaseInvocation):
 
         t2i_adapter_data = []
         for t2i_adapter_field in t2i_adapter:
-            t2i_adapter_model_config = context.models.get_config(key=t2i_adapter_field.t2i_adapter_model.key)
-            t2i_adapter_loaded_model = context.models.load(key=t2i_adapter_field.t2i_adapter_model.key)
-            image = context.images.get_pil(t2i_adapter_field.image.image_name)
+            t2i_adapter_model_info = context.services.model_manager.load_model_by_key(
+                key=t2i_adapter_field.t2i_adapter_model.key,
+                context=context,
+            )
+            image = context.services.images.get_pil_image(t2i_adapter_field.image.image_name)
 
             # The max_unet_downscale is the maximum amount that the UNet model downscales the latent image internally.
-            if t2i_adapter_model_config.base == BaseModelType.StableDiffusion1:
+            if t2i_adapter_model_info.base == BaseModelType.StableDiffusion1:
                 max_unet_downscale = 8
-            elif t2i_adapter_model_config.base == BaseModelType.StableDiffusionXL:
+            elif t2i_adapter_model_info.base == BaseModelType.StableDiffusionXL:
                 max_unet_downscale = 4
             else:
-                raise ValueError(f"Unexpected T2I-Adapter base model type: '{t2i_adapter_model_config.base}'.")
+                raise ValueError(f"Unexpected T2I-Adapter base model type: '{t2i_adapter_model_info.base}'.")
 
             t2i_adapter_model: T2IAdapter
-            with t2i_adapter_loaded_model as t2i_adapter_model:
+            with t2i_adapter_model_info as t2i_adapter_model:
                 total_downscale_factor = t2i_adapter_model.total_downscale_factor
 
                 # Resize the T2I-Adapter input image.
@@ -610,10 +660,10 @@ class DenoiseLatentsInvocation(BaseInvocation):
         if self.denoise_mask is None:
             return None, None
 
-        mask = context.tensors.load(self.denoise_mask.mask_name)
+        mask = context.services.latents.get(self.denoise_mask.mask_name)
         mask = tv_resize(mask, latents.shape[-2:], T.InterpolationMode.BILINEAR, antialias=False)
         if self.denoise_mask.masked_latents_name is not None:
-            masked_latents = context.tensors.load(self.denoise_mask.masked_latents_name)
+            masked_latents = context.services.latents.get(self.denoise_mask.masked_latents_name)
         else:
             masked_latents = None
 
@@ -625,11 +675,11 @@ class DenoiseLatentsInvocation(BaseInvocation):
             seed = None
             noise = None
             if self.noise is not None:
-                noise = context.tensors.load(self.noise.latents_name)
+                noise = context.services.latents.get(self.noise.latents_name)
                 seed = self.noise.seed
 
             if self.latents is not None:
-                latents = context.tensors.load(self.latents.latents_name)
+                latents = context.services.latents.get(self.latents.latents_name)
                 if seed is None:
                     seed = self.latents.seed
 
@@ -655,20 +705,30 @@ class DenoiseLatentsInvocation(BaseInvocation):
                 do_classifier_free_guidance=True,
             )
 
+            # 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]
+
             # get the unet's config so that we can pass the base to dispatch_progress()
-            unet_config = context.models.get_config(self.unet.unet.key)
+            unet_config = context.services.model_manager.store.get_model(self.unet.unet.key)
 
             def step_callback(state: PipelineIntermediateState) -> None:
-                context.util.sd_step_callback(state, unet_config.base)
+                self.dispatch_progress(context, source_node_id, state, unet_config.base)
 
             def _lora_loader() -> Iterator[Tuple[LoRAModelRaw, float]]:
                 for lora in self.unet.loras:
-                    lora_info = context.models.load(**lora.model_dump(exclude={"weight"}))
+                    lora_info = context.services.model_manager.load_model_by_key(
+                        **lora.model_dump(exclude={"weight"}),
+                        context=context,
+                    )
                     yield (lora_info.model, lora.weight)
                     del lora_info
                 return
 
-            unet_info = context.models.load(**self.unet.unet.model_dump())
+            unet_info = context.services.model_manager.load_model_by_key(
+                **self.unet.unet.model_dump(),
+                context=context,
+            )
             assert isinstance(unet_info.model, UNet2DConditionModel)
             with (
                 ExitStack() as exit_stack,
@@ -746,8 +806,9 @@ class DenoiseLatentsInvocation(BaseInvocation):
             if choose_torch_device() == torch.device("mps"):
                 mps.empty_cache()
 
-            name = context.tensors.save(tensor=result_latents)
-        return LatentsOutput.build(latents_name=name, latents=result_latents, seed=seed)
+            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, seed=seed)
 
 
 @invocation(
@@ -755,9 +816,9 @@ class DenoiseLatentsInvocation(BaseInvocation):
     title="Latents to Image",
     tags=["latents", "image", "vae", "l2i"],
     category="latents",
-    version="1.2.1",
+    version="1.2.0",
 )
-class LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
+class LatentsToImageInvocation(BaseInvocation, WithMetadata):
     """Generates an image from latents."""
 
     latents: LatentsField = InputField(
@@ -773,9 +834,12 @@ class LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
 
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        latents = context.tensors.load(self.latents.latents_name)
+        latents = context.services.latents.get(self.latents.latents_name)
 
-        vae_info = context.models.load(**self.vae.vae.model_dump())
+        vae_info = context.services.model_manager.load_model_by_key(
+            **self.vae.vae.model_dump(),
+            context=context,
+        )
 
         with set_seamless(vae_info.model, self.vae.seamless_axes), vae_info as vae:
             assert isinstance(vae, torch.nn.Module)
@@ -805,7 +869,7 @@ class LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
                 vae.to(dtype=torch.float16)
                 latents = latents.half()
 
-            if self.tiled or context.config.get().tiled_decode:
+            if self.tiled or context.services.configuration.tiled_decode:
                 vae.enable_tiling()
             else:
                 vae.disable_tiling()
@@ -829,9 +893,22 @@ class LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
         if choose_torch_device() == torch.device("mps"):
             mps.empty_cache()
 
-        image_dto = context.images.save(image=image)
+        image_dto = context.services.images.create(
+            image=image,
+            image_origin=ResourceOrigin.INTERNAL,
+            image_category=ImageCategory.GENERAL,
+            node_id=self.id,
+            session_id=context.graph_execution_state_id,
+            is_intermediate=self.is_intermediate,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )
 
 
 LATENTS_INTERPOLATION_MODE = Literal["nearest", "linear", "bilinear", "bicubic", "trilinear", "area", "nearest-exact"]
@@ -842,7 +919,7 @@ LATENTS_INTERPOLATION_MODE = Literal["nearest", "linear", "bilinear", "bicubic",
     title="Resize Latents",
     tags=["latents", "resize"],
     category="latents",
-    version="1.0.1",
+    version="1.0.0",
 )
 class ResizeLatentsInvocation(BaseInvocation):
     """Resizes latents to explicit width/height (in pixels). Provided dimensions are floor-divided by 8."""
@@ -865,7 +942,7 @@ class ResizeLatentsInvocation(BaseInvocation):
     antialias: bool = InputField(default=False, description=FieldDescriptions.torch_antialias)
 
     def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = context.tensors.load(self.latents.latents_name)
+        latents = context.services.latents.get(self.latents.latents_name)
 
         # TODO:
         device = choose_torch_device()
@@ -883,8 +960,10 @@ class ResizeLatentsInvocation(BaseInvocation):
         if device == torch.device("mps"):
             mps.empty_cache()
 
-        name = context.tensors.save(tensor=resized_latents)
-        return LatentsOutput.build(latents_name=name, latents=resized_latents, seed=self.latents.seed)
+        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, seed=self.latents.seed)
 
 
 @invocation(
@@ -892,7 +971,7 @@ class ResizeLatentsInvocation(BaseInvocation):
     title="Scale Latents",
     tags=["latents", "resize"],
     category="latents",
-    version="1.0.1",
+    version="1.0.0",
 )
 class ScaleLatentsInvocation(BaseInvocation):
     """Scales latents by a given factor."""
@@ -906,7 +985,7 @@ class ScaleLatentsInvocation(BaseInvocation):
     antialias: bool = InputField(default=False, description=FieldDescriptions.torch_antialias)
 
     def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = context.tensors.load(self.latents.latents_name)
+        latents = context.services.latents.get(self.latents.latents_name)
 
         # TODO:
         device = choose_torch_device()
@@ -925,8 +1004,10 @@ class ScaleLatentsInvocation(BaseInvocation):
         if device == torch.device("mps"):
             mps.empty_cache()
 
-        name = context.tensors.save(tensor=resized_latents)
-        return LatentsOutput.build(latents_name=name, latents=resized_latents, seed=self.latents.seed)
+        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, seed=self.latents.seed)
 
 
 @invocation(
@@ -934,7 +1015,7 @@ class ScaleLatentsInvocation(BaseInvocation):
     title="Image to Latents",
     tags=["latents", "image", "vae", "i2l"],
     category="latents",
-    version="1.0.1",
+    version="1.0.0",
 )
 class ImageToLatentsInvocation(BaseInvocation):
     """Encodes an image into latents."""
@@ -996,9 +1077,12 @@ class ImageToLatentsInvocation(BaseInvocation):
 
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> LatentsOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
 
-        vae_info = context.models.load(**self.vae.vae.model_dump())
+        vae_info = context.services.model_manager.load_model_by_key(
+            **self.vae.vae.model_dump(),
+            context=context,
+        )
 
         image_tensor = image_resized_to_grid_as_tensor(image.convert("RGB"))
         if image_tensor.dim() == 3:
@@ -1006,9 +1090,10 @@ class ImageToLatentsInvocation(BaseInvocation):
 
         latents = self.vae_encode(vae_info, self.fp32, self.tiled, image_tensor)
 
+        name = f"{context.graph_execution_state_id}__{self.id}"
         latents = latents.to("cpu")
-        name = context.tensors.save(tensor=latents)
-        return LatentsOutput.build(latents_name=name, latents=latents, seed=None)
+        context.services.latents.save(name, latents)
+        return build_latents_output(latents_name=name, latents=latents, seed=None)
 
     @singledispatchmethod
     @staticmethod
@@ -1033,7 +1118,7 @@ class ImageToLatentsInvocation(BaseInvocation):
     title="Blend Latents",
     tags=["latents", "blend"],
     category="latents",
-    version="1.0.1",
+    version="1.0.0",
 )
 class BlendLatentsInvocation(BaseInvocation):
     """Blend two latents using a given alpha. Latents must have same size."""
@@ -1049,8 +1134,8 @@ class BlendLatentsInvocation(BaseInvocation):
     alpha: float = InputField(default=0.5, description=FieldDescriptions.blend_alpha)
 
     def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents_a = context.tensors.load(self.latents_a.latents_name)
-        latents_b = context.tensors.load(self.latents_b.latents_name)
+        latents_a = context.services.latents.get(self.latents_a.latents_name)
+        latents_b = context.services.latents.get(self.latents_b.latents_name)
 
         if latents_a.shape != latents_b.shape:
             raise Exception("Latents to blend must be the same size.")
@@ -1113,8 +1198,10 @@ class BlendLatentsInvocation(BaseInvocation):
         if device == torch.device("mps"):
             mps.empty_cache()
 
-        name = context.tensors.save(tensor=blended_latents)
-        return LatentsOutput.build(latents_name=name, latents=blended_latents)
+        name = f"{context.graph_execution_state_id}__{self.id}"
+        # context.services.latents.set(name, resized_latents)
+        context.services.latents.save(name, blended_latents)
+        return build_latents_output(latents_name=name, latents=blended_latents)
 
 
 # The Crop Latents node was copied from @skunkworxdark's implementation here:
@@ -1124,7 +1211,7 @@ class BlendLatentsInvocation(BaseInvocation):
     title="Crop Latents",
     tags=["latents", "crop"],
     category="latents",
-    version="1.0.1",
+    version="1.0.0",
 )
 # TODO(ryand): Named `CropLatentsCoreInvocation` to prevent a conflict with custom node `CropLatentsInvocation`.
 # Currently, if the class names conflict then 'GET /openapi.json' fails.
@@ -1159,7 +1246,7 @@ class CropLatentsCoreInvocation(BaseInvocation):
     )
 
     def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = context.tensors.load(self.latents.latents_name)
+        latents = context.services.latents.get(self.latents.latents_name)
 
         x1 = self.x // LATENT_SCALE_FACTOR
         y1 = self.y // LATENT_SCALE_FACTOR
@@ -1168,9 +1255,10 @@ class CropLatentsCoreInvocation(BaseInvocation):
 
         cropped_latents = latents[..., y1:y2, x1:x2]
 
-        name = context.tensors.save(tensor=cropped_latents)
+        name = f"{context.graph_execution_state_id}__{self.id}"
+        context.services.latents.save(name, cropped_latents)
 
-        return LatentsOutput.build(latents_name=name, latents=cropped_latents)
+        return build_latents_output(latents_name=name, latents=cropped_latents)
 
 
 @invocation_output("ideal_size_output")
@@ -1202,7 +1290,10 @@ class IdealSizeInvocation(BaseInvocation):
         return tuple((x - x % multiple_of) for x in args)
 
     def invoke(self, context: InvocationContext) -> IdealSizeOutput:
-        unet_config = context.models.get_config(**self.unet.unet.model_dump())
+        unet_config = context.services.model_manager.load_model_by_key(
+            **self.unet.unet.model_dump(),
+            context=context,
+        )
         aspect = self.width / self.height
         dimension: float = 512
         if unet_config.base == BaseModelType.StableDiffusion2:

invokeai/app/invocations/math.py

@@ -5,11 +5,10 @@ from typing import Literal
 import numpy as np
 from pydantic import ValidationInfo, field_validator
 
-from invokeai.app.invocations.fields import FieldDescriptions, InputField
 from invokeai.app.invocations.primitives import FloatOutput, IntegerOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.shared.fields import FieldDescriptions
 
-from .baseinvocation import BaseInvocation, invocation
+from .baseinvocation import BaseInvocation, InputField, InvocationContext, invocation
 
 
 @invocation("add", title="Add Integers", tags=["math", "add"], category="math", version="1.0.0")

invokeai/app/invocations/metadata.py

@@ -5,22 +5,20 @@ from pydantic import BaseModel, ConfigDict, Field
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    InputField,
+    InvocationContext,
+    MetadataField,
+    OutputField,
+    UIType,
     invocation,
     invocation_output,
 )
 from invokeai.app.invocations.controlnet_image_processors import ControlField
-from invokeai.app.invocations.fields import (
-    FieldDescriptions,
-    ImageField,
-    InputField,
-    MetadataField,
-    OutputField,
-    UIType,
-)
 from invokeai.app.invocations.ip_adapter import IPAdapterModelField
 from invokeai.app.invocations.model import LoRAModelField, MainModelField, VAEModelField
+from invokeai.app.invocations.primitives import ImageField
 from invokeai.app.invocations.t2i_adapter import T2IAdapterField
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.shared.fields import FieldDescriptions
 
 from ...version import __version__
 

invokeai/app/invocations/model.py

@@ -3,14 +3,17 @@ from typing import List, Optional
 
 from pydantic import BaseModel, Field
 
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.shared.models import FreeUConfig
 
 from ...backend.model_manager import SubModelType
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
     invocation,
     invocation_output,
 )
@@ -91,7 +94,7 @@ class LoRAModelField(BaseModel):
     title="Main Model",
     tags=["model"],
     category="model",
-    version="1.0.1",
+    version="1.0.0",
 )
 class MainModelLoaderInvocation(BaseInvocation):
     """Loads a main model, outputting its submodels."""
@@ -103,7 +106,7 @@ class MainModelLoaderInvocation(BaseInvocation):
         key = self.model.key
 
         # TODO: not found exceptions
-        if not context.models.exists(key):
+        if not context.services.model_manager.store.exists(key):
             raise Exception(f"Unknown model {key}")
 
         return ModelLoaderOutput(
@@ -147,7 +150,7 @@ class LoraLoaderOutput(BaseInvocationOutput):
     clip: Optional[ClipField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP")
 
 
-@invocation("lora_loader", title="LoRA", tags=["model"], category="model", version="1.0.1")
+@invocation("lora_loader", title="LoRA", tags=["model"], category="model", version="1.0.0")
 class LoraLoaderInvocation(BaseInvocation):
     """Apply selected lora to unet and text_encoder."""
 
@@ -172,7 +175,7 @@ class LoraLoaderInvocation(BaseInvocation):
 
         lora_key = self.lora.key
 
-        if not context.models.exists(lora_key):
+        if not context.services.model_manager.store.exists(lora_key):
             raise Exception(f"Unkown lora: {lora_key}!")
 
         if self.unet is not None and any(lora.key == lora_key for lora in self.unet.loras):
@@ -220,7 +223,7 @@ class SDXLLoraLoaderOutput(BaseInvocationOutput):
     title="SDXL LoRA",
     tags=["lora", "model"],
     category="model",
-    version="1.0.1",
+    version="1.0.0",
 )
 class SDXLLoraLoaderInvocation(BaseInvocation):
     """Apply selected lora to unet and text_encoder."""
@@ -252,7 +255,7 @@ class SDXLLoraLoaderInvocation(BaseInvocation):
 
         lora_key = self.lora.key
 
-        if not context.models.exists(lora_key):
+        if not context.services.model_manager.store.exists(lora_key):
             raise Exception(f"Unknown lora: {lora_key}!")
 
         if self.unet is not None and any(lora.key == lora_key for lora in self.unet.loras):
@@ -305,7 +308,7 @@ class VAEModelField(BaseModel):
     key: str = Field(description="Model's key")
 
 
-@invocation("vae_loader", title="VAE", tags=["vae", "model"], category="model", version="1.0.1")
+@invocation("vae_loader", title="VAE", tags=["vae", "model"], category="model", version="1.0.0")
 class VaeLoaderInvocation(BaseInvocation):
     """Loads a VAE model, outputting a VaeLoaderOutput"""
 
@@ -318,7 +321,7 @@ class VaeLoaderInvocation(BaseInvocation):
     def invoke(self, context: InvocationContext) -> VAEOutput:
         key = self.vae_model.key
 
-        if not context.models.exists(key):
+        if not context.services.model_manager.store.exists(key):
             raise Exception(f"Unkown vae: {key}!")
 
         return VAEOutput(vae=VaeField(vae=ModelInfo(key=key)))

invokeai/app/invocations/noise.py

@@ -4,15 +4,17 @@
 import torch
 from pydantic import field_validator
 
-from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
-from invokeai.app.invocations.fields import FieldDescriptions, InputField, LatentsField, OutputField
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.invocations.latent import LatentsField
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.app.util.misc import SEED_MAX
 
 from ...backend.util.devices import choose_torch_device, torch_dtype
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    InputField,
+    InvocationContext,
+    OutputField,
     invocation,
     invocation_output,
 )
@@ -67,13 +69,13 @@ class NoiseOutput(BaseInvocationOutput):
     width: int = OutputField(description=FieldDescriptions.width)
     height: int = OutputField(description=FieldDescriptions.height)
 
-    @classmethod
-    def build(cls, latents_name: str, latents: torch.Tensor, seed: int) -> "NoiseOutput":
-        return cls(
-            noise=LatentsField(latents_name=latents_name, seed=seed),
-            width=latents.size()[3] * LATENT_SCALE_FACTOR,
-            height=latents.size()[2] * LATENT_SCALE_FACTOR,
-        )
+
+def build_noise_output(latents_name: str, latents: torch.Tensor, seed: int):
+    return NoiseOutput(
+        noise=LatentsField(latents_name=latents_name, seed=seed),
+        width=latents.size()[3] * 8,
+        height=latents.size()[2] * 8,
+    )
 
 
 @invocation(
@@ -94,13 +96,13 @@ class NoiseInvocation(BaseInvocation):
     )
     width: int = InputField(
         default=512,
-        multiple_of=LATENT_SCALE_FACTOR,
+        multiple_of=8,
         gt=0,
         description=FieldDescriptions.width,
     )
     height: int = InputField(
         default=512,
-        multiple_of=LATENT_SCALE_FACTOR,
+        multiple_of=8,
         gt=0,
         description=FieldDescriptions.height,
     )
@@ -122,5 +124,6 @@ class NoiseInvocation(BaseInvocation):
             seed=self.seed,
             use_cpu=self.use_cpu,
         )
-        name = context.tensors.save(tensor=noise)
-        return NoiseOutput.build(latents_name=name, latents=noise, seed=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, seed=self.seed)

invokeai/app/invocations/onnx.py

@@ -0,0 +1,457 @@
+# Copyright (c) 2023 Borisov Sergey (https://github.com/StAlKeR7779)
+
+import inspect
+
+# from contextlib import ExitStack
+from typing import List, Literal, Union
+
+import numpy as np
+import torch
+from diffusers.image_processor import VaeImageProcessor
+from pydantic import BaseModel, Field, field_validator
+from tqdm import tqdm
+
+from invokeai.app.invocations.primitives import ConditioningField, ConditioningOutput, ImageField, ImageOutput
+from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
+from invokeai.app.shared.fields import FieldDescriptions
+from invokeai.app.util.step_callback import stable_diffusion_step_callback
+from invokeai.backend.model_manager import ModelType, SubModelType
+from invokeai.backend.model_patcher import ONNXModelPatcher
+
+from ...backend.stable_diffusion import PipelineIntermediateState
+from ...backend.util import choose_torch_device
+from ..util.ti_utils import extract_ti_triggers_from_prompt
+from .baseinvocation import (
+    BaseInvocation,
+    BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
+    UIComponent,
+    UIType,
+    WithMetadata,
+    invocation,
+    invocation_output,
+)
+from .controlnet_image_processors import ControlField
+from .latent import SAMPLER_NAME_VALUES, LatentsField, LatentsOutput, build_latents_output, get_scheduler
+from .model import ClipField, ModelInfo, UNetField, VaeField
+
+ORT_TO_NP_TYPE = {
+    "tensor(bool)": np.bool_,
+    "tensor(int8)": np.int8,
+    "tensor(uint8)": np.uint8,
+    "tensor(int16)": np.int16,
+    "tensor(uint16)": np.uint16,
+    "tensor(int32)": np.int32,
+    "tensor(uint32)": np.uint32,
+    "tensor(int64)": np.int64,
+    "tensor(uint64)": np.uint64,
+    "tensor(float16)": np.float16,
+    "tensor(float)": np.float32,
+    "tensor(double)": np.float64,
+}
+
+PRECISION_VALUES = Literal[tuple(ORT_TO_NP_TYPE.keys())]
+
+
+@invocation("prompt_onnx", title="ONNX Prompt (Raw)", tags=["prompt", "onnx"], category="conditioning", version="1.0.0")
+class ONNXPromptInvocation(BaseInvocation):
+    prompt: str = InputField(default="", description=FieldDescriptions.raw_prompt, ui_component=UIComponent.Textarea)
+    clip: ClipField = InputField(description=FieldDescriptions.clip, input=Input.Connection)
+
+    def invoke(self, context: InvocationContext) -> ConditioningOutput:
+        tokenizer_info = context.services.model_manager.load_model_by_key(
+            **self.clip.tokenizer.model_dump(),
+        )
+        text_encoder_info = context.services.model_manager.load_model_by_key(
+            **self.clip.text_encoder.model_dump(),
+        )
+        with tokenizer_info as orig_tokenizer, text_encoder_info as text_encoder:  # , ExitStack() as stack:
+            loras = [
+                (
+                    context.services.model_manager.load_model_by_key(**lora.model_dump(exclude={"weight"})).model,
+                    lora.weight,
+                )
+                for lora in self.clip.loras
+            ]
+
+            ti_list = []
+            for trigger in extract_ti_triggers_from_prompt(self.prompt):
+                name = trigger[1:-1]
+                try:
+                    ti_list.append(
+                        (
+                            name,
+                            context.services.model_manager.load_model_by_attr(
+                                model_name=name,
+                                base_model=text_encoder_info.config.base,
+                                model_type=ModelType.TextualInversion,
+                            ).model,
+                        )
+                    )
+                except Exception:
+                    # print(e)
+                    # import traceback
+                    # print(traceback.format_exc())
+                    print(f'Warn: trigger: "{trigger}" not found')
+            if loras or ti_list:
+                text_encoder.release_session()
+            with (
+                ONNXModelPatcher.apply_lora_text_encoder(text_encoder, loras),
+                ONNXModelPatcher.apply_ti(orig_tokenizer, text_encoder, ti_list) as (tokenizer, ti_manager),
+            ):
+                text_encoder.create_session()
+
+                # copy from
+                # https://github.com/huggingface/diffusers/blob/3ebbaf7c96801271f9e6c21400033b6aa5ffcf29/src/diffusers/pipelines/stable_diffusion/pipeline_onnx_stable_diffusion.py#L153
+                text_inputs = tokenizer(
+                    self.prompt,
+                    padding="max_length",
+                    max_length=tokenizer.model_max_length,
+                    truncation=True,
+                    return_tensors="np",
+                )
+                text_input_ids = text_inputs.input_ids
+                """
+                untruncated_ids = tokenizer(prompt, padding="max_length", return_tensors="np").input_ids
+
+                if not np.array_equal(text_input_ids, untruncated_ids):
+                    removed_text = self.tokenizer.batch_decode(
+                        untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]
+                    )
+                    logger.warning(
+                        "The following part of your input was truncated because CLIP can only handle sequences up to"
+                        f" {self.tokenizer.model_max_length} tokens: {removed_text}"
+                    )
+                """
+
+                prompt_embeds = text_encoder(input_ids=text_input_ids.astype(np.int32))[0]
+
+        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, (prompt_embeds, None))
+
+        return ConditioningOutput(
+            conditioning=ConditioningField(
+                conditioning_name=conditioning_name,
+            ),
+        )
+
+
+# Text to image
+@invocation(
+    "t2l_onnx",
+    title="ONNX Text to Latents",
+    tags=["latents", "inference", "txt2img", "onnx"],
+    category="latents",
+    version="1.0.0",
+)
+class ONNXTextToLatentsInvocation(BaseInvocation):
+    """Generates latents from conditionings."""
+
+    positive_conditioning: ConditioningField = InputField(
+        description=FieldDescriptions.positive_cond,
+        input=Input.Connection,
+    )
+    negative_conditioning: ConditioningField = InputField(
+        description=FieldDescriptions.negative_cond,
+        input=Input.Connection,
+    )
+    noise: LatentsField = InputField(
+        description=FieldDescriptions.noise,
+        input=Input.Connection,
+    )
+    steps: int = InputField(default=10, gt=0, description=FieldDescriptions.steps)
+    cfg_scale: Union[float, List[float]] = InputField(
+        default=7.5,
+        ge=1,
+        description=FieldDescriptions.cfg_scale,
+    )
+    scheduler: SAMPLER_NAME_VALUES = InputField(
+        default="euler", description=FieldDescriptions.scheduler, input=Input.Direct, ui_type=UIType.Scheduler
+    )
+    precision: PRECISION_VALUES = InputField(default="tensor(float16)", description=FieldDescriptions.precision)
+    unet: UNetField = InputField(
+        description=FieldDescriptions.unet,
+        input=Input.Connection,
+    )
+    control: Union[ControlField, list[ControlField]] = InputField(
+        default=None,
+        description=FieldDescriptions.control,
+    )
+    # seamless:   bool = InputField(default=False, description="Whether or not to generate an image that can tile without seams", )
+    # seamless_axes: str = InputField(default="", description="The axes to tile the image on, 'x' and/or 'y'")
+
+    @field_validator("cfg_scale")
+    def ge_one(cls, v):
+        """validate that all cfg_scale values are >= 1"""
+        if isinstance(v, list):
+            for i in v:
+                if i < 1:
+                    raise ValueError("cfg_scale must be greater than 1")
+        else:
+            if v < 1:
+                raise ValueError("cfg_scale must be greater than 1")
+        return v
+
+    # based on
+    # https://github.com/huggingface/diffusers/blob/3ebbaf7c96801271f9e6c21400033b6aa5ffcf29/src/diffusers/pipelines/stable_diffusion/pipeline_onnx_stable_diffusion.py#L375
+    def invoke(self, context: InvocationContext) -> LatentsOutput:
+        c, _ = context.services.latents.get(self.positive_conditioning.conditioning_name)
+        uc, _ = context.services.latents.get(self.negative_conditioning.conditioning_name)
+        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]
+        if isinstance(c, torch.Tensor):
+            c = c.cpu().numpy()
+        if isinstance(uc, torch.Tensor):
+            uc = uc.cpu().numpy()
+        device = torch.device(choose_torch_device())
+        prompt_embeds = np.concatenate([uc, c])
+
+        latents = context.services.latents.get(self.noise.latents_name)
+        if isinstance(latents, torch.Tensor):
+            latents = latents.cpu().numpy()
+
+        # TODO: better execution device handling
+        latents = latents.astype(ORT_TO_NP_TYPE[self.precision])
+
+        # get the initial random noise unless the user supplied it
+        do_classifier_free_guidance = True
+        # latents_dtype = prompt_embeds.dtype
+        # latents_shape = (batch_size * num_images_per_prompt, 4, height // 8, width // 8)
+        # if latents.shape != latents_shape:
+        #    raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}")
+
+        scheduler = get_scheduler(
+            context=context,
+            scheduler_info=self.unet.scheduler,
+            scheduler_name=self.scheduler,
+            seed=0,  # TODO: refactor this node
+        )
+
+        def torch2numpy(latent: torch.Tensor):
+            return latent.cpu().numpy()
+
+        def numpy2torch(latent, device):
+            return torch.from_numpy(latent).to(device)
+
+        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.model_dump(),
+                source_node_id=source_node_id,
+            )
+
+        scheduler.set_timesteps(self.steps)
+        latents = latents * np.float64(scheduler.init_noise_sigma)
+
+        extra_step_kwargs = {}
+        if "eta" in set(inspect.signature(scheduler.step).parameters.keys()):
+            extra_step_kwargs.update(
+                eta=0.0,
+            )
+
+        unet_info = context.services.model_manager.load_model_by_key(**self.unet.unet.model_dump())
+
+        with unet_info as unet:  # , ExitStack() as stack:
+            # loras = [(stack.enter_context(context.services.model_manager.get_model(**lora.dict(exclude={"weight"}))), lora.weight) for lora in self.unet.loras]
+            loras = [
+                (
+                    context.services.model_manager.load_model_by_key(**lora.model_dump(exclude={"weight"})).model,
+                    lora.weight,
+                )
+                for lora in self.unet.loras
+            ]
+
+            if loras:
+                unet.release_session()
+            with ONNXModelPatcher.apply_lora_unet(unet, loras):
+                # TODO:
+                _, _, h, w = latents.shape
+                unet.create_session(h, w)
+
+                timestep_dtype = next(
+                    (input.type for input in unet.session.get_inputs() if input.name == "timestep"), "tensor(float16)"
+                )
+                timestep_dtype = ORT_TO_NP_TYPE[timestep_dtype]
+                for i in tqdm(range(len(scheduler.timesteps))):
+                    t = scheduler.timesteps[i]
+                    # expand the latents if we are doing classifier free guidance
+                    latent_model_input = np.concatenate([latents] * 2) if do_classifier_free_guidance else latents
+                    latent_model_input = scheduler.scale_model_input(numpy2torch(latent_model_input, device), t)
+                    latent_model_input = latent_model_input.cpu().numpy()
+
+                    # predict the noise residual
+                    timestep = np.array([t], dtype=timestep_dtype)
+                    noise_pred = unet(sample=latent_model_input, timestep=timestep, encoder_hidden_states=prompt_embeds)
+                    noise_pred = noise_pred[0]
+
+                    # perform guidance
+                    if do_classifier_free_guidance:
+                        noise_pred_uncond, noise_pred_text = np.split(noise_pred, 2)
+                        noise_pred = noise_pred_uncond + self.cfg_scale * (noise_pred_text - noise_pred_uncond)
+
+                    # compute the previous noisy sample x_t -> x_t-1
+                    scheduler_output = scheduler.step(
+                        numpy2torch(noise_pred, device), t, numpy2torch(latents, device), **extra_step_kwargs
+                    )
+                    latents = torch2numpy(scheduler_output.prev_sample)
+
+                    state = PipelineIntermediateState(
+                        run_id="test", step=i, timestep=timestep, latents=scheduler_output.prev_sample
+                    )
+                    dispatch_progress(self, context=context, source_node_id=source_node_id, intermediate_state=state)
+
+                    # call the callback, if provided
+                    # if callback is not None and i % callback_steps == 0:
+                    #    callback(i, t, latents)
+
+        torch.cuda.empty_cache()
+
+        name = f"{context.graph_execution_state_id}__{self.id}"
+        context.services.latents.save(name, latents)
+        return build_latents_output(latents_name=name, latents=torch.from_numpy(latents))
+
+
+# Latent to image
+@invocation(
+    "l2i_onnx",
+    title="ONNX Latents to Image",
+    tags=["latents", "image", "vae", "onnx"],
+    category="image",
+    version="1.2.0",
+)
+class ONNXLatentsToImageInvocation(BaseInvocation, WithMetadata):
+    """Generates an image from latents."""
+
+    latents: LatentsField = InputField(
+        description=FieldDescriptions.denoised_latents,
+        input=Input.Connection,
+    )
+    vae: VaeField = InputField(
+        description=FieldDescriptions.vae,
+        input=Input.Connection,
+    )
+    # tiled: bool = InputField(default=False, description="Decode latents by overlaping tiles(less memory consumption)")
+
+    def invoke(self, context: InvocationContext) -> ImageOutput:
+        latents = context.services.latents.get(self.latents.latents_name)
+
+        if self.vae.vae.submodel != SubModelType.VaeDecoder:
+            raise Exception(f"Expected vae_decoder, found: {self.vae.vae.submodel}")
+
+        vae_info = context.services.model_manager.load_model_by_key(
+            **self.vae.vae.model_dump(),
+        )
+
+        # clear memory as vae decode can request a lot
+        torch.cuda.empty_cache()
+
+        with vae_info as vae:
+            vae.create_session()
+
+            # copied from
+            # https://github.com/huggingface/diffusers/blob/3ebbaf7c96801271f9e6c21400033b6aa5ffcf29/src/diffusers/pipelines/stable_diffusion/pipeline_onnx_stable_diffusion.py#L427
+            latents = 1 / 0.18215 * latents
+            # image = self.vae_decoder(latent_sample=latents)[0]
+            # it seems likes there is a strange result for using half-precision vae decoder if batchsize>1
+            image = np.concatenate([vae(latent_sample=latents[i : i + 1])[0] for i in range(latents.shape[0])])
+
+            image = np.clip(image / 2 + 0.5, 0, 1)
+            image = image.transpose((0, 2, 3, 1))
+            image = VaeImageProcessor.numpy_to_pil(image)[0]
+
+        torch.cuda.empty_cache()
+
+        image_dto = context.services.images.create(
+            image=image,
+            image_origin=ResourceOrigin.INTERNAL,
+            image_category=ImageCategory.GENERAL,
+            node_id=self.id,
+            session_id=context.graph_execution_state_id,
+            is_intermediate=self.is_intermediate,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
+
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )
+
+
+@invocation_output("model_loader_output_onnx")
+class ONNXModelLoaderOutput(BaseInvocationOutput):
+    """Model loader output"""
+
+    unet: UNetField = OutputField(default=None, description=FieldDescriptions.unet, title="UNet")
+    clip: ClipField = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP")
+    vae_decoder: VaeField = OutputField(default=None, description=FieldDescriptions.vae, title="VAE Decoder")
+    vae_encoder: VaeField = OutputField(default=None, description=FieldDescriptions.vae, title="VAE Encoder")
+
+
+class OnnxModelField(BaseModel):
+    """Onnx model field"""
+
+    key: str = Field(description="Model ID")
+
+
+@invocation("onnx_model_loader", title="ONNX Main Model", tags=["onnx", "model"], category="model", version="1.0.0")
+class OnnxModelLoaderInvocation(BaseInvocation):
+    """Loads a main model, outputting its submodels."""
+
+    model: OnnxModelField = InputField(
+        description=FieldDescriptions.onnx_main_model, input=Input.Direct, ui_type=UIType.ONNXModel
+    )
+
+    def invoke(self, context: InvocationContext) -> ONNXModelLoaderOutput:
+        model_key = self.model.key
+
+        # TODO: not found exceptions
+        if not context.services.model_manager.store.exists(model_key):
+            raise Exception(f"Unknown model: {model_key}")
+
+        return ONNXModelLoaderOutput(
+            unet=UNetField(
+                unet=ModelInfo(
+                    key=model_key,
+                    submodel_type=SubModelType.UNet,
+                ),
+                scheduler=ModelInfo(
+                    key=model_key,
+                    submodel_type=SubModelType.Scheduler,
+                ),
+                loras=[],
+            ),
+            clip=ClipField(
+                tokenizer=ModelInfo(
+                    key=model_key,
+                    submodel_type=SubModelType.Tokenizer,
+                ),
+                text_encoder=ModelInfo(
+                    key=model_key,
+                    submodel_type=SubModelType.TextEncoder,
+                ),
+                loras=[],
+                skipped_layers=0,
+            ),
+            vae_decoder=VaeField(
+                vae=ModelInfo(
+                    key=model_key,
+                    submodel_type=SubModelType.VaeDecoder,
+                ),
+            ),
+            vae_encoder=VaeField(
+                vae=ModelInfo(
+                    key=model_key,
+                    submodel_type=SubModelType.VaeEncoder,
+                ),
+            ),
+        )

invokeai/app/invocations/param_easing.py

@@ -40,10 +40,8 @@ from easing_functions import (
 from matplotlib.ticker import MaxNLocator
 
 from invokeai.app.invocations.primitives import FloatCollectionOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
 
-from .baseinvocation import BaseInvocation, invocation
-from .fields import InputField
+from .baseinvocation import BaseInvocation, InputField, InvocationContext, invocation
 
 
 @invocation(
@@ -111,7 +109,7 @@ EASING_FUNCTION_KEYS = Literal[tuple(EASING_FUNCTIONS_MAP.keys())]
     title="Step Param Easing",
     tags=["step", "easing"],
     category="step",
-    version="1.0.1",
+    version="1.0.0",
 )
 class StepParamEasingInvocation(BaseInvocation):
     """Experimental per-step parameter easing for denoising steps"""
@@ -150,19 +148,19 @@ class StepParamEasingInvocation(BaseInvocation):
         postlist = list(num_poststeps * [self.post_end_value])
 
         if log_diagnostics:
-            context.logger.debug("start_step: " + str(start_step))
-            context.logger.debug("end_step: " + str(end_step))
-            context.logger.debug("num_easing_steps: " + str(num_easing_steps))
-            context.logger.debug("num_presteps: " + str(num_presteps))
-            context.logger.debug("num_poststeps: " + str(num_poststeps))
-            context.logger.debug("prelist size: " + str(len(prelist)))
-            context.logger.debug("postlist size: " + str(len(postlist)))
-            context.logger.debug("prelist: " + str(prelist))
-            context.logger.debug("postlist: " + str(postlist))
+            context.services.logger.debug("start_step: " + str(start_step))
+            context.services.logger.debug("end_step: " + str(end_step))
+            context.services.logger.debug("num_easing_steps: " + str(num_easing_steps))
+            context.services.logger.debug("num_presteps: " + str(num_presteps))
+            context.services.logger.debug("num_poststeps: " + str(num_poststeps))
+            context.services.logger.debug("prelist size: " + str(len(prelist)))
+            context.services.logger.debug("postlist size: " + str(len(postlist)))
+            context.services.logger.debug("prelist: " + str(prelist))
+            context.services.logger.debug("postlist: " + str(postlist))
 
         easing_class = EASING_FUNCTIONS_MAP[self.easing]
         if log_diagnostics:
-            context.logger.debug("easing class: " + str(easing_class))
+            context.services.logger.debug("easing class: " + str(easing_class))
         easing_list = []
         if self.mirror:  # "expected" mirroring
             # if number of steps is even, squeeze duration down to (number_of_steps)/2
@@ -173,7 +171,7 @@ class StepParamEasingInvocation(BaseInvocation):
 
             base_easing_duration = int(np.ceil(num_easing_steps / 2.0))
             if log_diagnostics:
-                context.logger.debug("base easing duration: " + str(base_easing_duration))
+                context.services.logger.debug("base easing duration: " + str(base_easing_duration))
             even_num_steps = num_easing_steps % 2 == 0  # even number of steps
             easing_function = easing_class(
                 start=self.start_value,
@@ -185,14 +183,14 @@ class StepParamEasingInvocation(BaseInvocation):
                 easing_val = easing_function.ease(step_index)
                 base_easing_vals.append(easing_val)
                 if log_diagnostics:
-                    context.logger.debug("step_index: " + str(step_index) + ", easing_val: " + str(easing_val))
+                    context.services.logger.debug("step_index: " + str(step_index) + ", easing_val: " + str(easing_val))
             if even_num_steps:
                 mirror_easing_vals = list(reversed(base_easing_vals))
             else:
                 mirror_easing_vals = list(reversed(base_easing_vals[0:-1]))
             if log_diagnostics:
-                context.logger.debug("base easing vals: " + str(base_easing_vals))
-                context.logger.debug("mirror easing vals: " + str(mirror_easing_vals))
+                context.services.logger.debug("base easing vals: " + str(base_easing_vals))
+                context.services.logger.debug("mirror easing vals: " + str(mirror_easing_vals))
             easing_list = base_easing_vals + mirror_easing_vals
 
         # FIXME: add alt_mirror option (alternative to default or mirror), or remove entirely
@@ -227,12 +225,12 @@ class StepParamEasingInvocation(BaseInvocation):
                 step_val = easing_function.ease(step_index)
                 easing_list.append(step_val)
                 if log_diagnostics:
-                    context.logger.debug("step_index: " + str(step_index) + ", easing_val: " + str(step_val))
+                    context.services.logger.debug("step_index: " + str(step_index) + ", easing_val: " + str(step_val))
 
         if log_diagnostics:
-            context.logger.debug("prelist size: " + str(len(prelist)))
-            context.logger.debug("easing_list size: " + str(len(easing_list)))
-            context.logger.debug("postlist size: " + str(len(postlist)))
+            context.services.logger.debug("prelist size: " + str(len(prelist)))
+            context.services.logger.debug("easing_list size: " + str(len(easing_list)))
+            context.services.logger.debug("postlist size: " + str(len(postlist)))
 
         param_list = prelist + easing_list + postlist
 

invokeai/app/invocations/primitives.py

@@ -1,28 +1,20 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
 
-from typing import Optional
+from typing import Optional, Tuple
 
 import torch
+from pydantic import BaseModel, Field
 
-from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
-from invokeai.app.invocations.fields import (
-    ColorField,
-    ConditioningField,
-    DenoiseMaskField,
-    FieldDescriptions,
-    ImageField,
-    Input,
-    InputField,
-    LatentsField,
-    OutputField,
-    UIComponent,
-)
-from invokeai.app.services.images.images_common import ImageDTO
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.shared.fields import FieldDescriptions
 
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
+    UIComponent,
     invocation,
     invocation_output,
 )
@@ -229,6 +221,18 @@ class StringCollectionInvocation(BaseInvocation):
 # region Image
 
 
+class ImageField(BaseModel):
+    """An image primitive field"""
+
+    image_name: str = Field(description="The name of the image")
+
+
+class BoardField(BaseModel):
+    """A board primitive field"""
+
+    board_id: str = Field(description="The id of the board")
+
+
 @invocation_output("image_output")
 class ImageOutput(BaseInvocationOutput):
     """Base class for nodes that output a single image"""
@@ -237,14 +241,6 @@ class ImageOutput(BaseInvocationOutput):
     width: int = OutputField(description="The width of the image in pixels")
     height: int = OutputField(description="The height of the image in pixels")
 
-    @classmethod
-    def build(cls, image_dto: ImageDTO) -> "ImageOutput":
-        return cls(
-            image=ImageField(image_name=image_dto.image_name),
-            width=image_dto.width,
-            height=image_dto.height,
-        )
-
 
 @invocation_output("image_collection_output")
 class ImageCollectionOutput(BaseInvocationOutput):
@@ -255,14 +251,16 @@ class ImageCollectionOutput(BaseInvocationOutput):
     )
 
 
-@invocation("image", title="Image Primitive", tags=["primitives", "image"], category="primitives", version="1.0.1")
-class ImageInvocation(BaseInvocation):
+@invocation("image", title="Image Primitive", tags=["primitives", "image"], category="primitives", version="1.0.0")
+class ImageInvocation(
+    BaseInvocation,
+):
     """An image primitive value"""
 
     image: ImageField = InputField(description="The image to load")
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name)
+        image = context.services.images.get_pil_image(self.image.image_name)
 
         return ImageOutput(
             image=ImageField(image_name=self.image.image_name),
@@ -292,40 +290,42 @@ class ImageCollectionInvocation(BaseInvocation):
 # region DenoiseMask
 
 
+class DenoiseMaskField(BaseModel):
+    """An inpaint mask field"""
+
+    mask_name: str = Field(description="The name of the mask image")
+    masked_latents_name: Optional[str] = Field(default=None, description="The name of the masked image latents")
+
+
 @invocation_output("denoise_mask_output")
 class DenoiseMaskOutput(BaseInvocationOutput):
     """Base class for nodes that output a single image"""
 
     denoise_mask: DenoiseMaskField = OutputField(description="Mask for denoise model run")
 
-    @classmethod
-    def build(cls, mask_name: str, masked_latents_name: Optional[str] = None) -> "DenoiseMaskOutput":
-        return cls(
-            denoise_mask=DenoiseMaskField(mask_name=mask_name, masked_latents_name=masked_latents_name),
-        )
-
 
 # endregion
 
 # region Latents
 
 
+class LatentsField(BaseModel):
+    """A latents tensor primitive field"""
+
+    latents_name: str = Field(description="The name of the latents")
+    seed: Optional[int] = Field(default=None, description="Seed used to generate this latents")
+
+
 @invocation_output("latents_output")
 class LatentsOutput(BaseInvocationOutput):
     """Base class for nodes that output a single latents tensor"""
 
-    latents: LatentsField = OutputField(description=FieldDescriptions.latents)
+    latents: LatentsField = OutputField(
+        description=FieldDescriptions.latents,
+    )
     width: int = OutputField(description=FieldDescriptions.width)
     height: int = OutputField(description=FieldDescriptions.height)
 
-    @classmethod
-    def build(cls, latents_name: str, latents: torch.Tensor, seed: Optional[int] = None) -> "LatentsOutput":
-        return cls(
-            latents=LatentsField(latents_name=latents_name, seed=seed),
-            width=latents.size()[3] * LATENT_SCALE_FACTOR,
-            height=latents.size()[2] * LATENT_SCALE_FACTOR,
-        )
-
 
 @invocation_output("latents_collection_output")
 class LatentsCollectionOutput(BaseInvocationOutput):
@@ -337,7 +337,7 @@ class LatentsCollectionOutput(BaseInvocationOutput):
 
 
 @invocation(
-    "latents", title="Latents Primitive", tags=["primitives", "latents"], category="primitives", version="1.0.1"
+    "latents", title="Latents Primitive", tags=["primitives", "latents"], category="primitives", version="1.0.0"
 )
 class LatentsInvocation(BaseInvocation):
     """A latents tensor primitive value"""
@@ -345,9 +345,9 @@ class LatentsInvocation(BaseInvocation):
     latents: LatentsField = InputField(description="The latents tensor", input=Input.Connection)
 
     def invoke(self, context: InvocationContext) -> LatentsOutput:
-        latents = context.tensors.load(self.latents.latents_name)
+        latents = context.services.latents.get(self.latents.latents_name)
 
-        return LatentsOutput.build(self.latents.latents_name, latents)
+        return build_latents_output(self.latents.latents_name, latents)
 
 
 @invocation(
@@ -368,11 +368,31 @@ class LatentsCollectionInvocation(BaseInvocation):
         return LatentsCollectionOutput(collection=self.collection)
 
 
+def build_latents_output(latents_name: str, latents: torch.Tensor, seed: Optional[int] = None) -> LatentsOutput:
+    return LatentsOutput(
+        latents=LatentsField(latents_name=latents_name, seed=seed),
+        width=latents.size()[3] * 8,
+        height=latents.size()[2] * 8,
+    )
+
+
 # endregion
 
 # region Color
 
 
+class ColorField(BaseModel):
+    """A color primitive field"""
+
+    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)
+
+
 @invocation_output("color_output")
 class ColorOutput(BaseInvocationOutput):
     """Base class for nodes that output a single color"""
@@ -404,16 +424,18 @@ class ColorInvocation(BaseInvocation):
 # region Conditioning
 
 
+class ConditioningField(BaseModel):
+    """A conditioning tensor primitive value"""
+
+    conditioning_name: str = Field(description="The name of conditioning tensor")
+
+
 @invocation_output("conditioning_output")
 class ConditioningOutput(BaseInvocationOutput):
     """Base class for nodes that output a single conditioning tensor"""
 
     conditioning: ConditioningField = OutputField(description=FieldDescriptions.cond)
 
-    @classmethod
-    def build(cls, conditioning_name: str) -> "ConditioningOutput":
-        return cls(conditioning=ConditioningField(conditioning_name=conditioning_name))
-
 
 @invocation_output("conditioning_collection_output")
 class ConditioningCollectionOutput(BaseInvocationOutput):

invokeai/app/invocations/prompt.py

@@ -6,10 +6,8 @@ from dynamicprompts.generators import CombinatorialPromptGenerator, RandomPrompt
 from pydantic import field_validator
 
 from invokeai.app.invocations.primitives import StringCollectionOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
 
-from .baseinvocation import BaseInvocation, invocation
-from .fields import InputField, UIComponent
+from .baseinvocation import BaseInvocation, InputField, InvocationContext, UIComponent, invocation
 
 
 @invocation(

invokeai/app/invocations/sdxl.py

@@ -1,10 +1,14 @@
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIType
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.shared.fields import FieldDescriptions
 from invokeai.backend.model_manager import SubModelType
 
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
+    UIType,
     invocation,
     invocation_output,
 )
@@ -30,7 +34,7 @@ class SDXLRefinerModelLoaderOutput(BaseInvocationOutput):
     vae: VaeField = OutputField(description=FieldDescriptions.vae, title="VAE")
 
 
-@invocation("sdxl_model_loader", title="SDXL Main Model", tags=["model", "sdxl"], category="model", version="1.0.1")
+@invocation("sdxl_model_loader", title="SDXL Main Model", tags=["model", "sdxl"], category="model", version="1.0.0")
 class SDXLModelLoaderInvocation(BaseInvocation):
     """Loads an sdxl base model, outputting its submodels."""
 
@@ -43,7 +47,7 @@ class SDXLModelLoaderInvocation(BaseInvocation):
         model_key = self.model.key
 
         # TODO: not found exceptions
-        if not context.models.exists(model_key):
+        if not context.services.model_manager.store.exists(model_key):
             raise Exception(f"Unknown model: {model_key}")
 
         return SDXLModelLoaderOutput(
@@ -96,7 +100,7 @@ class SDXLModelLoaderInvocation(BaseInvocation):
     title="SDXL Refiner Model",
     tags=["model", "sdxl", "refiner"],
     category="model",
-    version="1.0.1",
+    version="1.0.0",
 )
 class SDXLRefinerModelLoaderInvocation(BaseInvocation):
     """Loads an sdxl refiner model, outputting its submodels."""
@@ -112,7 +116,7 @@ class SDXLRefinerModelLoaderInvocation(BaseInvocation):
         model_key = self.model.key
 
         # TODO: not found exceptions
-        if not context.models.exists(model_key):
+        if not context.services.model_manager.store.exists(model_key):
             raise Exception(f"Unknown model: {model_key}")
 
         return SDXLRefinerModelLoaderOutput(

invokeai/app/invocations/strings.py

@@ -2,15 +2,16 @@
 
 import re
 
-from invokeai.app.services.shared.invocation_context import InvocationContext
-
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    InputField,
+    InvocationContext,
+    OutputField,
+    UIComponent,
     invocation,
     invocation_output,
 )
-from .fields import InputField, OutputField, UIComponent
 from .primitives import StringOutput
 
 

invokeai/app/invocations/t2i_adapter.py

@@ -5,13 +5,17 @@ from pydantic import BaseModel, Field, field_validator, model_validator
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
     invocation,
     invocation_output,
 )
 from invokeai.app.invocations.controlnet_image_processors import CONTROLNET_RESIZE_VALUES
-from invokeai.app.invocations.fields import FieldDescriptions, ImageField, Input, InputField, OutputField
+from invokeai.app.invocations.primitives import ImageField
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.shared.fields import FieldDescriptions
 
 
 class T2IAdapterModelField(BaseModel):

invokeai/app/invocations/tiles.py

@@ -8,12 +8,16 @@ from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
     Classification,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
+    WithMetadata,
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import ImageField, Input, InputField, OutputField, WithBoard, WithMetadata
-from invokeai.app.invocations.primitives import ImageOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.invocations.primitives import ImageField, ImageOutput
+from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
 from invokeai.backend.tiles.tiles import (
     calc_tiles_even_split,
     calc_tiles_min_overlap,
@@ -232,7 +236,7 @@ BLEND_MODES = Literal["Linear", "Seam"]
     version="1.1.0",
     classification=Classification.Beta,
 )
-class MergeTilesToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
+class MergeTilesToImageInvocation(BaseInvocation, WithMetadata):
     """Merge multiple tile images into a single image."""
 
     # Inputs
@@ -264,7 +268,7 @@ class MergeTilesToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
         # existed in memory at an earlier point in the graph.
         tile_np_images: list[np.ndarray] = []
         for image in images:
-            pil_image = context.images.get_pil(image.image_name)
+            pil_image = context.services.images.get_pil_image(image.image_name)
             pil_image = pil_image.convert("RGB")
             tile_np_images.append(np.array(pil_image))
 
@@ -287,5 +291,18 @@ class MergeTilesToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
         # Convert into a PIL image and save
         pil_image = Image.fromarray(np_image)
 
-        image_dto = context.images.save(image=pil_image)
-        return ImageOutput.build(image_dto)
+        image_dto = context.services.images.create(
+            image=pil_image,
+            image_origin=ResourceOrigin.INTERNAL,
+            image_category=ImageCategory.GENERAL,
+            node_id=self.id,
+            session_id=context.graph_execution_state_id,
+            is_intermediate=self.is_intermediate,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )

invokeai/app/invocations/upscale.py

@@ -8,15 +8,13 @@ import torch
 from PIL import Image
 from pydantic import ConfigDict
 
-from invokeai.app.invocations.fields import ImageField
-from invokeai.app.invocations.primitives import ImageOutput
-from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.app.invocations.primitives import ImageField, ImageOutput
+from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
 from invokeai.backend.image_util.basicsr.rrdbnet_arch import RRDBNet
 from invokeai.backend.image_util.realesrgan.realesrgan import RealESRGAN
 from invokeai.backend.util.devices import choose_torch_device
 
-from .baseinvocation import BaseInvocation, invocation
-from .fields import InputField, WithBoard, WithMetadata
+from .baseinvocation import BaseInvocation, InputField, InvocationContext, WithMetadata, invocation
 
 # TODO: Populate this from disk?
 # TODO: Use model manager to load?
@@ -31,8 +29,8 @@ if choose_torch_device() == torch.device("mps"):
     from torch import mps
 
 
-@invocation("esrgan", title="Upscale (RealESRGAN)", tags=["esrgan", "upscale"], category="esrgan", version="1.3.1")
-class ESRGANInvocation(BaseInvocation, WithMetadata, WithBoard):
+@invocation("esrgan", title="Upscale (RealESRGAN)", tags=["esrgan", "upscale"], category="esrgan", version="1.3.0")
+class ESRGANInvocation(BaseInvocation, WithMetadata):
     """Upscales an image using RealESRGAN."""
 
     image: ImageField = InputField(description="The input image")
@@ -44,8 +42,8 @@ class ESRGANInvocation(BaseInvocation, WithMetadata, WithBoard):
     model_config = ConfigDict(protected_namespaces=())
 
     def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name)
-        models_path = context.config.get().models_path
+        image = context.services.images.get_pil_image(self.image.image_name)
+        models_path = context.services.configuration.models_path
 
         rrdbnet_model = None
         netscale = None
@@ -89,7 +87,7 @@ class ESRGANInvocation(BaseInvocation, WithMetadata, WithBoard):
             netscale = 2
         else:
             msg = f"Invalid RealESRGAN model: {self.model_name}"
-            context.logger.error(msg)
+            context.services.logger.error(msg)
             raise ValueError(msg)
 
         esrgan_model_path = Path(f"core/upscaling/realesrgan/{self.model_name}")
@@ -112,6 +110,19 @@ class ESRGANInvocation(BaseInvocation, WithMetadata, WithBoard):
         if choose_torch_device() == torch.device("mps"):
             mps.empty_cache()
 
-        image_dto = context.images.save(image=pil_image)
+        image_dto = context.services.images.create(
+            image=pil_image,
+            image_origin=ResourceOrigin.INTERNAL,
+            image_category=ImageCategory.GENERAL,
+            node_id=self.id,
+            session_id=context.graph_execution_state_id,
+            is_intermediate=self.is_intermediate,
+            metadata=self.metadata,
+            workflow=context.workflow,
+        )
 
-        return ImageOutput.build(image_dto)
+        return ImageOutput(
+            image=ImageField(image_name=image_dto.image_name),
+            width=image_dto.width,
+            height=image_dto.height,
+        )

invokeai/app/services/events/events_base.py

@@ -54,7 +54,7 @@ class EventServiceBase:
         queue_item_id: int,
         queue_batch_id: str,
         graph_execution_state_id: str,
-        node_id: str,
+        node: dict,
         source_node_id: str,
         progress_image: Optional[ProgressImage],
         step: int,
@@ -69,7 +69,7 @@ class EventServiceBase:
                 "queue_item_id": queue_item_id,
                 "queue_batch_id": queue_batch_id,
                 "graph_execution_state_id": graph_execution_state_id,
-                "node_id": node_id,
+                "node_id": node.get("id"),
                 "source_node_id": source_node_id,
                 "progress_image": progress_image.model_dump() if progress_image is not None else None,
                 "step": step,

invokeai/app/services/image_files/image_files_base.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 from PIL.Image import Image as PILImageType
 
-from invokeai.app.invocations.fields import MetadataField
+from invokeai.app.invocations.baseinvocation import MetadataField
 from invokeai.app.services.workflow_records.workflow_records_common import WorkflowWithoutID
 
 

invokeai/app/services/image_files/image_files_disk.py

@@ -7,7 +7,7 @@ from PIL import Image, PngImagePlugin
 from PIL.Image import Image as PILImageType
 from send2trash import send2trash
 
-from invokeai.app.invocations.fields import MetadataField
+from invokeai.app.invocations.baseinvocation import MetadataField
 from invokeai.app.services.invoker import Invoker
 from invokeai.app.services.workflow_records.workflow_records_common import WorkflowWithoutID
 from invokeai.app.util.thumbnails import get_thumbnail_name, make_thumbnail

invokeai/app/services/image_records/image_records_base.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 from datetime import datetime
 from typing import Optional
 
-from invokeai.app.invocations.fields import MetadataField
+from invokeai.app.invocations.metadata import MetadataField
 from invokeai.app.services.shared.pagination import OffsetPaginatedResults
 
 from .image_records_common import ImageCategory, ImageRecord, ImageRecordChanges, ResourceOrigin

invokeai/app/services/image_records/image_records_sqlite.py

@@ -3,7 +3,7 @@ import threading
 from datetime import datetime
 from typing import Optional, Union, cast
 
-from invokeai.app.invocations.fields import MetadataField, MetadataFieldValidator
+from invokeai.app.invocations.baseinvocation import MetadataField, MetadataFieldValidator
 from invokeai.app.services.shared.pagination import OffsetPaginatedResults
 from invokeai.app.services.shared.sqlite.sqlite_database import SqliteDatabase
 

invokeai/app/services/images/images_base.py

@@ -3,7 +3,7 @@ from typing import Callable, Optional
 
 from PIL.Image import Image as PILImageType
 
-from invokeai.app.invocations.fields import MetadataField
+from invokeai.app.invocations.baseinvocation import MetadataField
 from invokeai.app.services.image_records.image_records_common import (
     ImageCategory,
     ImageRecord,

invokeai/app/services/images/images_default.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from PIL.Image import Image as PILImageType
 
-from invokeai.app.invocations.fields import MetadataField
+from invokeai.app.invocations.baseinvocation import MetadataField
 from invokeai.app.services.invoker import Invoker
 from invokeai.app.services.shared.pagination import OffsetPaginatedResults
 from invokeai.app.services.workflow_records.workflow_records_common import WorkflowWithoutID
@@ -154,7 +154,7 @@ class ImageService(ImageServiceABC):
             self.__invoker.services.logger.error("Image record not found")
             raise
         except Exception as e:
-            self.__invoker.services.logger.error("Problem getting image metadata")
+            self.__invoker.services.logger.error("Problem getting image DTO")
             raise e
 
     def get_workflow(self, image_name: str) -> Optional[WorkflowWithoutID]:

invokeai/app/services/invocation_cache/invocation_cache_memory.py

@@ -37,8 +37,7 @@ class MemoryInvocationCache(InvocationCacheBase):
         if self._max_cache_size == 0:
             return
         self._invoker.services.images.on_deleted(self._delete_by_match)
-        self._invoker.services.tensors.on_deleted(self._delete_by_match)
-        self._invoker.services.conditioning.on_deleted(self._delete_by_match)
+        self._invoker.services.latents.on_deleted(self._delete_by_match)
 
     def get(self, key: Union[int, str]) -> Optional[BaseInvocationOutput]:
         with self._lock:

invokeai/app/services/invocation_processor/invocation_processor_default.py

@@ -5,11 +5,11 @@ from threading import BoundedSemaphore, Event, Thread
 from typing import Optional
 
 import invokeai.backend.util.logging as logger
+from invokeai.app.invocations.baseinvocation import InvocationContext
 from invokeai.app.services.invocation_queue.invocation_queue_common import InvocationQueueItem
 from invokeai.app.services.invocation_stats.invocation_stats_common import (
     GESStatsNotFoundError,
 )
-from invokeai.app.services.shared.invocation_context import InvocationContextData, build_invocation_context
 from invokeai.app.util.profiler import Profiler
 
 from ..invoker import Invoker
@@ -24,10 +24,8 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
     __threadLimit: BoundedSemaphore
 
     def start(self, invoker: Invoker) -> None:
-        # LS - this will probably break
-        # but the idea is to enable multithreading up to the number of available
-        # GPUs. Nodes will block on model loading if no GPU is free.
-        self.__threadLimit = BoundedSemaphore(invoker.services.model_manager.gpu_count)
+        # 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(
@@ -133,20 +131,16 @@ class DefaultInvocationProcessor(InvocationProcessorABC):
                         # which handles a few things:
                         # - nodes that require a value, but get it only from a connection
                         # - referencing the invocation cache instead of executing the node
-                        context_data = InvocationContextData(
-                            invocation=invocation,
-                            session_id=graph_id,
-                            workflow=queue_item.workflow,
-                            source_node_id=source_node_id,
-                            queue_id=queue_item.session_queue_id,
-                            queue_item_id=queue_item.session_queue_item_id,
-                            batch_id=queue_item.session_queue_batch_id,
+                        outputs = invocation.invoke_internal(
+                            InvocationContext(
+                                services=self.__invoker.services,
+                                graph_execution_state_id=graph_execution_state.id,
+                                queue_item_id=queue_item.session_queue_item_id,
+                                queue_id=queue_item.session_queue_id,
+                                queue_batch_id=queue_item.session_queue_batch_id,
+                                workflow=queue_item.workflow,
+                            )
                         )
-                        context = build_invocation_context(
-                            services=self.__invoker.services,
-                            context_data=context_data,
-                        )
-                        outputs = invocation.invoke_internal(context=context, services=self.__invoker.services)
 
                         # Check queue to see if this is canceled, and skip if so
                         if self.__invoker.services.queue.is_canceled(graph_execution_state.id):

invokeai/app/services/invocation_services.py

@@ -3,15 +3,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from invokeai.app.services.object_serializer.object_serializer_base import ObjectSerializerBase
-
 if TYPE_CHECKING:
     from logging import Logger
 
-    import torch
-
-    from invokeai.backend.stable_diffusion.diffusion.conditioning_data import ConditioningFieldData
-
     from .board_image_records.board_image_records_base import BoardImageRecordStorageBase
     from .board_images.board_images_base import BoardImagesServiceABC
     from .board_records.board_records_base import BoardRecordStorageBase
@@ -27,6 +21,7 @@ if TYPE_CHECKING:
     from .invocation_queue.invocation_queue_base import InvocationQueueABC
     from .invocation_stats.invocation_stats_base import InvocationStatsServiceBase
     from .item_storage.item_storage_base import ItemStorageABC
+    from .latents_storage.latents_storage_base import LatentsStorageBase
     from .model_manager.model_manager_base import ModelManagerServiceBase
     from .names.names_base import NameServiceBase
     from .session_processor.session_processor_base import SessionProcessorBase
@@ -39,6 +34,31 @@ if TYPE_CHECKING:
 class InvocationServices:
     """Services that can be used by invocations"""
 
+    # TODO: Just forward-declared everything due to circular dependencies. Fix structure.
+    board_images: "BoardImagesServiceABC"
+    board_image_record_storage: "BoardImageRecordStorageBase"
+    boards: "BoardServiceABC"
+    board_records: "BoardRecordStorageBase"
+    configuration: "InvokeAIAppConfig"
+    events: "EventServiceBase"
+    graph_execution_manager: "ItemStorageABC[GraphExecutionState]"
+    images: "ImageServiceABC"
+    image_records: "ImageRecordStorageBase"
+    image_files: "ImageFileStorageBase"
+    latents: "LatentsStorageBase"
+    logger: "Logger"
+    model_manager: "ModelManagerServiceBase"
+    download_queue: "DownloadQueueServiceBase"
+    processor: "InvocationProcessorABC"
+    performance_statistics: "InvocationStatsServiceBase"
+    queue: "InvocationQueueABC"
+    session_queue: "SessionQueueBase"
+    session_processor: "SessionProcessorBase"
+    invocation_cache: "InvocationCacheBase"
+    names: "NameServiceBase"
+    urls: "UrlServiceBase"
+    workflow_records: "WorkflowRecordsStorageBase"
+
     def __init__(
         self,
         board_images: "BoardImagesServiceABC",
@@ -51,6 +71,7 @@ class InvocationServices:
         images: "ImageServiceABC",
         image_files: "ImageFileStorageBase",
         image_records: "ImageRecordStorageBase",
+        latents: "LatentsStorageBase",
         logger: "Logger",
         model_manager: "ModelManagerServiceBase",
         download_queue: "DownloadQueueServiceBase",
@@ -63,8 +84,6 @@ class InvocationServices:
         names: "NameServiceBase",
         urls: "UrlServiceBase",
         workflow_records: "WorkflowRecordsStorageBase",
-        tensors: "ObjectSerializerBase[torch.Tensor]",
-        conditioning: "ObjectSerializerBase[ConditioningFieldData]",
     ):
         self.board_images = board_images
         self.board_image_records = board_image_records
@@ -76,6 +95,7 @@ class InvocationServices:
         self.images = images
         self.image_files = image_files
         self.image_records = image_records
+        self.latents = latents
         self.logger = logger
         self.model_manager = model_manager
         self.download_queue = download_queue
@@ -88,5 +108,3 @@ class InvocationServices:
         self.names = names
         self.urls = urls
         self.workflow_records = workflow_records
-        self.tensors = tensors
-        self.conditioning = conditioning

invokeai/app/services/item_storage/item_storage_base.py

@@ -30,7 +30,7 @@ class ItemStorageABC(ABC, Generic[T]):
     @abstractmethod
     def set(self, item: T) -> None:
         """
-        Sets the item.
+        Sets the item. The id will be extracted based on id_field.
         :param item: the item to set
         """
         pass

invokeai/app/services/latents_storage/latents_storage_base.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
+
+from abc import ABC, abstractmethod
+from typing import Callable, Union
+
+import torch
+
+from invokeai.app.invocations.compel import ConditioningFieldData
+
+
+class LatentsStorageBase(ABC):
+    """Responsible for storing and retrieving latents."""
+
+    _on_changed_callbacks: list[Callable[[torch.Tensor], None]]
+    _on_deleted_callbacks: list[Callable[[str], None]]
+
+    def __init__(self) -> None:
+        self._on_changed_callbacks = []
+        self._on_deleted_callbacks = []
+
+    @abstractmethod
+    def get(self, name: str) -> torch.Tensor:
+        pass
+
+    # (LS) Added a Union with ConditioningFieldData to fix type mismatch errors in compel.py
+    # Not 100% sure this isn't an existing bug.
+    @abstractmethod
+    def save(self, name: str, data: Union[torch.Tensor, ConditioningFieldData]) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, name: str) -> None:
+        pass
+
+    def on_changed(self, on_changed: Callable[[torch.Tensor], None]) -> None:
+        """Register a callback for when an item is changed"""
+        self._on_changed_callbacks.append(on_changed)
+
+    def on_deleted(self, on_deleted: Callable[[str], None]) -> None:
+        """Register a callback for when an item is deleted"""
+        self._on_deleted_callbacks.append(on_deleted)
+
+    def _on_changed(self, item: torch.Tensor) -> None:
+        for callback in self._on_changed_callbacks:
+            callback(item)
+
+    def _on_deleted(self, item_id: str) -> None:
+        for callback in self._on_deleted_callbacks:
+            callback(item_id)

invokeai/app/services/latents_storage/latents_storage_disk.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
+
+from pathlib import Path
+from typing import Union
+
+import torch
+
+from invokeai.app.invocations.compel import ConditioningFieldData
+from invokeai.app.services.invoker import Invoker
+
+from .latents_storage_base import LatentsStorageBase
+
+
+class DiskLatentsStorage(LatentsStorageBase):
+    """Stores latents in a folder on disk without caching"""
+
+    __output_folder: Path
+
+    def __init__(self, output_folder: Union[str, Path]):
+        self.__output_folder = output_folder if isinstance(output_folder, Path) else Path(output_folder)
+        self.__output_folder.mkdir(parents=True, exist_ok=True)
+
+    def start(self, invoker: Invoker) -> None:
+        self._invoker = invoker
+        self._delete_all_latents()
+
+    def get(self, name: str) -> torch.Tensor:
+        latent_path = self.get_path(name)
+        return torch.load(latent_path)
+
+    def save(self, name: str, data: Union[torch.Tensor, ConditioningFieldData]) -> None:
+        self.__output_folder.mkdir(parents=True, exist_ok=True)
+        latent_path = self.get_path(name)
+        torch.save(data, latent_path)
+
+    def delete(self, name: str) -> None:
+        latent_path = self.get_path(name)
+        latent_path.unlink()
+
+    def get_path(self, name: str) -> Path:
+        return self.__output_folder / name
+
+    def _delete_all_latents(self) -> None:
+        """
+        Deletes all latents from disk.
+        Must be called after we have access to `self._invoker` (e.g. in `start()`).
+        """
+        deleted_latents_count = 0
+        freed_space = 0
+        for latents_file in Path(self.__output_folder).glob("*"):
+            if latents_file.is_file():
+                freed_space += latents_file.stat().st_size
+                deleted_latents_count += 1
+                latents_file.unlink()
+        if deleted_latents_count > 0:
+            freed_space_in_mb = round(freed_space / 1024 / 1024, 2)
+            self._invoker.services.logger.info(
+                f"Deleted {deleted_latents_count} latents files (freed {freed_space_in_mb}MB)"
+            )

invokeai/app/services/latents_storage/latents_storage_forward_cache.py

@@ -0,0 +1,71 @@
+# Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
+
+from queue import Queue
+from typing import Dict, Optional, Union
+
+import torch
+
+from invokeai.app.invocations.compel import ConditioningFieldData
+from invokeai.app.services.invoker import Invoker
+
+from .latents_storage_base import LatentsStorageBase
+
+
+class ForwardCacheLatentsStorage(LatentsStorageBase):
+    """Caches the latest N latents in memory, writing-thorugh to and reading from underlying storage"""
+
+    __cache: Dict[str, torch.Tensor]
+    __cache_ids: Queue
+    __max_cache_size: int
+    __underlying_storage: LatentsStorageBase
+
+    def __init__(self, underlying_storage: LatentsStorageBase, max_cache_size: int = 20):
+        super().__init__()
+        self.__underlying_storage = underlying_storage
+        self.__cache = {}
+        self.__cache_ids = Queue()
+        self.__max_cache_size = max_cache_size
+
+    def start(self, invoker: Invoker) -> None:
+        self._invoker = invoker
+        start_op = getattr(self.__underlying_storage, "start", None)
+        if callable(start_op):
+            start_op(invoker)
+
+    def stop(self, invoker: Invoker) -> None:
+        self._invoker = invoker
+        stop_op = getattr(self.__underlying_storage, "stop", None)
+        if callable(stop_op):
+            stop_op(invoker)
+
+    def get(self, name: str) -> torch.Tensor:
+        cache_item = self.__get_cache(name)
+        if cache_item is not None:
+            return cache_item
+
+        latent = self.__underlying_storage.get(name)
+        self.__set_cache(name, latent)
+        return latent
+
+    # TODO: (LS) ConditioningFieldData added as Union because of type-checking errors
+    # in compel.py. Unclear whether this is a long-standing bug, but seems to run.
+    def save(self, name: str, data: Union[torch.Tensor, ConditioningFieldData]) -> None:
+        self.__underlying_storage.save(name, data)
+        self.__set_cache(name, data)
+        self._on_changed(data)
+
+    def delete(self, name: str) -> None:
+        self.__underlying_storage.delete(name)
+        if name in self.__cache:
+            del self.__cache[name]
+        self._on_deleted(name)
+
+    def __get_cache(self, name: str) -> Optional[torch.Tensor]:
+        return None if name not in self.__cache else self.__cache[name]
+
+    def __set_cache(self, name: str, data: torch.Tensor):
+        if name not in self.__cache:
+            self.__cache[name] = data
+            self.__cache_ids.put(name)
+            if self.__cache_ids.qsize() > self.__max_cache_size:
+                self.__cache.pop(self.__cache_ids.get())

invokeai/app/services/model_load/model_load_base.py

@@ -4,7 +4,7 @@
 from abc import ABC, abstractmethod
 from typing import Optional
 
-from invokeai.app.services.shared.invocation_context import InvocationContextData
+from invokeai.app.invocations.baseinvocation import InvocationContext
 from invokeai.backend.model_manager import AnyModel, AnyModelConfig, SubModelType
 from invokeai.backend.model_manager.load import LoadedModel
 from invokeai.backend.model_manager.load.convert_cache import ModelConvertCacheBase
@@ -19,14 +19,14 @@ class ModelLoadServiceBase(ABC):
         self,
         model_config: AnyModelConfig,
         submodel_type: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
+        context: Optional[InvocationContext] = None,
     ) -> LoadedModel:
         """
         Given a model's configuration, load it and return the LoadedModel object.
 
         :param model_config: Model configuration record (as returned by ModelRecordBase.get_model())
         :param submodel: For main (pipeline models), the submodel to fetch.
-        :param context_data: Invocation context data used for event reporting
+        :param context: Invocation context used for event reporting
         """
 
     @property
@@ -38,8 +38,3 @@ class ModelLoadServiceBase(ABC):
     @abstractmethod
     def convert_cache(self) -> ModelConvertCacheBase:
         """Return the checkpoint convert cache used by this loader."""
-
-    @property
-    @abstractmethod
-    def gpu_count(self) -> int:
-        """Return the number of GPUs we are configured to use."""

invokeai/app/services/model_load/model_load_default.py

@@ -3,16 +3,11 @@
 
 from typing import Optional, Type
 
+from invokeai.app.invocations.baseinvocation import InvocationContext
 from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.app.services.invocation_processor.invocation_processor_common import CanceledException
-from invokeai.app.services.invoker import Invoker
-from invokeai.app.services.shared.invocation_context import InvocationContextData
 from invokeai.backend.model_manager import AnyModel, AnyModelConfig, SubModelType
-from invokeai.backend.model_manager.load import (
-    LoadedModel,
-    ModelLoaderRegistry,
-    ModelLoaderRegistryBase,
-)
+from invokeai.backend.model_manager.load import LoadedModel, ModelLoaderRegistry, ModelLoaderRegistryBase
 from invokeai.backend.model_manager.load.convert_cache import ModelConvertCacheBase
 from invokeai.backend.model_manager.load.model_cache.model_cache_base import ModelCacheBase
 from invokeai.backend.util.logging import InvokeAILogger
@@ -39,20 +34,11 @@ class ModelLoadService(ModelLoadServiceBase):
         self._convert_cache = convert_cache
         self._registry = registry
 
-    def start(self, invoker: Invoker) -> None:
-        """Start the service."""
-        self._invoker = invoker
-
     @property
     def ram_cache(self) -> ModelCacheBase[AnyModel]:
         """Return the RAM cache used by this loader."""
         return self._ram_cache
 
-    @property
-    def gpu_count(self) -> int:
-        """Return the number of GPUs available for our uses."""
-        return len(self._ram_cache.execution_devices)
-
     @property
     def convert_cache(self) -> ModelConvertCacheBase:
         """Return the checkpoint convert cache used by this loader."""
@@ -62,7 +48,7 @@ class ModelLoadService(ModelLoadServiceBase):
         self,
         model_config: AnyModelConfig,
         submodel_type: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
+        context: Optional[InvocationContext] = None,
     ) -> LoadedModel:
         """
         Given a model's configuration, load it and return the LoadedModel object.
@@ -71,9 +57,9 @@ class ModelLoadService(ModelLoadServiceBase):
         :param submodel: For main (pipeline models), the submodel to fetch.
         :param context: Invocation context used for event reporting
         """
-        if context_data:
+        if context:
             self._emit_load_event(
-                context_data=context_data,
+                context=context,
                 model_config=model_config,
             )
 
@@ -85,9 +71,9 @@ class ModelLoadService(ModelLoadServiceBase):
             convert_cache=self._convert_cache,
         ).load_model(model_config, submodel_type)
 
-        if context_data:
+        if context:
             self._emit_load_event(
-                context_data=context_data,
+                context=context,
                 model_config=model_config,
                 loaded=True,
             )
@@ -95,28 +81,26 @@ class ModelLoadService(ModelLoadServiceBase):
 
     def _emit_load_event(
         self,
-        context_data: InvocationContextData,
+        context: InvocationContext,
         model_config: AnyModelConfig,
         loaded: Optional[bool] = False,
     ) -> None:
-        if not self._invoker:
-            return
-        if self._invoker.services.queue.is_canceled(context_data.session_id):
+        if context.services.queue.is_canceled(context.graph_execution_state_id):
             raise CanceledException()
 
         if not loaded:
-            self._invoker.services.events.emit_model_load_started(
-                queue_id=context_data.queue_id,
-                queue_item_id=context_data.queue_item_id,
-                queue_batch_id=context_data.batch_id,
-                graph_execution_state_id=context_data.session_id,
+            context.services.events.emit_model_load_started(
+                queue_id=context.queue_id,
+                queue_item_id=context.queue_item_id,
+                queue_batch_id=context.queue_batch_id,
+                graph_execution_state_id=context.graph_execution_state_id,
                 model_config=model_config,
             )
         else:
-            self._invoker.services.events.emit_model_load_completed(
-                queue_id=context_data.queue_id,
-                queue_item_id=context_data.queue_item_id,
-                queue_batch_id=context_data.batch_id,
-                graph_execution_state_id=context_data.session_id,
+            context.services.events.emit_model_load_completed(
+                queue_id=context.queue_id,
+                queue_item_id=context.queue_item_id,
+                queue_batch_id=context.queue_batch_id,
+                graph_execution_state_id=context.graph_execution_state_id,
                 model_config=model_config,
             )

invokeai/app/services/model_manager/model_manager_base.py

@@ -1,14 +1,10 @@
 # Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Team
 
 from abc import ABC, abstractmethod
-from typing import Optional
 
 from typing_extensions import Self
 
 from invokeai.app.services.invoker import Invoker
-from invokeai.app.services.shared.invocation_context import InvocationContextData
-from invokeai.backend.model_manager.config import AnyModelConfig, BaseModelType, ModelType, SubModelType
-from invokeai.backend.model_manager.load.load_base import LoadedModel
 
 from ..config import InvokeAIAppConfig
 from ..download import DownloadQueueServiceBase
@@ -69,37 +65,3 @@ class ModelManagerServiceBase(ABC):
     @abstractmethod
     def stop(self, invoker: Invoker) -> None:
         pass
-
-    @abstractmethod
-    def load_model_by_config(
-        self,
-        model_config: AnyModelConfig,
-        submodel_type: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
-    ) -> LoadedModel:
-        pass
-
-    @abstractmethod
-    def load_model_by_key(
-        self,
-        key: str,
-        submodel_type: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
-    ) -> LoadedModel:
-        pass
-
-    @abstractmethod
-    def load_model_by_attr(
-        self,
-        model_name: str,
-        base_model: BaseModelType,
-        model_type: ModelType,
-        submodel: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
-    ) -> LoadedModel:
-        pass
-
-    @property
-    @abstractmethod
-    def gpu_count(self) -> int:
-        """Return the number of GPUs we are configured to use."""

invokeai/app/services/model_manager/model_manager_default.py

@@ -5,8 +5,8 @@ from typing import Optional
 
 from typing_extensions import Self
 
+from invokeai.app.invocations.baseinvocation import InvocationContext
 from invokeai.app.services.invoker import Invoker
-from invokeai.app.services.shared.invocation_context import InvocationContextData
 from invokeai.backend.model_manager import AnyModelConfig, BaseModelType, LoadedModel, ModelType, SubModelType
 from invokeai.backend.model_manager.load import ModelCache, ModelConvertCache, ModelLoaderRegistry
 from invokeai.backend.util.logging import InvokeAILogger
@@ -66,18 +66,18 @@ class ModelManagerService(ModelManagerServiceBase):
         self,
         model_config: AnyModelConfig,
         submodel_type: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
+        context: Optional[InvocationContext] = None,
     ) -> LoadedModel:
-        return self.load.load_model(model_config, submodel_type, context_data)
+        return self.load.load_model(model_config, submodel_type, context)
 
     def load_model_by_key(
         self,
         key: str,
         submodel_type: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
+        context: Optional[InvocationContext] = None,
     ) -> LoadedModel:
         config = self.store.get_model(key)
-        return self.load.load_model(config, submodel_type, context_data)
+        return self.load.load_model(config, submodel_type, context)
 
     def load_model_by_attr(
         self,
@@ -85,7 +85,7 @@ class ModelManagerService(ModelManagerServiceBase):
         base_model: BaseModelType,
         model_type: ModelType,
         submodel: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
+        context: Optional[InvocationContext] = None,
     ) -> LoadedModel:
         """
         Given a model's attributes, search the database for it, and if found, load and return the LoadedModel object.
@@ -110,12 +110,7 @@ class ModelManagerService(ModelManagerServiceBase):
         elif len(configs) > 1:
             raise ValueError(f"{base_model}/{model_type}/{model_name}: More than one model matches.")
         else:
-            return self.load.load_model(configs[0], submodel, context_data)
-
-    @property
-    def gpu_count(self) -> int:
-        """Return the number of GPUs we are using."""
-        return self.load.gpu_count
+            return self.load.load_model(configs[0], submodel, context)
 
     @classmethod
     def build_model_manager(

invokeai/app/services/object_serializer/object_serializer_base.py

@@ -1,44 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Callable, Generic, TypeVar
-
-T = TypeVar("T")
-
-
-class ObjectSerializerBase(ABC, Generic[T]):
-    """Saves and loads arbitrary python objects."""
-
-    def __init__(self) -> None:
-        self._on_deleted_callbacks: list[Callable[[str], None]] = []
-
-    @abstractmethod
-    def load(self, name: str) -> T:
-        """
-        Loads the object.
-        :param name: The name of the object to load.
-        :raises ObjectNotFoundError: if the object is not found
-        """
-        pass
-
-    @abstractmethod
-    def save(self, obj: T) -> str:
-        """
-        Saves the object, returning its name.
-        :param obj: The object to save.
-        """
-        pass
-
-    @abstractmethod
-    def delete(self, name: str) -> None:
-        """
-        Deletes the object, if it exists.
-        :param name: The name of the object to delete.
-        """
-        pass
-
-    def on_deleted(self, on_deleted: Callable[[str], None]) -> None:
-        """Register a callback for when an object is deleted"""
-        self._on_deleted_callbacks.append(on_deleted)
-
-    def _on_deleted(self, name: str) -> None:
-        for callback in self._on_deleted_callbacks:
-            callback(name)

invokeai/app/services/object_serializer/object_serializer_common.py

@@ -1,5 +0,0 @@
-class ObjectNotFoundError(KeyError):
-    """Raised when an object is not found while loading"""
-
-    def __init__(self, name: str) -> None:
-        super().__init__(f"Object with name {name} not found")

invokeai/app/services/object_serializer/object_serializer_disk.py

@@ -1,85 +0,0 @@
-import tempfile
-import typing
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TYPE_CHECKING, Optional, TypeVar
-
-import torch
-
-from invokeai.app.services.object_serializer.object_serializer_base import ObjectSerializerBase
-from invokeai.app.services.object_serializer.object_serializer_common import ObjectNotFoundError
-from invokeai.app.util.misc import uuid_string
-
-if TYPE_CHECKING:
-    from invokeai.app.services.invoker import Invoker
-
-
-T = TypeVar("T")
-
-
-@dataclass
-class DeleteAllResult:
-    deleted_count: int
-    freed_space_bytes: float
-
-
-class ObjectSerializerDisk(ObjectSerializerBase[T]):
-    """Disk-backed storage for arbitrary python objects. Serialization is handled by `torch.save` and `torch.load`.
-
-    :param output_dir: The folder where the serialized objects will be stored
-    :param ephemeral: If True, objects will be stored in a temporary directory inside the given output_dir and cleaned up on exit
-    """
-
-    def __init__(self, output_dir: Path, ephemeral: bool = False):
-        super().__init__()
-        self._ephemeral = ephemeral
-        self._base_output_dir = output_dir
-        self._base_output_dir.mkdir(parents=True, exist_ok=True)
-        # Must specify `ignore_cleanup_errors` to avoid fatal errors during cleanup on Windows
-        self._tempdir = (
-            tempfile.TemporaryDirectory(dir=self._base_output_dir, ignore_cleanup_errors=True) if ephemeral else None
-        )
-        self._output_dir = Path(self._tempdir.name) if self._tempdir else self._base_output_dir
-        self.__obj_class_name: Optional[str] = None
-
-    def load(self, name: str) -> T:
-        file_path = self._get_path(name)
-        try:
-            return torch.load(file_path)  # pyright: ignore [reportUnknownMemberType]
-        except FileNotFoundError as e:
-            raise ObjectNotFoundError(name) from e
-
-    def save(self, obj: T) -> str:
-        name = self._new_name()
-        file_path = self._get_path(name)
-        torch.save(obj, file_path)  # pyright: ignore [reportUnknownMemberType]
-        return name
-
-    def delete(self, name: str) -> None:
-        file_path = self._get_path(name)
-        file_path.unlink()
-
-    @property
-    def _obj_class_name(self) -> str:
-        if not self.__obj_class_name:
-            # `__orig_class__` is not available in the constructor for some technical, undoubtedly very pythonic reason
-            self.__obj_class_name = typing.get_args(self.__orig_class__)[0].__name__  # pyright: ignore [reportUnknownMemberType, reportAttributeAccessIssue]
-        return self.__obj_class_name
-
-    def _get_path(self, name: str) -> Path:
-        return self._output_dir / name
-
-    def _new_name(self) -> str:
-        return f"{self._obj_class_name}_{uuid_string()}"
-
-    def _tempdir_cleanup(self) -> None:
-        """Calls `cleanup` on the temporary directory, if it exists."""
-        if self._tempdir:
-            self._tempdir.cleanup()
-
-    def __del__(self) -> None:
-        # In case the service is not properly stopped, clean up the temporary directory when the class instance is GC'd.
-        self._tempdir_cleanup()
-
-    def stop(self, invoker: "Invoker") -> None:
-        self._tempdir_cleanup()

invokeai/app/services/object_serializer/object_serializer_forward_cache.py

@@ -1,65 +0,0 @@
-from queue import Queue
-from typing import TYPE_CHECKING, Optional, TypeVar
-
-from invokeai.app.services.object_serializer.object_serializer_base import ObjectSerializerBase
-
-T = TypeVar("T")
-
-if TYPE_CHECKING:
-    from invokeai.app.services.invoker import Invoker
-
-
-class ObjectSerializerForwardCache(ObjectSerializerBase[T]):
-    """
-    Provides a LRU cache for an instance of `ObjectSerializerBase`.
-    Saving an object to the cache always writes through to the underlying storage.
-    """
-
-    def __init__(self, underlying_storage: ObjectSerializerBase[T], max_cache_size: int = 20):
-        super().__init__()
-        self._underlying_storage = underlying_storage
-        self._cache: dict[str, T] = {}
-        self._cache_ids = Queue[str]()
-        self._max_cache_size = max_cache_size
-
-    def start(self, invoker: "Invoker") -> None:
-        self._invoker = invoker
-        start_op = getattr(self._underlying_storage, "start", None)
-        if callable(start_op):
-            start_op(invoker)
-
-    def stop(self, invoker: "Invoker") -> None:
-        self._invoker = invoker
-        stop_op = getattr(self._underlying_storage, "stop", None)
-        if callable(stop_op):
-            stop_op(invoker)
-
-    def load(self, name: str) -> T:
-        cache_item = self._get_cache(name)
-        if cache_item is not None:
-            return cache_item
-
-        obj = self._underlying_storage.load(name)
-        self._set_cache(name, obj)
-        return obj
-
-    def save(self, obj: T) -> str:
-        name = self._underlying_storage.save(obj)
-        self._set_cache(name, obj)
-        return name
-
-    def delete(self, name: str) -> None:
-        self._underlying_storage.delete(name)
-        if name in self._cache:
-            del self._cache[name]
-        self._on_deleted(name)
-
-    def _get_cache(self, name: str) -> Optional[T]:
-        return None if name not in self._cache else self._cache[name]
-
-    def _set_cache(self, name: str, data: T):
-        if name not in self._cache:
-            self._cache[name] = data
-            self._cache_ids.put(name)
-            if self._cache_ids.qsize() > self._max_cache_size:
-                self._cache.pop(self._cache_ids.get())

invokeai/app/services/shared/graph.py

@@ -13,11 +13,14 @@ from invokeai.app.invocations import *  # noqa: F401 F403
 from invokeai.app.invocations.baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
+    Input,
+    InputField,
+    InvocationContext,
+    OutputField,
+    UIType,
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import Input, InputField, OutputField, UIType
-from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.misc import uuid_string
 
 # in 3.10 this would be "from types import NoneType"
@@ -537,7 +540,7 @@ class Graph(BaseModel):
         except NodeNotFoundError:
             return False
 
-    def get_node(self, node_path: str) -> BaseInvocation:
+    def get_node(self, node_path: str) -> InvocationsUnion:
         """Gets a node from the graph using a node path."""
         # Materialized graphs may have nodes at the top level
         graph, node_id = self._get_graph_and_node(node_path)
@@ -888,7 +891,7 @@ class GraphExecutionState(BaseModel):
         # If next is still none, there's no next node, return None
         return next_node
 
-    def complete(self, node_id: str, output: BaseInvocationOutput) -> None:
+    def complete(self, node_id: str, output: InvocationOutputsUnion):
         """Marks a node as complete"""
 
         if node_id not in self.execution_graph.nodes:

invokeai/app/services/shared/invocation_context.py

@@ -1,471 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TYPE_CHECKING, Optional
-
-from PIL.Image import Image
-from torch import Tensor
-
-from invokeai.app.invocations.constants import IMAGE_MODES
-from invokeai.app.invocations.fields import MetadataField, WithBoard, WithMetadata
-from invokeai.app.services.boards.boards_common import BoardDTO
-from invokeai.app.services.config.config_default import InvokeAIAppConfig
-from invokeai.app.services.image_records.image_records_common import ImageCategory, ResourceOrigin
-from invokeai.app.services.images.images_common import ImageDTO
-from invokeai.app.services.invocation_services import InvocationServices
-from invokeai.app.services.workflow_records.workflow_records_common import WorkflowWithoutID
-from invokeai.app.util.step_callback import stable_diffusion_step_callback
-from invokeai.backend.model_manager.config import AnyModelConfig, BaseModelType, ModelFormat, ModelType, SubModelType
-from invokeai.backend.model_manager.load.load_base import LoadedModel
-from invokeai.backend.model_manager.metadata.metadata_base import AnyModelRepoMetadata
-from invokeai.backend.stable_diffusion.diffusers_pipeline import PipelineIntermediateState
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import ConditioningFieldData
-
-if TYPE_CHECKING:
-    from invokeai.app.invocations.baseinvocation import BaseInvocation
-
-"""
-The InvocationContext provides access to various services and data about the current invocation.
-
-We do not provide the invocation services directly, as their methods are both dangerous and
-inconvenient to use.
-
-For example:
-- The `images` service allows nodes to delete or unsafely modify existing images.
-- The `configuration` service allows nodes to change the app's config at runtime.
-- The `events` service allows nodes to emit arbitrary events.
-
-Wrapping these services provides a simpler and safer interface for nodes to use.
-
-When a node executes, a fresh `InvocationContext` is built for it, ensuring nodes cannot interfere
-with each other.
-
-Many of the wrappers have the same signature as the methods they wrap. This allows us to write
-user-facing docstrings and not need to go and update the internal services to match.
-
-Note: The docstrings are in weird places, but that's where they must be to get IDEs to see them.
-"""
-
-
-@dataclass
-class InvocationContextData:
-    invocation: "BaseInvocation"
-    """The invocation that is being executed."""
-    session_id: str
-    """The session that is being executed."""
-    queue_id: str
-    """The queue in which the session is being executed."""
-    source_node_id: str
-    """The ID of the node from which the currently executing invocation was prepared."""
-    queue_item_id: int
-    """The ID of the queue item that is being executed."""
-    batch_id: str
-    """The ID of the batch that is being executed."""
-    workflow: Optional[WorkflowWithoutID] = None
-    """The workflow associated with this queue item, if any."""
-
-
-class InvocationContextInterface:
-    def __init__(self, services: InvocationServices, context_data: InvocationContextData) -> None:
-        self._services = services
-        self._context_data = context_data
-
-
-class BoardsInterface(InvocationContextInterface):
-    def create(self, board_name: str) -> BoardDTO:
-        """
-        Creates a board.
-
-        :param board_name: The name of the board to create.
-        """
-        return self._services.boards.create(board_name)
-
-    def get_dto(self, board_id: str) -> BoardDTO:
-        """
-        Gets a board DTO.
-
-        :param board_id: The ID of the board to get.
-        """
-        return self._services.boards.get_dto(board_id)
-
-    def get_all(self) -> list[BoardDTO]:
-        """
-        Gets all boards.
-        """
-        return self._services.boards.get_all()
-
-    def add_image_to_board(self, board_id: str, image_name: str) -> None:
-        """
-        Adds an image to a board.
-
-        :param board_id: The ID of the board to add the image to.
-        :param image_name: The name of the image to add to the board.
-        """
-        return self._services.board_images.add_image_to_board(board_id, image_name)
-
-    def get_all_image_names_for_board(self, board_id: str) -> list[str]:
-        """
-        Gets all image names for a board.
-
-        :param board_id: The ID of the board to get the image names for.
-        """
-        return self._services.board_images.get_all_board_image_names_for_board(board_id)
-
-
-class LoggerInterface(InvocationContextInterface):
-    def debug(self, message: str) -> None:
-        """
-        Logs a debug message.
-
-        :param message: The message to log.
-        """
-        self._services.logger.debug(message)
-
-    def info(self, message: str) -> None:
-        """
-        Logs an info message.
-
-        :param message: The message to log.
-        """
-        self._services.logger.info(message)
-
-    def warning(self, message: str) -> None:
-        """
-        Logs a warning message.
-
-        :param message: The message to log.
-        """
-        self._services.logger.warning(message)
-
-    def error(self, message: str) -> None:
-        """
-        Logs an error message.
-
-        :param message: The message to log.
-        """
-        self._services.logger.error(message)
-
-
-class ImagesInterface(InvocationContextInterface):
-    def save(
-        self,
-        image: Image,
-        board_id: Optional[str] = None,
-        image_category: ImageCategory = ImageCategory.GENERAL,
-        metadata: Optional[MetadataField] = None,
-    ) -> ImageDTO:
-        """
-        Saves an image, returning its DTO.
-
-        If the current queue item has a workflow or metadata, it is automatically saved with the image.
-
-        :param image: The image to save, as a PIL image.
-        :param board_id: The board ID to add the image to, if it should be added. It the invocation \
-            inherits from `WithBoard`, that board will be used automatically. **Use this only if \
-            you want to override or provide a board manually!**
-        :param image_category: The category of the image. Only the GENERAL category is added \
-            to the gallery.
-        :param metadata: The metadata to save with the image, if it should have any. If the \
-            invocation inherits from `WithMetadata`, that metadata will be used automatically. \
-            **Use this only if you want to override or provide metadata manually!**
-        """
-
-        # If `metadata` is provided directly, use that. Else, use the metadata provided by `WithMetadata`, falling back to None.
-        metadata_ = None
-        if metadata:
-            metadata_ = metadata
-        elif isinstance(self._context_data.invocation, WithMetadata):
-            metadata_ = self._context_data.invocation.metadata
-
-        # If `board_id` is provided directly, use that. Else, use the board provided by `WithBoard`, falling back to None.
-        board_id_ = None
-        if board_id:
-            board_id_ = board_id
-        elif isinstance(self._context_data.invocation, WithBoard) and self._context_data.invocation.board:
-            board_id_ = self._context_data.invocation.board.board_id
-
-        return self._services.images.create(
-            image=image,
-            is_intermediate=self._context_data.invocation.is_intermediate,
-            image_category=image_category,
-            board_id=board_id_,
-            metadata=metadata_,
-            image_origin=ResourceOrigin.INTERNAL,
-            workflow=self._context_data.workflow,
-            session_id=self._context_data.session_id,
-            node_id=self._context_data.invocation.id,
-        )
-
-    def get_pil(self, image_name: str, mode: IMAGE_MODES | None = None) -> Image:
-        """
-        Gets an image as a PIL Image object.
-
-        :param image_name: The name of the image to get.
-        :param mode: The color mode to convert the image to. If None, the original mode is used.
-        """
-        image = self._services.images.get_pil_image(image_name)
-        if mode and mode != image.mode:
-            try:
-                image = image.convert(mode)
-            except ValueError:
-                self._services.logger.warning(
-                    f"Could not convert image from {image.mode} to {mode}. Using original mode instead."
-                )
-        return image
-
-    def get_metadata(self, image_name: str) -> Optional[MetadataField]:
-        """
-        Gets an image's metadata, if it has any.
-
-        :param image_name: The name of the image to get the metadata for.
-        """
-        return self._services.images.get_metadata(image_name)
-
-    def get_dto(self, image_name: str) -> ImageDTO:
-        """
-        Gets an image as an ImageDTO object.
-
-        :param image_name: The name of the image to get.
-        """
-        return self._services.images.get_dto(image_name)
-
-
-class TensorsInterface(InvocationContextInterface):
-    def save(self, tensor: Tensor) -> str:
-        """
-        Saves a tensor, returning its name.
-
-        :param tensor: The tensor to save.
-        """
-
-        name = self._services.tensors.save(obj=tensor)
-        return name
-
-    def load(self, name: str) -> Tensor:
-        """
-        Loads a tensor by name.
-
-        :param name: The name of the tensor to load.
-        """
-        return self._services.tensors.load(name)
-
-
-class ConditioningInterface(InvocationContextInterface):
-    def save(self, conditioning_data: ConditioningFieldData) -> str:
-        """
-        Saves a conditioning data object, returning its name.
-
-        :param conditioning_context_data: The conditioning data to save.
-        """
-
-        name = self._services.conditioning.save(obj=conditioning_data)
-        return name
-
-    def load(self, name: str) -> ConditioningFieldData:
-        """
-        Loads conditioning data by name.
-
-        :param name: The name of the conditioning data to load.
-        """
-
-        return self._services.conditioning.load(name)
-
-
-class ModelsInterface(InvocationContextInterface):
-    def exists(self, key: str) -> bool:
-        """
-        Checks if a model exists.
-
-        :param key: The key of the model.
-        """
-        return self._services.model_manager.store.exists(key)
-
-    def load(self, key: str, submodel_type: Optional[SubModelType] = None) -> LoadedModel:
-        """
-        Loads a model.
-
-        :param key: The key of the model.
-        :param submodel_type: The submodel of the model to get.
-        :returns: An object representing the loaded model.
-        """
-
-        # The model manager emits events as it loads the model. It needs the context data to build
-        # the event payloads.
-
-        return self._services.model_manager.load_model_by_key(
-            key=key, submodel_type=submodel_type, context_data=self._context_data
-        )
-
-    def load_by_attrs(
-        self, model_name: str, base_model: BaseModelType, model_type: ModelType, submodel: Optional[SubModelType] = None
-    ) -> LoadedModel:
-        """
-        Loads a model by its attributes.
-
-        :param model_name: Name of to be fetched.
-        :param base_model: Base model
-        :param model_type: Type of the model
-        :param submodel: For main (pipeline models), the submodel to fetch
-        """
-        return self._services.model_manager.load_model_by_attr(
-            model_name=model_name,
-            base_model=base_model,
-            model_type=model_type,
-            submodel=submodel,
-            context_data=self._context_data,
-        )
-
-    def get_config(self, key: str) -> AnyModelConfig:
-        """
-        Gets a model's info, an dict-like object.
-
-        :param key: The key of the model.
-        """
-        return self._services.model_manager.store.get_model(key=key)
-
-    def get_metadata(self, key: str) -> Optional[AnyModelRepoMetadata]:
-        """
-        Gets a model's metadata, if it has any.
-
-        :param key: The key of the model.
-        """
-        return self._services.model_manager.store.get_metadata(key=key)
-
-    def search_by_path(self, path: Path) -> list[AnyModelConfig]:
-        """
-        Searches for models by path.
-
-        :param path: The path to search for.
-        """
-        return self._services.model_manager.store.search_by_path(path)
-
-    def search_by_attrs(
-        self,
-        model_name: Optional[str] = None,
-        base_model: Optional[BaseModelType] = None,
-        model_type: Optional[ModelType] = None,
-        model_format: Optional[ModelFormat] = None,
-    ) -> list[AnyModelConfig]:
-        """
-        Searches for models by attributes.
-
-        :param model_name: Name of to be fetched.
-        :param base_model: Base model
-        :param model_type: Type of the model
-        :param submodel: For main (pipeline models), the submodel to fetch
-        """
-
-        return self._services.model_manager.store.search_by_attr(
-            model_name=model_name,
-            base_model=base_model,
-            model_type=model_type,
-            model_format=model_format,
-        )
-
-
-class ConfigInterface(InvocationContextInterface):
-    def get(self) -> InvokeAIAppConfig:
-        """Gets the app's config."""
-
-        return self._services.configuration.get_config()
-
-
-class UtilInterface(InvocationContextInterface):
-    def sd_step_callback(self, intermediate_state: PipelineIntermediateState, base_model: BaseModelType) -> None:
-        """
-        The step callback emits a progress event with the current step, the total number of
-        steps, a preview image, and some other internal metadata.
-
-        This should be called after each denoising step.
-
-        :param intermediate_state: The intermediate state of the diffusion pipeline.
-        :param base_model: The base model for the current denoising step.
-        """
-
-        # The step callback needs access to the events and the invocation queue services, but this
-        # represents a dangerous level of access.
-        #
-        # We wrap the step callback so that nodes do not have direct access to these services.
-
-        stable_diffusion_step_callback(
-            context_data=self._context_data,
-            intermediate_state=intermediate_state,
-            base_model=base_model,
-            invocation_queue=self._services.queue,
-            events=self._services.events,
-        )
-
-
-class InvocationContext:
-    """
-    The `InvocationContext` provides access to various services and data for the current invocation.
-    """
-
-    def __init__(
-        self,
-        images: ImagesInterface,
-        tensors: TensorsInterface,
-        conditioning: ConditioningInterface,
-        models: ModelsInterface,
-        logger: LoggerInterface,
-        config: ConfigInterface,
-        util: UtilInterface,
-        boards: BoardsInterface,
-        context_data: InvocationContextData,
-        services: InvocationServices,
-    ) -> None:
-        self.images = images
-        """Provides methods to save, get and update images and their metadata."""
-        self.tensors = tensors
-        """Provides methods to save and get tensors, including image, noise, masks, and masked images."""
-        self.conditioning = conditioning
-        """Provides methods to save and get conditioning data."""
-        self.models = models
-        """Provides methods to check if a model exists, get a model, and get a model's info."""
-        self.logger = logger
-        """Provides access to the app logger."""
-        self.config = config
-        """Provides access to the app's config."""
-        self.util = util
-        """Provides utility methods."""
-        self.boards = boards
-        """Provides methods to interact with boards."""
-        self._data = context_data
-        """Provides data about the current queue item and invocation. This is an internal API and may change without warning."""
-        self._services = services
-        """Provides access to the full application services. This is an internal API and may change without warning."""
-
-
-def build_invocation_context(
-    services: InvocationServices,
-    context_data: InvocationContextData,
-) -> InvocationContext:
-    """
-    Builds the invocation context for a specific invocation execution.
-
-    :param invocation_services: The invocation services to wrap.
-    :param invocation_context_data: The invocation context data.
-    """
-
-    logger = LoggerInterface(services=services, context_data=context_data)
-    images = ImagesInterface(services=services, context_data=context_data)
-    tensors = TensorsInterface(services=services, context_data=context_data)
-    models = ModelsInterface(services=services, context_data=context_data)
-    config = ConfigInterface(services=services, context_data=context_data)
-    util = UtilInterface(services=services, context_data=context_data)
-    conditioning = ConditioningInterface(services=services, context_data=context_data)
-    boards = BoardsInterface(services=services, context_data=context_data)
-
-    ctx = InvocationContext(
-        images=images,
-        logger=logger,
-        config=config,
-        tensors=tensors,
-        models=models,
-        context_data=context_data,
-        util=util,
-        conditioning=conditioning,
-        services=services,
-        boards=boards,
-    )
-
-    return ctx

invokeai/app/shared/fields.py

@@ -0,0 +1,67 @@
+class FieldDescriptions:
+    denoising_start = "When to start denoising, expressed a percentage of total steps"
+    denoising_end = "When to stop denoising, expressed a percentage of total steps"
+    cfg_scale = "Classifier-Free Guidance scale"
+    cfg_rescale_multiplier = "Rescale multiplier for CFG guidance, used for models trained with zero-terminal SNR"
+    scheduler = "Scheduler to use during inference"
+    positive_cond = "Positive conditioning tensor"
+    negative_cond = "Negative conditioning tensor"
+    noise = "Noise tensor"
+    clip = "CLIP (tokenizer, text encoder, LoRAs) and skipped layer count"
+    unet = "UNet (scheduler, LoRAs)"
+    vae = "VAE"
+    cond = "Conditioning tensor"
+    controlnet_model = "ControlNet model to load"
+    vae_model = "VAE model to load"
+    lora_model = "LoRA model to load"
+    main_model = "Main model (UNet, VAE, CLIP) to load"
+    sdxl_main_model = "SDXL Main model (UNet, VAE, CLIP1, CLIP2) to load"
+    sdxl_refiner_model = "SDXL Refiner Main Modde (UNet, VAE, CLIP2) to load"
+    onnx_main_model = "ONNX Main model (UNet, VAE, CLIP) to load"
+    lora_weight = "The weight at which the LoRA is applied to each model"
+    compel_prompt = "Prompt to be parsed by Compel to create a conditioning tensor"
+    raw_prompt = "Raw prompt text (no parsing)"
+    sdxl_aesthetic = "The aesthetic score to apply to the conditioning tensor"
+    skipped_layers = "Number of layers to skip in text encoder"
+    seed = "Seed for random number generation"
+    steps = "Number of steps to run"
+    width = "Width of output (px)"
+    height = "Height of output (px)"
+    control = "ControlNet(s) to apply"
+    ip_adapter = "IP-Adapter to apply"
+    t2i_adapter = "T2I-Adapter(s) to apply"
+    denoised_latents = "Denoised latents tensor"
+    latents = "Latents tensor"
+    strength = "Strength of denoising (proportional to steps)"
+    metadata = "Optional metadata to be saved with the image"
+    metadata_collection = "Collection of Metadata"
+    metadata_item_polymorphic = "A single metadata item or collection of metadata items"
+    metadata_item_label = "Label for this metadata item"
+    metadata_item_value = "The value for this metadata item (may be any type)"
+    workflow = "Optional workflow to be saved with the image"
+    interp_mode = "Interpolation mode"
+    torch_antialias = "Whether or not to apply antialiasing (bilinear or bicubic only)"
+    fp32 = "Whether or not to use full float32 precision"
+    precision = "Precision to use"
+    tiled = "Processing using overlapping tiles (reduce memory consumption)"
+    detect_res = "Pixel resolution for detection"
+    image_res = "Pixel resolution for output image"
+    safe_mode = "Whether or not to use safe mode"
+    scribble_mode = "Whether or not to use scribble mode"
+    scale_factor = "The factor by which to scale"
+    blend_alpha = (
+        "Blending factor. 0.0 = use input A only, 1.0 = use input B only, 0.5 = 50% mix of input A and input B."
+    )
+    num_1 = "The first number"
+    num_2 = "The second number"
+    mask = "The mask to use for the operation"
+    board = "The board to save the image to"
+    image = "The image to process"
+    tile_size = "Tile size"
+    inclusive_low = "The inclusive low value"
+    exclusive_high = "The exclusive high value"
+    decimal_places = "The number of decimal places to round to"
+    freeu_s1 = 'Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to mitigate the "oversmoothing effect" in the enhanced denoising process.'
+    freeu_s2 = 'Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to mitigate the "oversmoothing effect" in the enhanced denoising process.'
+    freeu_b1 = "Scaling factor for stage 1 to amplify the contributions of backbone features."
+    freeu_b2 = "Scaling factor for stage 2 to amplify the contributions of backbone features."

invokeai/app/shared/models.py

@@ -1,6 +1,6 @@
 from pydantic import BaseModel, Field
 
-from invokeai.app.invocations.fields import FieldDescriptions
+from invokeai.app.shared.fields import FieldDescriptions
 
 
 class FreeUConfig(BaseModel):

invokeai/app/util/step_callback.py

@@ -1,18 +1,12 @@
-from typing import TYPE_CHECKING
-
 import torch
 from PIL import Image
 
 from invokeai.app.services.invocation_processor.invocation_processor_common import CanceledException, ProgressImage
-from invokeai.backend.model_manager.config import BaseModelType
 
+from ...backend.model_manager import BaseModelType
 from ...backend.stable_diffusion import PipelineIntermediateState
 from ...backend.util.util import image_to_dataURL
-
-if TYPE_CHECKING:
-    from invokeai.app.services.events.events_base import EventServiceBase
-    from invokeai.app.services.invocation_queue.invocation_queue_base import InvocationQueueABC
-    from invokeai.app.services.shared.invocation_context import InvocationContextData
+from ..invocations.baseinvocation import InvocationContext
 
 
 def sample_to_lowres_estimated_image(samples, latent_rgb_factors, smooth_matrix=None):
@@ -31,13 +25,13 @@ def sample_to_lowres_estimated_image(samples, latent_rgb_factors, smooth_matrix=
 
 
 def stable_diffusion_step_callback(
-    context_data: "InvocationContextData",
+    context: InvocationContext,
     intermediate_state: PipelineIntermediateState,
+    node: dict,
+    source_node_id: str,
     base_model: BaseModelType,
-    invocation_queue: "InvocationQueueABC",
-    events: "EventServiceBase",
-) -> None:
-    if invocation_queue.is_canceled(context_data.session_id):
+):
+    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,
@@ -114,13 +108,13 @@ def stable_diffusion_step_callback(
 
     dataURL = image_to_dataURL(image, image_format="JPEG")
 
-    events.emit_generator_progress(
-        queue_id=context_data.queue_id,
-        queue_item_id=context_data.queue_item_id,
-        queue_batch_id=context_data.batch_id,
-        graph_execution_state_id=context_data.session_id,
-        node_id=context_data.invocation.id,
-        source_node_id=context_data.source_node_id,
+    context.services.events.emit_generator_progress(
+        queue_id=context.queue_id,
+        queue_item_id=context.queue_item_id,
+        queue_batch_id=context.queue_batch_id,
+        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,
         order=intermediate_state.order,

invokeai/backend/image_util/dw_openpose/__init__.py

@@ -1,81 +0,0 @@
-import numpy as np
-import torch
-from controlnet_aux.util import resize_image
-from PIL import Image
-
-from invokeai.backend.image_util.dw_openpose.utils import draw_bodypose, draw_facepose, draw_handpose
-from invokeai.backend.image_util.dw_openpose.wholebody import Wholebody
-
-
-def draw_pose(pose, H, W, draw_face=True, draw_body=True, draw_hands=True, resolution=512):
-    bodies = pose["bodies"]
-    faces = pose["faces"]
-    hands = pose["hands"]
-    candidate = bodies["candidate"]
-    subset = bodies["subset"]
-    canvas = np.zeros(shape=(H, W, 3), dtype=np.uint8)
-
-    if draw_body:
-        canvas = draw_bodypose(canvas, candidate, subset)
-
-    if draw_hands:
-        canvas = draw_handpose(canvas, hands)
-
-    if draw_face:
-        canvas = draw_facepose(canvas, faces)
-
-    dwpose_image = resize_image(
-        canvas,
-        resolution,
-    )
-    dwpose_image = Image.fromarray(dwpose_image)
-
-    return dwpose_image
-
-
-class DWOpenposeDetector:
-    """
-    Code from the original implementation of the DW Openpose Detector.
-    Credits: https://github.com/IDEA-Research/DWPose
-    """
-
-    def __init__(self) -> None:
-        self.pose_estimation = Wholebody()
-
-    def __call__(
-        self, image: Image.Image, draw_face=False, draw_body=True, draw_hands=False, resolution=512
-    ) -> Image.Image:
-        np_image = np.array(image)
-        H, W, C = np_image.shape
-
-        with torch.no_grad():
-            candidate, subset = self.pose_estimation(np_image)
-            nums, keys, locs = candidate.shape
-            candidate[..., 0] /= float(W)
-            candidate[..., 1] /= float(H)
-            body = candidate[:, :18].copy()
-            body = body.reshape(nums * 18, locs)
-            score = subset[:, :18]
-            for i in range(len(score)):
-                for j in range(len(score[i])):
-                    if score[i][j] > 0.3:
-                        score[i][j] = int(18 * i + j)
-                    else:
-                        score[i][j] = -1
-
-            un_visible = subset < 0.3
-            candidate[un_visible] = -1
-
-            # foot = candidate[:, 18:24]
-
-            faces = candidate[:, 24:92]
-
-            hands = candidate[:, 92:113]
-            hands = np.vstack([hands, candidate[:, 113:]])
-
-            bodies = {"candidate": body, "subset": score}
-            pose = {"bodies": bodies, "hands": hands, "faces": faces}
-
-            return draw_pose(
-                pose, H, W, draw_face=draw_face, draw_hands=draw_hands, draw_body=draw_body, resolution=resolution
-            )

invokeai/backend/image_util/dw_openpose/onnxdet.py

@@ -1,128 +0,0 @@
-# Code from the original DWPose Implementation: https://github.com/IDEA-Research/DWPose
-
-import cv2
-import numpy as np
-
-
-def nms(boxes, scores, nms_thr):
-    """Single class NMS implemented in Numpy."""
-    x1 = boxes[:, 0]
-    y1 = boxes[:, 1]
-    x2 = boxes[:, 2]
-    y2 = boxes[:, 3]
-
-    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-    order = scores.argsort()[::-1]
-
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(i)
-        xx1 = np.maximum(x1[i], x1[order[1:]])
-        yy1 = np.maximum(y1[i], y1[order[1:]])
-        xx2 = np.minimum(x2[i], x2[order[1:]])
-        yy2 = np.minimum(y2[i], y2[order[1:]])
-
-        w = np.maximum(0.0, xx2 - xx1 + 1)
-        h = np.maximum(0.0, yy2 - yy1 + 1)
-        inter = w * h
-        ovr = inter / (areas[i] + areas[order[1:]] - inter)
-
-        inds = np.where(ovr <= nms_thr)[0]
-        order = order[inds + 1]
-
-    return keep
-
-
-def multiclass_nms(boxes, scores, nms_thr, score_thr):
-    """Multiclass NMS implemented in Numpy. Class-aware version."""
-    final_dets = []
-    num_classes = scores.shape[1]
-    for cls_ind in range(num_classes):
-        cls_scores = scores[:, cls_ind]
-        valid_score_mask = cls_scores > score_thr
-        if valid_score_mask.sum() == 0:
-            continue
-        else:
-            valid_scores = cls_scores[valid_score_mask]
-            valid_boxes = boxes[valid_score_mask]
-            keep = nms(valid_boxes, valid_scores, nms_thr)
-            if len(keep) > 0:
-                cls_inds = np.ones((len(keep), 1)) * cls_ind
-                dets = np.concatenate([valid_boxes[keep], valid_scores[keep, None], cls_inds], 1)
-                final_dets.append(dets)
-    if len(final_dets) == 0:
-        return None
-    return np.concatenate(final_dets, 0)
-
-
-def demo_postprocess(outputs, img_size, p6=False):
-    grids = []
-    expanded_strides = []
-    strides = [8, 16, 32] if not p6 else [8, 16, 32, 64]
-
-    hsizes = [img_size[0] // stride for stride in strides]
-    wsizes = [img_size[1] // stride for stride in strides]
-
-    for hsize, wsize, stride in zip(hsizes, wsizes, strides, strict=False):
-        xv, yv = np.meshgrid(np.arange(wsize), np.arange(hsize))
-        grid = np.stack((xv, yv), 2).reshape(1, -1, 2)
-        grids.append(grid)
-        shape = grid.shape[:2]
-        expanded_strides.append(np.full((*shape, 1), stride))
-
-    grids = np.concatenate(grids, 1)
-    expanded_strides = np.concatenate(expanded_strides, 1)
-    outputs[..., :2] = (outputs[..., :2] + grids) * expanded_strides
-    outputs[..., 2:4] = np.exp(outputs[..., 2:4]) * expanded_strides
-
-    return outputs
-
-
-def preprocess(img, input_size, swap=(2, 0, 1)):
-    if len(img.shape) == 3:
-        padded_img = np.ones((input_size[0], input_size[1], 3), dtype=np.uint8) * 114
-    else:
-        padded_img = np.ones(input_size, dtype=np.uint8) * 114
-
-    r = min(input_size[0] / img.shape[0], input_size[1] / img.shape[1])
-    resized_img = cv2.resize(
-        img,
-        (int(img.shape[1] * r), int(img.shape[0] * r)),
-        interpolation=cv2.INTER_LINEAR,
-    ).astype(np.uint8)
-    padded_img[: int(img.shape[0] * r), : int(img.shape[1] * r)] = resized_img
-
-    padded_img = padded_img.transpose(swap)
-    padded_img = np.ascontiguousarray(padded_img, dtype=np.float32)
-    return padded_img, r
-
-
-def inference_detector(session, oriImg):
-    input_shape = (640, 640)
-    img, ratio = preprocess(oriImg, input_shape)
-
-    ort_inputs = {session.get_inputs()[0].name: img[None, :, :, :]}
-    output = session.run(None, ort_inputs)
-    predictions = demo_postprocess(output[0], input_shape)[0]
-
-    boxes = predictions[:, :4]
-    scores = predictions[:, 4:5] * predictions[:, 5:]
-
-    boxes_xyxy = np.ones_like(boxes)
-    boxes_xyxy[:, 0] = boxes[:, 0] - boxes[:, 2] / 2.0
-    boxes_xyxy[:, 1] = boxes[:, 1] - boxes[:, 3] / 2.0
-    boxes_xyxy[:, 2] = boxes[:, 0] + boxes[:, 2] / 2.0
-    boxes_xyxy[:, 3] = boxes[:, 1] + boxes[:, 3] / 2.0
-    boxes_xyxy /= ratio
-    dets = multiclass_nms(boxes_xyxy, scores, nms_thr=0.45, score_thr=0.1)
-    if dets is not None:
-        final_boxes, final_scores, final_cls_inds = dets[:, :4], dets[:, 4], dets[:, 5]
-        isscore = final_scores > 0.3
-        iscat = final_cls_inds == 0
-        isbbox = [i and j for (i, j) in zip(isscore, iscat, strict=False)]
-        final_boxes = final_boxes[isbbox]
-    else:
-        final_boxes = np.array([])
-
-    return final_boxes

invokeai/backend/image_util/dw_openpose/onnxpose.py

@@ -1,361 +0,0 @@
-# Code from the original DWPose Implementation: https://github.com/IDEA-Research/DWPose
-
-from typing import List, Tuple
-
-import cv2
-import numpy as np
-import onnxruntime as ort
-
-
-def preprocess(
-    img: np.ndarray, out_bbox, input_size: Tuple[int, int] = (192, 256)
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Do preprocessing for RTMPose model inference.
-
-    Args:
-        img (np.ndarray): Input image in shape.
-        input_size (tuple): Input image size in shape (w, h).
-
-    Returns:
-        tuple:
-        - resized_img (np.ndarray): Preprocessed image.
-        - center (np.ndarray): Center of image.
-        - scale (np.ndarray): Scale of image.
-    """
-    # get shape of image
-    img_shape = img.shape[:2]
-    out_img, out_center, out_scale = [], [], []
-    if len(out_bbox) == 0:
-        out_bbox = [[0, 0, img_shape[1], img_shape[0]]]
-    for i in range(len(out_bbox)):
-        x0 = out_bbox[i][0]
-        y0 = out_bbox[i][1]
-        x1 = out_bbox[i][2]
-        y1 = out_bbox[i][3]
-        bbox = np.array([x0, y0, x1, y1])
-
-        # get center and scale
-        center, scale = bbox_xyxy2cs(bbox, padding=1.25)
-
-        # do affine transformation
-        resized_img, scale = top_down_affine(input_size, scale, center, img)
-
-        # normalize image
-        mean = np.array([123.675, 116.28, 103.53])
-        std = np.array([58.395, 57.12, 57.375])
-        resized_img = (resized_img - mean) / std
-
-        out_img.append(resized_img)
-        out_center.append(center)
-        out_scale.append(scale)
-
-    return out_img, out_center, out_scale
-
-
-def inference(sess: ort.InferenceSession, img: np.ndarray) -> np.ndarray:
-    """Inference RTMPose model.
-
-    Args:
-        sess (ort.InferenceSession): ONNXRuntime session.
-        img (np.ndarray): Input image in shape.
-
-    Returns:
-        outputs (np.ndarray): Output of RTMPose model.
-    """
-    all_out = []
-    # build input
-    for i in range(len(img)):
-        input = [img[i].transpose(2, 0, 1)]
-
-        # build output
-        sess_input = {sess.get_inputs()[0].name: input}
-        sess_output = []
-        for out in sess.get_outputs():
-            sess_output.append(out.name)
-
-        # run model
-        outputs = sess.run(sess_output, sess_input)
-        all_out.append(outputs)
-
-    return all_out
-
-
-def postprocess(
-    outputs: List[np.ndarray],
-    model_input_size: Tuple[int, int],
-    center: Tuple[int, int],
-    scale: Tuple[int, int],
-    simcc_split_ratio: float = 2.0,
-) -> Tuple[np.ndarray, np.ndarray]:
-    """Postprocess for RTMPose model output.
-
-    Args:
-        outputs (np.ndarray): Output of RTMPose model.
-        model_input_size (tuple): RTMPose model Input image size.
-        center (tuple): Center of bbox in shape (x, y).
-        scale (tuple): Scale of bbox in shape (w, h).
-        simcc_split_ratio (float): Split ratio of simcc.
-
-    Returns:
-        tuple:
-        - keypoints (np.ndarray): Rescaled keypoints.
-        - scores (np.ndarray): Model predict scores.
-    """
-    all_key = []
-    all_score = []
-    for i in range(len(outputs)):
-        # use simcc to decode
-        simcc_x, simcc_y = outputs[i]
-        keypoints, scores = decode(simcc_x, simcc_y, simcc_split_ratio)
-
-        # rescale keypoints
-        keypoints = keypoints / model_input_size * scale[i] + center[i] - scale[i] / 2
-        all_key.append(keypoints[0])
-        all_score.append(scores[0])
-
-    return np.array(all_key), np.array(all_score)
-
-
-def bbox_xyxy2cs(bbox: np.ndarray, padding: float = 1.0) -> Tuple[np.ndarray, np.ndarray]:
-    """Transform the bbox format from (x,y,w,h) into (center, scale)
-
-    Args:
-        bbox (ndarray): Bounding box(es) in shape (4,) or (n, 4), formatted
-            as (left, top, right, bottom)
-        padding (float): BBox padding factor that will be multilied to scale.
-            Default: 1.0
-
-    Returns:
-        tuple: A tuple containing center and scale.
-        - np.ndarray[float32]: Center (x, y) of the bbox in shape (2,) or
-            (n, 2)
-        - np.ndarray[float32]: Scale (w, h) of the bbox in shape (2,) or
-            (n, 2)
-    """
-    # convert single bbox from (4, ) to (1, 4)
-    dim = bbox.ndim
-    if dim == 1:
-        bbox = bbox[None, :]
-
-    # get bbox center and scale
-    x1, y1, x2, y2 = np.hsplit(bbox, [1, 2, 3])
-    center = np.hstack([x1 + x2, y1 + y2]) * 0.5
-    scale = np.hstack([x2 - x1, y2 - y1]) * padding
-
-    if dim == 1:
-        center = center[0]
-        scale = scale[0]
-
-    return center, scale
-
-
-def _fix_aspect_ratio(bbox_scale: np.ndarray, aspect_ratio: float) -> np.ndarray:
-    """Extend the scale to match the given aspect ratio.
-
-    Args:
-        scale (np.ndarray): The image scale (w, h) in shape (2, )
-        aspect_ratio (float): The ratio of ``w/h``
-
-    Returns:
-        np.ndarray: The reshaped image scale in (2, )
-    """
-    w, h = np.hsplit(bbox_scale, [1])
-    bbox_scale = np.where(w > h * aspect_ratio, np.hstack([w, w / aspect_ratio]), np.hstack([h * aspect_ratio, h]))
-    return bbox_scale
-
-
-def _rotate_point(pt: np.ndarray, angle_rad: float) -> np.ndarray:
-    """Rotate a point by an angle.
-
-    Args:
-        pt (np.ndarray): 2D point coordinates (x, y) in shape (2, )
-        angle_rad (float): rotation angle in radian
-
-    Returns:
-        np.ndarray: Rotated point in shape (2, )
-    """
-    sn, cs = np.sin(angle_rad), np.cos(angle_rad)
-    rot_mat = np.array([[cs, -sn], [sn, cs]])
-    return rot_mat @ pt
-
-
-def _get_3rd_point(a: np.ndarray, b: np.ndarray) -> np.ndarray:
-    """To calculate the affine matrix, three pairs of points are required. This
-    function is used to get the 3rd point, given 2D points a & b.
-
-    The 3rd point is defined by rotating vector `a - b` by 90 degrees
-    anticlockwise, using b as the rotation center.
-
-    Args:
-        a (np.ndarray): The 1st point (x,y) in shape (2, )
-        b (np.ndarray): The 2nd point (x,y) in shape (2, )
-
-    Returns:
-        np.ndarray: The 3rd point.
-    """
-    direction = a - b
-    c = b + np.r_[-direction[1], direction[0]]
-    return c
-
-
-def get_warp_matrix(
-    center: np.ndarray,
-    scale: np.ndarray,
-    rot: float,
-    output_size: Tuple[int, int],
-    shift: Tuple[float, float] = (0.0, 0.0),
-    inv: bool = False,
-) -> np.ndarray:
-    """Calculate the affine transformation matrix that can warp the bbox area
-    in the input image to the output size.
-
-    Args:
-        center (np.ndarray[2, ]): Center of the bounding box (x, y).
-        scale (np.ndarray[2, ]): Scale of the bounding box
-            wrt [width, height].
-        rot (float): Rotation angle (degree).
-        output_size (np.ndarray[2, ] | list(2,)): Size of the
-            destination heatmaps.
-        shift (0-100%): Shift translation ratio wrt the width/height.
-            Default (0., 0.).
-        inv (bool): Option to inverse the affine transform direction.
-            (inv=False: src->dst or inv=True: dst->src)
-
-    Returns:
-        np.ndarray: A 2x3 transformation matrix
-    """
-    shift = np.array(shift)
-    src_w = scale[0]
-    dst_w = output_size[0]
-    dst_h = output_size[1]
-
-    # compute transformation matrix
-    rot_rad = np.deg2rad(rot)
-    src_dir = _rotate_point(np.array([0.0, src_w * -0.5]), rot_rad)
-    dst_dir = np.array([0.0, dst_w * -0.5])
-
-    # get four corners of the src rectangle in the original image
-    src = np.zeros((3, 2), dtype=np.float32)
-    src[0, :] = center + scale * shift
-    src[1, :] = center + src_dir + scale * shift
-    src[2, :] = _get_3rd_point(src[0, :], src[1, :])
-
-    # get four corners of the dst rectangle in the input image
-    dst = np.zeros((3, 2), dtype=np.float32)
-    dst[0, :] = [dst_w * 0.5, dst_h * 0.5]
-    dst[1, :] = np.array([dst_w * 0.5, dst_h * 0.5]) + dst_dir
-    dst[2, :] = _get_3rd_point(dst[0, :], dst[1, :])
-
-    if inv:
-        warp_mat = cv2.getAffineTransform(np.float32(dst), np.float32(src))
-    else:
-        warp_mat = cv2.getAffineTransform(np.float32(src), np.float32(dst))
-
-    return warp_mat
-
-
-def top_down_affine(
-    input_size: dict, bbox_scale: dict, bbox_center: dict, img: np.ndarray
-) -> Tuple[np.ndarray, np.ndarray]:
-    """Get the bbox image as the model input by affine transform.
-
-    Args:
-        input_size (dict): The input size of the model.
-        bbox_scale (dict): The bbox scale of the img.
-        bbox_center (dict): The bbox center of the img.
-        img (np.ndarray): The original image.
-
-    Returns:
-        tuple: A tuple containing center and scale.
-        - np.ndarray[float32]: img after affine transform.
-        - np.ndarray[float32]: bbox scale after affine transform.
-    """
-    w, h = input_size
-    warp_size = (int(w), int(h))
-
-    # reshape bbox to fixed aspect ratio
-    bbox_scale = _fix_aspect_ratio(bbox_scale, aspect_ratio=w / h)
-
-    # get the affine matrix
-    center = bbox_center
-    scale = bbox_scale
-    rot = 0
-    warp_mat = get_warp_matrix(center, scale, rot, output_size=(w, h))
-
-    # do affine transform
-    img = cv2.warpAffine(img, warp_mat, warp_size, flags=cv2.INTER_LINEAR)
-
-    return img, bbox_scale
-
-
-def get_simcc_maximum(simcc_x: np.ndarray, simcc_y: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-    """Get maximum response location and value from simcc representations.
-
-    Note:
-        instance number: N
-        num_keypoints: K
-        heatmap height: H
-        heatmap width: W
-
-    Args:
-        simcc_x (np.ndarray): x-axis SimCC in shape (K, Wx) or (N, K, Wx)
-        simcc_y (np.ndarray): y-axis SimCC in shape (K, Wy) or (N, K, Wy)
-
-    Returns:
-        tuple:
-        - locs (np.ndarray): locations of maximum heatmap responses in shape
-            (K, 2) or (N, K, 2)
-        - vals (np.ndarray): values of maximum heatmap responses in shape
-            (K,) or (N, K)
-    """
-    N, K, Wx = simcc_x.shape
-    simcc_x = simcc_x.reshape(N * K, -1)
-    simcc_y = simcc_y.reshape(N * K, -1)
-
-    # get maximum value locations
-    x_locs = np.argmax(simcc_x, axis=1)
-    y_locs = np.argmax(simcc_y, axis=1)
-    locs = np.stack((x_locs, y_locs), axis=-1).astype(np.float32)
-    max_val_x = np.amax(simcc_x, axis=1)
-    max_val_y = np.amax(simcc_y, axis=1)
-
-    # get maximum value across x and y axis
-    mask = max_val_x > max_val_y
-    max_val_x[mask] = max_val_y[mask]
-    vals = max_val_x
-    locs[vals <= 0.0] = -1
-
-    # reshape
-    locs = locs.reshape(N, K, 2)
-    vals = vals.reshape(N, K)
-
-    return locs, vals
-
-
-def decode(simcc_x: np.ndarray, simcc_y: np.ndarray, simcc_split_ratio) -> Tuple[np.ndarray, np.ndarray]:
-    """Modulate simcc distribution with Gaussian.
-
-    Args:
-        simcc_x (np.ndarray[K, Wx]): model predicted simcc in x.
-        simcc_y (np.ndarray[K, Wy]): model predicted simcc in y.
-        simcc_split_ratio (int): The split ratio of simcc.
-
-    Returns:
-        tuple: A tuple containing center and scale.
-        - np.ndarray[float32]: keypoints in shape (K, 2) or (n, K, 2)
-        - np.ndarray[float32]: scores in shape (K,) or (n, K)
-    """
-    keypoints, scores = get_simcc_maximum(simcc_x, simcc_y)
-    keypoints /= simcc_split_ratio
-
-    return keypoints, scores
-
-
-def inference_pose(session, out_bbox, oriImg):
-    h, w = session.get_inputs()[0].shape[2:]
-    model_input_size = (w, h)
-    resized_img, center, scale = preprocess(oriImg, out_bbox, model_input_size)
-    outputs = inference(session, resized_img)
-    keypoints, scores = postprocess(outputs, model_input_size, center, scale)
-
-    return keypoints, scores

invokeai/backend/image_util/dw_openpose/utils.py

@@ -1,155 +0,0 @@
-# Code from the original DWPose Implementation: https://github.com/IDEA-Research/DWPose
-
-import math
-
-import cv2
-import matplotlib
-import numpy as np
-
-eps = 0.01
-
-
-def draw_bodypose(canvas, candidate, subset):
-    H, W, C = canvas.shape
-    candidate = np.array(candidate)
-    subset = np.array(subset)
-
-    stickwidth = 4
-
-    limbSeq = [
-        [2, 3],
-        [2, 6],
-        [3, 4],
-        [4, 5],
-        [6, 7],
-        [7, 8],
-        [2, 9],
-        [9, 10],
-        [10, 11],
-        [2, 12],
-        [12, 13],
-        [13, 14],
-        [2, 1],
-        [1, 15],
-        [15, 17],
-        [1, 16],
-        [16, 18],
-        [3, 17],
-        [6, 18],
-    ]
-
-    colors = [
-        [255, 0, 0],
-        [255, 85, 0],
-        [255, 170, 0],
-        [255, 255, 0],
-        [170, 255, 0],
-        [85, 255, 0],
-        [0, 255, 0],
-        [0, 255, 85],
-        [0, 255, 170],
-        [0, 255, 255],
-        [0, 170, 255],
-        [0, 85, 255],
-        [0, 0, 255],
-        [85, 0, 255],
-        [170, 0, 255],
-        [255, 0, 255],
-        [255, 0, 170],
-        [255, 0, 85],
-    ]
-
-    for i in range(17):
-        for n in range(len(subset)):
-            index = subset[n][np.array(limbSeq[i]) - 1]
-            if -1 in index:
-                continue
-            Y = candidate[index.astype(int), 0] * float(W)
-            X = candidate[index.astype(int), 1] * float(H)
-            mX = np.mean(X)
-            mY = np.mean(Y)
-            length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
-            angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
-            polygon = cv2.ellipse2Poly((int(mY), int(mX)), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
-            cv2.fillConvexPoly(canvas, polygon, colors[i])
-
-    canvas = (canvas * 0.6).astype(np.uint8)
-
-    for i in range(18):
-        for n in range(len(subset)):
-            index = int(subset[n][i])
-            if index == -1:
-                continue
-            x, y = candidate[index][0:2]
-            x = int(x * W)
-            y = int(y * H)
-            cv2.circle(canvas, (int(x), int(y)), 4, colors[i], thickness=-1)
-
-    return canvas
-
-
-def draw_handpose(canvas, all_hand_peaks):
-    H, W, C = canvas.shape
-
-    edges = [
-        [0, 1],
-        [1, 2],
-        [2, 3],
-        [3, 4],
-        [0, 5],
-        [5, 6],
-        [6, 7],
-        [7, 8],
-        [0, 9],
-        [9, 10],
-        [10, 11],
-        [11, 12],
-        [0, 13],
-        [13, 14],
-        [14, 15],
-        [15, 16],
-        [0, 17],
-        [17, 18],
-        [18, 19],
-        [19, 20],
-    ]
-
-    for peaks in all_hand_peaks:
-        peaks = np.array(peaks)
-
-        for ie, e in enumerate(edges):
-            x1, y1 = peaks[e[0]]
-            x2, y2 = peaks[e[1]]
-            x1 = int(x1 * W)
-            y1 = int(y1 * H)
-            x2 = int(x2 * W)
-            y2 = int(y2 * H)
-            if x1 > eps and y1 > eps and x2 > eps and y2 > eps:
-                cv2.line(
-                    canvas,
-                    (x1, y1),
-                    (x2, y2),
-                    matplotlib.colors.hsv_to_rgb([ie / float(len(edges)), 1.0, 1.0]) * 255,
-                    thickness=2,
-                )
-
-        for _, keyponit in enumerate(peaks):
-            x, y = keyponit
-            x = int(x * W)
-            y = int(y * H)
-            if x > eps and y > eps:
-                cv2.circle(canvas, (x, y), 4, (0, 0, 255), thickness=-1)
-    return canvas
-
-
-def draw_facepose(canvas, all_lmks):
-    H, W, C = canvas.shape
-    for lmks in all_lmks:
-        lmks = np.array(lmks)
-        for lmk in lmks:
-            x, y = lmk
-            x = int(x * W)
-            y = int(y * H)
-            if x > eps and y > eps:
-                cv2.circle(canvas, (x, y), 3, (255, 255, 255), thickness=-1)
-    return canvas

invokeai/backend/image_util/dw_openpose/wholebody.py

@@ -1,67 +0,0 @@
-# Code from the original DWPose Implementation: https://github.com/IDEA-Research/DWPose
-# Modified pathing to suit Invoke
-
-import pathlib
-
-import numpy as np
-import onnxruntime as ort
-
-from invokeai.app.services.config.config_default import InvokeAIAppConfig
-from invokeai.backend.util.devices import choose_torch_device
-from invokeai.backend.util.util import download_with_progress_bar
-
-from .onnxdet import inference_detector
-from .onnxpose import inference_pose
-
-DWPOSE_MODELS = {
-    "yolox_l.onnx": {
-        "local": "any/annotators/dwpose/yolox_l.onnx",
-        "url": "https://huggingface.co/yzd-v/DWPose/resolve/main/yolox_l.onnx?download=true",
-    },
-    "dw-ll_ucoco_384.onnx": {
-        "local": "any/annotators/dwpose/dw-ll_ucoco_384.onnx",
-        "url": "https://huggingface.co/yzd-v/DWPose/resolve/main/dw-ll_ucoco_384.onnx?download=true",
-    },
-}
-
-config = InvokeAIAppConfig.get_config()
-
-
-class Wholebody:
-    def __init__(self):
-        device = choose_torch_device()
-
-        providers = ["CUDAExecutionProvider"] if device == "cuda" else ["CPUExecutionProvider"]
-
-        DET_MODEL_PATH = pathlib.Path(config.models_path / DWPOSE_MODELS["yolox_l.onnx"]["local"])
-        if not DET_MODEL_PATH.exists():
-            download_with_progress_bar(DWPOSE_MODELS["yolox_l.onnx"]["url"], DET_MODEL_PATH)
-
-        POSE_MODEL_PATH = pathlib.Path(config.models_path / DWPOSE_MODELS["dw-ll_ucoco_384.onnx"]["local"])
-        if not POSE_MODEL_PATH.exists():
-            download_with_progress_bar(DWPOSE_MODELS["dw-ll_ucoco_384.onnx"]["url"], POSE_MODEL_PATH)
-
-        onnx_det = DET_MODEL_PATH
-        onnx_pose = POSE_MODEL_PATH
-
-        self.session_det = ort.InferenceSession(path_or_bytes=onnx_det, providers=providers)
-        self.session_pose = ort.InferenceSession(path_or_bytes=onnx_pose, providers=providers)
-
-    def __call__(self, oriImg):
-        det_result = inference_detector(self.session_det, oriImg)
-        keypoints, scores = inference_pose(self.session_pose, det_result, oriImg)
-
-        keypoints_info = np.concatenate((keypoints, scores[..., None]), axis=-1)
-        # compute neck joint
-        neck = np.mean(keypoints_info[:, [5, 6]], axis=1)
-        # neck score when visualizing pred
-        neck[:, 2:4] = np.logical_and(keypoints_info[:, 5, 2:4] > 0.3, keypoints_info[:, 6, 2:4] > 0.3).astype(int)
-        new_keypoints_info = np.insert(keypoints_info, 17, neck, axis=1)
-        mmpose_idx = [17, 6, 8, 10, 7, 9, 12, 14, 16, 13, 15, 2, 1, 4, 3]
-        openpose_idx = [1, 2, 3, 4, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17]
-        new_keypoints_info[:, openpose_idx] = new_keypoints_info[:, mmpose_idx]
-        keypoints_info = new_keypoints_info
-
-        keypoints, scores = keypoints_info[..., :2], keypoints_info[..., 2]
-
-        return keypoints, scores

invokeai/backend/install/invokeai_configure.py

@@ -84,8 +84,6 @@ _, MAX_VRAM = torch.cuda.mem_get_info() if HAS_CUDA else (0.0, 0.0)
 MAX_VRAM /= GB
 MAX_RAM = psutil.virtual_memory().total / GB
 
-FORCE_FULL_PRECISION = False
-
 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
@@ -114,6 +112,9 @@ then run one of the following commands to start InvokeAI.
 Web UI:
    invokeai-web
 
+Command-line client:
+   invokeai
+
 If you installed using an installation script, run:
   {config.root_path}/invoke.{"bat" if sys.platform == "win32" else "sh"}
 
@@ -407,7 +408,7 @@ Use cursor arrows to make a checkbox selection, and space to toggle.
             begin_entry_at=3,
             max_height=2,
             relx=30,
-            max_width=80,
+            max_width=56,
             scroll_exit=True,
         )
         self.add_widget_intelligent(
@@ -663,6 +664,7 @@ https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/blob/main/LICENS
         generation_options = [GENERATION_OPT_CHOICES[x] for x in self.generation_options.value]
         for v in GENERATION_OPT_CHOICES:
             setattr(new_opts, v, v in generation_options)
+
         return new_opts
 
 
@@ -693,6 +695,9 @@ class EditOptApplication(npyscreen.NPSAppManaged):
                 cycle_widgets=False,
             )
 
+    def new_opts(self) -> Namespace:
+        return self.options.marshall_arguments()
+
 
 def default_ramcache() -> float:
     """Run a heuristic for the default RAM cache based on installed RAM."""
@@ -707,7 +712,6 @@ def default_ramcache() -> float:
 def default_startup_options(init_file: Path) -> InvokeAIAppConfig:
     opts = InvokeAIAppConfig.get_config()
     opts.ram = default_ramcache()
-    opts.precision = "float32" if FORCE_FULL_PRECISION else choose_precision(torch.device(choose_torch_device()))
     return opts
 
 
@@ -756,8 +760,7 @@ def initialize_rootdir(root: Path, yes_to_all: bool = False):
 def run_console_ui(
     program_opts: Namespace, initfile: Path, install_helper: InstallHelper
 ) -> Tuple[Optional[Namespace], Optional[InstallSelections]]:
-    first_time = not (config.root_path / "invokeai.yaml").exists()
-    invokeai_opts = default_startup_options(initfile) if first_time else config
+    invokeai_opts = default_startup_options(initfile)
     invokeai_opts.root = program_opts.root
 
     if not set_min_terminal_size(MIN_COLS, MIN_LINES):
@@ -770,7 +773,7 @@ def run_console_ui(
     if editApp.user_cancelled:
         return (None, None)
     else:
-        return (editApp.new_opts, editApp.install_selections)
+        return (editApp.new_opts(), editApp.install_selections)
 
 
 # -------------------------------------
@@ -782,7 +785,7 @@ def write_opts(opts: InvokeAIAppConfig, init_file: Path) -> None:
     new_config = InvokeAIAppConfig.get_config()
     new_config.root = config.root
 
-    for key, value in vars(opts).items():
+    for key, value in opts.model_dump().items():
         if hasattr(new_config, key):
             setattr(new_config, key, value)
 
@@ -866,8 +869,7 @@ def migrate_if_needed(opt: Namespace, root: Path) -> bool:
 
 
 # -------------------------------------
-def main() -> None:
-    global FORCE_FULL_PRECISION  # FIXME
+def main():
     parser = argparse.ArgumentParser(description="InvokeAI model downloader")
     parser.add_argument(
         "--skip-sd-weights",
@@ -919,16 +921,17 @@ def main() -> None:
         help="path to root of install directory",
     )
     opt = parser.parse_args()
+
     invoke_args = []
     if opt.root:
         invoke_args.extend(["--root", opt.root])
     if opt.full_precision:
         invoke_args.extend(["--precision", "float32"])
     config.parse_args(invoke_args)
+    config.precision = "float32" if opt.full_precision else choose_precision(torch.device(choose_torch_device()))
     logger = InvokeAILogger().get_logger(config=config)
 
     errors = set()
-    FORCE_FULL_PRECISION = opt.full_precision  # FIXME global
 
     try:
         # if we do a root migration/upgrade, then we are keeping previous

invokeai/backend/model_manager/load/load_base.py

@@ -41,14 +41,6 @@ class LoadedModel:
         return self._locker.model
 
 
-# TODO(MM2):
-# Some "intermediary" subclasses in the ModelLoaderBase class hierarchy define methods that their subclasses don't
-# know about. I think the problem may be related to this class being an ABC.
-#
-# For example, GenericDiffusersLoader defines `get_hf_load_class()`, and StableDiffusionDiffusersModel attempts to
-# call it. However, the method is not defined in the ABC, so it is not guaranteed to be implemented.
-
-
 class ModelLoaderBase(ABC):
     """Abstract base class for loading models into RAM/VRAM."""
 

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

@@ -10,7 +10,7 @@ model will be cleared and (re)loaded from disk when next needed.
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from logging import Logger
-from typing import Dict, Generic, Optional, Set, TypeVar
+from typing import Dict, Generic, Optional, TypeVar
 
 import torch
 
@@ -89,24 +89,8 @@ class ModelCacheBase(ABC, Generic[T]):
 
     @property
     @abstractmethod
-    def execution_devices(self) -> Set[torch.device]:
-        """Return the set of available execution devices."""
-        pass
-
-    @abstractmethod
-    def acquire_execution_device(self, timeout: int = 0) -> torch.device:
-        """
-        Pick the next available execution device.
-
-        If all devices are currently engaged (locked), then
-        block until timeout seconds have passed and raise a
-        TimeoutError if no devices are available.
-        """
-        pass
-
-    @abstractmethod
-    def release_execution_device(self, device: torch.device) -> None:
-        """Release a previously-acquired execution device."""
+    def execution_device(self) -> torch.device:
+        """Return the exection device (e.g. "cuda" for VRAM)."""
         pass
 
     @property

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

@@ -25,8 +25,7 @@ import sys
 import time
 from contextlib import suppress
 from logging import Logger
-from threading import BoundedSemaphore, Lock
-from typing import Dict, List, Optional, Set
+from typing import Dict, List, Optional
 
 import torch
 
@@ -62,8 +61,8 @@ class ModelCache(ModelCacheBase[AnyModel]):
         self,
         max_cache_size: float = DEFAULT_MAX_CACHE_SIZE,
         max_vram_cache_size: float = DEFAULT_MAX_VRAM_CACHE_SIZE,
+        execution_device: torch.device = torch.device("cuda"),
         storage_device: torch.device = torch.device("cpu"),
-        execution_devices: Optional[Set[torch.device]] = None,
         precision: torch.dtype = torch.float16,
         sequential_offload: bool = False,
         lazy_offloading: bool = True,
@@ -75,7 +74,7 @@ class ModelCache(ModelCacheBase[AnyModel]):
         Initialize the model RAM cache.
 
         :param max_cache_size: Maximum size of the RAM cache [6.0 GB]
-        :param execution_devices: Set of torch device to load active model into [calculated]
+        :param execution_device: Torch device to load active model into [torch.device('cuda')]
         :param storage_device: Torch device to save inactive model in [torch.device('cpu')]
         :param precision: Precision for loaded models [torch.float16]
         :param lazy_offloading: Keep model in VRAM until another model needs to be loaded
@@ -90,7 +89,7 @@ class ModelCache(ModelCacheBase[AnyModel]):
         self._precision: torch.dtype = precision
         self._max_cache_size: float = max_cache_size
         self._max_vram_cache_size: float = max_vram_cache_size
-        self._execution_devices: Set[torch.device] = execution_devices or self._get_execution_devices()
+        self._execution_device: torch.device = execution_device
         self._storage_device: torch.device = storage_device
         self._logger = logger or InvokeAILogger.get_logger(self.__class__.__name__)
         self._log_memory_usage = log_memory_usage or self._logger.level == logging.DEBUG
@@ -100,10 +99,6 @@ class ModelCache(ModelCacheBase[AnyModel]):
         self._cached_models: Dict[str, CacheRecord[AnyModel]] = {}
         self._cache_stack: List[str] = []
 
-        self._lock = Lock()
-        self._free_execution_device = BoundedSemaphore(len(self._execution_devices))
-        self._busy_execution_devices: Set[torch.device] = set()
-
     @property
     def logger(self) -> Logger:
         """Return the logger used by the cache."""
@@ -120,24 +115,9 @@ class ModelCache(ModelCacheBase[AnyModel]):
         return self._storage_device
 
     @property
-    def execution_devices(self) -> Set[torch.device]:
-        """Return the set of available execution devices."""
-        return self._execution_devices
-
-    def acquire_execution_device(self, timeout: int = 0) -> torch.device:
-        """Acquire and return an execution device (e.g. "cuda" for VRAM)."""
-        with self._lock:
-            self._free_execution_device.acquire(timeout=timeout)
-            free_devices = self.execution_devices - self._busy_execution_devices
-            chosen_device = list(free_devices)[0]
-            self._busy_execution_devices.add(chosen_device)
-        return chosen_device
-
-    def release_execution_device(self, device: torch.device) -> None:
-        """Mark this execution device as unused."""
-        with self._lock:
-            self._free_execution_device.release()
-            self._busy_execution_devices.remove(device)
+    def execution_device(self) -> torch.device:
+        """Return the exection device (e.g. "cuda" for VRAM)."""
+        return self._execution_device
 
     @property
     def max_cache_size(self) -> float:
@@ -425,13 +405,3 @@ class ModelCache(ModelCacheBase[AnyModel]):
             mps.empty_cache()
 
         self.logger.debug(f"After making room: cached_models={len(self._cached_models)}")
-
-    @staticmethod
-    def _get_execution_devices() -> Set[torch.device]:
-        default_device = choose_torch_device()
-        if default_device != torch.device("cuda"):
-            return {default_device}
-
-        # we get here if the default device is cuda, and return each of the
-        # cuda devices.
-        return {torch.device(f"cuda:{x}") for x in range(0, torch.cuda.device_count())}

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

@@ -2,16 +2,10 @@
 Base class and implementation of a class that moves models in and out of VRAM.
 """
 
-from typing import Optional
-
-import torch
-
 from invokeai.backend.model_manager import AnyModel
 
 from .model_cache_base import CacheRecord, ModelCacheBase, ModelLockerBase
 
-MAX_GPU_WAIT = 600  # wait up to 10 minutes for a GPU to become free
-
 
 class ModelLocker(ModelLockerBase):
     """Internal class that mediates movement in and out of GPU."""
@@ -25,7 +19,6 @@ class ModelLocker(ModelLockerBase):
         """
         self._cache = cache
         self._cache_entry = cache_entry
-        self._execution_device: Optional[torch.device] = None
 
     @property
     def model(self) -> AnyModel:
@@ -44,12 +37,10 @@ class ModelLocker(ModelLockerBase):
             if self._cache.lazy_offloading:
                 self._cache.offload_unlocked_models(self._cache_entry.size)
 
-            # We wait for a gpu to be free - may raise a TimeoutError
-            self._execution_device = self._cache.acquire_execution_device(MAX_GPU_WAIT)
-            self._cache.move_model_to_device(self._cache_entry, self._execution_device)
+            self._cache.move_model_to_device(self._cache_entry, self._cache.execution_device)
             self._cache_entry.loaded = True
 
-            self._cache.logger.debug(f"Locking {self._cache_entry.key} in {self._execution_device}")
+            self._cache.logger.debug(f"Locking {self._cache_entry.key} in {self._cache.execution_device}")
             self._cache.print_cuda_stats()
 
         except Exception:
@@ -63,8 +54,6 @@ class ModelLocker(ModelLockerBase):
             return
 
         self._cache_entry.unlock()
-        if self._execution_device:
-            self._cache.release_execution_device(self._execution_device)
         if not self._cache.lazy_offloading:
             self._cache.offload_unlocked_models(self._cache_entry.size)
             self._cache.print_cuda_stats()

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

@@ -44,7 +44,7 @@ class StableDiffusionDiffusersModel(GenericDiffusersLoader):
     ) -> AnyModel:
         if not submodel_type is not None:
             raise Exception("A submodel type must be provided when loading main pipelines.")
-        load_class = self.get_hf_load_class(model_path, submodel_type)
+        load_class = self._get_hf_load_class(model_path, submodel_type)
         variant = model_variant.value if model_variant else None
         model_path = model_path / submodel_type.value
         result: AnyModel = load_class.from_pretrained(

invokeai/backend/stable_diffusion/diffusion/conditioning_data.py

@@ -32,11 +32,6 @@ class BasicConditioningInfo:
         return self
 
 
-@dataclass
-class ConditioningFieldData:
-    conditionings: List[BasicConditioningInfo]
-
-
 @dataclass
 class SDXLConditioningInfo(BasicConditioningInfo):
     pooled_embeds: torch.Tensor

invokeai/backend/tiles/tiles.py

@@ -3,7 +3,7 @@ from typing import Union
 
 import numpy as np
 
-from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR
+from invokeai.app.invocations.latent import LATENT_SCALE_FACTOR
 from invokeai.backend.tiles.utils import TBLR, Tile, paste, seam_blend
 
 

invokeai/backend/util/test_utils.py

@@ -37,23 +37,23 @@ def install_and_load_model(
         submodel_type (Optional[SubModelType]): The submodel type, forwarded to ModelManager.get_model(...).
 
     Returns:
-        LoadedModelInfo
+        ModelInfo
     """
     # If the requested model is already installed, return its LoadedModel
     with contextlib.suppress(UnknownModelException):
         # TODO: Replace with wrapper call
-        loaded_model: LoadedModel = model_manager.load_model_by_attr(
-            model_name=model_name, base_model=base_model, model_type=model_type
+        loaded_model: LoadedModel = model_manager.load.load_model_by_attr(
+            name=model_name, base=base_model, type=model_type
         )
         return loaded_model
 
     # Install the requested model.
     job = model_manager.install.heuristic_import(model_path_id_or_url)
     model_manager.install.wait_for_job(job, timeout=10)
-    assert job.complete
+    assert job.is_complete
 
     try:
-        loaded_model = model_manager.load_model_by_config(job.config_out)
+        loaded_model = model_manager.load.load_by_config(job.config)
         return loaded_model
     except UnknownModelException as e:
         raise Exception(

invokeai/frontend/install/model_install.py

@@ -43,7 +43,7 @@ from invokeai.frontend.install.widgets import (
 warnings.filterwarnings("ignore", category=UserWarning)  # noqa: E402
 config = InvokeAIAppConfig.get_config()
 logger = InvokeAILogger.get_logger("ModelInstallService")
-# logger.setLevel("WARNING")
+logger.setLevel("WARNING")
 # logger.setLevel('DEBUG')
 
 # build a table mapping all non-printable characters to None

invokeai/frontend/web/.gitignore

@@ -41,6 +41,3 @@ stats.html
 # Yalc
 .yalc
 yalc.lock
-
-# vitest
-tsconfig.vitest-temp.json

invokeai/frontend/web/.storybook/ReduxInit.tsx

@@ -10,7 +10,13 @@ export const ReduxInit = memo((props: PropsWithChildren) => {
   const dispatch = useAppDispatch();
   useGlobalModifiersInit();
   useEffect(() => {
-    dispatch(modelChanged({ key: 'test_model', base: 'sd-1' }));
+    dispatch(
+      modelChanged({
+        model_name: 'test_model',
+        base_model: 'sd-1',
+        model_type: 'main',
+      })
+    );
   }, []);
 
   return props.children;

invokeai/frontend/web/config/common.mts

@@ -0,0 +1,12 @@
+import react from '@vitejs/plugin-react-swc';
+import { visualizer } from 'rollup-plugin-visualizer';
+import type { PluginOption, UserConfig } from 'vite';
+import eslint from 'vite-plugin-eslint';
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+export const commonPlugins: UserConfig['plugins'] = [
+  react(),
+  eslint(),
+  tsconfigPaths(),
+  visualizer() as unknown as PluginOption,
+];

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

@@ -0,0 +1,33 @@
+import type { UserConfig } from 'vite';
+
+import { commonPlugins } from './common.mjs';
+
+export const appConfig: UserConfig = {
+  base: './',
+  plugins: [...commonPlugins],
+  build: {
+    chunkSizeWarningLimit: 1500,
+  },
+  server: {
+    // Proxy HTTP requests to the flask server
+    proxy: {
+      // Proxy socket.io to the nodes socketio server
+      '/ws/socket.io': {
+        target: 'ws://127.0.0.1:9090',
+        ws: true,
+      },
+      // Proxy openapi schema definiton
+      '/openapi.json': {
+        target: 'http://127.0.0.1:9090/openapi.json',
+        rewrite: (path) => path.replace(/^\/openapi.json/, ''),
+        changeOrigin: true,
+      },
+      // proxy nodes api
+      '/api/v1': {
+        target: 'http://127.0.0.1:9090/api/v1',
+        rewrite: (path) => path.replace(/^\/api\/v1/, ''),
+        changeOrigin: true,
+      },
+    },
+  },
+};

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

@@ -0,0 +1,46 @@
+import path from 'path';
+import type { UserConfig } from 'vite';
+import cssInjectedByJsPlugin from 'vite-plugin-css-injected-by-js';
+import dts from 'vite-plugin-dts';
+
+import { commonPlugins } from './common.mjs';
+
+export const packageConfig: UserConfig = {
+  base: './',
+  plugins: [
+    ...commonPlugins,
+    dts({
+      insertTypesEntry: true,
+    }),
+    cssInjectedByJsPlugin(),
+  ],
+  build: {
+    cssCodeSplit: true,
+    lib: {
+      entry: path.resolve(__dirname, '../src/index.ts'),
+      name: 'InvokeAIUI',
+      fileName: (format) => `invoke-ai-ui.${format}.js`,
+    },
+    rollupOptions: {
+      external: ['react', 'react-dom', '@emotion/react', '@chakra-ui/react', '@invoke-ai/ui-library'],
+      output: {
+        globals: {
+          react: 'React',
+          'react-dom': 'ReactDOM',
+          '@emotion/react': 'EmotionReact',
+          '@invoke-ai/ui-library': 'UiLibrary',
+        },
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      app: path.resolve(__dirname, '../src/app'),
+      assets: path.resolve(__dirname, '../src/assets'),
+      common: path.resolve(__dirname, '../src/common'),
+      features: path.resolve(__dirname, '../src/features'),
+      services: path.resolve(__dirname, '../src/services'),
+      theme: path.resolve(__dirname, '../src/theme'),
+    },
+  },
+};

invokeai/frontend/web/package.json

@@ -33,9 +33,7 @@
     "preinstall": "npx only-allow pnpm",
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build",
-    "unimported": "npx unimported",
-    "test": "vitest",
-    "test:no-watch": "vitest --no-watch"
+    "unimported": "npx unimported"
   },
   "madge": {
     "excludeRegExp": [
@@ -54,7 +52,6 @@
     "@chakra-ui/react-use-size": "^2.1.0",
     "@dagrejs/graphlib": "^2.1.13",
     "@dnd-kit/core": "^6.1.0",
-    "@dnd-kit/sortable": "^8.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@fontsource-variable/inter": "^5.0.16",
     "@invoke-ai/ui-library": "^0.0.18",
@@ -154,14 +151,12 @@
     "rollup-plugin-visualizer": "^5.12.0",
     "storybook": "^7.6.10",
     "ts-toolbelt": "^9.6.0",
-    "tsafe": "^1.6.6",
     "typescript": "^5.3.3",
     "vite": "^5.0.12",
     "vite-plugin-css-injected-by-js": "^3.3.1",
     "vite-plugin-dts": "^3.7.1",
     "vite-plugin-eslint": "^1.8.1",
-    "vite-tsconfig-paths": "^4.3.1",
-    "vitest": "^1.2.2"
+    "vite-tsconfig-paths": "^4.3.1"
   },
   "pnpm": {
     "patchedDependencies": {

invokeai/frontend/web/pnpm-lock.yaml

@@ -22,9 +22,6 @@ dependencies:
   '@dnd-kit/core':
     specifier: ^6.1.0
     version: 6.1.0(react-dom@18.2.0)(react@18.2.0)
-  '@dnd-kit/sortable':
-    specifier: ^8.0.0
-    version: 8.0.0(@dnd-kit/core@6.1.0)(react@18.2.0)
   '@dnd-kit/utilities':
     specifier: ^3.2.2
     version: 3.2.2(react@18.2.0)
@@ -215,7 +212,7 @@ devDependencies:
     version: 7.6.10(react-dom@18.2.0)(react@18.2.0)(typescript@5.3.3)(vite@5.0.12)
   '@storybook/test':
     specifier: ^7.6.10
-    version: 7.6.10(vitest@1.2.2)
+    version: 7.6.10
   '@storybook/theming':
     specifier: ^7.6.10
     version: 7.6.10(react-dom@18.2.0)(react@18.2.0)
@@ -300,9 +297,6 @@ devDependencies:
   ts-toolbelt:
     specifier: ^9.6.0
     version: 9.6.0
-  tsafe:
-    specifier: ^1.6.6
-    version: 1.6.6
   typescript:
     specifier: ^5.3.3
     version: 5.3.3
@@ -321,9 +315,6 @@ devDependencies:
   vite-tsconfig-paths:
     specifier: ^4.3.1
     version: 4.3.1(typescript@5.3.3)(vite@5.0.12)
-  vitest:
-    specifier: ^1.2.2
-    version: 1.2.2(@types/node@20.11.5)
 
 packages:
 
@@ -2893,18 +2884,6 @@ packages:
       tslib: 2.6.2
     dev: false
 
-  /@dnd-kit/sortable@8.0.0(@dnd-kit/core@6.1.0)(react@18.2.0):
-    resolution: {integrity: sha512-U3jk5ebVXe1Lr7c2wU7SBZjcWdQP+j7peHJfCspnA81enlu88Mgd7CC8Q+pub9ubP7eKVETzJW+IBAhsqbSu/g==}
-    peerDependencies:
-      '@dnd-kit/core': ^6.1.0
-      react: '>=16.8.0'
-    dependencies:
-      '@dnd-kit/core': 6.1.0(react-dom@18.2.0)(react@18.2.0)
-      '@dnd-kit/utilities': 3.2.2(react@18.2.0)
-      react: 18.2.0
-      tslib: 2.6.2
-    dev: false
-
   /@dnd-kit/utilities@3.2.2(react@18.2.0):
     resolution: {integrity: sha512-+MKAJEOfaBe5SmV6t34p80MMKhjvUz0vRrvVJbPT0WElzaOJ/1xs+D+KDv+tD/NE5ujfrChEcshd4fLn0wpiqg==}
     peerDependencies:
@@ -5470,7 +5449,7 @@ packages:
       - supports-color
     dev: true
 
-  /@storybook/test@7.6.10(vitest@1.2.2):
+  /@storybook/test@7.6.10:
     resolution: {integrity: sha512-dn/T+HcWOBlVh3c74BHurp++BaqBoQgNbSIaXlYDpJoZ+DzNIoEQVsWFYm5gCbtKK27iFd4n52RiQI3f6Vblqw==}
     dependencies:
       '@storybook/client-logger': 7.6.10
@@ -5478,7 +5457,7 @@ packages:
       '@storybook/instrumenter': 7.6.10
       '@storybook/preview-api': 7.6.10
       '@testing-library/dom': 9.3.4
-      '@testing-library/jest-dom': 6.2.0(vitest@1.2.2)
+      '@testing-library/jest-dom': 6.2.0
       '@testing-library/user-event': 14.3.0(@testing-library/dom@9.3.4)
       '@types/chai': 4.3.11
       '@vitest/expect': 0.34.7
@@ -5658,7 +5637,7 @@ packages:
       pretty-format: 27.5.1
     dev: true
 
-  /@testing-library/jest-dom@6.2.0(vitest@1.2.2):
+  /@testing-library/jest-dom@6.2.0:
     resolution: {integrity: sha512-+BVQlJ9cmEn5RDMUS8c2+TU6giLvzaHZ8sU/x0Jj7fk+6/46wPdwlgOPcpxS17CjcanBi/3VmGMqVr2rmbUmNw==}
     engines: {node: '>=14', npm: '>=6', yarn: '>=1'}
     peerDependencies:
@@ -5684,7 +5663,6 @@ packages:
       dom-accessibility-api: 0.6.3
       lodash: 4.17.21
       redent: 3.0.0
-      vitest: 1.2.2(@types/node@20.11.5)
     dev: true
 
   /@testing-library/user-event@14.3.0(@testing-library/dom@9.3.4):
@@ -6497,42 +6475,12 @@ packages:
       chai: 4.4.1
     dev: true
 
-  /@vitest/expect@1.2.2:
-    resolution: {integrity: sha512-3jpcdPAD7LwHUUiT2pZTj2U82I2Tcgg2oVPvKxhn6mDI2On6tfvPQTjAI4628GUGDZrCm4Zna9iQHm5cEexOAg==}
-    dependencies:
-      '@vitest/spy': 1.2.2
-      '@vitest/utils': 1.2.2
-      chai: 4.4.1
-    dev: true
-
-  /@vitest/runner@1.2.2:
-    resolution: {integrity: sha512-JctG7QZ4LSDXr5CsUweFgcpEvrcxOV1Gft7uHrvkQ+fsAVylmWQvnaAr/HDp3LAH1fztGMQZugIheTWjaGzYIg==}
-    dependencies:
-      '@vitest/utils': 1.2.2
-      p-limit: 5.0.0
-      pathe: 1.1.2
-    dev: true
-
-  /@vitest/snapshot@1.2.2:
-    resolution: {integrity: sha512-SmGY4saEw1+bwE1th6S/cZmPxz/Q4JWsl7LvbQIky2tKE35US4gd0Mjzqfr84/4OD0tikGWaWdMja/nWL5NIPA==}
-    dependencies:
-      magic-string: 0.30.5
-      pathe: 1.1.2
-      pretty-format: 29.7.0
-    dev: true
-
   /@vitest/spy@0.34.7:
     resolution: {integrity: sha512-NMMSzOY2d8L0mcOt4XcliDOS1ISyGlAXuQtERWVOoVHnKwmG+kKhinAiGw3dTtMQWybfa89FG8Ucg9tiC/FhTQ==}
     dependencies:
       tinyspy: 2.2.0
     dev: true
 
-  /@vitest/spy@1.2.2:
-    resolution: {integrity: sha512-k9Gcahssw8d7X3pSLq3e3XEu/0L78mUkCjivUqCQeXJm9clfXR/Td8+AP+VC1O6fKPIDLcHDTAmBOINVuv6+7g==}
-    dependencies:
-      tinyspy: 2.2.0
-    dev: true
-
   /@vitest/utils@0.34.7:
     resolution: {integrity: sha512-ziAavQLpCYS9sLOorGrFFKmy2gnfiNU0ZJ15TsMz/K92NAPS/rp9K4z6AJQQk5Y8adCy4Iwpxy7pQumQ/psnRg==}
     dependencies:
@@ -6541,15 +6489,6 @@ packages:
       pretty-format: 29.7.0
     dev: true
 
-  /@vitest/utils@1.2.2:
-    resolution: {integrity: sha512-WKITBHLsBHlpjnDQahr+XK6RE7MiAsgrIkr0pGhQ9ygoxBfUeG0lUG5iLlzqjmKSlBv3+j5EGsriBzh+C3Tq9g==}
-    dependencies:
-      diff-sequences: 29.6.3
-      estree-walker: 3.0.3
-      loupe: 2.3.7
-      pretty-format: 29.7.0
-    dev: true
-
   /@volar/language-core@1.11.1:
     resolution: {integrity: sha512-dOcNn3i9GgZAcJt43wuaEykSluAuOkQgzni1cuxLxTV0nJKanQztp7FxyswdRILaKH+P2XZMPRp2S4MV/pElCw==}
     dependencies:
@@ -7230,11 +7169,6 @@ packages:
     engines: {node: '>=0.4.0'}
     dev: true
 
-  /acorn-walk@8.3.2:
-    resolution: {integrity: sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==}
-    engines: {node: '>=0.4.0'}
-    dev: true
-
   /acorn@7.4.1:
     resolution: {integrity: sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==}
     engines: {node: '>=0.4.0'}
@@ -7712,11 +7646,6 @@ packages:
     engines: {node: '>= 0.8'}
     dev: true
 
-  /cac@6.7.14:
-    resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
-    engines: {node: '>=8'}
-    dev: true
-
   /call-bind@1.0.5:
     resolution: {integrity: sha512-C3nQxfFZxFRVoJoGKKI8y3MOEo129NQ+FgQ08iye+Mk4zNZZGdjfs06bVTr+DBSlA66Q2VEcMki/cUCP4SercQ==}
     dependencies:
@@ -9229,12 +9158,6 @@ packages:
     resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
     dev: true
 
-  /estree-walker@3.0.3:
-    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
-    dependencies:
-      '@types/estree': 1.0.5
-    dev: true
-
   /esutils@2.0.3:
     resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
     engines: {node: '>=0.10.0'}
@@ -10609,10 +10532,6 @@ packages:
     hasBin: true
     dev: true
 
-  /jsonc-parser@3.2.1:
-    resolution: {integrity: sha512-AilxAyFOAcK5wA1+LeaySVBrHsGQvUFCDWXKpZjzaL0PqW+xfBOttn8GNtWKFWqneyMZj41MWF9Kl6iPWLwgOA==}
-    dev: true
-
   /jsondiffpatch@0.6.0:
     resolution: {integrity: sha512-3QItJOXp2AP1uv7waBkao5nCvhEv+QmJAd38Ybq7wNI74Q+BBmnLn4EDKz6yI9xGAIQoUF87qHt+kc1IVxB4zQ==}
     engines: {node: ^18.0.0 || >=20.0.0}
@@ -10714,14 +10633,6 @@ packages:
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     dev: true
 
-  /local-pkg@0.5.0:
-    resolution: {integrity: sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==}
-    engines: {node: '>=14'}
-    dependencies:
-      mlly: 1.5.0
-      pkg-types: 1.0.3
-    dev: true
-
   /locate-path@3.0.0:
     resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==}
     engines: {node: '>=6'}
@@ -11060,15 +10971,6 @@ packages:
     hasBin: true
     dev: true
 
-  /mlly@1.5.0:
-    resolution: {integrity: sha512-NPVQvAY1xr1QoVeG0cy8yUYC7FQcOx6evl/RjT1wL5FvzPnzOysoqB/jmx/DhssT2dYa8nxECLAaFI/+gVLhDQ==}
-    dependencies:
-      acorn: 8.11.3
-      pathe: 1.1.2
-      pkg-types: 1.0.3
-      ufo: 1.3.2
-    dev: true
-
   /module-definition@3.4.0:
     resolution: {integrity: sha512-XxJ88R1v458pifaSkPNLUTdSPNVGMP2SXVncVmApGO+gAfrLANiYe6JofymCzVceGOMwQE2xogxBSc8uB7XegA==}
     engines: {node: '>=6.0'}
@@ -11463,13 +11365,6 @@ packages:
       yocto-queue: 0.1.0
     dev: true
 
-  /p-limit@5.0.0:
-    resolution: {integrity: sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==}
-    engines: {node: '>=18'}
-    dependencies:
-      yocto-queue: 1.0.0
-    dev: true
-
   /p-locate@3.0.0:
     resolution: {integrity: sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==}
     engines: {node: '>=6'}
@@ -11640,14 +11535,6 @@ packages:
       find-up: 5.0.0
     dev: true
 
-  /pkg-types@1.0.3:
-    resolution: {integrity: sha512-nN7pYi0AQqJnoLPC9eHFQ8AcyaixBUOwvqc5TDnIKCMEE6I0y8P7OKA7fPexsXGCGxQDl/cmrLAp26LhcwxZ4A==}
-    dependencies:
-      jsonc-parser: 3.2.1
-      mlly: 1.5.0
-      pathe: 1.1.2
-    dev: true
-
   /pluralize@8.0.0:
     resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
     engines: {node: '>=4'}
@@ -12948,10 +12835,6 @@ packages:
       object-inspect: 1.13.1
     dev: true
 
-  /siginfo@2.0.0:
-    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
-    dev: true
-
   /signal-exit@3.0.7:
     resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
     dev: true
@@ -13070,10 +12953,6 @@ packages:
       stackframe: 1.3.4
     dev: false
 
-  /stackback@0.0.2:
-    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
-    dev: true
-
   /stackframe@1.3.4:
     resolution: {integrity: sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw==}
     dev: false
@@ -13098,10 +12977,6 @@ packages:
     engines: {node: '>= 0.8'}
     dev: true
 
-  /std-env@3.7.0:
-    resolution: {integrity: sha512-JPbdCEQLj1w5GilpiHAx3qJvFndqybBysA3qUOnznweH4QbNYUsW/ea8QzSrnh0vNsezMMw5bcVool8lM0gwzg==}
-    dev: true
-
   /stop-iteration-iterator@1.0.0:
     resolution: {integrity: sha512-iCGQj+0l0HOdZ2AEeBADlsRC+vsnDsZsbdSiH1yNSjcfKM7fdpCMfqAL/dwF5BLiw/XhRft/Wax6zQbhq2BcjQ==}
     engines: {node: '>= 0.4'}
@@ -13271,12 +13146,6 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /strip-literal@1.3.0:
-    resolution: {integrity: sha512-PugKzOsyXpArk0yWmUwqOZecSO0GH0bPoctLcqNDH9J04pVW3lflYE0ujElBGTloevcxF5MofAOZ7C5l2b+wLg==}
-    dependencies:
-      acorn: 8.11.3
-    dev: true
-
   /stylis@4.2.0:
     resolution: {integrity: sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw==}
     dev: false
@@ -13427,15 +13296,6 @@ packages:
   /tiny-invariant@1.3.1:
     resolution: {integrity: sha512-AD5ih2NlSssTCwsMznbvwMZpJ1cbhkGd2uueNxzv2jDlEeZdU04JQfRnggJQ8DrcVBGjAsCKwFBbDlVNtEMlzw==}
 
-  /tinybench@2.6.0:
-    resolution: {integrity: sha512-N8hW3PG/3aOoZAN5V/NSAEDz0ZixDSSt5b/a05iqtpgfLWMSVuCo7w0k2vVvEjdrIoeGqZzweX2WlyioNIHchA==}
-    dev: true
-
-  /tinypool@0.8.2:
-    resolution: {integrity: sha512-SUszKYe5wgsxnNOVlBYO6IC+8VGWdVGZWAqUxp3UErNBtptZvWbwyUOyzNL59zigz2rCA92QiL3wvG+JDSdJdQ==}
-    engines: {node: '>=14.0.0'}
-    dev: true
-
   /tinyspy@2.2.0:
     resolution: {integrity: sha512-d2eda04AN/cPOR89F7Xv5bK/jrQEhmcLFe6HFldoeO9AJtps+fqEnh486vnT/8y4bw38pSyxDcTCAq+Ks2aJTg==}
     engines: {node: '>=14.0.0'}
@@ -13508,10 +13368,6 @@ packages:
     resolution: {integrity: sha512-nsZd8ZeNUzukXPlJmTBwUAuABDe/9qtVDelJeT/qW0ow3ZS3BsQJtNkan1802aM9Uf68/Y8ljw86Hu0h5IUW3w==}
     dev: true
 
-  /tsafe@1.6.6:
-    resolution: {integrity: sha512-gzkapsdbMNwBnTIjgO758GujLCj031IgHK/PKr2mrmkCSJMhSOR5FeOuSxKLMUoYc0vAA4RGEYYbjt/v6afD3g==}
-    dev: true
-
   /tsconfck@3.0.1(typescript@5.3.3):
     resolution: {integrity: sha512-7ppiBlF3UEddCLeI1JRx5m2Ryq+xk4JrZuq4EuYXykipebaq1dV0Fhgr1hb7CkmHt32QSgOZlcqVLEtHBG4/mg==}
     engines: {node: ^18 || >=20}
@@ -13957,27 +13813,6 @@ packages:
     engines: {node: '>= 0.8'}
     dev: true
 
-  /vite-node@1.2.2(@types/node@20.11.5):
-    resolution: {integrity: sha512-1as4rDTgVWJO3n1uHmUYqq7nsFgINQ9u+mRcXpjeOMJUmviqNKjcZB7UfRZrlM7MjYXMKpuWp5oGkjaFLnjawg==}
-    engines: {node: ^18.0.0 || >=20.0.0}
-    hasBin: true
-    dependencies:
-      cac: 6.7.14
-      debug: 4.3.4
-      pathe: 1.1.2
-      picocolors: 1.0.0
-      vite: 5.0.12(@types/node@20.11.5)
-    transitivePeerDependencies:
-      - '@types/node'
-      - less
-      - lightningcss
-      - sass
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-    dev: true
-
   /vite-plugin-css-injected-by-js@3.3.1(vite@5.0.12):
     resolution: {integrity: sha512-PjM/X45DR3/V1K1fTRs8HtZHEQ55kIfdrn+dzaqNBFrOYO073SeSNCxp4j7gSYhV9NffVHaEnOL4myoko0ePAg==}
     peerDependencies:
@@ -14076,63 +13911,6 @@ packages:
       fsevents: 2.3.3
     dev: true
 
-  /vitest@1.2.2(@types/node@20.11.5):
-    resolution: {integrity: sha512-d5Ouvrnms3GD9USIK36KG8OZ5bEvKEkITFtnGv56HFaSlbItJuYr7hv2Lkn903+AvRAgSixiamozUVfORUekjw==}
-    engines: {node: ^18.0.0 || >=20.0.0}
-    hasBin: true
-    peerDependencies:
-      '@edge-runtime/vm': '*'
-      '@types/node': ^18.0.0 || >=20.0.0
-      '@vitest/browser': ^1.0.0
-      '@vitest/ui': ^1.0.0
-      happy-dom: '*'
-      jsdom: '*'
-    peerDependenciesMeta:
-      '@edge-runtime/vm':
-        optional: true
-      '@types/node':
-        optional: true
-      '@vitest/browser':
-        optional: true
-      '@vitest/ui':
-        optional: true
-      happy-dom:
-        optional: true
-      jsdom:
-        optional: true
-    dependencies:
-      '@types/node': 20.11.5
-      '@vitest/expect': 1.2.2
-      '@vitest/runner': 1.2.2
-      '@vitest/snapshot': 1.2.2
-      '@vitest/spy': 1.2.2
-      '@vitest/utils': 1.2.2
-      acorn-walk: 8.3.2
-      cac: 6.7.14
-      chai: 4.4.1
-      debug: 4.3.4
-      execa: 8.0.1
-      local-pkg: 0.5.0
-      magic-string: 0.30.5
-      pathe: 1.1.2
-      picocolors: 1.0.0
-      std-env: 3.7.0
-      strip-literal: 1.3.0
-      tinybench: 2.6.0
-      tinypool: 0.8.2
-      vite: 5.0.12(@types/node@20.11.5)
-      vite-node: 1.2.2(@types/node@20.11.5)
-      why-is-node-running: 2.2.2
-    transitivePeerDependencies:
-      - less
-      - lightningcss
-      - sass
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-    dev: true
-
   /void-elements@3.1.0:
     resolution: {integrity: sha512-Dhxzh5HZuiHQhbvTW9AMetFfBHDMYpo23Uo9btPXgdYP+3T5S+p+jgNy7spra+veYhBP2dCSgxR/i2Y02h5/6w==}
     engines: {node: '>=0.10.0'}
@@ -14256,15 +14034,6 @@ packages:
       isexe: 2.0.0
     dev: true
 
-  /why-is-node-running@2.2.2:
-    resolution: {integrity: sha512-6tSwToZxTOcotxHeA+qGCq1mVzKR3CwcJGmVcY+QE8SHy6TnpFnh8PAvPNHYr7EcuVeG0QSMxtYCuO1ta/G/oA==}
-    engines: {node: '>=8'}
-    hasBin: true
-    dependencies:
-      siginfo: 2.0.0
-      stackback: 0.0.2
-    dev: true
-
   /wordwrap@1.0.0:
     resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==}
     dev: true
@@ -14405,11 +14174,6 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /yocto-queue@1.0.0:
-    resolution: {integrity: sha512-9bnSc/HEW2uRy67wc+T8UwauLuPJVn28jb+GtJY16iiKWyvmYJRXVT4UamsAEGQfPohgr2q4Tq0sQbQlxTfi1g==}
-    engines: {node: '>=12.20'}
-    dev: true
-
   /z-schema@5.0.5:
     resolution: {integrity: sha512-D7eujBWkLa3p2sIpJA0d1pr7es+a7m0vFAnZLlCEKq/Ij2k0MLi9Br2UPxoxdYystm5K1yeBGzub0FlYUEWj2Q==}
     engines: {node: '>=8.0.0'}

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

@@ -69,7 +69,7 @@
         "random": "Zufall",
         "batch": "Stapel-Manager",
         "advanced": "Erweitert",
-        "unifiedCanvas": "Leinwand",
+        "unifiedCanvas": "Einheitliche Leinwand",
         "openInNewTab": "In einem neuem Tab öffnen",
         "statusProcessing": "wird bearbeitet",
         "linear": "Linear",
@@ -127,7 +127,7 @@
         "galleryImageResetSize": "Größe zurücksetzen",
         "gallerySettings": "Galerie-Einstellungen",
         "maintainAspectRatio": "Seitenverhältnis beibehalten",
-        "autoSwitchNewImages": "Auto-Wechsel zu neuen Bildern",
+        "autoSwitchNewImages": "Automatisch zu neuen Bildern wechseln",
         "singleColumnLayout": "Einspaltiges Layout",
         "allImagesLoaded": "Alle Bilder geladen",
         "loadMore": "Mehr laden",
@@ -226,7 +226,7 @@
         },
         "sendToImageToImage": {
             "title": "An Bild zu Bild senden",
-            "desc": "Aktuelles Bild an Bild-zu-Bild senden"
+            "desc": "Aktuelles Bild an Bild zu Bild senden"
         },
         "deleteImage": {
             "title": "Bild löschen",
@@ -258,7 +258,7 @@
         },
         "selectEraser": {
             "title": "Radiergummi auswählen",
-            "desc": "Wählt den Radiergummi aus"
+            "desc": "Wählt den Radiergummi für die Leinwand aus"
         },
         "decreaseBrushSize": {
             "title": "Pinselgröße verkleinern",
@@ -330,7 +330,7 @@
         },
         "downloadImage": {
             "title": "Bild herunterladen",
-            "desc": "Aktuelles Bild herunterladen"
+            "desc": "Aktuelle Leinwand herunterladen"
         },
         "undoStroke": {
             "title": "Pinselstrich rückgängig machen",
@@ -564,8 +564,8 @@
         "img2imgStrength": "Bild-zu-Bild-Stärke",
         "toggleLoopback": "Loopback umschalten",
         "sendTo": "Senden an",
-        "sendToImg2Img": "Senden an Bild-zu-Bild",
-        "sendToUnifiedCanvas": "Senden an Leinwand",
+        "sendToImg2Img": "Senden an Bild zu Bild",
+        "sendToUnifiedCanvas": "Senden an Unified Canvas",
         "copyImageToLink": "Bild-Link kopieren",
         "downloadImage": "Bild herunterladen",
         "openInViewer": "Im Viewer öffnen",
@@ -604,9 +604,7 @@
         "resetComplete": "Die Web-Oberfläche wurde zurückgesetzt.",
         "models": "Modelle",
         "useSlidersForAll": "Schieberegler für alle Optionen verwenden",
-        "showAdvancedOptions": "Erweiterte Optionen anzeigen",
-        "alternateCanvasLayout": "Alternatives Leinwand-Layout",
-        "clearIntermediatesDesc1": "Das Löschen der Zwischenprodukte setzt Leinwand und ControlNet zurück."
+        "showAdvancedOptions": "Erweiterte Optionen anzeigen"
     },
     "toast": {
         "tempFoldersEmptied": "Temp-Ordner geleert",
@@ -620,7 +618,7 @@
         "imageSavedToGallery": "Bild in die Galerie gespeichert",
         "canvasMerged": "Leinwand zusammengeführt",
         "sentToImageToImage": "Gesendet an Bild zu Bild",
-        "sentToUnifiedCanvas": "Gesendet an Leinwand",
+        "sentToUnifiedCanvas": "Gesendet an Unified Canvas",
         "parametersSet": "Parameter festlegen",
         "parametersNotSet": "Parameter nicht festgelegt",
         "parametersNotSetDesc": "Keine Metadaten für dieses Bild gefunden.",
@@ -637,21 +635,7 @@
         "metadataLoadFailed": "Metadaten konnten nicht geladen werden",
         "initialImageSet": "Ausgangsbild festgelegt",
         "initialImageNotSet": "Ausgangsbild nicht festgelegt",
-        "initialImageNotSetDesc": "Ausgangsbild konnte nicht geladen werden",
-        "setCanvasInitialImage": "Ausgangsbild setzen",
-        "problemMergingCanvas": "Problem bei Verschmelzung der Leinwand",
-        "canvasCopiedClipboard": "Leinwand in Zwischenablage kopiert",
-        "canvasSentControlnetAssets": "Leinwand an ControlNet & Sammlung geschickt",
-        "problemDownloadingCanvasDesc": "Kann Basis-Layer nicht exportieren",
-        "canvasDownloaded": "Leinwand heruntergeladen",
-        "problemSavingCanvasDesc": "Kann Basis-Layer nicht exportieren",
-        "canvasSavedGallery": "Leinwand in Galerie gespeichert",
-        "problemMergingCanvasDesc": "Kann Basis-Layer nicht exportieren",
-        "problemSavingCanvas": "Problem beim Speichern der Leinwand",
-        "problemCopyingCanvas": "Problem beim Kopieren der Leinwand",
-        "problemCopyingCanvasDesc": "Kann Basis-Layer nicht exportieren",
-        "problemDownloadingCanvas": "Problem beim Herunterladen der Leinwand",
-        "setAsCanvasInitialImage": "Als Ausgangsbild gesetzt"
+        "initialImageNotSetDesc": "Ausgangsbild konnte nicht geladen werden"
     },
     "tooltip": {
         "feature": {
@@ -664,7 +648,7 @@
             "faceCorrection": "Gesichtskorrektur mit GFPGAN oder Codeformer: Der Algorithmus erkennt Gesichter im Bild und korrigiert alle Fehler. Ein hoher Wert verändert das Bild stärker, was zu attraktiveren Gesichtern führt. Codeformer mit einer höheren Genauigkeit bewahrt das Originalbild auf Kosten einer stärkeren Gesichtskorrektur.",
             "imageToImage": "Bild zu Bild lädt ein beliebiges Bild als Ausgangsbild, aus dem dann zusammen mit dem Prompt ein neues Bild erzeugt wird. Je höher der Wert ist, desto stärker wird das Ergebnisbild verändert. Werte von 0,0 bis 1,0 sind möglich, der empfohlene Bereich ist .25-.75",
             "boundingBox": "Der Begrenzungsrahmen ist derselbe wie die Einstellungen für Breite und Höhe bei Text-zu-Bild oder Bild-zu-Bild. Es wird nur der Bereich innerhalb des Rahmens verarbeitet.",
-            "seamCorrection": "Behandlung von sichtbaren Übergängen, die zwischen den erzeugten Bildern auftreten.",
+            "seamCorrection": "Steuert die Behandlung von sichtbaren Übergängen, die zwischen den erzeugten Bildern auf der Leinwand auftreten.",
             "infillAndScaling": "Verwalten Sie Infill-Methoden (für maskierte oder gelöschte Bereiche der Leinwand) und Skalierung (nützlich für kleine Begrenzungsrahmengrößen)."
         }
     },
@@ -675,17 +659,17 @@
         "maskingOptions": "Maskierungsoptionen",
         "enableMask": "Maske aktivieren",
         "preserveMaskedArea": "Maskierten Bereich bewahren",
-        "clearMask": "Maske löschen (Shift+C)",
+        "clearMask": "Maske löschen",
         "brush": "Pinsel",
         "eraser": "Radierer",
         "fillBoundingBox": "Begrenzungsrahmen füllen",
         "eraseBoundingBox": "Begrenzungsrahmen löschen",
-        "colorPicker": "Pipette",
+        "colorPicker": "Farbpipette",
         "brushOptions": "Pinseloptionen",
         "brushSize": "Größe",
         "move": "Bewegen",
         "resetView": "Ansicht zurücksetzen",
-        "mergeVisible": "Sichtbare zusammenführen",
+        "mergeVisible": "Sichtbare Zusammenführen",
         "saveToGallery": "In Galerie speichern",
         "copyToClipboard": "In Zwischenablage kopieren",
         "downloadAsImage": "Als Bild herunterladen",
@@ -699,15 +683,15 @@
         "darkenOutsideSelection": "Außerhalb der Auswahl verdunkeln",
         "autoSaveToGallery": "Automatisch in Galerie speichern",
         "saveBoxRegionOnly": "Nur Auswahlbox speichern",
-        "limitStrokesToBox": "Striche auf Auswahl beschränken",
-        "showCanvasDebugInfo": "Zusätzliche Informationen anzeigen",
+        "limitStrokesToBox": "Striche auf Box beschränken",
+        "showCanvasDebugInfo": "Zusätzliche Informationen zur Leinwand anzeigen",
         "clearCanvasHistory": "Leinwand-Verlauf löschen",
         "clearHistory": "Verlauf löschen",
-        "clearCanvasHistoryMessage": "Wenn Sie den Verlauf löschen, bleibt die aktuelle Leinwand intakt, aber der Verlauf der Rückgängig- und Wiederherstellung wird unwiderruflich gelöscht.",
-        "clearCanvasHistoryConfirm": "Sind Sie sicher, dass Sie den Verlauf löschen möchten?",
+        "clearCanvasHistoryMessage": "Wenn Sie den Verlauf der Leinwand löschen, bleibt die aktuelle Leinwand intakt, aber der Verlauf der Rückgängig- und Wiederherstellung wird unwiderruflich gelöscht.",
+        "clearCanvasHistoryConfirm": "Sind Sie sicher, dass Sie den Verlauf der Leinwand löschen möchten?",
         "emptyTempImageFolder": "Temp-Image Ordner leeren",
         "emptyFolder": "Leerer Ordner",
-        "emptyTempImagesFolderMessage": "Wenn Sie den Ordner für temporäre Bilder leeren, wird die Leinwand zurückgesetzt. Dies umfasst den gesamten Verlauf der Rückgängig-/Wiederherstellungsvorgänge, die Bilder im Bereitstellungsbereich und die Leinwand-Basisebene.",
+        "emptyTempImagesFolderMessage": "Wenn Sie den Ordner für temporäre Bilder leeren, wird auch der Unified Canvas vollständig zurückgesetzt. Dies umfasst den gesamten Verlauf der Rückgängig-/Wiederherstellungsvorgänge, die Bilder im Bereitstellungsbereich und die Leinwand-Basisebene.",
         "emptyTempImagesFolderConfirm": "Sind Sie sicher, dass Sie den temporären Ordner leeren wollen?",
         "activeLayer": "Aktive Ebene",
         "canvasScale": "Leinwand Maßstab",
@@ -724,7 +708,7 @@
         "discardAll": "Alles verwerfen",
         "betaClear": "Löschen",
         "betaDarkenOutside": "Außen abdunkeln",
-        "betaLimitToBox": "Auf Auswahl begrenzen",
+        "betaLimitToBox": "Begrenzung auf das Feld",
         "betaPreserveMasked": "Maskiertes bewahren",
         "antialiasing": "Kantenglättung",
         "showResultsOn": "Zeige Ergebnisse (An)",
@@ -762,7 +746,7 @@
         "autoAddBoard": "Automatisches Hinzufügen zum Ordner",
         "topMessage": "Dieser Ordner enthält Bilder die in den folgenden Funktionen verwendet werden:",
         "move": "Bewegen",
-        "menuItemAutoAdd": "Auto-Hinzufügen zu diesem Ordner",
+        "menuItemAutoAdd": "Automatisches Hinzufügen zu diesem Ordner",
         "myBoard": "Meine Ordner",
         "searchBoard": "Ordner durchsuchen...",
         "noMatching": "Keine passenden Ordner",
@@ -842,6 +826,7 @@
         "pidi": "PIDI",
         "normalBae": "Normales BAE",
         "mlsdDescription": "Minimalistischer Liniensegmentdetektor",
+        "openPoseDescription": "Schätzung der menschlichen Pose mit Openpose",
         "control": "Kontrolle",
         "coarse": "Grob",
         "crop": "Zuschneiden",
@@ -854,9 +839,10 @@
         "lineartAnimeDescription": "Lineart-Verarbeitung im Anime-Stil",
         "minConfidence": "Minimales Vertrauen",
         "megaControl": "Mega-Kontrolle",
-        "autoConfigure": "Prozessor Auto-konfig",
+        "autoConfigure": "Prozessor automatisch konfigurieren",
         "normalBaeDescription": "Normale BAE-Verarbeitung",
         "noneDescription": "Es wurde keine Verarbeitung angewendet",
+        "openPose": "Openpose / \"Pose nutzen\"",
         "lineartAnime": "Lineart Anime / \"Strichzeichnung Anime\"",
         "mediapipeFaceDescription": "Gesichtserkennung mit Mediapipe",
         "canny": "\"Canny\"",
@@ -958,7 +944,7 @@
         "initImage": "Erstes Bild",
         "variations": "Seed-Gewichtungs-Paare",
         "vae": "VAE",
-        "workflow": "Workflow",
+        "workflow": "Arbeitsablauf",
         "scheduler": "Planer",
         "noRecallParameters": "Es wurden keine Parameter zum Abrufen gefunden",
         "recallParameters": "Parameter wiederherstellen"
@@ -1070,20 +1056,6 @@
                 "\"Per Bild\" wird einen einzigartigen Seed-Wert für jedes Bild verwenden. Dies bietet mehr Variationen."
             ],
             "heading": "Seed-Verhalten"
-        },
-        "dynamicPrompts": {
-            "paragraphs": [
-                "\"Dynamische Prompts\" übersetzt einen Prompt in mehrere.",
-                "Die Ausgangs-Syntax ist \"ein {roter|grüner|blauer} ball\". Das generiert 3 Prompts: \"ein roter ball\", \"ein grüner ball\" und \"ein blauer ball\".",
-                "Sie können die Syntax so oft verwenden, wie Sie in einem einzigen Prompt möchten, aber stellen Sie sicher, dass die Anzahl der Prompts zur Einstellung von \"Max Prompts\" passt."
-            ],
-            "heading": "Dynamische Prompts"
-        },
-        "controlNetWeight": {
-            "paragraphs": [
-                "Wie stark wird das ControlNet das generierte Bild beeinflussen wird."
-            ],
-            "heading": "Einfluss"
         }
     },
     "ui": {
@@ -1188,10 +1160,10 @@
         "outputFieldInInput": "Ausgabefeld im Eingang",
         "problemReadingWorkflow": "Problem beim Lesen des Arbeitsablaufs vom Bild",
         "reloadNodeTemplates": "Knoten-Vorlagen neu laden",
-        "newWorkflow": "Neuer Arbeitsablauf / Workflow",
+        "newWorkflow": "Neuer Arbeitsablauf",
         "newWorkflowDesc": "Einen neuen Arbeitsablauf erstellen?",
         "noFieldsLinearview": "Keine Felder zur linearen Ansicht hinzugefügt",
-        "clearWorkflow": "Workflow löschen",
+        "clearWorkflow": "Arbeitsablauf löschen",
         "clearWorkflowDesc": "Diesen Arbeitsablauf löschen und neu starten?",
         "noConnectionInProgress": "Es besteht keine Verbindung",
         "notes": "Anmerkungen",
@@ -1248,8 +1220,8 @@
         "stringDescription": "Zeichenfolgen (Strings) sind Text.",
         "fieldTypesMustMatch": "Feldtypen müssen übereinstimmen",
         "fitViewportNodes": "An Ansichtsgröße anpassen",
-        "missingCanvaInitMaskImages": "Fehlende Startbilder und Masken auf der Leinwand",
-        "missingCanvaInitImage": "Fehlendes Startbild auf der Leinwand",
+        "missingCanvaInitMaskImages": "Fehlende Startbilder und Masken auf der Arbeitsfläche",
+        "missingCanvaInitImage": "Fehlendes Startbild auf der Arbeitsfläche",
         "ipAdapterModelDescription": "IP-Adapter-Modellfeld",
         "latentsPolymorphicDescription": "Zwischen Nodes können Latents weitergegeben werden.",
         "loadingNodes": "Lade Nodes...",
@@ -1349,7 +1321,7 @@
         "workflows": "Arbeitsabläufe",
         "noSystemWorkflows": "Keine System-Arbeitsabläufe",
         "workflowName": "Arbeitsablauf-Name",
-        "workflowIsOpen": "Arbeitsablauf ist geöffnet",
+        "workflowIsOpen": "Arbeitsablauf ist offen",
         "saveWorkflowAs": "Arbeitsablauf speichern als",
         "searchWorkflows": "Suche Arbeitsabläufe",
         "newWorkflowCreated": "Neuer Arbeitsablauf erstellt",

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

@@ -175,7 +175,6 @@
         "statusUpscaling": "Upscaling",
         "statusUpscalingESRGAN": "Upscaling (ESRGAN)",
         "template": "Template",
-        "toResolve": "To resolve",
         "training": "Training",
         "trainingDesc1": "A dedicated workflow for training your own embeddings and checkpoints using Textual Inversion and Dreambooth from the web interface.",
         "trainingDesc2": "InvokeAI already supports training custom embeddourings using Textual Inversion using the main script.",
@@ -236,9 +235,6 @@
         "fill": "Fill",
         "h": "H",
         "handAndFace": "Hand and Face",
-        "face": "Face",
-        "body": "Body",
-        "hands": "Hands",
         "hed": "HED",
         "hedDescription": "Holistically-Nested Edge Detection",
         "hideAdvanced": "Hide Advanced",
@@ -265,8 +261,8 @@
         "noneDescription": "No processing applied",
         "normalBae": "Normal BAE",
         "normalBaeDescription": "Normal BAE processing",
-        "dwOpenpose": "DW Openpose",
-        "dwOpenposeDescription": "Human pose estimation using DW Openpose",
+        "openPose": "Openpose",
+        "openPoseDescription": "Human pose estimation using Openpose",
         "pidi": "PIDI",
         "pidiDescription": "PIDI image processing",
         "processor": "Processor",
@@ -901,7 +897,6 @@
         "doesNotExist": "does not exist",
         "downloadWorkflow": "Download Workflow JSON",
         "edge": "Edge",
-        "editMode": "Edit in Workflow Editor",
         "enum": "Enum",
         "enumDescription": "Enums are values that may be one of a number of options.",
         "executionStateCompleted": "Completed",
@@ -997,10 +992,8 @@
         "problemReadingMetadata": "Problem reading metadata from image",
         "problemReadingWorkflow": "Problem reading workflow from image",
         "problemSettingTitle": "Problem Setting Title",
-        "resetToDefaultValue": "Reset to default value",
         "reloadNodeTemplates": "Reload Node Templates",
         "removeLinearView": "Remove from Linear View",
-        "reorderLinearView": "Reorder Linear View",
         "newWorkflow": "New Workflow",
         "newWorkflowDesc": "Create a new workflow?",
         "newWorkflowDesc2": "Your current workflow has unsaved changes.",
@@ -1071,7 +1064,6 @@
         "vaeModelFieldDescription": "TODO",
         "validateConnections": "Validate Connections and Graph",
         "validateConnectionsHelp": "Prevent invalid connections from being made, and invalid graphs from being invoked",
-        "viewMode": "Use in Linear View",
         "unableToGetWorkflowVersion": "Unable to get workflow schema version",
         "unrecognizedWorkflowVersion": "Unrecognized workflow schema version {{version}}",
         "version": "Version",

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

@@ -795,8 +795,7 @@
         "workflowDeleted": "Flusso di lavoro eliminato",
         "problemRetrievingWorkflow": "Problema nel recupero del flusso di lavoro",
         "resetInitialImage": "Reimposta l'immagine iniziale",
-        "uploadInitialImage": "Carica l'immagine iniziale",
-        "problemDownloadingImage": "Impossibile scaricare l'immagine"
+        "uploadInitialImage": "Carica l'immagine iniziale"
     },
     "tooltip": {
         "feature": {
@@ -1135,10 +1134,7 @@
         "newWorkflow": "Nuovo flusso di lavoro",
         "newWorkflowDesc": "Creare un nuovo flusso di lavoro?",
         "newWorkflowDesc2": "Il flusso di lavoro attuale presenta modifiche non salvate.",
-        "unsupportedAnyOfLength": "unione di troppi elementi ({{count}})",
-        "clearWorkflowDesc": "Cancellare questo flusso di lavoro e avviarne uno nuovo?",
-        "clearWorkflow": "Cancella il flusso di lavoro",
-        "clearWorkflowDesc2": "Il tuo flusso di lavoro attuale presenta modifiche non salvate."
+        "unsupportedAnyOfLength": "unione di troppi elementi ({{count}})"
     },
     "boards": {
         "autoAddBoard": "Aggiungi automaticamente bacheca",
@@ -1195,6 +1191,7 @@
         "f": "F",
         "h": "A",
         "prompt": "Prompt",
+        "openPoseDescription": "Stima della posa umana utilizzando Openpose",
         "resizeMode": "Ridimensionamento",
         "weight": "Peso",
         "selectModel": "Seleziona un modello",
@@ -1675,9 +1672,7 @@
         "downloadWorkflow": "Salva su file",
         "uploadWorkflow": "Carica da file",
         "projectWorkflows": "Flussi di lavoro del progetto",
-        "noWorkflows": "Nessun flusso di lavoro",
-        "workflowCleared": "Flusso di lavoro cancellato",
-        "saveWorkflowToProject": "Salva flusso di lavoro nel progetto"
+        "noWorkflows": "Nessun flusso di lavoro"
     },
     "app": {
         "storeNotInitialized": "Il negozio non è inizializzato"

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

@@ -555,6 +555,7 @@
         "balanced": "バランス",
         "prompt": "プロンプト",
         "depthMidasDescription": "Midasを使用して深度マップを生成",
+        "openPoseDescription": "Openposeを使用してポーズを推定",
         "control": "コントロール",
         "resizeMode": "リサイズモード",
         "weight": "重み",

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

@@ -333,6 +333,7 @@
         "h": "H",
         "prompt": "프롬프트",
         "depthMidasDescription": "Midas를 사용하여 Depth map 생성하기",
+        "openPoseDescription": "Openpose를 이용한 사람 포즈 추정",
         "control": "Control",
         "resizeMode": "크기 조정 모드",
         "t2iEnabledControlNetDisabled": "$t(common.t2iAdapter) 사용 가능,$t(common.controlNet) 사용 불가능",
@@ -369,6 +370,7 @@
         "normalBaeDescription": "Normal BAE 처리",
         "noneDescription": "처리되지 않음",
         "saveControlImage": "Control Image 저장",
+        "openPose": "Openpose",
         "toggleControlNet": "해당 ControlNet으로 전환",
         "delete": "삭제",
         "controlAdapter_other": "Control Adapter(s)",

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

@@ -1033,6 +1033,7 @@
         "prompt": "Prompt",
         "depthMidasDescription": "Genereer diepteblad via Midas",
         "controlnet": "$t(controlnet.controlAdapter_one) #{{number}} ($t(common.controlNet))",
+        "openPoseDescription": "Menselijke pose-benadering via Openpose",
         "control": "Controle",
         "resizeMode": "Modus schaling",
         "t2iEnabledControlNetDisabled": "$t(common.t2iAdapter) ingeschakeld, $t(common.controlNet)s uitgeschakeld",
@@ -1071,6 +1072,7 @@
         "normalBaeDescription": "Normale BAE-verwerking",
         "noneDescription": "Geen verwerking toegepast",
         "saveControlImage": "Bewaar controle-afbeelding",
+        "openPose": "Openpose",
         "toggleControlNet": "Zet deze ControlNet aan/uit",
         "delete": "Verwijder",
         "controlAdapter_one": "Control-adapter",

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

@@ -1155,6 +1155,7 @@
         "resetControlImage": "Сбросить контрольное изображение",
         "prompt": "Запрос",
         "controlnet": "$t(controlnet.controlAdapter_one) №{{number}} $t(common.controlNet)",
+        "openPoseDescription": "Оценка позы человека с помощью Openpose",
         "resizeMode": "Режим изменения размера",
         "t2iEnabledControlNetDisabled": "$t(common.t2iAdapter) включен, $t(common.controlNet)s отключен",
         "weight": "Вес",

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

@@ -259,6 +259,7 @@
         "mediapipeFace": "Mediapipe Yüz",
         "megaControl": "Aşırı Yönetim",
         "mlsd": "M-LSD",
+        "openPoseDescription": "Openpose kullanarak poz belirleme",
         "setControlImageDimensions": "Yönetim Görseli Boyutlarını En/Boydan Al",
         "pidi": "PIDI",
         "scribble": "çiziktirme",
@@ -272,6 +273,7 @@
         "mlsdDescription": "Minimalist Line Segment Detector (Kolay Çizgi Parçası Algılama)",
         "normalBae": "Normal BAE",
         "normalBaeDescription": "Normal BAE işleme",
+        "openPose": "Openpose",
         "resetControlImage": "Yönetim Görselini Kaldır",
         "enableIPAdapter": "IP Aracını Etkinleştir",
         "lineart": "Çizim",

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

@@ -1143,6 +1143,7 @@
         "balanced": "平衡",
         "prompt": "Prompt (提示词控制)",
         "depthMidasDescription": "使用 Midas 生成深度图",
+        "openPoseDescription": "使用 Openpose 进行人体姿态估计",
         "resizeMode": "缩放模式",
         "weight": "权重",
         "selectModel": "选择一个模型",
@@ -1206,6 +1207,7 @@
         "megaControl": "Mega Control (超级控制)",
         "depthZoe": "Depth (Zoe)",
         "colorMap": "Color",
+        "openPose": "Openpose",
         "controlAdapter_other": "Control Adapters",
         "lineartAnime": "Lineart Anime",
         "canny": "Canny",

invokeai/frontend/web/src/app/store/middleware/devtools/actionSanitizer.ts

@@ -1,8 +1,8 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
 import { isAnyGraphBuilt } from 'features/nodes/store/actions';
-import { nodeTemplatesBuilt } from 'features/nodes/store/nodesSlice';
+import { nodeTemplatesBuilt } from 'features/nodes/store/nodeTemplatesSlice';
 import { cloneDeep } from 'lodash-es';
-import { appInfoApi } from 'services/api/endpoints/appInfo';
+import { receivedOpenAPISchema } from 'services/api/thunks/schema';
 import type { Graph } from 'services/api/types';
 import { socketGeneratorProgress } from 'services/events/actions';
 
@@ -18,7 +18,7 @@ export const actionSanitizer = <A extends UnknownAction>(action: A): A => {
     }
   }
 
-  if (appInfoApi.endpoints.getOpenAPISchema.matchFulfilled(action)) {
+  if (receivedOpenAPISchema.fulfilled.match(action)) {
     return {
       ...action,
       payload: '<OpenAPI schema omitted>',

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/index.ts

@@ -23,7 +23,6 @@ import { addControlNetImageProcessedListener } from './listeners/controlNetImage
 import { addEnqueueRequestedCanvasListener } from './listeners/enqueueRequestedCanvas';
 import { addEnqueueRequestedLinear } from './listeners/enqueueRequestedLinear';
 import { addEnqueueRequestedNodes } from './listeners/enqueueRequestedNodes';
-import { addGetOpenAPISchemaListener } from './listeners/getOpenAPISchema';
 import {
   addImageAddedToBoardFulfilledListener,
   addImageAddedToBoardRejectedListener,
@@ -48,6 +47,7 @@ import { addInitialImageSelectedListener } from './listeners/initialImageSelecte
 import { addModelSelectedListener } from './listeners/modelSelected';
 import { addModelsLoadedListener } from './listeners/modelsLoaded';
 import { addDynamicPromptsListener } from './listeners/promptChanged';
+import { addReceivedOpenAPISchemaListener } from './listeners/receivedOpenAPISchema';
 import { addSocketConnectedEventListener as addSocketConnectedListener } from './listeners/socketio/socketConnected';
 import { addSocketDisconnectedEventListener as addSocketDisconnectedListener } from './listeners/socketio/socketDisconnected';
 import { addGeneratorProgressEventListener as addGeneratorProgressListener } from './listeners/socketio/socketGeneratorProgress';
@@ -150,7 +150,7 @@ addImageRemovedFromBoardRejectedListener();
 addBoardIdSelectedListener();
 
 // Node schemas
-addGetOpenAPISchemaListener();
+addReceivedOpenAPISchemaListener();
 
 // Workflows
 addWorkflowLoadRequestedListener();

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/enqueueRequestedLinear.ts

@@ -19,7 +19,7 @@ export const addEnqueueRequestedLinear = () => {
 
       let graph;
 
-      if (model && model.base === 'sdxl') {
+      if (model && model.base_model === 'sdxl') {
         if (action.payload.tabName === 'txt2img') {
           graph = buildLinearSDXLTextToImageGraph(state);
         } else {

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/modelSelected.ts

@@ -30,8 +30,8 @@ export const addModelSelectedListener = () => {
 
       const newModel = result.data;
 
-      const newBaseModel = newModel.base;
-      const didBaseModelChange = state.generation.model?.base !== newBaseModel;
+      const newBaseModel = newModel.base_model;
+      const didBaseModelChange = state.generation.model?.base_model !== newBaseModel;
 
       if (didBaseModelChange) {
         // we may need to reset some incompatible submodels
@@ -39,7 +39,7 @@ export const addModelSelectedListener = () => {
 
         // handle incompatible loras
         forEach(state.lora.loras, (lora, id) => {
-          if (lora.base !== newBaseModel) {
+          if (lora.base_model !== newBaseModel) {
             dispatch(loraRemoved(id));
             modelsCleared += 1;
           }
@@ -47,14 +47,14 @@ export const addModelSelectedListener = () => {
 
         // handle incompatible vae
         const { vae } = state.generation;
-        if (vae && vae.base !== newBaseModel) {
+        if (vae && vae.base_model !== newBaseModel) {
           dispatch(vaeSelected(null));
           modelsCleared += 1;
         }
 
         // handle incompatible controlnets
         selectControlAdapterAll(state.controlAdapters).forEach((ca) => {
-          if (ca.model?.base !== newBaseModel) {
+          if (ca.model?.base_model !== newBaseModel) {
             dispatch(controlAdapterIsEnabledChanged({ id: ca.id, isEnabled: false }));
             modelsCleared += 1;
           }