add cmdopt status

Signed-off-by: Vladimir Mandic <mandic00@live.com>

CHANGELOG.md

@@ -24,13 +24,14 @@
   - params: Reset default guidance-rescale from 0.7 to 0.0  
   - progress: add additional fields to progress API  
 - **Fixes**  
-  - Logging: logging cleanup  
-  - Styles: resize and bring quick-ui to forward on hover  
-  - LoRA obey configured device when performing calculations  
-  - ZLUDA startup issues  
-  - balanced offload remove non-blocking move op  
-  - debug logging causes invalid import  
-  - UI progress allow for longer timeouts  
+  - styles: resize and bring quick-ui to forward on hover  
+  - LoRA: obey configured device when performing calculations  
+  - ZLUDA: startup issues  
+  - offload: balanced offload remove non-blocking move op  
+  - logging: debug causes invalid import  
+  - logging: cleanup  
+  - ui: progress allow for longer timeouts  
+  - internal: cleanup defined pipelines
 
 ## Update for 2025-04-03
 

installer.py

@@ -1486,12 +1486,13 @@ def add_args(parser):
     group_diag.add_argument('--test', default=os.environ.get("SD_TEST",False), action='store_true', help="Run test only and exit")
     group_diag.add_argument('--version', default=False, action='store_true', help="Print version information")
     group_diag.add_argument('--ignore', default=os.environ.get("SD_IGNORE",False), action='store_true', help="Ignore any errors and attempt to continue")
+    group_diag.add_argument("--monitor", default=os.environ.get("SD_MONITOR", 0), help="Run memory monitor, default: %(default)s")
+    group_diag.add_argument("--status", default=os.environ.get("SD_STATUS", 120), help="Run server is-alive status, default: %(default)s")
 
     group_log = parser.add_argument_group('Logging')
     group_log.add_argument("--log", type=str, default=os.environ.get("SD_LOG", None), help="Set log file, default: %(default)s")
     group_log.add_argument('--debug', default=os.environ.get("SD_DEBUG",False), action='store_true', help="Run installer with debug logging, default: %(default)s")
     group_log.add_argument("--profile", default=os.environ.get("SD_PROFILE", False), action='store_true', help="Run profiler, default: %(default)s")
-    group_log.add_argument("--monitor", default=os.environ.get("SD_PROFILE", 0), help="Run memory monitor, default: %(default)s")
     group_log.add_argument('--docs', default=os.environ.get("SD_DOCS", False), action='store_true', help="Mount API docs, default: %(default)s")
     group_log.add_argument("--api-log", default=os.environ.get("SD_APILOG", True), action='store_true', help="Log all API requests")
 

launch.py

@@ -274,7 +274,7 @@ def main():
             alive = False
             requests = 0
         t_current = time.time()
-        if t_current - t_server > 120:
+        if float(args.status) > 0 and t_current - t_server > float(args.status):
             installer.log.trace(f'Server: alive={alive} requests={requests} memory={get_memory_stats()} {instance.state.status()}')
             t_server = t_current
         if float(args.monitor) > 0 and t_current - t_monitor > float(args.monitor):

modules/cmd_args.py

@@ -37,7 +37,8 @@ def main_args():
     group_diag.add_argument("--no-hashing", default=os.environ.get("SD_NOHASHING", False), action='store_true', help="Disable hashing of checkpoints, default: %(default)s")
     group_diag.add_argument("--no-metadata", default=os.environ.get("SD_NOMETADATA", False), action='store_true', help="Disable reading of metadata from models, default: %(default)s")
     group_diag.add_argument("--profile", default=os.environ.get("SD_PROFILE", False), action='store_true', help="Run profiler, default: %(default)s")
-    group_diag.add_argument("--monitor", default=os.environ.get("SD_PROFILE", 0), help="Run memory monitor, default: %(default)s")
+    group_diag.add_argument("--monitor", default=os.environ.get("SD_MONITOR", 0), help="Run memory monitor, default: %(default)s")
+    group_diag.add_argument("--status", default=os.environ.get("SD_STATUS", 120), help="Run server is-alive status, default: %(default)s")
 
     group_http = parser.add_argument_group('HTTP')
     group_http.add_argument('--theme', type=str, default=os.environ.get("SD_THEME", None), help='Override UI theme')

