Next rebased #5836

… ModelLoader

This is useful for the zod schemas and types we have created to match the backend.

- Update most model identifiers to be `{key: string}` instead of name/base/type. Doesn't change the model select components yet. - Update model _parameters_, stored in redux, to be `{key: string, base: BaseModel}` - we need to store the base model to be able to check model compatibility. May want to store the whole config? Not sure...

The MM2 router is at `api/v2/models`. URL builder utils make this a bit easier to manage.

- ModelMetadataStoreService is now injected into ModelRecordStoreService (these two services are really joined at the hip, and should someday be merged) - ModelRecordStoreService is now injected into ModelManagerService - Reduced timeout value for the various installer and download wait*() methods - Introduced a Mock modelmanager for testing - Removed bare print() statement with _logger in the install helper backend. - Removed unused code from model loader init file - Made `locker` a private variable in the `LoadedModel` object. - Fixed up model merge frontend (will be deprecated anyway!)

- Rename old "model_management" directory to "model_management_OLD" in order to catch dangling references to original model manager. - Caught and fixed most dangling references (still checking) - Rename lora, textual_inversion and model_patcher modules - Introduce a RawModel base class to simplfy the Union returned by the model loaders. - Tidy up the model manager 2-related tests. Add useful fixtures, and a finalizer to the queue and installer fixtures that will stop the services and release threads.

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

Also default CNet preprocessors to "RGB"

We use pydantic to validate a union of valid invocations when instantiating a graph. Previously, we constructed the union while creating the `Graph` class. This introduces a dependency on the order of imports. For example, consider a setup where we have 3 invocations in the app: - Python executes the module where `FirstInvocation` is defined, registering `FirstInvocation`. - Python executes the module where `SecondInvocation` is defined, registering `SecondInvocation`. - Python executes the module where `Graph` is defined. A union of invocations is created and used to define the `Graph.nodes` field. The union contains `FirstInvocation` and `SecondInvocation`. - Python executes the module where `ThirdInvocation` is defined, registering `ThirdInvocation`. - A graph is created that includes `ThirdInvocation`. Pydantic validates the graph using the union, which does not know about `ThirdInvocation`, raising a `ValidationError` about an unknown invocation type. This scenario has been particularly problematic in tests, where we may create invocations dynamically. The test files have to be structured in such a way that the imports happen in the right order. It's a major pain. This PR refactors the validation of graph nodes to resolve this issue: - `BaseInvocation` gets a new method `get_typeadapter`. This builds a pydantic `TypeAdapter` for the union of all registered invocations, caching it after the first call. - `Graph.nodes`'s type is widened to `dict[str, BaseInvocation]`. This actually is a nice bonus, because we get better type hints whenever we reference `some_graph.nodes`. - A "plain" field validator takes over the validation logic for `Graph.nodes`. "Plain" validators totally override pydantic's own validation logic. The validator grabs the `TypeAdapter` from `BaseInvocation`, then validates each node with it. The validation is identical to the previous implementation - we get the same errors. `BaseInvocationOutput` gets the same treatment.

The change to `Graph.nodes` and `GraphExecutionState.results` validation requires some fanagling to get the OpenAPI schema generation to work. See new comments for a details.

