Allow optional base model lists to be passed in argparse

- `fastapi-events`: 0.10.1 -> 1.11.0
- `fastapi`: 0.109.2 -> 0.110.0
- `pydantic-settings`: 2.1.0 -> 2.2.1
- `pydantic`: 2.6.1 -> 2.6.3
- `uvicorn`: 0.27.1 -> 0.28.0

Makefile

@@ -6,16 +6,18 @@ default: help
 help:
 	@echo Developer commands:
 	@echo
-	@echo "ruff              Run ruff, fixing any safely-fixable errors and formatting"
-	@echo "ruff-unsafe       Run ruff, fixing all fixable errors and formatting"
-	@echo "mypy              Run mypy using the config in pyproject.toml to identify type mismatches and other coding errors"
-	@echo "mypy-all          Run mypy ignoring the config in pyproject.tom but still ignoring missing imports"
-	@echo "test"             Run the unit tests.
-	@echo "frontend-install" Install the pnpm modules needed for the front end
-	@echo "frontend-build    Build the frontend in order to run on localhost:9090"
-	@echo "frontend-dev      Run the frontend in developer mode on localhost:5173"
-	@echo "installer-zip     Build the installer .zip file for the current version"
-	@echo "tag-release       Tag the GitHub repository with the current version (use at release time only!)"
+	@echo "ruff                     Run ruff, fixing any safely-fixable errors and formatting"
+	@echo "ruff-unsafe              Run ruff, fixing all fixable errors and formatting"
+	@echo "mypy                     Run mypy using the config in pyproject.toml to identify type mismatches and other coding errors"
+	@echo "mypy-all                 Run mypy ignoring the config in pyproject.tom but still ignoring missing imports"
+	@echo "test                     Run the unit tests."
+	@echo "update-config-docstring  Update the app's config docstring so mkdocs can autogenerate it correctly."
+	@echo "frontend-install         Install the pnpm modules needed for the front end"
+	@echo "frontend-build           Build the frontend in order to run on localhost:9090"
+	@echo "frontend-dev             Run the frontend in developer mode on localhost:5173"
+	@echo "frontend-typegen         Generate types for the frontend from the OpenAPI schema"
+	@echo "installer-zip            Build the installer .zip file for the current version"
+	@echo "tag-release              Tag the GitHub repository with the current version (use at release time only!)"
 
 # Runs ruff, fixing any safely-fixable errors and formatting
 ruff:
@@ -40,6 +42,10 @@ mypy-all:
 test:
 	pytest ./tests
 
+# Update config docstring
+update-config-docstring:
+	python scripts/update_config_docstring.py
+
 # Install the pnpm modules needed for the front end
 frontend-install:
 	rm -rf invokeai/frontend/web/node_modules
@@ -53,6 +59,9 @@ frontend-build:
 frontend-dev:
 	cd invokeai/frontend/web && pnpm dev
 
+frontend-typegen:
+	cd invokeai/frontend/web && python ../../../scripts/generate_openapi_schema.py | pnpm typegen
+
 # Installer zip file
 installer-zip:
 	cd installer && ./create_installer.sh

docs/contributing/MODEL_MANAGER.md

@@ -16,11 +16,6 @@ model. These are the:
   information. It is also responsible for managing the InvokeAI
   `models` directory and its contents.
   
-* _ModelMetadataStore_ and _ModelMetaDataFetch_ Backend modules that
-  are able to retrieve metadata from online model repositories,
-  transform them into Pydantic models, and cache them to the InvokeAI
-  SQL database.
-  
 * _DownloadQueueServiceBase_
   A multithreaded downloader responsible
   for downloading models from a remote source to disk. The download
@@ -32,7 +27,6 @@ model. These are the:
   Responsible for loading a model from disk
   into RAM and VRAM and getting it ready for inference.
 
-  
 ## Location of the Code
 
 The four main services can be found in
@@ -63,23 +57,21 @@ provides the following fields:
 |----------------|-----------------|------------------|
 | `key`            | str           | Unique identifier for the model |
 | `name`           | str           | Name of the model (not unique) |
-| `model_type`     | ModelType     | The type of the model | 
-| `model_format`   | ModelFormat   | The format of the model (e.g. "diffusers"); also used as a Union discriminator | 
-| `base_model`     | BaseModelType | The base model that the model is compatible with | 
+| `model_type`     | ModelType     | The type of the model |
+| `model_format`   | ModelFormat   | The format of the model (e.g. "diffusers"); also used as a Union discriminator |
+| `base_model`     | BaseModelType | The base model that the model is compatible with |
 | `path`           | str           | Location of model on disk |
-| `original_hash`  | str           | Hash of the model when it was first installed |
-| `current_hash`   | str           | Most recent hash of the model's contents |
+| `hash`           | str           | Hash of the model |
 | `description`    | str           | Human-readable description of the model (optional) |
 | `source`         | str           | Model's source URL or repo id (optional) |
 
 The `key` is a unique 32-character random ID which was generated at
-install time. The `original_hash` field stores a hash of the model's
+install time. The `hash` field stores a hash of the model's
 contents at install time obtained by sampling several parts of the
 model's files using the `imohash` library. Over the course of the
 model's lifetime it may be transformed in various ways, such as
 changing its precision or converting it from a .safetensors to a
-diffusers model. When this happens, `original_hash` is unchanged, but
-`current_hash` is updated to indicate the current contents.
+diffusers model.
 
 `ModelType`, `ModelFormat` and `BaseModelType` are string enums that
 are defined in `invokeai.backend.model_manager.config`. They are also
@@ -94,7 +86,6 @@ The `path` field can be absolute or relative. If relative, it is taken
 to be relative to the `models_dir` setting in the user's
 `invokeai.yaml` file.
 
-
 ### CheckpointConfig
 
 This adds support for checkpoint configurations, and adds the
@@ -174,7 +165,7 @@ store = context.services.model_manager.store
 or from elsewhere in the code by accessing
 `ApiDependencies.invoker.services.model_manager.store`.
 
-### Creating a `ModelRecordService` 
+### Creating a `ModelRecordService`
 
 To create a new `ModelRecordService` database or open an existing one,
 you can directly create either a `ModelRecordServiceSQL` or a
@@ -217,27 +208,27 @@ for use in the InvokeAI web server. Its signature is:
 ```
 def open(
        cls, 
-	   config: InvokeAIAppConfig, 
-	   conn: Optional[sqlite3.Connection] = None, 
-	   lock: Optional[threading.Lock] = None
+    config: InvokeAIAppConfig, 
+    conn: Optional[sqlite3.Connection] = None, 
+    lock: Optional[threading.Lock] = None
     ) -> Union[ModelRecordServiceSQL, ModelRecordServiceFile]:
 ```
 
 The way it works is as follows:
 
 1. Retrieve the value of the `model_config_db` option from the user's
-	`invokeai.yaml` config file.
+ `invokeai.yaml` config file.
 2. If `model_config_db` is `auto` (the default), then:
-   - Use the values of `conn` and `lock` to return a `ModelRecordServiceSQL` object
-	 opened on the passed connection and lock.
-   - Open up a new connection to `databases/invokeai.db` if `conn`
+   * Use the values of `conn` and `lock` to return a `ModelRecordServiceSQL` object
+  opened on the passed connection and lock.
+   * Open up a new connection to `databases/invokeai.db` if `conn`
      and/or `lock` are missing (see note below).
 3. If `model_config_db` is a Path, then use `from_db_file`
    to return the appropriate type of ModelRecordService.
 4. If `model_config_db` is None, then retrieve the legacy
    `conf_path` option from `invokeai.yaml` and use the Path
    indicated there. This will default to `configs/models.yaml`.
-   
+
 So a typical startup pattern would be:
 
 ```
@@ -255,7 +246,7 @@ store = ModelRecordServiceBase.open(config, db_conn, lock)
 
 Configurations can be retrieved in several ways.
 
-#### get_model(key) -> AnyModelConfig:
+#### get_model(key) -> AnyModelConfig
 
 The basic functionality is to call the record store object's
 `get_model()` method with the desired model's unique key. It returns
@@ -272,28 +263,28 @@ print(model_conf.path)
 If the key is unrecognized, this call raises an
 `UnknownModelException`.
 
-#### exists(key) -> AnyModelConfig:
+#### exists(key) -> AnyModelConfig
 
 Returns True if a model with the given key exists in the databsae.
 
-#### search_by_path(path) -> AnyModelConfig:
+#### search_by_path(path) -> AnyModelConfig
 
 Returns the configuration of the model whose path is `path`. The path
 is matched using a simple string comparison and won't correctly match
 models referred to by different paths (e.g. using symbolic links).
 
-#### search_by_name(name, base, type) -> List[AnyModelConfig]:
+#### search_by_name(name, base, type) -> List[AnyModelConfig]
 
 This method searches for models that match some combination of `name`,
 `BaseType` and `ModelType`. Calling without any arguments will return
 all the models in the database.
 
-#### all_models() -> List[AnyModelConfig]:
+#### all_models() -> List[AnyModelConfig]
 
 Return all the model configs in the database. Exactly equivalent to
 calling `search_by_name()` with no arguments.
 
-#### search_by_tag(tags) -> List[AnyModelConfig]:
+#### search_by_tag(tags) -> List[AnyModelConfig]
 
 `tags` is a list of strings. This method returns a list of model
 configs that contain all of the given tags. Examples:
@@ -312,11 +303,11 @@ commercializable_models = [x for x in store.all_models() \
                            if x.license.contains('allowCommercialUse=Sell')]
 ```
 
-#### version() -> str:
+#### version() -> str
 
 Returns the version of the database, currently at `3.2`
 
-#### model_info_by_name(name, base_model, model_type) -> ModelConfigBase:
+#### model_info_by_name(name, base_model, model_type) -> ModelConfigBase
 
 This method exists to ease the transition from the previous version of
 the model manager, in which `get_model()` took the three arguments
@@ -337,7 +328,7 @@ model and pass its key to `get_model()`.
 Several methods allow you to create and update stored model config
 records.
 
-#### add_model(key, config) -> AnyModelConfig:
+#### add_model(key, config) -> AnyModelConfig
 
 Given a key and a configuration, this will add the model's
 configuration record to the database. `config` can either be a subclass of
@@ -352,7 +343,7 @@ model with the same key is already in the database, or an
 `InvalidModelConfigException` if a dict was passed and Pydantic
 experienced a parse or validation error.
 
-### update_model(key, config) -> AnyModelConfig:
+### update_model(key, config) -> AnyModelConfig
 
 Given a key and a configuration, this will update the model
 configuration record in the database. `config` can be either a
@@ -370,33 +361,30 @@ The `ModelInstallService` class implements the
 shop for all your model install needs. It provides the following
 functionality:
 
-- Registering a model config record for a model already located on the
+* Registering a model config record for a model already located on the
   local filesystem, without moving it or changing its path.
   
-- Installing a model alreadiy located on the local filesystem, by
+* Installing a model alreadiy located on the local filesystem, by
   moving it into the InvokeAI root directory under the
   `models` folder (or wherever config parameter `models_dir`
   specifies).
-	
-- Probing of models to determine their type, base type and other key
+
+* Probing of models to determine their type, base type and other key
   information.
   
-- Interface with the InvokeAI event bus to provide status updates on
+* Interface with the InvokeAI event bus to provide status updates on
   the download, installation and registration process.
   
-- Downloading a model from an arbitrary URL and installing it in
+* Downloading a model from an arbitrary URL and installing it in
   `models_dir`.
-  
-- Special handling for Civitai model URLs which allow the user to
-  paste in a model page's URL or download link
-  
-- Special handling for HuggingFace repo_ids to recursively download
+
+* Special handling for HuggingFace repo_ids to recursively download
   the contents of the repository, paying attention to alternative
   variants such as fp16.
   
-- Saving tags and other metadata about the model into the invokeai database
+* Saving tags and other metadata about the model into the invokeai database
   when fetching from a repo that provides that type of information,
-  (currently only Civitai and HuggingFace).
+  (currently only HuggingFace).
   
 ### Initializing the installer
 
@@ -427,8 +415,8 @@ queue.start()
 
 installer = ModelInstallService(app_config=config, 
                                 record_store=record_store,
-						        download_queue=queue
-							    )
+              download_queue=queue
+           )
 installer.start()
 ```
 
@@ -440,10 +428,8 @@ required parameters:
 | `app_config`         | InvokeAIAppConfig       | InvokeAI app configuration object |
 | `record_store`   | ModelRecordServiceBase  | Config record storage database |
 | `download_queue`   | DownloadQueueServiceBase  | Download queue object |
-| `metadata_store`   | Optional[ModelMetadataStore]  | Metadata storage object |
 |`session`           | Optional[requests.Session]    | Swap in a different Session object (usually for debugging) |
 
-
 Once initialized, the installer will provide the following methods:
 
 #### install_job = installer.heuristic_import(source, [config], [access_token])
@@ -457,15 +443,15 @@ The `source` is a string that can be any of these forms
 1. A path on the local filesystem (`C:\\users\\fred\\model.safetensors`)
 2. A Url pointing to a single downloadable model file (`https://civitai.com/models/58390/detail-tweaker-lora-lora`)
 3. A HuggingFace repo_id with any of the following formats:
-   - `model/name` -- entire model
-   - `model/name:fp32` -- entire model, using the fp32 variant
-   - `model/name:fp16:vae` -- vae submodel, using the fp16 variant
-   - `model/name::vae` -- vae submodel, using default precision
-   - `model/name:fp16:path/to/model.safetensors` -- an individual model file, fp16 variant
-   - `model/name::path/to/model.safetensors` -- an individual model file, default variant
+   * `model/name` -- entire model
+   * `model/name:fp32` -- entire model, using the fp32 variant
+   * `model/name:fp16:vae` -- vae submodel, using the fp16 variant
+   * `model/name::vae` -- vae submodel, using default precision
+   * `model/name:fp16:path/to/model.safetensors` -- an individual model file, fp16 variant
+   * `model/name::path/to/model.safetensors` -- an individual model file, default variant
 
 Note that by specifying a relative path to the top of the HuggingFace
-repo, you can download and install arbitrary models files. 
+repo, you can download and install arbitrary models files.
 
 The variant, if not provided, will be automatically filled in with
 `fp32` if the user has requested full precision, and `fp16`
@@ -491,9 +477,9 @@ following illustrates basic usage:
 
 ```
 from invokeai.app.services.model_install import (
-	LocalModelSource,
-	HFModelSource,
-	URLModelSource,
+ LocalModelSource,
+ HFModelSource,
+ URLModelSource,
 )
 
 source1 = LocalModelSource(path='/opt/models/sushi.safetensors')   # a local safetensors file
@@ -513,13 +499,13 @@ for source in [source1, source2, source3, source4, source5, source6, source7]:
 source2job = installer.wait_for_installs(timeout=120)
 for source in sources:
     job = source2job[source]
-	if job.complete:
-		model_config = job.config_out
-		model_key = model_config.key
-		print(f"{source} installed as {model_key}")
-	elif job.errored:
-	    print(f"{source}: {job.error_type}.\nStack trace:\n{job.error}")
-	
+ if job.complete:
+  model_config = job.config_out
+  model_key = model_config.key
+  print(f"{source} installed as {model_key}")
+ elif job.errored:
+     print(f"{source}: {job.error_type}.\nStack trace:\n{job.error}")
+ 
 ```
 
 As shown here, the `import_model()` method accepts a variety of
@@ -528,7 +514,7 @@ HuggingFace repo_ids with and without a subfolder designation,
 Civitai model URLs and arbitrary URLs that point to checkpoint files
 (but not to folders).
 
-Each call to `import_model()` return a `ModelInstallJob` job, 
+Each call to `import_model()` return a `ModelInstallJob` job,
 an object which tracks the progress of the install.
 
 If a remote model is requested, the model's files are downloaded in
@@ -555,7 +541,7 @@ The full list of arguments to `import_model()` is as follows:
 | `config`         | Dict[str, Any]               | None        | Override all or a portion of model's probed attributes |
 
 The next few sections describe the various types of ModelSource that
-can be passed to `import_model()`. 
+can be passed to `import_model()`.
 
 `config` can be used to override all or a portion of the configuration
 attributes returned by the model prober. See the section below for
@@ -566,7 +552,6 @@ details.
 This is used for a model that is located on a locally-accessible Posix
 filesystem, such as a local disk or networked fileshare.
 
-
 | **Argument**     | **Type**                     | **Default** | **Description**                           |
 |------------------|------------------------------|-------------|-------------------------------------------|
 | `path`           | str | Path                   | None        | Path to the model file or directory |
@@ -586,33 +571,7 @@ The `AnyHttpUrl` class can be imported from `pydantic.networks`.
 
 Ordinarily, no metadata is retrieved from these sources. However,
 there is special-case code in the installer that looks for HuggingFace
-and Civitai URLs and fetches the corresponding model metadata from
-the corresponding repo.
-
-#### CivitaiModelSource
-
-This is used for a model that is hosted by the Civitai web site.
-
-| **Argument**     | **Type**                     | **Default** | **Description**                           |
-|------------------|------------------------------|-------------|-------------------------------------------|
-| `version_id`     | int                          | None        | The ID of the particular version of the desired model. |
-| `access_token`   | str                          | None        | An access token needed to gain access to a subscriber's-only model. |
-
-Civitai has two model IDs, both of which are integers. The `model_id`
-corresponds to a collection of model versions that may different in
-arbitrary ways, such as derivation from different checkpoint training
-steps, SFW vs NSFW generation, pruned vs non-pruned, etc. The
-`version_id` points to a specific version. Please use the latter.
-
-Some Civitai models require an access token to download. These can be
-generated from the Civitai profile page of a logged-in
-account. Somewhat annoyingly, if you fail to provide the access token
-when downloading a model that needs it, Civitai generates a redirect
-to a login page rather than a 403 Forbidden error. The installer
-attempts to catch this event and issue an informative error
-message. Otherwise you will get an "unrecognized model suffix" error
-when the model prober tries to identify the type of the HTML login
-page.
+and fetches the corresponding model metadata from the corresponding repo.
 
 #### HFModelSource
 
@@ -625,7 +584,6 @@ HuggingFace has the most complicated `ModelSource` structure:
 | `subfolder`      | Path                         | None        | Look for the model in a subfolder of the repo. |
 | `access_token`   | str                          | None        | An access token needed to gain access to a subscriber's-only model. |
 
-
 The `repo_id` is the repository ID, such as `stabilityai/sdxl-turbo`.
 
 The `variant` is one of the various diffusers formats that HuggingFace
@@ -661,7 +619,6 @@ in. To download these files, you must provide an
 `HfFolder.get_token()` will be called to fill it in with the cached
 one.
 
-
 #### Monitoring the install job process
 
 When you create an install job with `import_model()`, it launches the
@@ -675,14 +632,13 @@ The `ModelInstallJob` class has the following structure:
 | `id`           | `int`           | Integer ID for this job |
 | `status`       | `InstallStatus`  | An enum of [`waiting`, `downloading`, `running`, `completed`, `error` and `cancelled`]|
 | `config_in`    | `dict`          | Overriding configuration values provided by the caller |
-| `config_out`   | `AnyModelConfig`| After successful completion, contains the configuration record written to the database | 
-| `inplace`      | `boolean`       | True if the caller asked to install the model in place using its local path | 
-| `source`       | `ModelSource`   | The local path, remote URL or repo_id of the model to be installed | 
+| `config_out`   | `AnyModelConfig`| After successful completion, contains the configuration record written to the database |
+| `inplace`      | `boolean`       | True if the caller asked to install the model in place using its local path |
+| `source`       | `ModelSource`   | The local path, remote URL or repo_id of the model to be installed |
 | `local_path`   | `Path`          | If a remote model, holds the path of the model after it is downloaded; if a local model, same as `source` |
 | `error_type`   | `str`           | Name of the exception that led to an error status |
 | `error`        | `str`           | Traceback of the error |
 
-
 If the `event_bus` argument was provided, events will also be
 broadcast to the InvokeAI event bus. The events will appear on the bus
 as an event of type `EventServiceBase.model_event`, a timestamp and
@@ -702,14 +658,13 @@ following keys:
 | `total_bytes`  | int       | Total size of all the files that make up the model |
 | `parts`        | List[Dict]| Information on the progress of the individual files that make up the model |
 
-
 The parts is a list of dictionaries that give information on each of
 the components pieces of the download. The dictionary's keys are
 `source`, `local_path`, `bytes` and `total_bytes`, and correspond to
 the like-named keys in the main event.
 
 Note that downloading events will not be issued for local models, and
-that downloading events occur *before* the running event.
+that downloading events occur _before_ the running event.
 
 ##### `model_install_running`
 
@@ -752,14 +707,13 @@ properties: `waiting`, `downloading`, `running`, `complete`, `errored`
 and `cancelled`, as well as `in_terminal_state`. The last will return
 True if the job is in the complete, errored or cancelled states.
 
-
 #### Model configuration and probing
 
 The install service uses the `invokeai.backend.model_manager.probe`
 module during import to determine the model's type, base type, and
 other configuration parameters. Among other things, it assigns a
 default name and description for the model based on probed
-fields. 
+fields.
 
 When downloading remote models is implemented, additional
 configuration information, such as list of trigger terms, will be
@@ -774,11 +728,11 @@ attributes. Here is an example of setting the
 ```
 install_job = installer.import_model(
                source=HFModelSource(repo_id='stabilityai/stable-diffusion-2-1',variant='fp32'),
-			   config=dict(
-			         prediction_type=SchedulerPredictionType('v_prediction')
-					 name='stable diffusion 2 base model',
-	           )
-	      )
+      config=dict(
+            prediction_type=SchedulerPredictionType('v_prediction')
+      name='stable diffusion 2 base model',
+            )
+       )
 ```
 
 ### Other installer methods
@@ -862,7 +816,6 @@ This method is similar to `unregister()`, but also unconditionally
 deletes the corresponding model weights file(s), regardless of whether
 they are inside or outside the InvokeAI models hierarchy.
 
-
 #### path = installer.download_and_cache(remote_source, [access_token], [timeout])
 
 This utility routine will download the model file located at source,
@@ -953,7 +906,7 @@ following fields:
 
 When you create a job, you can assign it a `priority`. If multiple
 jobs are queued, the job with the lowest priority runs first. (Don't
-blame me! The Unix developers came up with this convention.) 
+blame me! The Unix developers came up with this convention.)
 
 Every job has a `source` and a `destination`. `source` is a string in
 the base class, but subclassses redefine it more specifically.
@@ -974,7 +927,7 @@ is in its lifecycle. Values are defined in the string enum
 `DownloadJobStatus`, a symbol available from
 `invokeai.app.services.download_manager`. Possible values are:
 
-| **Value**    |   **String Value**  | ** Description ** |
+| **Value**    |   **String Value**  | **Description** |
 |--------------|---------------------|-------------------|
 | `IDLE`         | idle              | Job created, but not submitted to the queue |
 | `ENQUEUED`     | enqueued          | Job is patiently waiting on the queue       |
@@ -991,7 +944,7 @@ debugging and performance testing.
 
 In case of an error, the Exception that caused the error will be
 placed in the `error` field, and the job's status will be set to
-`DownloadJobStatus.ERROR`. 
+`DownloadJobStatus.ERROR`.
 
 After an error occurs, any partially downloaded files will be deleted
 from disk, unless `preserve_partial_downloads` was set to True at job
@@ -1040,11 +993,11 @@ While a job is being downloaded, the queue will emit events at
 periodic intervals. A typical series of events during a successful
 download session will look like this:
 
-- enqueued
-- running
-- running
-- running
-- completed
+* enqueued
+* running
+* running
+* running
+* completed
 
 There will be a single enqueued event, followed by one or more running
 events, and finally one `completed`, `error` or `cancelled`
@@ -1053,12 +1006,12 @@ events.
 It is possible for a caller to pause download temporarily, in which
 case the events may look something like this:
 
-- enqueued
-- running
-- running
-- paused
-- running
-- completed
+* enqueued
+* running
+* running
+* paused
+* running
+* completed
 
 The download queue logs when downloads start and end (unless `quiet`
 is set to True at initialization time) but doesn't log any progress
@@ -1120,11 +1073,11 @@ A typical initialization sequence will look like:
 from invokeai.app.services.download_manager import DownloadQueueService
 
 def log_download_event(job: DownloadJobBase):
-	logger.info(f'job={job.id}: status={job.status}')
+ logger.info(f'job={job.id}: status={job.status}')
 
 queue = DownloadQueueService(
-					  event_handlers=[log_download_event]
-						  )
+       event_handlers=[log_download_event]
+        )
 ```
 
 Event handlers can be provided to the queue at initialization time as
@@ -1155,9 +1108,9 @@ To use the former method, follow this example:
 ```
 job = DownloadJobRemoteSource(
          source='http://www.civitai.com/models/13456',
-		 destination='/tmp/models/',
-		 event_handlers=[my_handler1, my_handler2], # if desired
-		 )
+   destination='/tmp/models/',
+   event_handlers=[my_handler1, my_handler2], # if desired
+   )
 queue.submit_download_job(job, start=True)
 ```
 
@@ -1172,13 +1125,13 @@ To have the queue create the job for you, follow this example instead:
 ```
 job = queue.create_download_job(
          source='http://www.civitai.com/models/13456',
-		 destdir='/tmp/models/',
-		 filename='my_model.safetensors',
-		 event_handlers=[my_handler1, my_handler2], # if desired
-		 start=True,
-	)
+   destdir='/tmp/models/',
+   filename='my_model.safetensors',
+   event_handlers=[my_handler1, my_handler2], # if desired
+   start=True,
+ )
 ```
- 
+
 The `filename` argument forces the downloader to use the specified
 name for the file rather than the name provided by the remote source,
 and is equivalent to manually specifying a destination of
@@ -1187,7 +1140,6 @@ and is equivalent to manually specifying a destination of
 Here is the full list of arguments that can be provided to
 `create_download_job()`:
 
-
 | **Argument**     | **Type**                     | **Default** | **Description**                           |
 |------------------|------------------------------|-------------|-------------------------------------------|
 | `source`         | Union[str, Path, AnyHttpUrl] |             | Download remote or local source           |
@@ -1200,7 +1152,7 @@ Here is the full list of arguments that can be provided to
 
 Internally, `create_download_job()` has a little bit of internal logic
 that looks at the type of the source and selects the right subclass of
-`DownloadJobBase` to create and enqueue. 
+`DownloadJobBase` to create and enqueue.
 
 **TODO**: move this logic into its own method for overriding in
 subclasses.
@@ -1266,51 +1218,30 @@ queue and have not yet reached a terminal state.
 
 The modules found under `invokeai.backend.model_manager.metadata`
 provide a straightforward API for fetching model metadatda from online
-repositories. Currently two repositories are supported: HuggingFace
-and Civitai. However, the modules are easily extended for additional
-repos, provided that they have defined APIs for metadata access.
+repositories. Currently only HuggingFace is supported. However, the
+modules are easily extended for additional repos, provided that they
+have defined APIs for metadata access.
 
 Metadata comprises any descriptive information that is not essential
 for getting the model to run. For example "author" is metadata, while
 "type", "base" and "format" are not. The latter fields are part of the
 model's config, as defined in `invokeai.backend.model_manager.config`.
 
-### Example Usage:
+### Example Usage
 
 ```
 from invokeai.backend.model_manager.metadata import (
    AnyModelRepoMetadata,
-   CivitaiMetadataFetch,
-   CivitaiMetadata
-   ModelMetadataStore,
 )
 # to access the initialized sql database
 from invokeai.app.api.dependencies import ApiDependencies
 
-civitai = CivitaiMetadataFetch()
+hf = HuggingFaceMetadataFetch()
 
 # fetch the metadata
-model_metadata = civitai.from_url("https://civitai.com/models/215796")
+model_metadata = hf.from_id("<repo_id>")
 
-# get some common metadata fields
-author = model_metadata.author
-tags = model_metadata.tags
-
-# get some Civitai-specific fields
-assert isinstance(model_metadata, CivitaiMetadata)
-
-trained_words = model_metadata.trained_words
-base_model = model_metadata.base_model_trained_on
-thumbnail = model_metadata.thumbnail_url
-
-# cache the metadata to the database using the key corresponding to
-# an existing model config record in the `model_config` table
-sql_cache = ModelMetadataStore(ApiDependencies.invoker.services.db)
-sql_cache.add_metadata('fb237ace520b6716adc98bcb16e8462c', model_metadata)
-
-# now we can search the database by tag, author or model name
-# matches will contain a list of model keys that match the search
-matches = sql_cache.search_by_tag({"tool", "turbo"})
+assert isinstance(model_metadata, HuggingFaceMetadata)
 ```
 
 ### Structure of the Metadata objects
@@ -1328,7 +1259,6 @@ This is the common base class for metadata:
 | `author`      | str           | Model's author |
 | `tags`        | Set[str]      | Model tags |
 
-
 Note that the model config record also has a `name` field. It is
 intended that the config record version be locally customizable, while
 the metadata version is read-only. However, enforcing this is expected
@@ -1348,53 +1278,14 @@ This descends from `ModelMetadataBase` and adds the following fields:
 | `last_modified`| datetime         | Date of last commit of this model to the repo |
 | `files`        | List[Path]       | List of the files in the model repo |
 
-
-#### `CivitaiMetadata`
-
-This descends from `ModelMetadataBase` and adds the following fields:
-
-| **Field Name** | **Type**        |  **Description** |
-|----------------|-----------------|------------------|
-| `type`         | Literal["civitai"]   | Used for the discriminated union of metadata classes|
-| `id`           | int                  | Civitai model id |
-| `version_name` | str                  | Name of this version of the model (distinct from model name) |
-| `version_id`   | int                  | Civitai model version id (distinct from model id) |
-| `created`      | datetime             | Date this version of the model was created |
-| `updated`      | datetime             | Date this version of the model was last updated |
-| `published`    | datetime             | Date this version of the model was published to Civitai |
-| `description`  | str                  | Model description. Quite verbose and contains HTML tags |
-| `version_description` | str           | Model version description, usually describes changes to the model |
-| `nsfw`         | bool                 | Whether the model tends to generate NSFW content |
-| `restrictions` | LicenseRestrictions  | An object that describes what is and isn't allowed with this model |
-| `trained_words`| Set[str]             | Trigger words for this model, if any |
-| `download_url` | AnyHttpUrl           | URL for downloading this version of the model |
-| `base_model_trained_on` | str         | Name of the model that this version was trained on |
-| `thumbnail_url` | AnyHttpUrl          | URL to access a representative thumbnail image of the model's output |
-| `weight_min`    | int                 | For LoRA sliders, the minimum suggested weight to apply |
-| `weight_max`    | int                 | For LoRA sliders, the maximum suggested weight to apply |
-
-Note that `weight_min` and `weight_max` are not currently populated
-and take the default values of (-1.0, +2.0). The issue is that these
-values aren't part of the structured data but appear in the text
-description. Some regular expression or LLM coding may be able to
-extract these values.
-
-Also be aware that `base_model_trained_on` is free text and doesn't
-correspond to our `ModelType` enum.
-
-`CivitaiMetadata` also defines some convenience properties relating to
-licensing restrictions: `credit_required`, `allow_commercial_use`,
-`allow_derivatives` and `allow_different_license`.
-
 #### `AnyModelRepoMetadata`
 
-This is a discriminated Union of `CivitaiMetadata` and
-`HuggingFaceMetadata`.
+This is a discriminated Union of `HuggingFaceMetadata`.
 
 ### Fetching Metadata from Online Repos
 
-The `HuggingFaceMetadataFetch` and `CivitaiMetadataFetch` classes will
-retrieve metadata from their corresponding repositories and return
+The `HuggingFaceMetadataFetch` class will
+retrieve metadata from its corresponding repository and return
 `AnyModelRepoMetadata` objects. Their base class
 `ModelMetadataFetchBase` is an abstract class that defines two
 methods: `from_url()` and `from_id()`. The former accepts the type of
@@ -1412,98 +1303,17 @@ provide a `requests.Session` argument. This allows you to customize
 the low-level HTTP fetch requests and is used, for instance, in the
 testing suite to avoid hitting the internet.
 
-The HuggingFace and Civitai fetcher subclasses add additional
-repo-specific fetching methods:
-
+The HuggingFace fetcher subclass add additional repo-specific fetching methods:
 
 #### HuggingFaceMetadataFetch
 
 This overrides its base class `from_json()` method to return a
 `HuggingFaceMetadata` object directly.
 
-#### CivitaiMetadataFetch
-
-This adds the following methods:
-
-`from_civitai_modelid()` This takes the ID of a model, finds the
-default version of the model, and then retrieves the metadata for
-that version, returning a `CivitaiMetadata` object directly.
-
-`from_civitai_versionid()` This takes the ID of a model version and
-retrieves its metadata. Functionally equivalent to `from_id()`, the
-only difference is that it returna a `CivitaiMetadata` object rather
-than an `AnyModelRepoMetadata`.
-
-
 ### Metadata Storage
 
-The `ModelMetadataStore` provides a simple facility to store model
-metadata in the `invokeai.db` database. The data is stored as a JSON
-blob, with a few common fields (`name`, `author`, `tags`) broken out
-to be searchable. 
-
-When a metadata object is saved to the database, it is identified
-using the model key, _and this key must correspond to an existing
-model key in the model_config table_. There is a foreign key integrity
-constraint between the `model_config.id` field and the
-`model_metadata.id` field such that if you attempt to save metadata
-under an unknown key, the attempt will result in an
-`UnknownModelException`. Likewise, when a model is deleted from
-`model_config`, the deletion of the corresponding metadata record will
-be triggered.
-
-Tags are stored in a normalized fashion in the tables `model_tags` and
-`tags`. Triggers keep the tag table in sync with the `model_metadata`
-table.
-
-To create the storage object, initialize it with the InvokeAI
-`SqliteDatabase` object. This is often done this way:
-
-```
-from invokeai.app.api.dependencies import ApiDependencies
-metadata_store = ModelMetadataStore(ApiDependencies.invoker.services.db)
-```
-
-You can then access the storage with the following methods:
-
-#### `add_metadata(key, metadata)`
-
-Add the metadata using a previously-defined model key.
-
-There is currently no `delete_metadata()` method. The metadata will
-persist until the matching config is deleted from the `model_config`
-table.
-
-#### `get_metadata(key) -> AnyModelRepoMetadata`
-
-Retrieve the metadata corresponding to the model key.
-
-#### `update_metadata(key, new_metadata)`
-
-Update an existing metadata record with new metadata.
-
-#### `search_by_tag(tags: Set[str]) -> Set[str]`
-
-Given a set of tags, find models that are tagged with them. If
-multiple tags are provided then a matching model must be tagged with
-*all* the tags in the set. This method returns a set of model keys and
-is intended to be used in conjunction with the `ModelRecordService`:
-
-```
-model_config_store = ApiDependencies.invoker.services.model_records
-matches = metadata_store.search_by_tag({'license:other'})
-models = [model_config_store.get(x) for x in matches]
-```
-
-#### `search_by_name(name: str) -> Set[str]
-
-Find all model metadata records that have the given name and return a
-set of keys to the corresponding model config objects.
-
-#### `search_by_author(author: str) -> Set[str]
-
-Find all model metadata records that have the given author and return
-a set of keys to the corresponding model config objects.
+The `ModelConfigBase` stores this response in the `source_api_response` field
+as a JSON blob.
 
 ***
 
@@ -1535,16 +1345,16 @@ from invokeai.app.services.model_load import ModelLoadService, ModelLoaderRegist
 
 config = InvokeAIAppConfig.get_config()
 ram_cache = ModelCache(
-	max_cache_size=config.ram_cache_size, max_vram_cache_size=config.vram_cache_size, logger=logger
+ max_cache_size=config.ram_cache_size, max_vram_cache_size=config.vram_cache_size, logger=logger
 )
 convert_cache = ModelConvertCache(
-	cache_path=config.models_convert_cache_path, max_size=config.convert_cache_size
+ cache_path=config.models_convert_cache_path, max_size=config.convert_cache_size
 )
 loader = ModelLoadService(
-	app_config=config,
-	ram_cache=ram_cache,
-	convert_cache=convert_cache,
-	registry=ModelLoaderRegistry
+ app_config=config,
+ ram_cache=ram_cache,
+ convert_cache=convert_cache,
+ registry=ModelLoaderRegistry
 )
 ```
 
@@ -1567,7 +1377,6 @@ The returned `LoadedModel` object contains a copy of the configuration
 record returned by the model record `get_model()` method, as well as
 the in-memory loaded model:
 
-
 | **Attribute Name** | **Type**        |  **Description** |
 |----------------|-----------------|------------------|
 | `config`       | AnyModelConfig         | A copy of the model's configuration record for retrieving base type, etc. |
@@ -1581,7 +1390,6 @@ return `AnyModel`, a Union `ModelMixin`, `torch.nn.Module`,
 models, `EmbeddingModelRaw` is used for LoRA and TextualInversion
 models. The others are obvious.
 
-
 `LoadedModel` acts as a context manager. The context loads the model
 into the execution device (e.g. VRAM on CUDA systems), locks the model
 in the execution device for the duration of the context, and returns
@@ -1590,14 +1398,14 @@ the model. Use it like this:
 ```
 model_info = loader.get_model_by_key('f13dd932c0c35c22dcb8d6cda4203764', SubModelType('vae'))
 with model_info as vae:
-	image = vae.decode(latents)[0]
+ image = vae.decode(latents)[0]
 ```
 
 `get_model_by_key()` may raise any of the following exceptions:
 
-- `UnknownModelException`   -- key not in database
-- `ModelNotFoundException`  -- key in database but model not found at path
-- `NotImplementedException` -- the loader doesn't know how to load this type of model
+* `UnknownModelException`   -- key not in database
+* `ModelNotFoundException`  -- key in database but model not found at path
+* `NotImplementedException` -- the loader doesn't know how to load this type of model
   
 ### Emitting model loading events
 
@@ -1609,15 +1417,15 @@ following payload:
 
 ```
 payload=dict(
-	queue_id=queue_id,
-	queue_item_id=queue_item_id,
-	queue_batch_id=queue_batch_id,
-	graph_execution_state_id=graph_execution_state_id,
-	model_key=model_key,
-	submodel_type=submodel,
-	hash=model_info.hash,
-	location=str(model_info.location),
-	precision=str(model_info.precision),
+ queue_id=queue_id,
+ queue_item_id=queue_item_id,
+ queue_batch_id=queue_batch_id,
+ graph_execution_state_id=graph_execution_state_id,
+ model_key=model_key,
+ submodel_type=submodel,
+ hash=model_info.hash,
+ location=str(model_info.location),
+ precision=str(model_info.precision),
 )
 ```
 
@@ -1724,6 +1532,7 @@ object, or in `context.services.model_manager` from within an
 invocation.
 
 In the examples below, we have retrieved the manager using:
+
 ```
 mm = ApiDependencies.invoker.services.model_manager
 ```

docs/features/CONFIGURATION.md

@@ -31,18 +31,18 @@ be referred to as ROOT.
 To find its root directory, InvokeAI uses the following recipe:
 
 1. It first looks for the argument `--root <path>` on the command line
-it was launched from, and uses the indicated path if present.
+   it was launched from, and uses the indicated path if present.
 
 2. Next it looks for the environment variable INVOKEAI_ROOT, and uses
-the directory path found there if present.
+   the directory path found there if present.
 
 3. If neither of these are present, then InvokeAI looks for the
-folder containing the `.venv` Python virtual environment directory for
-the currently active environment. This directory is checked for files
-expected inside the InvokeAI root before it is used.
+   folder containing the `.venv` Python virtual environment directory for
+   the currently active environment. This directory is checked for files
+   expected inside the InvokeAI root before it is used.
 
 4. Finally, InvokeAI looks for a directory in the current user's home
-directory named `invokeai`.
+   directory named `invokeai`.
 
 #### Reading the InvokeAI Configuration File
 
@@ -149,104 +149,65 @@ usage: InvokeAI [-h] [--host HOST] [--port PORT] [--allow_origins [ALLOW_ORIGINS
 
 ## The Configuration Settings
 
-The configuration settings are divided into several distinct
-groups in `invokeia.yaml`:
+The config is managed by the `InvokeAIAppConfig` class, which is a pydantic model. The below docs are autogenerated from the class.
 
-### Web Server
+When editing your `invokeai.yaml` file, you'll need to put settings under their appropriate group. The group for each setting is denoted in the table below.
 
-| Setting             | Default Value | Description                                                                                                                |
-|---------------------|---------------|----------------------------------------------------------------------------------------------------------------------------|
-| `host`              | `localhost`   | Name or IP address of the network interface that the web server will listen on                                             |
-| `port`              | `9090`        | Network port number that the web server will listen on                                                                     |
-| `allow_origins`     | `[]`          | A list of host names or IP addresses that are allowed to connect to the InvokeAI API in the format `['host1','host2',...]` |
-| `allow_credentials` | `true`        | Require credentials for a foreign host to access the InvokeAI API (don't change this)                                      |
-| `allow_methods`     | `*`           | List of HTTP methods ("GET", "POST") that the web server is allowed to use when accessing the API                          |
-| `allow_headers`     | `*`           | List of HTTP headers that the web server will accept when accessing the API                                                |
-| `ssl_certfile`      | null          | Path to an SSL certificate file, used to enable HTTPS.                                                                     |
-| `ssl_keyfile`       | null          | Path to an SSL keyfile, if the key is not included in the certificate file.                                                |
+Following the table are additional explanations for certain settings.
 
-The documentation for InvokeAI's API can be accessed by browsing to the following URL: [http://localhost:9090/docs].
+<!-- prettier-ignore-start -->
+::: invokeai.app.services.config.config_default.InvokeAIAppConfig
+    options:
+        heading_level: 3
+        members: false
+<!-- prettier-ignore-end -->
 
-### Features
+### Model Marketplace API Keys
 
-These configuration settings allow you to enable and disable various InvokeAI features:
+Some model marketplaces require an API key to download models. You can provide a URL pattern and appropriate token in your `invokeai.yaml` file to provide that API key.
 
-| Setting  | Default Value  |  Description |
-|----------|----------------|--------------|
-| `esrgan`     | `true`      | Activate the ESRGAN upscaling options|
-| `internet_available` | `true`     | When a resource is not available locally, try to fetch it via the internet |
-| `log_tokenization` | `false`      | Before each text2image generation, print a color-coded representation of the prompt to the console; this can help understand why a prompt is not working as expected |
-| `patchmatch` | `true`     | Activate the "patchmatch" algorithm for improved inpainting |
+The pattern can be any valid regex (you may need to surround the pattern with quotes):
 
-### Generation
+```yaml
+InvokeAI:
+  Model Install:
+    remote_api_tokens:
+      # Any URL containing `models.com` will automatically use `your_models_com_token`
+      - url_regex: models.com
+        token: your_models_com_token
+      # Any URL matching this contrived regex will use `some_other_token`
+      - url_regex: '^[a-z]{3}whatever.*\.com$'
+        token: some_other_token
+```
 
-These options tune InvokeAI's memory and performance characteristics.
+The provided token will be added as a `Bearer` token to the network requests to download the model files. As far as we know, this works for all model marketplaces that require authorization.
 
-| Setting               | Default Value | Description                                                                                                                                                                                                                                                      |
-|-----------------------|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `sequential_guidance` | `false`       | Calculate guidance in serial rather than in parallel, lowering memory requirements at the cost of some performance loss                                                                                                                                          |
-| `attention_type`      | `auto`        | Select the type of attention to use. One of `auto`,`normal`,`xformers`,`sliced`, or `torch-sdp`                                                                                                                                                                  |
-| `attention_slice_size` | `auto`       | When "sliced" attention is selected, set the slice size. One of `auto`, `balanced`, `max` or the integers 1-8|
-| `force_tiled_decode`  | `false`       | Force the VAE step to decode in tiles, reducing memory consumption at the cost of performance |
+### Model Hashing
 
-### Device
+Models are hashed during installation with the `BLAKE3` algorithm, providing a stable identifier for models across all platforms.
 
-These options configure the generation execution device.
-
-| Setting               | Default Value | Description                                                                                                                                                                                                                                                      |
-|-----------------------|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `device`           | `auto`        | Preferred execution device. One of `auto`, `cpu`, `cuda`, `cuda:1`, `mps`. `auto` will choose the device depending on the hardware platform and the installed torch capabilities. |
-| `precision`           | `auto`        | Floating point precision. One of `auto`, `float16` or `float32`. `float16` will consume half the memory of `float32` but produce slightly lower-quality images. The `auto` setting will guess the proper precision based on your video card and operating system |
+Model hashing is a one-time operation, but it may take a couple minutes to hash a large model collection. You may opt out of model hashing and instead have a random UUID assigned instead:
 
+```yaml
+InvokeAI:
+  Model Install:
+    skip_model_hash: true
+```
 
 ### Paths
 
 These options set the paths of various directories and files used by
-InvokeAI. Relative paths are interpreted relative to INVOKEAI_ROOT, so
-if INVOKEAI_ROOT is `/home/fred/invokeai` and the path is
+InvokeAI. Relative paths are interpreted relative to the root directory, so
+if root is `/home/fred/invokeai` and the path is
 `autoimport/main`, then the corresponding directory will be located at
 `/home/fred/invokeai/autoimport/main`.
 
-| Setting  | Default Value  |  Description |
-|----------|----------------|--------------|
-| `autoimport_dir` | `autoimport/main`     | At startup time, read and import any main model files found in this directory |
-| `lora_dir` | `autoimport/lora`     | At startup time, read and import any LoRA/LyCORIS models found in this directory |
-| `embedding_dir` | `autoimport/embedding`  | At startup time, read and import any textual inversion (embedding) models found in this directory |
-| `controlnet_dir` | `autoimport/controlnet`  | At startup time, read and import any ControlNet models found in this directory |
-| `conf_path` | `configs/models.yaml`  | Location of the `models.yaml` model configuration file |
-| `models_dir` | `models`  | Location of the directory containing models installed by InvokeAI's model manager |
-| `legacy_conf_dir` | `configs/stable-diffusion`  | Location of the directory containing the .yaml configuration files for legacy checkpoint models |
-| `db_dir` | `databases`  | Location of the directory containing InvokeAI's image, schema and session database |
-| `outdir` | `outputs`  | Location of the directory in which the gallery of generated and uploaded images will be stored |
-| `use_memory_db` | `false`  | Keep database information in memory rather than on disk; this will not preserve image gallery information across restarts |
-
-Note that the autoimport directories will be searched recursively,
+Note that the autoimport directory will be searched recursively,
 allowing you to organize the models into folders and subfolders in any
-way you wish. In addition, while we have split up autoimport
-directories by the type of model they contain, this isn't
-necessary. You can combine different model types in the same folder
-and InvokeAI will figure out what they are. So you can easily use just
-one autoimport directory by commenting out the unneeded paths:
-
-```
-Paths:
-  autoimport_dir: autoimport
-#  lora_dir: null
-#  embedding_dir: null
-#  controlnet_dir: null
-```
+way you wish.
 
 ### Logging
 
-These settings control the information, warning, and debugging
-messages printed to the console log while InvokeAI is running:
-
-| Setting  | Default Value  |  Description |
-|----------|----------------|--------------|
-| `log_handlers` | `console` | This controls where log messages are sent, and can be a list of one or more destinations. Values include `console`, `file`, `syslog` and `http`. These are described in more detail below |
-| `log_format` | `color` | This controls the formatting of the log messages. Values are `plain`, `color`, `legacy` and `syslog` |
-| `log_level`  | `debug` | This filters messages according to the level of severity and can be one of `debug`, `info`, `warning`, `error` and `critical`. For example, setting to `warning` will display all messages at the warning level or higher, but won't display "debug" or "info" messages |
-
 Several different log handler destinations are available, and multiple destinations are supported by providing a list:
 
 ```
@@ -256,9 +217,9 @@ Several different log handler destinations are available, and multiple destinati
      - file=/var/log/invokeai.log
 ```
 
-* `console` is the default. It prints log messages to the command-line window from which InvokeAI was launched.
+- `console` is the default. It prints log messages to the command-line window from which InvokeAI was launched.
 
-* `syslog` is only available on Linux and Macintosh systems. It uses
+- `syslog` is only available on Linux and Macintosh systems. It uses
   the operating system's "syslog" facility to write log file entries
   locally or to a remote logging machine. `syslog` offers a variety
   of configuration options:
@@ -271,7 +232,7 @@ Several different log handler destinations are available, and multiple destinati
                         - Log to LAN-connected server "fredserver" using the facility LOG_USER and datagram packets.
 ```
 
-* `http` can be used to log to a remote web server. The server must be
+- `http` can be used to log to a remote web server. The server must be
   properly configured to receive and act on log messages. The option
   accepts the URL to the web server, and a `method` argument
   indicating whether the message should be submitted using the GET or
@@ -283,7 +244,7 @@ Several different log handler destinations are available, and multiple destinati
 
 The `log_format` option provides several alternative formats:
 
-* `color`    - default format providing time, date and a message, using text colors to distinguish different log severities
-* `plain`    - same as above, but monochrome text only
-* `syslog`   - the log level and error message only, allowing the syslog system to attach the time and date
-* `legacy`   - a format similar to the one used by the legacy 2.3 InvokeAI releases.
+- `color` - default format providing time, date and a message, using text colors to distinguish different log severities
+- `plain` - same as above, but monochrome text only
+- `syslog` - the log level and error message only, allowing the syslog system to attach the time and date
+- `legacy` - a format similar to the one used by the legacy 2.3 InvokeAI releases.

docs/features/DATABASE.md

@@ -0,0 +1,35 @@
+---
+title: Database
+---
+
+# Invoke's SQLite Database
+
+Invoke uses a SQLite database to store image, workflow, model, and execution data.
+
+We take great care to ensure your data is safe, by utilizing transactions and a database migration system.
+
+Even so, when testing an prerelease version of the app, we strongly suggest either backing up your database or using an in-memory database. This ensures any prelease hiccups or databases schema changes will not cause problems for your data.
+
+## Database Backup
+
+Backing up your database is very simple. Invoke's data is stored in an `$INVOKEAI_ROOT` directory - where your `invoke.sh`/`invoke.bat` and `invokeai.yaml` files live.
+
+To back up your database, copy the `invokeai.db` file from `$INVOKEAI_ROOT/databases/invokeai.db` to somewhere safe.
+
+If anything comes up during prelease testing, you can simply copy your backup back into `$INVOKEAI_ROOT/databases/`.
+
+## In-Memory Database
+
+SQLite can run on an in-memory database. Your existing database is untouched when this mode is enabled, but your existing data won't be accessible.
+
+This is very useful for testing, as there is no chance of a database change modifying your "physical" database.
+
+To run Invoke with a memory database, edit your `invokeai.yaml` file, and add `use_memory_db: true` to the `Paths:` stanza:
+
+```yaml
+InvokeAI:
+  Development:
+    use_memory_db: true
+```
+
+Delete this line (or set it to `false`) to use your main database.

invokeai/app/api/dependencies.py

@@ -25,8 +25,8 @@ from ..services.invocation_cache.invocation_cache_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.model_images.model_images_default import ModelImageFileStorageDisk
 from ..services.model_manager.model_manager_default import ModelManagerService
-from ..services.model_metadata import ModelMetadataStoreSQL
 from ..services.model_records import ModelRecordServiceSQL
 from ..services.names.names_default import SimpleNameService
 from ..services.session_processor.session_processor_default import DefaultSessionProcessor
@@ -72,6 +72,8 @@ class ApiDependencies:
 
         image_files = DiskImageFileStorage(f"{output_folder}/images")
 
+        model_images_folder = config.models_path
+
         db = init_db(config=config, logger=logger, image_files=image_files)
 
         configuration = config
@@ -93,10 +95,10 @@ class ApiDependencies:
             ObjectSerializerDisk[ConditioningFieldData](output_folder / "conditioning", ephemeral=True)
         )
         download_queue_service = DownloadQueueService(event_bus=events)
-        model_metadata_service = ModelMetadataStoreSQL(db=db)
+        model_images_service = ModelImageFileStorageDisk(model_images_folder / "model_images")
         model_manager = ModelManagerService.build_model_manager(
             app_config=configuration,
-            model_record_service=ModelRecordServiceSQL(db=db, metadata_store=model_metadata_service),
+            model_record_service=ModelRecordServiceSQL(db=db),
             download_queue=download_queue_service,
             events=events,
         )
@@ -120,6 +122,7 @@ class ApiDependencies:
             images=images,
             invocation_cache=invocation_cache,
             logger=logger,
+            model_images=model_images_service,
             model_manager=model_manager,
             download_queue=download_queue_service,
             names=names,

invokeai/app/api/routers/model_manager.py

@@ -1,28 +1,26 @@
 # Copyright (c) 2023 Lincoln D. Stein
 """FastAPI route for model configuration records."""
 
+import io
 import pathlib
 import shutil
-from hashlib import sha1
-from random import randbytes
-from typing import Any, Dict, List, Optional, Set
+import traceback
+from typing import Any, Dict, List, Optional
 
-from fastapi import Body, Path, Query, Response
+from fastapi import Body, Path, Query, Response, UploadFile
+from fastapi.responses import FileResponse
 from fastapi.routing import APIRouter
+from PIL import Image
 from pydantic import BaseModel, ConfigDict, Field
 from starlette.exceptions import HTTPException
 from typing_extensions import Annotated
 
 from invokeai.app.services.model_install import ModelInstallJob
-from invokeai.app.services.model_metadata.metadata_store_base import ModelMetadataChanges
 from invokeai.app.services.model_records import (
-    DuplicateModelException,
     InvalidModelException,
-    ModelRecordOrderBy,
-    ModelSummary,
     UnknownModelException,
 )
-from invokeai.app.services.shared.pagination import PaginatedResults
+from invokeai.app.services.model_records.model_records_base import DuplicateModelException, ModelRecordChanges
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
     BaseModelType,
@@ -31,15 +29,15 @@ from invokeai.backend.model_manager.config import (
     ModelType,
     SubModelType,
 )
-from invokeai.backend.model_manager.merge import MergeInterpolationMethod, ModelMerger
-from invokeai.backend.model_manager.metadata import AnyModelRepoMetadata
-from invokeai.backend.model_manager.metadata.metadata_base import BaseMetadata
 from invokeai.backend.model_manager.search import ModelSearch
 
 from ..dependencies import ApiDependencies
 
 model_manager_router = APIRouter(prefix="/v2/models", tags=["model_manager"])
 
+# images are immutable; set a high max-age
+IMAGE_MAX_AGE = 31536000
+
 
 class ModelsList(BaseModel):
     """Return list of configs."""
@@ -49,15 +47,6 @@ class ModelsList(BaseModel):
     model_config = ConfigDict(use_enum_values=True)
 
 
-class ModelTagSet(BaseModel):
-    """Return tags for a set of models."""
-
-    key: str
-    name: str
-    author: str
-    tags: Set[str]
-
-
 ##############################################################################
 # These are example inputs and outputs that are used in places where Swagger
 # is unable to generate a correct example.
@@ -68,19 +57,16 @@ example_model_config = {
     "base": "sd-1",
     "type": "main",
     "format": "checkpoint",
-    "config": "string",
+    "config_path": "string",
     "key": "string",
-    "original_hash": "string",
-    "current_hash": "string",
+    "hash": "string",
     "description": "string",
     "source": "string",
-    "last_modified": 0,
-    "vae": "string",
+    "converted_at": 0,
     "variant": "normal",
     "prediction_type": "epsilon",
     "repo_variant": "fp16",
     "upcast_attention": False,
-    "ztsnr_training": False,
 }
 
 example_model_input = {
@@ -89,50 +75,12 @@ example_model_input = {
     "base": "sd-1",
     "type": "main",
     "format": "checkpoint",
-    "config": "configs/stable-diffusion/v1-inference.yaml",
+    "config_path": "configs/stable-diffusion/v1-inference.yaml",
     "description": "Model description",
     "vae": None,
     "variant": "normal",
 }
 
-example_model_metadata = {
-    "name": "ip_adapter_sd_image_encoder",
-    "author": "InvokeAI",
-    "tags": [
-        "transformers",
-        "safetensors",
-        "clip_vision_model",
-        "endpoints_compatible",
-        "region:us",
-        "has_space",
-        "license:apache-2.0",
-    ],
-    "files": [
-        {
-            "url": "https://huggingface.co/InvokeAI/ip_adapter_sd_image_encoder/resolve/main/README.md",
-            "path": "ip_adapter_sd_image_encoder/README.md",
-            "size": 628,
-            "sha256": None,
-        },
-        {
-            "url": "https://huggingface.co/InvokeAI/ip_adapter_sd_image_encoder/resolve/main/config.json",
-            "path": "ip_adapter_sd_image_encoder/config.json",
-            "size": 560,
-            "sha256": None,
-        },
-        {
-            "url": "https://huggingface.co/InvokeAI/ip_adapter_sd_image_encoder/resolve/main/model.safetensors",
-            "path": "ip_adapter_sd_image_encoder/model.safetensors",
-            "size": 2528373448,
-            "sha256": "6ca9667da1ca9e0b0f75e46bb030f7e011f44f86cbfb8d5a36590fcd7507b030",
-        },
-    ],
-    "type": "huggingface",
-    "id": "InvokeAI/ip_adapter_sd_image_encoder",
-    "tag_dict": {"license": "apache-2.0"},
-    "last_modified": "2023-09-23T17:33:25Z",
-}
-
 ##############################################################################
 # ROUTES
 ##############################################################################
@@ -164,6 +112,9 @@ async def list_model_records(
         found_models.extend(
             record_store.search_by_attr(model_type=model_type, model_name=model_name, model_format=model_format)
         )
+    for model in found_models:
+        cover_image = ApiDependencies.invoker.services.model_images.get_url(model.key)
+        model.cover_image = cover_image
     return ModelsList(models=found_models)
 
 
@@ -207,94 +158,23 @@ async def get_model_record(
     record_store = ApiDependencies.invoker.services.model_manager.store
     try:
         config: AnyModelConfig = record_store.get_model(key)
+        cover_image = ApiDependencies.invoker.services.model_images.get_url(key)
+        config.cover_image = cover_image
         return config
     except UnknownModelException as e:
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@model_manager_router.get("/summary", operation_id="list_model_summary")
-async def list_model_summary(
-    page: int = Query(default=0, description="The page to get"),
-    per_page: int = Query(default=10, description="The number of models per page"),
-    order_by: ModelRecordOrderBy = Query(default=ModelRecordOrderBy.Default, description="The attribute to order by"),
-) -> PaginatedResults[ModelSummary]:
-    """Gets a page of model summary data."""
-    record_store = ApiDependencies.invoker.services.model_manager.store
-    results: PaginatedResults[ModelSummary] = record_store.list_models(page=page, per_page=per_page, order_by=order_by)
-    return results
-
-
-@model_manager_router.get(
-    "/i/{key}/metadata",
-    operation_id="get_model_metadata",
-    responses={
-        200: {
-            "description": "The model metadata was retrieved successfully",
-            "content": {"application/json": {"example": example_model_metadata}},
-        },
-        400: {"description": "Bad request"},
-    },
-)
-async def get_model_metadata(
-    key: str = Path(description="Key of the model repo metadata to fetch."),
-) -> Optional[AnyModelRepoMetadata]:
-    """Get a model metadata object."""
-    record_store = ApiDependencies.invoker.services.model_manager.store
-    result: Optional[AnyModelRepoMetadata] = record_store.get_metadata(key)
-
-    return result
-
-
-@model_manager_router.patch(
-    "/i/{key}/metadata",
-    operation_id="update_model_metadata",
-    responses={
-        201: {
-            "description": "The model metadata was updated successfully",
-            "content": {"application/json": {"example": example_model_metadata}},
-        },
-        400: {"description": "Bad request"},
-    },
-)
-async def update_model_metadata(
-    key: str = Path(description="Key of the model repo metadata to fetch."),
-    changes: ModelMetadataChanges = Body(description="The changes"),
-) -> Optional[AnyModelRepoMetadata]:
-    """Updates or creates a model metadata object."""
-    record_store = ApiDependencies.invoker.services.model_manager.store
-    metadata_store = ApiDependencies.invoker.services.model_manager.store.metadata_store
-
-    try:
-        original_metadata = record_store.get_metadata(key)
-        if original_metadata:
-            if changes.default_settings:
-                original_metadata.default_settings = changes.default_settings
-
-            metadata_store.update_metadata(key, original_metadata)
-        else:
-            metadata_store.add_metadata(
-                key, BaseMetadata(name="", author="", default_settings=changes.default_settings)
-            )
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"An error occurred while updating the model metadata: {e}",
-        )
-
-    result: Optional[AnyModelRepoMetadata] = record_store.get_metadata(key)
-
-    return result
-
-
-@model_manager_router.get(
-    "/tags",
-    operation_id="list_tags",
-)
-async def list_tags() -> Set[str]:
-    """Get a unique set of all the model tags."""
-    record_store = ApiDependencies.invoker.services.model_manager.store
-    result: Set[str] = record_store.list_tags()
-    return result
+# @model_manager_router.get("/summary", operation_id="list_model_summary")
+# async def list_model_summary(
+#     page: int = Query(default=0, description="The page to get"),
+#     per_page: int = Query(default=10, description="The number of models per page"),
+#     order_by: ModelRecordOrderBy = Query(default=ModelRecordOrderBy.Default, description="The attribute to order by"),
+# ) -> PaginatedResults[ModelSummary]:
+#     """Gets a page of model summary data."""
+#     record_store = ApiDependencies.invoker.services.model_manager.store
+#     results: PaginatedResults[ModelSummary] = record_store.list_models(page=page, per_page=per_page, order_by=order_by)
+#     return results
 
 
 class FoundModel(BaseModel):
@@ -366,19 +246,6 @@ async def scan_for_models(
     return scan_results
 
 
-@model_manager_router.get(
-    "/tags/search",
-    operation_id="search_by_metadata_tags",
-)
-async def search_by_metadata_tags(
-    tags: Set[str] = Query(default=None, description="Tags to search for"),
-) -> ModelsList:
-    """Get a list of models."""
-    record_store = ApiDependencies.invoker.services.model_manager.store
-    results = record_store.search_by_metadata_tag(tags)
-    return ModelsList(models=results)
-
-
 @model_manager_router.patch(
     "/i/{key}",
     operation_id="update_model_record",
@@ -395,15 +262,13 @@ async def search_by_metadata_tags(
 )
 async def update_model_record(
     key: Annotated[str, Path(description="Unique key of model")],
-    info: Annotated[
-        AnyModelConfig, Body(description="Model config", discriminator="type", example=example_model_input)
-    ],
+    changes: Annotated[ModelRecordChanges, Body(description="Model config", example=example_model_input)],
 ) -> AnyModelConfig:
-    """Update model contents with a new config. If the model name or base fields are changed, then the model is renamed."""
+    """Update a model's config."""
     logger = ApiDependencies.invoker.services.logger
     record_store = ApiDependencies.invoker.services.model_manager.store
     try:
-        model_response: AnyModelConfig = record_store.update_model(key, config=info)
+        model_response: AnyModelConfig = record_store.update_model(key, changes=changes)
         logger.info(f"Updated model: {key}")
     except UnknownModelException as e:
         raise HTTPException(status_code=404, detail=str(e))
@@ -413,16 +278,85 @@ async def update_model_record(
     return model_response
 
 
+@model_manager_router.get(
+    "/i/{key}/image",
+    operation_id="get_model_image",
+    responses={
+        200: {
+            "description": "The model image was fetched successfully",
+        },
+        400: {"description": "Bad request"},
+        404: {"description": "The model image could not be found"},
+    },
+    status_code=200,
+)
+async def get_model_image(
+    key: str = Path(description="The name of model image file to get"),
+) -> FileResponse:
+    """Gets an image file that previews the model"""
+
+    try:
+        path = ApiDependencies.invoker.services.model_images.get_path(key)
+
+        response = FileResponse(
+            path,
+            media_type="image/png",
+            filename=key + ".png",
+            content_disposition_type="inline",
+        )
+        response.headers["Cache-Control"] = f"max-age={IMAGE_MAX_AGE}"
+        return response
+    except Exception:
+        raise HTTPException(status_code=404)
+
+
+@model_manager_router.patch(
+    "/i/{key}/image",
+    operation_id="update_model_image",
+    responses={
+        200: {
+            "description": "The model image was updated successfully",
+        },
+        400: {"description": "Bad request"},
+    },
+    status_code=200,
+)
+async def update_model_image(
+    key: Annotated[str, Path(description="Unique key of model")],
+    image: UploadFile,
+) -> None:
+    if not image.content_type or not image.content_type.startswith("image"):
+        raise HTTPException(status_code=415, detail="Not an image")
+
+    contents = await image.read()
+    try:
+        pil_image = Image.open(io.BytesIO(contents))
+
+    except Exception:
+        ApiDependencies.invoker.services.logger.error(traceback.format_exc())
+        raise HTTPException(status_code=415, detail="Failed to read image")
+
+    logger = ApiDependencies.invoker.services.logger
+    model_images = ApiDependencies.invoker.services.model_images
+    try:
+        model_images.save(pil_image, key)
+        logger.info(f"Updated image for model: {key}")
+    except ValueError as e:
+        logger.error(str(e))
+        raise HTTPException(status_code=409, detail=str(e))
+    return
+
+
 @model_manager_router.delete(
     "/i/{key}",
-    operation_id="del_model_record",
+    operation_id="delete_model",
     responses={
         204: {"description": "Model deleted successfully"},
         404: {"description": "Model not found"},
     },
     status_code=204,
 )
-async def del_model_record(
+async def delete_model(
     key: str = Path(description="Unique key of model to remove from model registry."),
 ) -> Response:
     """
@@ -443,42 +377,62 @@ async def del_model_record(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@model_manager_router.post(
-    "/i/",
-    operation_id="add_model_record",
+@model_manager_router.delete(
+    "/i/{key}/image",
+    operation_id="delete_model_image",
     responses={
-        201: {
-            "description": "The model added successfully",
-            "content": {"application/json": {"example": example_model_config}},
-        },
-        409: {"description": "There is already a model corresponding to this path or repo_id"},
-        415: {"description": "Unrecognized file/folder format"},
+        204: {"description": "Model image deleted successfully"},
+        404: {"description": "Model image not found"},
     },
-    status_code=201,
+    status_code=204,
 )
-async def add_model_record(
-    config: Annotated[
-        AnyModelConfig, Body(description="Model config", discriminator="type", example=example_model_input)
-    ],
-) -> AnyModelConfig:
-    """Add a model using the configuration information appropriate for its type."""
+async def delete_model_image(
+    key: str = Path(description="Unique key of model image to remove from model_images directory."),
+) -> None:
     logger = ApiDependencies.invoker.services.logger
-    record_store = ApiDependencies.invoker.services.model_manager.store
-    if config.key == "<NOKEY>":
-        config.key = sha1(randbytes(100)).hexdigest()
-        logger.info(f"Created model {config.key} for {config.name}")
+    model_images = ApiDependencies.invoker.services.model_images
     try:
-        record_store.add_model(config.key, config)
-    except DuplicateModelException as e:
+        model_images.delete(key)
+        logger.info(f"Deleted model image: {key}")
+        return
+    except UnknownModelException as e:
         logger.error(str(e))
-        raise HTTPException(status_code=409, detail=str(e))
-    except InvalidModelException as e:
-        logger.error(str(e))
-        raise HTTPException(status_code=415)
+        raise HTTPException(status_code=404, detail=str(e))
 
-    # now fetch it out
-    result: AnyModelConfig = record_store.get_model(config.key)
-    return result
+
+# @model_manager_router.post(
+#     "/i/",
+#     operation_id="add_model_record",
+#     responses={
+#         201: {
+#             "description": "The model added successfully",
+#             "content": {"application/json": {"example": example_model_config}},
+#         },
+#         409: {"description": "There is already a model corresponding to this path or repo_id"},
+#         415: {"description": "Unrecognized file/folder format"},
+#     },
+#     status_code=201,
+# )
+# async def add_model_record(
+#     config: Annotated[
+#         AnyModelConfig, Body(description="Model config", discriminator="type", example=example_model_input)
+#     ],
+# ) -> AnyModelConfig:
+#     """Add a model using the configuration information appropriate for its type."""
+#     logger = ApiDependencies.invoker.services.logger
+#     record_store = ApiDependencies.invoker.services.model_manager.store
+#     try:
+#         record_store.add_model(config)
+#     except DuplicateModelException as e:
+#         logger.error(str(e))
+#         raise HTTPException(status_code=409, detail=str(e))
+#     except InvalidModelException as e:
+#         logger.error(str(e))
+#         raise HTTPException(status_code=415)
+
+#     # now fetch it out
+#     result: AnyModelConfig = record_store.get_model(config.key)
+#     return result
 
 
 @model_manager_router.post(
@@ -553,10 +507,10 @@ async def install_model(
 
 
 @model_manager_router.get(
-    "/import",
-    operation_id="list_model_install_jobs",
+    "/install",
+    operation_id="list_model_installs",
 )
-async def list_model_install_jobs() -> List[ModelInstallJob]:
+async def list_model_installs() -> List[ModelInstallJob]:
     """Return the list of model install jobs.
 
     Install jobs have a numeric `id`, a `status`, and other fields that provide information on
@@ -570,9 +524,8 @@ async def list_model_install_jobs() -> List[ModelInstallJob]:
     * "cancelled" -- Job was cancelled before completion.
 
     Once completed, information about the model such as its size, base
-    model, type, and metadata can be retrieved from the `config_out`
-    field. For multi-file models such as diffusers, information on individual files
-    can be retrieved from `download_parts`.
+    model and type can be retrieved from the `config_out` field. For multi-file models such as diffusers,
+    information on individual files can be retrieved from `download_parts`.
 
     See the example and schema below for more information.
     """
@@ -581,7 +534,7 @@ async def list_model_install_jobs() -> List[ModelInstallJob]:
 
 
 @model_manager_router.get(
-    "/import/{id}",
+    "/install/{id}",
     operation_id="get_model_install_job",
     responses={
         200: {"description": "Success"},
@@ -601,7 +554,7 @@ async def get_model_install_job(id: int = Path(description="Model install id"))
 
 
 @model_manager_router.delete(
-    "/import/{id}",
+    "/install/{id}",
     operation_id="cancel_model_install_job",
     responses={
         201: {"description": "The job was cancelled successfully"},
@@ -619,8 +572,8 @@ async def cancel_model_install_job(id: int = Path(description="Model install job
     installer.cancel_job(job)
 
 
-@model_manager_router.patch(
-    "/import",
+@model_manager_router.delete(
+    "/install",
     operation_id="prune_model_install_jobs",
     responses={
         204: {"description": "All completed and errored jobs have been pruned"},
@@ -690,7 +643,7 @@ async def convert_model(
         raise HTTPException(400, f"The model with key {key} is not a main checkpoint model.")
 
     # loading the model will convert it into a cached diffusers file
-    model_manager.load_model_by_config(model_config, submodel_type=SubModelType.Scheduler)
+    model_manager.load.load_model(model_config, submodel_type=SubModelType.Scheduler)
 
     # Get the path of the converted model from the loader
     cache_path = loader.convert_cache.cache_path(key)
@@ -699,7 +652,8 @@ async def convert_model(
     # temporarily rename the original safetensors file so that there is no naming conflict
     original_name = model_config.name
     model_config.name = f"{original_name}.DELETE"
-    store.update_model(key, config=model_config)
+    changes = ModelRecordChanges(name=model_config.name)
+    store.update_model(key, changes=changes)
 
     # install the diffusers
     try:
@@ -708,7 +662,7 @@ async def convert_model(
             config={
                 "name": original_name,
                 "description": model_config.description,
-                "original_hash": model_config.original_hash,
+                "hash": model_config.hash,
                 "source": model_config.source,
             },
         )
@@ -716,10 +670,6 @@ async def convert_model(
         logger.error(str(e))
         raise HTTPException(status_code=409, detail=str(e))
 
-    # get the original metadata
-    if orig_metadata := store.get_metadata(key):
-        store.metadata_store.add_metadata(new_key, orig_metadata)
-
     # delete the original safetensors file
     installer.delete(key)
 
@@ -731,66 +681,66 @@ async def convert_model(
     return new_config
 
 
-@model_manager_router.put(
-    "/merge",
-    operation_id="merge",
-    responses={
-        200: {
-            "description": "Model converted successfully",
-            "content": {"application/json": {"example": example_model_config}},
-        },
-        400: {"description": "Bad request"},
-        404: {"description": "Model not found"},
-        409: {"description": "There is already a model registered at this location"},
-    },
-)
-async def merge(
-    keys: List[str] = Body(description="Keys for two to three models to merge", min_length=2, max_length=3),
-    merged_model_name: Optional[str] = Body(description="Name of destination model", default=None),
-    alpha: float = Body(description="Alpha weighting strength to apply to 2d and 3d models", default=0.5),
-    force: bool = Body(
-        description="Force merging of models created with different versions of diffusers",
-        default=False,
-    ),
-    interp: Optional[MergeInterpolationMethod] = Body(description="Interpolation method", default=None),
-    merge_dest_directory: Optional[str] = Body(
-        description="Save the merged model to the designated directory (with 'merged_model_name' appended)",
-        default=None,
-    ),
-) -> AnyModelConfig:
-    """
-    Merge diffusers models. The process is controlled by a set parameters provided in the body of the request.
-    ```
-    Argument                Description [default]
-    --------               ----------------------
-    keys                   List of 2-3 model keys to merge together. All models must use the same base type.
-    merged_model_name      Name for the merged model [Concat model names]
-    alpha                  Alpha value (0.0-1.0). Higher values give more weight to the second model [0.5]
-    force                  If true, force the merge even if the models were generated by different versions of the diffusers library [False]
-    interp                 Interpolation method. One of "weighted_sum", "sigmoid", "inv_sigmoid" or "add_difference" [weighted_sum]
-    merge_dest_directory   Specify a directory to store the merged model in [models directory]
-    ```
-    """
-    logger = ApiDependencies.invoker.services.logger
-    try:
-        logger.info(f"Merging models: {keys} into {merge_dest_directory or '<MODELS>'}/{merged_model_name}")
-        dest = pathlib.Path(merge_dest_directory) if merge_dest_directory else None
-        installer = ApiDependencies.invoker.services.model_manager.install
-        merger = ModelMerger(installer)
-        model_names = [installer.record_store.get_model(x).name for x in keys]
-        response = merger.merge_diffusion_models_and_save(
-            model_keys=keys,
-            merged_model_name=merged_model_name or "+".join(model_names),
-            alpha=alpha,
-            interp=interp,
-            force=force,
-            merge_dest_directory=dest,
-        )
-    except UnknownModelException:
-        raise HTTPException(
-            status_code=404,
-            detail=f"One or more of the models '{keys}' not found",
-        )
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    return response
+# @model_manager_router.put(
+#     "/merge",
+#     operation_id="merge",
+#     responses={
+#         200: {
+#             "description": "Model converted successfully",
+#             "content": {"application/json": {"example": example_model_config}},
+#         },
+#         400: {"description": "Bad request"},
+#         404: {"description": "Model not found"},
+#         409: {"description": "There is already a model registered at this location"},
+#     },
+# )
+# async def merge(
+#     keys: List[str] = Body(description="Keys for two to three models to merge", min_length=2, max_length=3),
+#     merged_model_name: Optional[str] = Body(description="Name of destination model", default=None),
+#     alpha: float = Body(description="Alpha weighting strength to apply to 2d and 3d models", default=0.5),
+#     force: bool = Body(
+#         description="Force merging of models created with different versions of diffusers",
+#         default=False,
+#     ),
+#     interp: Optional[MergeInterpolationMethod] = Body(description="Interpolation method", default=None),
+#     merge_dest_directory: Optional[str] = Body(
+#         description="Save the merged model to the designated directory (with 'merged_model_name' appended)",
+#         default=None,
+#     ),
+# ) -> AnyModelConfig:
+#     """
+#     Merge diffusers models. The process is controlled by a set parameters provided in the body of the request.
+#     ```
+#     Argument                Description [default]
+#     --------               ----------------------
+#     keys                   List of 2-3 model keys to merge together. All models must use the same base type.
+#     merged_model_name      Name for the merged model [Concat model names]
+#     alpha                  Alpha value (0.0-1.0). Higher values give more weight to the second model [0.5]
+#     force                  If true, force the merge even if the models were generated by different versions of the diffusers library [False]
+#     interp                 Interpolation method. One of "weighted_sum", "sigmoid", "inv_sigmoid" or "add_difference" [weighted_sum]
+#     merge_dest_directory   Specify a directory to store the merged model in [models directory]
+#     ```
+#     """
+#     logger = ApiDependencies.invoker.services.logger
+#     try:
+#         logger.info(f"Merging models: {keys} into {merge_dest_directory or '<MODELS>'}/{merged_model_name}")
+#         dest = pathlib.Path(merge_dest_directory) if merge_dest_directory else None
+#         installer = ApiDependencies.invoker.services.model_manager.install
+#         merger = ModelMerger(installer)
+#         model_names = [installer.record_store.get_model(x).name for x in keys]
+#         response = merger.merge_diffusion_models_and_save(
+#             model_keys=keys,
+#             merged_model_name=merged_model_name or "+".join(model_names),
+#             alpha=alpha,
+#             interp=interp,
+#             force=force,
+#             merge_dest_directory=dest,
+#         )
+#     except UnknownModelException:
+#         raise HTTPException(
+#             status_code=404,
+#             detail=f"One or more of the models '{keys}' not found",
+#         )
+#     except ValueError as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#     return response

invokeai/app/api_app.py

@@ -2,12 +2,11 @@
 # which are imported/used before parse_args() is called will get the default config values instead of the
 # values from the command line or config file.
 import sys
-from contextlib import asynccontextmanager
 
-from invokeai.app.api.no_cache_staticfiles import NoCacheStaticFiles
+from invokeai.app.invocations.model import ModelIdentifierField
+from invokeai.app.services.session_processor.session_processor_common import ProgressImage
 from invokeai.version.invokeai_version import __version__
 
-from .invocations.fields import InputFieldJSONSchemaExtra, OutputFieldJSONSchemaExtra
 from .services.config import InvokeAIAppConfig
 
 app_config = InvokeAIAppConfig.get_config()
@@ -20,6 +19,7 @@ if True:  # hack to make flake8 happy with imports coming after setting up the c
     import asyncio
     import mimetypes
     import socket
+    from contextlib import asynccontextmanager
     from inspect import signature
     from pathlib import Path
     from typing import Any
@@ -40,6 +40,7 @@ if True:  # hack to make flake8 happy with imports coming after setting up the c
     # noinspection PyUnresolvedReferences
     import invokeai.backend.util.hotfixes  # noqa: F401 (monkeypatching on import)
     import invokeai.frontend.web as web_dir
+    from invokeai.app.api.no_cache_staticfiles import NoCacheStaticFiles
 
     from ..backend.util.logging import InvokeAILogger
     from .api.dependencies import ApiDependencies
@@ -59,6 +60,7 @@ if True:  # hack to make flake8 happy with imports coming after setting up the c
         BaseInvocation,
         UIConfigBase,
     )
+    from .invocations.fields import InputFieldJSONSchemaExtra, OutputFieldJSONSchemaExtra
 
     if is_mps_available():
         import invokeai.backend.util.mps_fixes  # noqa: F401 (monkeypatching on import)
@@ -156,17 +158,19 @@ def custom_openapi() -> dict[str, Any]:
         openapi_schema["components"]["schemas"][schema_key] = output_schema
         openapi_schema["components"]["schemas"][schema_key]["class"] = "output"
 
-    # Add Node Editor UI helper schemas
-    ui_config_schemas = models_json_schema(
+    # Some models don't end up in the schemas as standalone definitions
+    additional_schemas = models_json_schema(
         [
             (UIConfigBase, "serialization"),
             (InputFieldJSONSchemaExtra, "serialization"),
             (OutputFieldJSONSchemaExtra, "serialization"),
+            (ModelIdentifierField, "serialization"),
+            (ProgressImage, "serialization"),
         ],
         ref_template="#/components/schemas/{model}",
     )
-    for schema_key, ui_config_schema in ui_config_schemas[1]["$defs"].items():
-        openapi_schema["components"]["schemas"][schema_key] = ui_config_schema
+    for schema_key, schema_json in additional_schemas[1]["$defs"].items():
+        openapi_schema["components"]["schemas"][schema_key] = schema_json
 
     # Add a reference to the output type to additionalProperties of the invoker schema
     for invoker in all_invocations:

invokeai/app/invocations/compel.py

@@ -5,15 +5,7 @@ from compel import Compel, ReturnedEmbeddingsType
 from compel.prompt_parser import Blend, Conjunction, CrossAttentionControlSubstitute, FlattenedPrompt, Fragment
 from transformers import CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer
 
-from invokeai.app.invocations.fields import (
-    ConditioningField,
-    FieldDescriptions,
-    Input,
-    InputField,
-    MaskField,
-    OutputField,
-    UIComponent,
-)
+from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIComponent
 from invokeai.app.invocations.primitives import ConditioningOutput
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.ti_utils import generate_ti_list
@@ -28,7 +20,7 @@ from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
 from invokeai.backend.util.devices import torch_dtype
 
 from .baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
-from .model import ClipField
+from .model import CLIPField
 
 # unconditioned: Optional[torch.Tensor]
 
@@ -44,7 +36,7 @@ from .model import ClipField
     title="Prompt",
     tags=["prompt", "compel"],
     category="conditioning",
-    version="1.2.0",
+    version="1.0.1",
 )
 class CompelInvocation(BaseInvocation):
     """Parse prompt using compel package to conditioning."""
@@ -54,28 +46,24 @@ class CompelInvocation(BaseInvocation):
         description=FieldDescriptions.compel_prompt,
         ui_component=UIComponent.Textarea,
     )
-    clip: ClipField = InputField(
+    clip: CLIPField = InputField(
         title="CLIP",
         description=FieldDescriptions.clip,
         input=Input.Connection,
     )
-    mask: Optional[MaskField] = InputField(
-        default=None, description="A mask defining the region that this conditioning prompt applies to."
-    )
-    mask_weight: float = InputField(default=1.0, description="")
 
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> ConditioningOutput:
-        tokenizer_info = context.models.load(**self.clip.tokenizer.model_dump())
+        tokenizer_info = context.models.load(self.clip.tokenizer)
         tokenizer_model = tokenizer_info.model
         assert isinstance(tokenizer_model, CLIPTokenizer)
-        text_encoder_info = context.models.load(**self.clip.text_encoder.model_dump())
+        text_encoder_info = context.models.load(self.clip.text_encoder)
         text_encoder_model = text_encoder_info.model
         assert isinstance(text_encoder_model, CLIPTextModel)
 
         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.models.load(lora.lora)
                 assert isinstance(lora_info.model, LoRAModelRaw)
                 yield (lora_info.model, lora.weight)
                 del lora_info
@@ -130,13 +118,7 @@ class CompelInvocation(BaseInvocation):
 
         conditioning_name = context.conditioning.save(conditioning_data)
 
-        return ConditioningOutput(
-            conditioning=ConditioningField(
-                conditioning_name=conditioning_name,
-                mask=self.mask,
-                mask_weight=self.mask_weight,
-            )
-        )
+        return ConditioningOutput.build(conditioning_name)
 
 
 class SDXLPromptInvocationBase:
@@ -145,16 +127,16 @@ class SDXLPromptInvocationBase:
     def run_clip_compel(
         self,
         context: InvocationContext,
-        clip_field: ClipField,
+        clip_field: CLIPField,
         prompt: str,
         get_pooled: bool,
         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())
+        tokenizer_info = context.models.load(clip_field.tokenizer)
         tokenizer_model = tokenizer_info.model
         assert isinstance(tokenizer_model, CLIPTokenizer)
-        text_encoder_info = context.models.load(**clip_field.text_encoder.model_dump())
+        text_encoder_info = context.models.load(clip_field.text_encoder)
         text_encoder_model = text_encoder_info.model
         assert isinstance(text_encoder_model, (CLIPTextModel, CLIPTextModelWithProjection))
 
@@ -181,7 +163,7 @@ 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.models.load(lora.lora)
                 lora_model = lora_info.model
                 assert isinstance(lora_model, LoRAModelRaw)
                 yield (lora_model, lora.weight)
@@ -250,7 +232,7 @@ class SDXLPromptInvocationBase:
     title="SDXL Prompt",
     tags=["sdxl", "compel", "prompt"],
     category="conditioning",
-    version="1.2.0",
+    version="1.0.1",
 )
 class SDXLCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase):
     """Parse prompt using compel package to conditioning."""
@@ -271,13 +253,8 @@ class SDXLCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase):
     crop_left: int = InputField(default=0, description="")
     target_width: int = InputField(default=1024, description="")
     target_height: int = InputField(default=1024, description="")
-    clip: ClipField = InputField(description=FieldDescriptions.clip, input=Input.Connection, title="CLIP 1")
-    clip2: ClipField = InputField(description=FieldDescriptions.clip, input=Input.Connection, title="CLIP 2")
-
-    mask: Optional[MaskField] = InputField(
-        default=None, description="A mask defining the region that this conditioning prompt applies to."
-    )
-    mask_weight: float = InputField(default=1.0, description="")
+    clip: CLIPField = InputField(description=FieldDescriptions.clip, input=Input.Connection, title="CLIP 1")
+    clip2: CLIPField = InputField(description=FieldDescriptions.clip, input=Input.Connection, title="CLIP 2")
 
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> ConditioningOutput:
@@ -340,13 +317,7 @@ class SDXLCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase):
 
         conditioning_name = context.conditioning.save(conditioning_data)
 
-        return ConditioningOutput(
-            conditioning=ConditioningField(
-                conditioning_name=conditioning_name,
-                mask=self.mask,
-                mask_weight=self.mask_weight,
-            )
-        )
+        return ConditioningOutput.build(conditioning_name)
 
 
 @invocation(
@@ -369,7 +340,7 @@ class SDXLRefinerCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase
     crop_top: int = InputField(default=0, description="")
     crop_left: int = InputField(default=0, description="")
     aesthetic_score: float = InputField(default=6.0, description=FieldDescriptions.sdxl_aesthetic)
-    clip2: ClipField = InputField(description=FieldDescriptions.clip, input=Input.Connection)
+    clip2: CLIPField = InputField(description=FieldDescriptions.clip, input=Input.Connection)
 
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> ConditioningOutput:
@@ -395,14 +366,14 @@ class SDXLRefinerCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase
 
         conditioning_name = context.conditioning.save(conditioning_data)
 
-        return ConditioningOutput(conditioning=ConditioningField(conditioning_name=conditioning_name, mask_weight=1.0))
+        return ConditioningOutput.build(conditioning_name)
 
 
 @invocation_output("clip_skip_output")
-class ClipSkipInvocationOutput(BaseInvocationOutput):
-    """Clip skip node output"""
+class CLIPSkipInvocationOutput(BaseInvocationOutput):
+    """CLIP skip node output"""
 
-    clip: Optional[ClipField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP")
+    clip: Optional[CLIPField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP")
 
 
 @invocation(
@@ -412,15 +383,15 @@ class ClipSkipInvocationOutput(BaseInvocationOutput):
     category="conditioning",
     version="1.0.0",
 )
-class ClipSkipInvocation(BaseInvocation):
+class CLIPSkipInvocation(BaseInvocation):
     """Skip layers in clip text_encoder model."""
 
-    clip: ClipField = InputField(description=FieldDescriptions.clip, input=Input.Connection, title="CLIP")
+    clip: CLIPField = InputField(description=FieldDescriptions.clip, input=Input.Connection, title="CLIP")
     skipped_layers: int = InputField(default=0, ge=0, description=FieldDescriptions.skipped_layers)
 
-    def invoke(self, context: InvocationContext) -> ClipSkipInvocationOutput:
+    def invoke(self, context: InvocationContext) -> CLIPSkipInvocationOutput:
         self.clip.skipped_layers += self.skipped_layers
-        return ClipSkipInvocationOutput(
+        return CLIPSkipInvocationOutput(
             clip=self.clip,
         )
 

invokeai/app/invocations/conditioning.py

@@ -1,40 +0,0 @@
-import torch
-
-from invokeai.app.invocations.baseinvocation import (
-    BaseInvocation,
-    InvocationContext,
-    invocation,
-)
-from invokeai.app.invocations.fields import InputField, WithMetadata
-from invokeai.app.invocations.primitives import MaskField, MaskOutput
-
-
-@invocation(
-    "rectangle_mask",
-    title="Create Rectangle Mask",
-    tags=["conditioning"],
-    category="conditioning",
-    version="1.0.0",
-)
-class RectangleMaskInvocation(BaseInvocation, WithMetadata):
-    """Create a rectangular mask."""
-
-    height: int = InputField(description="The height of the entire mask.")
-    width: int = InputField(description="The width of the entire mask.")
-    y_top: int = InputField(description="The top y-coordinate of the rectangular masked region (inclusive).")
-    x_left: int = InputField(description="The left x-coordinate of the rectangular masked region (inclusive).")
-    rectangle_height: int = InputField(description="The height of the rectangular masked region.")
-    rectangle_width: int = InputField(description="The width of the rectangular masked region.")
-
-    def invoke(self, context: InvocationContext) -> MaskOutput:
-        mask = torch.zeros((1, self.height, self.width), dtype=torch.bool)
-        mask[
-            :, self.y_top : self.y_top + self.rectangle_height, self.x_left : self.x_left + self.rectangle_width
-        ] = True
-
-        mask_name = context.tensors.save(mask)
-        return MaskOutput(
-            mask=MaskField(mask_name=mask_name),
-            width=self.width,
-            height=self.height,
-        )

invokeai/app/invocations/controlnet_image_processors.py

@@ -31,9 +31,11 @@ from invokeai.app.invocations.fields import (
     Input,
     InputField,
     OutputField,
+    UIType,
     WithBoard,
     WithMetadata,
 )
+from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import ImageOutput
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
 from invokeai.app.services.shared.invocation_context import InvocationContext
@@ -51,15 +53,9 @@ CONTROLNET_RESIZE_VALUES = Literal[
 ]
 
 
-class ControlNetModelField(BaseModel):
-    """ControlNet model field"""
-
-    key: str = Field(description="Model config record key for the ControlNet model")
-
-
 class ControlField(BaseModel):
     image: ImageField = Field(description="The control image")
-    control_model: ControlNetModelField = Field(description="The ControlNet model to use")
+    control_model: ModelIdentifierField = Field(description="The ControlNet model to use")
     control_weight: Union[float, List[float]] = Field(default=1, description="The weight given to the ControlNet")
     begin_step_percent: float = Field(
         default=0, ge=0, le=1, description="When the ControlNet is first applied (% of total steps)"
@@ -95,7 +91,9 @@ class ControlNetInvocation(BaseInvocation):
     """Collects ControlNet info to pass to other nodes"""
 
     image: ImageField = InputField(description="The control image")
-    control_model: ControlNetModelField = InputField(description=FieldDescriptions.controlnet_model, input=Input.Direct)
+    control_model: ModelIdentifierField = InputField(
+        description=FieldDescriptions.controlnet_model, input=Input.Direct, ui_type=UIType.ControlNetModel
+    )
     control_weight: Union[float, List[float]] = InputField(
         default=1.0, ge=-1, le=2, description="The weight given to the ControlNet"
     )

invokeai/app/invocations/fields.py

@@ -39,13 +39,15 @@ class UIType(str, Enum, metaclass=MetaEnum):
     """
 
     # region Model Field Types
+    MainModel = "MainModelField"
     SDXLMainModel = "SDXLMainModelField"
     SDXLRefinerModel = "SDXLRefinerModelField"
     ONNXModel = "ONNXModelField"
-    VaeModel = "VAEModelField"
+    VAEModel = "VAEModelField"
     LoRAModel = "LoRAModelField"
     ControlNetModel = "ControlNetModelField"
     IPAdapterModel = "IPAdapterModelField"
+    T2IAdapterModel = "T2IAdapterModelField"
     # endregion
 
     # region Misc Field Types
@@ -86,7 +88,6 @@ class UIType(str, Enum, metaclass=MetaEnum):
     IntegerPolymorphic = "DEPRECATED_IntegerPolymorphic"
     LatentsPolymorphic = "DEPRECATED_LatentsPolymorphic"
     StringPolymorphic = "DEPRECATED_StringPolymorphic"
-    MainModel = "DEPRECATED_MainModel"
     UNet = "DEPRECATED_UNet"
     Vae = "DEPRECATED_Vae"
     CLIP = "DEPRECATED_CLIP"
@@ -194,12 +195,6 @@ class BoardField(BaseModel):
     board_id: str = Field(description="The id of the board")
 
 
-class MaskField(BaseModel):
-    """A mask primitive field."""
-
-    mask_name: str = Field(description="The name of the mask.")
-
-
 class DenoiseMaskField(BaseModel):
     """An inpaint mask field"""
 
@@ -231,15 +226,10 @@ class ConditioningField(BaseModel):
     """A conditioning tensor primitive value"""
 
     conditioning_name: str = Field(description="The name of conditioning tensor")
-    mask: Optional[MaskField] = Field(
-        default=None,
-        description="The bool mask associated with this conditioning tensor. Excluded regions should be set to False, "
-        "included regions should be set to True.",
-    )
-    mask_weight: float = Field(description="")
+    # endregion
 
 
-class MetadataField(RootModel):
+class MetadataField(RootModel[dict[str, Any]]):
     """
     Pydantic model for metadata with custom root of type dict[str, Any].
     Metadata is stored without a strict schema.

invokeai/app/invocations/ip_adapter.py

@@ -10,26 +10,18 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIType
+from invokeai.app.invocations.model import ModelIdentifierField
 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
-
-
-# LS: Consider moving these two classes into model.py
-class IPAdapterModelField(BaseModel):
-    key: str = Field(description="Key to the IP-Adapter model")
-
-
-class CLIPVisionModelField(BaseModel):
-    key: str = Field(description="Key to the CLIP Vision image encoder model")
+from invokeai.backend.model_manager.config import BaseModelType, IPAdapterConfig, ModelType
 
 
 class IPAdapterField(BaseModel):
     image: Union[ImageField, List[ImageField]] = Field(description="The IP-Adapter image prompt(s).")
-    ip_adapter_model: IPAdapterModelField = Field(description="The IP-Adapter model to use.")
-    image_encoder_model: CLIPVisionModelField = Field(description="The name of the CLIP image encoder model.")
+    ip_adapter_model: ModelIdentifierField = Field(description="The IP-Adapter model to use.")
+    image_encoder_model: ModelIdentifierField = Field(description="The name of the CLIP image encoder model.")
     weight: Union[float, List[float]] = Field(default=1, description="The weight given to the ControlNet")
     begin_step_percent: float = Field(
         default=0, ge=0, le=1, description="When the IP-Adapter is first applied (% of total steps)"
@@ -62,8 +54,12 @@ class IPAdapterInvocation(BaseInvocation):
 
     # Inputs
     image: Union[ImageField, List[ImageField]] = InputField(description="The IP-Adapter image prompt(s).")
-    ip_adapter_model: IPAdapterModelField = InputField(
-        description="The IP-Adapter model.", title="IP-Adapter Model", input=Input.Direct, ui_order=-1
+    ip_adapter_model: ModelIdentifierField = InputField(
+        description="The IP-Adapter model.",
+        title="IP-Adapter Model",
+        input=Input.Direct,
+        ui_order=-1,
+        ui_type=UIType.IPAdapterModel,
     )
 
     weight: Union[float, List[float]] = InputField(
@@ -90,18 +86,18 @@ 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)
+        assert isinstance(ip_adapter_info, IPAdapterConfig)
         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(
             name=image_encoder_model_name, base=BaseModelType.Any, type=ModelType.CLIPVision
         )
         assert len(image_encoder_models) == 1
-        image_encoder_model = CLIPVisionModelField(key=image_encoder_models[0].key)
         return IPAdapterOutput(
             ip_adapter=IPAdapterField(
                 image=self.image,
                 ip_adapter_model=self.ip_adapter_model,
-                image_encoder_model=image_encoder_model,
+                image_encoder_model=ModelIdentifierField.from_config(image_encoder_models[0]),
                 weight=self.weight,
                 begin_step_percent=self.begin_step_percent,
                 end_step_percent=self.end_step_percent,

invokeai/app/invocations/latent.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2023 Kyle Schouviller (https://github.com/kyle0654)
-import inspect
+
 import math
 from contextlib import ExitStack
 from functools import singledispatchmethod
@@ -9,7 +9,6 @@ import einops
 import numpy as np
 import numpy.typing as npt
 import torch
-import torchvision
 import torchvision.transforms as T
 from diffusers import AutoencoderKL, AutoencoderTiny
 from diffusers.configuration_utils import ConfigMixin
@@ -27,6 +26,7 @@ from diffusers.schedulers import SchedulerMixin as Scheduler
 from PIL import Image, ImageFilter
 from pydantic import field_validator
 from torchvision.transforms.functional import resize as tv_resize
+from transformers import CLIPVisionModelWithProjection
 
 from invokeai.app.invocations.constants import LATENT_SCALE_FACTOR, SCHEDULER_NAME_VALUES
 from invokeai.app.invocations.fields import (
@@ -56,14 +56,7 @@ from invokeai.backend.lora import LoRAModelRaw
 from invokeai.backend.model_manager import BaseModelType, LoadedModel
 from invokeai.backend.model_patcher import ModelPatcher
 from invokeai.backend.stable_diffusion import PipelineIntermediateState, set_seamless
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
-    BasicConditioningInfo,
-    IPAdapterConditioningInfo,
-    Range,
-    SDXLConditioningInfo,
-    TextConditioningData,
-    TextConditioningRegions,
-)
+from invokeai.backend.stable_diffusion.diffusion.conditioning_data import ConditioningData, IPAdapterConditioningInfo
 from invokeai.backend.util.silence_warnings import SilenceWarnings
 
 from ...backend.stable_diffusion.diffusers_pipeline import (
@@ -82,7 +75,7 @@ from .baseinvocation import (
     invocation_output,
 )
 from .controlnet_image_processors import ControlField
-from .model import ModelInfo, UNetField, VaeField
+from .model import ModelIdentifierField, UNetField, VAEField
 
 if choose_torch_device() == torch.device("mps"):
     from torch import mps
@@ -125,7 +118,7 @@ class SchedulerInvocation(BaseInvocation):
 class CreateDenoiseMaskInvocation(BaseInvocation):
     """Creates mask for denoising model run."""
 
-    vae: VaeField = InputField(description=FieldDescriptions.vae, input=Input.Connection, ui_order=0)
+    vae: VAEField = InputField(description=FieldDescriptions.vae, input=Input.Connection, ui_order=0)
     image: Optional[ImageField] = InputField(default=None, description="Image which will be masked", ui_order=1)
     mask: ImageField = InputField(description="The mask to use when pasting", ui_order=2)
     tiled: bool = InputField(default=False, description=FieldDescriptions.tiled, ui_order=3)
@@ -160,7 +153,7 @@ class CreateDenoiseMaskInvocation(BaseInvocation):
         )
 
         if image_tensor is not None:
-            vae_info = context.models.load(**self.vae.vae.model_dump())
+            vae_info = context.models.load(self.vae.vae)
 
             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)
@@ -251,12 +244,12 @@ class CreateGradientMaskInvocation(BaseInvocation):
 
 def get_scheduler(
     context: InvocationContext,
-    scheduler_info: ModelInfo,
+    scheduler_info: ModelIdentifierField,
     scheduler_name: str,
     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.models.load(scheduler_info)
     with orig_scheduler_info as orig_scheduler:
         scheduler_config = orig_scheduler.config
 
@@ -291,11 +284,11 @@ def get_scheduler(
 class DenoiseLatentsInvocation(BaseInvocation):
     """Denoises noisy latents to decodable images"""
 
-    positive_conditioning: Union[ConditioningField, list[ConditioningField]] = InputField(
+    positive_conditioning: ConditioningField = InputField(
         description=FieldDescriptions.positive_cond, input=Input.Connection, ui_order=0
     )
-    negative_conditioning: Union[ConditioningField, list[ConditioningField]] = InputField(
-        description=FieldDescriptions.negative_cond, input=Input.Connection, ui_order=0
+    negative_conditioning: ConditioningField = InputField(
+        description=FieldDescriptions.negative_cond, input=Input.Connection, ui_order=1
     )
     noise: Optional[LatentsField] = InputField(
         default=None,
@@ -372,191 +365,34 @@ class DenoiseLatentsInvocation(BaseInvocation):
                 raise ValueError("cfg_scale must be greater than 1")
         return v
 
-    def _get_text_embeddings_and_masks(
-        self,
-        cond_list: list[ConditioningField],
-        context: InvocationContext,
-        device: torch.device,
-        dtype: torch.dtype,
-    ) -> tuple[Union[list[BasicConditioningInfo], list[SDXLConditioningInfo]], list[Optional[torch.Tensor]]]:
-        """Get the text embeddings and masks from the input conditioning fields."""
-        text_embeddings: Union[list[BasicConditioningInfo], list[SDXLConditioningInfo]] = []
-        text_embeddings_masks: list[Optional[torch.Tensor]] = []
-        for cond in cond_list:
-            cond_data = context.conditioning.load(cond.conditioning_name)
-            text_embeddings.append(cond_data.conditionings[0].to(device=device, dtype=dtype))
-
-            mask = cond.mask
-            if mask is not None:
-                mask = context.tensors.load(mask.mask_name)
-            text_embeddings_masks.append(mask)
-
-        return text_embeddings, text_embeddings_masks
-
-    def _preprocess_regional_prompt_mask(
-        self, mask: Optional[torch.Tensor], target_height: int, target_width: int
-    ) -> torch.Tensor:
-        """Preprocess a regional prompt mask to match the target height and width.
-
-        If mask is None, returns a mask of all ones with the target height and width.
-        If mask is not None, resizes the mask to the target height and width using nearest neighbor interpolation.
-
-        Returns:
-            torch.Tensor: The processed mask. dtype: torch.bool, shape: (1, 1, target_height, target_width).
-        """
-        if mask is None:
-            return torch.ones((1, 1, target_height, target_width), dtype=torch.bool)
-
-        tf = torchvision.transforms.Resize(
-            (target_height, target_width), interpolation=torchvision.transforms.InterpolationMode.NEAREST
-        )
-        mask = mask.unsqueeze(0)  # Shape: (1, h, w) -> (1, 1, h, w)
-        mask = tf(mask)
-
-        return mask
-
-    def concat_regional_text_embeddings(
-        self,
-        text_conditionings: Union[list[BasicConditioningInfo], list[SDXLConditioningInfo]],
-        masks: Optional[list[Optional[torch.Tensor]]],
-        conditioning_fields: list[ConditioningField],
-        latent_height: int,
-        latent_width: int,
-    ) -> tuple[Union[BasicConditioningInfo, SDXLConditioningInfo], Optional[TextConditioningRegions]]:
-        """Concatenate regional text embeddings into a single embedding and track the region masks accordingly."""
-        if masks is None:
-            masks = [None] * len(text_conditionings)
-        assert len(text_conditionings) == len(masks)
-
-        is_sdxl = type(text_conditionings[0]) is SDXLConditioningInfo
-
-        all_masks_are_none = all(mask is None for mask in masks)
-
-        text_embedding = []
-        pooled_embedding = None
-        add_time_ids = None
-        cur_text_embedding_len = 0
-        processed_masks = []
-        embedding_ranges = []
-        extra_conditioning = None
-
-        for prompt_idx, text_embedding_info in enumerate(text_conditionings):
-            mask = masks[prompt_idx]
-            if (
-                text_embedding_info.extra_conditioning is not None
-                and text_embedding_info.extra_conditioning.wants_cross_attention_control
-            ):
-                extra_conditioning = text_embedding_info.extra_conditioning
-
-            if is_sdxl:
-                # We choose a random SDXLConditioningInfo's pooled_embeds and add_time_ids here, with a preference for
-                # prompts without a mask. We prefer prompts without a mask, because they are more likely to contain
-                # global prompt information.  In an ideal case, there should be exactly one global prompt without a
-                # mask, but we don't enforce this.
-
-                # HACK(ryand): The fact that we have to choose a single pooled_embedding and add_time_ids here is a
-                # fundamental interface issue. The SDXL Compel nodes are not designed to be used in the way that we use
-                # them for regional prompting. Ideally, the DenoiseLatents invocation should accept a single
-                # pooled_embeds tensor and a list of standard text embeds with region masks. This change would be a
-                # pretty major breaking change to a popular node, so for now we use this hack.
-                if pooled_embedding is None or mask is None:
-                    pooled_embedding = text_embedding_info.pooled_embeds
-                if add_time_ids is None or mask is None:
-                    add_time_ids = text_embedding_info.add_time_ids
-
-            text_embedding.append(text_embedding_info.embeds)
-            if not all_masks_are_none:
-                # embedding_ranges.append(
-                #     Range(
-                #         start=cur_text_embedding_len, end=cur_text_embedding_len + text_embedding_info.embeds.shape[1]
-                #     )
-                # )
-                # HACK(ryand): Contrary to its name, tokens_count_including_eos_bos does not seem to include eos and bos
-                # in the count.
-                embedding_ranges.append(
-                    Range(
-                        start=cur_text_embedding_len + 1,
-                        end=cur_text_embedding_len
-                        + text_embedding_info.extra_conditioning.tokens_count_including_eos_bos,
-                    )
-                )
-                processed_masks.append(self._preprocess_regional_prompt_mask(mask, latent_height, latent_width))
-
-            cur_text_embedding_len += text_embedding_info.embeds.shape[1]
-
-        text_embedding = torch.cat(text_embedding, dim=1)
-        assert len(text_embedding.shape) == 3  # batch_size, seq_len, token_len
-
-        regions = None
-        if not all_masks_are_none:
-            regions = TextConditioningRegions(
-                masks=torch.cat(processed_masks, dim=1),
-                ranges=embedding_ranges,
-                mask_weights=[x.mask_weight for x in conditioning_fields],
-            )
-
-        if extra_conditioning is not None and len(text_conditionings) > 1:
-            raise ValueError(
-                "Prompt-to-prompt cross-attention control (a.k.a. `swap()`) is not supported when using multiple "
-                "prompts."
-            )
-
-        if is_sdxl:
-            return SDXLConditioningInfo(
-                embeds=text_embedding,
-                extra_conditioning=extra_conditioning,
-                pooled_embeds=pooled_embedding,
-                add_time_ids=add_time_ids,
-            ), regions
-        return BasicConditioningInfo(
-            embeds=text_embedding,
-            extra_conditioning=extra_conditioning,
-        ), regions
-
     def get_conditioning_data(
         self,
         context: InvocationContext,
+        scheduler: Scheduler,
         unet: UNet2DConditionModel,
-        latent_height: int,
-        latent_width: int,
-    ) -> TextConditioningData:
-        # Normalize self.positive_conditioning and self.negative_conditioning to lists.
-        cond_list = self.positive_conditioning
-        if not isinstance(cond_list, list):
-            cond_list = [cond_list]
-        uncond_list = self.negative_conditioning
-        if not isinstance(uncond_list, list):
-            uncond_list = [uncond_list]
+        seed: int,
+    ) -> ConditioningData:
+        positive_cond_data = context.conditioning.load(self.positive_conditioning.conditioning_name)
+        c = positive_cond_data.conditionings[0].to(device=unet.device, dtype=unet.dtype)
 
-        cond_text_embeddings, cond_text_embedding_masks = self._get_text_embeddings_and_masks(
-            cond_list, context, unet.device, unet.dtype
-        )
+        negative_cond_data = context.conditioning.load(self.negative_conditioning.conditioning_name)
+        uc = negative_cond_data.conditionings[0].to(device=unet.device, dtype=unet.dtype)
 
-        uncond_text_embeddings, uncond_text_embedding_masks = self._get_text_embeddings_and_masks(
-            uncond_list, context, unet.device, unet.dtype
-        )
-        cond_text_embedding, cond_regions = self.concat_regional_text_embeddings(
-            text_conditionings=cond_text_embeddings,
-            masks=cond_text_embedding_masks,
-            conditioning_fields=cond_list,
-            latent_height=latent_height,
-            latent_width=latent_width,
-        )
-        uncond_text_embedding, uncond_regions = self.concat_regional_text_embeddings(
-            text_conditionings=uncond_text_embeddings,
-            masks=uncond_text_embedding_masks,
-            conditioning_fields=uncond_list,
-            latent_height=latent_height,
-            latent_width=latent_width,
-        )
-        conditioning_data = TextConditioningData(
-            uncond_text=uncond_text_embedding,
-            cond_text=cond_text_embedding,
-            uncond_regions=uncond_regions,
-            cond_regions=cond_regions,
+        conditioning_data = ConditioningData(
+            unconditioned_embeddings=uc,
+            text_embeddings=c,
             guidance_scale=self.cfg_scale,
             guidance_rescale_multiplier=self.cfg_rescale_multiplier,
         )
+
+        conditioning_data = conditioning_data.add_scheduler_args_if_applicable(  # FIXME
+            scheduler,
+            # for ddim scheduler
+            eta=0.0,  # ddim_eta
+            # for ancestral and sde schedulers
+            # flip all bits to have noise different from initial
+            generator=torch.Generator(device=unet.device).manual_seed(seed ^ 0xFFFFFFFF),
+        )
         return conditioning_data
 
     def create_pipeline(
@@ -619,7 +455,7 @@ 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.models.load(control_info.control_model))
 
             # control_models.append(control_model)
             control_image_field = control_info.image
@@ -661,6 +497,7 @@ class DenoiseLatentsInvocation(BaseInvocation):
         self,
         context: InvocationContext,
         ip_adapter: Optional[Union[IPAdapterField, list[IPAdapterField]]],
+        conditioning_data: ConditioningData,
         exit_stack: ExitStack,
     ) -> Optional[list[IPAdapterData]]:
         """If IP-Adapter is enabled, then this function loads the requisite models, and adds the image prompt embeddings
@@ -677,13 +514,13 @@ class DenoiseLatentsInvocation(BaseInvocation):
             return None
 
         ip_adapter_data_list = []
+        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.models.load(single_ip_adapter.ip_adapter_model)
             )
 
-            image_encoder_model_info = context.models.load(key=single_ip_adapter.image_encoder_model.key)
-
+            image_encoder_model_info = context.models.load(single_ip_adapter.image_encoder_model)
             # `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):
@@ -694,18 +531,22 @@ class DenoiseLatentsInvocation(BaseInvocation):
             # 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.
             with image_encoder_model_info as image_encoder_model:
+                assert isinstance(image_encoder_model, CLIPVisionModelWithProjection)
                 # Get image embeddings from CLIP and ImageProjModel.
                 image_prompt_embeds, uncond_image_prompt_embeds = ip_adapter_model.get_image_embeds(
                     single_ipa_images, image_encoder_model
                 )
 
+                conditioning_data.ip_adapter_conditioning.append(
+                    IPAdapterConditioningInfo(image_prompt_embeds, uncond_image_prompt_embeds)
+                )
+
             ip_adapter_data_list.append(
                 IPAdapterData(
                     ip_adapter_model=ip_adapter_model,
                     weight=single_ip_adapter.weight,
                     begin_step_percent=single_ip_adapter.begin_step_percent,
                     end_step_percent=single_ip_adapter.end_step_percent,
-                    ip_adapter_conditioning=IPAdapterConditioningInfo(image_prompt_embeds, uncond_image_prompt_embeds),
                 )
             )
 
@@ -730,8 +571,8 @@ 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)
+            t2i_adapter_model_config = context.models.get_config(t2i_adapter_field.t2i_adapter_model.key)
+            t2i_adapter_loaded_model = context.models.load(t2i_adapter_field.t2i_adapter_model)
             image = context.images.get_pil(t2i_adapter_field.image.image_name)
 
             # The max_unet_downscale is the maximum amount that the UNet model downscales the latent image internally.
@@ -795,7 +636,6 @@ class DenoiseLatentsInvocation(BaseInvocation):
         steps: int,
         denoising_start: float,
         denoising_end: float,
-        seed: int,
     ) -> Tuple[int, List[int], int]:
         assert isinstance(scheduler, ConfigMixin)
         if scheduler.config.get("cpu_only", False):
@@ -824,15 +664,7 @@ class DenoiseLatentsInvocation(BaseInvocation):
         timesteps = timesteps[t_start_idx : t_start_idx + t_end_idx]
         num_inference_steps = len(timesteps) // scheduler.order
 
-        scheduler_step_kwargs = {}
-        scheduler_step_signature = inspect.signature(scheduler.step)
-        if "generator" in scheduler_step_signature.parameters:
-            # At some point, someone decided that schedulers that accept a generator should use the original seed with
-            # all bits flipped. I don't know the original rationale for this, but now we must keep it like this for
-            # reproducibility.
-            scheduler_step_kwargs = {"generator": torch.Generator(device=device).manual_seed(seed ^ 0xFFFFFFFF)}
-
-        return num_inference_steps, timesteps, init_timestep, scheduler_step_kwargs
+        return num_inference_steps, timesteps, init_timestep
 
     def prep_inpaint_mask(
         self, context: InvocationContext, latents: torch.Tensor
@@ -845,7 +677,7 @@ class DenoiseLatentsInvocation(BaseInvocation):
         if self.denoise_mask.masked_latents_name is not None:
             masked_latents = context.tensors.load(self.denoise_mask.masked_latents_name)
         else:
-            masked_latents = None
+            masked_latents = torch.where(mask < 0.5, 0.0, latents)
 
         return 1 - mask, masked_latents, self.denoise_mask.gradient
 
@@ -893,12 +725,13 @@ class DenoiseLatentsInvocation(BaseInvocation):
 
             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.models.load(lora.lora)
+                    assert isinstance(lora_info.model, LoRAModelRaw)
                     yield (lora_info.model, lora.weight)
                     del lora_info
                 return
 
-            unet_info = context.models.load(**self.unet.unet.model_dump())
+            unet_info = context.models.load(self.unet.unet)
             assert isinstance(unet_info.model, UNet2DConditionModel)
             with (
                 ExitStack() as exit_stack,
@@ -925,10 +758,7 @@ class DenoiseLatentsInvocation(BaseInvocation):
                 )
 
                 pipeline = self.create_pipeline(unet, scheduler)
-                _, _, latent_height, latent_width = latents.shape
-                conditioning_data = self.get_conditioning_data(
-                    context=context, unet=unet, latent_height=latent_height, latent_width=latent_width
-                )
+                conditioning_data = self.get_conditioning_data(context, scheduler, unet, seed)
 
                 controlnet_data = self.prep_control_data(
                     context=context,
@@ -942,16 +772,16 @@ class DenoiseLatentsInvocation(BaseInvocation):
                 ip_adapter_data = self.prep_ip_adapter_data(
                     context=context,
                     ip_adapter=self.ip_adapter,
+                    conditioning_data=conditioning_data,
                     exit_stack=exit_stack,
                 )
 
-                num_inference_steps, timesteps, init_timestep, scheduler_step_kwargs = self.init_scheduler(
+                num_inference_steps, timesteps, init_timestep = self.init_scheduler(
                     scheduler,
                     device=unet.device,
                     steps=self.steps,
                     denoising_start=self.denoising_start,
                     denoising_end=self.denoising_end,
-                    seed=seed,
                 )
 
                 result_latents = pipeline.latents_from_embeddings(
@@ -964,7 +794,6 @@ class DenoiseLatentsInvocation(BaseInvocation):
                     masked_latents=masked_latents,
                     gradient_mask=gradient_mask,
                     num_inference_steps=num_inference_steps,
-                    scheduler_step_kwargs=scheduler_step_kwargs,
                     conditioning_data=conditioning_data,
                     control_data=controlnet_data,
                     ip_adapter_data=ip_adapter_data,
@@ -996,7 +825,7 @@ class LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
         description=FieldDescriptions.latents,
         input=Input.Connection,
     )
-    vae: VaeField = InputField(
+    vae: VAEField = InputField(
         description=FieldDescriptions.vae,
         input=Input.Connection,
     )
@@ -1007,8 +836,8 @@ class LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
     def invoke(self, context: InvocationContext) -> ImageOutput:
         latents = context.tensors.load(self.latents.latents_name)
 
-        vae_info = context.models.load(**self.vae.vae.model_dump())
-
+        vae_info = context.models.load(self.vae.vae)
+        assert isinstance(vae_info.model, (UNet2DConditionModel, AutoencoderKL))
         with set_seamless(vae_info.model, self.vae.seamless_axes), vae_info as vae:
             assert isinstance(vae, torch.nn.Module)
             latents = latents.to(vae.device)
@@ -1174,7 +1003,7 @@ class ImageToLatentsInvocation(BaseInvocation):
     image: ImageField = InputField(
         description="The image to encode",
     )
-    vae: VaeField = InputField(
+    vae: VAEField = InputField(
         description=FieldDescriptions.vae,
         input=Input.Connection,
     )
@@ -1230,7 +1059,7 @@ class ImageToLatentsInvocation(BaseInvocation):
     def invoke(self, context: InvocationContext) -> LatentsOutput:
         image = context.images.get_pil(self.image.image_name)
 
-        vae_info = context.models.load(**self.vae.vae.model_dump())
+        vae_info = context.models.load(self.vae.vae)
 
         image_tensor = image_resized_to_grid_as_tensor(image.convert("RGB"))
         if image_tensor.dim() == 3:

invokeai/app/invocations/metadata.py

@@ -8,7 +8,10 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.controlnet_image_processors import ControlField
+from invokeai.app.invocations.controlnet_image_processors import (
+    CONTROLNET_MODE_VALUES,
+    CONTROLNET_RESIZE_VALUES,
+)
 from invokeai.app.invocations.fields import (
     FieldDescriptions,
     ImageField,
@@ -17,10 +20,8 @@ from invokeai.app.invocations.fields import (
     OutputField,
     UIType,
 )
-from invokeai.app.invocations.ip_adapter import IPAdapterModelField
-from invokeai.app.invocations.model import LoRAModelField, MainModelField, VAEModelField
-from invokeai.app.invocations.t2i_adapter import T2IAdapterField
 from invokeai.app.services.shared.invocation_context import InvocationContext
+from invokeai.backend.model_manager.config import BaseModelType, ModelType
 
 from ...version import __version__
 
@@ -30,10 +31,20 @@ class MetadataItemField(BaseModel):
     value: Any = Field(description=FieldDescriptions.metadata_item_value)
 
 
+class ModelMetadataField(BaseModel):
+    """Model Metadata Field"""
+
+    key: str
+    hash: str
+    name: str
+    base: BaseModelType
+    type: ModelType
+
+
 class LoRAMetadataField(BaseModel):
     """LoRA Metadata Field"""
 
-    model: LoRAModelField = Field(description=FieldDescriptions.lora_model)
+    model: ModelMetadataField = Field(description=FieldDescriptions.lora_model)
     weight: float = Field(description=FieldDescriptions.lora_weight)
 
 
@@ -41,7 +52,7 @@ class IPAdapterMetadataField(BaseModel):
     """IP Adapter Field, minus the CLIP Vision Encoder model"""
 
     image: ImageField = Field(description="The IP-Adapter image prompt.")
-    ip_adapter_model: IPAdapterModelField = Field(
+    ip_adapter_model: ModelMetadataField = Field(
         description="The IP-Adapter model.",
     )
     weight: Union[float, list[float]] = Field(
@@ -51,6 +62,33 @@ class IPAdapterMetadataField(BaseModel):
     end_step_percent: float = Field(description="When the IP-Adapter is last applied (% of total steps)")
 
 
+class T2IAdapterMetadataField(BaseModel):
+    image: ImageField = Field(description="The T2I-Adapter image prompt.")
+    t2i_adapter_model: ModelMetadataField = Field(description="The T2I-Adapter model to use.")
+    weight: Union[float, list[float]] = Field(default=1, description="The weight given to the T2I-Adapter")
+    begin_step_percent: float = Field(
+        default=0, ge=0, le=1, description="When the T2I-Adapter is first applied (% of total steps)"
+    )
+    end_step_percent: float = Field(
+        default=1, ge=0, le=1, description="When the T2I-Adapter is last applied (% of total steps)"
+    )
+    resize_mode: CONTROLNET_RESIZE_VALUES = Field(default="just_resize", description="The resize mode to use")
+
+
+class ControlNetMetadataField(BaseModel):
+    image: ImageField = Field(description="The control image")
+    control_model: ModelMetadataField = Field(description="The ControlNet model to use")
+    control_weight: Union[float, list[float]] = Field(default=1, description="The weight given to the ControlNet")
+    begin_step_percent: float = Field(
+        default=0, ge=0, le=1, description="When the ControlNet is first applied (% of total steps)"
+    )
+    end_step_percent: float = Field(
+        default=1, ge=0, le=1, description="When the ControlNet is last applied (% of total steps)"
+    )
+    control_mode: CONTROLNET_MODE_VALUES = Field(default="balanced", description="The control mode to use")
+    resize_mode: CONTROLNET_RESIZE_VALUES = Field(default="just_resize", description="The resize mode to use")
+
+
 @invocation_output("metadata_item_output")
 class MetadataItemOutput(BaseInvocationOutput):
     """Metadata Item Output"""
@@ -140,14 +178,14 @@ class CoreMetadataInvocation(BaseInvocation):
         default=None,
         description="The number of skipped CLIP layers",
     )
-    model: Optional[MainModelField] = InputField(default=None, description="The main model used for inference")
-    controlnets: Optional[list[ControlField]] = InputField(
+    model: Optional[ModelMetadataField] = InputField(default=None, description="The main model used for inference")
+    controlnets: Optional[list[ControlNetMetadataField]] = InputField(
         default=None, description="The ControlNets used for inference"
     )
     ipAdapters: Optional[list[IPAdapterMetadataField]] = InputField(
         default=None, description="The IP Adapters used for inference"
     )
-    t2iAdapters: Optional[list[T2IAdapterField]] = InputField(
+    t2iAdapters: Optional[list[T2IAdapterMetadataField]] = InputField(
         default=None, description="The IP Adapters used for inference"
     )
     loras: Optional[list[LoRAMetadataField]] = InputField(default=None, description="The LoRAs used for inference")
@@ -159,7 +197,7 @@ class CoreMetadataInvocation(BaseInvocation):
         default=None,
         description="The name of the initial image",
     )
-    vae: Optional[VAEModelField] = InputField(
+    vae: Optional[ModelMetadataField] = InputField(
         default=None,
         description="The VAE used for decoding, if the main model's default was not used",
     )
@@ -190,7 +228,7 @@ class CoreMetadataInvocation(BaseInvocation):
     )
 
     # SDXL Refiner
-    refiner_model: Optional[MainModelField] = InputField(
+    refiner_model: Optional[ModelMetadataField] = InputField(
         default=None,
         description="The SDXL Refiner model used",
     )
@@ -222,10 +260,9 @@ class CoreMetadataInvocation(BaseInvocation):
     def invoke(self, context: InvocationContext) -> MetadataOutput:
         """Collects and outputs a CoreMetadata object"""
 
-        return MetadataOutput(
-            metadata=MetadataField.model_validate(
-                self.model_dump(exclude_none=True, exclude={"id", "type", "is_intermediate", "use_cache"})
-            )
-        )
+        as_dict = self.model_dump(exclude_none=True, exclude={"id", "type", "is_intermediate", "use_cache"})
+        as_dict["app_version"] = __version__
+
+        return MetadataOutput(metadata=MetadataField.model_validate(as_dict))
 
     model_config = ConfigDict(extra="allow")

invokeai/app/invocations/model.py

@@ -3,11 +3,11 @@ from typing import List, Optional
 
 from pydantic import BaseModel, Field
 
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIType
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.shared.models import FreeUConfig
+from invokeai.backend.model_manager.config import AnyModelConfig, BaseModelType, ModelType, SubModelType
 
-from ...backend.model_manager import SubModelType
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
@@ -16,33 +16,52 @@ from .baseinvocation import (
 )
 
 
-class ModelInfo(BaseModel):
-    key: str = Field(description="Key of model as returned by ModelRecordServiceBase.get_model()")
-    submodel_type: Optional[SubModelType] = Field(default=None, description="Info to load submodel")
+class ModelIdentifierField(BaseModel):
+    key: str = Field(description="The model's unique key")
+    hash: str = Field(description="The model's BLAKE3 hash")
+    name: str = Field(description="The model's name")
+    base: BaseModelType = Field(description="The model's base model type")
+    type: ModelType = Field(description="The model's type")
+    submodel_type: Optional[SubModelType] = Field(
+        description="The submodel to load, if this is a main model", default=None
+    )
+
+    @classmethod
+    def from_config(
+        cls, config: "AnyModelConfig", submodel_type: Optional[SubModelType] = None
+    ) -> "ModelIdentifierField":
+        return cls(
+            key=config.key,
+            hash=config.hash,
+            name=config.name,
+            base=config.base,
+            type=config.type,
+            submodel_type=submodel_type,
+        )
 
 
-class LoraInfo(ModelInfo):
-    weight: float = Field(description="Lora's weight which to use when apply to model")
+class LoRAField(BaseModel):
+    lora: ModelIdentifierField = Field(description="Info to load lora model")
+    weight: float = Field(description="Weight to apply to lora model")
 
 
 class UNetField(BaseModel):
-    unet: ModelInfo = Field(description="Info to load unet submodel")
-    scheduler: ModelInfo = Field(description="Info to load scheduler submodel")
-    loras: List[LoraInfo] = Field(description="Loras to apply on model loading")
+    unet: ModelIdentifierField = Field(description="Info to load unet submodel")
+    scheduler: ModelIdentifierField = Field(description="Info to load scheduler submodel")
+    loras: List[LoRAField] = Field(description="LoRAs to apply on model loading")
     seamless_axes: List[str] = Field(default_factory=list, description='Axes("x" and "y") to which apply seamless')
     freeu_config: Optional[FreeUConfig] = Field(default=None, description="FreeU configuration")
 
 
-class ClipField(BaseModel):
-    tokenizer: ModelInfo = Field(description="Info to load tokenizer submodel")
-    text_encoder: ModelInfo = Field(description="Info to load text_encoder submodel")
+class CLIPField(BaseModel):
+    tokenizer: ModelIdentifierField = Field(description="Info to load tokenizer submodel")
+    text_encoder: ModelIdentifierField = Field(description="Info to load text_encoder submodel")
     skipped_layers: int = Field(description="Number of skipped layers in text_encoder")
-    loras: List[LoraInfo] = Field(description="Loras to apply on model loading")
+    loras: List[LoRAField] = Field(description="LoRAs to apply on model loading")
 
 
-class VaeField(BaseModel):
-    # TODO: better naming?
-    vae: ModelInfo = Field(description="Info to load vae submodel")
+class VAEField(BaseModel):
+    vae: ModelIdentifierField = Field(description="Info to load vae submodel")
     seamless_axes: List[str] = Field(default_factory=list, description='Axes("x" and "y") to which apply seamless')
 
 
@@ -57,14 +76,14 @@ class UNetOutput(BaseInvocationOutput):
 class VAEOutput(BaseInvocationOutput):
     """Base class for invocations that output a VAE field"""
 
-    vae: VaeField = OutputField(description=FieldDescriptions.vae, title="VAE")
+    vae: VAEField = OutputField(description=FieldDescriptions.vae, title="VAE")
 
 
 @invocation_output("clip_output")
 class CLIPOutput(BaseInvocationOutput):
     """Base class for invocations that output a CLIP field"""
 
-    clip: ClipField = OutputField(description=FieldDescriptions.clip, title="CLIP")
+    clip: CLIPField = OutputField(description=FieldDescriptions.clip, title="CLIP")
 
 
 @invocation_output("model_loader_output")
@@ -74,18 +93,6 @@ class ModelLoaderOutput(UNetOutput, CLIPOutput, VAEOutput):
     pass
 
 
-class MainModelField(BaseModel):
-    """Main model field"""
-
-    key: str = Field(description="Model key")
-
-
-class LoRAModelField(BaseModel):
-    """LoRA model field"""
-
-    key: str = Field(description="LoRA model key")
-
-
 @invocation(
     "main_model_loader",
     title="Main Model",
@@ -96,62 +103,44 @@ class LoRAModelField(BaseModel):
 class MainModelLoaderInvocation(BaseInvocation):
     """Loads a main model, outputting its submodels."""
 
-    model: MainModelField = InputField(description=FieldDescriptions.main_model, input=Input.Direct)
+    model: ModelIdentifierField = InputField(
+        description=FieldDescriptions.main_model, input=Input.Direct, ui_type=UIType.MainModel
+    )
     # TODO: precision?
 
     def invoke(self, context: InvocationContext) -> ModelLoaderOutput:
-        key = self.model.key
-
         # TODO: not found exceptions
-        if not context.models.exists(key):
-            raise Exception(f"Unknown model {key}")
+        if not context.models.exists(self.model.key):
+            raise Exception(f"Unknown model {self.model.key}")
+
+        unet = self.model.model_copy(update={"submodel_type": SubModelType.UNet})
+        scheduler = self.model.model_copy(update={"submodel_type": SubModelType.Scheduler})
+        tokenizer = self.model.model_copy(update={"submodel_type": SubModelType.Tokenizer})
+        text_encoder = self.model.model_copy(update={"submodel_type": SubModelType.TextEncoder})
+        vae = self.model.model_copy(update={"submodel_type": SubModelType.VAE})
 
         return ModelLoaderOutput(
-            unet=UNetField(
-                unet=ModelInfo(
-                    key=key,
-                    submodel_type=SubModelType.UNet,
-                ),
-                scheduler=ModelInfo(
-                    key=key,
-                    submodel_type=SubModelType.Scheduler,
-                ),
-                loras=[],
-            ),
-            clip=ClipField(
-                tokenizer=ModelInfo(
-                    key=key,
-                    submodel_type=SubModelType.Tokenizer,
-                ),
-                text_encoder=ModelInfo(
-                    key=key,
-                    submodel_type=SubModelType.TextEncoder,
-                ),
-                loras=[],
-                skipped_layers=0,
-            ),
-            vae=VaeField(
-                vae=ModelInfo(
-                    key=key,
-                    submodel_type=SubModelType.Vae,
-                ),
-            ),
+            unet=UNetField(unet=unet, scheduler=scheduler, loras=[]),
+            clip=CLIPField(tokenizer=tokenizer, text_encoder=text_encoder, loras=[], skipped_layers=0),
+            vae=VAEField(vae=vae),
         )
 
 
 @invocation_output("lora_loader_output")
-class LoraLoaderOutput(BaseInvocationOutput):
+class LoRALoaderOutput(BaseInvocationOutput):
     """Model loader output"""
 
     unet: Optional[UNetField] = OutputField(default=None, description=FieldDescriptions.unet, title="UNet")
-    clip: Optional[ClipField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP")
+    clip: Optional[CLIPField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP")
 
 
 @invocation("lora_loader", title="LoRA", tags=["model"], category="model", version="1.0.1")
-class LoraLoaderInvocation(BaseInvocation):
+class LoRALoaderInvocation(BaseInvocation):
     """Apply selected lora to unet and text_encoder."""
 
-    lora: LoRAModelField = InputField(description=FieldDescriptions.lora_model, input=Input.Direct, title="LoRA")
+    lora: ModelIdentifierField = InputField(
+        description=FieldDescriptions.lora_model, input=Input.Direct, title="LoRA", ui_type=UIType.LoRAModel
+    )
     weight: float = InputField(default=0.75, description=FieldDescriptions.lora_weight)
     unet: Optional[UNetField] = InputField(
         default=None,
@@ -159,46 +148,41 @@ class LoraLoaderInvocation(BaseInvocation):
         input=Input.Connection,
         title="UNet",
     )
-    clip: Optional[ClipField] = InputField(
+    clip: Optional[CLIPField] = InputField(
         default=None,
         description=FieldDescriptions.clip,
         input=Input.Connection,
         title="CLIP",
     )
 
-    def invoke(self, context: InvocationContext) -> LoraLoaderOutput:
-        if self.lora is None:
-            raise Exception("No LoRA provided")
-
+    def invoke(self, context: InvocationContext) -> LoRALoaderOutput:
         lora_key = self.lora.key
 
         if not context.models.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):
-            raise Exception(f'Lora "{lora_key}" already applied to unet')
+        if self.unet is not None and any(lora.lora.key == lora_key for lora in self.unet.loras):
+            raise Exception(f'LoRA "{lora_key}" already applied to unet')
 
-        if self.clip is not None and any(lora.key == lora_key for lora in self.clip.loras):
-            raise Exception(f'Lora "{lora_key}" already applied to clip')
+        if self.clip is not None and any(lora.lora.key == lora_key for lora in self.clip.loras):
+            raise Exception(f'LoRA "{lora_key}" already applied to clip')
 
-        output = LoraLoaderOutput()
+        output = LoRALoaderOutput()
 
         if self.unet is not None:
-            output.unet = copy.deepcopy(self.unet)
+            output.unet = self.unet.model_copy(deep=True)
             output.unet.loras.append(
-                LoraInfo(
-                    key=lora_key,
-                    submodel_type=None,
+                LoRAField(
+                    lora=self.lora,
                     weight=self.weight,
                 )
             )
 
         if self.clip is not None:
-            output.clip = copy.deepcopy(self.clip)
+            output.clip = self.clip.model_copy(deep=True)
             output.clip.loras.append(
-                LoraInfo(
-                    key=lora_key,
-                    submodel_type=None,
+                LoRAField(
+                    lora=self.lora,
                     weight=self.weight,
                 )
             )
@@ -207,12 +191,12 @@ class LoraLoaderInvocation(BaseInvocation):
 
 
 @invocation_output("sdxl_lora_loader_output")
-class SDXLLoraLoaderOutput(BaseInvocationOutput):
+class SDXLLoRALoaderOutput(BaseInvocationOutput):
     """SDXL LoRA Loader Output"""
 
     unet: Optional[UNetField] = OutputField(default=None, description=FieldDescriptions.unet, title="UNet")
-    clip: Optional[ClipField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP 1")
-    clip2: Optional[ClipField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP 2")
+    clip: Optional[CLIPField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP 1")
+    clip2: Optional[CLIPField] = OutputField(default=None, description=FieldDescriptions.clip, title="CLIP 2")
 
 
 @invocation(
@@ -222,10 +206,12 @@ class SDXLLoraLoaderOutput(BaseInvocationOutput):
     category="model",
     version="1.0.1",
 )
-class SDXLLoraLoaderInvocation(BaseInvocation):
+class SDXLLoRALoaderInvocation(BaseInvocation):
     """Apply selected lora to unet and text_encoder."""
 
-    lora: LoRAModelField = InputField(description=FieldDescriptions.lora_model, input=Input.Direct, title="LoRA")
+    lora: ModelIdentifierField = InputField(
+        description=FieldDescriptions.lora_model, input=Input.Direct, title="LoRA", ui_type=UIType.LoRAModel
+    )
     weight: float = InputField(default=0.75, description=FieldDescriptions.lora_weight)
     unet: Optional[UNetField] = InputField(
         default=None,
@@ -233,65 +219,59 @@ class SDXLLoraLoaderInvocation(BaseInvocation):
         input=Input.Connection,
         title="UNet",
     )
-    clip: Optional[ClipField] = InputField(
+    clip: Optional[CLIPField] = InputField(
         default=None,
         description=FieldDescriptions.clip,
         input=Input.Connection,
         title="CLIP 1",
     )
-    clip2: Optional[ClipField] = InputField(
+    clip2: Optional[CLIPField] = InputField(
         default=None,
         description=FieldDescriptions.clip,
         input=Input.Connection,
         title="CLIP 2",
     )
 
-    def invoke(self, context: InvocationContext) -> SDXLLoraLoaderOutput:
-        if self.lora is None:
-            raise Exception("No LoRA provided")
-
+    def invoke(self, context: InvocationContext) -> SDXLLoRALoaderOutput:
         lora_key = self.lora.key
 
         if not context.models.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):
-            raise Exception(f'Lora "{lora_key}" already applied to unet')
+        if self.unet is not None and any(lora.lora.key == lora_key for lora in self.unet.loras):
+            raise Exception(f'LoRA "{lora_key}" already applied to unet')
 
-        if self.clip is not None and any(lora.key == lora_key for lora in self.clip.loras):
-            raise Exception(f'Lora "{lora_key}" already applied to clip')
+        if self.clip is not None and any(lora.lora.key == lora_key for lora in self.clip.loras):
+            raise Exception(f'LoRA "{lora_key}" already applied to clip')
 
-        if self.clip2 is not None and any(lora.key == lora_key for lora in self.clip2.loras):
-            raise Exception(f'Lora "{lora_key}" already applied to clip2')
+        if self.clip2 is not None and any(lora.lora.key == lora_key for lora in self.clip2.loras):
+            raise Exception(f'LoRA "{lora_key}" already applied to clip2')
 
-        output = SDXLLoraLoaderOutput()
+        output = SDXLLoRALoaderOutput()
 
         if self.unet is not None:
-            output.unet = copy.deepcopy(self.unet)
+            output.unet = self.unet.model_copy(deep=True)
             output.unet.loras.append(
-                LoraInfo(
-                    key=lora_key,
-                    submodel_type=None,
+                LoRAField(
+                    lora=self.lora,
                     weight=self.weight,
                 )
             )
 
         if self.clip is not None:
-            output.clip = copy.deepcopy(self.clip)
+            output.clip = self.clip.model_copy(deep=True)
             output.clip.loras.append(
-                LoraInfo(
-                    key=lora_key,
-                    submodel_type=None,
+                LoRAField(
+                    lora=self.lora,
                     weight=self.weight,
                 )
             )
 
         if self.clip2 is not None:
-            output.clip2 = copy.deepcopy(self.clip2)
+            output.clip2 = self.clip2.model_copy(deep=True)
             output.clip2.loras.append(
-                LoraInfo(
-                    key=lora_key,
-                    submodel_type=None,
+                LoRAField(
+                    lora=self.lora,
                     weight=self.weight,
                 )
             )
@@ -299,20 +279,12 @@ class SDXLLoraLoaderInvocation(BaseInvocation):
         return output
 
 
-class VAEModelField(BaseModel):
-    """Vae model field"""
-
-    key: str = Field(description="Model's key")
-
-
 @invocation("vae_loader", title="VAE", tags=["vae", "model"], category="model", version="1.0.1")
-class VaeLoaderInvocation(BaseInvocation):
+class VAELoaderInvocation(BaseInvocation):
     """Loads a VAE model, outputting a VaeLoaderOutput"""
 
-    vae_model: VAEModelField = InputField(
-        description=FieldDescriptions.vae_model,
-        input=Input.Direct,
-        title="VAE",
+    vae_model: ModelIdentifierField = InputField(
+        description=FieldDescriptions.vae_model, input=Input.Direct, title="VAE", ui_type=UIType.VAEModel
     )
 
     def invoke(self, context: InvocationContext) -> VAEOutput:
@@ -321,7 +293,7 @@ class VaeLoaderInvocation(BaseInvocation):
         if not context.models.exists(key):
             raise Exception(f"Unkown vae: {key}!")
 
-        return VAEOutput(vae=VaeField(vae=ModelInfo(key=key)))
+        return VAEOutput(vae=VAEField(vae=self.vae_model))
 
 
 @invocation_output("seamless_output")
@@ -329,7 +301,7 @@ class SeamlessModeOutput(BaseInvocationOutput):
     """Modified Seamless Model output"""
 
     unet: Optional[UNetField] = OutputField(default=None, description=FieldDescriptions.unet, title="UNet")
-    vae: Optional[VaeField] = OutputField(default=None, description=FieldDescriptions.vae, title="VAE")
+    vae: Optional[VAEField] = OutputField(default=None, description=FieldDescriptions.vae, title="VAE")
 
 
 @invocation(
@@ -348,7 +320,7 @@ class SeamlessModeInvocation(BaseInvocation):
         input=Input.Connection,
         title="UNet",
     )
-    vae: Optional[VaeField] = InputField(
+    vae: Optional[VAEField] = InputField(
         default=None,
         description=FieldDescriptions.vae_model,
         input=Input.Connection,

invokeai/app/invocations/primitives.py

@@ -14,7 +14,6 @@ from invokeai.app.invocations.fields import (
     Input,
     InputField,
     LatentsField,
-    MaskField,
     OutputField,
     UIComponent,
 )
@@ -230,18 +229,6 @@ class StringCollectionInvocation(BaseInvocation):
 # region Image
 
 
-@invocation_output("mask_output")
-class MaskOutput(BaseInvocationOutput):
-    """A torch mask tensor.
-    dtype: torch.bool
-    shape: (1, height, width).
-    """
-
-    mask: MaskField = OutputField(description="The mask.")
-    width: int = OutputField(description="The width of the mask in pixels.")
-    height: int = OutputField(description="The height of the mask in pixels.")
-
-
 @invocation_output("image_output")
 class ImageOutput(BaseInvocationOutput):
     """Base class for nodes that output a single image"""
@@ -427,6 +414,10 @@ class ConditioningOutput(BaseInvocationOutput):
 
     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/sdxl.py

@@ -8,7 +8,7 @@ from .baseinvocation import (
     invocation,
     invocation_output,
 )
-from .model import ClipField, MainModelField, ModelInfo, UNetField, VaeField
+from .model import CLIPField, ModelIdentifierField, UNetField, VAEField
 
 
 @invocation_output("sdxl_model_loader_output")
@@ -16,9 +16,9 @@ class SDXLModelLoaderOutput(BaseInvocationOutput):
     """SDXL base model loader output"""
 
     unet: UNetField = OutputField(description=FieldDescriptions.unet, title="UNet")
-    clip: ClipField = OutputField(description=FieldDescriptions.clip, title="CLIP 1")
-    clip2: ClipField = OutputField(description=FieldDescriptions.clip, title="CLIP 2")
-    vae: VaeField = OutputField(description=FieldDescriptions.vae, title="VAE")
+    clip: CLIPField = OutputField(description=FieldDescriptions.clip, title="CLIP 1")
+    clip2: CLIPField = OutputField(description=FieldDescriptions.clip, title="CLIP 2")
+    vae: VAEField = OutputField(description=FieldDescriptions.vae, title="VAE")
 
 
 @invocation_output("sdxl_refiner_model_loader_output")
@@ -26,15 +26,15 @@ class SDXLRefinerModelLoaderOutput(BaseInvocationOutput):
     """SDXL refiner model loader output"""
 
     unet: UNetField = OutputField(description=FieldDescriptions.unet, title="UNet")
-    clip2: ClipField = OutputField(description=FieldDescriptions.clip, title="CLIP 2")
-    vae: VaeField = OutputField(description=FieldDescriptions.vae, title="VAE")
+    clip2: CLIPField = OutputField(description=FieldDescriptions.clip, title="CLIP 2")
+    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")
 class SDXLModelLoaderInvocation(BaseInvocation):
     """Loads an sdxl base model, outputting its submodels."""
 
-    model: MainModelField = InputField(
+    model: ModelIdentifierField = InputField(
         description=FieldDescriptions.sdxl_main_model, input=Input.Direct, ui_type=UIType.SDXLMainModel
     )
     # TODO: precision?
@@ -46,48 +46,19 @@ class SDXLModelLoaderInvocation(BaseInvocation):
         if not context.models.exists(model_key):
             raise Exception(f"Unknown model: {model_key}")
 
+        unet = self.model.model_copy(update={"submodel_type": SubModelType.UNet})
+        scheduler = self.model.model_copy(update={"submodel_type": SubModelType.Scheduler})
+        tokenizer = self.model.model_copy(update={"submodel_type": SubModelType.Tokenizer})
+        text_encoder = self.model.model_copy(update={"submodel_type": SubModelType.TextEncoder})
+        tokenizer2 = self.model.model_copy(update={"submodel_type": SubModelType.Tokenizer2})
+        text_encoder2 = self.model.model_copy(update={"submodel_type": SubModelType.TextEncoder2})
+        vae = self.model.model_copy(update={"submodel_type": SubModelType.VAE})
+
         return SDXLModelLoaderOutput(
-            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,
-            ),
-            clip2=ClipField(
-                tokenizer=ModelInfo(
-                    key=model_key,
-                    submodel_type=SubModelType.Tokenizer2,
-                ),
-                text_encoder=ModelInfo(
-                    key=model_key,
-                    submodel_type=SubModelType.TextEncoder2,
-                ),
-                loras=[],
-                skipped_layers=0,
-            ),
-            vae=VaeField(
-                vae=ModelInfo(
-                    key=model_key,
-                    submodel_type=SubModelType.Vae,
-                ),
-            ),
+            unet=UNetField(unet=unet, scheduler=scheduler, loras=[]),
+            clip=CLIPField(tokenizer=tokenizer, text_encoder=text_encoder, loras=[], skipped_layers=0),
+            clip2=CLIPField(tokenizer=tokenizer2, text_encoder=text_encoder2, loras=[], skipped_layers=0),
+            vae=VAEField(vae=vae),
         )
 
 
@@ -101,10 +72,8 @@ class SDXLModelLoaderInvocation(BaseInvocation):
 class SDXLRefinerModelLoaderInvocation(BaseInvocation):
     """Loads an sdxl refiner model, outputting its submodels."""
 
-    model: MainModelField = InputField(
-        description=FieldDescriptions.sdxl_refiner_model,
-        input=Input.Direct,
-        ui_type=UIType.SDXLRefinerModel,
+    model: ModelIdentifierField = InputField(
+        description=FieldDescriptions.sdxl_refiner_model, input=Input.Direct, ui_type=UIType.SDXLRefinerModel
     )
     # TODO: precision?
 
@@ -115,34 +84,14 @@ class SDXLRefinerModelLoaderInvocation(BaseInvocation):
         if not context.models.exists(model_key):
             raise Exception(f"Unknown model: {model_key}")
 
+        unet = self.model.model_copy(update={"submodel_type": SubModelType.UNet})
+        scheduler = self.model.model_copy(update={"submodel_type": SubModelType.Scheduler})
+        tokenizer2 = self.model.model_copy(update={"submodel_type": SubModelType.Tokenizer2})
+        text_encoder2 = self.model.model_copy(update={"submodel_type": SubModelType.TextEncoder2})
+        vae = self.model.model_copy(update={"submodel_type": SubModelType.VAE})
+
         return SDXLRefinerModelLoaderOutput(
-            unet=UNetField(
-                unet=ModelInfo(
-                    key=model_key,
-                    submodel_type=SubModelType.UNet,
-                ),
-                scheduler=ModelInfo(
-                    key=model_key,
-                    submodel_type=SubModelType.Scheduler,
-                ),
-                loras=[],
-            ),
-            clip2=ClipField(
-                tokenizer=ModelInfo(
-                    key=model_key,
-                    submodel_type=SubModelType.Tokenizer2,
-                ),
-                text_encoder=ModelInfo(
-                    key=model_key,
-                    submodel_type=SubModelType.TextEncoder2,
-                ),
-                loras=[],
-                skipped_layers=0,
-            ),
-            vae=VaeField(
-                vae=ModelInfo(
-                    key=model_key,
-                    submodel_type=SubModelType.Vae,
-                ),
-            ),
+            unet=UNetField(unet=unet, scheduler=scheduler, loras=[]),
+            clip2=CLIPField(tokenizer=tokenizer2, text_encoder=text_encoder2, loras=[], skipped_layers=0),
+            vae=VAEField(vae=vae),
         )

invokeai/app/invocations/t2i_adapter.py

@@ -9,18 +9,15 @@ from invokeai.app.invocations.baseinvocation import (
     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.fields import FieldDescriptions, ImageField, Input, InputField, OutputField, UIType
+from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
 from invokeai.app.services.shared.invocation_context import InvocationContext
 
 
-class T2IAdapterModelField(BaseModel):
-    key: str = Field(description="Model record key for the T2I-Adapter model")
-
-
 class T2IAdapterField(BaseModel):
     image: ImageField = Field(description="The T2I-Adapter image prompt.")
-    t2i_adapter_model: T2IAdapterModelField = Field(description="The T2I-Adapter model to use.")
+    t2i_adapter_model: ModelIdentifierField = Field(description="The T2I-Adapter model to use.")
     weight: Union[float, list[float]] = Field(default=1, description="The weight given to the T2I-Adapter")
     begin_step_percent: float = Field(
         default=0, ge=0, le=1, description="When the T2I-Adapter is first applied (% of total steps)"
@@ -55,11 +52,12 @@ class T2IAdapterInvocation(BaseInvocation):
 
     # Inputs
     image: ImageField = InputField(description="The IP-Adapter image prompt.")
-    t2i_adapter_model: T2IAdapterModelField = InputField(
+    t2i_adapter_model: ModelIdentifierField = InputField(
         description="The T2I-Adapter model.",
         title="T2I-Adapter Model",
         input=Input.Direct,
         ui_order=-1,
+        ui_type=UIType.T2IAdapterModel,
     )
     weight: Union[float, list[float]] = InputField(
         default=1, ge=0, description="The weight given to the T2I-Adapter", title="Weight"

invokeai/app/services/config/config_base.py

@@ -11,17 +11,36 @@ the command line.
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import sys
 from argparse import ArgumentParser
 from pathlib import Path
-from typing import Any, ClassVar, Dict, List, Literal, Optional, Union, get_args, get_origin, get_type_hints
+from typing import Any, ClassVar, Dict, List, Literal, Optional, Union, Type, get_args, get_origin, get_type_hints
 
-from omegaconf import DictConfig, ListConfig, OmegaConf
+from omegaconf import DictConfig, DictKeyType, ListConfig, OmegaConf
+from pydantic import BaseModel
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from invokeai.app.services.config.config_common import PagingArgumentParser, int_or_float_or_str
 
+class ParseModelListAction(argparse.Action):
+    """An argparse action that parses a JSON string into a list of Pydantic models."""
+
+    model_type: Type[BaseModel]
+
+    def __init__(self, model_type: Type[BaseModel], *args, **kwargs): # type: ignore
+        super(ParseModelListAction, self).__init__(*args, **kwargs) # type: ignore
+        self.model_type = model_type
+
+    def __call__(self, parser, namespace, values, option_string=None): # type: ignore
+        try:
+            items_data = json.loads(values) # type: ignore
+            items = [self.model_type(**item_data) for item_data in items_data]
+            setattr(namespace, self.dest, items)
+        except Exception as e:
+            parser.error(f"Could not parse models: {e}")
+
 
 class InvokeAISettings(BaseSettings):
     """Runtime configuration settings in which default values are read from an omegaconf .yaml file."""
@@ -62,6 +81,22 @@ class InvokeAISettings(BaseSettings):
             assert isinstance(category, str)
             if category not in field_dict[type]:
                 field_dict[type][category] = {}
+            if isinstance(value, BaseModel):
+                dump = value.model_dump(exclude_defaults=True, exclude_unset=True, exclude_none=True)
+                field_dict[type][category][name] = dump
+                continue
+            if isinstance(value, list):
+                if not value or len(value) == 0:
+                    continue
+                primitive = isinstance(value[0], get_args(DictKeyType))
+                if not primitive:
+                    val_list: List[Dict[str, Any]] = []
+                    for list_val in value:
+                        if isinstance(list_val, BaseModel):
+                            dump = list_val.model_dump(exclude_defaults=True, exclude_unset=True, exclude_none=True)
+                            val_list.append(dump)
+                    field_dict[type][category][name] = val_list
+                    continue
             # keep paths as strings to make it easier to read
             field_dict[type][category][name] = str(value) if isinstance(value, Path) else value
         conf = OmegaConf.create(field_dict)
@@ -177,7 +212,28 @@ class InvokeAISettings(BaseSettings):
         else:
             argparse_group = command_parser
 
-        if get_origin(field_type) == Literal:
+        def matches_optional_list_of_basemodel_subclasses(field_type):
+            args = get_args(field_type)
+            for arg in args:
+                list_origin = get_origin(arg)
+                if list_origin is list:
+                    list_args = get_args(arg)
+                    if len(list_args) == 1 and issubclass(list_args[0], BaseModel):
+                        return list_args[0]
+            return None
+        if name == "remote_api_tokens":
+            pass
+        if bm_type:=matches_optional_list_of_basemodel_subclasses(field_type):
+            argparse_group.add_argument(
+                f"--{name}",
+                dest=name,
+                action=ParseModelListAction,
+                model_type=bm_type,
+                type=str,
+                default=default,
+                help=field.description,
+            )
+        elif get_origin(field_type) == Literal:
             allowed_values = get_args(field.annotation)
             allowed_types = set()
             for val in allowed_values:

invokeai/app/services/config/config_default.py

@@ -170,11 +170,12 @@ two configs are kept in separate sections of the config file:
 from __future__ import annotations
 
 import os
+import re
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List, Literal, Optional
 
 from omegaconf import DictConfig, OmegaConf
-from pydantic import Field
+from pydantic import BaseModel, Field, field_validator
 from pydantic.config import JsonDict
 from pydantic_settings import SettingsConfigDict
 
@@ -196,17 +197,87 @@ class Categories(object):
     Paths: JsonDict = {"category": "Paths"}
     Logging: JsonDict = {"category": "Logging"}
     Development: JsonDict = {"category": "Development"}
-    Other: JsonDict = {"category": "Other"}
+    CLIArgs: JsonDict = {"category": "CLIArgs"}
+    ModelInstall: JsonDict = {"category": "Model Install"}
     ModelCache: JsonDict = {"category": "Model Cache"}
     Device: JsonDict = {"category": "Device"}
     Generation: JsonDict = {"category": "Generation"}
     Queue: JsonDict = {"category": "Queue"}
     Nodes: JsonDict = {"category": "Nodes"}
     MemoryPerformance: JsonDict = {"category": "Memory/Performance"}
+    Deprecated: JsonDict = {"category": "Deprecated"}
+
+
+class URLRegexToken(BaseModel):
+    url_regex: str = Field(description="Regular expression to match against the URL")
+    token: str = Field(description="Token to use when the URL matches the regex")
+
+    @field_validator("url_regex")
+    @classmethod
+    def validate_url_regex(cls, v: str) -> str:
+        """Validate that the value is a valid regex."""
+        try:
+            re.compile(v)
+        except re.error as e:
+            raise ValueError(f"Invalid regex: {e}")
+        return v
 
 
 class InvokeAIAppConfig(InvokeAISettings):
-    """Configuration object for InvokeAI App."""
+    """Invoke App Configuration
+
+    Attributes:
+        host: **Web Server**: IP address to bind to. Use `0.0.0.0` to serve to your local network.
+        port: **Web Server**: Port to bind to.
+        allow_origins: **Web Server**: Allowed CORS origins.
+        allow_credentials: **Web Server**: Allow CORS credentials.
+        allow_methods: **Web Server**: Methods allowed for CORS.
+        allow_headers: **Web Server**: Headers allowed for CORS.
+        ssl_certfile: **Web Server**: SSL certificate file for HTTPS.
+        ssl_keyfile: **Web Server**: SSL key file for HTTPS.
+        esrgan: **Features**: Enables or disables the upscaling code.
+        internet_available: **Features**: If true, attempt to download models on the fly; otherwise only use local models.
+        log_tokenization: **Features**: Enable logging of parsed prompt tokens.
+        patchmatch: **Features**: Enable patchmatch inpaint code.
+        ignore_missing_core_models: **Features**: Ignore missing core models on startup. If `True`, the app will attempt to download missing models on startup.
+        root: **Paths**: The InvokeAI runtime root directory.
+        autoimport_dir: **Paths**: Path to a directory of models files to be imported on startup.
+        models_dir: **Paths**: Path to the models directory.
+        convert_cache_dir: **Paths**: Path to the converted models cache directory. When loading a non-diffusers model, it will be converted and store on disk at this location.
+        legacy_conf_dir: **Paths**: Path to directory of legacy checkpoint config files.
+        db_dir: **Paths**: Path to InvokeAI databases directory.
+        outdir: **Paths**: Path to directory for outputs.
+        custom_nodes_dir: **Paths**: Path to directory for custom nodes.
+        from_file: **Paths**: Take command input from the indicated file (command-line client only).
+        log_handlers: **Logging**: Log handler. Valid options are "console", "file=<path>", "syslog=path|address:host:port", "http=<url>".
+        log_format: **Logging**: Log format. Use "plain" for text-only, "color" for colorized output, "legacy" for 2.3-style logging and "syslog" for syslog-style.
+        log_level: **Logging**: Emit logging messages at this level or higher.
+        log_sql: **Logging**: Log SQL queries. `log_level` must be `debug` for this to do anything. Extremely verbose.
+        use_memory_db: **Development**: Use in-memory database. Useful for development.
+        dev_reload: **Development**: Automatically reload when Python sources are changed. Does not reload node definitions.
+        profile_graphs: **Development**: Enable graph profiling using `cProfile`.
+        profile_prefix: **Development**: An optional prefix for profile output files.
+        profiles_dir: **Development**: Path to profiles output directory.
+        version: **CLIArgs**: CLI arg - show InvokeAI version and exit.
+        skip_model_hash: **Model Install**: Skip model hashing, instead assigning a UUID to models. Useful when using a memory db to reduce model installation time, or if you don't care about storing stable hashes for models.
+        remote_api_tokens: **Model Install**: List of regular expression and token pairs used when downloading models from URLs. The download URL is tested against the regex, and if it matches, the token is provided in as a Bearer token.
+        ram: **Model Cache**: Maximum memory amount used by memory model cache for rapid switching (GB).
+        vram: **Model Cache**: Amount of VRAM reserved for model storage (GB)
+        convert_cache: **Model Cache**: Maximum size of on-disk converted models cache (GB)
+        lazy_offload: **Model Cache**: Keep models in VRAM until their space is needed.
+        log_memory_usage: **Model Cache**: If True, a memory snapshot will be captured before and after every model cache operation, and the result will be logged (at debug level). There is a time cost to capturing the memory snapshots, so it is recommended to only enable this feature if you are actively inspecting the model cache's behaviour.
+        device: **Device**: Preferred execution device. `auto` will choose the device depending on the hardware platform and the installed torch capabilities.
+        precision: **Device**: Floating point precision. `float16` will consume half the memory of `float32` but produce slightly lower-quality images. The `auto` setting will guess the proper precision based on your video card and operating system.
+        sequential_guidance: **Generation**: Whether to calculate guidance in serial instead of in parallel, lowering memory requirements.
+        attention_type: **Generation**: Attention type.
+        attention_slice_size: **Generation**: Slice size, valid when attention_type=="sliced".
+        force_tiled_decode: **Generation**: Whether to enable tiled VAE decode (reduces memory consumption with some performance penalty).
+        png_compress_level: **Generation**: The compress_level setting of PIL.Image.save(), used for PNG encoding. All settings are lossless. 0 = no compression, 1 = fastest with slightly larger filesize, 9 = slowest with smallest filesize. 1 is typically the best setting.
+        max_queue_size: **Queue**: Maximum number of items in the session queue.
+        allow_nodes: **Nodes**: List of nodes to allow. Omit to allow all.
+        deny_nodes: **Nodes**: List of nodes to deny. Omit to deny none.
+        node_cache_size: **Nodes**: How many cached nodes to keep in memory.
+    """
 
     singleton_config: ClassVar[Optional[InvokeAIAppConfig]] = None
     singleton_init: ClassVar[Optional[Dict[str, Any]]] = None
@@ -215,90 +286,98 @@ class InvokeAIAppConfig(InvokeAISettings):
     type: Literal["InvokeAI"] = "InvokeAI"
 
     # WEB
-    host                : str = Field(default="127.0.0.1", description="IP address to bind to", json_schema_extra=Categories.WebServer)
-    port                : int = Field(default=9090, description="Port to bind to", json_schema_extra=Categories.WebServer)
-    allow_origins       : List[str] = Field(default=[], description="Allowed CORS origins", json_schema_extra=Categories.WebServer)
-    allow_credentials   : bool = Field(default=True, description="Allow CORS credentials", json_schema_extra=Categories.WebServer)
-    allow_methods       : List[str] = Field(default=["*"], description="Methods allowed for CORS", json_schema_extra=Categories.WebServer)
-    allow_headers       : List[str] = Field(default=["*"], description="Headers allowed for CORS", json_schema_extra=Categories.WebServer)
+    host                : str = Field(default="127.0.0.1", description="IP address to bind to. Use `0.0.0.0` to serve to your local network.", json_schema_extra=Categories.WebServer)
+    port                : int = Field(default=9090, description="Port to bind to.", json_schema_extra=Categories.WebServer)
+    allow_origins       : List[str] = Field(default=[], description="Allowed CORS origins.", json_schema_extra=Categories.WebServer)
+    allow_credentials   : bool = Field(default=True, description="Allow CORS credentials.", json_schema_extra=Categories.WebServer)
+    allow_methods       : List[str] = Field(default=["*"], description="Methods allowed for CORS.", json_schema_extra=Categories.WebServer)
+    allow_headers       : List[str] = Field(default=["*"], description="Headers allowed for CORS.", json_schema_extra=Categories.WebServer)
     # SSL options correspond to https://www.uvicorn.org/settings/#https
-    ssl_certfile        : Optional[Path] = Field(default=None, description="SSL certificate file (for HTTPS)", json_schema_extra=Categories.WebServer)
-    ssl_keyfile         : Optional[Path] = Field(default=None, description="SSL key file", json_schema_extra=Categories.WebServer)
+    ssl_certfile        : Optional[Path] = Field(default=None, description="SSL certificate file for HTTPS.", json_schema_extra=Categories.WebServer)
+    ssl_keyfile         : Optional[Path] = Field(default=None, description="SSL key file for HTTPS.", json_schema_extra=Categories.WebServer)
 
     # FEATURES
-    esrgan              : bool = Field(default=True, description="Enable/disable upscaling code", json_schema_extra=Categories.Features)
-    internet_available  : bool = Field(default=True, description="If true, attempt to download models on the fly; otherwise only use local models", json_schema_extra=Categories.Features)
+    esrgan              : bool = Field(default=True, description="Enables or disables the upscaling code.", json_schema_extra=Categories.Features)
+    # TODO(psyche): This is not used anywhere.
+    internet_available  : bool = Field(default=True, description="If true, attempt to download models on the fly; otherwise only use local models.", json_schema_extra=Categories.Features)
     log_tokenization    : bool = Field(default=False, description="Enable logging of parsed prompt tokens.", json_schema_extra=Categories.Features)
-    patchmatch          : bool = Field(default=True, description="Enable/disable patchmatch inpaint code", json_schema_extra=Categories.Features)
-    ignore_missing_core_models : bool = Field(default=False, description='Ignore missing models in models/core/convert', json_schema_extra=Categories.Features)
+    patchmatch          : bool = Field(default=True, description="Enable patchmatch inpaint code.", json_schema_extra=Categories.Features)
+    ignore_missing_core_models : bool = Field(default=False, description='Ignore missing core models on startup. If `True`, the app will attempt to download missing models on startup.', json_schema_extra=Categories.Features)
 
     # PATHS
-    root                : Optional[Path] = Field(default=None, description='InvokeAI runtime root directory', json_schema_extra=Categories.Paths)
+    root                : Optional[Path] = Field(default=None, description='The InvokeAI runtime root directory.', json_schema_extra=Categories.Paths)
     autoimport_dir      : Path = Field(default=Path('autoimport'), description='Path to a directory of models files to be imported on startup.', json_schema_extra=Categories.Paths)
-    models_dir          : Path = Field(default=Path('models'), description='Path to the models directory', json_schema_extra=Categories.Paths)
-    convert_cache_dir   : Path = Field(default=Path('models/.cache'), description='Path to the converted models cache directory', json_schema_extra=Categories.Paths)
-    legacy_conf_dir     : Path = Field(default=Path('configs/stable-diffusion'), description='Path to directory of legacy checkpoint config files', json_schema_extra=Categories.Paths)
-    db_dir              : Path = Field(default=Path('databases'), description='Path to InvokeAI databases directory', json_schema_extra=Categories.Paths)
-    outdir              : Path = Field(default=Path('outputs'), description='Default folder for output images', json_schema_extra=Categories.Paths)
-    use_memory_db       : bool = Field(default=False, description='Use in-memory database for storing image metadata', json_schema_extra=Categories.Paths)
-    custom_nodes_dir    : Path = Field(default=Path('nodes'), description='Path to directory for custom nodes', json_schema_extra=Categories.Paths)
-    from_file           : Optional[Path] = Field(default=None, description='Take command input from the indicated file (command-line client only)', json_schema_extra=Categories.Paths)
+    models_dir          : Path = Field(default=Path('models'), description='Path to the models directory.', json_schema_extra=Categories.Paths)
+    convert_cache_dir   : Path = Field(default=Path('models/.cache'), description='Path to the converted models cache directory. When loading a non-diffusers model, it will be converted and store on disk at this location.', json_schema_extra=Categories.Paths)
+    legacy_conf_dir     : Path = Field(default=Path('configs/stable-diffusion'), description='Path to directory of legacy checkpoint config files.', json_schema_extra=Categories.Paths)
+    db_dir              : Path = Field(default=Path('databases'), description='Path to InvokeAI databases directory.', json_schema_extra=Categories.Paths)
+    outdir              : Path = Field(default=Path('outputs'), description='Path to directory for outputs.', json_schema_extra=Categories.Paths)
+    custom_nodes_dir    : Path = Field(default=Path('nodes'), description='Path to directory for custom nodes.', json_schema_extra=Categories.Paths)
+    # TODO(psyche): This is not used anywhere.
+    from_file           : Optional[Path] = Field(default=None, description='Take command input from the indicated file (command-line client only).', json_schema_extra=Categories.Paths)
 
     # LOGGING
-    log_handlers        : List[str] = Field(default=["console"], description='Log handler. Valid options are "console", "file=<path>", "syslog=path|address:host:port", "http=<url>"', json_schema_extra=Categories.Logging)
+    log_handlers        : List[str] = Field(default=["console"], description='Log handler. Valid options are "console", "file=<path>", "syslog=path|address:host:port", "http=<url>".', json_schema_extra=Categories.Logging)
     # note - would be better to read the log_format values from logging.py, but this creates circular dependencies issues
-    log_format          : Literal['plain', 'color', 'syslog', 'legacy'] = Field(default="color", description='Log format. Use "plain" for text-only, "color" for colorized output, "legacy" for 2.3-style logging and "syslog" for syslog-style', json_schema_extra=Categories.Logging)
-    log_level           : Literal["debug", "info", "warning", "error", "critical"] = Field(default="info", description="Emit logging messages at this level or  higher", json_schema_extra=Categories.Logging)
-    log_sql             : bool = Field(default=False, description="Log SQL queries", json_schema_extra=Categories.Logging)
+    log_format          : Literal['plain', 'color', 'syslog', 'legacy'] = Field(default="color", description='Log format. Use "plain" for text-only, "color" for colorized output, "legacy" for 2.3-style logging and "syslog" for syslog-style.', json_schema_extra=Categories.Logging)
+    log_level           : Literal["debug", "info", "warning", "error", "critical"] = Field(default="info", description="Emit logging messages at this level or higher.", json_schema_extra=Categories.Logging)
+    log_sql             : bool = Field(default=False, description="Log SQL queries. `log_level` must be `debug` for this to do anything. Extremely verbose.", json_schema_extra=Categories.Logging)
 
     # Development
-    dev_reload          : bool = Field(default=False, description="Automatically reload when Python sources are changed.", json_schema_extra=Categories.Development)
-    profile_graphs      : bool = Field(default=False, description="Enable graph profiling", json_schema_extra=Categories.Development)
+    use_memory_db       : bool = Field(default=False, description='Use in-memory database. Useful for development.', json_schema_extra=Categories.Development)
+    dev_reload          : bool = Field(default=False, description="Automatically reload when Python sources are changed. Does not reload node definitions.", json_schema_extra=Categories.Development)
+    profile_graphs      : bool = Field(default=False, description="Enable graph profiling using `cProfile`.", json_schema_extra=Categories.Development)
     profile_prefix      : Optional[str] = Field(default=None, description="An optional prefix for profile output files.", json_schema_extra=Categories.Development)
-    profiles_dir        : Path = Field(default=Path('profiles'), description="Directory for graph profiles", json_schema_extra=Categories.Development)
+    profiles_dir        : Path = Field(default=Path('profiles'), description="Path to profiles output directory.", json_schema_extra=Categories.Development)
 
-    version             : bool = Field(default=False, description="Show InvokeAI version and exit", json_schema_extra=Categories.Other)
+    version             : bool = Field(default=False, description="CLI arg - show InvokeAI version and exit.", json_schema_extra=Categories.CLIArgs)
 
     # CACHE
-    ram                 : float = Field(default=DEFAULT_RAM_CACHE, gt=0, description="Maximum memory amount used by model cache for rapid switching (floating point number, GB)", json_schema_extra=Categories.ModelCache, )
-    vram                : float = Field(default=DEFAULT_VRAM_CACHE, ge=0, description="Amount of VRAM reserved for model storage (floating point number, GB)", json_schema_extra=Categories.ModelCache, )
+    ram                 : float = Field(default=DEFAULT_RAM_CACHE, gt=0, description="Maximum memory amount used by memory model cache for rapid switching (GB).", json_schema_extra=Categories.ModelCache, )
+    vram                : float = Field(default=DEFAULT_VRAM_CACHE, ge=0, description="Amount of VRAM reserved for model storage (GB)", json_schema_extra=Categories.ModelCache, )
     convert_cache       : float = Field(default=DEFAULT_CONVERT_CACHE, ge=0, description="Maximum size of on-disk converted models cache (GB)", json_schema_extra=Categories.ModelCache)
 
-    lazy_offload        : bool = Field(default=True, description="Keep models in VRAM until their space is needed", json_schema_extra=Categories.ModelCache, )
+    lazy_offload        : bool = Field(default=True, description="Keep models in VRAM until their space is needed.", json_schema_extra=Categories.ModelCache, )
     log_memory_usage    : bool = Field(default=False, description="If True, a memory snapshot will be captured before and after every model cache operation, and the result will be logged (at debug level). There is a time cost to capturing the memory snapshots, so it is recommended to only enable this feature if you are actively inspecting the model cache's behaviour.", json_schema_extra=Categories.ModelCache)
 
     # DEVICE
-    device              : Literal["auto", "cpu", "cuda", "cuda:1", "mps"] = Field(default="auto", description="Generation device", json_schema_extra=Categories.Device)
-    precision           : Literal["auto", "float16", "bfloat16", "float32", "autocast"] = Field(default="auto", description="Floating point precision", json_schema_extra=Categories.Device)
+    device              : Literal["auto", "cpu", "cuda", "cuda:1", "mps"] = Field(default="auto", description="Preferred execution device. `auto` will choose the device depending on the hardware platform and the installed torch capabilities.", json_schema_extra=Categories.Device)
+    precision           : Literal["auto", "float16", "bfloat16", "float32", "autocast"] = Field(default="auto", description="Floating point precision. `float16` will consume half the memory of `float32` but produce slightly lower-quality images. The `auto` setting will guess the proper precision based on your video card and operating system.", json_schema_extra=Categories.Device)
 
     # GENERATION
-    sequential_guidance : bool = Field(default=False, description="Whether to calculate guidance in serial instead of in parallel, lowering memory requirements", json_schema_extra=Categories.Generation)
-    attention_type      : Literal["auto", "normal", "xformers", "sliced", "torch-sdp"] = Field(default="auto", description="Attention type", json_schema_extra=Categories.Generation)
-    attention_slice_size: Literal["auto", "balanced", "max", 1, 2, 3, 4, 5, 6, 7, 8] = Field(default="auto", description='Slice size, valid when attention_type=="sliced"', json_schema_extra=Categories.Generation)
-    force_tiled_decode  : bool = Field(default=False, description="Whether to enable tiled VAE decode (reduces memory consumption with some performance penalty)", json_schema_extra=Categories.Generation)
-    png_compress_level  : int = Field(default=1, description="The compress_level setting of PIL.Image.save(), used for PNG encoding. All settings are lossless. 0 = fastest, largest filesize, 9 = slowest, smallest filesize", json_schema_extra=Categories.Generation)
+    sequential_guidance : bool = Field(default=False, description="Whether to calculate guidance in serial instead of in parallel, lowering memory requirements.", json_schema_extra=Categories.Generation)
+    attention_type      : Literal["auto", "normal", "xformers", "sliced", "torch-sdp"] = Field(default="auto", description="Attention type.", json_schema_extra=Categories.Generation)
+    attention_slice_size: Literal["auto", "balanced", "max", 1, 2, 3, 4, 5, 6, 7, 8] = Field(default="auto", description='Slice size, valid when attention_type=="sliced".', json_schema_extra=Categories.Generation)
+    force_tiled_decode  : bool = Field(default=False, description="Whether to enable tiled VAE decode (reduces memory consumption with some performance penalty).", json_schema_extra=Categories.Generation)
+    png_compress_level  : int = Field(default=1, description="The compress_level setting of PIL.Image.save(), used for PNG encoding. All settings are lossless. 0 = no compression, 1 = fastest with slightly larger filesize, 9 = slowest with smallest filesize. 1 is typically the best setting.", json_schema_extra=Categories.Generation)
 
     # QUEUE
-    max_queue_size      : int = Field(default=10000, gt=0, description="Maximum number of items in the session queue", json_schema_extra=Categories.Queue)
+    max_queue_size      : int = Field(default=10000, gt=0, description="Maximum number of items in the session queue.", json_schema_extra=Categories.Queue)
 
     # NODES
     allow_nodes         : Optional[List[str]] = Field(default=None, description="List of nodes to allow. Omit to allow all.", json_schema_extra=Categories.Nodes)
     deny_nodes          : Optional[List[str]] = Field(default=None, description="List of nodes to deny. Omit to deny none.", json_schema_extra=Categories.Nodes)
-    node_cache_size     : int = Field(default=512, description="How many cached nodes to keep in memory", json_schema_extra=Categories.Nodes)
+    node_cache_size     : int = Field(default=512, description="How many cached nodes to keep in memory.", json_schema_extra=Categories.Nodes)
 
-    # MODEL IMPORT
-    civitai_api_key       : Optional[str] = Field(default=os.environ.get("CIVITAI_API_KEY"), description="API key for CivitAI", json_schema_extra=Categories.Other)
+    # MODEL INSTALL
+    skip_model_hash     : bool = Field(default=False, description="Skip model hashing, instead assigning a UUID to models. Useful when using a memory db to reduce model installation time, or if you don't care about storing stable hashes for models.", json_schema_extra=Categories.ModelInstall)
+    remote_api_tokens   : Optional[list[URLRegexToken]] = Field(
+        default=None,
+        description="List of regular expression and token pairs used when downloading models from URLs. The download URL is tested against the regex, and if it matches, the token is provided in as a Bearer token.",
+        json_schema_extra=Categories.ModelInstall
+    )
 
+    # TODO(psyche): Can we just remove these then?
     # DEPRECATED FIELDS - STILL HERE IN ORDER TO OBTAN VALUES FROM PRE-3.1 CONFIG FILES
-    always_use_cpu      : bool = Field(default=False, description="If true, use the CPU for rendering even if a GPU is available.", json_schema_extra=Categories.MemoryPerformance)
-    max_cache_size      : Optional[float] = Field(default=None, gt=0, description="Maximum memory amount used by model cache for rapid switching", json_schema_extra=Categories.MemoryPerformance)
-    max_vram_cache_size : Optional[float] = Field(default=None, ge=0, description="Amount of VRAM reserved for model storage", json_schema_extra=Categories.MemoryPerformance)
-    xformers_enabled    : bool = Field(default=True, description="Enable/disable memory-efficient attention", json_schema_extra=Categories.MemoryPerformance)
-    tiled_decode        : bool = Field(default=False, description="Whether to enable tiled VAE decode (reduces memory consumption with some performance penalty)", json_schema_extra=Categories.MemoryPerformance)
-    lora_dir            : Optional[Path] = Field(default=None, description='Path to a directory of LoRA/LyCORIS models to be imported on startup.', json_schema_extra=Categories.Paths)
-    embedding_dir       : Optional[Path] = Field(default=None, description='Path to a directory of Textual Inversion embeddings to be imported on startup.', json_schema_extra=Categories.Paths)
-    controlnet_dir      : Optional[Path] = Field(default=None, description='Path to a directory of ControlNet embeddings to be imported on startup.', json_schema_extra=Categories.Paths)
-    conf_path           : Path = Field(default=Path('configs/models.yaml'), description='Path to models definition file', json_schema_extra=Categories.Paths)
+    always_use_cpu      : bool = Field(default=False, description="If true, use the CPU for rendering even if a GPU is available.", json_schema_extra=Categories.Deprecated)
+    max_cache_size      : Optional[float] = Field(default=None, gt=0, description="Maximum memory amount used by model cache for rapid switching", json_schema_extra=Categories.Deprecated)
+    max_vram_cache_size : Optional[float] = Field(default=None, ge=0, description="Amount of VRAM reserved for model storage", json_schema_extra=Categories.Deprecated)
+    xformers_enabled    : bool = Field(default=True, description="Enable/disable memory-efficient attention", json_schema_extra=Categories.Deprecated)
+    tiled_decode        : bool = Field(default=False, description="Whether to enable tiled VAE decode (reduces memory consumption with some performance penalty)", json_schema_extra=Categories.Deprecated)
+    lora_dir            : Optional[Path] = Field(default=None, description='Path to a directory of LoRA/LyCORIS models to be imported on startup.', json_schema_extra=Categories.Deprecated)
+    embedding_dir       : Optional[Path] = Field(default=None, description='Path to a directory of Textual Inversion embeddings to be imported on startup.', json_schema_extra=Categories.Deprecated)
+    controlnet_dir      : Optional[Path] = Field(default=None, description='Path to a directory of ControlNet embeddings to be imported on startup.', json_schema_extra=Categories.Deprecated)
+    conf_path           : Path = Field(default=Path('configs/models.yaml'), description='Path to models definition file', json_schema_extra=Categories.Deprecated)
 
     # this is not referred to in the source code and can be removed entirely
     #free_gpu_mem        : Optional[bool] = Field(default=None, description="If true, purge model from GPU after each generation.", json_schema_extra=Categories.MemoryPerformance)
@@ -476,6 +555,53 @@ class InvokeAIAppConfig(InvokeAISettings):
         """Choose the runtime root directory when not specified on command line or init file."""
         return _find_root()
 
+    @staticmethod
+    def generate_docstrings() -> str:
+        """Helper function for mkdocs. Generates a docstring for the InvokeAIAppConfig class.
+
+        You shouldn't run this manually. Instead, run `scripts/update-config-docstring.py` to update the docstring.
+        A makefile target is also available: `make update-config-docstring`.
+
+        See that script for more information about why this is necessary.
+        """
+        docstring = '    """Invoke App Configuration\n\n'
+        docstring += "    Attributes:"
+
+        field_descriptions: dict[str, list[str]] = {}
+
+        for k, v in InvokeAIAppConfig.model_fields.items():
+            if not isinstance(v.json_schema_extra, dict):
+                # Should never happen
+                continue
+
+            category = v.json_schema_extra.get("category", None)
+            if not isinstance(category, str) or category == "Deprecated":
+                continue
+            if not field_descriptions.get(category):
+                field_descriptions[category] = []
+            field_descriptions[category].append(f"        {k}: **{category}**: {v.description}")
+
+        for c in [
+            "Web Server",
+            "Features",
+            "Paths",
+            "Logging",
+            "Development",
+            "CLIArgs",
+            "Model Install",
+            "Model Cache",
+            "Device",
+            "Generation",
+            "Queue",
+            "Nodes",
+        ]:
+            docstring += "\n"
+            docstring += "\n".join(field_descriptions[c])
+
+        docstring += '\n    """'
+
+        return docstring
+
 
 def get_invokeai_config(**kwargs: Any) -> InvokeAIAppConfig:
     """Legacy function which returns InvokeAIAppConfig.get_config()."""

invokeai/app/services/invocation_cache/invocation_cache_base.py

@@ -41,8 +41,9 @@ class InvocationCacheBase(ABC):
         """Clears the cache"""
         pass
 
+    @staticmethod
     @abstractmethod
-    def create_key(self, invocation: BaseInvocation) -> int:
+    def create_key(invocation: BaseInvocation) -> int:
         """Gets the key for the invocation's cache item"""
         pass
 

invokeai/app/services/invocation_cache/invocation_cache_memory.py

@@ -61,9 +61,7 @@ class MemoryInvocationCache(InvocationCacheBase):
             self._delete_oldest_access(number_to_delete)
             self._cache[key] = CachedItem(
                 invocation_output,
-                invocation_output.model_dump_json(
-                    warnings=False, exclude_defaults=True, exclude_unset=True, include={"type"}
-                ),
+                invocation_output.model_dump_json(warnings=False, exclude_defaults=True, exclude_unset=True),
             )
 
     def _delete_oldest_access(self, number_to_delete: int) -> None:
@@ -81,7 +79,7 @@ class MemoryInvocationCache(InvocationCacheBase):
         with self._lock:
             return self._delete(key)
 
-    def clear(self, *args, **kwargs) -> None:
+    def clear(self) -> None:
         with self._lock:
             if self._max_cache_size == 0:
                 return

invokeai/app/services/invocation_services.py

@@ -25,6 +25,7 @@ if TYPE_CHECKING:
     from .images.images_base import ImageServiceABC
     from .invocation_cache.invocation_cache_base import InvocationCacheBase
     from .invocation_stats.invocation_stats_base import InvocationStatsServiceBase
+    from .model_images.model_images_base import ModelImageFileStorageBase
     from .model_manager.model_manager_base import ModelManagerServiceBase
     from .names.names_base import NameServiceBase
     from .session_processor.session_processor_base import SessionProcessorBase
@@ -49,6 +50,7 @@ class InvocationServices:
         image_files: "ImageFileStorageBase",
         image_records: "ImageRecordStorageBase",
         logger: "Logger",
+        model_images: "ModelImageFileStorageBase",
         model_manager: "ModelManagerServiceBase",
         download_queue: "DownloadQueueServiceBase",
         performance_statistics: "InvocationStatsServiceBase",
@@ -72,6 +74,7 @@ class InvocationServices:
         self.image_files = image_files
         self.image_records = image_records
         self.logger = logger
+        self.model_images = model_images
         self.model_manager = model_manager
         self.download_queue = download_queue
         self.performance_statistics = performance_statistics

invokeai/app/services/model_images/model_images_base.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from PIL.Image import Image as PILImageType
+
+
+class ModelImageFileStorageBase(ABC):
+    """Low-level service responsible for storing and retrieving image files."""
+
+    @abstractmethod
+    def get(self, model_key: str) -> PILImageType:
+        """Retrieves a model image as PIL Image."""
+        pass
+
+    @abstractmethod
+    def get_path(self, model_key: str) -> Path:
+        """Gets the internal path to a model image."""
+        pass
+
+    @abstractmethod
+    def get_url(self, model_key: str) -> str | None:
+        """Gets the URL to fetch a model image."""
+        pass
+
+    @abstractmethod
+    def save(self, image: PILImageType, model_key: str) -> None:
+        """Saves a model image."""
+        pass
+
+    @abstractmethod
+    def delete(self, model_key: str) -> None:
+        """Deletes a model image."""
+        pass

invokeai/app/services/model_images/model_images_common.py

@@ -0,0 +1,20 @@
+# TODO: Should these excpetions subclass existing python exceptions?
+class ModelImageFileNotFoundException(Exception):
+    """Raised when an image file is not found in storage."""
+
+    def __init__(self, message="Model image file not found"):
+        super().__init__(message)
+
+
+class ModelImageFileSaveException(Exception):
+    """Raised when an image cannot be saved."""
+
+    def __init__(self, message="Model image file not saved"):
+        super().__init__(message)
+
+
+class ModelImageFileDeleteException(Exception):
+    """Raised when an image cannot be deleted."""
+
+    def __init__(self, message="Model image file not deleted"):
+        super().__init__(message)

invokeai/app/services/model_images/model_images_default.py

@@ -0,0 +1,85 @@
+from pathlib import Path
+
+from PIL import Image
+from PIL.Image import Image as PILImageType
+from send2trash import send2trash
+
+from invokeai.app.services.invoker import Invoker
+from invokeai.app.util.misc import uuid_string
+from invokeai.app.util.thumbnails import make_thumbnail
+
+from .model_images_base import ModelImageFileStorageBase
+from .model_images_common import (
+    ModelImageFileDeleteException,
+    ModelImageFileNotFoundException,
+    ModelImageFileSaveException,
+)
+
+
+class ModelImageFileStorageDisk(ModelImageFileStorageBase):
+    """Stores images on disk"""
+
+    def __init__(self, model_images_folder: Path):
+        self._model_images_folder = model_images_folder
+        self._validate_storage_folders()
+
+    def start(self, invoker: Invoker) -> None:
+        self._invoker = invoker
+
+    def get(self, model_key: str) -> PILImageType:
+        try:
+            path = self.get_path(model_key)
+
+            if not self._validate_path(path):
+                raise ModelImageFileNotFoundException
+
+            return Image.open(path)
+        except FileNotFoundError as e:
+            raise ModelImageFileNotFoundException from e
+
+    def save(self, image: PILImageType, model_key: str) -> None:
+        try:
+            self._validate_storage_folders()
+            image_path = self._model_images_folder / (model_key + ".webp")
+            thumbnail = make_thumbnail(image, 256)
+            thumbnail.save(image_path, format="webp")
+
+        except Exception as e:
+            raise ModelImageFileSaveException from e
+
+    def get_path(self, model_key: str) -> Path:
+        path = self._model_images_folder / (model_key + ".webp")
+
+        return path
+
+    def get_url(self, model_key: str) -> str | None:
+        path = self.get_path(model_key)
+        if not self._validate_path(path):
+            return
+
+        url = self._invoker.services.urls.get_model_image_url(model_key)
+
+        # The image URL never changes, so we must add random query string to it to prevent caching
+        url += f"?{uuid_string()}"
+
+        return url
+
+    def delete(self, model_key: str) -> None:
+        try:
+            path = self.get_path(model_key)
+
+            if not self._validate_path(path):
+                raise ModelImageFileNotFoundException
+
+            send2trash(path)
+
+        except Exception as e:
+            raise ModelImageFileDeleteException from e
+
+    def _validate_path(self, path: Path) -> bool:
+        """Validates the path given for an image."""
+        return path.exists()
+
+    def _validate_storage_folders(self) -> None:
+        """Checks if the required folders exist and create them if they don't"""
+        self._model_images_folder.mkdir(parents=True, exist_ok=True)

invokeai/app/services/model_install/__init__.py

@@ -1,7 +1,6 @@
 """Initialization file for model install service package."""
 
 from .model_install_base import (
-    CivitaiModelSource,
     HFModelSource,
     InstallStatus,
     LocalModelSource,
@@ -23,5 +22,4 @@ __all__ = [
     "LocalModelSource",
     "HFModelSource",
     "URLModelSource",
-    "CivitaiModelSource",
 ]

invokeai/app/services/model_install/model_install_base.py

@@ -18,10 +18,9 @@ from invokeai.app.services.events.events_base import EventServiceBase
 from invokeai.app.services.invoker import Invoker
 from invokeai.app.services.model_records import ModelRecordServiceBase
 from invokeai.backend.model_manager import AnyModelConfig, ModelRepoVariant
+from invokeai.backend.model_manager.config import ModelSourceType
 from invokeai.backend.model_manager.metadata import AnyModelRepoMetadata
 
-from ..model_metadata import ModelMetadataStoreBase
-
 
 class InstallStatus(str, Enum):
     """State of an install job running in the background."""
@@ -92,21 +91,6 @@ class LocalModelSource(StringLikeSource):
         return Path(self.path).as_posix()
 
 
-class CivitaiModelSource(StringLikeSource):
-    """A Civitai version id, with optional variant and access token."""
-
-    version_id: int
-    variant: Optional[ModelRepoVariant] = None
-    access_token: Optional[str] = None
-    type: Literal["civitai"] = "civitai"
-
-    def __str__(self) -> str:
-        """Return string version of repoid when string rep needed."""
-        base: str = str(self.version_id)
-        base += f" ({self.variant})" if self.variant else ""
-        return base
-
-
 class HFModelSource(StringLikeSource):
     """
     A HuggingFace repo_id with optional variant, sub-folder and access token.
@@ -147,9 +131,13 @@ class URLModelSource(StringLikeSource):
         return str(self.url)
 
 
-ModelSource = Annotated[
-    Union[LocalModelSource, HFModelSource, CivitaiModelSource, URLModelSource], Field(discriminator="type")
-]
+ModelSource = Annotated[Union[LocalModelSource, HFModelSource, URLModelSource], Field(discriminator="type")]
+
+MODEL_SOURCE_TO_TYPE_MAP = {
+    URLModelSource: ModelSourceType.Url,
+    HFModelSource: ModelSourceType.HFRepoID,
+    LocalModelSource: ModelSourceType.Path,
+}
 
 
 class ModelInstallJob(BaseModel):
@@ -260,7 +248,6 @@ class ModelInstallServiceBase(ABC):
         app_config: InvokeAIAppConfig,
         record_store: ModelRecordServiceBase,
         download_queue: DownloadQueueServiceBase,
-        metadata_store: ModelMetadataStoreBase,
         event_bus: Optional["EventServiceBase"] = None,
     ):
         """
@@ -347,6 +334,7 @@ class ModelInstallServiceBase(ABC):
         source: str,
         config: Optional[Dict[str, Any]] = None,
         access_token: Optional[str] = None,
+        inplace: Optional[bool] = False,
     ) -> ModelInstallJob:
         r"""Install the indicated model using heuristics to interpret user intentions.
 
@@ -392,7 +380,7 @@ class ModelInstallServiceBase(ABC):
          will override corresponding autoassigned probe fields in the
          model's config record. Use it to override
          `name`, `description`, `base_type`, `model_type`, `format`,
-         `prediction_type`, `image_size`, and/or `ztsnr_training`.
+         `prediction_type`, and/or `image_size`.
 
         This will download the model located at `source`,
         probe it, and install it into the models directory.

invokeai/app/services/model_install/model_install_default.py

@@ -12,6 +12,7 @@ from tempfile import mkdtemp
 from typing import Any, Dict, List, Optional, Set, Union
 
 from huggingface_hub import HfFolder
+from omegaconf import DictConfig, OmegaConf
 from pydantic.networks import AnyHttpUrl
 from requests import Session
 
@@ -20,28 +21,31 @@ from invokeai.app.services.download import DownloadJob, DownloadQueueServiceBase
 from invokeai.app.services.events.events_base import EventServiceBase
 from invokeai.app.services.invoker import Invoker
 from invokeai.app.services.model_records import DuplicateModelException, ModelRecordServiceBase
+from invokeai.app.services.model_records.model_records_base import ModelRecordChanges
 from invokeai.app.util.misc import uuid_string
 from invokeai.backend.model_manager.config import (
     AnyModelConfig,
     BaseModelType,
+    CheckpointConfigBase,
     InvalidModelConfigException,
     ModelRepoVariant,
+    ModelSourceType,
     ModelType,
 )
 from invokeai.backend.model_manager.metadata import (
     AnyModelRepoMetadata,
-    CivitaiMetadataFetch,
     HuggingFaceMetadataFetch,
     ModelMetadataWithFiles,
     RemoteModelFile,
 )
+from invokeai.backend.model_manager.metadata.metadata_base import HuggingFaceMetadata
 from invokeai.backend.model_manager.probe import ModelProbe
 from invokeai.backend.model_manager.search import ModelSearch
 from invokeai.backend.util import Chdir, InvokeAILogger
 from invokeai.backend.util.devices import choose_precision, choose_torch_device
 
 from .model_install_base import (
-    CivitaiModelSource,
+    MODEL_SOURCE_TO_TYPE_MAP,
     HFModelSource,
     InstallStatus,
     LocalModelSource,
@@ -90,7 +94,6 @@ class ModelInstallService(ModelInstallServiceBase):
         self._running = False
         self._session = session
         self._next_job_id = 0
-        self._metadata_store = record_store.metadata_store  # for convenience
 
     @property
     def app_config(self) -> InvokeAIAppConfig:  # noqa D102
@@ -113,6 +116,7 @@ class ModelInstallService(ModelInstallServiceBase):
                 raise Exception("Attempt to start the installer service twice")
             self._start_installer_thread()
             self._remove_dangling_install_dirs()
+            self._migrate_yaml()
             self.sync_to_config()
 
     def stop(self, invoker: Optional[Invoker] = None) -> None:
@@ -139,6 +143,7 @@ class ModelInstallService(ModelInstallServiceBase):
         config = config or {}
         if not config.get("source"):
             config["source"] = model_path.resolve().as_posix()
+        config["source_type"] = ModelSourceType.Path
         return self._register(model_path, config)
 
     def install_path(
@@ -148,11 +153,11 @@ class ModelInstallService(ModelInstallServiceBase):
     ) -> str:  # noqa D102
         model_path = Path(model_path)
         config = config or {}
-        if not config.get("source"):
-            config["source"] = model_path.resolve().as_posix()
-        config["key"] = config.get("key", uuid_string())
 
-        info: AnyModelConfig = self._probe_model(Path(model_path), config)
+        if self._app_config.skip_model_hash:
+            config["hash"] = uuid_string()
+
+        info: AnyModelConfig = ModelProbe.probe(Path(model_path), config)
 
         if preferred_name := config.get("name"):
             preferred_name = Path(preferred_name).with_suffix(model_path.suffix)
@@ -178,7 +183,7 @@ class ModelInstallService(ModelInstallServiceBase):
         source: str,
         config: Optional[Dict[str, Any]] = None,
         access_token: Optional[str] = None,
-        inplace: bool = False,
+        inplace: Optional[bool] = False,
     ) -> ModelInstallJob:
         variants = "|".join(ModelRepoVariant.__members__.values())
         hf_repoid_re = f"^([^/:]+/[^/:]+)(?::({variants})?(?::/?([^:]+))?)?$"
@@ -194,9 +199,16 @@ class ModelInstallService(ModelInstallServiceBase):
                 access_token=access_token,
             )
         elif re.match(r"^https?://[^/]+", source):
+            # Pull the token from config if it exists and matches the URL
+            _token = access_token
+            if _token is None:
+                for pair in self.app_config.remote_api_tokens or []:
+                    if re.search(pair.url_regex, source):
+                        _token = pair.token
+                        break
             source_obj = URLModelSource(
                 url=AnyHttpUrl(source),
-                access_token=access_token,
+                access_token=_token,
             )
         else:
             raise ValueError(f"Unsupported model source: '{source}'")
@@ -211,8 +223,6 @@ class ModelInstallService(ModelInstallServiceBase):
         if isinstance(source, LocalModelSource):
             install_job = self._import_local_model(source, config)
             self._install_queue.put(install_job)  # synchronously install
-        elif isinstance(source, CivitaiModelSource):
-            install_job = self._import_from_civitai(source, config)
         elif isinstance(source, HFModelSource):
             install_job = self._import_from_hf(source, config)
         elif isinstance(source, URLModelSource):
@@ -279,10 +289,52 @@ class ModelInstallService(ModelInstallServiceBase):
             self._logger.info(f"{len(installed)} new models registered")
         self._logger.info("Model installer (re)initialized")
 
+    def _migrate_yaml(self) -> None:
+        db_models = self.record_store.all_models()
+        try:
+            yaml = self._get_yaml()
+        except OSError:
+            return
+
+        yaml_metadata = yaml.pop("__metadata__")
+        yaml_version = yaml_metadata.get("version")
+
+        if yaml_version != "3.0.0":
+            raise ValueError(
+                f"Attempted migration of unsupported `models.yaml` v{yaml_version}. Only v3.0.0 is supported. Exiting."
+            )
+
+        self._logger.info(
+            f"Starting one-time migration of {len(yaml.items())} models from `models.yaml` to database. This may take a few minutes."
+        )
+
+        if len(db_models) == 0 and len(yaml.items()) != 0:
+            for model_key, stanza in yaml.items():
+                _, _, model_name = str(model_key).split("/")
+                model_path = Path(stanza["path"])
+                if not model_path.is_absolute():
+                    model_path = self._app_config.models_path / model_path
+                model_path = model_path.resolve()
+
+                config: dict[str, Any] = {}
+                config["name"] = model_name
+                config["description"] = stanza.get("description")
+                config["config_path"] = stanza.get("config")
+
+                try:
+                    id = self.register_path(model_path=model_path, config=config)
+                    self._logger.info(f"Migrated {model_name} with id {id}")
+                except Exception as e:
+                    self._logger.warning(f"Model at {model_path} could not be migrated: {e}")
+
+        # Rename `models.yaml` to `models.yaml.bak` to prevent re-migration
+        yaml_path = self._app_config.model_conf_path
+        yaml_path.rename(yaml_path.with_suffix(".yaml.bak"))
+
     def scan_directory(self, scan_dir: Path, install: bool = False) -> List[str]:  # noqa D102
         self._cached_model_paths = {Path(x.path).absolute() for x in self.record_store.all_models()}
         callback = self._scan_install if install else self._scan_register
-        search = ModelSearch(on_model_found=callback, config=self._app_config)
+        search = ModelSearch(on_model_found=callback)
         self._models_installed.clear()
         search.search(scan_dir)
         return list(self._models_installed)
@@ -294,7 +346,7 @@ class ModelInstallService(ModelInstallServiceBase):
         """Unregister the model. Delete its files only if they are within our models directory."""
         model = self.record_store.get_model(key)
         models_dir = self.app_config.models_path
-        model_path = models_dir / model.path
+        model_path = Path(model.path)
         if model_path.is_relative_to(models_dir):
             self.unconditionally_delete(key)
         else:
@@ -302,11 +354,11 @@ class ModelInstallService(ModelInstallServiceBase):
 
     def unconditionally_delete(self, key: str) -> None:  # noqa D102
         model = self.record_store.get_model(key)
-        path = self.app_config.models_path / model.path
-        if path.is_dir():
-            rmtree(path)
+        model_path = Path(model.path)
+        if model_path.is_dir():
+            rmtree(model_path)
         else:
-            path.unlink()
+            model_path.unlink()
         self.unregister(key)
 
     def download_and_cache(
@@ -374,15 +426,16 @@ class ModelInstallService(ModelInstallServiceBase):
                     job.bytes = job.total_bytes
                     self._signal_job_running(job)
                     job.config_in["source"] = str(job.source)
+                    job.config_in["source_type"] = MODEL_SOURCE_TO_TYPE_MAP[job.source.__class__]
+                    # enter the metadata, if there is any
+                    if isinstance(job.source_metadata, (HuggingFaceMetadata)):
+                        job.config_in["source_api_response"] = job.source_metadata.api_response
+
                     if job.inplace:
                         key = self.register_path(job.local_path, job.config_in)
                     else:
                         key = self.install_path(job.local_path, job.config_in)
                     job.config_out = self.record_store.get_model(key)
-
-                    # enter the metadata, if there is any
-                    if job.source_metadata:
-                        self._metadata_store.add_metadata(key, job.source_metadata)
                     self._signal_job_completed(job)
 
             except InvalidModelConfigException as excp:
@@ -442,7 +495,7 @@ class ModelInstallService(ModelInstallServiceBase):
             self._logger.info(f"Scanning {self._app_config.models_path} for new and orphaned models")
             for cur_base_model in BaseModelType:
                 for cur_model_type in ModelType:
-                    models_dir = Path(cur_base_model.value, cur_model_type.value)
+                    models_dir = self._app_config.models_path / Path(cur_base_model.value, cur_model_type.value)
                     installed.update(self.scan_directory(models_dir))
             self._logger.info(f"{len(installed)} new models registered; {len(defunct_models)} unregistered")
 
@@ -461,14 +514,21 @@ class ModelInstallService(ModelInstallServiceBase):
         old_path = Path(model.path)
         models_dir = self.app_config.models_path
 
-        if not old_path.is_relative_to(models_dir):
+        try:
+            old_path.relative_to(models_dir)
+            return model
+        except ValueError:
+            pass
+
+        new_path = models_dir / model.base.value / model.type.value / old_path.name
+
+        if old_path == new_path:
             return model
 
-        new_path = models_dir / model.base.value / model.type.value / model.name
         self._logger.info(f"Moving {model.name} to {new_path}.")
         new_path = self._move_model(old_path, new_path)
-        model.path = new_path.relative_to(models_dir).as_posix()
-        self.record_store.update_model(key, model)
+        model.path = new_path.as_posix()
+        self.record_store.update_model(key, ModelRecordChanges(path=model.path))
         return model
 
     def _scan_register(self, model: Path) -> bool:
@@ -520,37 +580,25 @@ class ModelInstallService(ModelInstallServiceBase):
         move(old_path, new_path)
         return new_path
 
-    def _probe_model(self, model_path: Path, config: Optional[Dict[str, Any]] = None) -> AnyModelConfig:
-        info: AnyModelConfig = ModelProbe.probe(Path(model_path))
-        if config:  # used to override probe fields
-            for key, value in config.items():
-                setattr(info, key, value)
-        return info
-
     def _register(
         self, model_path: Path, config: Optional[Dict[str, Any]] = None, info: Optional[AnyModelConfig] = None
     ) -> str:
-        # Note that we may be passed a pre-populated AnyModelConfig object,
-        # in which case the key field should have been populated by the caller (e.g. in `install_path`).
-        config["key"] = config.get("key", uuid_string())
+        config = config or {}
+
+        if self._app_config.skip_model_hash:
+            config["hash"] = uuid_string()
+
         info = info or ModelProbe.probe(model_path, config)
-        override_key: Optional[str] = config.get("key") if config else None
 
-        assert info.original_hash  # always assigned by probe()
-        info.key = override_key or info.original_hash
-
-        model_path = model_path.absolute()
-        if model_path.is_relative_to(self.app_config.models_path):
-            model_path = model_path.relative_to(self.app_config.models_path)
+        model_path = model_path.resolve()
 
         info.path = model_path.as_posix()
 
         # add 'main' specific fields
-        if hasattr(info, "config"):
-            # make config relative to our root
-            legacy_conf = (self.app_config.root_dir / self.app_config.legacy_conf_dir / info.config).resolve()
-            info.config = legacy_conf.relative_to(self.app_config.root_dir).as_posix()
-        self.record_store.add_model(info.key, info)
+        if isinstance(info, CheckpointConfigBase):
+            legacy_conf = (self.app_config.root_dir / self.app_config.legacy_conf_dir / info.config_path).resolve()
+            info.config_path = legacy_conf.as_posix()
+        self.record_store.add_model(info)
         return info.key
 
     def _next_id(self) -> int:
@@ -559,6 +607,16 @@ class ModelInstallService(ModelInstallServiceBase):
             self._next_job_id += 1
         return id
 
+    # --------------------------------------------------------------------------------------------
+    # Internal functions that manage the old yaml config
+    # --------------------------------------------------------------------------------------------
+    def _get_yaml(self) -> DictConfig:
+        """Fetch the models.yaml DictConfig for this installation."""
+        yaml_path = self._app_config.model_conf_path
+        omegaconf = OmegaConf.load(yaml_path)
+        assert isinstance(omegaconf, DictConfig)
+        return omegaconf
+
     @staticmethod
     def _guess_variant() -> Optional[ModelRepoVariant]:
         """Guess the best HuggingFace variant type to download."""
@@ -571,17 +629,9 @@ class ModelInstallService(ModelInstallServiceBase):
             source=source,
             config_in=config or {},
             local_path=Path(source.path),
-            inplace=source.inplace,
+            inplace=source.inplace or False,
         )
 
-    def _import_from_civitai(self, source: CivitaiModelSource, config: Optional[Dict[str, Any]]) -> ModelInstallJob:
-        if not source.access_token:
-            self._logger.info("No Civitai access token provided; some models may not be downloadable.")
-        metadata = CivitaiMetadataFetch(self._session).from_id(str(source.version_id))
-        assert isinstance(metadata, ModelMetadataWithFiles)
-        remote_files = metadata.download_urls(session=self._session)
-        return self._import_remote_model(source=source, config=config, metadata=metadata, remote_files=remote_files)
-
     def _import_from_hf(self, source: HFModelSource, config: Optional[Dict[str, Any]]) -> ModelInstallJob:
         # Add user's cached access token to HuggingFace requests
         source.access_token = source.access_token or HfFolder.get_token()
@@ -604,16 +654,16 @@ class ModelInstallService(ModelInstallServiceBase):
         )
 
     def _import_from_url(self, source: URLModelSource, config: Optional[Dict[str, Any]]) -> ModelInstallJob:
-        # URLs from Civitai or HuggingFace will be handled specially
-        url_patterns = {
-            r"^https?://civitai.com/": CivitaiMetadataFetch,
-            r"^https?://huggingface.co/[^/]+/[^/]+$": HuggingFaceMetadataFetch,
-        }
+        # URLs from HuggingFace will be handled specially
         metadata = None
-        for pattern, fetcher in url_patterns.items():
-            if re.match(pattern, str(source.url), re.IGNORECASE):
-                metadata = fetcher(self._session).from_url(source.url)
-                break
+        fetcher = None
+        try:
+            fetcher = self.get_fetcher_from_url(str(source.url))
+        except ValueError:
+            pass
+        kwargs: dict[str, Any] = {"session": self._session}
+        if fetcher is not None:
+            metadata = fetcher(**kwargs).from_url(source.url)
         self._logger.debug(f"metadata={metadata}")
         if metadata and isinstance(metadata, ModelMetadataWithFiles):
             remote_files = metadata.download_urls(session=self._session)
@@ -628,7 +678,7 @@ class ModelInstallService(ModelInstallServiceBase):
 
     def _import_remote_model(
         self,
-        source: ModelSource,
+        source: HFModelSource | URLModelSource,
         remote_files: List[RemoteModelFile],
         metadata: Optional[AnyModelRepoMetadata],
         config: Optional[Dict[str, Any]],
@@ -656,7 +706,7 @@ class ModelInstallService(ModelInstallServiceBase):
         # In the event that there is a subfolder specified in the source,
         # we need to remove it from the destination path in order to avoid
         # creating unwanted subfolders
-        if hasattr(source, "subfolder") and source.subfolder:
+        if isinstance(source, HFModelSource) and source.subfolder:
             root = Path(remote_files[0].path.parts[0])
             subfolder = root / source.subfolder
         else:
@@ -843,3 +893,9 @@ class ModelInstallService(ModelInstallServiceBase):
         self._logger.info(f"{job.source}: model installation was cancelled")
         if self._event_bus:
             self._event_bus.emit_model_install_cancelled(str(job.source))
+
+    @staticmethod
+    def get_fetcher_from_url(url: str):
+        if re.match(r"^https?://huggingface.co/[^/]+/[^/]+$", url.lower()):
+            return HuggingFaceMetadataFetch
+        raise ValueError(f"Unsupported model source: '{url}'")

invokeai/app/services/model_manager/model_manager_base.py

@@ -1,15 +1,11 @@
 # Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Team
 
 from abc import ABC, abstractmethod
-from typing import Optional
 
 import torch
 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
@@ -70,32 +66,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

invokeai/app/services/model_manager/model_manager_default.py

@@ -1,14 +1,10 @@
 # Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Team
 """Implementation of ModelManagerServiceBase."""
 
-from typing import Optional
-
 import torch
 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 import AnyModelConfig, BaseModelType, LoadedModel, ModelType, SubModelType
 from invokeai.backend.model_manager.load import ModelCache, ModelConvertCache, ModelLoaderRegistry
 from invokeai.backend.util.devices import choose_torch_device
 from invokeai.backend.util.logging import InvokeAILogger
@@ -18,7 +14,7 @@ from ..download import DownloadQueueServiceBase
 from ..events.events_base import EventServiceBase
 from ..model_install import ModelInstallService, ModelInstallServiceBase
 from ..model_load import ModelLoadService, ModelLoadServiceBase
-from ..model_records import ModelRecordServiceBase, UnknownModelException
+from ..model_records import ModelRecordServiceBase
 from .model_manager_base import ModelManagerServiceBase
 
 
@@ -64,56 +60,6 @@ class ModelManagerService(ModelManagerServiceBase):
             if hasattr(service, "stop"):
                 service.stop(invoker)
 
-    def load_model_by_config(
-        self,
-        model_config: AnyModelConfig,
-        submodel_type: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
-    ) -> LoadedModel:
-        return self.load.load_model(model_config, submodel_type, context_data)
-
-    def load_model_by_key(
-        self,
-        key: str,
-        submodel_type: Optional[SubModelType] = None,
-        context_data: Optional[InvocationContextData] = None,
-    ) -> LoadedModel:
-        config = self.store.get_model(key)
-        return self.load.load_model(config, submodel_type, context_data)
-
-    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:
-        """
-        Given a model's attributes, search the database for it, and if found, load and return the LoadedModel object.
-
-        This is provided for API compatability with the get_model() method
-        in the original model manager. However, note that LoadedModel is
-        not the same as the original ModelInfo that ws returned.
-
-        :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
-        :param context: The invocation context.
-
-        Exceptions: UnknownModelException -- model with this key not known
-                    NotImplementedException -- a model loader was not provided at initialization time
-                    ValueError -- more than one model matches this combination
-        """
-        configs = self.store.search_by_attr(model_name, base_model, model_type)
-        if len(configs) == 0:
-            raise UnknownModelException(f"{base_model}/{model_type}/{model_name}: Unknown model")
-        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)
-
     @classmethod
     def build_model_manager(
         cls,

invokeai/app/services/model_metadata/__init__.py

@@ -1,9 +0,0 @@
-"""Init file for ModelMetadataStoreService module."""
-
-from .metadata_store_base import ModelMetadataStoreBase
-from .metadata_store_sql import ModelMetadataStoreSQL
-
-__all__ = [
-    "ModelMetadataStoreBase",
-    "ModelMetadataStoreSQL",
-]

invokeai/app/services/model_metadata/metadata_store_base.py

@@ -1,81 +0,0 @@
-# Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Development Team
-"""
-Storage for Model Metadata
-"""
-
-from abc import ABC, abstractmethod
-from typing import List, Optional, Set, Tuple
-
-from pydantic import Field
-
-from invokeai.app.util.model_exclude_null import BaseModelExcludeNull
-from invokeai.backend.model_manager.metadata import AnyModelRepoMetadata
-from invokeai.backend.model_manager.metadata.metadata_base import ModelDefaultSettings
-
-
-class ModelMetadataChanges(BaseModelExcludeNull, extra="allow"):
-    """A set of changes to apply to model metadata.
-    Only limited changes are valid:
-      - `default_settings`: the user-configured default settings for this model
-    """
-
-    default_settings: Optional[ModelDefaultSettings] = Field(
-        default=None, description="The user-configured default settings for this model"
-    )
-    """The user-configured default settings for this model"""
-
-
-class ModelMetadataStoreBase(ABC):
-    """Store, search and fetch model metadata retrieved from remote repositories."""
-
-    @abstractmethod
-    def add_metadata(self, model_key: str, metadata: AnyModelRepoMetadata) -> None:
-        """
-        Add a block of repo metadata to a model record.
-
-        The model record config must already exist in the database with the
-        same key. Otherwise a FOREIGN KEY constraint exception will be raised.
-
-        :param model_key: Existing model key in the `model_config` table
-        :param metadata: ModelRepoMetadata object to store
-        """
-
-    @abstractmethod
-    def get_metadata(self, model_key: str) -> AnyModelRepoMetadata:
-        """Retrieve the ModelRepoMetadata corresponding to model key."""
-
-    @abstractmethod
-    def list_all_metadata(self) -> List[Tuple[str, AnyModelRepoMetadata]]:  # key, metadata
-        """Dump out all the metadata."""
-
-    @abstractmethod
-    def update_metadata(self, model_key: str, metadata: AnyModelRepoMetadata) -> AnyModelRepoMetadata:
-        """
-        Update metadata corresponding to the model with the indicated key.
-
-        :param model_key: Existing model key in the `model_config` table
-        :param metadata: ModelRepoMetadata object to update
-        """
-
-    @abstractmethod
-    def list_tags(self) -> Set[str]:
-        """Return all tags in the tags table."""
-
-    @abstractmethod
-    def search_by_tag(self, tags: Set[str]) -> Set[str]:
-        """Return the keys of models containing all of the listed tags."""
-
-    @abstractmethod
-    def search_by_author(self, author: str) -> Set[str]:
-        """Return the keys of models authored by the indicated author."""
-
-    @abstractmethod
-    def search_by_name(self, name: str) -> Set[str]:
-        """
-        Return the keys of models with the indicated name.
-
-        Note that this is the name of the model given to it by
-        the remote source. The user may have changed the local
-        name. The local name will be located in the model config
-        record object.
-        """

invokeai/app/services/model_metadata/metadata_store_sql.py

@@ -1,223 +0,0 @@
-# Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Development Team
-"""
-SQL Storage for Model Metadata
-"""
-
-import sqlite3
-from typing import List, Optional, Set, Tuple
-
-from invokeai.app.services.shared.sqlite.sqlite_database import SqliteDatabase
-from invokeai.backend.model_manager.metadata import AnyModelRepoMetadata, UnknownMetadataException
-from invokeai.backend.model_manager.metadata.fetch import ModelMetadataFetchBase
-
-from .metadata_store_base import ModelMetadataStoreBase
-
-
-class ModelMetadataStoreSQL(ModelMetadataStoreBase):
-    """Store, search and fetch model metadata retrieved from remote repositories."""
-
-    def __init__(self, db: SqliteDatabase):
-        """
-        Initialize a new object from preexisting sqlite3 connection and threading lock objects.
-
-        :param conn: sqlite3 connection object
-        :param lock: threading Lock object
-        """
-        super().__init__()
-        self._db = db
-        self._cursor = self._db.conn.cursor()
-
-    def add_metadata(self, model_key: str, metadata: AnyModelRepoMetadata) -> None:
-        """
-        Add a block of repo metadata to a model record.
-
-        The model record config must already exist in the database with the
-        same key. Otherwise a FOREIGN KEY constraint exception will be raised.
-
-        :param model_key: Existing model key in the `model_config` table
-        :param metadata: ModelRepoMetadata object to store
-        """
-        json_serialized = metadata.model_dump_json()
-        with self._db.lock:
-            try:
-                self._cursor.execute(
-                    """--sql
-                    INSERT INTO model_metadata(
-                       id,
-                       metadata
-                    )
-                    VALUES (?,?);
-                    """,
-                    (
-                        model_key,
-                        json_serialized,
-                    ),
-                )
-                self._update_tags(model_key, metadata.tags)
-                self._db.conn.commit()
-            except sqlite3.IntegrityError as excp:  # FOREIGN KEY error: the key was not in model_config table
-                self._db.conn.rollback()
-                raise UnknownMetadataException from excp
-            except sqlite3.Error as excp:
-                self._db.conn.rollback()
-                raise excp
-
-    def get_metadata(self, model_key: str) -> AnyModelRepoMetadata:
-        """Retrieve the ModelRepoMetadata corresponding to model key."""
-        with self._db.lock:
-            self._cursor.execute(
-                """--sql
-                SELECT metadata FROM model_metadata
-                WHERE id=?;
-                """,
-                (model_key,),
-            )
-            rows = self._cursor.fetchone()
-            if not rows:
-                raise UnknownMetadataException("model metadata not found")
-            return ModelMetadataFetchBase.from_json(rows[0])
-
-    def list_all_metadata(self) -> List[Tuple[str, AnyModelRepoMetadata]]:  # key, metadata
-        """Dump out all the metadata."""
-        with self._db.lock:
-            self._cursor.execute(
-                """--sql
-                SELECT id,metadata FROM model_metadata;
-                """,
-                (),
-            )
-            rows = self._cursor.fetchall()
-        return [(x[0], ModelMetadataFetchBase.from_json(x[1])) for x in rows]
-
-    def update_metadata(self, model_key: str, metadata: AnyModelRepoMetadata) -> AnyModelRepoMetadata:
-        """
-        Update metadata corresponding to the model with the indicated key.
-
-        :param model_key: Existing model key in the `model_config` table
-        :param metadata: ModelRepoMetadata object to update
-        """
-        json_serialized = metadata.model_dump_json()  # turn it into a json string.
-        with self._db.lock:
-            try:
-                self._cursor.execute(
-                    """--sql
-                    UPDATE model_metadata
-                    SET
-                        metadata=?
-                    WHERE id=?;
-                    """,
-                    (json_serialized, model_key),
-                )
-                if self._cursor.rowcount == 0:
-                    raise UnknownMetadataException("model metadata not found")
-                self._update_tags(model_key, metadata.tags)
-                self._db.conn.commit()
-            except sqlite3.Error as e:
-                self._db.conn.rollback()
-                raise e
-
-        return self.get_metadata(model_key)
-
-    def list_tags(self) -> Set[str]:
-        """Return all tags in the tags table."""
-        self._cursor.execute(
-            """--sql
-            select tag_text from tags;
-            """
-        )
-        return {x[0] for x in self._cursor.fetchall()}
-
-    def search_by_tag(self, tags: Set[str]) -> Set[str]:
-        """Return the keys of models containing all of the listed tags."""
-        with self._db.lock:
-            try:
-                matches: Optional[Set[str]] = None
-                for tag in tags:
-                    self._cursor.execute(
-                        """--sql
-                        SELECT a.model_id FROM model_tags AS a,
-                                                     tags AS b
-                        WHERE a.tag_id=b.tag_id
-                          AND b.tag_text=?;
-                        """,
-                        (tag,),
-                    )
-                    model_keys = {x[0] for x in self._cursor.fetchall()}
-                    if matches is None:
-                        matches = model_keys
-                    matches = matches.intersection(model_keys)
-            except sqlite3.Error as e:
-                raise e
-        return matches if matches else set()
-
-    def search_by_author(self, author: str) -> Set[str]:
-        """Return the keys of models authored by the indicated author."""
-        self._cursor.execute(
-            """--sql
-            SELECT id FROM model_metadata
-            WHERE author=?;
-            """,
-            (author,),
-        )
-        return {x[0] for x in self._cursor.fetchall()}
-
-    def search_by_name(self, name: str) -> Set[str]:
-        """
-        Return the keys of models with the indicated name.
-
-        Note that this is the name of the model given to it by
-        the remote source. The user may have changed the local
-        name. The local name will be located in the model config
-        record object.
-        """
-        self._cursor.execute(
-            """--sql
-            SELECT id FROM model_metadata
-            WHERE name=?;
-            """,
-            (name,),
-        )
-        return {x[0] for x in self._cursor.fetchall()}
-
-    def _update_tags(self, model_key: str, tags: Optional[Set[str]]) -> None:
-        """Update tags for the model referenced by model_key."""
-        if tags:
-            # remove previous tags from this model
-            self._cursor.execute(
-                """--sql
-                DELETE FROM model_tags
-                WHERE model_id=?;
-                """,
-                (model_key,),
-            )
-
-            for tag in tags:
-                self._cursor.execute(
-                    """--sql
-                    INSERT OR IGNORE INTO tags (
-                    tag_text
-                    )
-                    VALUES (?);
-                    """,
-                    (tag,),
-                )
-                self._cursor.execute(
-                    """--sql
-                    SELECT tag_id
-                    FROM tags
-                    WHERE tag_text = ?
-                    LIMIT 1;
-                    """,
-                    (tag,),
-                )
-                tag_id = self._cursor.fetchone()[0]
-                self._cursor.execute(
-                    """--sql
-                    INSERT OR IGNORE INTO model_tags (
-                    model_id,
-                    tag_id
-                    )
-                    VALUES (?,?);
-                    """,
-                    (model_key, tag_id),
-                )

invokeai/app/services/model_records/model_records_base.py

@@ -6,20 +6,24 @@ Abstract base class for storing and retrieving model configuration records.
 from abc import ABC, abstractmethod
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
+from typing import List, Optional, Set, Union
 
 from pydantic import BaseModel, Field
 
 from invokeai.app.services.shared.pagination import PaginatedResults
+from invokeai.app.util.model_exclude_null import BaseModelExcludeNull
 from invokeai.backend.model_manager import (
     AnyModelConfig,
     BaseModelType,
     ModelFormat,
     ModelType,
 )
-from invokeai.backend.model_manager.metadata import AnyModelRepoMetadata
-
-from ..model_metadata import ModelMetadataStoreBase
+from invokeai.backend.model_manager.config import (
+    ControlAdapterDefaultSettings,
+    MainModelDefaultSettings,
+    ModelVariantType,
+    SchedulerPredictionType,
+)
 
 
 class DuplicateModelException(Exception):
@@ -60,11 +64,34 @@ class ModelSummary(BaseModel):
     tags: Set[str] = Field(description="tags associated with model")
 
 
+class ModelRecordChanges(BaseModelExcludeNull):
+    """A set of changes to apply to a model."""
+
+    # Changes applicable to all models
+    name: Optional[str] = Field(description="Name of the model.", default=None)
+    path: Optional[str] = Field(description="Path to the model.", default=None)
+    description: Optional[str] = Field(description="Model description", default=None)
+    base: Optional[BaseModelType] = Field(description="The base model.", default=None)
+    trigger_phrases: Optional[set[str]] = Field(description="Set of trigger phrases for this model", default=None)
+    default_settings: Optional[MainModelDefaultSettings | ControlAdapterDefaultSettings] = Field(
+        description="Default settings for this model", default=None
+    )
+
+    # Checkpoint-specific changes
+    # TODO(MM2): Should we expose these? Feels footgun-y...
+    variant: Optional[ModelVariantType] = Field(description="The variant of the model.", default=None)
+    prediction_type: Optional[SchedulerPredictionType] = Field(
+        description="The prediction type of the model.", default=None
+    )
+    upcast_attention: Optional[bool] = Field(description="Whether to upcast attention.", default=None)
+    config_path: Optional[str] = Field(description="Path to config file for model", default=None)
+
+
 class ModelRecordServiceBase(ABC):
     """Abstract base class for storage and retrieval of model configs."""
 
     @abstractmethod
-    def add_model(self, key: str, config: Union[Dict[str, Any], AnyModelConfig]) -> AnyModelConfig:
+    def add_model(self, config: AnyModelConfig) -> AnyModelConfig:
         """
         Add a model to the database.
 
@@ -88,13 +115,12 @@ class ModelRecordServiceBase(ABC):
         pass
 
     @abstractmethod
-    def update_model(self, key: str, config: Union[Dict[str, Any], AnyModelConfig]) -> AnyModelConfig:
+    def update_model(self, key: str, changes: ModelRecordChanges) -> AnyModelConfig:
         """
         Update the model, returning the updated version.
 
-        :param key: Unique key for the model to be updated
-        :param config: Model configuration record. Either a dict with the
-         required fields, or a ModelConfigBase instance.
+        :param key: Unique key for the model to be updated.
+        :param changes: A set of changes to apply to this model. Changes are validated before being written.
         """
         pass
 
@@ -109,40 +135,17 @@ class ModelRecordServiceBase(ABC):
         """
         pass
 
-    @property
     @abstractmethod
-    def metadata_store(self) -> ModelMetadataStoreBase:
-        """Return a ModelMetadataStore initialized on the same database."""
-        pass
-
-    @abstractmethod
-    def get_metadata(self, key: str) -> Optional[AnyModelRepoMetadata]:
+    def get_model_by_hash(self, hash: str) -> AnyModelConfig:
         """
-        Retrieve metadata (if any) from when model was downloaded from a repo.
+        Retrieve the configuration for the indicated model.
 
-        :param key: Model key
+        :param hash: Hash of model config to be fetched.
+
+        Exceptions: UnknownModelException
         """
         pass
 
-    @abstractmethod
-    def list_all_metadata(self) -> List[Tuple[str, AnyModelRepoMetadata]]:
-        """List metadata for all models that have it."""
-        pass
-
-    @abstractmethod
-    def search_by_metadata_tag(self, tags: Set[str]) -> List[AnyModelConfig]:
-        """
-        Search model metadata for ones with all listed tags and return their corresponding configs.
-
-        :param tags: Set of tags to search for. All tags must be present.
-        """
-        pass
-
-    @abstractmethod
-    def list_tags(self) -> Set[str]:
-        """Return a unique set of all the model tags in the metadata database."""
-        pass
-
     @abstractmethod
     def list_models(
         self, page: int = 0, per_page: int = 10, order_by: ModelRecordOrderBy = ModelRecordOrderBy.Default
@@ -217,21 +220,3 @@ class ModelRecordServiceBase(ABC):
                 f"More than one model matched the search criteria: base_model='{base_model}', model_type='{model_type}', model_name='{model_name}'."
             )
         return model_configs[0]
-
-    def rename_model(
-        self,
-        key: str,
-        new_name: str,
-    ) -> AnyModelConfig:
-        """
-        Rename the indicated model. Just a special case of update_model().
-
-        In some implementations, renaming the model may involve changing where
-        it is stored on the filesystem. So this is broken out.
-
-        :param key: Model key
-        :param new_name: New name for model
-        """
-        config = self.get_model(key)
-        config.name = new_name
-        return self.update_model(key, config)

invokeai/app/services/model_records/model_records_sql.py

@@ -43,7 +43,7 @@ import json
 import sqlite3
 from math import ceil
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
+from typing import List, Optional, Union
 
 from invokeai.app.services.shared.pagination import PaginatedResults
 from invokeai.backend.model_manager.config import (
@@ -53,12 +53,11 @@ from invokeai.backend.model_manager.config import (
     ModelFormat,
     ModelType,
 )
-from invokeai.backend.model_manager.metadata import AnyModelRepoMetadata, UnknownMetadataException
 
-from ..model_metadata import ModelMetadataStoreBase, ModelMetadataStoreSQL
 from ..shared.sqlite.sqlite_database import SqliteDatabase
 from .model_records_base import (
     DuplicateModelException,
+    ModelRecordChanges,
     ModelRecordOrderBy,
     ModelRecordServiceBase,
     ModelSummary,
@@ -69,7 +68,7 @@ from .model_records_base import (
 class ModelRecordServiceSQL(ModelRecordServiceBase):
     """Implementation of the ModelConfigStore ABC using a SQL database."""
 
-    def __init__(self, db: SqliteDatabase, metadata_store: ModelMetadataStoreBase):
+    def __init__(self, db: SqliteDatabase):
         """
         Initialize a new object from preexisting sqlite3 connection and threading lock objects.
 
@@ -78,14 +77,13 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
         super().__init__()
         self._db = db
         self._cursor = db.conn.cursor()
-        self._metadata_store = metadata_store
 
     @property
     def db(self) -> SqliteDatabase:
         """Return the underlying database."""
         return self._db
 
-    def add_model(self, key: str, config: Union[Dict[str, Any], AnyModelConfig]) -> AnyModelConfig:
+    def add_model(self, config: AnyModelConfig) -> AnyModelConfig:
         """
         Add a model to the database.
 
@@ -95,23 +93,19 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
 
         Can raise DuplicateModelException and InvalidModelConfigException exceptions.
         """
-        record = ModelConfigFactory.make_config(config, key=key)  # ensure it is a valid config obect.
-        json_serialized = record.model_dump_json()  # and turn it into a json string.
         with self._db.lock:
             try:
                 self._cursor.execute(
                     """--sql
-                    INSERT INTO model_config (
+                    INSERT INTO models (
                        id,
-                       original_hash,
                        config
                       )
-                    VALUES (?,?,?);
+                    VALUES (?,?);
                     """,
                     (
-                        key,
-                        record.original_hash,
-                        json_serialized,
+                        config.key,
+                        config.model_dump_json(),
                     ),
                 )
                 self._db.conn.commit()
@@ -119,12 +113,12 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
             except sqlite3.IntegrityError as e:
                 self._db.conn.rollback()
                 if "UNIQUE constraint failed" in str(e):
-                    if "model_config.path" in str(e):
-                        msg = f"A model with path '{record.path}' is already installed"
-                    elif "model_config.name" in str(e):
-                        msg = f"A model with name='{record.name}', type='{record.type}', base='{record.base}' is already installed"
+                    if "models.path" in str(e):
+                        msg = f"A model with path '{config.path}' is already installed"
+                    elif "models.name" in str(e):
+                        msg = f"A model with name='{config.name}', type='{config.type}', base='{config.base}' is already installed"
                     else:
-                        msg = f"A model with key '{key}' is already installed"
+                        msg = f"A model with key '{config.key}' is already installed"
                     raise DuplicateModelException(msg) from e
                 else:
                     raise e
@@ -132,7 +126,7 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
                 self._db.conn.rollback()
                 raise e
 
-        return self.get_model(key)
+        return self.get_model(config.key)
 
     def del_model(self, key: str) -> None:
         """
@@ -146,7 +140,7 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
             try:
                 self._cursor.execute(
                     """--sql
-                    DELETE FROM model_config
+                    DELETE FROM models
                     WHERE id=?;
                     """,
                     (key,),
@@ -158,21 +152,20 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
                 self._db.conn.rollback()
                 raise e
 
-    def update_model(self, key: str, config: Union[Dict[str, Any], AnyModelConfig]) -> AnyModelConfig:
-        """
-        Update the model, returning the updated version.
+    def update_model(self, key: str, changes: ModelRecordChanges) -> AnyModelConfig:
+        record = self.get_model(key)
+
+        # Model configs use pydantic's `validate_assignment`, so each change is validated by pydantic.
+        for field_name in changes.model_fields_set:
+            setattr(record, field_name, getattr(changes, field_name))
+
+        json_serialized = record.model_dump_json()
 
-        :param key: Unique key for the model to be updated
-        :param config: Model configuration record. Either a dict with the
-         required fields, or a ModelConfigBase instance.
-        """
-        record = ModelConfigFactory.make_config(config, key=key)  # ensure it is a valid config obect
-        json_serialized = record.model_dump_json()  # and turn it into a json string.
         with self._db.lock:
             try:
                 self._cursor.execute(
                     """--sql
-                    UPDATE model_config
+                    UPDATE models
                     SET
                         config=?
                     WHERE id=?;
@@ -199,7 +192,7 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
         with self._db.lock:
             self._cursor.execute(
                 """--sql
-                SELECT config, strftime('%s',updated_at) FROM model_config
+                SELECT config, strftime('%s',updated_at) FROM models
                 WHERE id=?;
                 """,
                 (key,),
@@ -210,6 +203,21 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
             model = ModelConfigFactory.make_config(json.loads(rows[0]), timestamp=rows[1])
         return model
 
+    def get_model_by_hash(self, hash: str) -> AnyModelConfig:
+        with self._db.lock:
+            self._cursor.execute(
+                """--sql
+                SELECT config, strftime('%s',updated_at) FROM models
+                WHERE hash=?;
+                """,
+                (hash,),
+            )
+            rows = self._cursor.fetchone()
+            if not rows:
+                raise UnknownModelException("model not found")
+            model = ModelConfigFactory.make_config(json.loads(rows[0]), timestamp=rows[1])
+        return model
+
     def exists(self, key: str) -> bool:
         """
         Return True if a model with the indicated key exists in the databse.
@@ -220,7 +228,7 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
         with self._db.lock:
             self._cursor.execute(
                 """--sql
-                select count(*) FROM model_config
+                select count(*) FROM models
                 WHERE id=?;
                 """,
                 (key,),
@@ -234,6 +242,7 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
         base_model: Optional[BaseModelType] = None,
         model_type: Optional[ModelType] = None,
         model_format: Optional[ModelFormat] = None,
+        order_by: ModelRecordOrderBy = ModelRecordOrderBy.Default,
     ) -> List[AnyModelConfig]:
         """
         Return models matching name, base and/or type.
@@ -242,13 +251,23 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
         :param base_model: Filter by base model (optional)
         :param model_type: Filter by type of model (optional)
         :param model_format: Filter by model format (e.g. "diffusers") (optional)
+        :param order_by: Result order
 
         If none of the optional filters are passed, will return all
         models in the database.
         """
-        results = []
-        where_clause = []
-        bindings = []
+
+        assert isinstance(order_by, ModelRecordOrderBy)
+        ordering = {
+            ModelRecordOrderBy.Default: "type, base, name, format",
+            ModelRecordOrderBy.Type: "type",
+            ModelRecordOrderBy.Base: "base",
+            ModelRecordOrderBy.Name: "name",
+            ModelRecordOrderBy.Format: "format",
+        }
+
+        where_clause: list[str] = []
+        bindings: list[str] = []
         if model_name:
             where_clause.append("name=?")
             bindings.append(model_name)
@@ -265,14 +284,15 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
         with self._db.lock:
             self._cursor.execute(
                 f"""--sql
-                select config, strftime('%s',updated_at) FROM model_config
-                {where};
+                SELECT config, strftime('%s',updated_at)
+                FROM models
+                {where}
+                ORDER BY {ordering[order_by]} -- using ? to bind doesn't work here for some reason;
                 """,
                 tuple(bindings),
             )
-            results = [
-                ModelConfigFactory.make_config(json.loads(x[0]), timestamp=x[1]) for x in self._cursor.fetchall()
-            ]
+            result = self._cursor.fetchall()
+            results = [ModelConfigFactory.make_config(json.loads(x[0]), timestamp=x[1]) for x in result]
         return results
 
     def search_by_path(self, path: Union[str, Path]) -> List[AnyModelConfig]:
@@ -281,7 +301,7 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
         with self._db.lock:
             self._cursor.execute(
                 """--sql
-                SELECT config, strftime('%s',updated_at) FROM model_config
+                SELECT config, strftime('%s',updated_at) FROM models
                 WHERE path=?;
                 """,
                 (str(path),),
@@ -292,13 +312,13 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
         return results
 
     def search_by_hash(self, hash: str) -> List[AnyModelConfig]:
-        """Return models with the indicated original_hash."""
+        """Return models with the indicated hash."""
         results = []
         with self._db.lock:
             self._cursor.execute(
                 """--sql
-                SELECT config, strftime('%s',updated_at) FROM model_config
-                WHERE original_hash=?;
+                SELECT config, strftime('%s',updated_at) FROM models
+                WHERE hash=?;
                 """,
                 (hash,),
             )
@@ -307,83 +327,35 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
             ]
         return results
 
-    @property
-    def metadata_store(self) -> ModelMetadataStoreBase:
-        """Return a ModelMetadataStore initialized on the same database."""
-        return self._metadata_store
-
-    def get_metadata(self, key: str) -> Optional[AnyModelRepoMetadata]:
-        """
-        Retrieve metadata (if any) from when model was downloaded from a repo.
-
-        :param key: Model key
-        """
-        store = self.metadata_store
-        try:
-            metadata = store.get_metadata(key)
-            return metadata
-        except UnknownMetadataException:
-            return None
-
-    def search_by_metadata_tag(self, tags: Set[str]) -> List[AnyModelConfig]:
-        """
-        Search model metadata for ones with all listed tags and return their corresponding configs.
-
-        :param tags: Set of tags to search for. All tags must be present.
-        """
-        store = ModelMetadataStoreSQL(self._db)
-        keys = store.search_by_tag(tags)
-        return [self.get_model(x) for x in keys]
-
-    def list_tags(self) -> Set[str]:
-        """Return a unique set of all the model tags in the metadata database."""
-        store = ModelMetadataStoreSQL(self._db)
-        return store.list_tags()
-
-    def list_all_metadata(self) -> List[Tuple[str, AnyModelRepoMetadata]]:
-        """List metadata for all models that have it."""
-        store = ModelMetadataStoreSQL(self._db)
-        return store.list_all_metadata()
-
     def list_models(
         self, page: int = 0, per_page: int = 10, order_by: ModelRecordOrderBy = ModelRecordOrderBy.Default
     ) -> PaginatedResults[ModelSummary]:
         """Return a paginated summary listing of each model in the database."""
+        assert isinstance(order_by, ModelRecordOrderBy)
         ordering = {
-            ModelRecordOrderBy.Default: "a.type, a.base, a.format, a.name",
-            ModelRecordOrderBy.Type: "a.type",
-            ModelRecordOrderBy.Base: "a.base",
-            ModelRecordOrderBy.Name: "a.name",
-            ModelRecordOrderBy.Format: "a.format",
+            ModelRecordOrderBy.Default: "type, base, name, format",
+            ModelRecordOrderBy.Type: "type",
+            ModelRecordOrderBy.Base: "base",
+            ModelRecordOrderBy.Name: "name",
+            ModelRecordOrderBy.Format: "format",
         }
 
-        def _fixup(summary: Dict[str, str]) -> Dict[str, Union[str, int, Set[str]]]:
-            """Fix up results so that there are no null values."""
-            result: Dict[str, Union[str, int, Set[str]]] = {}
-            for key, item in summary.items():
-                result[key] = item or ""
-            result["tags"] = set(json.loads(summary["tags"] or "[]"))
-            return result
-
         # Lock so that the database isn't updated while we're doing the two queries.
         with self._db.lock:
             # query1: get the total number of model configs
             self._cursor.execute(
                 """--sql
-                select count(*) from model_config;
+                select count(*) from models;
                 """,
                 (),
             )
             total = int(self._cursor.fetchone()[0])
 
-            # query2: fetch key fields from the join of model_config and model_metadata
+            # query2: fetch key fields
             self._cursor.execute(
                 f"""--sql
-                SELECT a.id as key, a.type, a.base, a.format, a.name,
-                       json_extract(a.config, '$.description') as description,
-                       json_extract(b.metadata, '$.tags') as tags
-                FROM model_config AS a
-                LEFT JOIN model_metadata AS b on a.id=b.id
+                SELECT config
+                FROM models
                 ORDER BY {ordering[order_by]} -- using ? to bind doesn't work here for some reason
                 LIMIT ?
                 OFFSET ?;
@@ -394,7 +366,7 @@ class ModelRecordServiceSQL(ModelRecordServiceBase):
                 ),
             )
             rows = self._cursor.fetchall()
-            items = [ModelSummary.model_validate(_fixup(dict(x))) for x in rows]
+            items = [ModelSummary.model_validate(dict(x)) for x in rows]
             return PaginatedResults(
                 page=page, pages=ceil(total / per_page), per_page=per_page, total=total, items=items
             )

invokeai/app/services/shared/invocation_context.py

@@ -1,7 +1,7 @@
 import threading
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Union
 
 from PIL.Image import Image
 from torch import Tensor
@@ -13,15 +13,16 @@ 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.model_records.model_records_base import UnknownModelException
 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
+    from invokeai.app.invocations.model import ModelIdentifierField
     from invokeai.app.services.session_queue.session_queue_common import SessionQueueItem
 
 """
@@ -299,22 +300,27 @@ class ConditioningInterface(InvocationContextInterface):
 
 
 class ModelsInterface(InvocationContextInterface):
-    def exists(self, key: str) -> bool:
+    def exists(self, identifier: Union[str, "ModelIdentifierField"]) -> bool:
         """Checks if a model exists.
 
         Args:
-            key: The key of the model.
+            identifier: The key or ModelField representing the model.
 
         Returns:
             True if the model exists, False if not.
         """
-        return self._services.model_manager.store.exists(key)
+        if isinstance(identifier, str):
+            return self._services.model_manager.store.exists(identifier)
 
-    def load(self, key: str, submodel_type: Optional[SubModelType] = None) -> LoadedModel:
+        return self._services.model_manager.store.exists(identifier.key)
+
+    def load(
+        self, identifier: Union[str, "ModelIdentifierField"], submodel_type: Optional[SubModelType] = None
+    ) -> LoadedModel:
         """Loads a model.
 
         Args:
-            key: The key of the model.
+            identifier: The key or ModelField representing the model.
             submodel_type: The submodel of the model to get.
 
         Returns:
@@ -324,9 +330,13 @@ class ModelsInterface(InvocationContextInterface):
         # 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._data
-        )
+        if isinstance(identifier, str):
+            model = self._services.model_manager.store.get_model(identifier)
+            return self._services.model_manager.load.load_model(model, submodel_type, self._data)
+        else:
+            _submodel_type = submodel_type or identifier.submodel_type
+            model = self._services.model_manager.store.get_model(identifier.key)
+            return self._services.model_manager.load.load_model(model, _submodel_type, self._data)
 
     def load_by_attrs(
         self, name: str, base: BaseModelType, type: ModelType, submodel_type: Optional[SubModelType] = None
@@ -343,35 +353,29 @@ class ModelsInterface(InvocationContextInterface):
         Returns:
             An object representing the loaded model.
         """
-        return self._services.model_manager.load_model_by_attr(
-            model_name=name,
-            base_model=base,
-            model_type=type,
-            submodel=submodel_type,
-            context_data=self._data,
-        )
 
-    def get_config(self, key: str) -> AnyModelConfig:
+        configs = self._services.model_manager.store.search_by_attr(model_name=name, base_model=base, model_type=type)
+        if len(configs) == 0:
+            raise UnknownModelException(f"No model found with name {name}, base {base}, and type {type}")
+
+        if len(configs) > 1:
+            raise ValueError(f"More than one model found with name {name}, base {base}, and type {type}")
+
+        return self._services.model_manager.load.load_model(configs[0], submodel_type, self._data)
+
+    def get_config(self, identifier: Union[str, "ModelIdentifierField"]) -> AnyModelConfig:
         """Gets a model's config.
 
         Args:
-            key: The key of the model.
+            identifier: The key or ModelField representing the model.
 
         Returns:
             The model's config.
         """
-        return self._services.model_manager.store.get_model(key=key)
+        if isinstance(identifier, str):
+            return self._services.model_manager.store.get_model(identifier)
 
-    def get_metadata(self, key: str) -> Optional[AnyModelRepoMetadata]:
-        """Gets a model's metadata, if it has any.
-
-        Args:
-            key: The key of the model.
-
-        Returns:
-            The model's metadata, if it has any.
-        """
-        return self._services.model_manager.store.get_metadata(key=key)
+        return self._services.model_manager.store.get_model(identifier.key)
 
     def search_by_path(self, path: Path) -> list[AnyModelConfig]:
         """Searches for models by path.

invokeai/app/services/shared/sqlite/sqlite_util.py

@@ -9,6 +9,7 @@ from invokeai.app.services.shared.sqlite_migrator.migrations.migration_3 import
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_4 import build_migration_4
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_5 import build_migration_5
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_6 import build_migration_6
+from invokeai.app.services.shared.sqlite_migrator.migrations.migration_7 import build_migration_7
 from invokeai.app.services.shared.sqlite_migrator.sqlite_migrator_impl import SqliteMigrator
 
 
@@ -35,6 +36,7 @@ def init_db(config: InvokeAIAppConfig, logger: Logger, image_files: ImageFileSto
     migrator.register_migration(build_migration_4())
     migrator.register_migration(build_migration_5())
     migrator.register_migration(build_migration_6())
+    migrator.register_migration(build_migration_7())
     migrator.run_migrations()
 
     return db

invokeai/app/services/shared/sqlite_migrator/migrations/migration_3.py

@@ -4,8 +4,6 @@ from logging import Logger
 from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.app.services.shared.sqlite_migrator.sqlite_migrator_common import Migration
 
-from .util.migrate_yaml_config_1 import MigrateModelYamlToDb1
-
 
 class Migration3Callback:
     def __init__(self, app_config: InvokeAIAppConfig, logger: Logger) -> None:
@@ -15,7 +13,6 @@ class Migration3Callback:
     def __call__(self, cursor: sqlite3.Cursor) -> None:
         self._drop_model_manager_metadata(cursor)
         self._recreate_model_config(cursor)
-        self._migrate_model_config_records(cursor)
 
     def _drop_model_manager_metadata(self, cursor: sqlite3.Cursor) -> None:
         """Drops the `model_manager_metadata` table."""
@@ -55,12 +52,6 @@ class Migration3Callback:
             """
         )
 
-    def _migrate_model_config_records(self, cursor: sqlite3.Cursor) -> None:
-        """After updating the model config table, we repopulate it."""
-        self._logger.info("Migrating model config records from models.yaml to database")
-        model_record_migrator = MigrateModelYamlToDb1(self._app_config, self._logger, cursor)
-        model_record_migrator.migrate()
-
 
 def build_migration_3(app_config: InvokeAIAppConfig, logger: Logger) -> Migration:
     """

invokeai/app/services/shared/sqlite_migrator/migrations/migration_7.py

@@ -0,0 +1,88 @@
+import sqlite3
+
+from invokeai.app.services.shared.sqlite_migrator.sqlite_migrator_common import Migration
+
+
+class Migration7Callback:
+    def __call__(self, cursor: sqlite3.Cursor) -> None:
+        self._create_models_table(cursor)
+        self._drop_old_models_tables(cursor)
+
+    def _drop_old_models_tables(self, cursor: sqlite3.Cursor) -> None:
+        """Drops the old model_records, model_metadata, model_tags and tags tables."""
+
+        tables = ["model_records", "model_metadata", "model_tags", "tags"]
+
+        for table in tables:
+            cursor.execute(f"DROP TABLE IF EXISTS {table};")
+
+    def _create_models_table(self, cursor: sqlite3.Cursor) -> None:
+        """Creates the v4.0.0 models table."""
+
+        tables = [
+            """--sql
+            CREATE TABLE IF NOT EXISTS models (
+                id TEXT NOT NULL PRIMARY KEY,
+                hash TEXT GENERATED ALWAYS as (json_extract(config, '$.hash')) VIRTUAL NOT NULL,
+                base TEXT GENERATED ALWAYS as (json_extract(config, '$.base')) VIRTUAL NOT NULL,
+                type TEXT GENERATED ALWAYS as (json_extract(config, '$.type')) VIRTUAL NOT NULL,
+                path TEXT GENERATED ALWAYS as (json_extract(config, '$.path')) VIRTUAL NOT NULL,
+                format TEXT GENERATED ALWAYS as (json_extract(config, '$.format')) VIRTUAL NOT NULL,
+                name TEXT GENERATED ALWAYS as (json_extract(config, '$.name')) VIRTUAL NOT NULL,
+                description TEXT GENERATED ALWAYS as (json_extract(config, '$.description')) VIRTUAL,
+                source TEXT GENERATED ALWAYS as (json_extract(config, '$.source')) VIRTUAL NOT NULL,
+                source_type TEXT GENERATED ALWAYS as (json_extract(config, '$.source_type')) VIRTUAL NOT NULL,
+                source_api_response TEXT GENERATED ALWAYS as (json_extract(config, '$.source_api_response')) VIRTUAL,
+                trigger_phrases TEXT GENERATED ALWAYS as (json_extract(config, '$.trigger_phrases')) VIRTUAL,
+                -- Serialized JSON representation of the whole config object, which will contain additional fields from subclasses
+                config TEXT NOT NULL,
+                created_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
+                -- Updated via trigger
+                updated_at DATETIME NOT NULL DEFAULT(STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')),
+                -- unique constraint on combo of name, base and type
+                UNIQUE(name, base, type)
+            );
+            """
+        ]
+
+        # Add trigger for `updated_at`.
+        triggers = [
+            """--sql
+            CREATE TRIGGER IF NOT EXISTS models_updated_at
+            AFTER UPDATE
+            ON models FOR EACH ROW
+            BEGIN
+                UPDATE models SET updated_at = STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')
+                    WHERE id = old.id;
+            END;
+            """
+        ]
+
+        # Add indexes for searchable fields
+        indices = [
+            "CREATE INDEX IF NOT EXISTS base_index ON models(base);",
+            "CREATE INDEX IF NOT EXISTS type_index ON models(type);",
+            "CREATE INDEX IF NOT EXISTS name_index ON models(name);",
+            "CREATE UNIQUE INDEX IF NOT EXISTS path_index ON models(path);",
+        ]
+
+        for stmt in tables + indices + triggers:
+            cursor.execute(stmt)
+
+
+def build_migration_7() -> Migration:
+    """
+    Build the migration from database version 6 to 7.
+
+    This migration does the following:
+    - Adds the new models table
+    - Drops the old model_records, model_metadata, model_tags and tags tables.
+    - TODO(MM2): Migrates model names and descriptions from `models.yaml` to the new table (?).
+    """
+    migration_7 = Migration(
+        from_version=6,
+        to_version=7,
+        callback=Migration7Callback(),
+    )
+
+    return migration_7

invokeai/app/services/shared/sqlite_migrator/migrations/util/migrate_yaml_config_1.py

@@ -1,163 +0,0 @@
-# Copyright (c) 2023 Lincoln D. Stein
-"""Migrate from the InvokeAI v2 models.yaml format to the v3 sqlite format."""
-
-import json
-import sqlite3
-from logging import Logger
-from pathlib import Path
-from typing import Optional
-
-from omegaconf import DictConfig, OmegaConf
-from pydantic import TypeAdapter
-
-from invokeai.app.services.config import InvokeAIAppConfig
-from invokeai.app.services.model_records import (
-    DuplicateModelException,
-    UnknownModelException,
-)
-from invokeai.backend.model_manager.config import (
-    AnyModelConfig,
-    BaseModelType,
-    ModelConfigFactory,
-    ModelType,
-)
-from invokeai.backend.model_manager.hash import ModelHash
-
-ModelsValidator = TypeAdapter(AnyModelConfig)
-
-
-class MigrateModelYamlToDb1:
-    """
-    Migrate the InvokeAI models.yaml format (VERSION 3.0.0) to SQL3 database format (VERSION 3.5.0).
-
-    The class has one externally useful method, migrate(), which scans the
-    currently models.yaml file and imports all its entries into invokeai.db.
-
-    Use this way:
-
-      from invokeai.backend.model_manager/migrate_to_db import MigrateModelYamlToDb
-      MigrateModelYamlToDb().migrate()
-
-    """
-
-    config: InvokeAIAppConfig
-    logger: Logger
-    cursor: sqlite3.Cursor
-
-    def __init__(self, config: InvokeAIAppConfig, logger: Logger, cursor: sqlite3.Cursor = None) -> None:
-        self.config = config
-        self.logger = logger
-        self.cursor = cursor
-
-    def get_yaml(self) -> DictConfig:
-        """Fetch the models.yaml DictConfig for this installation."""
-        yaml_path = self.config.model_conf_path
-        omegaconf = OmegaConf.load(yaml_path)
-        assert isinstance(omegaconf, DictConfig)
-        return omegaconf
-
-    def migrate(self) -> None:
-        """Do the migration from models.yaml to invokeai.db."""
-        try:
-            yaml = self.get_yaml()
-        except OSError:
-            return
-
-        for model_key, stanza in yaml.items():
-            if model_key == "__metadata__":
-                assert (
-                    stanza["version"] == "3.0.0"
-                ), f"This script works on version 3.0.0 yaml files, but your configuration points to a {stanza['version']} version"
-                continue
-
-            base_type, model_type, model_name = str(model_key).split("/")
-            try:
-                hash = ModelHash().hash(self.config.models_path / stanza.path)
-            except OSError:
-                self.logger.warning(f"The model at {stanza.path} is not a valid file or directory. Skipping migration.")
-                continue
-
-            stanza["base"] = BaseModelType(base_type)
-            stanza["type"] = ModelType(model_type)
-            stanza["name"] = model_name
-            stanza["original_hash"] = hash
-            stanza["current_hash"] = hash
-            new_key = hash  # deterministic key assignment
-
-            # special case for ip adapters, which need the new `image_encoder_model_id` field
-            if stanza["type"] == ModelType.IPAdapter:
-                try:
-                    stanza["image_encoder_model_id"] = self._get_image_encoder_model_id(
-                        self.config.models_path / stanza.path
-                    )
-                except OSError:
-                    self.logger.warning(f"Could not determine image encoder for {stanza.path}. Skipping.")
-                    continue
-
-            new_config: AnyModelConfig = ModelsValidator.validate_python(stanza)  # type: ignore # see https://github.com/pydantic/pydantic/discussions/7094
-
-            try:
-                if original_record := self._search_by_path(stanza.path):
-                    key = original_record.key
-                    self.logger.info(f"Updating model {model_name} with information from models.yaml using key {key}")
-                    self._update_model(key, new_config)
-                else:
-                    self.logger.info(f"Adding model {model_name} with key {new_key}")
-                    self._add_model(new_key, new_config)
-            except DuplicateModelException:
-                self.logger.warning(f"Model {model_name} is already in the database")
-            except UnknownModelException:
-                self.logger.warning(f"Model at {stanza.path} could not be found in database")
-
-    def _search_by_path(self, path: Path) -> Optional[AnyModelConfig]:
-        self.cursor.execute(
-            """--sql
-            SELECT config FROM model_config
-            WHERE path=?;
-            """,
-            (str(path),),
-        )
-        results = [ModelConfigFactory.make_config(json.loads(x[0])) for x in self.cursor.fetchall()]
-        return results[0] if results else None
-
-    def _update_model(self, key: str, config: AnyModelConfig) -> None:
-        record = ModelConfigFactory.make_config(config, key=key)  # ensure it is a valid config obect
-        json_serialized = record.model_dump_json()  # and turn it into a json string.
-        self.cursor.execute(
-            """--sql
-            UPDATE model_config
-            SET
-                config=?
-            WHERE id=?;
-            """,
-            (json_serialized, key),
-        )
-        if self.cursor.rowcount == 0:
-            raise UnknownModelException("model not found")
-
-    def _add_model(self, key: str, config: AnyModelConfig) -> None:
-        record = ModelConfigFactory.make_config(config, key=key)  # ensure it is a valid config obect.
-        json_serialized = record.model_dump_json()  # and turn it into a json string.
-        try:
-            self.cursor.execute(
-                """--sql
-                INSERT INTO model_config (
-                   id,
-                   original_hash,
-                   config
-                  )
-                VALUES (?,?,?);
-                """,
-                (
-                    key,
-                    record.original_hash,
-                    json_serialized,
-                ),
-            )
-        except sqlite3.IntegrityError as exc:
-            raise DuplicateModelException(f"{record.name}: model is already in database") from exc
-
-    def _get_image_encoder_model_id(self, model_path: Path) -> str:
-        with open(model_path / "image_encoder.txt") as f:
-            encoder = f.read()
-        return encoder.strip()

invokeai/app/services/urls/urls_base.py

@@ -8,3 +8,8 @@ class UrlServiceBase(ABC):
     def get_image_url(self, image_name: str, thumbnail: bool = False) -> str:
         """Gets the URL for an image or thumbnail."""
         pass
+
+    @abstractmethod
+    def get_model_image_url(self, model_key: str) -> str:
+        """Gets the URL for a model image"""
+        pass

invokeai/app/services/urls/urls_default.py

@@ -4,8 +4,9 @@ from .urls_base import UrlServiceBase
 
 
 class LocalUrlService(UrlServiceBase):
-    def __init__(self, base_url: str = "api/v1"):
+    def __init__(self, base_url: str = "api/v1", base_url_v2: str = "api/v2"):
         self._base_url = base_url
+        self._base_url_v2 = base_url_v2
 
     def get_image_url(self, image_name: str, thumbnail: bool = False) -> str:
         image_basename = os.path.basename(image_name)
@@ -15,3 +16,6 @@ class LocalUrlService(UrlServiceBase):
             return f"{self._base_url}/images/i/{image_basename}/thumbnail"
 
         return f"{self._base_url}/images/i/{image_basename}/full"
+
+    def get_model_image_url(self, model_key: str) -> str:
+        return f"{self._base_url_v2}/models/i/{model_key}/image"

invokeai/app/util/metadata.py

@@ -1,55 +0,0 @@
-import json
-from typing import Optional
-
-from pydantic import ValidationError
-
-from invokeai.app.services.shared.graph import Edge
-
-
-def get_metadata_graph_from_raw_session(session_raw: str) -> Optional[dict]:
-    """
-    Parses raw session string, returning a dict of the graph.
-
-    Only the general graph shape is validated; none of the fields are validated.
-
-    Any `metadata_accumulator` nodes and edges are removed.
-
-    Any validation failure will return None.
-    """
-
-    graph = json.loads(session_raw).get("graph", None)
-
-    # sanity check make sure the graph is at least reasonably shaped
-    if (
-        not isinstance(graph, dict)
-        or "nodes" not in graph
-        or not isinstance(graph["nodes"], dict)
-        or "edges" not in graph
-        or not isinstance(graph["edges"], list)
-    ):
-        # something has gone terribly awry, return an empty dict
-        return None
-
-    try:
-        # delete the `metadata_accumulator` node
-        del graph["nodes"]["metadata_accumulator"]
-    except KeyError:
-        # no accumulator node, all good
-        pass
-
-    # delete any edges to or from it
-    for i, edge in enumerate(graph["edges"]):
-        try:
-            # try to parse the edge
-            Edge(**edge)
-        except ValidationError:
-            # something has gone terribly awry, return an empty dict
-            return None
-
-        if (
-            edge["source"]["node_id"] == "metadata_accumulator"
-            or edge["destination"]["node_id"] == "metadata_accumulator"
-        ):
-            del graph["edges"][i]
-
-    return graph

invokeai/app/util/ti_utils.py

@@ -22,7 +22,7 @@ def generate_ti_list(
     for trigger in extract_ti_triggers_from_prompt(prompt):
         name_or_key = trigger[1:-1]
         try:
-            loaded_model = context.models.load(key=name_or_key)
+            loaded_model = context.models.load(name_or_key)
             model = loaded_model.model
             assert isinstance(model, TextualInversionModelRaw)
             assert loaded_model.config.base == base

invokeai/backend/install/install_helper.py

@@ -19,7 +19,6 @@ from invokeai.app.services.model_install import (
     ModelInstallService,
     ModelInstallServiceBase,
 )
-from invokeai.app.services.model_metadata import ModelMetadataStoreSQL
 from invokeai.app.services.model_records import ModelRecordServiceBase, ModelRecordServiceSQL
 from invokeai.app.services.shared.sqlite.sqlite_util import init_db
 from invokeai.backend.model_manager import (
@@ -39,7 +38,7 @@ def initialize_record_store(app_config: InvokeAIAppConfig) -> ModelRecordService
     logger = InvokeAILogger.get_logger(config=app_config)
     image_files = DiskImageFileStorage(f"{app_config.output_path}/images")
     db = init_db(config=app_config, logger=logger, image_files=image_files)
-    obj: ModelRecordServiceBase = ModelRecordServiceSQL(db, ModelMetadataStoreSQL(db))
+    obj: ModelRecordServiceBase = ModelRecordServiceSQL(db)
     return obj
 
 

invokeai/backend/install/invokeai_configure.py

@@ -17,7 +17,7 @@ import warnings
 from argparse import Namespace
 from enum import Enum
 from pathlib import Path
-from shutil import get_terminal_size
+from shutil import copy, get_terminal_size, move
 from typing import Any, Optional, Set, Tuple, Type, get_args, get_type_hints
 from urllib import request
 
@@ -929,6 +929,10 @@ def main() -> None:
 
     errors = set()
     FORCE_FULL_PRECISION = opt.full_precision  # FIXME global
+    new_init_file = config.root_path / "invokeai.yaml"
+    backup_init_file = new_init_file.with_suffix(".bak")
+    if new_init_file.exists():
+        copy(new_init_file, backup_init_file)
 
     try:
         # if we do a root migration/upgrade, then we are keeping previous
@@ -943,7 +947,6 @@ def main() -> None:
         install_helper = InstallHelper(config, logger)
 
         models_to_download = default_user_selections(opt, install_helper)
-        new_init_file = config.root_path / "invokeai.yaml"
 
         if opt.yes_to_all:
             write_default_options(opt, new_init_file)
@@ -975,8 +978,17 @@ def main() -> None:
             input("Press any key to continue...")
     except WindowTooSmallException as e:
         logger.error(str(e))
+        if backup_init_file.exists():
+            move(backup_init_file, new_init_file)
     except KeyboardInterrupt:
         print("\nGoodbye! Come back soon.")
+        if backup_init_file.exists():
+            move(backup_init_file, new_init_file)
+    except Exception:
+        print("An error occurred during installation.")
+        if backup_init_file.exists():
+            move(backup_init_file, new_init_file)
+        print(traceback.format_exc(), file=sys.stderr)
 
 
 # -------------------------------------

invokeai/backend/ip_adapter/attention_processor.py

@@ -0,0 +1,182 @@
+# copied from https://github.com/tencent-ailab/IP-Adapter (Apache License 2.0)
+#   and modified as needed
+
+# tencent-ailab comment:
+# modified from https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from diffusers.models.attention_processor import AttnProcessor2_0 as DiffusersAttnProcessor2_0
+
+from invokeai.backend.ip_adapter.ip_attention_weights import IPAttentionProcessorWeights
+
+
+# Create a version of AttnProcessor2_0 that is a sub-class of nn.Module. This is required for IP-Adapter state_dict
+# loading.
+class AttnProcessor2_0(DiffusersAttnProcessor2_0, nn.Module):
+    def __init__(self):
+        DiffusersAttnProcessor2_0.__init__(self)
+        nn.Module.__init__(self)
+
+    def __call__(
+        self,
+        attn,
+        hidden_states,
+        encoder_hidden_states=None,
+        attention_mask=None,
+        temb=None,
+        ip_adapter_image_prompt_embeds=None,
+    ):
+        """Re-definition of DiffusersAttnProcessor2_0.__call__(...) that accepts and ignores the
+        ip_adapter_image_prompt_embeds parameter.
+        """
+        return DiffusersAttnProcessor2_0.__call__(
+            self, attn, hidden_states, encoder_hidden_states, attention_mask, temb
+        )
+
+
+class IPAttnProcessor2_0(torch.nn.Module):
+    r"""
+    Attention processor for IP-Adapater for PyTorch 2.0.
+    Args:
+        hidden_size (`int`):
+            The hidden size of the attention layer.
+        cross_attention_dim (`int`):
+            The number of channels in the `encoder_hidden_states`.
+        scale (`float`, defaults to 1.0):
+            the weight scale of image prompt.
+    """
+
+    def __init__(self, weights: list[IPAttentionProcessorWeights], scales: list[float]):
+        super().__init__()
+
+        if not hasattr(F, "scaled_dot_product_attention"):
+            raise ImportError("AttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")
+
+        assert len(weights) == len(scales)
+
+        self._weights = weights
+        self._scales = scales
+
+    def __call__(
+        self,
+        attn,
+        hidden_states,
+        encoder_hidden_states=None,
+        attention_mask=None,
+        temb=None,
+        ip_adapter_image_prompt_embeds=None,
+    ):
+        """Apply IP-Adapter attention.
+
+        Args:
+            ip_adapter_image_prompt_embeds (torch.Tensor): The image prompt embeddings.
+                Shape: (batch_size, num_ip_images, seq_len, ip_embedding_len).
+        """
+        residual = hidden_states
+
+        if attn.spatial_norm is not None:
+            hidden_states = attn.spatial_norm(hidden_states, temb)
+
+        input_ndim = hidden_states.ndim
+
+        if input_ndim == 4:
+            batch_size, channel, height, width = hidden_states.shape
+            hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)
+
+        batch_size, sequence_length, _ = (
+            hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape
+        )
+
+        if attention_mask is not None:
+            attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
+            # scaled_dot_product_attention expects attention_mask shape to be
+            # (batch, heads, source_length, target_length)
+            attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])
+
+        if attn.group_norm is not None:
+            hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2)
+
+        query = attn.to_q(hidden_states)
+
+        if encoder_hidden_states is None:
+            encoder_hidden_states = hidden_states
+        elif attn.norm_cross:
+            encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states)
+
+        key = attn.to_k(encoder_hidden_states)
+        value = attn.to_v(encoder_hidden_states)
+
+        inner_dim = key.shape[-1]
+        head_dim = inner_dim // attn.heads
+
+        query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+
+        key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+        value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+
+        # the output of sdp = (batch, num_heads, seq_len, head_dim)
+        # TODO: add support for attn.scale when we move to Torch 2.1
+        hidden_states = F.scaled_dot_product_attention(
+            query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False
+        )
+
+        hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
+        hidden_states = hidden_states.to(query.dtype)
+
+        if encoder_hidden_states is not None:
+            # If encoder_hidden_states is not None, then we are doing cross-attention, not self-attention. In this case,
+            # we will apply IP-Adapter conditioning. We validate the inputs for IP-Adapter conditioning here.
+            assert ip_adapter_image_prompt_embeds is not None
+            assert len(ip_adapter_image_prompt_embeds) == len(self._weights)
+
+            for ipa_embed, ipa_weights, scale in zip(
+                ip_adapter_image_prompt_embeds, self._weights, self._scales, strict=True
+            ):
+                # The batch dimensions should match.
+                assert ipa_embed.shape[0] == encoder_hidden_states.shape[0]
+                # The token_len dimensions should match.
+                assert ipa_embed.shape[-1] == encoder_hidden_states.shape[-1]
+
+                ip_hidden_states = ipa_embed
+
+                # Expected ip_hidden_state shape: (batch_size, num_ip_images, ip_seq_len, ip_image_embedding)
+
+                ip_key = ipa_weights.to_k_ip(ip_hidden_states)
+                ip_value = ipa_weights.to_v_ip(ip_hidden_states)
+
+                # Expected ip_key and ip_value shape: (batch_size, num_ip_images, ip_seq_len, head_dim * num_heads)
+
+                ip_key = ip_key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+                ip_value = ip_value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+
+                # Expected ip_key and ip_value shape: (batch_size, num_heads, num_ip_images * ip_seq_len, head_dim)
+
+                # TODO: add support for attn.scale when we move to Torch 2.1
+                ip_hidden_states = F.scaled_dot_product_attention(
+                    query, ip_key, ip_value, attn_mask=None, dropout_p=0.0, is_causal=False
+                )
+
+                # Expected ip_hidden_states shape: (batch_size, num_heads, query_seq_len, head_dim)
+
+                ip_hidden_states = ip_hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
+                ip_hidden_states = ip_hidden_states.to(query.dtype)
+
+                # Expected ip_hidden_states shape: (batch_size, query_seq_len, num_heads * head_dim)
+
+                hidden_states = hidden_states + scale * ip_hidden_states
+
+        # linear proj
+        hidden_states = attn.to_out[0](hidden_states)
+        # dropout
+        hidden_states = attn.to_out[1](hidden_states)
+
+        if input_ndim == 4:
+            hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
+
+        if attn.residual_connection:
+            hidden_states = hidden_states + residual
+
+        hidden_states = hidden_states / attn.rescale_output_factor
+
+        return hidden_states

invokeai/backend/ip_adapter/unet_patcher.py

@@ -1,55 +1,52 @@
 from contextlib import contextmanager
-from typing import Optional
 
 from diffusers.models import UNet2DConditionModel
 
+from invokeai.backend.ip_adapter.attention_processor import AttnProcessor2_0, IPAttnProcessor2_0
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter
-from invokeai.backend.stable_diffusion.diffusion.custom_attention import CustomAttnProcessor2_0
 
 
-class UNetAttentionPatcher:
-    """A class for patching a UNet with CustomAttnProcessor2_0 attention layers."""
+class UNetPatcher:
+    """A class that contains multiple IP-Adapters and can apply them to a UNet."""
 
-    def __init__(self, ip_adapters: Optional[list[IPAdapter]]):
+    def __init__(self, ip_adapters: list[IPAdapter]):
         self._ip_adapters = ip_adapters
-        self._ip_adapter_scales = None
-
-        if self._ip_adapters is not None:
-            self._ip_adapter_scales = [1.0] * len(self._ip_adapters)
+        self._scales = [1.0] * len(self._ip_adapters)
 
     def set_scale(self, idx: int, value: float):
-        self._ip_adapter_scales[idx] = value
+        self._scales[idx] = value
 
     def _prepare_attention_processors(self, unet: UNet2DConditionModel):
         """Prepare a dict of attention processors that can be injected into a unet, and load the IP-Adapter attention
-        weights into them (if IP-Adapters are being applied).
+        weights into them.
 
         Note that the `unet` param is only used to determine attention block dimensions and naming.
         """
         # Construct a dict of attention processors based on the UNet's architecture.
         attn_procs = {}
         for idx, name in enumerate(unet.attn_processors.keys()):
-            if name.endswith("attn1.processor") or self._ip_adapters is None:
-                # "attn1" processors do not use IP-Adapters.
-                attn_procs[name] = CustomAttnProcessor2_0()
+            if name.endswith("attn1.processor"):
+                attn_procs[name] = AttnProcessor2_0()
             else:
                 # Collect the weights from each IP Adapter for the idx'th attention processor.
-                attn_procs[name] = CustomAttnProcessor2_0(
+                attn_procs[name] = IPAttnProcessor2_0(
                     [ip_adapter.attn_weights.get_attention_processor_weights(idx) for ip_adapter in self._ip_adapters],
-                    self._ip_adapter_scales,
+                    self._scales,
                 )
         return attn_procs
 
     @contextmanager
     def apply_ip_adapter_attention(self, unet: UNet2DConditionModel):
-        """A context manager that patches `unet` with CustomAttnProcessor2_0 attention layers."""
+        """A context manager that patches `unet` with IP-Adapter attention processors."""
+
         attn_procs = self._prepare_attention_processors(unet)
+
         orig_attn_processors = unet.attn_processors
 
         try:
-            # Note to future devs: set_attn_processor(...) does something slightly unexpected - it pops elements from
-            # the passed dict. So, if you wanted to keep the dict for future use, you'd have to make a
-            # moderately-shallow copy of it. E.g. `attn_procs_copy = {k: v for k, v in attn_procs.items()}`.
+            # Note to future devs: set_attn_processor(...) does something slightly unexpected - it pops elements from the
+            # passed dict. So, if you wanted to keep the dict for future use, you'd have to make a moderately-shallow copy
+            # of it. E.g. `attn_procs_copy = {k: v for k, v in attn_procs.items()}`.
             unet.set_attn_processor(attn_procs)
             yield None
         finally:

invokeai/backend/model_manager/config.py

@@ -22,13 +22,16 @@ Validation errors will raise an InvalidModelConfigException error.
 
 import time
 from enum import Enum
-from typing import Literal, Optional, Type, Union
+from typing import Literal, Optional, Type, TypeAlias, Union
 
 import torch
-from diffusers import ModelMixin
-from pydantic import BaseModel, ConfigDict, Field, TypeAdapter
+from diffusers.models.modeling_utils import ModelMixin
+from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag, TypeAdapter
 from typing_extensions import Annotated, Any, Dict
 
+from invokeai.app.invocations.constants import SCHEDULER_NAME_VALUES
+from invokeai.app.util.misc import uuid_string
+
 from ..raw_model import RawModel
 
 # ModelMixin is the base class for all diffusers and transformers models
@@ -56,8 +59,8 @@ class ModelType(str, Enum):
 
     ONNX = "onnx"
     Main = "main"
-    Vae = "vae"
-    Lora = "lora"
+    VAE = "vae"
+    LoRA = "lora"
     ControlNet = "controlnet"  # used by model_probe
     TextualInversion = "embedding"
     IPAdapter = "ip_adapter"
@@ -73,9 +76,9 @@ class SubModelType(str, Enum):
     TextEncoder2 = "text_encoder_2"
     Tokenizer = "tokenizer"
     Tokenizer2 = "tokenizer_2"
-    Vae = "vae"
-    VaeDecoder = "vae_decoder"
-    VaeEncoder = "vae_encoder"
+    VAE = "vae"
+    VAEDecoder = "vae_decoder"
+    VAEEncoder = "vae_encoder"
     Scheduler = "scheduler"
     SafetyChecker = "safety_checker"
 
@@ -93,8 +96,8 @@ class ModelFormat(str, Enum):
 
     Diffusers = "diffusers"
     Checkpoint = "checkpoint"
-    Lycoris = "lycoris"
-    Onnx = "onnx"
+    LyCORIS = "lycoris"
+    ONNX = "onnx"
     Olive = "olive"
     EmbeddingFile = "embedding_file"
     EmbeddingFolder = "embedding_folder"
@@ -112,127 +115,201 @@ class SchedulerPredictionType(str, Enum):
 class ModelRepoVariant(str, Enum):
     """Various hugging face variants on the diffusers format."""
 
-    DEFAULT = ""  # model files without "fp16" or other qualifier - empty str
+    Default = ""  # model files without "fp16" or other qualifier - empty str
     FP16 = "fp16"
     FP32 = "fp32"
     ONNX = "onnx"
-    OPENVINO = "openvino"
-    FLAX = "flax"
+    OpenVINO = "openvino"
+    Flax = "flax"
+
+
+class ModelSourceType(str, Enum):
+    """Model source type."""
+
+    Path = "path"
+    Url = "url"
+    HFRepoID = "hf_repo_id"
+
+
+class MainModelDefaultSettings(BaseModel):
+    vae: str | None
+    vae_precision: str | None
+    scheduler: SCHEDULER_NAME_VALUES | None
+    steps: int | None
+    cfg_scale: float | None
+    cfg_rescale_multiplier: float | None
+
+
+class ControlAdapterDefaultSettings(BaseModel):
+    # This could be narrowed to controlnet processor nodes, but they change. Leaving this a string is safer.
+    preprocessor: str | None
 
 
 class ModelConfigBase(BaseModel):
     """Base class for model configuration information."""
 
-    path: str = Field(description="filesystem path to the model file or directory")
-    name: str = Field(description="model name")
-    base: BaseModelType = Field(description="base model")
-    type: ModelType = Field(description="type of the model")
-    format: ModelFormat = Field(description="model format")
-    key: str = Field(description="unique key for model", default="<NOKEY>")
-    original_hash: Optional[str] = Field(
-        description="original fasthash of model contents", default=None
-    )  # this is assigned at install time and will not change
-    current_hash: Optional[str] = Field(
-        description="current fasthash of model contents", default=None
-    )  # if model is converted or otherwise modified, this will hold updated hash
-    description: Optional[str] = Field(description="human readable description of the model", default=None)
-    source: Optional[str] = Field(description="model original source (path, URL or repo_id)", default=None)
-    last_modified: Optional[float] = Field(description="timestamp for modification time", default_factory=time.time)
+    key: str = Field(description="A unique key for this model.", default_factory=uuid_string)
+    hash: str = Field(description="The hash of the model file(s).")
+    path: str = Field(
+        description="Path to the model on the filesystem. Relative paths are relative to the Invoke root directory."
+    )
+    name: str = Field(description="Name of the model.")
+    base: BaseModelType = Field(description="The base model.")
+    description: Optional[str] = Field(description="Model description", default=None)
+    source: str = Field(description="The original source of the model (path, URL or repo_id).")
+    source_type: ModelSourceType = Field(description="The type of source")
+    source_api_response: Optional[str] = Field(
+        description="The original API response from the source, as stringified JSON.", default=None
+    )
+    cover_image: Optional[str] = Field(description="Url for image to preview model", default=None)
 
     @staticmethod
     def json_schema_extra(schema: dict[str, Any], model_class: Type[BaseModel]) -> None:
-        schema["required"].extend(
-            ["key", "base", "type", "format", "original_hash", "current_hash", "source", "last_modified"]
-        )
+        schema["required"].extend(["key", "type", "format"])
 
-    model_config = ConfigDict(
-        use_enum_values=False,
-        validate_assignment=True,
-        json_schema_extra=json_schema_extra,
-    )
-
-    def update(self, attributes: Dict[str, Any]) -> None:
-        """Update the object with fields in dict."""
-        for key, value in attributes.items():
-            setattr(self, key, value)  # may raise a validation error
+    model_config = ConfigDict(validate_assignment=True, json_schema_extra=json_schema_extra)
 
 
-class _CheckpointConfig(ModelConfigBase):
+class CheckpointConfigBase(ModelConfigBase):
     """Model config for checkpoint-style models."""
 
     format: Literal[ModelFormat.Checkpoint] = ModelFormat.Checkpoint
-    config: str = Field(description="path to the checkpoint model config file")
+    config_path: str = Field(description="path to the checkpoint model config file")
+    converted_at: Optional[float] = Field(
+        description="When this model was last converted to diffusers", default_factory=time.time
+    )
 
 
-class _DiffusersConfig(ModelConfigBase):
+class DiffusersConfigBase(ModelConfigBase):
     """Model config for diffusers-style models."""
 
     format: Literal[ModelFormat.Diffusers] = ModelFormat.Diffusers
-    repo_variant: Optional[ModelRepoVariant] = ModelRepoVariant.DEFAULT
+    repo_variant: Optional[ModelRepoVariant] = ModelRepoVariant.Default
 
 
-class LoRAConfig(ModelConfigBase):
+class LoRAConfigBase(ModelConfigBase):
+    type: Literal[ModelType.LoRA] = ModelType.LoRA
+    trigger_phrases: Optional[set[str]] = Field(description="Set of trigger phrases for this model", default=None)
+
+
+class LoRALyCORISConfig(LoRAConfigBase):
     """Model config for LoRA/Lycoris models."""
 
-    type: Literal[ModelType.Lora] = ModelType.Lora
-    format: Literal[ModelFormat.Lycoris, ModelFormat.Diffusers]
+    format: Literal[ModelFormat.LyCORIS] = ModelFormat.LyCORIS
+
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.LoRA.value}.{ModelFormat.LyCORIS.value}")
 
 
-class VaeCheckpointConfig(ModelConfigBase):
+class LoRADiffusersConfig(LoRAConfigBase):
+    """Model config for LoRA/Diffusers models."""
+
+    format: Literal[ModelFormat.Diffusers] = ModelFormat.Diffusers
+
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.LoRA.value}.{ModelFormat.Diffusers.value}")
+
+
+class VAECheckpointConfig(CheckpointConfigBase):
     """Model config for standalone VAE models."""
 
-    type: Literal[ModelType.Vae] = ModelType.Vae
+    type: Literal[ModelType.VAE] = ModelType.VAE
     format: Literal[ModelFormat.Checkpoint] = ModelFormat.Checkpoint
 
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.VAE.value}.{ModelFormat.Checkpoint.value}")
 
-class VaeDiffusersConfig(ModelConfigBase):
+
+class VAEDiffusersConfig(ModelConfigBase):
     """Model config for standalone VAE models (diffusers version)."""
 
-    type: Literal[ModelType.Vae] = ModelType.Vae
+    type: Literal[ModelType.VAE] = ModelType.VAE
     format: Literal[ModelFormat.Diffusers] = ModelFormat.Diffusers
 
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.VAE.value}.{ModelFormat.Diffusers.value}")
 
-class ControlNetDiffusersConfig(_DiffusersConfig):
+
+class ControlAdapterConfigBase(BaseModel):
+    default_settings: Optional[ControlAdapterDefaultSettings] = Field(
+        description="Default settings for this model", default=None
+    )
+
+
+class ControlNetDiffusersConfig(DiffusersConfigBase, ControlAdapterConfigBase):
     """Model config for ControlNet models (diffusers version)."""
 
     type: Literal[ModelType.ControlNet] = ModelType.ControlNet
     format: Literal[ModelFormat.Diffusers] = ModelFormat.Diffusers
 
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.ControlNet.value}.{ModelFormat.Diffusers.value}")
 
-class ControlNetCheckpointConfig(_CheckpointConfig):
+
+class ControlNetCheckpointConfig(CheckpointConfigBase, ControlAdapterConfigBase):
     """Model config for ControlNet models (diffusers version)."""
 
     type: Literal[ModelType.ControlNet] = ModelType.ControlNet
     format: Literal[ModelFormat.Checkpoint] = ModelFormat.Checkpoint
 
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.ControlNet.value}.{ModelFormat.Checkpoint.value}")
 
-class TextualInversionConfig(ModelConfigBase):
+
+class TextualInversionFileConfig(ModelConfigBase):
     """Model config for textual inversion embeddings."""
 
     type: Literal[ModelType.TextualInversion] = ModelType.TextualInversion
-    format: Literal[ModelFormat.EmbeddingFile, ModelFormat.EmbeddingFolder]
+    format: Literal[ModelFormat.EmbeddingFile] = ModelFormat.EmbeddingFile
+
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.TextualInversion.value}.{ModelFormat.EmbeddingFile.value}")
 
 
-class _MainConfig(ModelConfigBase):
-    """Model config for main models."""
+class TextualInversionFolderConfig(ModelConfigBase):
+    """Model config for textual inversion embeddings."""
+
+    type: Literal[ModelType.TextualInversion] = ModelType.TextualInversion
+    format: Literal[ModelFormat.EmbeddingFolder] = ModelFormat.EmbeddingFolder
+
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.TextualInversion.value}.{ModelFormat.EmbeddingFolder.value}")
+
+
+class MainConfigBase(ModelConfigBase):
+    type: Literal[ModelType.Main] = ModelType.Main
+    trigger_phrases: Optional[set[str]] = Field(description="Set of trigger phrases for this model", default=None)
+    default_settings: Optional[MainModelDefaultSettings] = Field(
+        description="Default settings for this model", default=None
+    )
+
+
+class MainCheckpointConfig(CheckpointConfigBase, MainConfigBase):
+    """Model config for main checkpoint models."""
 
-    vae: Optional[str] = Field(default=None)
     variant: ModelVariantType = ModelVariantType.Normal
     prediction_type: SchedulerPredictionType = SchedulerPredictionType.Epsilon
     upcast_attention: bool = False
-    ztsnr_training: bool = False
+
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.Main.value}.{ModelFormat.Checkpoint.value}")
 
 
-class MainCheckpointConfig(_CheckpointConfig, _MainConfig):
-    """Model config for main checkpoint models."""
-
-    type: Literal[ModelType.Main] = ModelType.Main
-
-
-class MainDiffusersConfig(_DiffusersConfig, _MainConfig):
+class MainDiffusersConfig(DiffusersConfigBase, MainConfigBase):
     """Model config for main diffusers models."""
 
-    type: Literal[ModelType.Main] = ModelType.Main
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.Main.value}.{ModelFormat.Diffusers.value}")
 
 
 class IPAdapterConfig(ModelConfigBase):
@@ -242,63 +319,75 @@ class IPAdapterConfig(ModelConfigBase):
     image_encoder_model_id: str
     format: Literal[ModelFormat.InvokeAI]
 
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.IPAdapter.value}.{ModelFormat.InvokeAI.value}")
+
 
 class CLIPVisionDiffusersConfig(ModelConfigBase):
-    """Model config for ClipVision."""
+    """Model config for CLIPVision."""
 
     type: Literal[ModelType.CLIPVision] = ModelType.CLIPVision
     format: Literal[ModelFormat.Diffusers]
 
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.CLIPVision.value}.{ModelFormat.Diffusers.value}")
 
-class T2IConfig(ModelConfigBase):
+
+class T2IAdapterConfig(ModelConfigBase, ControlAdapterConfigBase):
     """Model config for T2I."""
 
     type: Literal[ModelType.T2IAdapter] = ModelType.T2IAdapter
     format: Literal[ModelFormat.Diffusers]
 
+    @staticmethod
+    def get_tag() -> Tag:
+        return Tag(f"{ModelType.T2IAdapter.value}.{ModelFormat.Diffusers.value}")
 
-_ControlNetConfig = Annotated[
-    Union[ControlNetDiffusersConfig, ControlNetCheckpointConfig],
-    Field(discriminator="format"),
-]
-_VaeConfig = Annotated[Union[VaeDiffusersConfig, VaeCheckpointConfig], Field(discriminator="format")]
-_MainModelConfig = Annotated[Union[MainDiffusersConfig, MainCheckpointConfig], Field(discriminator="format")]
 
-AnyModelConfig = Union[
-    _MainModelConfig,
-    _VaeConfig,
-    _ControlNetConfig,
-    # ModelConfigBase,
-    LoRAConfig,
-    TextualInversionConfig,
-    IPAdapterConfig,
-    CLIPVisionDiffusersConfig,
-    T2IConfig,
+def get_model_discriminator_value(v: Any) -> str:
+    """
+    Computes the discriminator value for a model config.
+    https://docs.pydantic.dev/latest/concepts/unions/#discriminated-unions-with-callable-discriminator
+    """
+    format_ = None
+    type_ = None
+    if isinstance(v, dict):
+        format_ = v.get("format")
+        if isinstance(format_, Enum):
+            format_ = format_.value
+        type_ = v.get("type")
+        if isinstance(type_, Enum):
+            type_ = type_.value
+    else:
+        format_ = v.format.value
+        type_ = v.type.value
+    v = f"{type_}.{format_}"
+    return v
+
+
+AnyModelConfig = Annotated[
+    Union[
+        Annotated[MainDiffusersConfig, MainDiffusersConfig.get_tag()],
+        Annotated[MainCheckpointConfig, MainCheckpointConfig.get_tag()],
+        Annotated[VAEDiffusersConfig, VAEDiffusersConfig.get_tag()],
+        Annotated[VAECheckpointConfig, VAECheckpointConfig.get_tag()],
+        Annotated[ControlNetDiffusersConfig, ControlNetDiffusersConfig.get_tag()],
+        Annotated[ControlNetCheckpointConfig, ControlNetCheckpointConfig.get_tag()],
+        Annotated[LoRALyCORISConfig, LoRALyCORISConfig.get_tag()],
+        Annotated[LoRADiffusersConfig, LoRADiffusersConfig.get_tag()],
+        Annotated[TextualInversionFileConfig, TextualInversionFileConfig.get_tag()],
+        Annotated[TextualInversionFolderConfig, TextualInversionFolderConfig.get_tag()],
+        Annotated[IPAdapterConfig, IPAdapterConfig.get_tag()],
+        Annotated[T2IAdapterConfig, T2IAdapterConfig.get_tag()],
+        Annotated[CLIPVisionDiffusersConfig, CLIPVisionDiffusersConfig.get_tag()],
+    ],
+    Discriminator(get_model_discriminator_value),
 ]
 
 AnyModelConfigValidator = TypeAdapter(AnyModelConfig)
-
-
-# IMPLEMENTATION NOTE:
-# The preferred alternative to the above is a discriminated Union as shown
-# below. However, it breaks FastAPI when used as the input Body parameter in a route.
-# This is a known issue. Please see:
-#   https://github.com/tiangolo/fastapi/discussions/9761 and
-#   https://github.com/tiangolo/fastapi/discussions/9287
-# AnyModelConfig = Annotated[
-#     Union[
-#         _MainModelConfig,
-#         _ONNXConfig,
-#         _VaeConfig,
-#         _ControlNetConfig,
-#         LoRAConfig,
-#         TextualInversionConfig,
-#         IPAdapterConfig,
-#         CLIPVisionDiffusersConfig,
-#         T2IConfig,
-#     ],
-#     Field(discriminator="type"),
-# ]
+AnyDefaultSettings: TypeAlias = Union[MainModelDefaultSettings, ControlAdapterDefaultSettings]
 
 
 class ModelConfigFactory(object):
@@ -332,6 +421,6 @@ class ModelConfigFactory(object):
         assert model is not None
         if key:
             model.key = key
-        if timestamp:
-            model.last_modified = timestamp
+        if isinstance(model, CheckpointConfigBase) and timestamp is not None:
+            model.converted_at = timestamp
         return model  # type: ignore

invokeai/backend/model_manager/load/load_default.py

@@ -13,6 +13,7 @@ from invokeai.backend.model_manager import (
     ModelRepoVariant,
     SubModelType,
 )
+from invokeai.backend.model_manager.config import DiffusersConfigBase, ModelType
 from invokeai.backend.model_manager.load.convert_cache import ModelConvertCacheBase
 from invokeai.backend.model_manager.load.load_base import LoadedModel, ModelLoaderBase
 from invokeai.backend.model_manager.load.model_cache.model_cache_base import ModelCacheBase, ModelLockerBase
@@ -50,7 +51,7 @@ class ModelLoader(ModelLoaderBase):
         :param submodel_type: an ModelType enum indicating the portion of
                the model to retrieve (e.g. ModelType.Vae)
         """
-        if model_config.type == "main" and not submodel_type:
+        if model_config.type is ModelType.Main and not submodel_type:
             raise InvalidModelConfigException("submodel_type is required when loading a main model")
 
         model_path, model_config, submodel_type = self._get_model_path(model_config, submodel_type)
@@ -80,7 +81,7 @@ class ModelLoader(ModelLoaderBase):
         self._convert_cache.make_room(self.get_size_fs(config, model_path, submodel_type))
         return self._convert_model(config, model_path, cache_path)
 
-    def _needs_conversion(self, config: AnyModelConfig, model_path: Path, cache_path: Path) -> bool:
+    def _needs_conversion(self, config: AnyModelConfig, model_path: Path, dest_path: Path) -> bool:
         return False
 
     def _load_if_needed(
@@ -119,7 +120,7 @@ class ModelLoader(ModelLoaderBase):
         return calc_model_size_by_fs(
             model_path=model_path,
             subfolder=submodel_type.value if submodel_type else None,
-            variant=config.repo_variant if hasattr(config, "repo_variant") else None,
+            variant=config.repo_variant if isinstance(config, DiffusersConfigBase) else None,
         )
 
     # This needs to be implemented in subclasses that handle checkpoints

invokeai/backend/model_manager/load/model_loader_registry.py

@@ -15,10 +15,8 @@ Use like this:
 
 """
 
-import hashlib
 from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Callable, Dict, Optional, Tuple, Type
+from typing import Callable, Dict, Optional, Tuple, Type, TypeVar
 
 from ..config import (
     AnyModelConfig,
@@ -27,8 +25,6 @@ from ..config import (
     ModelFormat,
     ModelType,
     SubModelType,
-    VaeCheckpointConfig,
-    VaeDiffusersConfig,
 )
 from . import ModelLoaderBase
 
@@ -61,7 +57,10 @@ class ModelLoaderRegistryBase(ABC):
         """
 
 
-class ModelLoaderRegistry:
+TModelLoader = TypeVar("TModelLoader", bound=ModelLoaderBase)
+
+
+class ModelLoaderRegistry(ModelLoaderRegistryBase):
     """
     This class allows model loaders to register their type, base and format.
     """
@@ -71,10 +70,10 @@ class ModelLoaderRegistry:
     @classmethod
     def register(
         cls, type: ModelType, format: ModelFormat, base: BaseModelType = BaseModelType.Any
-    ) -> Callable[[Type[ModelLoaderBase]], Type[ModelLoaderBase]]:
+    ) -> Callable[[Type[TModelLoader]], Type[TModelLoader]]:
         """Define a decorator which registers the subclass of loader."""
 
-        def decorator(subclass: Type[ModelLoaderBase]) -> Type[ModelLoaderBase]:
+        def decorator(subclass: Type[TModelLoader]) -> Type[TModelLoader]:
             key = cls._to_registry_key(base, type, format)
             if key in cls._registry:
                 raise Exception(
@@ -90,33 +89,15 @@ class ModelLoaderRegistry:
         cls, config: AnyModelConfig, submodel_type: Optional[SubModelType]
     ) -> Tuple[Type[ModelLoaderBase], ModelConfigBase, Optional[SubModelType]]:
         """Get subclass of ModelLoaderBase registered to handle base and type."""
-        # We have to handle VAE overrides here because this will change the model type and the corresponding implementation returned
-        conf2, submodel_type = cls._handle_subtype_overrides(config, submodel_type)
 
-        key1 = cls._to_registry_key(conf2.base, conf2.type, conf2.format)  # for a specific base type
-        key2 = cls._to_registry_key(BaseModelType.Any, conf2.type, conf2.format)  # with wildcard Any
+        key1 = cls._to_registry_key(config.base, config.type, config.format)  # for a specific base type
+        key2 = cls._to_registry_key(BaseModelType.Any, config.type, config.format)  # with wildcard Any
         implementation = cls._registry.get(key1) or cls._registry.get(key2)
         if not implementation:
             raise NotImplementedError(
                 f"No subclass of LoadedModel is registered for base={config.base}, type={config.type}, format={config.format}"
             )
-        return implementation, conf2, submodel_type
-
-    @classmethod
-    def _handle_subtype_overrides(
-        cls, config: AnyModelConfig, submodel_type: Optional[SubModelType]
-    ) -> Tuple[ModelConfigBase, Optional[SubModelType]]:
-        if submodel_type == SubModelType.Vae and hasattr(config, "vae") and config.vae is not None:
-            model_path = Path(config.vae)
-            config_class = (
-                VaeCheckpointConfig if model_path.suffix in [".pt", ".safetensors", ".ckpt"] else VaeDiffusersConfig
-            )
-            hash = hashlib.md5(model_path.as_posix().encode("utf-8")).hexdigest()
-            new_conf = config_class(path=model_path.as_posix(), name=model_path.stem, base=config.base, key=hash)
-            submodel_type = None
-        else:
-            new_conf = config
-        return new_conf, submodel_type
+        return implementation, config, submodel_type
 
     @staticmethod
     def _to_registry_key(base: BaseModelType, type: ModelType, format: ModelFormat) -> str:

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

@@ -3,8 +3,8 @@
 
 from pathlib import Path
 
-import safetensors
 import torch
+from safetensors.torch import load_file as safetensors_load_file
 
 from invokeai.backend.model_manager import (
     AnyModelConfig,
@@ -12,6 +12,7 @@ from invokeai.backend.model_manager import (
     ModelFormat,
     ModelType,
 )
+from invokeai.backend.model_manager.config import CheckpointConfigBase
 from invokeai.backend.model_manager.convert_ckpt_to_diffusers import convert_controlnet_to_diffusers
 
 from .. import ModelLoaderRegistry
@@ -20,15 +21,15 @@ from .generic_diffusers import GenericDiffusersLoader
 
 @ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.ControlNet, format=ModelFormat.Diffusers)
 @ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.ControlNet, format=ModelFormat.Checkpoint)
-class ControlnetLoader(GenericDiffusersLoader):
+class ControlNetLoader(GenericDiffusersLoader):
     """Class to load ControlNet models."""
 
     def _needs_conversion(self, config: AnyModelConfig, model_path: Path, dest_path: Path) -> bool:
-        if config.format != ModelFormat.Checkpoint:
+        if not isinstance(config, CheckpointConfigBase):
             return False
         elif (
             dest_path.exists()
-            and (dest_path / "config.json").stat().st_mtime >= (config.last_modified or 0.0)
+            and (dest_path / "config.json").stat().st_mtime >= (config.converted_at or 0.0)
             and (dest_path / "config.json").stat().st_mtime >= model_path.stat().st_mtime
         ):
             return False
@@ -37,13 +38,13 @@ class ControlnetLoader(GenericDiffusersLoader):
 
     def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Path) -> Path:
         if config.base not in {BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2}:
-            raise Exception(f"Vae conversion not supported for model type: {config.base}")
+            raise Exception(f"ControlNet conversion not supported for model type: {config.base}")
         else:
-            assert hasattr(config, "config")
-            config_file = config.config
+            assert isinstance(config, CheckpointConfigBase)
+            config_file = config.config_path
 
         if model_path.suffix == ".safetensors":
-            checkpoint = safetensors.torch.load_file(model_path, device="cpu")
+            checkpoint = safetensors_load_file(model_path, device="cpu")
         else:
             checkpoint = torch.load(model_path, map_location="cpu")
 

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

@@ -3,9 +3,10 @@
 
 import sys
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
-from diffusers import ConfigMixin, ModelMixin
+from diffusers.configuration_utils import ConfigMixin
+from diffusers.models.modeling_utils import ModelMixin
 
 from invokeai.backend.model_manager import (
     AnyModel,
@@ -41,6 +42,7 @@ class GenericDiffusersLoader(ModelLoader):
     # TO DO: Add exception handling
     def get_hf_load_class(self, model_path: Path, submodel_type: Optional[SubModelType] = None) -> ModelMixin:
         """Given the model path and submodel, returns the diffusers ModelMixin subclass needed to load."""
+        result = None
         if submodel_type:
             try:
                 config = self._load_diffusers_config(model_path, config_name="model_index.json")
@@ -64,6 +66,7 @@ class GenericDiffusersLoader(ModelLoader):
                     raise InvalidModelConfigException("Unable to decifer Load Class based on given config.json")
             except KeyError as e:
                 raise InvalidModelConfigException("An expected config.json file is missing from this model.") from e
+        assert result is not None
         return result
 
     # TO DO: Add exception handling
@@ -75,7 +78,7 @@ class GenericDiffusersLoader(ModelLoader):
         result: ModelMixin = getattr(res_type, class_name)
         return result
 
-    def _load_diffusers_config(self, model_path: Path, config_name: str = "config.json") -> Dict[str, Any]:
+    def _load_diffusers_config(self, model_path: Path, config_name: str = "config.json") -> dict[str, Any]:
         return ConfigLoader.load_config(model_path, config_name=config_name)
 
 
@@ -83,8 +86,8 @@ class ConfigLoader(ConfigMixin):
     """Subclass of ConfigMixin for loading diffusers configuration files."""
 
     @classmethod
-    def load_config(cls, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+    def load_config(cls, *args: Any, **kwargs: Any) -> dict[str, Any]:  # pyright: ignore [reportIncompatibleMethodOverride]
         """Load a diffusrs ConfigMixin configuration."""
         cls.config_name = kwargs.pop("config_name")
-        # Diffusers doesn't provide typing info
+        # TODO(psyche): the types on this diffusers method are not correct
         return super().load_config(*args, **kwargs)  # type: ignore

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

@@ -31,7 +31,7 @@ class IPAdapterInvokeAILoader(ModelLoader):
         if submodel_type is not None:
             raise ValueError("There are no submodels in an IP-Adapter model.")
         model = build_ip_adapter(
-            ip_adapter_ckpt_path=model_path / "ip_adapter.bin",
+            ip_adapter_ckpt_path=str(model_path / "ip_adapter.bin"),
             device=torch.device("cpu"),
             dtype=self._torch_dtype,
         )

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

@@ -22,9 +22,9 @@ from invokeai.backend.model_manager.load.model_cache.model_cache_base import Mod
 from .. import ModelLoader, ModelLoaderRegistry
 
 
-@ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.Lora, format=ModelFormat.Diffusers)
-@ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.Lora, format=ModelFormat.Lycoris)
-class LoraLoader(ModelLoader):
+@ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.LoRA, format=ModelFormat.Diffusers)
+@ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.LoRA, format=ModelFormat.LyCORIS)
+class LoRALoader(ModelLoader):
     """Class to load LoRA models."""
 
     # We cheat a little bit to get access to the model base

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

@@ -18,7 +18,7 @@ from .. import ModelLoaderRegistry
 from .generic_diffusers import GenericDiffusersLoader
 
 
-@ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.ONNX, format=ModelFormat.Onnx)
+@ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.ONNX, format=ModelFormat.ONNX)
 @ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.ONNX, format=ModelFormat.Olive)
 class OnnyxDiffusersModel(GenericDiffusersLoader):
     """Class to load onnx models."""

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

@@ -4,7 +4,8 @@
 from pathlib import Path
 from typing import Optional
 
-from diffusers import StableDiffusionInpaintPipeline, StableDiffusionPipeline
+from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipeline
+from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
 
 from invokeai.backend.model_manager import (
     AnyModel,
@@ -16,7 +17,7 @@ from invokeai.backend.model_manager import (
     ModelVariantType,
     SubModelType,
 )
-from invokeai.backend.model_manager.config import MainCheckpointConfig
+from invokeai.backend.model_manager.config import CheckpointConfigBase, MainCheckpointConfig
 from invokeai.backend.model_manager.convert_ckpt_to_diffusers import convert_ckpt_to_diffusers
 
 from .. import ModelLoaderRegistry
@@ -54,11 +55,11 @@ class StableDiffusionDiffusersModel(GenericDiffusersLoader):
         return result
 
     def _needs_conversion(self, config: AnyModelConfig, model_path: Path, dest_path: Path) -> bool:
-        if config.format != ModelFormat.Checkpoint:
+        if not isinstance(config, CheckpointConfigBase):
             return False
         elif (
             dest_path.exists()
-            and (dest_path / "model_index.json").stat().st_mtime >= (config.last_modified or 0.0)
+            and (dest_path / "model_index.json").stat().st_mtime >= (config.converted_at or 0.0)
             and (dest_path / "model_index.json").stat().st_mtime >= model_path.stat().st_mtime
         ):
             return False
@@ -73,7 +74,7 @@ class StableDiffusionDiffusersModel(GenericDiffusersLoader):
             StableDiffusionInpaintPipeline if variant == ModelVariantType.Inpaint else StableDiffusionPipeline
         )
 
-        config_file = config.config
+        config_file = config.config_path
 
         self._logger.info(f"Converting {model_path} to diffusers format")
         convert_ckpt_to_diffusers(

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

@@ -3,9 +3,9 @@
 
 from pathlib import Path
 
-import safetensors
 import torch
 from omegaconf import DictConfig, OmegaConf
+from safetensors.torch import load_file as safetensors_load_file
 
 from invokeai.backend.model_manager import (
     AnyModelConfig,
@@ -13,24 +13,25 @@ from invokeai.backend.model_manager import (
     ModelFormat,
     ModelType,
 )
+from invokeai.backend.model_manager.config import CheckpointConfigBase
 from invokeai.backend.model_manager.convert_ckpt_to_diffusers import convert_ldm_vae_to_diffusers
 
 from .. import ModelLoaderRegistry
 from .generic_diffusers import GenericDiffusersLoader
 
 
-@ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.Vae, format=ModelFormat.Diffusers)
-@ModelLoaderRegistry.register(base=BaseModelType.StableDiffusion1, type=ModelType.Vae, format=ModelFormat.Checkpoint)
-@ModelLoaderRegistry.register(base=BaseModelType.StableDiffusion2, type=ModelType.Vae, format=ModelFormat.Checkpoint)
-class VaeLoader(GenericDiffusersLoader):
+@ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.VAE, format=ModelFormat.Diffusers)
+@ModelLoaderRegistry.register(base=BaseModelType.StableDiffusion1, type=ModelType.VAE, format=ModelFormat.Checkpoint)
+@ModelLoaderRegistry.register(base=BaseModelType.StableDiffusion2, type=ModelType.VAE, format=ModelFormat.Checkpoint)
+class VAELoader(GenericDiffusersLoader):
     """Class to load VAE models."""
 
     def _needs_conversion(self, config: AnyModelConfig, model_path: Path, dest_path: Path) -> bool:
-        if config.format != ModelFormat.Checkpoint:
+        if not isinstance(config, CheckpointConfigBase):
             return False
         elif (
             dest_path.exists()
-            and (dest_path / "config.json").stat().st_mtime >= (config.last_modified or 0.0)
+            and (dest_path / "config.json").stat().st_mtime >= (config.converted_at or 0.0)
             and (dest_path / "config.json").stat().st_mtime >= model_path.stat().st_mtime
         ):
             return False
@@ -38,16 +39,15 @@ class VaeLoader(GenericDiffusersLoader):
             return True
 
     def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Path) -> Path:
-        # TO DO: check whether sdxl VAE models convert.
+        # TODO(MM2): check whether sdxl VAE models convert.
         if config.base not in {BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2}:
-            raise Exception(f"Vae conversion not supported for model type: {config.base}")
+            raise Exception(f"VAE conversion not supported for model type: {config.base}")
         else:
-            config_file = (
-                "v1-inference.yaml" if config.base == BaseModelType.StableDiffusion1 else "v2-inference-v.yaml"
-            )
+            assert isinstance(config, CheckpointConfigBase)
+            config_file = config.config_path
 
         if model_path.suffix == ".safetensors":
-            checkpoint = safetensors.torch.load_file(model_path, device="cpu")
+            checkpoint = safetensors_load_file(model_path, device="cpu")
         else:
             checkpoint = torch.load(model_path, map_location="cpu")
 
@@ -55,7 +55,7 @@ class VaeLoader(GenericDiffusersLoader):
         if "state_dict" in checkpoint:
             checkpoint = checkpoint["state_dict"]
 
-        ckpt_config = OmegaConf.load(self._app_config.legacy_conf_path / config_file)
+        ckpt_config = OmegaConf.load(self._app_config.root_path / config_file)
         assert isinstance(ckpt_config, DictConfig)
 
         vae_model = convert_ldm_vae_to_diffusers(

invokeai/backend/model_manager/merge.py

@@ -16,6 +16,7 @@ from diffusers import AutoPipelineForText2Image
 from diffusers.utils import logging as dlogging
 
 from invokeai.app.services.model_install import ModelInstallServiceBase
+from invokeai.app.services.model_records.model_records_base import ModelRecordChanges
 from invokeai.backend.util.devices import choose_torch_device, torch_dtype
 
 from . import (
@@ -117,7 +118,6 @@ class ModelMerger(object):
         config = self._installer.app_config
         store = self._installer.record_store
         base_models: Set[BaseModelType] = set()
-        vae = None
         variant = None if self._installer.app_config.full_precision else "fp16"
 
         assert (
@@ -134,10 +134,6 @@ class ModelMerger(object):
                 "normal"
             ), f"{info.name} ({info.key}) is a {info.variant} model, which cannot currently be merged"
 
-            # pick up the first model's vae
-            if key == model_keys[0]:
-                vae = info.vae
-
             # tally base models used
             base_models.add(info.base)
             model_paths.extend([config.models_path / info.path])
@@ -163,12 +159,10 @@ class ModelMerger(object):
 
         # update model's config
         model_config = self._installer.record_store.get_model(key)
-        model_config.update(
-            {
-                "name": merged_model_name,
-                "description": f"Merge of models {', '.join(model_names)}",
-                "vae": vae,
-            }
+        model_config.name = merged_model_name
+        model_config.description = f"Merge of models {', '.join(model_names)}"
+
+        self._installer.record_store.update_model(
+            key, ModelRecordChanges(name=model_config.name, description=model_config.description)
         )
-        self._installer.record_store.update_model(key, model_config)
         return model_config

invokeai/backend/model_manager/metadata/__init__.py

@@ -8,26 +8,20 @@ from invokeai.backend.model_manager.metadata import(
    CommercialUsage,
    LicenseRestrictions,
    HuggingFaceMetadata,
-   CivitaiMetadata,
 )
 
-from invokeai.backend.model_manager.metadata.fetch import CivitaiMetadataFetch
+from invokeai.backend.model_manager.metadata.fetch import HuggingFaceMetadataFetch
 
-data = CivitaiMetadataFetch().from_url("https://civitai.com/models/206883/split")
-assert isinstance(data, CivitaiMetadata)
-if data.allow_commercial_use:
-   print("Commercial use of this model is allowed")
+data = HuggingFaceMetadataFetch().from_id("<REPO_ID>")
+assert isinstance(data, HuggingFaceMetadata)
 """
 
-from .fetch import CivitaiMetadataFetch, HuggingFaceMetadataFetch, ModelMetadataFetchBase
+from .fetch import HuggingFaceMetadataFetch, ModelMetadataFetchBase
 from .metadata_base import (
     AnyModelRepoMetadata,
     AnyModelRepoMetadataValidator,
     BaseMetadata,
-    CivitaiMetadata,
-    CommercialUsage,
     HuggingFaceMetadata,
-    LicenseRestrictions,
     ModelMetadataWithFiles,
     RemoteModelFile,
     UnknownMetadataException,
@@ -36,12 +30,8 @@ from .metadata_base import (
 __all__ = [
     "AnyModelRepoMetadata",
     "AnyModelRepoMetadataValidator",
-    "CivitaiMetadata",
-    "CivitaiMetadataFetch",
-    "CommercialUsage",
     "HuggingFaceMetadata",
     "HuggingFaceMetadataFetch",
-    "LicenseRestrictions",
     "ModelMetadataFetchBase",
     "BaseMetadata",
     "ModelMetadataWithFiles",

invokeai/backend/model_manager/metadata/fetch/__init__.py

@@ -3,19 +3,14 @@ Initialization file for invokeai.backend.model_manager.metadata.fetch
 
 Usage:
 from invokeai.backend.model_manager.metadata.fetch import (
-    CivitaiMetadataFetch,
     HuggingFaceMetadataFetch,
 )
-from invokeai.backend.model_manager.metadata import CivitaiMetadata
 
-data = CivitaiMetadataFetch().from_url("https://civitai.com/models/206883/split")
-assert isinstance(data, CivitaiMetadata)
-if data.allow_commercial_use:
-   print("Commercial use of this model is allowed")
+data = HuggingFaceMetadataFetch().from_id("<repo_id>")
+assert isinstance(data, HuggingFaceMetadata)
 """
 
-from .civitai import CivitaiMetadataFetch
 from .fetch_base import ModelMetadataFetchBase
 from .huggingface import HuggingFaceMetadataFetch
 
-__all__ = ["ModelMetadataFetchBase", "CivitaiMetadataFetch", "HuggingFaceMetadataFetch"]
+__all__ = ["ModelMetadataFetchBase", "HuggingFaceMetadataFetch"]

invokeai/backend/model_manager/metadata/fetch/civitai.py

@@ -1,194 +0,0 @@
-# Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Development Team
-
-"""
-This module fetches model metadata objects from the Civitai model repository.
-In addition to the `from_url()` and `from_id()` methods inherited from the
-`ModelMetadataFetchBase` base class.
-
-Civitai has two separate ID spaces: a model ID and a version ID. The
-version ID corresponds to a specific model, and is the ID accepted by
-`from_id()`. The model ID corresponds to a family of related models,
-such as different training checkpoints or 16 vs 32-bit versions. The
-`from_civitai_modelid()` method will accept a model ID and return the
-metadata from the default version within this model set. The default
-version is the same as what the user sees when they click on a model's
-thumbnail.
-
-Usage:
-
-from invokeai.backend.model_manager.metadata.fetch import CivitaiMetadataFetch
-
-fetcher = CivitaiMetadataFetch()
-metadata = fetcher.from_url("https://civitai.com/models/206883/split")
-print(metadata.trained_words)
-"""
-
-import re
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-import requests
-from pydantic.networks import AnyHttpUrl
-from requests.sessions import Session
-
-from invokeai.backend.model_manager import ModelRepoVariant
-
-from ..metadata_base import (
-    AnyModelRepoMetadata,
-    CivitaiMetadata,
-    CommercialUsage,
-    LicenseRestrictions,
-    RemoteModelFile,
-    UnknownMetadataException,
-)
-from .fetch_base import ModelMetadataFetchBase
-
-CIVITAI_MODEL_PAGE_RE = r"https?://civitai.com/models/(\d+)"
-CIVITAI_VERSION_PAGE_RE = r"https?://civitai.com/models/(\d+)\?modelVersionId=(\d+)"
-CIVITAI_DOWNLOAD_RE = r"https?://civitai.com/api/download/models/(\d+)"
-
-CIVITAI_VERSION_ENDPOINT = "https://civitai.com/api/v1/model-versions/"
-CIVITAI_MODEL_ENDPOINT = "https://civitai.com/api/v1/models/"
-
-
-class CivitaiMetadataFetch(ModelMetadataFetchBase):
-    """Fetch model metadata from Civitai."""
-
-    def __init__(self, session: Optional[Session] = None):
-        """
-        Initialize the fetcher with an optional requests.sessions.Session object.
-
-        By providing a configurable Session object, we can support unit tests on
-        this module without an internet connection.
-        """
-        self._requests = session or requests.Session()
-
-    def from_url(self, url: AnyHttpUrl) -> AnyModelRepoMetadata:
-        """
-        Given a URL to a CivitAI model or version page, return a ModelMetadata object.
-
-        In the event that the URL points to a model page without the particular version
-        indicated, the default model version is returned. Otherwise, the requested version
-        is returned.
-        """
-        if match := re.match(CIVITAI_VERSION_PAGE_RE, str(url), re.IGNORECASE):
-            model_id = match.group(1)
-            version_id = match.group(2)
-            return self.from_civitai_versionid(int(version_id), int(model_id))
-        elif match := re.match(CIVITAI_MODEL_PAGE_RE, str(url), re.IGNORECASE):
-            model_id = match.group(1)
-            return self.from_civitai_modelid(int(model_id))
-        elif match := re.match(CIVITAI_DOWNLOAD_RE, str(url), re.IGNORECASE):
-            version_id = match.group(1)
-            return self.from_civitai_versionid(int(version_id))
-        raise UnknownMetadataException("The url '{url}' does not match any known Civitai URL patterns")
-
-    def from_id(self, id: str, variant: Optional[ModelRepoVariant] = None) -> AnyModelRepoMetadata:
-        """
-        Given a Civitai model version ID, return a ModelRepoMetadata object.
-
-        :param id: An ID.
-        :param variant: A model variant from the ModelRepoVariant enum (currently ignored)
-
-        May raise an `UnknownMetadataException`.
-        """
-        return self.from_civitai_versionid(int(id))
-
-    def from_civitai_modelid(self, model_id: int) -> CivitaiMetadata:
-        """
-        Return metadata from the default version of the indicated model.
-
-        May raise an `UnknownMetadataException`.
-        """
-        model_url = CIVITAI_MODEL_ENDPOINT + str(model_id)
-        model_json = self._requests.get(model_url).json()
-        return self._from_model_json(model_json)
-
-    def _from_model_json(self, model_json: Dict[str, Any], version_id: Optional[int] = None) -> CivitaiMetadata:
-        try:
-            version_id = version_id or model_json["modelVersions"][0]["id"]
-        except TypeError as excp:
-            raise UnknownMetadataException from excp
-
-        # loop till we find the section containing the version requested
-        version_sections = [x for x in model_json["modelVersions"] if x["id"] == version_id]
-        if not version_sections:
-            raise UnknownMetadataException(f"Version {version_id} not found in model metadata")
-
-        version_json = version_sections[0]
-        safe_thumbnails = [x["url"] for x in version_json["images"] if x["nsfw"] == "None"]
-
-        # Civitai has one "primary" file plus others such as VAEs. We only fetch the primary.
-        primary = [x for x in version_json["files"] if x.get("primary")]
-        assert len(primary) == 1
-        primary_file = primary[0]
-
-        url = primary_file["downloadUrl"]
-        if "?" not in url:  # work around apparent bug in civitai api
-            metadata_string = ""
-            for key, value in primary_file["metadata"].items():
-                if not value:
-                    continue
-                metadata_string += f"&{key}={value}"
-            url = url + f"?type={primary_file['type']}{metadata_string}"
-        model_files = [
-            RemoteModelFile(
-                url=url,
-                path=Path(primary_file["name"]),
-                size=int(primary_file["sizeKB"] * 1024),
-                sha256=primary_file["hashes"]["SHA256"],
-            )
-        ]
-        return CivitaiMetadata(
-            id=model_json["id"],
-            name=version_json["name"],
-            version_id=version_json["id"],
-            version_name=version_json["name"],
-            created=datetime.fromisoformat(_fix_timezone(version_json["createdAt"])),
-            updated=datetime.fromisoformat(_fix_timezone(version_json["updatedAt"])),
-            published=datetime.fromisoformat(_fix_timezone(version_json["publishedAt"])),
-            base_model_trained_on=version_json["baseModel"],  # note - need a dictionary to turn into a BaseModelType
-            files=model_files,
-            download_url=version_json["downloadUrl"],
-            thumbnail_url=safe_thumbnails[0] if safe_thumbnails else None,
-            author=model_json["creator"]["username"],
-            description=model_json["description"],
-            version_description=version_json["description"] or "",
-            tags=model_json["tags"],
-            trained_words=version_json["trainedWords"],
-            nsfw=model_json["nsfw"],
-            restrictions=LicenseRestrictions(
-                AllowNoCredit=model_json["allowNoCredit"],
-                AllowCommercialUse={CommercialUsage(x) for x in model_json["allowCommercialUse"]},
-                AllowDerivatives=model_json["allowDerivatives"],
-                AllowDifferentLicense=model_json["allowDifferentLicense"],
-            ),
-        )
-
-    def from_civitai_versionid(self, version_id: int, model_id: Optional[int] = None) -> CivitaiMetadata:
-        """
-        Return a CivitaiMetadata object given a model version id.
-
-        May raise an `UnknownMetadataException`.
-        """
-        if model_id is None:
-            version_url = CIVITAI_VERSION_ENDPOINT + str(version_id)
-            version = self._requests.get(version_url).json()
-            if error := version.get("error"):
-                raise UnknownMetadataException(error)
-            model_id = version["modelId"]
-
-        model_url = CIVITAI_MODEL_ENDPOINT + str(model_id)
-        model_json = self._requests.get(model_url).json()
-        return self._from_model_json(model_json, version_id)
-
-    @classmethod
-    def from_json(cls, json: str) -> CivitaiMetadata:
-        """Given the JSON representation of the metadata, return the corresponding Pydantic object."""
-        metadata = CivitaiMetadata.model_validate_json(json)
-        return metadata
-
-
-def _fix_timezone(date: str) -> str:
-    return re.sub(r"Z$", "+00:00", date)

invokeai/backend/model_manager/metadata/fetch/fetch_base.py

@@ -5,11 +5,10 @@ This module is the base class for subclasses that fetch metadata from model repo
 
 Usage:
 
-from invokeai.backend.model_manager.metadata.fetch import CivitAIMetadataFetch
+from invokeai.backend.model_manager.metadata.fetch import HuggingFaceMetadataFetch
 
-fetcher = CivitaiMetadataFetch()
-metadata = fetcher.from_url("https://civitai.com/models/206883/split")
-print(metadata.trained_words)
+data = HuggingFaceMetadataFetch().from_id("<REPO_ID>")
+assert isinstance(data, HuggingFaceMetadata)
 """
 
 from abc import ABC, abstractmethod

invokeai/backend/model_manager/metadata/fetch/huggingface.py

@@ -13,6 +13,7 @@ metadata = fetcher.from_url("https://huggingface.co/stabilityai/sdxl-turbo")
 print(metadata.tags)
 """
 
+import json
 import re
 from pathlib import Path
 from typing import Optional
@@ -23,7 +24,7 @@ from huggingface_hub.utils._errors import RepositoryNotFoundError, RevisionNotFo
 from pydantic.networks import AnyHttpUrl
 from requests.sessions import Session
 
-from invokeai.backend.model_manager import ModelRepoVariant
+from invokeai.backend.model_manager.config import ModelRepoVariant
 
 from ..metadata_base import (
     AnyModelRepoMetadata,
@@ -60,6 +61,7 @@ class HuggingFaceMetadataFetch(ModelMetadataFetchBase):
         # Little loop which tries fetching a revision corresponding to the selected variant.
         # If not available, then set variant to None and get the default.
         # If this too fails, raise exception.
+
         model_info = None
         while not model_info:
             try:
@@ -72,23 +74,24 @@ class HuggingFaceMetadataFetch(ModelMetadataFetchBase):
                 else:
                     variant = None
 
+        files: list[RemoteModelFile] = []
+
         _, name = id.split("/")
-        return HuggingFaceMetadata(
-            id=model_info.id,
-            author=model_info.author,
-            name=name,
-            last_modified=model_info.last_modified,
-            tag_dict=model_info.card_data.to_dict() if model_info.card_data else {},
-            tags=model_info.tags,
-            files=[
+
+        for s in model_info.siblings or []:
+            assert s.rfilename is not None
+            assert s.size is not None
+            files.append(
                 RemoteModelFile(
-                    url=hf_hub_url(id, x.rfilename, revision=variant),
-                    path=Path(name, x.rfilename),
-                    size=x.size,
-                    sha256=x.lfs.get("sha256") if x.lfs else None,
+                    url=hf_hub_url(id, s.rfilename, revision=variant),
+                    path=Path(name, s.rfilename),
+                    size=s.size,
+                    sha256=s.lfs.get("sha256") if s.lfs else None,
                 )
-                for x in model_info.siblings
-            ],
+            )
+
+        return HuggingFaceMetadata(
+            id=model_info.id, name=name, files=files, api_response=json.dumps(model_info.__dict__, default=str)
         )
 
     def from_url(self, url: AnyHttpUrl) -> AnyModelRepoMetadata:

invokeai/backend/model_manager/metadata/metadata_base.py

@@ -14,10 +14,8 @@ versions of these fields are intended to be kept in sync with the
 remote repo.
 """
 
-from datetime import datetime
-from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, Set, Tuple, Union
+from typing import List, Literal, Optional, Union
 
 from huggingface_hub import configure_http_backend, hf_hub_url
 from pydantic import BaseModel, Field, TypeAdapter
@@ -25,7 +23,6 @@ from pydantic.networks import AnyHttpUrl
 from requests.sessions import Session
 from typing_extensions import Annotated
 
-from invokeai.app.invocations.constants import SCHEDULER_NAME_VALUES
 from invokeai.backend.model_manager import ModelRepoVariant
 
 from ..util import select_hf_files
@@ -35,31 +32,6 @@ class UnknownMetadataException(Exception):
     """Raised when no metadata is available for a model."""
 
 
-class CommercialUsage(str, Enum):
-    """Type of commercial usage allowed."""
-
-    No = "None"
-    Image = "Image"
-    Rent = "Rent"
-    RentCivit = "RentCivit"
-    Sell = "Sell"
-
-
-class LicenseRestrictions(BaseModel):
-    """Broad categories of licensing restrictions."""
-
-    AllowNoCredit: bool = Field(
-        description="if true, model can be redistributed without crediting author", default=False
-    )
-    AllowDerivatives: bool = Field(description="if true, derivatives of this model can be redistributed", default=False)
-    AllowDifferentLicense: bool = Field(
-        description="if true, derivatives of this model be redistributed under a different license", default=False
-    )
-    AllowCommercialUse: Optional[Set[CommercialUsage] | CommercialUsage] = Field(
-        description="Type of commercial use allowed if no commercial use is allowed.", default=None
-    )
-
-
 class RemoteModelFile(BaseModel):
     """Information about a downloadable file that forms part of a model."""
 
@@ -69,24 +41,10 @@ class RemoteModelFile(BaseModel):
     sha256: Optional[str] = Field(description="SHA256 hash of this model (not always available)", default=None)
 
 
-class ModelDefaultSettings(BaseModel):
-    vae: str | None
-    vae_precision: str | None
-    scheduler: SCHEDULER_NAME_VALUES | None
-    steps: int | None
-    cfg_scale: float | None
-    cfg_rescale_multiplier: float | None
-
-
 class ModelMetadataBase(BaseModel):
     """Base class for model metadata information."""
 
     name: str = Field(description="model's name")
-    author: str = Field(description="model's author")
-    tags: Optional[Set[str]] = Field(description="tags provided by model source", default=None)
-    default_settings: Optional[ModelDefaultSettings] = Field(
-        description="default settings for this model", default=None
-    )
 
 
 class BaseMetadata(ModelMetadataBase):
@@ -120,64 +78,12 @@ class ModelMetadataWithFiles(ModelMetadataBase):
         return self.files
 
 
-class CivitaiMetadata(ModelMetadataWithFiles):
-    """Extended metadata fields provided by Civitai."""
-
-    type: Literal["civitai"] = "civitai"
-    id: int = Field(description="Civitai version identifier")
-    version_name: str = Field(description="Version identifier, such as 'V2-alpha'")
-    version_id: int = Field(description="Civitai model version identifier")
-    created: datetime = Field(description="date the model was created")
-    updated: datetime = Field(description="date the model was last modified")
-    published: datetime = Field(description="date the model was published to Civitai")
-    description: str = Field(description="text description of model; may contain HTML")
-    version_description: str = Field(
-        description="text description of the model's reversion; usually change history; may contain HTML"
-    )
-    nsfw: bool = Field(description="whether the model tends to generate NSFW content", default=False)
-    restrictions: LicenseRestrictions = Field(description="license terms", default_factory=LicenseRestrictions)
-    trained_words: Set[str] = Field(description="words to trigger the model", default_factory=set)
-    download_url: AnyHttpUrl = Field(description="download URL for this model")
-    base_model_trained_on: str = Field(description="base model on which this model was trained (currently not an enum)")
-    thumbnail_url: Optional[AnyHttpUrl] = Field(description="a thumbnail image for this model", default=None)
-    weight_minmax: Tuple[float, float] = Field(
-        description="minimum and maximum slider values for a LoRA or other secondary model", default=(-1.0, +2.0)
-    )  # note: For future use
-
-    @property
-    def credit_required(self) -> bool:
-        """Return True if you must give credit for derivatives of this model and images generated from it."""
-        return not self.restrictions.AllowNoCredit
-
-    @property
-    def allow_commercial_use(self) -> bool:
-        """Return True if commercial use is allowed."""
-        if self.restrictions.AllowCommercialUse is None:
-            return False
-        else:
-            # accommodate schema change
-            acu = self.restrictions.AllowCommercialUse
-            commercial_usage = acu if isinstance(acu, set) else {acu}
-            return CommercialUsage.No not in commercial_usage
-
-    @property
-    def allow_derivatives(self) -> bool:
-        """Return True if derivatives of this model can be redistributed."""
-        return self.restrictions.AllowDerivatives
-
-    @property
-    def allow_different_license(self) -> bool:
-        """Return true if derivatives of this model can use a different license."""
-        return self.restrictions.AllowDifferentLicense
-
-
 class HuggingFaceMetadata(ModelMetadataWithFiles):
     """Extended metadata fields provided by HuggingFace."""
 
     type: Literal["huggingface"] = "huggingface"
-    id: str = Field(description="huggingface model id")
-    tag_dict: Dict[str, Any]
-    last_modified: datetime = Field(description="date of last commit to repo")
+    id: str = Field(description="The HF model id")
+    api_response: Optional[str] = Field(description="Response from the HF API as stringified JSON", default=None)
 
     def download_urls(
         self,
@@ -206,7 +112,7 @@ class HuggingFaceMetadata(ModelMetadataWithFiles):
         # the next step reads model_index.json to determine which subdirectories belong
         # to the model
         if Path(f"{prefix}model_index.json") in paths:
-            url = hf_hub_url(self.id, filename="model_index.json", subfolder=subfolder)
+            url = hf_hub_url(self.id, filename="model_index.json", subfolder=str(subfolder) if subfolder else None)
             resp = session.get(url)
             resp.raise_for_status()
             submodels = resp.json()
@@ -216,5 +122,5 @@ class HuggingFaceMetadata(ModelMetadataWithFiles):
         return [x for x in self.files if x.path in paths]
 
 
-AnyModelRepoMetadata = Annotated[Union[BaseMetadata, HuggingFaceMetadata, CivitaiMetadata], Field(discriminator="type")]
+AnyModelRepoMetadata = Annotated[Union[BaseMetadata, HuggingFaceMetadata], Field(discriminator="type")]
 AnyModelRepoMetadataValidator = TypeAdapter(AnyModelRepoMetadata)

invokeai/backend/model_manager/metadata/metadata_store.py

@@ -1,221 +0,0 @@
-# Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Development Team
-"""
-SQL Storage for Model Metadata
-"""
-
-import sqlite3
-from typing import List, Optional, Set, Tuple
-
-from invokeai.app.services.shared.sqlite.sqlite_database import SqliteDatabase
-
-from .fetch import ModelMetadataFetchBase
-from .metadata_base import AnyModelRepoMetadata, UnknownMetadataException
-
-
-class ModelMetadataStore:
-    """Store, search and fetch model metadata retrieved from remote repositories."""
-
-    def __init__(self, db: SqliteDatabase):
-        """
-        Initialize a new object from preexisting sqlite3 connection and threading lock objects.
-
-        :param conn: sqlite3 connection object
-        :param lock: threading Lock object
-        """
-        super().__init__()
-        self._db = db
-        self._cursor = self._db.conn.cursor()
-
-    def add_metadata(self, model_key: str, metadata: AnyModelRepoMetadata) -> None:
-        """
-        Add a block of repo metadata to a model record.
-
-        The model record config must already exist in the database with the
-        same key. Otherwise a FOREIGN KEY constraint exception will be raised.
-
-        :param model_key: Existing model key in the `model_config` table
-        :param metadata: ModelRepoMetadata object to store
-        """
-        json_serialized = metadata.model_dump_json()
-        with self._db.lock:
-            try:
-                self._cursor.execute(
-                    """--sql
-                    INSERT INTO model_metadata(
-                       id,
-                       metadata
-                    )
-                    VALUES (?,?);
-                    """,
-                    (
-                        model_key,
-                        json_serialized,
-                    ),
-                )
-                self._update_tags(model_key, metadata.tags)
-                self._db.conn.commit()
-            except sqlite3.IntegrityError as excp:  # FOREIGN KEY error: the key was not in model_config table
-                self._db.conn.rollback()
-                raise UnknownMetadataException from excp
-            except sqlite3.Error as excp:
-                self._db.conn.rollback()
-                raise excp
-
-    def get_metadata(self, model_key: str) -> AnyModelRepoMetadata:
-        """Retrieve the ModelRepoMetadata corresponding to model key."""
-        with self._db.lock:
-            self._cursor.execute(
-                """--sql
-                SELECT metadata FROM model_metadata
-                WHERE id=?;
-                """,
-                (model_key,),
-            )
-            rows = self._cursor.fetchone()
-            if not rows:
-                raise UnknownMetadataException("model metadata not found")
-            return ModelMetadataFetchBase.from_json(rows[0])
-
-    def list_all_metadata(self) -> List[Tuple[str, AnyModelRepoMetadata]]:  # key, metadata
-        """Dump out all the metadata."""
-        with self._db.lock:
-            self._cursor.execute(
-                """--sql
-                SELECT id,metadata FROM model_metadata;
-                """,
-                (),
-            )
-            rows = self._cursor.fetchall()
-        return [(x[0], ModelMetadataFetchBase.from_json(x[1])) for x in rows]
-
-    def update_metadata(self, model_key: str, metadata: AnyModelRepoMetadata) -> AnyModelRepoMetadata:
-        """
-        Update metadata corresponding to the model with the indicated key.
-
-        :param model_key: Existing model key in the `model_config` table
-        :param metadata: ModelRepoMetadata object to update
-        """
-        json_serialized = metadata.model_dump_json()  # turn it into a json string.
-        with self._db.lock:
-            try:
-                self._cursor.execute(
-                    """--sql
-                    UPDATE model_metadata
-                    SET
-                        metadata=?
-                    WHERE id=?;
-                    """,
-                    (json_serialized, model_key),
-                )
-                if self._cursor.rowcount == 0:
-                    raise UnknownMetadataException("model metadata not found")
-                self._update_tags(model_key, metadata.tags)
-                self._db.conn.commit()
-            except sqlite3.Error as e:
-                self._db.conn.rollback()
-                raise e
-
-        return self.get_metadata(model_key)
-
-    def list_tags(self) -> Set[str]:
-        """Return all tags in the tags table."""
-        self._cursor.execute(
-            """--sql
-            select tag_text from tags;
-            """
-        )
-        return {x[0] for x in self._cursor.fetchall()}
-
-    def search_by_tag(self, tags: Set[str]) -> Set[str]:
-        """Return the keys of models containing all of the listed tags."""
-        with self._db.lock:
-            try:
-                matches: Optional[Set[str]] = None
-                for tag in tags:
-                    self._cursor.execute(
-                        """--sql
-                        SELECT a.model_id FROM model_tags AS a,
-                                                     tags AS b
-                        WHERE a.tag_id=b.tag_id
-                          AND b.tag_text=?;
-                        """,
-                        (tag,),
-                    )
-                    model_keys = {x[0] for x in self._cursor.fetchall()}
-                    if matches is None:
-                        matches = model_keys
-                    matches = matches.intersection(model_keys)
-            except sqlite3.Error as e:
-                raise e
-        return matches if matches else set()
-
-    def search_by_author(self, author: str) -> Set[str]:
-        """Return the keys of models authored by the indicated author."""
-        self._cursor.execute(
-            """--sql
-            SELECT id FROM model_metadata
-            WHERE author=?;
-            """,
-            (author,),
-        )
-        return {x[0] for x in self._cursor.fetchall()}
-
-    def search_by_name(self, name: str) -> Set[str]:
-        """
-        Return the keys of models with the indicated name.
-
-        Note that this is the name of the model given to it by
-        the remote source. The user may have changed the local
-        name. The local name will be located in the model config
-        record object.
-        """
-        self._cursor.execute(
-            """--sql
-            SELECT id FROM model_metadata
-            WHERE name=?;
-            """,
-            (name,),
-        )
-        return {x[0] for x in self._cursor.fetchall()}
-
-    def _update_tags(self, model_key: str, tags: Set[str]) -> None:
-        """Update tags for the model referenced by model_key."""
-        # remove previous tags from this model
-        self._cursor.execute(
-            """--sql
-            DELETE FROM model_tags
-            WHERE model_id=?;
-            """,
-            (model_key,),
-        )
-
-        for tag in tags:
-            self._cursor.execute(
-                """--sql
-                INSERT OR IGNORE INTO tags (
-                  tag_text
-                  )
-                VALUES (?);
-                """,
-                (tag,),
-            )
-            self._cursor.execute(
-                """--sql
-                SELECT tag_id
-                FROM tags
-                WHERE tag_text = ?
-                LIMIT 1;
-                """,
-                (tag,),
-            )
-            tag_id = self._cursor.fetchone()[0]
-            self._cursor.execute(
-                """--sql
-                INSERT OR IGNORE INTO model_tags (
-                   model_id,
-                   tag_id
-                  )
-                VALUES (?,?);
-                """,
-                (model_key, tag_id),
-            )

invokeai/backend/model_manager/probe.py

@@ -8,15 +8,18 @@ import torch
 from picklescan.scanner import scan_file_path
 
 import invokeai.backend.util.logging as logger
+from invokeai.app.util.misc import uuid_string
 from invokeai.backend.util.util import SilenceWarnings
 
 from .config import (
     AnyModelConfig,
     BaseModelType,
+    ControlAdapterDefaultSettings,
     InvalidModelConfigException,
     ModelConfigFactory,
     ModelFormat,
     ModelRepoVariant,
+    ModelSourceType,
     ModelType,
     ModelVariantType,
     SchedulerPredictionType,
@@ -95,8 +98,8 @@ class ModelProbe(object):
         "StableDiffusionXLImg2ImgPipeline": ModelType.Main,
         "StableDiffusionXLInpaintPipeline": ModelType.Main,
         "LatentConsistencyModelPipeline": ModelType.Main,
-        "AutoencoderKL": ModelType.Vae,
-        "AutoencoderTiny": ModelType.Vae,
+        "AutoencoderKL": ModelType.VAE,
+        "AutoencoderTiny": ModelType.VAE,
         "ControlNetModel": ModelType.ControlNet,
         "CLIPVisionModelWithProjection": ModelType.CLIPVision,
         "T2IAdapter": ModelType.T2IAdapter,
@@ -108,14 +111,6 @@ class ModelProbe(object):
     ) -> None:
         cls.PROBES[format][model_type] = probe_class
 
-    @classmethod
-    def heuristic_probe(
-        cls,
-        model_path: Path,
-        fields: Optional[Dict[str, Any]] = None,
-    ) -> AnyModelConfig:
-        return cls.probe(model_path, fields)
-
     @classmethod
     def probe(
         cls,
@@ -134,22 +129,26 @@ class ModelProbe(object):
         if fields is None:
             fields = {}
 
+        model_path = model_path.resolve()
+
         format_type = ModelFormat.Diffusers if model_path.is_dir() else ModelFormat.Checkpoint
         model_info = None
         model_type = None
-        if format_type == "diffusers":
+        if format_type is ModelFormat.Diffusers:
             model_type = cls.get_model_type_from_folder(model_path)
         else:
             model_type = cls.get_model_type_from_checkpoint(model_path)
-        format_type = ModelFormat.Onnx if model_type == ModelType.ONNX else format_type
+        format_type = ModelFormat.ONNX if model_type == ModelType.ONNX else format_type
 
         probe_class = cls.PROBES[format_type].get(model_type)
         if not probe_class:
             raise InvalidModelConfigException(f"Unhandled combination of {format_type} and {model_type}")
 
-        hash = ModelHash().hash(model_path)
         probe = probe_class(model_path)
 
+        fields["source_type"] = fields.get("source_type") or ModelSourceType.Path
+        fields["source"] = fields.get("source") or model_path.as_posix()
+        fields["key"] = fields.get("key", uuid_string())
         fields["path"] = model_path.as_posix()
         fields["type"] = fields.get("type") or model_type
         fields["base"] = fields.get("base") or probe.get_base_type()
@@ -161,15 +160,23 @@ class ModelProbe(object):
             fields.get("description") or f"{fields['base'].value} {fields['type'].value} model {fields['name']}"
         )
         fields["format"] = fields.get("format") or probe.get_format()
-        fields["original_hash"] = fields.get("original_hash") or hash
-        fields["current_hash"] = fields.get("current_hash") or hash
+        fields["hash"] = fields.get("hash") or ModelHash().hash(model_path)
 
-        if format_type == ModelFormat.Diffusers and hasattr(probe, "get_repo_variant"):
+        fields["default_settings"] = (
+            fields.get("default_settings") or probe.get_default_settings(fields["name"])
+            if isinstance(probe, ControlAdapterProbe)
+            else None
+        )
+
+        if format_type == ModelFormat.Diffusers and isinstance(probe, FolderProbeBase):
             fields["repo_variant"] = fields.get("repo_variant") or probe.get_repo_variant()
 
         # additional fields needed for main and controlnet models
-        if fields["type"] in [ModelType.Main, ModelType.ControlNet] and fields["format"] == ModelFormat.Checkpoint:
-            fields["config"] = cls._get_checkpoint_config_path(
+        if (
+            fields["type"] in [ModelType.Main, ModelType.ControlNet, ModelType.VAE]
+            and fields["format"] is ModelFormat.Checkpoint
+        ):
+            fields["config_path"] = cls._get_checkpoint_config_path(
                 model_path,
                 model_type=fields["type"],
                 base_type=fields["base"],
@@ -179,7 +186,7 @@ class ModelProbe(object):
 
         # additional fields needed for main non-checkpoint models
         elif fields["type"] == ModelType.Main and fields["format"] in [
-            ModelFormat.Onnx,
+            ModelFormat.ONNX,
             ModelFormat.Olive,
             ModelFormat.Diffusers,
         ]:
@@ -213,11 +220,11 @@ class ModelProbe(object):
             if any(key.startswith(v) for v in {"cond_stage_model.", "first_stage_model.", "model.diffusion_model."}):
                 return ModelType.Main
             elif any(key.startswith(v) for v in {"encoder.conv_in", "decoder.conv_in"}):
-                return ModelType.Vae
+                return ModelType.VAE
             elif any(key.startswith(v) for v in {"lora_te_", "lora_unet_"}):
-                return ModelType.Lora
+                return ModelType.LoRA
             elif any(key.endswith(v) for v in {"to_k_lora.up.weight", "to_q_lora.down.weight"}):
-                return ModelType.Lora
+                return ModelType.LoRA
             elif any(key.startswith(v) for v in {"control_model", "input_blocks"}):
                 return ModelType.ControlNet
             elif key in {"emb_params", "string_to_param"}:
@@ -239,7 +246,7 @@ class ModelProbe(object):
             if (folder_path / f"learned_embeds.{suffix}").exists():
                 return ModelType.TextualInversion
             if (folder_path / f"pytorch_lora_weights.{suffix}").exists():
-                return ModelType.Lora
+                return ModelType.LoRA
         if (folder_path / "unet/model.onnx").exists():
             return ModelType.ONNX
         if (folder_path / "image_encoder.txt").exists():
@@ -285,13 +292,21 @@ class ModelProbe(object):
         if possible_conf.exists():
             return possible_conf.absolute()
 
-        if model_type == ModelType.Main:
+        if model_type is ModelType.Main:
             config_file = LEGACY_CONFIGS[base_type][variant_type]
             if isinstance(config_file, dict):  # need another tier for sd-2.x models
                 config_file = config_file[prediction_type]
-        elif model_type == ModelType.ControlNet:
+        elif model_type is ModelType.ControlNet:
             config_file = (
-                "../controlnet/cldm_v15.yaml" if base_type == BaseModelType("sd-1") else "../controlnet/cldm_v21.yaml"
+                "../controlnet/cldm_v15.yaml"
+                if base_type is BaseModelType.StableDiffusion1
+                else "../controlnet/cldm_v21.yaml"
+            )
+        elif model_type is ModelType.VAE:
+            config_file = (
+                "../stable-diffusion/v1-inference.yaml"
+                if base_type is BaseModelType.StableDiffusion1
+                else "../stable-diffusion/v2-inference.yaml"
             )
         else:
             raise InvalidModelConfigException(
@@ -323,6 +338,38 @@ class ModelProbe(object):
             raise Exception("The model {model_name} is potentially infected by malware. Aborting import.")
 
 
+class ControlAdapterProbe(ProbeBase):
+    """Adds `get_default_settings` for ControlNet and T2IAdapter probes"""
+
+    # TODO(psyche): It would be nice to get these from the invocations, but that creates circular dependencies.
+    # "canny": CannyImageProcessorInvocation.get_type()
+    MODEL_NAME_TO_PREPROCESSOR = {
+        "canny": "canny_image_processor",
+        "mlsd": "mlsd_image_processor",
+        "depth": "depth_anything_image_processor",
+        "bae": "normalbae_image_processor",
+        "normal": "normalbae_image_processor",
+        "sketch": "pidi_image_processor",
+        "scribble": "lineart_image_processor",
+        "lineart": "lineart_image_processor",
+        "lineart_anime": "lineart_anime_image_processor",
+        "softedge": "hed_image_processor",
+        "shuffle": "content_shuffle_image_processor",
+        "pose": "dw_openpose_image_processor",
+        "mediapipe": "mediapipe_face_processor",
+        "pidi": "pidi_image_processor",
+        "zoe": "zoe_depth_image_processor",
+        "color": "color_map_image_processor",
+    }
+
+    @classmethod
+    def get_default_settings(cls, model_name: str) -> Optional[ControlAdapterDefaultSettings]:
+        for k, v in cls.MODEL_NAME_TO_PREPROCESSOR.items():
+            if k in model_name:
+                return ControlAdapterDefaultSettings(preprocessor=v)
+        return None
+
+
 # ##################################################3
 # Checkpoint probing
 # ##################################################3
@@ -446,7 +493,7 @@ class TextualInversionCheckpointProbe(CheckpointProbeBase):
             raise InvalidModelConfigException(f"{self.model_path}: Could not determine base type")
 
 
-class ControlNetCheckpointProbe(CheckpointProbeBase):
+class ControlNetCheckpointProbe(CheckpointProbeBase, ControlAdapterProbe):
     """Class for probing controlnets."""
 
     def get_base_type(self) -> BaseModelType:
@@ -474,7 +521,7 @@ class CLIPVisionCheckpointProbe(CheckpointProbeBase):
         raise NotImplementedError()
 
 
-class T2IAdapterCheckpointProbe(CheckpointProbeBase):
+class T2IAdapterCheckpointProbe(CheckpointProbeBase, ControlAdapterProbe):
     def get_base_type(self) -> BaseModelType:
         raise NotImplementedError()
 
@@ -497,12 +544,12 @@ class FolderProbeBase(ProbeBase):
             if ".fp16" in x.suffixes:
                 return ModelRepoVariant.FP16
             if "openvino_model" in x.name:
-                return ModelRepoVariant.OPENVINO
+                return ModelRepoVariant.OpenVINO
             if "flax_model" in x.name:
-                return ModelRepoVariant.FLAX
+                return ModelRepoVariant.Flax
             if x.suffix == ".onnx":
                 return ModelRepoVariant.ONNX
-        return ModelRepoVariant.DEFAULT
+        return ModelRepoVariant.Default
 
 
 class PipelineFolderProbe(FolderProbeBase):
@@ -612,7 +659,7 @@ class ONNXFolderProbe(PipelineFolderProbe):
         return ModelVariantType.Normal
 
 
-class ControlNetFolderProbe(FolderProbeBase):
+class ControlNetFolderProbe(FolderProbeBase, ControlAdapterProbe):
     def get_base_type(self) -> BaseModelType:
         config_file = self.model_path / "config.json"
         if not config_file.exists():
@@ -686,7 +733,7 @@ class CLIPVisionFolderProbe(FolderProbeBase):
         return BaseModelType.Any
 
 
-class T2IAdapterFolderProbe(FolderProbeBase):
+class T2IAdapterFolderProbe(FolderProbeBase, ControlAdapterProbe):
     def get_base_type(self) -> BaseModelType:
         config_file = self.model_path / "config.json"
         if not config_file.exists():
@@ -708,8 +755,8 @@ class T2IAdapterFolderProbe(FolderProbeBase):
 
 ############## register probe classes ######
 ModelProbe.register_probe("diffusers", ModelType.Main, PipelineFolderProbe)
-ModelProbe.register_probe("diffusers", ModelType.Vae, VaeFolderProbe)
-ModelProbe.register_probe("diffusers", ModelType.Lora, LoRAFolderProbe)
+ModelProbe.register_probe("diffusers", ModelType.VAE, VaeFolderProbe)
+ModelProbe.register_probe("diffusers", ModelType.LoRA, LoRAFolderProbe)
 ModelProbe.register_probe("diffusers", ModelType.TextualInversion, TextualInversionFolderProbe)
 ModelProbe.register_probe("diffusers", ModelType.ControlNet, ControlNetFolderProbe)
 ModelProbe.register_probe("diffusers", ModelType.IPAdapter, IPAdapterFolderProbe)
@@ -717,8 +764,8 @@ ModelProbe.register_probe("diffusers", ModelType.CLIPVision, CLIPVisionFolderPro
 ModelProbe.register_probe("diffusers", ModelType.T2IAdapter, T2IAdapterFolderProbe)
 
 ModelProbe.register_probe("checkpoint", ModelType.Main, PipelineCheckpointProbe)
-ModelProbe.register_probe("checkpoint", ModelType.Vae, VaeCheckpointProbe)
-ModelProbe.register_probe("checkpoint", ModelType.Lora, LoRACheckpointProbe)
+ModelProbe.register_probe("checkpoint", ModelType.VAE, VaeCheckpointProbe)
+ModelProbe.register_probe("checkpoint", ModelType.LoRA, LoRACheckpointProbe)
 ModelProbe.register_probe("checkpoint", ModelType.TextualInversion, TextualInversionCheckpointProbe)
 ModelProbe.register_probe("checkpoint", ModelType.ControlNet, ControlNetCheckpointProbe)
 ModelProbe.register_probe("checkpoint", ModelType.IPAdapter, IPAdapterCheckpointProbe)

invokeai/backend/model_manager/search.py

@@ -4,121 +4,75 @@ Abstract base class and implementation for recursive directory search for models
 
 Example usage:
 ```
-  from invokeai.backend.model_manager import ModelSearch, ModelProbe
+    from invokeai.backend.model_manager import ModelSearch, ModelProbe
 
-  def find_main_models(model: Path) -> bool:
-    info = ModelProbe.probe(model)
-    if info.model_type == 'main' and info.base_type == 'sd-1':
-        return True
-    else:
-        return False
+    def find_main_models(model: Path) -> bool:
+        info = ModelProbe.probe(model)
+        if info.model_type == 'main' and info.base_type == 'sd-1':
+            return True
+        else:
+            return False
 
-  search = ModelSearch(on_model_found=report_it)
-  found = search.search('/tmp/models')
-  print(found)   #  list of matching model paths
-  print(search.stats)  #  search stats
+    search = ModelSearch(on_model_found=report_it)
+    found = search.search('/tmp/models')
+    print(found)   #  list of matching model paths
+    print(search.stats)  #  search stats
 ```
 """
 
 import os
-from abc import ABC, abstractmethod
-from logging import Logger
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Callable, Optional, Set, Union
+from typing import Callable, Optional
 
-from pydantic import BaseModel, Field
-
-from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.backend.util.logging import InvokeAILogger
 
-default_logger: Logger = InvokeAILogger.get_logger()
 
+@dataclass
+class SearchStats:
+    """Statistics about the search.
 
-class SearchStats(BaseModel):
-    items_scanned: int = 0
-    models_found: int = 0
-    models_filtered: int = 0
-
-
-class ModelSearchBase(ABC, BaseModel):
+    Attributes:
+        items_scanned: number of items scanned
+        models_found: number of models found
+        models_filtered: number of models that passed the filter
     """
-    Abstract directory traversal model search class
+
+    items_scanned = 0
+    models_found = 0
+    models_filtered = 0
+
+
+class ModelSearch:
+    """Searches a directory tree for models, using a callback to filter the results.
 
     Usage:
-       search = ModelSearchBase(
-            on_search_started = search_started_callback,
-            on_search_completed = search_completed_callback,
-            on_model_found = model_found_callback,
-       )
-       models_found = search.search('/path/to/directory')
+        search = ModelSearch()
+        search.model_found = lambda path : 'anime' in path.as_posix()
+        found = search.list_models(['/tmp/models1','/tmp/models2'])
+        # returns all models that have 'anime' in the path
     """
 
-    # fmt: off
-    on_search_started   : Optional[Callable[[Path], None]]      = Field(default=None, description="Called just before the search starts.")  # noqa E221
-    on_model_found      : Optional[Callable[[Path], bool]]      = Field(default=None, description="Called when a model is found.")          # noqa E221
-    on_search_completed : Optional[Callable[[Set[Path]], None]] = Field(default=None, description="Called when search is complete.")        # noqa E221
-    stats               : SearchStats                           = Field(default_factory=SearchStats, description="Summary statistics after search")  # noqa E221
-    logger              : Logger                                = Field(default=default_logger, description="Logger instance.")     # noqa E221
-    # fmt: on
+    def __init__(
+        self,
+        on_search_started: Optional[Callable[[Path], None]] = None,
+        on_model_found: Optional[Callable[[Path], bool]] = None,
+        on_search_completed: Optional[Callable[[set[Path]], None]] = None,
+    ) -> None:
+        """Create a new ModelSearch object.
 
-    class Config:
-        arbitrary_types_allowed = True
-
-    @abstractmethod
-    def search_started(self) -> None:
+        Args:
+            on_search_started: callback to be invoked when the search starts
+            on_model_found: callback to be invoked when a model is found. The callback should return True if the model
+                should be included in the results.
+            on_search_completed: callback to be invoked when the search is completed
         """
-        Called before the scan starts.
-
-        Passes the root search directory to the Callable `on_search_started`.
-        """
-        pass
-
-    @abstractmethod
-    def model_found(self, model: Path) -> None:
-        """
-        Called when a model is found during search.
-
-        :param model: Model to process - could be a directory or checkpoint.
-
-        Passes the model's Path to the Callable `on_model_found`.
-        This Callable receives the path to the model and returns a boolean
-        to indicate whether the model should be returned in the search
-        results.
-        """
-        pass
-
-    @abstractmethod
-    def search_completed(self) -> None:
-        """
-        Called before the scan starts.
-
-        Passes the Set of found model Paths to the Callable `on_search_completed`.
-        """
-        pass
-
-    @abstractmethod
-    def search(self, directory: Union[Path, str]) -> Set[Path]:
-        """
-        Recursively search for models in `directory` and return a set of model paths.
-
-        If provided, the `on_search_started`, `on_model_found` and `on_search_completed`
-        Callables will be invoked during the search.
-        """
-        pass
-
-
-class ModelSearch(ModelSearchBase):
-    """
-    Implementation of ModelSearch with callbacks.
-    Usage:
-       search = ModelSearch()
-       search.model_found = lambda path : 'anime' in path.as_posix()
-       found = search.list_models(['/tmp/models1','/tmp/models2'])
-       # returns all models that have 'anime' in the path
-    """
-
-    models_found: Set[Path] = Field(default_factory=set)
-    config: InvokeAIAppConfig = InvokeAIAppConfig.get_config()
+        self.stats = SearchStats()
+        self.logger = InvokeAILogger.get_logger()
+        self.on_search_started = on_search_started
+        self.on_model_found = on_model_found
+        self.on_search_completed = on_search_completed
+        self.models_found: set[Path] = set()
 
     def search_started(self) -> None:
         self.models_found = set()
@@ -135,17 +89,17 @@ class ModelSearch(ModelSearchBase):
         if self.on_search_completed is not None:
             self.on_search_completed(self.models_found)
 
-    def search(self, directory: Union[Path, str]) -> Set[Path]:
+    def search(self, directory: Path) -> set[Path]:
         self._directory = Path(directory)
-        if not self._directory.is_absolute():
-            self._directory = self.config.models_path / self._directory
+        self._directory = self._directory.resolve()
         self.stats = SearchStats()  # zero out
         self.search_started()  # This will initialize _models_found to empty
         self._walk_directory(self._directory)
         self.search_completed()
         return self.models_found
 
-    def _walk_directory(self, path: Union[Path, str], max_depth: int = 20) -> None:
+    def _walk_directory(self, path: Path, max_depth: int = 20) -> None:
+        """Recursively walk the directory tree, looking for models."""
         absolute_path = Path(path)
         if (
             len(absolute_path.parts) - len(self._directory.parts) > max_depth

invokeai/backend/model_manager/util/select_hf_files.py

@@ -13,6 +13,7 @@ files_to_download = select_hf_model_files(metadata.files, variant='onnx')
 """
 
 import re
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Dict, List, Optional, Set
 
@@ -34,7 +35,7 @@ def filter_files(
     The file list can be obtained from the `files` field of HuggingFaceMetadata,
     as defined in `invokeai.backend.model_manager.metadata.metadata_base`.
     """
-    variant = variant or ModelRepoVariant.DEFAULT
+    variant = variant or ModelRepoVariant.Default
     paths: List[Path] = []
     root = files[0].parts[0]
 
@@ -73,64 +74,81 @@ def filter_files(
     return sorted(_filter_by_variant(paths, variant))
 
 
+@dataclass
+class SubfolderCandidate:
+    path: Path
+    score: int
+
+
 def _filter_by_variant(files: List[Path], variant: ModelRepoVariant) -> Set[Path]:
     """Select the proper variant files from a list of HuggingFace repo_id paths."""
-    result = set()
-    basenames: Dict[Path, Path] = {}
+    result: set[Path] = set()
+    subfolder_weights: dict[Path, list[SubfolderCandidate]] = {}
     for path in files:
         if path.suffix in [".onnx", ".pb", ".onnx_data"]:
             if variant == ModelRepoVariant.ONNX:
                 result.add(path)
 
         elif "openvino_model" in path.name:
-            if variant == ModelRepoVariant.OPENVINO:
+            if variant == ModelRepoVariant.OpenVINO:
                 result.add(path)
 
         elif "flax_model" in path.name:
-            if variant == ModelRepoVariant.FLAX:
+            if variant == ModelRepoVariant.Flax:
                 result.add(path)
 
         elif path.suffix in [".json", ".txt"]:
             result.add(path)
 
-        elif path.suffix in [".bin", ".safetensors", ".pt", ".ckpt"] and variant in [
+        elif variant in [
             ModelRepoVariant.FP16,
             ModelRepoVariant.FP32,
-            ModelRepoVariant.DEFAULT,
-        ]:
-            parent = path.parent
-            suffixes = path.suffixes
-            if len(suffixes) == 2:
-                variant_label, suffix = suffixes
-                basename = parent / Path(path.stem).stem
-            else:
-                variant_label = ""
-                suffix = suffixes[0]
-                basename = parent / path.stem
+            ModelRepoVariant.Default,
+        ] and path.suffix in [".bin", ".safetensors", ".pt", ".ckpt"]:
+            # For weights files, we want to select the best one for each subfolder. For example, we may have multiple
+            # text encoders:
+            #
+            # - text_encoder/model.fp16.safetensors
+            # - text_encoder/model.safetensors
+            # - text_encoder/pytorch_model.bin
+            # - text_encoder/pytorch_model.fp16.bin
+            #
+            # We prefer safetensors over other file formats and an exact variant match. We'll score each file based on
+            # variant and format and select the best one.
 
-            if previous := basenames.get(basename):
-                if (
-                    previous.suffix != ".safetensors" and suffix == ".safetensors"
-                ):  # replace non-safetensors with safetensors when available
-                    basenames[basename] = path
-                if variant_label == f".{variant}":
-                    basenames[basename] = path
-                elif not variant_label and variant in [ModelRepoVariant.FP32, ModelRepoVariant.DEFAULT]:
-                    basenames[basename] = path
-            else:
-                basenames[basename] = path
+            parent = path.parent
+            score = 0
+
+            if path.suffix == ".safetensors":
+                score += 1
+
+            candidate_variant_label = path.suffixes[0] if len(path.suffixes) == 2 else None
+
+            # Some special handling is needed here if there is not an exact match and if we cannot infer the variant
+            # from the file name. In this case, we only give this file a point if the requested variant is FP32 or DEFAULT.
+            if candidate_variant_label == f".{variant}" or (
+                not candidate_variant_label and variant in [ModelRepoVariant.FP32, ModelRepoVariant.Default]
+            ):
+                score += 1
+
+            if parent not in subfolder_weights:
+                subfolder_weights[parent] = []
+
+            subfolder_weights[parent].append(SubfolderCandidate(path=path, score=score))
 
         else:
             continue
 
-    for v in basenames.values():
-        result.add(v)
+    for candidate_list in subfolder_weights.values():
+        highest_score_candidate = max(candidate_list, key=lambda candidate: candidate.score)
+        if highest_score_candidate:
+            result.add(highest_score_candidate.path)
 
     # If one of the architecture-related variants was specified and no files matched other than
     # config and text files then we return an empty list
     if (
         variant
-        and variant in [ModelRepoVariant.ONNX, ModelRepoVariant.OPENVINO, ModelRepoVariant.FLAX]
+        and variant in [ModelRepoVariant.ONNX, ModelRepoVariant.OpenVINO, ModelRepoVariant.Flax]
         and not any(variant.value in x.name for x in result)
     ):
         return set()

invokeai/backend/stable_diffusion/diffusers_pipeline.py

@@ -23,12 +23,9 @@ from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
 
 from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
-    IPAdapterConditioningInfo,
-    TextConditioningData,
-)
+from invokeai.backend.ip_adapter.unet_patcher import UNetPatcher
+from invokeai.backend.stable_diffusion.diffusion.conditioning_data import ConditioningData
 from invokeai.backend.stable_diffusion.diffusion.shared_invokeai_diffusion import InvokeAIDiffuserComponent
-from invokeai.backend.stable_diffusion.diffusion.unet_attention_patcher import UNetAttentionPatcher
 
 from ..util import auto_detect_slice_size, normalize_device
 
@@ -173,11 +170,10 @@ class ControlNetData:
 
 @dataclass
 class IPAdapterData:
-    ip_adapter_model: IPAdapter
-    ip_adapter_conditioning: IPAdapterConditioningInfo
-
-    # Either a single weight applied to all steps, or a list of weights for each step.
+    ip_adapter_model: IPAdapter = Field(default=None)
+    # TODO: change to polymorphic so can do different weights per step (once implemented...)
     weight: Union[float, List[float]] = Field(default=1.0)
+    # weight: float = Field(default=1.0)
     begin_step_percent: float = Field(default=0.0)
     end_step_percent: float = Field(default=1.0)
 
@@ -318,8 +314,7 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         self,
         latents: torch.Tensor,
         num_inference_steps: int,
-        scheduler_step_kwargs: dict[str, Any],
-        conditioning_data: TextConditioningData,
+        conditioning_data: ConditioningData,
         *,
         noise: Optional[torch.Tensor],
         timesteps: torch.Tensor,
@@ -379,7 +374,6 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
                 latents,
                 timesteps,
                 conditioning_data,
-                scheduler_step_kwargs=scheduler_step_kwargs,
                 additional_guidance=additional_guidance,
                 control_data=control_data,
                 ip_adapter_data=ip_adapter_data,
@@ -399,8 +393,7 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         self,
         latents: torch.Tensor,
         timesteps,
-        conditioning_data: TextConditioningData,
-        scheduler_step_kwargs: dict[str, Any],
+        conditioning_data: ConditioningData,
         *,
         additional_guidance: List[Callable] = None,
         control_data: List[ControlNetData] = None,
@@ -417,35 +410,22 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         if timesteps.shape[0] == 0:
             return latents
 
-        extra_conditioning_info = conditioning_data.cond_text.extra_conditioning
-        use_cross_attention_control = (
-            extra_conditioning_info is not None and extra_conditioning_info.wants_cross_attention_control
-        )
-        use_ip_adapter = ip_adapter_data is not None
-        use_regional_prompting = (
-            conditioning_data.cond_regions is not None or conditioning_data.uncond_regions is not None
-        )
-        if use_cross_attention_control and use_ip_adapter:
-            raise ValueError(
-                "Prompt-to-prompt cross-attention control (`.swap()`) and IP-Adapter cannot be used simultaneously."
-            )
-        if use_cross_attention_control and use_regional_prompting:
-            raise ValueError(
-                "Prompt-to-prompt cross-attention control (`.swap()`) and regional prompting cannot be used simultaneously."
-            )
-
-        unet_attention_patcher = None
-        self.use_ip_adapter = use_ip_adapter
-        attn_ctx = nullcontext()
-        if use_cross_attention_control:
+        ip_adapter_unet_patcher = None
+        extra_conditioning_info = conditioning_data.text_embeddings.extra_conditioning
+        if extra_conditioning_info is not None and extra_conditioning_info.wants_cross_attention_control:
             attn_ctx = self.invokeai_diffuser.custom_attention_context(
                 self.invokeai_diffuser.model,
                 extra_conditioning_info=extra_conditioning_info,
             )
-        if use_ip_adapter or use_regional_prompting:
-            ip_adapters = [ipa.ip_adapter_model for ipa in ip_adapter_data] if use_ip_adapter else None
-            unet_attention_patcher = UNetAttentionPatcher(ip_adapters)
-            attn_ctx = unet_attention_patcher.apply_ip_adapter_attention(self.invokeai_diffuser.model)
+            self.use_ip_adapter = False
+        elif ip_adapter_data is not None:
+            # TODO(ryand): Should we raise an exception if both custom attention and IP-Adapter attention are active?
+            # As it is now, the IP-Adapter will silently be skipped.
+            ip_adapter_unet_patcher = UNetPatcher([ipa.ip_adapter_model for ipa in ip_adapter_data])
+            attn_ctx = ip_adapter_unet_patcher.apply_ip_adapter_attention(self.invokeai_diffuser.model)
+            self.use_ip_adapter = True
+        else:
+            attn_ctx = nullcontext()
 
         with attn_ctx:
             if callback is not None:
@@ -468,12 +448,11 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
                     conditioning_data,
                     step_index=i,
                     total_step_count=len(timesteps),
-                    scheduler_step_kwargs=scheduler_step_kwargs,
                     additional_guidance=additional_guidance,
                     control_data=control_data,
                     ip_adapter_data=ip_adapter_data,
                     t2i_adapter_data=t2i_adapter_data,
-                    unet_attention_patcher=unet_attention_patcher,
+                    ip_adapter_unet_patcher=ip_adapter_unet_patcher,
                 )
                 latents = step_output.prev_sample
                 predicted_original = getattr(step_output, "pred_original_sample", None)
@@ -497,15 +476,14 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         self,
         t: torch.Tensor,
         latents: torch.Tensor,
-        conditioning_data: TextConditioningData,
+        conditioning_data: ConditioningData,
         step_index: int,
         total_step_count: int,
-        scheduler_step_kwargs: dict[str, Any],
         additional_guidance: List[Callable] = None,
         control_data: List[ControlNetData] = None,
         ip_adapter_data: Optional[list[IPAdapterData]] = None,
         t2i_adapter_data: Optional[list[T2IAdapterData]] = None,
-        unet_attention_patcher: Optional[UNetAttentionPatcher] = None,
+        ip_adapter_unet_patcher: Optional[UNetPatcher] = None,
     ):
         # invokeai_diffuser has batched timesteps, but diffusers schedulers expect a single value
         timestep = t[0]
@@ -528,10 +506,10 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
                 )
                 if step_index >= first_adapter_step and step_index <= last_adapter_step:
                     # Only apply this IP-Adapter if the current step is within the IP-Adapter's begin/end step range.
-                    unet_attention_patcher.set_scale(i, weight)
+                    ip_adapter_unet_patcher.set_scale(i, weight)
                 else:
                     # Otherwise, set the IP-Adapter's scale to 0, so it has no effect.
-                    unet_attention_patcher.set_scale(i, 0.0)
+                    ip_adapter_unet_patcher.set_scale(i, 0.0)
 
         # Handle ControlNet(s)
         down_block_additional_residuals = None
@@ -575,17 +553,12 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
 
             down_intrablock_additional_residuals = accum_adapter_state
 
-        ip_adapter_conditioning = None
-        if ip_adapter_data is not None:
-            ip_adapter_conditioning = [ipa.ip_adapter_conditioning for ipa in ip_adapter_data]
-
         uc_noise_pred, c_noise_pred = self.invokeai_diffuser.do_unet_step(
             sample=latent_model_input,
             timestep=t,  # TODO: debug how handled batched and non batched timesteps
             step_index=step_index,
             total_step_count=total_step_count,
             conditioning_data=conditioning_data,
-            ip_adapter_conditioning=ip_adapter_conditioning,
             down_block_additional_residuals=down_block_additional_residuals,  # for ControlNet
             mid_block_additional_residual=mid_block_additional_residual,  # for ControlNet
             down_intrablock_additional_residuals=down_intrablock_additional_residuals,  # for T2I-Adapter
@@ -605,7 +578,7 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
             )
 
         # compute the previous noisy sample x_t -> x_t-1
-        step_output = self.scheduler.step(noise_pred, timestep, latents, **scheduler_step_kwargs)
+        step_output = self.scheduler.step(noise_pred, timestep, latents, **conditioning_data.scheduler_args)
 
         # TODO: issue to diffusers?
         # undo internal counter increment done by scheduler.step, so timestep can be resolved as before call

invokeai/backend/stable_diffusion/diffusion/conditioning_data.py

@@ -1,5 +1,7 @@
-from dataclasses import dataclass
-from typing import List, Optional, Union
+import dataclasses
+import inspect
+from dataclasses import dataclass, field
+from typing import Any, List, Optional, Union
 
 import torch
 
@@ -8,11 +10,6 @@ from .cross_attention_control import Arguments
 
 @dataclass
 class ExtraConditioningInfo:
-    """Extra conditioning information produced by Compel.
-
-    This is used for prompt-to-prompt cross-attention control (a.k.a. `.swap()` in Compel).
-    """
-
     tokens_count_including_eos_bos: int
     cross_attention_control_args: Optional[Arguments] = None
 
@@ -23,8 +20,6 @@ class ExtraConditioningInfo:
 
 @dataclass
 class BasicConditioningInfo:
-    """SD 1/2 text conditioning information produced by Compel."""
-
     embeds: torch.Tensor
     extra_conditioning: Optional[ExtraConditioningInfo]
 
@@ -40,8 +35,6 @@ class ConditioningFieldData:
 
 @dataclass
 class SDXLConditioningInfo(BasicConditioningInfo):
-    """SDXL text conditioning information produced by Compel."""
-
     pooled_embeds: torch.Tensor
     add_time_ids: torch.Tensor
 
@@ -64,55 +57,37 @@ class IPAdapterConditioningInfo:
 
 
 @dataclass
-class Range:
-    start: int
-    end: int
+class ConditioningData:
+    unconditioned_embeddings: BasicConditioningInfo
+    text_embeddings: BasicConditioningInfo
+    """
+    Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
+    `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://arxiv.org/pdf/2205.11487.pdf).
+    Guidance scale is enabled by setting `guidance_scale > 1`. Higher guidance scale encourages to generate
+    images that are closely linked to the text `prompt`, usually at the expense of lower image quality.
+    """
+    guidance_scale: Union[float, List[float]]
+    """ for models trained using zero-terminal SNR ("ztsnr"), it's suggested to use guidance_rescale_multiplier of 0.7 .
+     ref [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf)
+    """
+    guidance_rescale_multiplier: float = 0
+    scheduler_args: dict[str, Any] = field(default_factory=dict)
 
+    ip_adapter_conditioning: Optional[list[IPAdapterConditioningInfo]] = None
 
-class TextConditioningRegions:
-    def __init__(
-        self,
-        masks: torch.Tensor,
-        ranges: list[Range],
-        mask_weights: list[float],
-    ):
-        # A binary mask indicating the regions of the image that the prompt should be applied to.
-        # Shape: (1, num_prompts, height, width)
-        # Dtype: torch.bool
-        self.masks = masks
+    @property
+    def dtype(self):
+        return self.text_embeddings.dtype
 
-        # A list of ranges indicating the start and end indices of the embeddings that corresponding mask applies to.
-        # ranges[i] contains the embedding range for the i'th prompt / mask.
-        self.ranges = ranges
-
-        self.mask_weights = mask_weights
-
-        assert self.masks.shape[1] == len(self.ranges) == len(self.mask_weights)
-
-
-class TextConditioningData:
-    def __init__(
-        self,
-        uncond_text: Union[BasicConditioningInfo, SDXLConditioningInfo],
-        cond_text: Union[BasicConditioningInfo, SDXLConditioningInfo],
-        uncond_regions: Optional[TextConditioningRegions],
-        cond_regions: Optional[TextConditioningRegions],
-        guidance_scale: Union[float, List[float]],
-        guidance_rescale_multiplier: float = 0,
-    ):
-        self.uncond_text = uncond_text
-        self.cond_text = cond_text
-        self.uncond_regions = uncond_regions
-        self.cond_regions = cond_regions
-        # Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-        # `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://arxiv.org/pdf/2205.11487.pdf).
-        # Guidance scale is enabled by setting `guidance_scale > 1`. Higher guidance scale encourages to generate
-        # images that are closely linked to the text `prompt`, usually at the expense of lower image quality.
-        self.guidance_scale = guidance_scale
-        # For models trained using zero-terminal SNR ("ztsnr"), it's suggested to use guidance_rescale_multiplier of 0.7.
-        # See [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf).
-        self.guidance_rescale_multiplier = guidance_rescale_multiplier
-
-    def is_sdxl(self):
-        assert isinstance(self.uncond_text, SDXLConditioningInfo) == isinstance(self.cond_text, SDXLConditioningInfo)
-        return isinstance(self.cond_text, SDXLConditioningInfo)
+    def add_scheduler_args_if_applicable(self, scheduler, **kwargs):
+        scheduler_args = dict(self.scheduler_args)
+        step_method = inspect.signature(scheduler.step)
+        for name, value in kwargs.items():
+            try:
+                step_method.bind_partial(**{name: value})
+            except TypeError:
+                # FIXME: don't silently discard arguments
+                pass  # debug("%s does not accept argument named %r", scheduler, name)
+            else:
+                scheduler_args[name] = value
+        return dataclasses.replace(self, scheduler_args=scheduler_args)

invokeai/backend/stable_diffusion/diffusion/custom_attention.py

@@ -1,242 +0,0 @@
-import math
-from typing import Optional
-
-import torch
-import torch.nn.functional as F
-from diffusers.models.attention_processor import Attention, AttnProcessor2_0
-from diffusers.utils import USE_PEFT_BACKEND
-
-from invokeai.backend.ip_adapter.ip_attention_weights import IPAttentionProcessorWeights
-from invokeai.backend.stable_diffusion.diffusion.regional_prompt_data import RegionalPromptData
-
-
-class CustomAttnProcessor2_0(AttnProcessor2_0):
-    """A custom implementation of AttnProcessor2_0 that supports additional Invoke features.
-
-    This implementation is based on
-    https://github.com/huggingface/diffusers/blame/fcfa270fbd1dc294e2f3a505bae6bcb791d721c3/src/diffusers/models/attention_processor.py#L1204
-
-    Supported custom features:
-    - IP-Adapter
-    - Regional prompt attention
-    """
-
-    def __init__(
-        self,
-        ip_adapter_weights: Optional[list[IPAttentionProcessorWeights]] = None,
-        ip_adapter_scales: Optional[list[float]] = None,
-    ):
-        """Initialize a CustomAttnProcessor2_0.
-
-        Note: Arguments that are the same for all attention layers are passed to __call__(). Arguments that are
-        layer-specific are passed to __init__().
-
-        Args:
-            ip_adapter_weights: The IP-Adapter attention weights. ip_adapter_weights[i] contains the attention weights
-                for the i'th IP-Adapter.
-            ip_adapter_scales: The IP-Adapter attention scales. ip_adapter_scales[i] contains the attention scale for
-                the i'th IP-Adapter.
-        """
-        super().__init__()
-
-        self._ip_adapter_weights = ip_adapter_weights
-        self._ip_adapter_scales = ip_adapter_scales
-
-        assert (self._ip_adapter_weights is None) == (self._ip_adapter_scales is None)
-        if self._ip_adapter_weights is not None:
-            assert len(ip_adapter_weights) == len(ip_adapter_scales)
-
-    def _is_ip_adapter_enabled(self) -> bool:
-        return self._ip_adapter_weights is not None
-
-    def __call__(
-        self,
-        attn: Attention,
-        hidden_states: torch.FloatTensor,
-        encoder_hidden_states: Optional[torch.FloatTensor] = None,
-        attention_mask: Optional[torch.FloatTensor] = None,
-        temb: Optional[torch.FloatTensor] = None,
-        scale: float = 1.0,
-        # For regional prompting:
-        regional_prompt_data: Optional[RegionalPromptData] = None,
-        percent_through: Optional[float] = None,
-        # For IP-Adapter:
-        ip_adapter_image_prompt_embeds: Optional[list[torch.Tensor]] = None,
-    ) -> torch.FloatTensor:
-        """Apply attention.
-
-        Args:
-            regional_prompt_data: The regional prompt data for the current batch. If not None, this will be used to
-                apply regional prompt masking.
-            ip_adapter_image_prompt_embeds: The IP-Adapter image prompt embeddings for the current batch.
-                ip_adapter_image_prompt_embeds[i] contains the image prompt embeddings for the i'th IP-Adapter. Each
-                tensor has shape (batch_size, num_ip_images, seq_len, ip_embedding_len).
-        """
-        # If true, we are doing cross-attention, if false we are doing self-attention.
-        is_cross_attention = encoder_hidden_states is not None
-
-        # Start unmodified block from AttnProcessor2_0.
-        # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
-        residual = hidden_states
-        if attn.spatial_norm is not None:
-            hidden_states = attn.spatial_norm(hidden_states, temb)
-
-        input_ndim = hidden_states.ndim
-
-        if input_ndim == 4:
-            batch_size, channel, height, width = hidden_states.shape
-            hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)
-
-        batch_size, sequence_length, _ = (
-            hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape
-        )
-        # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-        # End unmodified block from AttnProcessor2_0.
-
-        # Handle regional prompt attention masks.
-        if regional_prompt_data is not None:
-            assert percent_through is not None
-            _, query_seq_len, _ = hidden_states.shape
-            if is_cross_attention:
-                prompt_region_attention_mask = regional_prompt_data.get_cross_attn_mask(
-                    query_seq_len=query_seq_len, key_seq_len=sequence_length
-                )
-                # TODO(ryand): Avoid redundant type/device conversion here.
-                prompt_region_attention_mask = prompt_region_attention_mask.to(
-                    dtype=hidden_states.dtype, device=hidden_states.device
-                )
-
-                attn_mask_weight = 1.0 * ((1 - percent_through) ** 5)
-            else:  # self-attention
-                prompt_region_attention_mask = regional_prompt_data.get_self_attn_mask(
-                    query_seq_len=query_seq_len,
-                    percent_through=percent_through,
-                )
-                attn_mask_weight = 0.3 * ((1 - percent_through) ** 5)
-
-        if attn.group_norm is not None:
-            hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2)
-
-        args = () if USE_PEFT_BACKEND else (scale,)
-        query = attn.to_q(hidden_states, *args)
-
-        if encoder_hidden_states is None:
-            encoder_hidden_states = hidden_states
-        elif attn.norm_cross:
-            encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states)
-
-        key = attn.to_k(encoder_hidden_states, *args)
-        value = attn.to_v(encoder_hidden_states, *args)
-
-        inner_dim = key.shape[-1]
-        head_dim = inner_dim // attn.heads
-
-        query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
-
-        key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
-        value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
-
-        if attention_mask is not None:
-            attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
-            # scaled_dot_product_attention expects attention_mask shape to be
-            # (batch, heads, source_length, target_length)
-            attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])
-
-        if regional_prompt_data is not None and percent_through < 0.3:
-            # Don't apply to uncond????
-
-            prompt_region_attention_mask = attn.prepare_attention_mask(
-                prompt_region_attention_mask, sequence_length, batch_size
-            )
-            # scaled_dot_product_attention expects attention_mask shape to be
-            # (batch, heads, source_length, target_length)
-            prompt_region_attention_mask = prompt_region_attention_mask.view(
-                batch_size, attn.heads, -1, prompt_region_attention_mask.shape[-1]
-            )
-
-            scale_factor = 1 / math.sqrt(query.size(-1))
-            attn_weight = query @ key.transpose(-2, -1) * scale_factor
-            m_pos = attn_weight.max(dim=-1, keepdim=True)[0] - attn_weight
-            m_neg = attn_weight - attn_weight.min(dim=-1, keepdim=True)[0]
-
-            prompt_region_attention_mask = attn_mask_weight * (
-                m_pos * prompt_region_attention_mask - m_neg * (1.0 - prompt_region_attention_mask)
-            )
-
-            if attention_mask is None:
-                attention_mask = prompt_region_attention_mask
-            else:
-                attention_mask = prompt_region_attention_mask + attention_mask
-        else:
-            pass
-
-        # the output of sdp = (batch, num_heads, seq_len, head_dim)
-        # TODO: add support for attn.scale when we move to Torch 2.1
-        hidden_states = F.scaled_dot_product_attention(
-            query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False
-        )
-
-        hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
-        hidden_states = hidden_states.to(query.dtype)
-        # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-        # End unmodified block from AttnProcessor2_0.
-
-        # Apply IP-Adapter conditioning.
-        if is_cross_attention and self._is_ip_adapter_enabled():
-            if self._is_ip_adapter_enabled():
-                assert ip_adapter_image_prompt_embeds is not None
-                for ipa_embed, ipa_weights, scale in zip(
-                    ip_adapter_image_prompt_embeds, self._ip_adapter_weights, self._ip_adapter_scales, strict=True
-                ):
-                    # The batch dimensions should match.
-                    assert ipa_embed.shape[0] == encoder_hidden_states.shape[0]
-                    # The token_len dimensions should match.
-                    assert ipa_embed.shape[-1] == encoder_hidden_states.shape[-1]
-
-                    ip_hidden_states = ipa_embed
-
-                    # Expected ip_hidden_state shape: (batch_size, num_ip_images, ip_seq_len, ip_image_embedding)
-
-                    ip_key = ipa_weights.to_k_ip(ip_hidden_states)
-                    ip_value = ipa_weights.to_v_ip(ip_hidden_states)
-
-                    # Expected ip_key and ip_value shape: (batch_size, num_ip_images, ip_seq_len, head_dim * num_heads)
-
-                    ip_key = ip_key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
-                    ip_value = ip_value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
-
-                    # Expected ip_key and ip_value shape: (batch_size, num_heads, num_ip_images * ip_seq_len, head_dim)
-
-                    # TODO: add support for attn.scale when we move to Torch 2.1
-                    ip_hidden_states = F.scaled_dot_product_attention(
-                        query, ip_key, ip_value, attn_mask=None, dropout_p=0.0, is_causal=False
-                    )
-
-                    # Expected ip_hidden_states shape: (batch_size, num_heads, query_seq_len, head_dim)
-
-                    ip_hidden_states = ip_hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
-                    ip_hidden_states = ip_hidden_states.to(query.dtype)
-
-                    # Expected ip_hidden_states shape: (batch_size, query_seq_len, num_heads * head_dim)
-
-                    hidden_states = hidden_states + scale * ip_hidden_states
-            else:
-                # If IP-Adapter is not enabled, then ip_adapter_image_prompt_embeds should not be passed in.
-                assert ip_adapter_image_prompt_embeds is None
-
-        # Start unmodified block from AttnProcessor2_0.
-        # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
-        # linear proj
-        hidden_states = attn.to_out[0](hidden_states, *args)
-        # dropout
-        hidden_states = attn.to_out[1](hidden_states)
-
-        if input_ndim == 4:
-            hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
-
-        if attn.residual_connection:
-            hidden_states = hidden_states + residual
-
-        hidden_states = hidden_states / attn.rescale_output_factor
-
-        return hidden_states

invokeai/backend/stable_diffusion/diffusion/regional_prompt_data.py

@@ -1,164 +0,0 @@
-import torch
-import torch.nn.functional as F
-
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
-    TextConditioningRegions,
-)
-
-
-class RegionalPromptData:
-    def __init__(
-        self,
-        regions: list[TextConditioningRegions],
-        device: torch.device,
-        dtype: torch.dtype,
-        max_downscale_factor: int = 8,
-    ):
-        """Initialize a `RegionalPromptData` object.
-
-        Args:
-            regions (list[TextConditioningRegions]): regions[i] contains the prompt regions for the i'th sample in the
-                batch.
-            device (torch.device): The device to use for the attention masks.
-            dtype (torch.dtype): The data type to use for the attention masks.
-            max_downscale_factor: Spatial masks will be prepared for downscale factors from 1 to max_downscale_factor
-                in steps of 2x.
-        """
-        self._regions = regions
-        self._device = device
-        self._dtype = dtype
-        # self._spatial_masks_by_seq_len[b][s] contains the spatial masks for the b'th batch sample with a query
-        # sequence length of s.
-        self._spatial_masks_by_seq_len: list[dict[int, torch.Tensor]] = self._prepare_spatial_masks(
-            regions, max_downscale_factor
-        )
-        self._negative_cross_attn_mask_score = 0.0
-        self._size_weight = 1.0
-
-    def _prepare_spatial_masks(
-        self, regions: list[TextConditioningRegions], max_downscale_factor: int = 8
-    ) -> list[dict[int, torch.Tensor]]:
-        """Prepare the spatial masks for all downscaling factors."""
-        # batch_masks_by_seq_len[b][s] contains the spatial masks for the b'th batch sample with a query sequence length
-        # of s.
-        batch_sample_masks_by_seq_len: list[dict[int, torch.Tensor]] = []
-
-        for batch_sample_regions in regions:
-            batch_sample_masks_by_seq_len.append({})
-
-            # Convert the bool masks to float masks so that max pooling can be applied.
-            batch_sample_masks = batch_sample_regions.masks.to(device=self._device, dtype=self._dtype)
-
-            # Downsample the spatial dimensions by factors of 2 until max_downscale_factor is reached.
-            downscale_factor = 1
-            while downscale_factor <= max_downscale_factor:
-                b, _num_prompts, h, w = batch_sample_masks.shape
-                assert b == 1
-                query_seq_len = h * w
-
-                batch_sample_masks_by_seq_len[-1][query_seq_len] = batch_sample_masks
-
-                downscale_factor *= 2
-                if downscale_factor <= max_downscale_factor:
-                    # We use max pooling because we downscale to a pretty low resolution, so we don't want small prompt
-                    # regions to be lost entirely.
-                    # TODO(ryand): In the future, we may want to experiment with other downsampling methods, and could
-                    # potentially use a weighted mask rather than a binary mask.
-                    batch_sample_masks = F.max_pool2d(batch_sample_masks, kernel_size=2, stride=2)
-
-        return batch_sample_masks_by_seq_len
-
-    def get_cross_attn_mask(self, query_seq_len: int, key_seq_len: int) -> torch.Tensor:
-        """Get the cross-attention mask for the given query sequence length.
-
-        Args:
-            query_seq_len: The length of the flattened spatial features at the current downscaling level.
-            key_seq_len (int): The sequence length of the prompt embeddings (which act as the key in the cross-attention
-                layers). This is most likely equal to the max embedding range end, but we pass it explicitly to be sure.
-
-        Returns:
-            torch.Tensor: The masks.
-                shape: (batch_size, query_seq_len, key_seq_len).
-                dtype: float
-                The mask is a binary mask with values of 0.0 and 1.0.
-        """
-        batch_size = len(self._spatial_masks_by_seq_len)
-        batch_spatial_masks = [self._spatial_masks_by_seq_len[b][query_seq_len] for b in range(batch_size)]
-
-        # Create an empty attention mask with the correct shape.
-        attn_mask = torch.zeros((batch_size, query_seq_len, key_seq_len), dtype=self._dtype, device=self._device)
-
-        for batch_idx in range(batch_size):
-            batch_sample_spatial_masks = batch_spatial_masks[batch_idx]
-            batch_sample_regions = self._regions[batch_idx]
-
-            # Flatten the spatial dimensions of the mask by reshaping to (1, num_prompts, query_seq_len, 1).
-            _, num_prompts, _, _ = batch_sample_spatial_masks.shape
-            batch_sample_query_masks = batch_sample_spatial_masks.view((1, num_prompts, query_seq_len, 1))
-
-            for prompt_idx, embedding_range in enumerate(batch_sample_regions.ranges):
-                batch_sample_query_scores = batch_sample_query_masks[0, prompt_idx, :, :]
-                size = batch_sample_query_scores.sum() / batch_sample_query_scores.numel()
-                mask_weight = batch_sample_regions.mask_weights[prompt_idx]
-                # size = size.to(dtype=batch_sample_query_scores.dtype)
-                # batch_sample_query_mask = batch_sample_query_scores > 0.5
-                # batch_sample_query_scores[batch_sample_query_mask] = 1.0 * (1.0 - size)
-                # batch_sample_query_scores[~batch_sample_query_mask] = 0.0
-                attn_mask[batch_idx, :, embedding_range.start : embedding_range.end] = batch_sample_query_scores * (
-                    mask_weight + self._size_weight * (1 - size)
-                )
-
-        return attn_mask
-
-    def get_self_attn_mask(self, query_seq_len: int, percent_through: float) -> torch.Tensor:
-        """Get the self-attention mask for the given query sequence length.
-
-        Args:
-            query_seq_len: The length of the flattened spatial features at the current downscaling level.
-
-        Returns:
-            torch.Tensor: The masks.
-                shape: (batch_size, query_seq_len, query_seq_len).
-                dtype: float
-                The mask is a binary mask with values of 0.0 and 1.0.
-        """
-        batch_size = len(self._spatial_masks_by_seq_len)
-        batch_spatial_masks = [self._spatial_masks_by_seq_len[b][query_seq_len] for b in range(batch_size)]
-
-        # Create an empty attention mask with the correct shape.
-        attn_mask = torch.zeros((batch_size, query_seq_len, query_seq_len), dtype=self._dtype, device=self._device)
-
-        for batch_idx in range(batch_size):
-            batch_sample_spatial_masks = batch_spatial_masks[batch_idx]
-            batch_sample_regions = self._regions[batch_idx]
-
-            # Flatten the spatial dimensions of the mask by reshaping to (1, num_prompts, query_seq_len, 1).
-            _, num_prompts, _, _ = batch_sample_spatial_masks.shape
-            batch_sample_query_masks = batch_sample_spatial_masks.view((1, num_prompts, query_seq_len, 1))
-
-            for prompt_idx in range(num_prompts):
-                prompt_query_mask = batch_sample_query_masks[0, prompt_idx, :, 0]  # Shape: (query_seq_len,)
-                size = prompt_query_mask.sum() / prompt_query_mask.numel()
-                size = size.to(dtype=prompt_query_mask.dtype)
-                mask_weight = batch_sample_regions.mask_weights[prompt_idx]
-                # Multiply a (1, query_seq_len) mask by a (query_seq_len, 1) mask to get a (query_seq_len,
-                # query_seq_len) mask.
-                # TODO(ryand): Is += really the best option here? Maybe elementwise max is better?
-                attn_mask[batch_idx, :, :] = torch.maximum(
-                    attn_mask[batch_idx, :, :],
-                    prompt_query_mask.unsqueeze(0)
-                    * prompt_query_mask.unsqueeze(1)
-                    * (mask_weight + self._size_weight * (1 - size)),
-                )
-
-            # if attn_mask[batch_idx].max() < 0.01:
-            #     attn_mask[batch_idx, ...] = 1.0
-
-        # attn_mask[attn_mask > 0.5] = 1.0
-        # attn_mask[attn_mask <= 0.5] = 0.0
-        # attn_mask_min = attn_mask[batch_idx].min()
-
-        # # Adjust so that the minimum value is 0.0 regardless of whether all pixels are covered or not.
-        # if abs(attn_mask_min) > 0.0001:
-        #     attn_mask[batch_idx] = attn_mask[batch_idx] - attn_mask_min
-        return attn_mask

invokeai/backend/stable_diffusion/diffusion/shared_invokeai_diffusion.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import math
-import time
 from contextlib import contextmanager
 from typing import Any, Callable, Optional, Union
 
@@ -11,13 +10,10 @@ from typing_extensions import TypeAlias
 
 from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
+    ConditioningData,
     ExtraConditioningInfo,
-    IPAdapterConditioningInfo,
-    Range,
-    TextConditioningData,
-    TextConditioningRegions,
+    SDXLConditioningInfo,
 )
-from invokeai.backend.stable_diffusion.diffusion.regional_prompt_data import RegionalPromptData
 
 from .cross_attention_control import (
     CrossAttentionType,
@@ -59,6 +55,7 @@ class InvokeAIDiffuserComponent:
         :param model_forward_callback: a lambda with arguments (x, sigma, conditioning_to_apply). will be called repeatedly. most likely, this should simply call model.forward(x, sigma, conditioning)
         """
         config = InvokeAIAppConfig.get_config()
+        self.conditioning = None
         self.model = model
         self.model_forward_callback = model_forward_callback
         self.cross_attention_control_context = None
@@ -93,7 +90,7 @@ class InvokeAIDiffuserComponent:
         timestep: torch.Tensor,
         step_index: int,
         total_step_count: int,
-        conditioning_data: TextConditioningData,
+        conditioning_data,
     ):
         down_block_res_samples, mid_block_res_sample = None, None
 
@@ -126,30 +123,38 @@ class InvokeAIDiffuserComponent:
                 added_cond_kwargs = None
 
                 if cfg_injection:  # only applying ControlNet to conditional instead of in unconditioned
-                    if conditioning_data.is_sdxl():
+                    if type(conditioning_data.text_embeddings) is SDXLConditioningInfo:
                         added_cond_kwargs = {
-                            "text_embeds": conditioning_data.cond_text.pooled_embeds,
-                            "time_ids": conditioning_data.cond_text.add_time_ids,
+                            "text_embeds": conditioning_data.text_embeddings.pooled_embeds,
+                            "time_ids": conditioning_data.text_embeddings.add_time_ids,
                         }
-                    encoder_hidden_states = conditioning_data.cond_text.embeds
+                    encoder_hidden_states = conditioning_data.text_embeddings.embeds
                     encoder_attention_mask = None
                 else:
-                    if conditioning_data.is_sdxl():
+                    if type(conditioning_data.text_embeddings) is SDXLConditioningInfo:
                         added_cond_kwargs = {
                             "text_embeds": torch.cat(
                                 [
-                                    conditioning_data.uncond_text.pooled_embeds,
-                                    conditioning_data.cond_text.pooled_embeds,
+                                    # TODO: how to pad? just by zeros? or even truncate?
+                                    conditioning_data.unconditioned_embeddings.pooled_embeds,
+                                    conditioning_data.text_embeddings.pooled_embeds,
                                 ],
                                 dim=0,
                             ),
                             "time_ids": torch.cat(
-                                [conditioning_data.uncond_text.add_time_ids, conditioning_data.cond_text.add_time_ids],
+                                [
+                                    conditioning_data.unconditioned_embeddings.add_time_ids,
+                                    conditioning_data.text_embeddings.add_time_ids,
+                                ],
                                 dim=0,
                             ),
                         }
-                    (encoder_hidden_states, encoder_attention_mask) = self._concat_conditionings_for_batch(
-                        conditioning_data.uncond_text.embeds, conditioning_data.cond_text.embeds
+                    (
+                        encoder_hidden_states,
+                        encoder_attention_mask,
+                    ) = self._concat_conditionings_for_batch(
+                        conditioning_data.unconditioned_embeddings.embeds,
+                        conditioning_data.text_embeddings.embeds,
                     )
                 if isinstance(control_datum.weight, list):
                     # if controlnet has multiple weights, use the weight for the current step
@@ -193,17 +198,16 @@ class InvokeAIDiffuserComponent:
         self,
         sample: torch.Tensor,
         timestep: torch.Tensor,
-        conditioning_data: TextConditioningData,
-        ip_adapter_conditioning: Optional[list[IPAdapterConditioningInfo]],
+        conditioning_data: ConditioningData,
         step_index: int,
         total_step_count: int,
         down_block_additional_residuals: Optional[torch.Tensor] = None,  # for ControlNet
         mid_block_additional_residual: Optional[torch.Tensor] = None,  # for ControlNet
         down_intrablock_additional_residuals: Optional[torch.Tensor] = None,  # for T2I-Adapter
     ):
-        percent_through = step_index / total_step_count
         cross_attention_control_types_to_do = []
         if self.cross_attention_control_context is not None:
+            percent_through = step_index / total_step_count
             cross_attention_control_types_to_do = (
                 self.cross_attention_control_context.get_active_cross_attention_control_types_for_step(percent_through)
             )
@@ -219,8 +223,6 @@ class InvokeAIDiffuserComponent:
                 x=sample,
                 sigma=timestep,
                 conditioning_data=conditioning_data,
-                ip_adapter_conditioning=ip_adapter_conditioning,
-                percent_through=percent_through,
                 cross_attention_control_types_to_do=cross_attention_control_types_to_do,
                 down_block_additional_residuals=down_block_additional_residuals,
                 mid_block_additional_residual=mid_block_additional_residual,
@@ -234,8 +236,6 @@ class InvokeAIDiffuserComponent:
                 x=sample,
                 sigma=timestep,
                 conditioning_data=conditioning_data,
-                percent_through=percent_through,
-                ip_adapter_conditioning=ip_adapter_conditioning,
                 down_block_additional_residuals=down_block_additional_residuals,
                 mid_block_additional_residual=mid_block_additional_residual,
                 down_intrablock_additional_residuals=down_intrablock_additional_residuals,
@@ -290,13 +290,13 @@ class InvokeAIDiffuserComponent:
 
         return torch.cat([unconditioning, conditioning]), encoder_attention_mask
 
+    # methods below are called from do_diffusion_step and should be considered private to this class.
+
     def _apply_standard_conditioning(
         self,
         x,
         sigma,
-        conditioning_data: TextConditioningData,
-        ip_adapter_conditioning: Optional[list[IPAdapterConditioningInfo]],
-        percent_through: float,
+        conditioning_data: ConditioningData,
         down_block_additional_residuals: Optional[torch.Tensor] = None,  # for ControlNet
         mid_block_additional_residual: Optional[torch.Tensor] = None,  # for ControlNet
         down_intrablock_additional_residuals: Optional[torch.Tensor] = None,  # for T2I-Adapter
@@ -307,55 +307,41 @@ class InvokeAIDiffuserComponent:
         x_twice = torch.cat([x] * 2)
         sigma_twice = torch.cat([sigma] * 2)
 
-        cross_attention_kwargs = {}
-        if ip_adapter_conditioning is not None:
+        cross_attention_kwargs = None
+        if conditioning_data.ip_adapter_conditioning is not None:
             # Note that we 'stack' to produce tensors of shape (batch_size, num_ip_images, seq_len, token_len).
-            cross_attention_kwargs["ip_adapter_image_prompt_embeds"] = [
-                torch.stack([ipa_conditioning.uncond_image_prompt_embeds, ipa_conditioning.cond_image_prompt_embeds])
-                for ipa_conditioning in ip_adapter_conditioning
-            ]
-
-        uncond_text = conditioning_data.uncond_text
-        cond_text = conditioning_data.cond_text
+            cross_attention_kwargs = {
+                "ip_adapter_image_prompt_embeds": [
+                    torch.stack(
+                        [ipa_conditioning.uncond_image_prompt_embeds, ipa_conditioning.cond_image_prompt_embeds]
+                    )
+                    for ipa_conditioning in conditioning_data.ip_adapter_conditioning
+                ]
+            }
 
         added_cond_kwargs = None
-        if conditioning_data.is_sdxl():
+        if type(conditioning_data.text_embeddings) is SDXLConditioningInfo:
             added_cond_kwargs = {
-                "text_embeds": torch.cat([uncond_text.pooled_embeds, cond_text.pooled_embeds], dim=0),
-                "time_ids": torch.cat([uncond_text.add_time_ids, cond_text.add_time_ids], dim=0),
+                "text_embeds": torch.cat(
+                    [
+                        # TODO: how to pad? just by zeros? or even truncate?
+                        conditioning_data.unconditioned_embeddings.pooled_embeds,
+                        conditioning_data.text_embeddings.pooled_embeds,
+                    ],
+                    dim=0,
+                ),
+                "time_ids": torch.cat(
+                    [
+                        conditioning_data.unconditioned_embeddings.add_time_ids,
+                        conditioning_data.text_embeddings.add_time_ids,
+                    ],
+                    dim=0,
+                ),
             }
 
         both_conditionings, encoder_attention_mask = self._concat_conditionings_for_batch(
-            uncond_text.embeds, cond_text.embeds
+            conditioning_data.unconditioned_embeddings.embeds, conditioning_data.text_embeddings.embeds
         )
-
-        if conditioning_data.cond_regions is not None or conditioning_data.uncond_regions is not None:
-            # TODO(ryand): We currently initialize RegionalPromptData for every denoising step. The text conditionings
-            # and masks are not changing from step-to-step, so this really only needs to be done once. While this seems
-            # painfully inefficient, the time spent is typically negligible compared to the forward inference pass of
-            # the UNet. The main reason that this hasn't been moved up to eliminate redundancy is that it is slightly
-            # awkward to handle both standard conditioning and sequential conditioning further up the stack.
-            regions = []
-            for c, r in [
-                (conditioning_data.uncond_text, conditioning_data.uncond_regions),
-                (conditioning_data.cond_text, conditioning_data.cond_regions),
-            ]:
-                if r is None:
-                    # Create a dummy mask and range for text conditioning that doesn't have region masks.
-                    _, _, h, w = x.shape
-                    r = TextConditioningRegions(
-                        masks=torch.ones((1, 1, h, w), dtype=torch.bool),
-                        ranges=[Range(start=0, end=c.embeds.shape[1])],
-                        mask_weights=[0.0],
-                    )
-                regions.append(r)
-
-            cross_attention_kwargs["regional_prompt_data"] = RegionalPromptData(
-                regions=regions, device=x.device, dtype=x.dtype
-            )
-            cross_attention_kwargs["percent_through"] = percent_through
-            time.sleep(1.0)
-
         both_results = self.model_forward_callback(
             x_twice,
             sigma_twice,
@@ -374,10 +360,8 @@ class InvokeAIDiffuserComponent:
         self,
         x: torch.Tensor,
         sigma,
-        conditioning_data: TextConditioningData,
-        ip_adapter_conditioning: Optional[list[IPAdapterConditioningInfo]],
+        conditioning_data: ConditioningData,
         cross_attention_control_types_to_do: list[CrossAttentionType],
-        percent_through: float,
         down_block_additional_residuals: Optional[torch.Tensor] = None,  # for ControlNet
         mid_block_additional_residual: Optional[torch.Tensor] = None,  # for ControlNet
         down_intrablock_additional_residuals: Optional[torch.Tensor] = None,  # for T2I-Adapter
@@ -424,40 +408,36 @@ class InvokeAIDiffuserComponent:
         # Unconditioned pass
         #####################
 
-        cross_attention_kwargs = {}
+        cross_attention_kwargs = None
 
         # Prepare IP-Adapter cross-attention kwargs for the unconditioned pass.
-        if ip_adapter_conditioning is not None:
+        if conditioning_data.ip_adapter_conditioning is not None:
             # Note that we 'unsqueeze' to produce tensors of shape (batch_size=1, num_ip_images, seq_len, token_len).
-            cross_attention_kwargs["ip_adapter_image_prompt_embeds"] = [
-                torch.unsqueeze(ipa_conditioning.uncond_image_prompt_embeds, dim=0)
-                for ipa_conditioning in ip_adapter_conditioning
-            ]
+            cross_attention_kwargs = {
+                "ip_adapter_image_prompt_embeds": [
+                    torch.unsqueeze(ipa_conditioning.uncond_image_prompt_embeds, dim=0)
+                    for ipa_conditioning in conditioning_data.ip_adapter_conditioning
+                ]
+            }
 
         # Prepare cross-attention control kwargs for the unconditioned pass.
         if cross_attn_processor_context is not None:
-            cross_attention_kwargs["swap_cross_attn_context"] = cross_attn_processor_context
+            cross_attention_kwargs = {"swap_cross_attn_context": cross_attn_processor_context}
 
         # Prepare SDXL conditioning kwargs for the unconditioned pass.
         added_cond_kwargs = None
-        if conditioning_data.is_sdxl():
+        is_sdxl = type(conditioning_data.text_embeddings) is SDXLConditioningInfo
+        if is_sdxl:
             added_cond_kwargs = {
-                "text_embeds": conditioning_data.uncond_text.pooled_embeds,
-                "time_ids": conditioning_data.uncond_text.add_time_ids,
+                "text_embeds": conditioning_data.unconditioned_embeddings.pooled_embeds,
+                "time_ids": conditioning_data.unconditioned_embeddings.add_time_ids,
             }
 
-        # Prepare prompt regions for the unconditioned pass.
-        if conditioning_data.uncond_regions is not None:
-            cross_attention_kwargs["regional_prompt_data"] = RegionalPromptData(
-                regions=[conditioning_data.uncond_regions], device=x.device, dtype=x.dtype
-            )
-            cross_attention_kwargs["percent_through"] = percent_through
-
         # Run unconditioned UNet denoising (i.e. negative prompt).
         unconditioned_next_x = self.model_forward_callback(
             x,
             sigma,
-            conditioning_data.uncond_text.embeds,
+            conditioning_data.unconditioned_embeddings.embeds,
             cross_attention_kwargs=cross_attention_kwargs,
             down_block_additional_residuals=uncond_down_block,
             mid_block_additional_residual=uncond_mid_block,
@@ -469,41 +449,36 @@ class InvokeAIDiffuserComponent:
         # Conditioned pass
         ###################
 
-        cross_attention_kwargs = {}
+        cross_attention_kwargs = None
 
         # Prepare IP-Adapter cross-attention kwargs for the conditioned pass.
-        if ip_adapter_conditioning is not None:
+        if conditioning_data.ip_adapter_conditioning is not None:
             # Note that we 'unsqueeze' to produce tensors of shape (batch_size=1, num_ip_images, seq_len, token_len).
-            cross_attention_kwargs["ip_adapter_image_prompt_embeds"] = [
-                torch.unsqueeze(ipa_conditioning.cond_image_prompt_embeds, dim=0)
-                for ipa_conditioning in ip_adapter_conditioning
-            ]
+            cross_attention_kwargs = {
+                "ip_adapter_image_prompt_embeds": [
+                    torch.unsqueeze(ipa_conditioning.cond_image_prompt_embeds, dim=0)
+                    for ipa_conditioning in conditioning_data.ip_adapter_conditioning
+                ]
+            }
 
         # Prepare cross-attention control kwargs for the conditioned pass.
         if cross_attn_processor_context is not None:
             cross_attn_processor_context.cross_attention_types_to_do = cross_attention_control_types_to_do
-            cross_attention_kwargs["swap_cross_attn_context"] = cross_attn_processor_context
+            cross_attention_kwargs = {"swap_cross_attn_context": cross_attn_processor_context}
 
         # Prepare SDXL conditioning kwargs for the conditioned pass.
         added_cond_kwargs = None
-        if conditioning_data.is_sdxl():
+        if is_sdxl:
             added_cond_kwargs = {
-                "text_embeds": conditioning_data.cond_text.pooled_embeds,
-                "time_ids": conditioning_data.cond_text.add_time_ids,
+                "text_embeds": conditioning_data.text_embeddings.pooled_embeds,
+                "time_ids": conditioning_data.text_embeddings.add_time_ids,
             }
 
-        # Prepare prompt regions for the conditioned pass.
-        if conditioning_data.cond_regions is not None:
-            cross_attention_kwargs["regional_prompt_data"] = RegionalPromptData(
-                regions=[conditioning_data.cond_regions], device=x.device, dtype=x.dtype
-            )
-            cross_attention_kwargs["percent_through"] = percent_through
-
         # Run conditioned UNet denoising (i.e. positive prompt).
         conditioned_next_x = self.model_forward_callback(
             x,
             sigma,
-            conditioning_data.cond_text.embeds,
+            conditioning_data.text_embeddings.embeds,
             cross_attention_kwargs=cross_attention_kwargs,
             down_block_additional_residuals=cond_down_block,
             mid_block_additional_residual=cond_mid_block,

invokeai/backend/util/test_utils.py

@@ -42,9 +42,10 @@ def install_and_load_model(
     # 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(
+        configs = model_manager.store.search_by_attr(
             model_name=model_name, base_model=base_model, model_type=model_type
         )
+        loaded_model: LoadedModel = model_manager.load.load_model(configs[0])
         return loaded_model
 
     # Install the requested model.
@@ -53,7 +54,7 @@ def install_and_load_model(
     assert job.complete
 
     try:
-        loaded_model = model_manager.load_model_by_config(job.config_out)
+        loaded_model = model_manager.load.load_model(job.config_out)
         return loaded_model
     except UnknownModelException as e:
         raise Exception(

invokeai/frontend/install/model_install.py

@@ -144,7 +144,7 @@ class addModelsForm(CyclingForm, npyscreen.FormMultiPage):
 
         self.nextrely = top_of_table
         self.lora_models = self.add_model_widgets(
-            model_type=ModelType.Lora,
+            model_type=ModelType.LoRA,
             window_width=window_width,
         )
         bottom_of_table = max(bottom_of_table, self.nextrely)

invokeai/frontend/merge/merge_diffusers.py

@@ -20,7 +20,6 @@ from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.app.services.download import DownloadQueueService
 from invokeai.app.services.image_files.image_files_disk import DiskImageFileStorage
 from invokeai.app.services.model_install import ModelInstallService
-from invokeai.app.services.model_metadata import ModelMetadataStoreSQL
 from invokeai.app.services.model_records import ModelRecordServiceBase, ModelRecordServiceSQL
 from invokeai.app.services.shared.sqlite.sqlite_util import init_db
 from invokeai.backend.model_manager import (
@@ -413,7 +412,7 @@ def get_config_store() -> ModelRecordServiceSQL:
     assert output_path is not None
     image_files = DiskImageFileStorage(output_path / "images")
     db = init_db(config=config, logger=InvokeAILogger.get_logger(), image_files=image_files)
-    return ModelRecordServiceSQL(db, ModelMetadataStoreSQL(db))
+    return ModelRecordServiceSQL(db)
 
 
 def get_model_merger(record_store: ModelRecordServiceBase) -> ModelMerger:

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

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

invokeai/frontend/web/package.json

@@ -30,7 +30,7 @@
     "lint:prettier": "prettier --check .",
     "lint:tsc": "tsc --noEmit",
     "lint": "concurrently -g -c red,green,yellow,blue,magenta pnpm:lint:*",
-    "fix": "knip --fix && eslint --fix . && prettier --log-level warn --write .",
+    "fix": "eslint --fix . && prettier --log-level warn --write .",
     "preinstall": "npx only-allow pnpm",
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build",

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

@@ -304,6 +304,12 @@
             "method": "High Resolution Fix Method"
         }
     },
+    "prompt": {
+        "addPromptTrigger": "Add Prompt Trigger",
+        "compatibleEmbeddings": "Compatible Embeddings",
+        "noPromptTriggers": "No triggers available",
+        "noMatchingTriggers": "No matching triggers"
+    },
     "embedding": {
         "addEmbedding": "Add Embedding",
         "incompatibleModel": "Incompatible base model:",
@@ -740,6 +746,7 @@
         "delete": "Delete",
         "deleteConfig": "Delete Config",
         "deleteModel": "Delete Model",
+        "deleteModelImage": "Delete Model Image",
         "deleteMsg1": "Are you sure you want to delete this model from InvokeAI?",
         "deleteMsg2": "This WILL delete the model from disk if it is in the InvokeAI root folder. If you are using a custom location, then the model WILL NOT be deleted from disk.",
         "description": "Description",
@@ -759,11 +766,14 @@
         "importModels": "Import Models",
         "importQueue": "Import Queue",
         "inpainting": "v1 Inpainting",
+        "inplaceInstall": "In-place install",
+        "inplaceInstallDesc": "Install models without copying the files. When using the model, it will be loaded from its this location. If disabled, the model file(s) will be copied into the Invoke-managed models directory during installation.",
         "interpolationType": "Interpolation Type",
         "inverseSigmoid": "Inverse Sigmoid",
         "invokeAIFolder": "Invoke AI Folder",
         "invokeRoot": "InvokeAI folder",
         "load": "Load",
+        "localOnly": "local only",
         "loraModels": "LoRAs",
         "manual": "Manual",
         "merge": "Merge",
@@ -780,6 +790,10 @@
         "modelDeleteFailed": "Failed to delete model",
         "modelEntryDeleted": "Model Entry Deleted",
         "modelExists": "Model Exists",
+        "modelImageDeleted": "Model Image Deleted",
+        "modelImageDeleteFailed": "Model Image Delete Failed",
+        "modelImageUpdated": "Model Image Updated",
+        "modelImageUpdateFailed": "Model Image Update Failed",
         "modelLocation": "Model Location",
         "modelLocationValidationMsg": "Provide the path to a local folder where your Diffusers Model is stored",
         "modelManager": "Model Manager",
@@ -812,6 +826,7 @@
         "oliveModels": "Olives",
         "onnxModels": "Onnx",
         "path": "Path",
+        "pathToConfig": "Path To Config",
         "pathToCustomConfig": "Path To Custom Config",
         "pickModelType": "Pick Model Type",
         "predictionType": "Prediction Type",
@@ -844,8 +859,11 @@
         "syncModels": "Sync Models",
         "syncModelsDesc": "If your models are out of sync with the backend, you can refresh them up using this option. This is generally handy in cases where you add models to the InvokeAI root folder or autoimport directory after the application has booted.",
         "triggerPhrases": "Trigger Phrases",
+        "loraTriggerPhrases": "LoRA Trigger Phrases",
+        "mainModelTriggerPhrases": "Main Model Trigger Phrases",
         "typePhraseHere": "Type phrase here",
         "upcastAttention": "Upcast Attention",
+        "uploadImage": "Upload Image",
         "updateModel": "Update Model",
         "useCustomConfig": "Use Custom Config",
         "useDefaultSettings": "Use Default Settings",
@@ -938,6 +956,7 @@
         "doesNotExist": "does not exist",
         "downloadWorkflow": "Download Workflow JSON",
         "edge": "Edge",
+        "edit": "Edit",
         "editMode": "Edit in Workflow Editor",
         "enum": "Enum",
         "enumDescription": "Enums are values that may be one of a number of options.",
@@ -1013,6 +1032,7 @@
         "nodeTemplate": "Node Template",
         "nodeType": "Node Type",
         "noFieldsLinearview": "No fields added to Linear View",
+        "noFieldsViewMode": "This workflow has no selected fields to display. View the full workflow to configure values.",
         "noFieldType": "No field type",
         "noImageFoundState": "No initial image found in state",
         "noMatchingNodes": "No matching nodes",
@@ -1800,6 +1820,7 @@
         "cursorPosition": "Cursor Position",
         "darkenOutsideSelection": "Darken Outside Selection",
         "discardAll": "Discard All",
+        "discardCurrent": "Discard Current",
         "downloadAsImage": "Download As Image",
         "emptyFolder": "Empty Folder",
         "emptyTempImageFolder": "Empty Temp Image Folder",
@@ -1809,6 +1830,7 @@
         "eraseBoundingBox": "Erase Bounding Box",
         "eraser": "Eraser",
         "fillBoundingBox": "Fill Bounding Box",
+        "invertBrushSizeScrollDirection": "Invert Scroll for Brush Size",
         "layer": "Layer",
         "limitStrokesToBox": "Limit Strokes to Box",
         "mask": "Mask",

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

@@ -115,7 +115,8 @@
         "safetensors": "Safetensors",
         "ai": "ia",
         "file": "File",
-        "toResolve": "Da risolvere"
+        "toResolve": "Da risolvere",
+        "add": "Aggiungi"
     },
     "gallery": {
         "generations": "Generazioni",
@@ -153,7 +154,12 @@
         "starImage": "Immagine preferita",
         "dropToUpload": "$t(gallery.drop) per aggiornare",
         "problemDeletingImagesDesc": "Impossibile eliminare una o più immagini",
-        "problemDeletingImages": "Problema durante l'eliminazione delle immagini"
+        "problemDeletingImages": "Problema durante l'eliminazione delle immagini",
+        "bulkDownloadRequested": "Preparazione del download",
+        "bulkDownloadRequestedDesc": "La tua richiesta di download è in preparazione. L'operazione potrebbe richiedere alcuni istanti.",
+        "bulkDownloadRequestFailed": "Problema durante la preparazione del download",
+        "bulkDownloadStarting": "Avvio scaricamento",
+        "bulkDownloadFailed": "Scaricamento fallito"
     },
     "hotkeys": {
         "keyboardShortcuts": "Tasti di scelta rapida",
@@ -505,12 +511,12 @@
         "modelSyncFailed": "Sincronizzazione modello non riuscita",
         "settings": "Impostazioni",
         "syncModels": "Sincronizza Modelli",
-        "syncModelsDesc": "Se i tuoi modelli non sono sincronizzati con il back-end, puoi aggiornarli utilizzando questa opzione. Questo è generalmente utile nei casi in cui aggiorni manualmente il tuo file models.yaml o aggiungi modelli alla cartella principale di InvokeAI dopo l'avvio dell'applicazione.",
+        "syncModelsDesc": "Se i tuoi modelli non sono sincronizzati con il back-end, puoi aggiornarli utilizzando questa opzione. Questo è generalmente utile nei casi in cui aggiungi modelli alla cartella principale di InvokeAI dopo l'avvio dell'applicazione.",
         "loraModels": "LoRA",
         "oliveModels": "Olive",
         "onnxModels": "ONNX",
         "noModels": "Nessun modello trovato",
-        "predictionType": "Tipo di previsione (per modelli Stable Diffusion 2.x ed alcuni modelli Stable Diffusion 1.x)",
+        "predictionType": "Tipo di previsione",
         "quickAdd": "Aggiunta rapida",
         "simpleModelDesc": "Fornire un percorso a un modello diffusori locale, un modello checkpoint/safetensor locale, un ID repository HuggingFace o un URL del modello checkpoint/diffusori.",
         "advanced": "Avanzate",
@@ -521,7 +527,34 @@
         "vaePrecision": "Precisione VAE",
         "noModelSelected": "Nessun modello selezionato",
         "conversionNotSupported": "Conversione non supportata",
-        "configFile": "File di configurazione"
+        "configFile": "File di configurazione",
+        "modelName": "Nome del modello",
+        "modelSettings": "Impostazioni del modello",
+        "advancedImportInfo": "La scheda opzioni avanzate consente la configurazione manuale delle impostazioni del modello principale. Utilizza questa scheda solo se sei sicuro di conoscere il tipo di modello e la configurazione corretti per il modello selezionato.",
+        "addAll": "Aggiungi tutto",
+        "addModels": "Aggiungi modelli",
+        "cancel": "Annulla",
+        "edit": "Modifica",
+        "imageEncoderModelId": "ID modello codificatore di immagini",
+        "importQueue": "Coda di importazione",
+        "modelMetadata": "Metadati del modello",
+        "path": "Percorso",
+        "prune": "Elimina",
+        "pruneTooltip": "Elimina dalla coda le importazioni completate",
+        "removeFromQueue": "Rimuovi dalla coda",
+        "repoVariant": "Variante del repository",
+        "scan": "Scansiona",
+        "scanFolder": "Scansione cartella",
+        "scanResults": "Risultati della scansione",
+        "source": "Sorgente",
+        "upcastAttention": "Eleva l'attenzione",
+        "ztsnrTraining": "Addestramento ZTSNR",
+        "typePhraseHere": "Digita la frase qui",
+        "defaultSettingsSaved": "Impostazioni predefinite salvate",
+        "defaultSettings": "Impostazioni predefinite",
+        "metadata": "Metadati",
+        "useDefaultSettings": "Usa le impostazioni predefinite",
+        "triggerPhrases": "Frasi trigger"
     },
     "parameters": {
         "images": "Immagini",
@@ -603,8 +636,8 @@
         "clipSkip": "CLIP Skip",
         "aspectRatio": "Proporzioni",
         "maskAdjustmentsHeader": "Regolazioni della maschera",
-        "maskBlur": "Sfocatura",
-        "maskBlurMethod": "Metodo di sfocatura",
+        "maskBlur": "Sfocatura maschera",
+        "maskBlurMethod": "Metodo sfocatura maschera",
         "seamLowThreshold": "Basso",
         "seamHighThreshold": "Alto",
         "coherencePassHeader": "Passaggio di coerenza",
@@ -661,7 +694,8 @@
         "setToOptimalSizeTooLarge": "$t(parameters.setToOptimalSize) (potrebbe essere troppo grande)",
         "boxBlur": "Box",
         "gaussianBlur": "Gaussian",
-        "remixImage": "Remixa l'immagine"
+        "remixImage": "Remixa l'immagine",
+        "coherenceEdgeSize": "Dimensione bordo"
     },
     "settings": {
         "models": "Modelli",
@@ -744,8 +778,8 @@
         "canceled": "Elaborazione annullata",
         "problemCopyingImageLink": "Impossibile copiare il collegamento dell'immagine",
         "uploadFailedInvalidUploadDesc": "Deve essere una singola immagine PNG o JPEG",
-        "parameterSet": "Parametro impostato",
-        "parameterNotSet": "Parametro non impostato",
+        "parameterSet": "{{parameter}} impostato",
+        "parameterNotSet": "{{parameter}} non impostato",
         "nodesLoadedFailed": "Impossibile caricare i nodi",
         "nodesSaved": "Nodi salvati",
         "nodesLoaded": "Nodi caricati",
@@ -798,7 +832,10 @@
         "problemRetrievingWorkflow": "Problema nel recupero del flusso di lavoro",
         "resetInitialImage": "Reimposta l'immagine iniziale",
         "uploadInitialImage": "Carica l'immagine iniziale",
-        "problemDownloadingImage": "Impossibile scaricare l'immagine"
+        "problemDownloadingImage": "Impossibile scaricare l'immagine",
+        "prunedQueue": "Coda ripulita",
+        "modelImportCanceled": "Importazione del modello annullata",
+        "modelImportRemoved": "Importazione del modello rimossa"
     },
     "tooltip": {
         "feature": {
@@ -876,7 +913,10 @@
         "antialiasing": "Anti aliasing",
         "showResultsOn": "Mostra i risultati (attivato)",
         "showResultsOff": "Mostra i risultati (disattivato)",
-        "saveMask": "Salva $t(unifiedCanvas.mask)"
+        "saveMask": "Salva $t(unifiedCanvas.mask)",
+        "coherenceModeGaussianBlur": "Sfocatura Gaussiana",
+        "coherenceModeBoxBlur": "Sfocatura Box",
+        "coherenceModeStaged": "Maschera espansa"
     },
     "accessibility": {
         "modelSelect": "Seleziona modello",
@@ -1345,7 +1385,8 @@
         "allLoRAsAdded": "Tutti i LoRA aggiunti",
         "defaultVAE": "VAE predefinito",
         "incompatibleBaseModel": "Modello base incompatibile",
-        "loraAlreadyAdded": "LoRA già aggiunto"
+        "loraAlreadyAdded": "LoRA già aggiunto",
+        "concepts": "Concetti"
     },
     "invocationCache": {
         "disable": "Disabilita",
@@ -1698,6 +1739,25 @@
             "paragraphs": [
                 "Valuta le generazioni in modo che siano più simili alle immagini con un punteggio estetico elevato, in base ai dati di addestramento."
             ]
+        },
+        "compositingCoherenceMinDenoise": {
+            "heading": "Livello minimo di riduzione del rumore",
+            "paragraphs": [
+                "Intensità minima di riduzione rumore per la modalità di Coerenza",
+                "L'intensità minima di riduzione del rumore per la regione di coerenza durante l'inpainting o l'outpainting"
+            ]
+        },
+        "compositingMaskBlur": {
+            "paragraphs": [
+                "Il raggio di sfocatura della maschera."
+            ],
+            "heading": "Sfocatura maschera"
+        },
+        "compositingCoherenceEdgeSize": {
+            "heading": "Dimensione del bordo",
+            "paragraphs": [
+                "La dimensione del bordo del passaggio di coerenza."
+            ]
         }
     },
     "sdxl": {
@@ -1746,7 +1806,12 @@
         "scheduler": "Campionatore",
         "recallParameters": "Richiama i parametri",
         "noRecallParameters": "Nessun parametro da richiamare trovato",
-        "cfgRescaleMultiplier": "$t(parameters.cfgRescaleMultiplier)"
+        "cfgRescaleMultiplier": "$t(parameters.cfgRescaleMultiplier)",
+        "allPrompts": "Tutti i prompt",
+        "imageDimensions": "Dimensioni dell'immagine",
+        "parameterSet": "Parametro {{parameter}} impostato",
+        "parsingFailed": "Analisi non riuscita",
+        "recallParameter": "Richiama {{label}}"
     },
     "hrf": {
         "enableHrf": "Abilita Correzione Alta Risoluzione",
@@ -1818,5 +1883,11 @@
         "image": {
             "title": "Immagine"
         }
+    },
+    "prompt": {
+        "compatibleEmbeddings": "Incorporamenti compatibili",
+        "addPromptTrigger": "Aggiungi parola chiave nel prompt",
+        "noPromptTriggers": "Nessuna parola chiave disponibile",
+        "noMatchingTriggers": "Nessuna parola chiave corrispondente"
     }
 }

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

@@ -52,7 +52,7 @@
         "accept": "Принять",
         "postprocessing": "Постобработка",
         "txt2img": "Текст в изображение (txt2img)",
-        "linear": "Линейная обработка",
+        "linear": "Линейный вид",
         "dontAskMeAgain": "Больше не спрашивать",
         "areYouSure": "Вы уверены?",
         "random": "Случайное",
@@ -117,7 +117,8 @@
         "toResolve": "Чтоб решить",
         "copy": "Копировать",
         "localSystem": "Локальная система",
-        "aboutDesc": "Используя Invoke для работы? Проверьте это:"
+        "aboutDesc": "Используя Invoke для работы? Проверьте это:",
+        "add": "Добавить"
     },
     "gallery": {
         "generations": "Генерации",
@@ -155,7 +156,12 @@
         "noImageSelected": "Изображение не выбрано",
         "setCurrentImage": "Установить как текущее изображение",
         "starImage": "Добавить в избранное",
-        "dropToUpload": "$t(gallery.drop) чтоб загрузить"
+        "dropToUpload": "$t(gallery.drop) чтоб загрузить",
+        "bulkDownloadFailed": "Загрузка не удалась",
+        "bulkDownloadStarting": "Начало загрузки",
+        "bulkDownloadRequested": "Подготовка к скачиванию",
+        "bulkDownloadRequestedDesc": "Ваш запрос на скачивание готовится. Это может занять несколько минут.",
+        "bulkDownloadRequestFailed": "Возникла проблема при подготовке скачивания"
     },
     "hotkeys": {
         "keyboardShortcuts": "Горячие клавиши",
@@ -504,7 +510,7 @@
         "settings": "Настройки",
         "selectModel": "Выберите модель",
         "syncModels": "Синхронизация моделей",
-        "syncModelsDesc": "Если ваши модели не синхронизированы с серверной частью, вы можете обновить их, используя эту опцию. Обычно это удобно в тех случаях, когда вы вручную обновляете свой файл \"models.yaml\" или добавляете модели в корневую папку InvokeAI после загрузки приложения.",
+        "syncModelsDesc": "Если ваши модели не синхронизированы с серверной частью, вы можете обновить их с помощью этой опции. Обычно это удобно в тех случаях, когда вы добавляете модели в корневую папку InvokeAI или каталог автоимпорта после загрузки приложения.",
         "modelUpdateFailed": "Не удалось обновить модель",
         "modelConversionFailed": "Не удалось сконвертировать модель",
         "modelsMergeFailed": "Не удалось выполнить слияние моделей",
@@ -513,7 +519,7 @@
         "oliveModels": "Модели Olives",
         "conversionNotSupported": "Преобразование не поддерживается",
         "noModels": "Нет моделей",
-        "predictionType": "Тип прогноза (для моделей Stable Diffusion 2.x и периодических моделей Stable Diffusion 1.x)",
+        "predictionType": "Тип прогноза",
         "quickAdd": "Быстрое добавление",
         "simpleModelDesc": "Укажите путь к локальной модели Diffusers , локальной модели checkpoint / safetensors, идентификатор репозитория HuggingFace или URL-адрес модели контрольной checkpoint / diffusers.",
         "advanced": "Продвинутый",
@@ -524,7 +530,33 @@
         "customConfigFileLocation": "Расположение пользовательского файла конфигурации",
         "vaePrecision": "Точность VAE",
         "noModelSelected": "Модель не выбрана",
-        "configFile": "Файл конфигурации"
+        "configFile": "Файл конфигурации",
+        "addAll": "Добавить всё",
+        "addModels": "Добавить модели",
+        "cancel": "Отмена",
+        "defaultSettings": "Стандартные настройки",
+        "importQueue": "Импортировать очередь",
+        "metadata": "Метаданные",
+        "imageEncoderModelId": "ID модели-энкодера изображений",
+        "typePhraseHere": "Введите фразы здесь",
+        "advancedImportInfo": "Вкладка «Дополнительно» позволяет вручную настроить основные параметры модели. Используйте эту вкладку только в том случае, если вы уверены, что знаете правильный тип модели и конфигурацию выбранной модели.",
+        "defaultSettingsSaved": "Стандартные настройки сохранены",
+        "edit": "Редактировать",
+        "path": "Путь",
+        "prune": "Удалить",
+        "pruneTooltip": "Удалить готовые импорты из очереди",
+        "removeFromQueue": "Удалить из очереди",
+        "repoVariant": "Вариант репозитория",
+        "scan": "Сканировать",
+        "scanFolder": "Сканировать папку",
+        "scanResults": "Результаты сканирования",
+        "source": "Источник",
+        "triggerPhrases": "Триггерные фразы",
+        "useDefaultSettings": "Использовать стандартные настройки",
+        "modelMetadata": "Метаданные модели",
+        "modelName": "Название модели",
+        "modelSettings": "Настройки модели",
+        "upcastAttention": "Внимание"
     },
     "parameters": {
         "images": "Изображения",
@@ -591,7 +623,7 @@
         "hSymmetryStep": "Шаг гор. симметрии",
         "hidePreview": "Скрыть предпросмотр",
         "imageToImage": "Изображение в изображение",
-        "denoisingStrength": "Сила шумоподавления",
+        "denoisingStrength": "Сила зашумления",
         "copyImage": "Скопировать изображение",
         "showPreview": "Показать предпросмотр",
         "noiseSettings": "Шум",
@@ -606,8 +638,8 @@
         "clipSkip": "CLIP Пропуск",
         "aspectRatio": "Соотношение",
         "maskAdjustmentsHeader": "Настройка маски",
-        "maskBlur": "Размытие",
-        "maskBlurMethod": "Метод размытия",
+        "maskBlur": "Размытие маски",
+        "maskBlurMethod": "Метод размытия маски",
         "seamLowThreshold": "Низкий",
         "seamHighThreshold": "Высокий",
         "coherencePassHeader": "Порог Coherence",
@@ -666,7 +698,9 @@
         "lockAspectRatio": "Заблокировать соотношение",
         "boxBlur": "Размытие прямоугольника",
         "gaussianBlur": "Размытие по Гауссу",
-        "remixImage": "Ремикс изображения"
+        "remixImage": "Ремикс изображения",
+        "coherenceMinDenoise": "Мин. шумоподавление",
+        "coherenceEdgeSize": "Размер края"
     },
     "settings": {
         "models": "Модели",
@@ -749,8 +783,8 @@
         "canceled": "Обработка отменена",
         "problemCopyingImageLink": "Не удалось скопировать ссылку на изображение",
         "uploadFailedInvalidUploadDesc": "Должно быть одно изображение в формате PNG или JPEG",
-        "parameterNotSet": "Параметр не задан",
-        "parameterSet": "Параметр задан",
+        "parameterNotSet": "Параметр {{parameter}} не задан",
+        "parameterSet": "Параметр {{parameter}} задан",
         "nodesLoaded": "Узлы загружены",
         "problemCopyingImage": "Не удается скопировать изображение",
         "nodesLoadedFailed": "Не удалось загрузить Узлы",
@@ -803,7 +837,10 @@
         "problemImportingMask": "Проблема с импортом маски",
         "problemDownloadingImage": "Не удается скачать изображение",
         "uploadInitialImage": "Загрузить начальное изображение",
-        "resetInitialImage": "Сбросить начальное изображение"
+        "resetInitialImage": "Сбросить начальное изображение",
+        "prunedQueue": "Урезанная очередь",
+        "modelImportCanceled": "Импорт модели отменен",
+        "modelImportRemoved": "Импорт модели удален"
     },
     "tooltip": {
         "feature": {
@@ -1145,7 +1182,11 @@
         "reorderLinearView": "Изменить порядок линейного просмотра",
         "viewMode": "Использовать в линейном представлении",
         "editMode": "Открыть в редакторе узлов",
-        "resetToDefaultValue": "Сбросить к стандартному значкнию"
+        "resetToDefaultValue": "Сбросить к стандартному значкнию",
+        "latentsField": "Латенты",
+        "latentsCollectionDescription": "Латенты могут передаваться между узлами.",
+        "latentsPolymorphicDescription": "Латенты могут передаваться между узлами.",
+        "latentsFieldDescription": "Латенты могут передаваться между узлами."
     },
     "controlnet": {
         "amult": "a_mult",
@@ -1294,7 +1335,8 @@
         },
         "paramScheduler": {
             "paragraphs": [
-                "Планировщик определяет, как итеративно добавлять шум к изображению или как обновлять образец на основе выходных данных модели."
+                "Планировщик, используемый в процессе генерации.",
+                "Каждый планировщик определяет, как итеративно добавлять шум к изображению или как обновлять образец на основе выходных данных модели."
             ],
             "heading": "Планировщик"
         },
@@ -1347,7 +1389,7 @@
         "compositingCoherenceMode": {
             "heading": "Режим",
             "paragraphs": [
-                "Режим прохождения когерентности."
+                "Метод, используемый для создания связного изображения с вновь созданной замаскированной областью."
             ]
         },
         "paramSeed": {
@@ -1365,7 +1407,7 @@
         },
         "controlNetBeginEnd": {
             "paragraphs": [
-                "На каких этапах процесса шумоподавления будет применена ControlNet.",
+                "Часть процесса шумоподавления, к которой будет применен адаптер контроля.",
                 "ControlNet, применяемые в начале процесса, направляют композицию, а ControlNet, применяемые в конце, направляют детали."
             ],
             "heading": "Процент начала/конца шага"
@@ -1381,8 +1423,8 @@
         },
         "clipSkip": {
             "paragraphs": [
-                "Выберите, сколько слоев модели CLIP нужно пропустить.",
-                "Некоторые модели работают лучше с определенными настройками пропуска CLIP."
+                "Сколько слоев модели CLIP пропустить.",
+                "Некоторые модели лучше подходят для использования с CLIP Skip."
             ],
             "heading": "CLIP пропуск"
         },
@@ -1479,6 +1521,25 @@
             "paragraphs": [
                 "Более высокий вес LoRA приведет к большему влиянию на конечное изображение."
             ]
+        },
+        "compositingMaskBlur": {
+            "heading": "Размытие маски",
+            "paragraphs": [
+                "Радиус размытия маски."
+            ]
+        },
+        "compositingCoherenceMinDenoise": {
+            "heading": "Минимальное шумоподавление",
+            "paragraphs": [
+                "Минимальный уровень шумоподавления для режима Coherence",
+                "Минимальный уровень шумоподавления для области когерентности при перерисовывании или дорисовке"
+            ]
+        },
+        "compositingCoherenceEdgeSize": {
+            "heading": "Размер края",
+            "paragraphs": [
+                "Размер края прохода когерентности."
+            ]
         }
     },
     "metadata": {
@@ -1509,7 +1570,12 @@
         "steps": "Шаги",
         "scheduler": "Планировщик",
         "noRecallParameters": "Параметры для вызова не найдены",
-        "cfgRescaleMultiplier": "$t(parameters.cfgRescaleMultiplier)"
+        "cfgRescaleMultiplier": "$t(parameters.cfgRescaleMultiplier)",
+        "parameterSet": "Параметр {{parameter}} установлен",
+        "parsingFailed": "Не удалось выполнить синтаксический анализ",
+        "recallParameter": "Отозвать {{label}}",
+        "allPrompts": "Все запросы",
+        "imageDimensions": "Размеры изображения"
     },
     "queue": {
         "status": "Статус",
@@ -1588,10 +1654,11 @@
         "denoisingStrength": "Шумоподавление",
         "refinermodel": "Модель перерисовщик",
         "posAestheticScore": "Положительная эстетическая оценка",
-        "concatPromptStyle": "Объединение запроса и стиля",
+        "concatPromptStyle": "Связывание запроса и стиля",
         "loading": "Загрузка...",
         "steps": "Шаги",
-        "posStylePrompt": "Запрос стиля"
+        "posStylePrompt": "Запрос стиля",
+        "freePromptStyle": "Ручной запрос стиля"
     },
     "invocationCache": {
         "useCache": "Использовать кэш",
@@ -1678,7 +1745,8 @@
         "allLoRAsAdded": "Все LoRA добавлены",
         "defaultVAE": "Стандартное VAE",
         "incompatibleBaseModel": "Несовместимая базовая модель",
-        "loraAlreadyAdded": "LoRA уже добавлена"
+        "loraAlreadyAdded": "LoRA уже добавлена",
+        "concepts": "Концепты"
     },
     "app": {
         "storeNotInitialized": "Магазин не инициализирован"
@@ -1696,7 +1764,7 @@
         },
         "generation": {
             "title": "Генерация",
-            "conceptsTab": "Концепты",
+            "conceptsTab": "LoRA",
             "modelTab": "Модель"
         },
         "advanced": {

invokeai/frontend/web/scripts/typegen.js

@@ -5,18 +5,55 @@ import openapiTS from 'openapi-typescript';
 const OPENAPI_URL = 'http://127.0.0.1:9090/openapi.json';
 const OUTPUT_FILE = 'src/services/api/schema.ts';
 
-async function main() {
-  process.stdout.write(`Generating types "${OPENAPI_URL}" --> "${OUTPUT_FILE}"...`);
-  const types = await openapiTS(OPENAPI_URL, {
+async function generateTypes(schema) {
+  process.stdout.write(`Generating types ${OUTPUT_FILE}...`);
+  const types = await openapiTS(schema, {
     exportType: true,
     transform: (schemaObject) => {
       if ('format' in schemaObject && schemaObject.format === 'binary') {
         return schemaObject.nullable ? 'Blob | null' : 'Blob';
       }
+      if (schemaObject.title === 'MetadataField') {
+        // This is `Record<string, never>` by default, but it actually accepts any a dict of any valid JSON value.
+        return 'Record<string, unknown>';
+      }
     },
   });
   fs.writeFileSync(OUTPUT_FILE, types);
   process.stdout.write(`\nOK!\r\n`);
 }
 
+async function main() {
+  const encoding = 'utf-8';
+
+  if (process.stdin.isTTY) {
+    // Handle generating types with an arg (e.g. URL or path to file)
+    if (process.argv.length > 3) {
+      console.error('Usage: typegen.js <openapi.json>');
+      process.exit(1);
+    }
+    if (process.argv[2]) {
+      const schema = new Buffer.from(process.argv[2], encoding);
+      generateTypes(schema);
+    } else {
+      generateTypes(OPENAPI_URL);
+    }
+  } else {
+    // Handle generating types from stdin
+    let schema = '';
+    process.stdin.setEncoding(encoding);
+
+    process.stdin.on('readable', function () {
+      const chunk = process.stdin.read();
+      if (chunk !== null) {
+        schema += chunk;
+      }
+    });
+
+    process.stdin.on('end', function () {
+      generateTypes(JSON.parse(schema));
+    });
+  }
+}
+
 main();

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

@@ -153,7 +153,7 @@ addFirstListImagesListener(startAppListening);
 // Ad-hoc upscale workflwo
 addUpscaleRequestedListener(startAppListening);
 
-// Dynamic prompts
+// Prompts
 addDynamicPromptsListener(startAppListening);
 
 addSetDefaultSettingsListener(startAppListening);

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

@@ -38,7 +38,7 @@ export const addCanvasImageToControlNetListener = (startAppListening: AppStartLi
             type: 'image/png',
           }),
           image_category: 'control',
-          is_intermediate: false,
+          is_intermediate: true,
           board_id: autoAddBoardId === 'none' ? undefined : autoAddBoardId,
           crop_visible: false,
           postUploadAction: {

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

@@ -48,7 +48,7 @@ export const addCanvasMaskToControlNetListener = (startAppListening: AppStartLis
             type: 'image/png',
           }),
           image_category: 'mask',
-          is_intermediate: false,
+          is_intermediate: true,
           board_id: autoAddBoardId === 'none' ? undefined : autoAddBoardId,
           crop_visible: false,
           postUploadAction: {

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

@@ -101,7 +101,7 @@ export const addEnqueueRequestedCanvasListener = (startAppListening: AppStartLis
         ).unwrap();
       }
 
-      const graph = buildCanvasGraph(state, generationMode, canvasInitImage, canvasMaskImage);
+      const graph = await buildCanvasGraph(state, generationMode, canvasInitImage, canvasMaskImage);
 
       log.debug({ graph: parseify(graph) }, `Canvas graph built`);
 

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

@@ -20,15 +20,15 @@ export const addEnqueueRequestedLinear = (startAppListening: AppStartListening)
 
       if (model && model.base === 'sdxl') {
         if (action.payload.tabName === 'txt2img') {
-          graph = buildLinearSDXLTextToImageGraph(state);
+          graph = await buildLinearSDXLTextToImageGraph(state);
         } else {
-          graph = buildLinearSDXLImageToImageGraph(state);
+          graph = await buildLinearSDXLImageToImageGraph(state);
         }
       } else {
         if (action.payload.tabName === 'txt2img') {
-          graph = buildLinearTextToImageGraph(state);
+          graph = await buildLinearTextToImageGraph(state);
         } else {
-          graph = buildLinearImageToImageGraph(state);
+          graph = await buildLinearImageToImageGraph(state);
         }
       }
 

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

@@ -7,8 +7,10 @@ import {
   selectAllT2IAdapters,
 } from 'features/controlAdapters/store/controlAdaptersSlice';
 import { loraRemoved } from 'features/lora/store/loraSlice';
-import { modelChanged, vaeSelected } from 'features/parameters/store/generationSlice';
+import { calculateNewSize } from 'features/parameters/components/ImageSize/calculateNewSize';
+import { heightChanged, modelChanged, vaeSelected, widthChanged } from 'features/parameters/store/generationSlice';
 import { zParameterModel, zParameterVAEModel } from 'features/parameters/types/parameterSchemas';
+import { getIsSizeOptimal, getOptimalDimension } from 'features/parameters/util/optimalDimension';
 import { refinerModelChanged } from 'features/sdxl/store/sdxlSlice';
 import { forEach, some } from 'lodash-es';
 import { mainModelsAdapterSelectors, modelsApi, vaeModelsAdapterSelectors } from 'services/api/endpoints/models';
@@ -24,7 +26,9 @@ export const addModelsLoadedListener = (startAppListening: AppStartListening) =>
       const log = logger('models');
       log.info({ models: action.payload.entities }, `Main models loaded (${action.payload.ids.length})`);
 
-      const currentModel = getState().generation.model;
+      const state = getState();
+
+      const currentModel = state.generation.model;
       const models = mainModelsAdapterSelectors.selectAll(action.payload);
 
       if (models.length === 0) {
@@ -39,6 +43,29 @@ export const addModelsLoadedListener = (startAppListening: AppStartListening) =>
         return;
       }
 
+      const defaultModel = state.config.sd.defaultModel;
+      const defaultModelInList = defaultModel ? models.find((m) => m.key === defaultModel) : false;
+
+      if (defaultModelInList) {
+        const result = zParameterModel.safeParse(defaultModelInList);
+        if (result.success) {
+          dispatch(modelChanged(defaultModelInList, currentModel));
+
+          const optimalDimension = getOptimalDimension(defaultModelInList);
+          if (getIsSizeOptimal(state.generation.width, state.generation.height, optimalDimension)) {
+            return;
+          }
+          const { width, height } = calculateNewSize(
+            state.generation.aspectRatio.value,
+            optimalDimension * optimalDimension
+          );
+
+          dispatch(widthChanged(width));
+          dispatch(heightChanged(height));
+          return;
+        }
+      }
+
       const result = zParameterModel.safeParse(models[0]);
 
       if (!result.success) {

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

@@ -21,6 +21,7 @@ import { makeToast } from 'features/system/util/makeToast';
 import { t } from 'i18next';
 import { map } from 'lodash-es';
 import { modelsApi } from 'services/api/endpoints/models';
+import { isNonRefinerMainModelConfig } from 'services/api/types';
 
 export const addSetDefaultSettingsListener = (startAppListening: AppStartListening) => {
   startAppListening({
@@ -34,63 +35,66 @@ export const addSetDefaultSettingsListener = (startAppListening: AppStartListeni
         return;
       }
 
-      const metadata = await dispatch(modelsApi.endpoints.getModelMetadata.initiate(currentModel.key)).unwrap();
+      const modelConfig = await dispatch(modelsApi.endpoints.getModelConfig.initiate(currentModel.key)).unwrap();
 
-      if (!metadata || !metadata.default_settings) {
+      if (!modelConfig) {
         return;
       }
 
-      const { vae, vae_precision, cfg_scale, cfg_rescale_multiplier, steps, scheduler } = metadata.default_settings;
+      if (isNonRefinerMainModelConfig(modelConfig) && modelConfig.default_settings) {
+        const { vae, vae_precision, cfg_scale, cfg_rescale_multiplier, steps, scheduler } =
+          modelConfig.default_settings;
 
-      if (vae) {
-        // we store this as "default" within default settings
-        // to distinguish it from no default set
-        if (vae === 'default') {
-          dispatch(vaeSelected(null));
-        } else {
-          const { data } = modelsApi.endpoints.getVaeModels.select()(state);
-          const vaeArray = map(data?.entities);
-          const validVae = vaeArray.find((model) => model.key === vae);
+        if (vae) {
+          // we store this as "default" within default settings
+          // to distinguish it from no default set
+          if (vae === 'default') {
+            dispatch(vaeSelected(null));
+          } else {
+            const { data } = modelsApi.endpoints.getVaeModels.select()(state);
+            const vaeArray = map(data?.entities);
+            const validVae = vaeArray.find((model) => model.key === vae);
 
-          const result = zParameterVAEModel.safeParse(validVae);
-          if (!result.success) {
-            return;
+            const result = zParameterVAEModel.safeParse(validVae);
+            if (!result.success) {
+              return;
+            }
+            dispatch(vaeSelected(result.data));
           }
-          dispatch(vaeSelected(result.data));
         }
-      }
 
-      if (vae_precision) {
-        if (isParameterPrecision(vae_precision)) {
-          dispatch(vaePrecisionChanged(vae_precision));
+        if (vae_precision) {
+          if (isParameterPrecision(vae_precision)) {
+            dispatch(vaePrecisionChanged(vae_precision));
+          }
         }
-      }
 
-      if (cfg_scale) {
-        if (isParameterCFGScale(cfg_scale)) {
-          dispatch(setCfgScale(cfg_scale));
+        if (cfg_scale) {
+          if (isParameterCFGScale(cfg_scale)) {
+            dispatch(setCfgScale(cfg_scale));
+          }
         }
-      }
 
-      if (cfg_rescale_multiplier) {
-        if (isParameterCFGRescaleMultiplier(cfg_rescale_multiplier)) {
-          dispatch(setCfgRescaleMultiplier(cfg_rescale_multiplier));
+        if (cfg_rescale_multiplier) {
+          if (isParameterCFGRescaleMultiplier(cfg_rescale_multiplier)) {
+            dispatch(setCfgRescaleMultiplier(cfg_rescale_multiplier));
+          }
         }
-      }
 
-      if (steps) {
-        if (isParameterSteps(steps)) {
-          dispatch(setSteps(steps));
+        if (steps) {
+          if (isParameterSteps(steps)) {
+            dispatch(setSteps(steps));
+          }
         }
-      }
 
-      if (scheduler) {
-        if (isParameterScheduler(scheduler)) {
-          dispatch(setScheduler(scheduler));
+        if (scheduler) {
+          if (isParameterScheduler(scheduler)) {
+            dispatch(setScheduler(scheduler));
+          }
         }
-      }
 
-      dispatch(addToast(makeToast({ title: t('toast.parameterSet', { parameter: 'Default settings' }) })));
+        dispatch(addToast(makeToast({ title: t('toast.parameterSet', { parameter: 'Default settings' }) })));
+      }
     },
   });
 };

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

@@ -14,7 +14,7 @@ export const addModelInstallEventListener = (startAppListening: AppStartListenin
       const { bytes, total_bytes, id } = action.payload.data;
 
       dispatch(
-        modelsApi.util.updateQueryData('getModelImports', undefined, (draft) => {
+        modelsApi.util.updateQueryData('listModelInstalls', undefined, (draft) => {
           const modelImport = draft.find((m) => m.id === id);
           if (modelImport) {
             modelImport.bytes = bytes;
@@ -33,7 +33,7 @@ export const addModelInstallEventListener = (startAppListening: AppStartListenin
       const { id } = action.payload.data;
 
       dispatch(
-        modelsApi.util.updateQueryData('getModelImports', undefined, (draft) => {
+        modelsApi.util.updateQueryData('listModelInstalls', undefined, (draft) => {
           const modelImport = draft.find((m) => m.id === id);
           if (modelImport) {
             modelImport.status = 'completed';
@@ -41,7 +41,7 @@ export const addModelInstallEventListener = (startAppListening: AppStartListenin
           return draft;
         })
       );
-      dispatch(api.util.invalidateTags([{ type: 'ModelConfig' }]));
+      dispatch(api.util.invalidateTags(['Model']));
     },
   });
 
@@ -51,7 +51,7 @@ export const addModelInstallEventListener = (startAppListening: AppStartListenin
       const { id, error, error_type } = action.payload.data;
 
       dispatch(
-        modelsApi.util.updateQueryData('getModelImports', undefined, (draft) => {
+        modelsApi.util.updateQueryData('listModelInstalls', undefined, (draft) => {
           const modelImport = draft.find((m) => m.id === id);
           if (modelImport) {
             modelImport.status = 'error';

invokeai/frontend/web/src/common/components/IAIColorPicker.tsx

@@ -20,7 +20,7 @@ const sx: ChakraProps['sx'] = {
   '.react-colorful__hue-pointer': colorPickerPointerStyles,
   '.react-colorful__saturation-pointer': colorPickerPointerStyles,
   '.react-colorful__alpha-pointer': colorPickerPointerStyles,
-  gap: 2,
+  gap: 5,
   flexDir: 'column',
 };
 
@@ -39,8 +39,8 @@ const IAIColorPicker = (props: IAIColorPickerProps) => {
     <Flex sx={sx}>
       <RgbaColorPicker color={color} onChange={onChange} style={colorPickerStyles} {...rest} />
       {withNumberInput && (
-        <Flex>
-          <FormControl>
+        <Flex gap={5}>
+          <FormControl gap={0}>
             <FormLabel>{t('common.red')}</FormLabel>
             <CompositeNumberInput
               value={color.r}
@@ -52,7 +52,7 @@ const IAIColorPicker = (props: IAIColorPickerProps) => {
               defaultValue={90}
             />
           </FormControl>
-          <FormControl>
+          <FormControl gap={0}>
             <FormLabel>{t('common.green')}</FormLabel>
             <CompositeNumberInput
               value={color.g}
@@ -64,7 +64,7 @@ const IAIColorPicker = (props: IAIColorPickerProps) => {
               defaultValue={90}
             />
           </FormControl>
-          <FormControl>
+          <FormControl gap={0}>
             <FormLabel>{t('common.blue')}</FormLabel>
             <CompositeNumberInput
               value={color.b}
@@ -76,7 +76,7 @@ const IAIColorPicker = (props: IAIColorPickerProps) => {
               defaultValue={255}
             />
           </FormControl>
-          <FormControl>
+          <FormControl gap={0}>
             <FormLabel>{t('common.alpha')}</FormLabel>
             <CompositeNumberInput
               value={color.a}

invokeai/frontend/web/src/common/hooks/useGroupedModelCombobox.ts

@@ -2,7 +2,7 @@ import type { ComboboxOnChange, ComboboxOption } from '@invoke-ai/ui-library';
 import type { EntityState } from '@reduxjs/toolkit';
 import { useAppSelector } from 'app/store/storeHooks';
 import type { GroupBase } from 'chakra-react-select';
-import type { ModelIdentifierWithBase } from 'features/nodes/types/common';
+import type { ModelIdentifierField } from 'features/nodes/types/common';
 import { groupBy, map, reduce } from 'lodash-es';
 import { useCallback, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -10,7 +10,7 @@ import type { AnyModelConfig } from 'services/api/types';
 
 type UseGroupedModelComboboxArg<T extends AnyModelConfig> = {
   modelEntities: EntityState<T, string> | undefined;
-  selectedModel?: ModelIdentifierWithBase | null;
+  selectedModel?: ModelIdentifierField | null;
   onChange: (value: T | null) => void;
   getIsDisabled?: (model: T) => boolean;
   isLoading?: boolean;

invokeai/frontend/web/src/common/hooks/useModelCombobox.ts

@@ -1,6 +1,6 @@
 import type { ComboboxOnChange, ComboboxOption } from '@invoke-ai/ui-library';
 import type { EntityState } from '@reduxjs/toolkit';
-import type { ModelIdentifierWithBase } from 'features/nodes/types/common';
+import type { ModelIdentifierField } from 'features/nodes/types/common';
 import { map } from 'lodash-es';
 import { useCallback, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -8,7 +8,7 @@ import type { AnyModelConfig } from 'services/api/types';
 
 type UseModelComboboxArg<T extends AnyModelConfig> = {
   modelEntities: EntityState<T, string> | undefined;
-  selectedModel?: ModelIdentifierWithBase | null;
+  selectedModel?: ModelIdentifierField | null;
   onChange: (value: T | null) => void;
   getIsDisabled?: (model: T) => boolean;
   optionsFilter?: (model: T) => boolean;

invokeai/frontend/web/src/common/hooks/useModelCustomSelect.ts

@@ -1,7 +1,7 @@
 import type { Item } from '@invoke-ai/ui-library';
 import type { EntityState } from '@reduxjs/toolkit';
 import { EMPTY_ARRAY } from 'app/store/constants';
-import type { ModelIdentifierWithBase } from 'features/nodes/types/common';
+import type { ModelIdentifierField } from 'features/nodes/types/common';
 import { MODEL_TYPE_SHORT_MAP } from 'features/parameters/types/constants';
 import { filter } from 'lodash-es';
 import { useCallback, useMemo } from 'react';
@@ -11,7 +11,7 @@ import type { AnyModelConfig } from 'services/api/types';
 type UseModelCustomSelectArg<T extends AnyModelConfig> = {
   data: EntityState<T, string> | undefined;
   isLoading: boolean;
-  selectedModel?: ModelIdentifierWithBase | null;
+  selectedModel?: ModelIdentifierField | null;
   onChange: (value: T | null) => void;
   modelFilter?: (model: T) => boolean;
   isModelDisabled?: (model: T) => boolean;

invokeai/frontend/web/src/features/canvas/components/IAICanvas.tsx

@@ -29,7 +29,7 @@ import { Layer, Stage } from 'react-konva';
 import IAICanvasBoundingBoxOverlay from './IAICanvasBoundingBoxOverlay';
 import IAICanvasGrid from './IAICanvasGrid';
 import IAICanvasIntermediateImage from './IAICanvasIntermediateImage';
-import IAICanvasMaskCompositer from './IAICanvasMaskCompositer';
+import IAICanvasMaskCompositor from './IAICanvasMaskCompositor';
 import IAICanvasMaskLines from './IAICanvasMaskLines';
 import IAICanvasObjectRenderer from './IAICanvasObjectRenderer';
 import IAICanvasStagingArea from './IAICanvasStagingArea';
@@ -176,7 +176,7 @@ const IAICanvas = () => {
           </Layer>
           <Layer id="mask" visible={isMaskEnabled && !isStaging} listening={false}>
             <IAICanvasMaskLines visible={true} listening={false} />
-            <IAICanvasMaskCompositer listening={false} />
+            <IAICanvasMaskCompositor listening={false} />
           </Layer>
           <Layer listening={false}>
             <IAICanvasBoundingBoxOverlay />

invokeai/frontend/web/src/features/canvas/components/IAICanvasMaskCompositor.tsx

@@ -16,9 +16,9 @@ const canvasMaskCompositerSelector = createMemoizedSelector(selectCanvasSlice, (
   };
 });
 
-type IAICanvasMaskCompositerProps = RectConfig;
+type IAICanvasMaskCompositorProps = RectConfig;
 
-const IAICanvasMaskCompositer = (props: IAICanvasMaskCompositerProps) => {
+const IAICanvasMaskCompositor = (props: IAICanvasMaskCompositorProps) => {
   const { ...rest } = props;
 
   const { stageCoordinates, stageDimensions } = useAppSelector(canvasMaskCompositerSelector);
@@ -89,4 +89,4 @@ const IAICanvasMaskCompositer = (props: IAICanvasMaskCompositerProps) => {
   );
 };
 
-export default memo(IAICanvasMaskCompositer);
+export default memo(IAICanvasMaskCompositor);

invokeai/frontend/web/src/features/canvas/components/IAICanvasStagingAreaToolbar.tsx

@@ -5,6 +5,7 @@ import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
 import { stagingAreaImageSaved } from 'features/canvas/store/actions';
 import {
   commitStagingAreaImage,
+  discardStagedImage,
   discardStagedImages,
   nextStagingAreaImage,
   prevStagingAreaImage,
@@ -22,6 +23,7 @@ import {
   PiEyeBold,
   PiEyeSlashBold,
   PiFloppyDiskBold,
+  PiTrashSimpleBold,
   PiXBold,
 } from 'react-icons/pi';
 import { useGetImageDTOQuery } from 'services/api/endpoints/images';
@@ -44,6 +46,40 @@ const selector = createMemoizedSelector(selectCanvasSlice, (canvas) => {
   };
 });
 
+const ClearStagingIntermediatesIconButton = () => {
+  const dispatch = useAppDispatch();
+  const { t } = useTranslation();
+
+  const handleDiscardStagingArea = useCallback(() => {
+    dispatch(discardStagedImages());
+  }, [dispatch]);
+
+  const handleDiscardStagingImage = useCallback(() => {
+    dispatch(discardStagedImage());
+  }, [dispatch]);
+
+  return (
+    <>
+      <IconButton
+        tooltip={`${t('unifiedCanvas.discardCurrent')}`}
+        aria-label={t('unifiedCanvas.discardCurrent')}
+        icon={<PiXBold />}
+        onClick={handleDiscardStagingImage}
+        colorScheme="invokeBlue"
+        fontSize={16}
+      />
+      <IconButton
+        tooltip={`${t('unifiedCanvas.discardAll')} (Esc)`}
+        aria-label={t('unifiedCanvas.discardAll')}
+        icon={<PiTrashSimpleBold />}
+        onClick={handleDiscardStagingArea}
+        colorScheme="error"
+        fontSize={16}
+      />
+    </>
+  );
+};
+
 const IAICanvasStagingAreaToolbar = () => {
   const dispatch = useAppDispatch();
   const { currentStagingAreaImage, shouldShowStagingImage, currentIndex, total } = useAppSelector(selector);
@@ -185,14 +221,7 @@ const IAICanvasStagingAreaToolbar = () => {
           onClick={handleSaveToGallery}
           colorScheme="invokeBlue"
         />
-        <IconButton
-          tooltip={`${t('unifiedCanvas.discardAll')} (Esc)`}
-          aria-label={t('unifiedCanvas.discardAll')}
-          icon={<PiXBold />}
-          onClick={handleDiscardStagingArea}
-          colorScheme="error"
-          fontSize={20}
-        />
+        <ClearStagingIntermediatesIconButton />
       </ButtonGroup>
     </Flex>
   );

invokeai/frontend/web/src/features/canvas/components/IAICanvasToolbar/IAICanvasSettingsButtonPopover.tsx

@@ -18,6 +18,7 @@ import {
   setShouldAutoSave,
   setShouldCropToBoundingBoxOnSave,
   setShouldDarkenOutsideBoundingBox,
+  setShouldInvertBrushSizeScrollDirection,
   setShouldRestrictStrokesToBox,
   setShouldShowCanvasDebugInfo,
   setShouldShowGrid,
@@ -40,6 +41,7 @@ const IAICanvasSettingsButtonPopover = () => {
   const shouldAutoSave = useAppSelector((s) => s.canvas.shouldAutoSave);
   const shouldCropToBoundingBoxOnSave = useAppSelector((s) => s.canvas.shouldCropToBoundingBoxOnSave);
   const shouldDarkenOutsideBoundingBox = useAppSelector((s) => s.canvas.shouldDarkenOutsideBoundingBox);
+  const shouldInvertBrushSizeScrollDirection = useAppSelector((s) => s.canvas.shouldInvertBrushSizeScrollDirection);
   const shouldShowCanvasDebugInfo = useAppSelector((s) => s.canvas.shouldShowCanvasDebugInfo);
   const shouldShowGrid = useAppSelector((s) => s.canvas.shouldShowGrid);
   const shouldShowIntermediates = useAppSelector((s) => s.canvas.shouldShowIntermediates);
@@ -76,6 +78,10 @@ const IAICanvasSettingsButtonPopover = () => {
     (e: ChangeEvent<HTMLInputElement>) => dispatch(setShouldDarkenOutsideBoundingBox(e.target.checked)),
     [dispatch]
   );
+  const handleChangeShouldInvertBrushSizeScrollDirection = useCallback(
+    (e: ChangeEvent<HTMLInputElement>) => dispatch(setShouldInvertBrushSizeScrollDirection(e.target.checked)),
+    [dispatch]
+  );
   const handleChangeShouldAutoSave = useCallback(
     (e: ChangeEvent<HTMLInputElement>) => dispatch(setShouldAutoSave(e.target.checked)),
     [dispatch]
@@ -144,6 +150,13 @@ const IAICanvasSettingsButtonPopover = () => {
                 <FormLabel>{t('unifiedCanvas.limitStrokesToBox')}</FormLabel>
                 <Checkbox isChecked={shouldRestrictStrokesToBox} onChange={handleChangeShouldRestrictStrokesToBox} />
               </FormControl>
+              <FormControl>
+                <FormLabel>{t('unifiedCanvas.invertBrushSizeScrollDirection')}</FormLabel>
+                <Checkbox
+                  isChecked={shouldInvertBrushSizeScrollDirection}
+                  onChange={handleChangeShouldInvertBrushSizeScrollDirection}
+                />
+              </FormControl>
               <FormControl>
                 <FormLabel>{t('unifiedCanvas.showCanvasDebugInfo')}</FormLabel>
                 <Checkbox isChecked={shouldShowCanvasDebugInfo} onChange={handleChangeShouldShowCanvasDebugInfo} />