modules/model_meissonic.py

@@ -3,12 +3,13 @@ import diffusers
 
 
 def load_meissonic(checkpoint_info, diffusers_load_config={}):
-    from modules import shared, devices, modelloader, sd_models
+    from modules import shared, devices, modelloader, sd_models, shared_items
     from modules.meissonic.transformer import Transformer2DModel as TransformerMeissonic
     from modules.meissonic.scheduler import Scheduler as MeissonicScheduler
     from modules.meissonic.pipeline import Pipeline as PipelineMeissonic
     from modules.meissonic.pipeline_img2img import Img2ImgPipeline as PipelineMeissonicImg2Img
     from modules.meissonic.pipeline_inpaint import InpaintPipeline as PipelineMeissonicInpaint
+    shared_items.pipelines['Meissonic'] = PipelineMeissonic
 
     modelloader.hf_login()
     fn = sd_models.path_to_repo(checkpoint_info.path)

modules/model_omnigen.py

@@ -1,9 +1,10 @@
 def load_omnigen(checkpoint_info, diffusers_load_config={}): # pylint: disable=unused-argument
-    from modules import shared, devices, sd_models
+    from modules import shared, devices, sd_models, shared_items
     repo_id = sd_models.path_to_repo(checkpoint_info.name)
 
     # load
     from modules.omnigen import OmniGenPipeline
