Add configuration system, remove legacy globals, args, generate and CLI (#3340)

# Application-wide configuration service

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

Arguments and fields are taken from the pydantic definition of the
model. Defaults can be set by creating a yaml configuration file that
has a top-level key of "InvokeAI" and subheadings for each of the
categories returned by `invokeai --help`.

The file looks like this:

[file: invokeai.yaml]
```
InvokeAI:
  Paths:
    root: /home/lstein/invokeai-main
    conf_path: configs/models.yaml
    legacy_conf_dir: configs/stable-diffusion
    outdir: outputs
    embedding_dir: embeddings
    lora_dir: loras
    autoconvert_dir: null
    gfpgan_model_dir: models/gfpgan/GFPGANv1.4.pth
  Models:
    model: stable-diffusion-1.5
    embeddings: true
  Memory/Performance:
    xformers_enabled: false
    sequential_guidance: false
    precision: float16
    max_loaded_models: 4
    always_use_cpu: false
    free_gpu_mem: false
  Features:
    nsfw_checker: true
    restore: true
    esrgan: true
    patchmatch: true
    internet_available: true
    log_tokenization: false
  Cross-Origin Resource Sharing:
    allow_origins: []
    allow_credentials: true
    allow_methods:
    - '*'
    allow_headers:
    - '*'
  Web Server:
    host: 127.0.0.1
    port: 8081

```

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

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

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

By default, InvokeAIAppConfig will parse the contents of `sys.argv` at
initialization time. You may pass a list of strings in the optional
`argv` argument to use instead of the system argv:

```
conf = InvokeAIAppConfig(arg=['--xformers_enabled'])
```

It is also possible to set a value at initialization time. This value
has highest priority.
```
conf = InvokeAIAppConfig(xformers_enabled=True)
```
Any setting can be overwritten by setting an environment variable of
form: "INVOKEAI_<setting>", as in:

```
export INVOKEAI_port=8080
```

Order of precedence (from highest):
   1) initialization options
   2) command line options
   3) environment variable options
   4) config file options
   5) pydantic defaults

Typical usage:

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

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

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

# Legacy code removal and porting

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

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

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

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

Author: lstein

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

@@ -80,12 +80,7 @@ jobs:
         uses: actions/checkout@v3
 
       - name: set test prompt to main branch validation
-        if: ${{ github.ref == 'refs/heads/main' }}
-        run: echo "TEST_PROMPTS=tests/preflight_prompts.txt" >> ${{ matrix.github-env }}
-
-      - name: set test prompt to Pull Request validation
-        if: ${{ github.ref != 'refs/heads/main' }}
-        run: echo "TEST_PROMPTS=tests/validate_pr_prompt.txt" >> ${{ matrix.github-env }}
+        run:echo "TEST_PROMPTS=tests/validate_pr_prompt.txt" >> ${{ matrix.github-env }}
 
       - name: setup python
         uses: actions/setup-python@v4
@@ -105,12 +100,6 @@ jobs:
         id: run-pytest
         run: pytest
 
-      - name: set INVOKEAI_OUTDIR
-        run: >
-          python -c
-          "import os;from invokeai.backend.globals import Globals;OUTDIR=os.path.join(Globals.root,str('outputs'));print(f'INVOKEAI_OUTDIR={OUTDIR}')"
-          >> ${{ matrix.github-env }}
-
       - name: run invokeai-configure
         id: run-preload-models
         env:
@@ -129,15 +118,20 @@ jobs:
           HF_HUB_OFFLINE: 1
           HF_DATASETS_OFFLINE: 1
           TRANSFORMERS_OFFLINE: 1
+          INVOKEAI_OUTDIR: ${{ github.workspace }}/results
         run: >
           invokeai
           --no-patchmatch
           --no-nsfw_checker
-          --from_file ${{ env.TEST_PROMPTS }}
+          --precision=float32
+          --always_use_cpu
           --outdir ${{ env.INVOKEAI_OUTDIR }}/${{ matrix.python-version }}/${{ matrix.pytorch }}
+          --from_file ${{ env.TEST_PROMPTS }}
 
       - name: Archive results
         id: archive-results
+        env:
+          INVOKEAI_OUTDIR: ${{ github.workspace }}/results
         uses: actions/upload-artifact@v3
         with:
           name: results

.gitignore

@@ -201,6 +201,8 @@ checkpoints
 # If it's a Mac
 .DS_Store
 
