update logging

modules/deepbooru.py

@@ -16,7 +16,7 @@ class DeepDanbooru:
         if self.model is not None:
             return
         model_path = os.path.join(paths.models_path, "DeepDanbooru")
-        shared.log.debug(f'Loading interrogate model: type=DeepDanbooru folder="{model_path}"')
+        shared.log.debug(f'Load interrogate model: type=DeepDanbooru folder="{model_path}"')
         files = modelloader.load_models(
             model_path=model_path,
             model_url='https://github.com/AUTOMATIC1111/TorchDeepDanbooru/releases/download/v1/model-resnet_custom_v3.pt',

modules/extras.py

@@ -286,7 +286,7 @@ def run_modelconvert(model, checkpoint_formats, precision, conv_type, custom_nam
     }
     shared.state.begin('Convert')
     model_info = sd_models.checkpoints_list[model]
-    shared.state.textinfo = f"Loading {model_info.filename}..."
+    shared.state.textinfo = f"Load {model_info.filename}..."
     shared.log.info(f"Model convert loading: {model_info.filename}")
     state_dict = load_model(model_info.filename)
 

modules/images.py

@@ -14,7 +14,7 @@ from PIL import Image, PngImagePlugin, ExifTags
 from modules import sd_samplers, shared, script_callbacks, errors, paths
 from modules.images_grid import image_grid, split_grid, combine_grid, check_grid_size, get_font, draw_grid_annotations, draw_prompt_matrix, GridAnnotation, Grid # pylint: disable=unused-import
 from modules.images_resize import resize_image # pylint: disable=unused-import
-from modules.images_namegen import FilenameGenerator
+from modules.images_namegen import FilenameGenerator, get_next_sequence_number # pylint: disable=unused-import
 
 
 debug = errors.log.trace if os.environ.get('SD_PATH_DEBUG', None) is not None else lambda *args, **kwargs: None

modules/model_auraflow.py

@@ -11,7 +11,7 @@ def load_auraflow(checkpoint_info, diffusers_load_config={}):
     repo_id = sd_models.path_to_repo(checkpoint_info.name)
     if 'torch_dtype' not in diffusers_load_config:
         diffusers_load_config['torch_dtype'] = torch.float16
-    debug(f'Loading AuraFlow: repo="{repo_id}" config={diffusers_load_config}')
+    debug(f'Load model: type=AuraFlow repo="{repo_id}" config={diffusers_load_config}')
     pipe = diffusers.AuraFlowPipeline.from_pretrained(
         repo_id,
         cache_dir = shared.opts.diffusers_dir,

modules/model_stablecascade.py

@@ -44,7 +44,7 @@ def load_text_encoder(path):
             vocab_size=49408
         )
 
-        shared.log.info(f'Loading Text Encoder: name="{os.path.basename(os.path.splitext(path)[0])}" file="{path}"')
+        shared.log.info(f'Load Text Encoder: name="{os.path.basename(os.path.splitext(path)[0])}" file="{path}"')
 
         with init_empty_weights():
             text_encoder = CLIPTextModelWithProjection(config)
@@ -74,7 +74,7 @@ def load_prior(path, config_file="default"):
         else:
             config_file = "configs/stable-cascade/prior/config.json"
 
-    shared.log.info(f'Loading UNet: name="{os.path.basename(os.path.splitext(path)[0])}" file="{path}" config="{config_file}"')
+    shared.log.info(f'Load UNet: name="{os.path.basename(os.path.splitext(path)[0])}" file="{path}" config="{config_file}"')
     prior_unet = StableCascadeUNet.from_single_file(path, config=config_file, torch_dtype=devices.dtype_unet, cache_dir=shared.opts.diffusers_dir)
 
     if os.path.isfile(os.path.splitext(path)[0] + "_text_encoder.safetensors"): # OneTrainer

modules/processing.py

@@ -395,6 +395,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
 
         t1 = time.time()
         shared.log.info(f'Processed: images={len(output_images)} time={t1 - t0:.2f} its={(p.steps * len(output_images)) / (t1 - t0):.2f} memory={memstats.memory_stats()}')
+        from modules import timer
 
         p.color_corrections = None
         index_of_first_image = 0

modules/prompt_parser_diffusers.py

@@ -52,10 +52,10 @@ def sd3_compel_hijack(self, token_ids: torch.Tensor,
 def insert_parser_highjack(pipename):
     if "StableDiffusion3" in pipename:
         EmbeddingsProvider._encode_token_ids_to_embeddings = sd3_compel_hijack # pylint: disable=protected-access
-        debug("Loading SD3 Parser hijack")
+        debug("Load SD3 Parser hijack")
     else:
         EmbeddingsProvider._encode_token_ids_to_embeddings = compel_hijack # pylint: disable=protected-access
-        debug("Loading Standard Parser hijack")
+        debug("Load Standard Parser hijack")
 
 
 

modules/sd_models.py

@@ -382,13 +382,13 @@ def read_metadata_from_safetensors(filename):
     return res
 
 
-def read_state_dict(checkpoint_file, map_location=None): # pylint: disable=unused-argument
+def read_state_dict(checkpoint_file, map_location=None, what:str='model'): # pylint: disable=unused-argument
     if not os.path.isfile(checkpoint_file):
         shared.log.error(f'Load dict: path="{checkpoint_file}" not a file')
         return None
     try:
         pl_sd = None
-        with progress.open(checkpoint_file, 'rb', description=f'[cyan]Loading model: [yellow]{checkpoint_file}', auto_refresh=True, console=shared.console) as f:
+        with progress.open(checkpoint_file, 'rb', description=f'[cyan]Load {what}: [yellow]{checkpoint_file}', auto_refresh=True, console=shared.console) as f:
             _, extension = os.path.splitext(checkpoint_file)
             if extension.lower() == ".ckpt" and shared.opts.sd_disable_ckpt:
                 shared.log.warning(f"Checkpoint loading disabled: {checkpoint_file}")
@@ -424,7 +424,7 @@ def get_checkpoint_state_dict(checkpoint_info: CheckpointInfo, timer):
         shared.log.info("Load model: cache")
         checkpoints_loaded.move_to_end(checkpoint_info, last=True)  # FIFO -> LRU cache
         return checkpoints_loaded[checkpoint_info]
-    res = read_state_dict(checkpoint_info.filename)
+    res = read_state_dict(checkpoint_info.filename, what='model')
     if shared.opts.sd_checkpoint_cache > 0 and not shared.native:
         # cache newly loaded model
         checkpoints_loaded[checkpoint_info] = res
@@ -1803,7 +1803,7 @@ def reload_model_weights(sd_model=None, info=None, reuse_dict=False, op='model',
             return model_data.sd_refiner
 
     # fallback
-    shared.log.info(f"Loading using fallback: {op} model={checkpoint_info.title}")
+    shared.log.info(f"Load {op} using fallback: model={checkpoint_info.title}")
     try:
         load_model_weights(sd_model, checkpoint_info, state_dict, timer)
     except Exception:
@@ -1819,7 +1819,7 @@ def reload_model_weights(sd_model=None, info=None, reuse_dict=False, op='model',
             timer.record("device")
     shared.state.end()
     shared.state = orig_state
-    shared.log.info(f"Load: {op} time={timer.summary()}")
+    shared.log.info(f"Load {op}: time={timer.summary()}")
     return sd_model
 
 

modules/sd_vae.py

@@ -138,7 +138,7 @@ def resolve_vae(checkpoint_file):
 
 
 def load_vae_dict(filename):
-    vae_ckpt = sd_models.read_state_dict(filename)
+    vae_ckpt = sd_models.read_state_dict(filename, what='vae')
     vae_dict_1 = {k: v for k, v in vae_ckpt.items() if k[0:4] != "loss" and k not in vae_ignore_keys}
     return vae_dict_1
 
@@ -154,7 +154,7 @@ def load_vae(model, vae_file=None, vae_source="unknown-source"):
             vae_dict_1 = load_vae_dict(vae_file)
             _load_vae_dict(model, vae_dict_1)
         except Exception as e:
-            shared.log.error(f"Loading VAE failed: model={vae_file} source={vae_source} {e}")
+            shared.log.error(f"Load VAE failed: model={vae_file} source={vae_source} {e}")
             if debug:
                 errors.display(e, 'VAE')
             restore_base_vae(model)
@@ -236,7 +236,7 @@ def load_vae_diffusers(model_file, vae_file=None, vae_source="unknown-source"):
             sd_models.move_model(vae, devices.device)
         return vae
     except Exception as e:
-        shared.log.error(f"Loading VAE failed: model={vae_file} {e}")
+        shared.log.error(f"Load VAE failed: model={vae_file} {e}")
         if debug:
             errors.display(e, 'VAE')
     return None

modules/textual_inversion/textual_inversion.py

@@ -295,10 +295,10 @@ class EmbeddingDatabase:
                     embedding.tokens = []
                     self.skipped_embeddings[embedding.name] = embedding
             except Exception as e:
-                shared.log.error(f'Embedding invalid: name="{embedding.name}" fn="{filename}" {e}')
+                shared.log.error(f'Load embedding invalid: name="{embedding.name}" fn="{filename}" {e}')
                 self.skipped_embeddings[embedding.name] = embedding
         if overwrite:
-            shared.log.info(f"Loading Bundled embeddings: {list(data.keys())}")
+            shared.log.info(f"Load bundled embeddings: {list(data.keys())}")
             for embedding in embeddings:
                 if embedding.name not in self.skipped_embeddings:
                     deref_tokenizers(embedding.tokens, tokenizers)
@@ -309,7 +309,7 @@ class EmbeddingDatabase:
                     insert_vectors(embedding, tokenizers, text_encoders, hiddensizes)
                     self.register_embedding(embedding, shared.sd_model)
                 except Exception as e:
-                    shared.log.error(f'Embedding load: name="{embedding.name}" file="{embedding.filename}" {e}')
+                    shared.log.error(f'Load embedding: name="{embedding.name}" file="{embedding.filename}" {e}')
         return
 
     def load_from_file(self, path, filename):