+    shared_items.pipelines['OmniGen'] = OmniGenPipeline
     pipe = OmniGenPipeline.from_pretrained(
         model_name=repo_id,
         vae_path='madebyollin/sdxl-vae-fp16-fix',

modules/sd_detect.py

@@ -56,7 +56,7 @@ def detect_pipeline(f: str, op: str = 'model', warning=True, quiet=False):
             if 'hunyuandit' in f.lower():
                 guess = 'HunyuanDiT'
             if 'pixart-xl' in f.lower():
-                guess = 'PixArt-Alpha'
+                guess = 'PixArt Alpha'
             if 'stable-diffusion-3' in f.lower():
                 guess = 'Stable Diffusion 3'
             if 'stable-cascade' in f.lower() or 'stablecascade' in f.lower() or 'wuerstchen3' in f.lower() or ('sotediffusion' in f.lower() and "v2" in f.lower()):
@@ -64,7 +64,7 @@ def detect_pipeline(f: str, op: str = 'model', warning=True, quiet=False):
                     warn('Stable Cascade does not support Float16')
                 guess = 'Stable Cascade'
             if 'pixart-sigma' in f.lower():
-                guess = 'PixArt-Sigma'
+                guess = 'PixArt Sigma'
             if 'sana' in f.lower():
                 guess = 'Sana'
             if 'lumina-next' in f.lower():
@@ -76,9 +76,9 @@ def detect_pipeline(f: str, op: str = 'model', warning=True, quiet=False):
             if 'auraflow' in f.lower():
                 guess = 'AuraFlow'
             if 'cogview3' in f.lower():
-                guess = 'CogView3'
+                guess = 'CogView 3'
             if 'cogview4' in f.lower():
-                guess = 'CogView4'
+                guess = 'CogView 4'
             if 'meissonic' in f.lower():
                 guess = 'Meissonic'
                 pipeline = 'custom'

modules/sd_models.py

@@ -10,7 +10,7 @@ import diffusers.loaders.single_file_utils
 import torch
 
 from installer import log
-from modules import paths, shared, shared_state, modelloader, devices, script_callbacks, sd_vae, sd_unet, errors, sd_models_config, sd_models_compile, sd_hijack_accelerate, sd_detect, model_quant
+from modules import paths, shared, shared_state, shared_items, modelloader, devices, script_callbacks, sd_vae, sd_unet, errors, sd_models_config, sd_models_compile, sd_hijack_accelerate, sd_detect, model_quant
 from modules.timer import Timer, process as process_timer
 from modules.memstats import memory_stats
 from modules.modeldata import model_data
@@ -282,12 +282,14 @@ def load_diffuser_force(model_type, checkpoint_info, diffusers_load_config, op='
             sd_model = load_cascade_combined(checkpoint_info, diffusers_load_config)
         elif model_type in ['InstaFlow']: # forced pipeline
             pipeline = diffusers.utils.get_class_from_dynamic_module('instaflow_one_step', module_file='pipeline.py')
+            shared_items.pipelines['InstaFlow'] = pipeline
             sd_model = pipeline.from_pretrained(checkpoint_info.path, cache_dir=shared.opts.diffusers_dir, **diffusers_load_config)
         elif model_type in ['SegMoE']: # forced pipeline
             from modules.segmoe.segmoe_model import SegMoEPipeline
             sd_model = SegMoEPipeline(checkpoint_info.path, cache_dir=shared.opts.diffusers_dir, **diffusers_load_config)
             sd_model = sd_model.pipe # segmoe pipe does its stuff in __init__ and __call__ is the original pipeline
-        elif model_type in ['PixArt-Sigma']: # forced pipeline
+            shared_items.pipelines['SegMoE'] = SegMoEPipeline
+        elif model_type in ['PixArt Sigma']: # forced pipeline
             from modules.model_pixart import load_pixart
             sd_model = load_pixart(checkpoint_info, diffusers_load_config)
         elif model_type in ['Sana']: # forced pipeline
@@ -311,10 +313,10 @@ def load_diffuser_force(model_type, checkpoint_info, diffusers_load_config, op='
         elif model_type in ['Stable Diffusion 3']:
             from modules.model_sd3 import load_sd3
             sd_model = load_sd3(checkpoint_info, cache_dir=shared.opts.diffusers_dir, config=diffusers_load_config.get('config', None))
-        elif model_type in ['CogView3']: # forced pipeline
+        elif model_type in ['CogView 3']: # forced pipeline
             from modules.model_cogview import load_cogview3
             sd_model = load_cogview3(checkpoint_info, diffusers_load_config)
-        elif model_type in ['CogView4']: # forced pipeline
+        elif model_type in ['CogView 4']: # forced pipeline
             from modules.model_cogview import load_cogview4
             sd_model = load_cogview4(checkpoint_info, diffusers_load_config)
         elif model_type in ['Meissonic']: # forced pipeline

modules/shared_items.py

@@ -1,3 +1,52 @@
+import diffusers
+
+
+pipelines = {
+    # note: not all pipelines can be used manually as they require prior pipeline next to decoder pipeline
+    'Autodetect': None,
+    'Custom Diffusers Pipeline': getattr(diffusers, 'DiffusionPipeline', None),
+
+    # standard pipelines
+    'Stable Diffusion 1.5': getattr(diffusers, 'StableDiffusionPipeline', None),
+    'Stable Diffusion 2.x': getattr(diffusers, 'StableDiffusionPipeline', None),
+    'Stable Diffusion Upscale': getattr(diffusers, 'StableDiffusionUpscalePipeline', None),
+    'Stable Diffusion XL': getattr(diffusers, 'StableDiffusionXLPipeline', None),
+    'Stable Cascade': getattr(diffusers, 'StableCascadeCombinedPipeline', None),
+    'Stable Diffusion 3.x': getattr(diffusers, 'StableDiffusion3Pipeline', None),
+    'Latent Consistency Model': getattr(diffusers, 'LatentConsistencyModelPipeline', None),
+    'PixArt Alpha': getattr(diffusers, 'PixArtAlphaPipeline', None),
+    'PixArt Sigma': getattr(diffusers, 'PixArtSigmaPipeline', None),
+    'HunyuanDiT': getattr(diffusers, 'HunyuanDiTPipeline', None),
+    'DeepFloyd IF': getattr(diffusers, 'IFPipeline', None),
+    'FLUX': getattr(diffusers, 'FluxPipeline', None),
+    'Sana': getattr(diffusers, 'SanaPipeline', None),
+    'Lumina-Next': getattr(diffusers, 'LuminaText2ImgPipeline', None),
+    'Lumina 2': getattr(diffusers, 'Lumina2Text2ImgPipeline', None),
+    'AuraFlow': getattr(diffusers, 'AuraFlowPipeline', None),
+    'Kandinsky 2.1': getattr(diffusers, 'KandinskyCombinedPipeline', None),
+    'Kandinsky 2.2': getattr(diffusers, 'KandinskyV22CombinedPipeline', None),
+    'Kandinsky 3.0': getattr(diffusers, 'Kandinsky3Pipeline', None),
+    'Wuerstchen': getattr(diffusers, 'WuerstchenCombinedPipeline', None),
+    'Kolors': getattr(diffusers, 'KolorsPipeline', None),
+    'CogView 3': getattr(diffusers, 'CogView3PlusPipeline', None),
+    'CogView 4': getattr(diffusers, 'CogView4Pipeline', None),
+    'UniDiffuser': getattr(diffusers, 'UniDiffuserPipeline', None),
+    'Amused': getattr(diffusers, 'AmusedPipeline', None),
+
+    # dynamically imported and redefined later
+    'Meissonic': getattr(diffusers, 'StableDiffusionPipeline', None), # dynamically redefined and loaded in sd_models.load_diffuser
+    'OmniGenPipeline': getattr(diffusers, 'StableDiffusionPipeline', None), # dynamically redefined and loaded in sd_models.load_diffuser
+    'InstaFlow': getattr(diffusers, 'StableDiffusionPipeline', None), # dynamically redefined and loaded in sd_models.load_diffuser
+    'SegMoE': getattr(diffusers, 'StableDiffusionPipeline', None), # dynamically redefined and loaded in sd_models.load_diffuser
+}
+onnx_pipelines = {
+    'ONNX Stable Diffusion': getattr(diffusers, 'OnnxStableDiffusionPipeline', None),
+    'ONNX Stable Diffusion Img2Img': getattr(diffusers, 'OnnxStableDiffusionImg2ImgPipeline', None),
+    'ONNX Stable Diffusion Inpaint': getattr(diffusers, 'OnnxStableDiffusionInpaintPipeline', None),
+    'ONNX Stable Diffusion Upscale': getattr(diffusers, 'OnnxStableDiffusionUpscalePipeline', None),
+}
+
+
 def postprocessing_scripts():
     import modules.scripts
     return modules.scripts.scripts_postproc.scripts
@@ -38,8 +87,8 @@ def refresh_te_list():
     modules.model_te.refresh_te_list()
 
 
-def list_crossattention(diffusers=False):
-    if diffusers:
+def list_crossattention(native:bool=True):
+    if native:
         return [
             "Disabled",
             "Scaled-Dot-Product",
@@ -60,67 +109,9 @@ def list_crossattention(diffusers=False):
         ]
 
 def get_pipelines():
-    import diffusers
     from installer import log
-
-    pipelines = { # note: not all pipelines can be used manually as they require prior pipeline next to decoder pipeline
-        'Autodetect': None,
-        'Stable Diffusion': getattr(diffusers, 'StableDiffusionPipeline', None),
-        'Stable Diffusion 2': getattr(diffusers, 'StableDiffusionPipeline', None),
-        'Stable Diffusion Inpaint': getattr(diffusers, 'StableDiffusionInpaintPipeline', None),
-        'Stable Diffusion Img2Img': getattr(diffusers, 'StableDiffusionImg2ImgPipeline', None),
-        'Stable Diffusion Instruct': getattr(diffusers, 'StableDiffusionInstructPix2PixPipeline', None),
-        'Stable Diffusion Upscale': getattr(diffusers, 'StableDiffusionUpscalePipeline', None),
-        'Stable Diffusion XL': getattr(diffusers, 'StableDiffusionXLPipeline', None),
-        'Stable Diffusion XL Refiner': getattr(diffusers, 'StableDiffusionXLImg2ImgPipeline', None),
-        'Stable Diffusion XL Img2Img': getattr(diffusers, 'StableDiffusionXLImg2ImgPipeline', None),
-        'Stable Diffusion XL Inpaint': getattr(diffusers, 'StableDiffusionXLInpaintPipeline', None),
-        'Stable Diffusion XL Instruct': getattr(diffusers, 'StableDiffusionXLInstructPix2PixPipeline', None),
-        'Latent Consistency Model': getattr(diffusers, 'LatentConsistencyModelPipeline', None),
-        'PixArt-Alpha': getattr(diffusers, 'PixArtAlphaPipeline', None),
-        'UniDiffuser': getattr(diffusers, 'UniDiffuserPipeline', None),
-        'Wuerstchen': getattr(diffusers, 'WuerstchenCombinedPipeline', None),
-        'Kandinsky 2.1': getattr(diffusers, 'KandinskyPipeline', None),
-        'Kandinsky 2.2': getattr(diffusers, 'KandinskyV22Pipeline', None),
-        'Kandinsky 3': getattr(diffusers, 'Kandinsky3Pipeline', None),
-        'DeepFloyd IF': getattr(diffusers, 'IFPipeline', None),
-        'Custom Diffusers Pipeline': getattr(diffusers, 'DiffusionPipeline', None),
-        'InstaFlow': getattr(diffusers, 'StableDiffusionPipeline', None), # dynamically redefined and loaded in sd_models.load_diffuser
-        'SegMoE': getattr(diffusers, 'StableDiffusionPipeline', None), # dynamically redefined and loaded in sd_models.load_diffuser
-        'Kolors': getattr(diffusers, 'KolorsPipeline', None),
-        'AuraFlow': getattr(diffusers, 'AuraFlowPipeline', None),
-        'CogView3': getattr(diffusers, 'CogView3PlusPipeline', None),
-        'CogView4': getattr(diffusers, 'CogView4Pipeline', None),
-        'Stable Cascade': getattr(diffusers, 'StableCascadeCombinedPipeline', None),
-        'PixArt-Sigma': getattr(diffusers, 'PixArtSigmaPipeline', None),
-        'HunyuanDiT': getattr(diffusers, 'HunyuanDiTPipeline', None),
-        'Stable Diffusion 3': getattr(diffusers, 'StableDiffusion3Pipeline', None),
-        'Stable Diffusion 3 Img2Img': getattr(diffusers, 'StableDiffusion3Img2ImgPipeline', None),
-        'Lumina-Next': getattr(diffusers, 'LuminaText2ImgPipeline', None),
-        'FLUX': getattr(diffusers, 'FluxPipeline', None),
-        'Sana': getattr(diffusers, 'SanaPAGPipeline', None),
-    }
-    if hasattr(diffusers, 'OnnxStableDiffusionPipeline'):
-        onnx_pipelines = {
-            'ONNX Stable Diffusion': getattr(diffusers, 'OnnxStableDiffusionPipeline', None),
-            'ONNX Stable Diffusion Img2Img': getattr(diffusers, 'OnnxStableDiffusionImg2ImgPipeline', None),
-            'ONNX Stable Diffusion Inpaint': getattr(diffusers, 'OnnxStableDiffusionInpaintPipeline', None),
-            'ONNX Stable Diffusion Upscale': getattr(diffusers, 'OnnxStableDiffusionUpscalePipeline', None),
-        }
+    if hasattr(diffusers, 'OnnxStableDiffusionPipeline') and 'ONNX Stable Diffusion' not in list(pipelines):
         pipelines.update(onnx_pipelines)
-    if hasattr(diffusers, 'OnnxStableDiffusionXLPipeline'):
-        onnx_pipelines = {
-            'ONNX Stable Diffusion XL': getattr(diffusers, 'OnnxStableDiffusionXLPipeline', None),
-            'ONNX Stable Diffusion XL Img2Img': getattr(diffusers, 'OnnxStableDiffusionXLImg2ImgPipeline', None),
-        }
-        pipelines.update(onnx_pipelines)
-
-    # items that may rely on diffusers dev version
-    """
-    if hasattr(diffusers, 'FluxPipeline'):
-        pipelines['FLUX'] = getattr(diffusers, 'FluxPipeline', None)
-    """
-
     for k, v in pipelines.items():
         if k != 'Autodetect' and v is None:
             log.error(f'Not available: pipeline={k} diffusers={diffusers.__version__} path={diffusers.__file__}')