+invokeai/frontend/web/dist/*
+
 # Let the frontend manage its own gitignore
 !invokeai/frontend/web/*
 

invokeai/app/api/dependencies.py

@@ -7,7 +7,6 @@
 
 from ..services.default_graphs import create_system_graphs
 from ..services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
-from ...backend import Globals
 from ..services.model_manager_initializer import get_model_manager
 from ..services.restoration_services import RestorationServices
 from ..services.graph import GraphExecutionState, LibraryGraph
@@ -42,17 +41,8 @@ class ApiDependencies:
 
     invoker: Invoker = None
 
-    @staticmethod
     def initialize(config, event_handler_id: int, logger: types.ModuleType=logger):
-        Globals.try_patchmatch = config.patchmatch
-        Globals.always_use_cpu = config.always_use_cpu
-        Globals.internet_available = config.internet_available and check_internet()
-        Globals.disable_xformers = not config.xformers
-        Globals.ckpt_convert = config.ckpt_convert
-
-        # TO DO: Use the config to select the logger rather than use the default
-        # invokeai logging module
-        logger.info(f"Internet connectivity is {Globals.internet_available}")
+        logger.info(f"Internet connectivity is {config.internet_available}")
 
         events = FastAPIEventService(event_handler_id)
 
@@ -72,7 +62,6 @@ def initialize(config, event_handler_id: int, logger: types.ModuleType=logger):
         services = InvocationServices(
             model_manager=get_model_manager(config,logger),
             events=events,
-            logger=logger,
             latents=latents,
             images=images,
             metadata=metadata,
@@ -85,6 +74,8 @@ def initialize(config, event_handler_id: int, logger: types.ModuleType=logger):
             ),
             processor=DefaultInvocationProcessor(),
             restoration=RestorationServices(config,logger),
+            configuration=config,
+            logger=logger,
         )
 
         create_system_graphs(services.graph_library)

invokeai/app/api_app.py

@@ -13,11 +13,11 @@
 from fastapi_events.middleware import EventHandlerASGIMiddleware
 from pydantic.schema import schema
 
-from ..backend import Args
 from .api.dependencies import ApiDependencies
 from .api.routers import images, sessions, models
 from .api.sockets import SocketIO
 from .invocations.baseinvocation import BaseInvocation
+from .services.config import InvokeAIAppConfig
 
 # Create the app
 # TODO: create this all in a method so configuration/etc. can be passed in?
@@ -33,30 +33,25 @@
     middleware_id=event_handler_id,
 )
 
-# Add CORS
-# TODO: use configuration for this
-origins = []
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
 socket_io = SocketIO(app)
 
-config = {}
-
+# initialize config
+# this is a module global
+app_config = InvokeAIAppConfig()
 
 # Add startup event to load dependencies
 @app.on_event("startup")
 async def startup_event():
-    config = Args()
-    config.parse_args()
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=app_config.allow_origins,
+        allow_credentials=app_config.allow_credentials,
+        allow_methods=app_config.allow_methods,
+        allow_headers=app_config.allow_headers,
+    )
 
     ApiDependencies.initialize(
-        config=config, event_handler_id=event_handler_id, logger=logger
+        config=app_config, event_handler_id=event_handler_id, logger=logger
     )
 
 
@@ -148,14 +143,11 @@ def overridden_redoc():
 
 def invoke_api():
     # Start our own event loop for eventing usage
-    # TODO: determine if there's a better way to do this
     loop = asyncio.new_event_loop()
-    config = uvicorn.Config(app=app, host="0.0.0.0", port=9090, loop=loop)
+    config = uvicorn.Config(app=app, host=app_config.host, port=app_config.port, loop=loop)
     # Use access_log to turn off logging
-
     server = uvicorn.Server(config)
     loop.run_until_complete(server.serve())
 
-
 if __name__ == "__main__":
     invoke_api()

invokeai/app/cli/commands.py

@@ -285,3 +285,19 @@ def run(self, context: CliContext) -> None:
         nx.draw_networkx_labels(nxgraph, pos, font_size=20, font_family="sans-serif")
         plt.axis("off")
         plt.show()
+
+class SortedHelpFormatter(argparse.HelpFormatter):
+    def _iter_indented_subactions(self, action):
+        try:
+            get_subactions = action._get_subactions
+        except AttributeError:
+            pass
+        else:
+            self._indent()
+            if isinstance(action, argparse._SubParsersAction):
+                for subaction in sorted(get_subactions(), key=lambda x: x.dest):
+                    yield subaction
+            else:
+                for subaction in get_subactions():
+                    yield subaction
+                self._dedent()

invokeai/app/cli/completer.py

@@ -11,9 +11,10 @@
 from typing import List, Dict, Literal, get_args, get_type_hints, get_origin
 
 import invokeai.backend.util.logging as logger
-from ...backend import ModelManager, Globals
+from ...backend import ModelManager
 from ..invocations.baseinvocation import BaseInvocation
 from .commands import BaseCommand
+from ..services.invocation_services import InvocationServices
 
 # singleton object, class variable
 completer = None
@@ -131,13 +132,13 @@ def _pre_input_hook(self):
             readline.redisplay()
             self.linebuffer = None
 
-def set_autocompleter(model_manager: ModelManager) -> Completer:
+def set_autocompleter(services: InvocationServices) -> Completer:
     global completer
 
     if completer:
         return completer
 
-    completer = Completer(model_manager)
+    completer = Completer(services.model_manager)
 
     readline.set_completer(completer.complete)
     # pyreadline3 does not have a set_auto_history() method
@@ -153,7 +154,7 @@ def set_autocompleter(model_manager: ModelManager) -> Completer:
     readline.parse_and_bind("set skip-completed-text on")
     readline.parse_and_bind("set show-all-if-ambiguous on")
 
-    histfile = Path(Globals.root, ".invoke_history")
+    histfile = Path(services.configuration.root_dir / ".invoke_history")
     try:
         readline.read_history_file(histfile)
         readline.set_history_length(1000)

invokeai/app/cli_app.py

@@ -4,13 +4,14 @@
 import os
 import re
 import shlex
+import sys
 import time
 from typing import (
     Union,
     get_type_hints,
 )
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 from pydantic.fields import Field
 
 
@@ -19,8 +20,7 @@
 from .services.default_graphs import create_system_graphs
 from .services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
 
-from ..backend import Args
-from .cli.commands import BaseCommand, CliContext, ExitCli, add_graph_parsers, add_parsers
+from .cli.commands import BaseCommand, CliContext, ExitCli, add_graph_parsers, add_parsers, SortedHelpFormatter
 from .cli.completer import set_autocompleter
 from .invocations.baseinvocation import BaseInvocation
 from .services.events import EventServiceBase
@@ -34,7 +34,7 @@
 from .services.invoker import Invoker
 from .services.processor import DefaultInvocationProcessor
 from .services.sqlite import SqliteItemStorage
-
+from .services.config import get_invokeai_config
 
 class CliCommand(BaseModel):
     command: Union[BaseCommand.get_commands() + BaseInvocation.get_invocations()] = Field(discriminator="type")  # type: ignore
@@ -64,7 +64,7 @@ def add_invocation_args(command_parser):
 
 def get_command_parser(services: InvocationServices) -> argparse.ArgumentParser:
     # Create invocation parser
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(formatter_class=SortedHelpFormatter)
 
     def exit(*args, **kwargs):
         raise InvalidArgs
@@ -189,24 +189,25 @@ def invoke_all(context: CliContext):
 
 
 def invoke_cli():
-    config = Args()
-    config.parse_args()
+    # this gets the basic configuration
+    config = get_invokeai_config()
+
+    # get the optional list of invocations to execute on the command line
+    parser = config.get_parser()
+    parser.add_argument('commands',nargs='*')
+    invocation_commands = parser.parse_args().commands
+
+    # get the optional file to read commands from.
+    # Simplest is to use it for STDIN
+    if infile := config.from_file:
+        sys.stdin = open(infile,"r")
+    
     model_manager = get_model_manager(config,logger=logger)
-
-    # This initializes the autocompleter and returns it.
-    # Currently nothing is done with the returned Completer
-    # object, but the object can be used to change autocompletion
-    # behavior on the fly, if desired.
-    set_autocompleter(model_manager)
-
+    
     events = EventServiceBase()
-
+    output_folder = config.output_path
     metadata = PngMetadataService()
 
-    output_folder = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), "../../../outputs")
-    )
-
     # TODO: build a file/path manager?
     db_location = os.path.join(output_folder, "invokeai.db")
 
@@ -226,6 +227,7 @@ def invoke_cli():
         processor=DefaultInvocationProcessor(),
         restoration=RestorationServices(config,logger=logger),
         logger=logger,
+        configuration=config,
     )
 
     system_graphs = create_system_graphs(services.graph_library)
@@ -241,10 +243,18 @@ def invoke_cli():
     # print(services.session_manager.list())
 
     context = CliContext(invoker, session, parser)
+    set_autocompleter(services)
 
-    while True:
+    command_line_args_exist = len(invocation_commands) > 0
+    done = False
+    
+    while not done:
         try:
-            cmd_input = input("invoke> ")
+            if command_line_args_exist:
+                cmd_input = invocation_commands.pop(0)
+                done = len(invocation_commands) == 0
+            else:
+                cmd_input = input("invoke> ")
         except (KeyboardInterrupt, EOFError):
             # Ctrl-c exits
             break
@@ -368,6 +378,9 @@ def invoke_cli():
             invoker.services.logger.warning('Invalid command, use "help" to list commands')
             continue
 
+        except ValidationError:
+            invoker.services.logger.warning('Invalid command arguments, run "<command> --help" for summary')
+
         except SessionError:
             # Start a new session
             invoker.services.logger.warning("Session error: creating a new session")

invokeai/app/invocations/compel.py

@@ -16,8 +16,6 @@
     Fragment,
 )
 
-from invokeai.backend.globals import Globals
-
 
 class ConditioningField(BaseModel):
     conditioning_name: Optional[str] = Field(default=None, description="The name of conditioning data")
@@ -103,7 +101,7 @@ def load_huggingface_concepts(concepts: list[str]):
         conjunction = Compel.parse_prompt_string(prompt_str)
         prompt: Union[FlattenedPrompt, Blend] = conjunction.prompts[0]
 
-        if getattr(Globals, "log_tokenization", False):
+        if context.services.configuration.log_tokenization:
             log_tokenization_for_prompt_object(prompt, tokenizer)
 
         c, options = compel.build_conditioning_tensor_for_prompt_object(prompt)