`GraphInvocation` is a node that can contain a whole graph. It is removed for a number of reasons: 1. This feature was unused (the UI doesn't support it) and there is no plan for it to be used. The use-case it served is known in other node execution engines as "node groups" or "blocks" - a self-contained group of nodes, which has group inputs and outputs. This is a planned feature that will be handled client-side. 2. It adds substantial complexity to the graph processing logic. It's probably not enough to have a measurable performance impact but it does make it harder to work in the graph logic. 3. It allows for graphs to be recursive, and the improved invocations union handling does not play well with it. Actually, it works fine within `graph.py` but not in the tests for some reason. I do not understand why. There's probably a workaround, but I took this as encouragement to remove `GraphInvocation` from the app since we don't use it.

Thanks to the resolution of the import vs union issue, we can put tests anywhere.

The workflow library supersedes this unused feature.

Because we now customize the JSON Schema creation for GraphExecutionState, the model_config did nothing.

Consolidate graph processing logic into session processor. With graphs as the unit of work, and the session queue distributing graphs, we no longer need the invocation queue or processor. Instead, the session processor dequeues the next session and processes it in a simple loop, greatly simplifying the app. - Remove `graph_execution_manager` service. - Remove `queue` (invocation queue) service. - Remove `processor` (invocation processor) service. - Remove queue-related logic from `Invoker`. It now only starts and stops the services, providing them with access to other services. - Remove unused `invocation_retrieval_error` and `session_retrieval_error` events, these are no longer needed. - Clean up stats service now that it is less coupled to the rest of the app. - Refactor cancellation logic - cancellations now originate from session queue (i.e. HTTP cancel endpoint) and are emitted as events. Processor gets the events and sets the canceled event. Access to this event is provided to the invocation context for e.g. the step callback. - Remove `sessions` router; it provided access to `graph_executions` but that no longer exists.

No reason to not have the whole thing in there.

Changed within InvocationContext, for brevity.

…rable

was accessing incorrect properties in event data

- "test" to run pytests - "frontend-install" to reinstall pnpm's node modeuls

… download file on complete

…event to existing invoker tests

…ot the route

…or bulk download

`start`, `stop` and `__init__` are not required in implementations of an ABC or service.

These can be misleading as they shadow actual assigned class attributes. This pattern is in the rest of the app but it shouldn't be.

Double underscores are used in the app but it doesn't actually do or convey anything that single underscores don't already do. Considered unpythonic except for actual dunder/magic methods.

Just a bit cleaner.

…for board We can get all images for the board as a list of image names, then pass that to `_image_handler` to get the DTOs, decoupling from the pagination API.

Using the invoker object directly leaves no ambiguity as to what `_events_bus` actually is.

- Deduplicate the mock invocation services. This is possible now that the import order issue is resolved. - Merge `DummyEventService` into `TestEventService` and update all tests to use `TestEventService`.

- Use a single listener for all of the to keep them in one spot - Use the bulk download item name as a toast id so we can update the existing toasts - Update handling to work with other environments - Move all bulk download handling from components to listener

Notable updates: - Minor version of RTK includes customizable selectors for RTK Query, so we can remove the patch that was added to ensure only the LRU memoize function was used for perf reasons. Updated to use the LRU memoize function. - Major version of react-resizable-panels. No breaking changes, works great, and you can now resize all panels when dragging at the intersection point of panels. Cool! - Minor (?) version of nanostores. `action` API is removed, we were using it in one spot. Fixed. - @invoke-ai/eslint-config-react has all deps bumped and now has its dependent plugins/configs listed as normal dependencies (as opposed to peer deps). This means we can remove those packages from explicit dev deps.

…page

prevent lora and embedding file suffixes from being stripped during installation apply psychedelicious patch to get compel to load proper TI embedding

- Support extended HF repoid syntax in TUI. This allows installation of subfolders and safetensors files, as in `XpucT/Deliberate::Deliberate_v5.safetensors` - Add `error` and `error_traceback` properties to the install job objects. - Rename the `heuristic_import` route to `heuristic_install`. - Fix the example `config` input in the `heuristic_install` route.

- The new package has more useful types - Only used `JsonObject` from `type-fest`; added an implementation of that type

The setup of `ModelConfigBase` means autogenerated types have critical fields flagged as nullable (like `key` and `base`). Need to manually flag them as required.

Refactor of metadata recall handling. This is in preparation for a backwards compatibility layer for models. - Create helpers to fetch a model outside react (e.g. not in a hook) - Created helpers to parse model metadata - Renamed a lot of types that were confusing and/or had naming collisions

It's `Required` util does not distribute over unions as expected. Also we have `ts-toolbelt` already for some utils.

… messages

…dy installed This was done in the frontend before but it's something the backend should handle. The logic compares the found model paths to the path and source of all installed models. It excludes core models.

… models are installed already

Gets the first model that matches the given name, base and type. Raises 404 if there isn't one. This will be used for backwards compatibility with old metadata.

Add concepts for metadata handlers. Handlers include parsers, recallers and validators for different metadata types: - Parsers parse a raw metadata object of any shape to a structured object. - Recallers load the parsed metadata into state. Recallers are optional, as some metadata types don't need to be loaded into state. - Validators provide an additional layer of validation before recalling the metadata. This is needed because a metadata object may be valid, but not able to be recalled due to some other requirement, like base model compatibility. Validators are optional. Sometimes metadata is not a single object but a list of items - like LoRAs. Metadata handlers may implement an optional set of "item" handlers which operate on individual items in the list. Parsers and validators are async to allow fetching additional data, like a model config. Recallers are synchronous. The these handlers are composed into a public API, exported as a `handlers` object. Besides the handlers functions, a metadata handler set includes: - A function to get the label of the metadata type. - An optional function to render the value of the metadata type. - An optional function to render the _item_ value of the metadata type.

…nd to multiple of 8 This allows image dimensions that are not multiples of 8 to still be recalled with best effort.

When we retrieve a list of models, upsert that data into the `getModelConfig` and `getModelConfigByAttrs` query caches. With this change, calls to those two queries are almost always going to be free, because their caches will already have all models in them. The exception is queries for models that no longer exist.

- Move some files around - Use util to extract key and base from model config

LoRA model now at under `model` not `lora.

Model metadata includes the main model, VAE and refiner model. These used full model configs, as returned by the server, as their metadata type. LoRA and control adapter metadata only use the metadata identifier. This created a difference in handling. After parsing a model/vae/refiner, we have its name and can display it. But for LoRAs and control adapters, we only have the model key and must query for the full model config to get the name. This change makes main model/vae/refiner metadata only have the model key, like LoRAs and control adapters. The render function is now async so fetching can occur within it. All metadata fields with models now only contain the identifier, and fetch the model name to render their values.

These are the same as the existing control adapter types, but the model field is non-nullable, simplifying handling of these objects.

https://knip.dev/ Replaces `unimported`

- Only export when necessary - Remove totally usused functions, variables, state, etc - Remove unused packages

types and schemas

variables, types and schemas

unused files

Forgot to run `pnpm i` earlier after removing packages.

Knip should never touch the autogenerated types

The only major version is `query-string`. The breaking change for it is dropping support for old versions of node. Not a problem for us.

…ition to using keys

…eneration

Also remove ancient requirements file - the docs dependencies are in the pyproject.toml file.

Needs an `__init__.py`.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Next rebased #5836

Next rebased #5836

Commits on Feb 29, 2024