Merge branch 'main_upstream' into feature/add-nsfw-filter

modules/async_worker.py

@@ -34,6 +34,7 @@ def worker():
     import modules.advanced_parameters as advanced_parameters
     import extras.ip_adapter as ip_adapter
     import extras.face_crop
+    import fooocus_version
 
     from modules.censor import censor_batch
     from modules.sdxl_styles import apply_style, apply_wildcards, fooocus_expansion
@@ -281,9 +282,10 @@ def worker():
                 inpaint_image = HWC3(inpaint_image)
                 if isinstance(inpaint_image, np.ndarray) and isinstance(inpaint_mask, np.ndarray) \
                         and (np.any(inpaint_mask > 127) or len(outpaint_selections) > 0):
+                    progressbar(async_task, 1, 'Downloading upscale models ...')
+                    modules.config.downloading_upscale_model()
                     if inpaint_parameterized:
                         progressbar(async_task, 1, 'Downloading inpainter ...')
-                        modules.config.downloading_upscale_model()
                         inpaint_head_model_path, inpaint_patch_model_path = modules.config.downloading_inpaint_models(
                             advanced_parameters.inpaint_engine)
                         base_model_additional_loras += [(inpaint_patch_model_path, 1.0)]
@@ -401,8 +403,8 @@ def worker():
                     uc=None,
                     positive_top_k=len(positive_basic_workloads),
                     negative_top_k=len(negative_basic_workloads),
-                    log_positive_prompt='; '.join([task_prompt] + task_extra_positive_prompts),
-                    log_negative_prompt='; '.join([task_negative_prompt] + task_extra_negative_prompts),
+                    log_positive_prompt='\n'.join([task_prompt] + task_extra_positive_prompts),
+                    log_negative_prompt='\n'.join([task_negative_prompt] + task_extra_negative_prompts),
                 ))
 
             if use_expansion:
@@ -497,7 +499,7 @@ def worker():
 
             if direct_return:
                 d = [('Upscale (Fast)', '2x')]
-                log(uov_input_image, d, single_line_number=1)
+                log(uov_input_image, d)
                 yield_result(async_task, uov_input_image, do_not_show_finished_images=True)
                 return
 
@@ -779,12 +781,13 @@ def worker():
                         ('Refiner Switch', refiner_switch),
                         ('Sampler', sampler_name),
                         ('Scheduler', scheduler_name),
-                        ('Seed', task['task_seed'])
+                        ('Seed', task['task_seed']),
                     ]
-                    for n, w in loras:
+                    for li, (n, w) in enumerate(loras):
                         if n != 'None':
-                            d.append((f'LoRA [{n}] weight', w))
-                    log(x, d, single_line_number=3)
+                            d.append((f'LoRA {li + 1}', f'{n} : {w}'))
+                    d.append(('Version', 'v' + fooocus_version.version))
+                    log(x, d)
 
                 yield_result(async_task, imgs, do_not_show_finished_images=len(tasks) == 1, progressbar_index=int(15.0 + 85.0 * float((current_task_id + 1) * steps) / float(all_steps)))
             except ldm_patched.modules.model_management.InterruptProcessingException as e:
@@ -806,12 +809,12 @@ def worker():
             task = async_tasks.pop(0)
             try:
                 handler(task)
-            except:
-                traceback.print_exc()
-            finally:
                 build_image_wall(task)
                 task.yields.append(['finish', task.results])
                 pipeline.prepare_text_encoder(async_call=True)
+            except:
+                traceback.print_exc()
+                task.yields.append(['finish', task.results])
     pass
 
 

modules/core.py

@@ -191,7 +191,7 @@ def encode_vae_inpaint(vae, pixels, mask):
 
     latent_mask = mask[:, None, :, :]
     latent_mask = torch.nn.functional.interpolate(latent_mask, size=(H * 8, W * 8), mode="bilinear").round()
-    latent_mask = torch.nn.functional.max_pool2d(latent_mask, (8, 8)).round()
+    latent_mask = torch.nn.functional.max_pool2d(latent_mask, (8, 8)).round().to(latent)
 
     return latent, latent_mask
 

modules/meta_parser.py

@@ -0,0 +1,144 @@
+import json
+import gradio as gr
+import modules.config
+
+
+def load_parameter_button_click(raw_prompt_txt):
+    loaded_parameter_dict = json.loads(raw_prompt_txt)
+    assert isinstance(loaded_parameter_dict, dict)
+
+    results = [True, 1]
+
+    try:
+        h = loaded_parameter_dict.get('Prompt', None)
+        assert isinstance(h, str)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Negative Prompt', None)
+        assert isinstance(h, str)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Styles', None)
+        h = eval(h)
+        assert isinstance(h, list)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Performance', None)
+        assert isinstance(h, str)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Resolution', None)
+        width, height = eval(h)
+        formatted = modules.config.add_ratio(f'{width}*{height}')
+        if formatted in modules.config.available_aspect_ratios:
+            results.append(formatted)
+            results.append(-1)
+            results.append(-1)
+        else:
+            results.append(gr.update())
+            results.append(width)
+            results.append(height)
+    except:
+        results.append(gr.update())
+        results.append(gr.update())
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Sharpness', None)
+        assert h is not None
+        h = float(h)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Guidance Scale', None)
+        assert h is not None
+        h = float(h)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('ADM Guidance', None)
+        p, n, e = eval(h)
+        results.append(float(p))
+        results.append(float(n))
+        results.append(float(e))
+    except:
+        results.append(gr.update())
+        results.append(gr.update())
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Base Model', None)
+        assert isinstance(h, str)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Refiner Model', None)
+        assert isinstance(h, str)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Refiner Switch', None)
+        assert h is not None
+        h = float(h)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Sampler', None)
+        assert isinstance(h, str)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Scheduler', None)
+        assert isinstance(h, str)
+        results.append(h)
+    except:
+        results.append(gr.update())
+
+    try:
+        h = loaded_parameter_dict.get('Seed', None)
+        assert h is not None
+        h = int(h)
+        results.append(False)
+        results.append(h)
+    except:
+        results.append(gr.update())
+        results.append(gr.update())
+
+    results.append(gr.update(visible=True))
+    results.append(gr.update(visible=False))
+
+    for i in range(1, 6):
+        try:
+            n, w = loaded_parameter_dict.get(f'LoRA {i}').split(' : ')
+            w = float(w)
+            results.append(n)
+            results.append(w)
+        except:
+            results.append(gr.update())
+            results.append(gr.update())
+
+    return results

modules/patch.py

@@ -25,6 +25,8 @@ import modules.constants as constants
 from ldm_patched.modules.samplers import calc_cond_uncond_batch
 from ldm_patched.k_diffusion.sampling import BatchedBrownianTree
 from ldm_patched.ldm.modules.diffusionmodules.openaimodel import forward_timestep_embed, apply_control
+from modules.patch_precision import patch_all_precision
+from modules.patch_clip import patch_all_clip
 
 
 sharpness = 2.0
@@ -214,16 +216,20 @@ def compute_cfg(uncond, cond, cfg_scale, t):
 
 
 def patched_sampling_function(model, x, timestep, uncond, cond, cond_scale, model_options=None, seed=None):
-    if math.isclose(cond_scale, 1.0):
-        return calc_cond_uncond_batch(model, cond, None, x, timestep, model_options)[0]
-
     global eps_record
 
+    if math.isclose(cond_scale, 1.0):
+        final_x0 = calc_cond_uncond_batch(model, cond, None, x, timestep, model_options)[0]
+
+        if eps_record is not None:
+            eps_record = ((x - final_x0) / timestep).cpu()
+
+        return final_x0
+
     positive_x0, negative_x0 = calc_cond_uncond_batch(model, cond, uncond, x, timestep, model_options)
 
     positive_eps = x - positive_x0
     negative_eps = x - negative_x0
-    sigma = timestep
 
     alpha = 0.001 * sharpness * global_diffusion_progress
 
@@ -234,7 +240,7 @@ def patched_sampling_function(model, x, timestep, uncond, cond, cond_scale, mode
                             cfg_scale=cond_scale, t=global_diffusion_progress)
 
     if eps_record is not None:
-        eps_record = (final_eps / sigma).cpu()
+        eps_record = (final_eps / timestep).cpu()
 
     return x - final_eps
 
@@ -265,11 +271,11 @@ def sdxl_encode_adm_patched(self, **kwargs):
         height = float(height) * positive_adm_scale
 
     def embedder(number_list):
-        h = [self.embedder(torch.Tensor([number])) for number in number_list]
-        y = torch.flatten(torch.cat(h)).unsqueeze(dim=0).repeat(clip_pooled.shape[0], 1)
-        return y
+        h = self.embedder(torch.tensor(number_list, dtype=torch.float32))
+        h = torch.flatten(h).unsqueeze(dim=0).repeat(clip_pooled.shape[0], 1)
+        return h
 
-    width, height = round_to_64(width), round_to_64(height)
+    width, height = int(width), int(height)
     target_width, target_height = round_to_64(target_width), round_to_64(target_height)
 
     adm_emphasized = embedder([height, width, 0, 0, target_height, target_width])
@@ -281,46 +287,6 @@ def sdxl_encode_adm_patched(self, **kwargs):
     return final_adm
 
 
-def encode_token_weights_patched_with_a1111_method(self, token_weight_pairs):
-    to_encode = list()
-    max_token_len = 0
-    has_weights = False
-    for x in token_weight_pairs:
-        tokens = list(map(lambda a: a[0], x))
-        max_token_len = max(len(tokens), max_token_len)
-        has_weights = has_weights or not all(map(lambda a: a[1] == 1.0, x))
-        to_encode.append(tokens)
-
-    sections = len(to_encode)
-    if has_weights or sections == 0:
-        to_encode.append(ldm_patched.modules.sd1_clip.gen_empty_tokens(self.special_tokens, max_token_len))
-
-    out, pooled = self.encode(to_encode)
-    if pooled is not None:
-        first_pooled = pooled[0:1].to(ldm_patched.modules.model_management.intermediate_device())
-    else:
-        first_pooled = pooled
-
-    output = []
-    for k in range(0, sections):
-        z = out[k:k + 1]
-        if has_weights:
-            original_mean = z.mean()
-            z_empty = out[-1]
-            for i in range(len(z)):
-                for j in range(len(z[i])):
-                    weight = token_weight_pairs[k][j][1]
-                    if weight != 1.0:
-                        z[i][j] = (z[i][j] - z_empty[j]) * weight + z_empty[j]
-            new_mean = z.mean()
-            z = z * (original_mean / new_mean)
-        output.append(z)
-
-    if len(output) == 0:
-        return out[-1:].to(ldm_patched.modules.model_management.intermediate_device()), first_pooled
-    return torch.cat(output, dim=-2).to(ldm_patched.modules.model_management.intermediate_device()), first_pooled
-
-
 def patched_KSamplerX0Inpaint_forward(self, x, sigma, uncond, cond, cond_scale, denoise_mask, model_options={}, seed=None):
     if inpaint_worker.current_task is not None:
         latent_processor = self.inner_model.inner_model.process_latent_in
@@ -514,6 +480,9 @@ def build_loaded(module, loader_name):
 
 
 def patch_all():
+    patch_all_precision()
+    patch_all_clip()
+
     if not hasattr(ldm_patched.modules.model_management, 'load_models_gpu_origin'):
         ldm_patched.modules.model_management.load_models_gpu_origin = ldm_patched.modules.model_management.load_models_gpu
 
@@ -522,7 +491,6 @@ def patch_all():
     ldm_patched.controlnet.cldm.ControlNet.forward = patched_cldm_forward
     ldm_patched.ldm.modules.diffusionmodules.openaimodel.UNetModel.forward = patched_unet_forward
     ldm_patched.modules.model_base.SDXL.encode_adm = sdxl_encode_adm_patched
-    ldm_patched.modules.sd1_clip.ClipTokenWeightEncoder.encode_token_weights = encode_token_weights_patched_with_a1111_method
     ldm_patched.modules.samplers.KSamplerX0Inpaint.forward = patched_KSamplerX0Inpaint_forward
     ldm_patched.k_diffusion.sampling.BrownianTreeNoiseSampler = BrownianTreeNoiseSamplerPatched
     ldm_patched.modules.samplers.sampling_function = patched_sampling_function

modules/patch_clip.py

@@ -0,0 +1,213 @@
+# Consistent with Kohya/A1111 to reduce differences between model training and inference.
+
+import os
+import torch
+import ldm_patched.controlnet.cldm
+import ldm_patched.k_diffusion.sampling
+import ldm_patched.ldm.modules.attention
+import ldm_patched.ldm.modules.diffusionmodules.model
+import ldm_patched.ldm.modules.diffusionmodules.openaimodel
+import ldm_patched.ldm.modules.diffusionmodules.openaimodel
+import ldm_patched.modules.args_parser
+import ldm_patched.modules.model_base
+import ldm_patched.modules.model_management
+import ldm_patched.modules.model_patcher
+import ldm_patched.modules.samplers
+import ldm_patched.modules.sd
+import ldm_patched.modules.sd1_clip
+import ldm_patched.modules.clip_vision
+import ldm_patched.modules.model_management as model_management
+import ldm_patched.modules.ops as ops
+import contextlib
+
+from transformers import CLIPTextModel, CLIPTextConfig, modeling_utils, CLIPVisionConfig, CLIPVisionModelWithProjection
+
+
+@contextlib.contextmanager
+def use_patched_ops(operations):
+    op_names = ['Linear', 'Conv2d', 'Conv3d', 'GroupNorm', 'LayerNorm']
+    backups = {op_name: getattr(torch.nn, op_name) for op_name in op_names}
+
+    try:
+        for op_name in op_names:
+            setattr(torch.nn, op_name, getattr(operations, op_name))
+
+        yield
+
+    finally:
+        for op_name in op_names:
+            setattr(torch.nn, op_name, backups[op_name])
+    return
+
+
+def patched_encode_token_weights(self, token_weight_pairs):
+    to_encode = list()
+    max_token_len = 0
+    has_weights = False
+    for x in token_weight_pairs:
+        tokens = list(map(lambda a: a[0], x))
+        max_token_len = max(len(tokens), max_token_len)
+        has_weights = has_weights or not all(map(lambda a: a[1] == 1.0, x))
+        to_encode.append(tokens)
+
+    sections = len(to_encode)
+    if has_weights or sections == 0:
+        to_encode.append(ldm_patched.modules.sd1_clip.gen_empty_tokens(self.special_tokens, max_token_len))
+
+    out, pooled = self.encode(to_encode)
+    if pooled is not None:
+        first_pooled = pooled[0:1].to(ldm_patched.modules.model_management.intermediate_device())
+    else:
+        first_pooled = pooled
+
+    output = []
+    for k in range(0, sections):
+        z = out[k:k + 1]
+        if has_weights:
+            original_mean = z.mean()
+            z_empty = out[-1]
+            for i in range(len(z)):
+                for j in range(len(z[i])):
+                    weight = token_weight_pairs[k][j][1]
+                    if weight != 1.0:
+                        z[i][j] = (z[i][j] - z_empty[j]) * weight + z_empty[j]
+            new_mean = z.mean()
+            z = z * (original_mean / new_mean)
+        output.append(z)
+
+    if len(output) == 0:
+        return out[-1:].to(ldm_patched.modules.model_management.intermediate_device()), first_pooled
+    return torch.cat(output, dim=-2).to(ldm_patched.modules.model_management.intermediate_device()), first_pooled
+
+
+def patched_SDClipModel__init__(self, max_length=77, freeze=True, layer="last", layer_idx=None,
+                                textmodel_json_config=None, dtype=None, special_tokens=None,
+                                layer_norm_hidden_state=True, **kwargs):
+    torch.nn.Module.__init__(self)
+    assert layer in self.LAYERS
+
+    if special_tokens is None:
+        special_tokens = {"start": 49406, "end": 49407, "pad": 49407}
+
+    if textmodel_json_config is None:
+        textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(ldm_patched.modules.sd1_clip.__file__)),
+                                             "sd1_clip_config.json")
+
+    config = CLIPTextConfig.from_json_file(textmodel_json_config)
+    self.num_layers = config.num_hidden_layers
+
+    with use_patched_ops(ops.manual_cast):
+        with modeling_utils.no_init_weights():
+            self.transformer = CLIPTextModel(config)
+
+    if dtype is not None:
+        self.transformer.to(dtype)
+
+    self.transformer.text_model.embeddings.to(torch.float32)
+
+    if freeze:
+        self.freeze()
+
+    self.max_length = max_length
+    self.layer = layer
+    self.layer_idx = None
+    self.special_tokens = special_tokens
+    self.text_projection = torch.nn.Parameter(torch.eye(self.transformer.get_input_embeddings().weight.shape[1]))
+    self.logit_scale = torch.nn.Parameter(torch.tensor(4.6055))
+    self.enable_attention_masks = False
+
+    self.layer_norm_hidden_state = layer_norm_hidden_state
+    if layer == "hidden":
+        assert layer_idx is not None
+        assert abs(layer_idx) < self.num_layers
+        self.clip_layer(layer_idx)
+    self.layer_default = (self.layer, self.layer_idx)
+
+
+def patched_SDClipModel_forward(self, tokens):
+    backup_embeds = self.transformer.get_input_embeddings()
+    device = backup_embeds.weight.device
+    tokens = self.set_up_textual_embeddings(tokens, backup_embeds)
+    tokens = torch.LongTensor(tokens).to(device)
+
+    attention_mask = None
+    if self.enable_attention_masks:
+        attention_mask = torch.zeros_like(tokens)
+        max_token = self.transformer.get_input_embeddings().weight.shape[0] - 1
+        for x in range(attention_mask.shape[0]):
+            for y in range(attention_mask.shape[1]):
+                attention_mask[x, y] = 1
+                if tokens[x, y] == max_token:
+                    break
+
+    outputs = self.transformer(input_ids=tokens, attention_mask=attention_mask,
+                               output_hidden_states=self.layer == "hidden")
+    self.transformer.set_input_embeddings(backup_embeds)
+
+    if self.layer == "last":
+        z = outputs.last_hidden_state
+    elif self.layer == "pooled":
+        z = outputs.pooler_output[:, None, :]
+    else:
+        z = outputs.hidden_states[self.layer_idx]
+        if self.layer_norm_hidden_state:
+            z = self.transformer.text_model.final_layer_norm(z)
+
+    if hasattr(outputs, "pooler_output"):
+        pooled_output = outputs.pooler_output.float()
+    else:
+        pooled_output = None
+
+    if self.text_projection is not None and pooled_output is not None:
+        pooled_output = pooled_output.float().to(self.text_projection.device) @ self.text_projection.float()
+
+    return z.float(), pooled_output
+
+
+def patched_ClipVisionModel__init__(self, json_config):
+    config = CLIPVisionConfig.from_json_file(json_config)
+
+    self.load_device = ldm_patched.modules.model_management.text_encoder_device()
+    self.offload_device = ldm_patched.modules.model_management.text_encoder_offload_device()
+
+    if ldm_patched.modules.model_management.should_use_fp16(self.load_device, prioritize_performance=False):
+        self.dtype = torch.float16
+    else:
+        self.dtype = torch.float32
+
+    with use_patched_ops(ops.manual_cast):
+        with modeling_utils.no_init_weights():
+            self.model = CLIPVisionModelWithProjection(config)
+
+    self.model.to(self.dtype)
+    self.patcher = ldm_patched.modules.model_patcher.ModelPatcher(
+        self.model,
+        load_device=self.load_device,
+        offload_device=self.offload_device
+    )
+
+
+def patched_ClipVisionModel_encode_image(self, image):
+    ldm_patched.modules.model_management.load_model_gpu(self.patcher)
+    pixel_values = ldm_patched.modules.clip_vision.clip_preprocess(image.to(self.load_device))
+    outputs = self.model(pixel_values=pixel_values, output_hidden_states=True)
+
+    for k in outputs:
+        t = outputs[k]
+        if t is not None:
+            if k == 'hidden_states':
+                outputs["penultimate_hidden_states"] = t[-2].to(ldm_patched.modules.model_management.intermediate_device())
+                outputs["hidden_states"] = None
+            else:
+                outputs[k] = t.to(ldm_patched.modules.model_management.intermediate_device())
+
+    return outputs
+
+
+def patch_all_clip():
+    ldm_patched.modules.sd1_clip.ClipTokenWeightEncoder.encode_token_weights = patched_encode_token_weights
+    ldm_patched.modules.sd1_clip.SDClipModel.__init__ = patched_SDClipModel__init__
+    ldm_patched.modules.sd1_clip.SDClipModel.forward = patched_SDClipModel_forward
+    ldm_patched.modules.clip_vision.ClipVisionModel.__init__ = patched_ClipVisionModel__init__
+    ldm_patched.modules.clip_vision.ClipVisionModel.encode_image = patched_ClipVisionModel_encode_image
+    return

modules/patch_precision.py

@@ -0,0 +1,60 @@
+# Consistent with Kohya to reduce differences between model training and inference.
+
+import torch
+import math
+import einops
+import numpy as np
+
+import ldm_patched.ldm.modules.diffusionmodules.openaimodel
+import ldm_patched.modules.model_sampling
+import ldm_patched.modules.sd1_clip
+
+from ldm_patched.ldm.modules.diffusionmodules.util import make_beta_schedule
+
+
+def patched_timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False):
+    # Consistent with Kohya to reduce differences between model training and inference.
+
+    if not repeat_only:
+        half = dim // 2
+        freqs = torch.exp(
+            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
+        ).to(device=timesteps.device)
+        args = timesteps[:, None].float() * freqs[None]
+        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        if dim % 2:
+            embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+    else:
+        embedding = einops.repeat(timesteps, 'b -> b d', d=dim)
+    return embedding
+
+
+def patched_register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000,
+                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
+    # Consistent with Kohya to reduce differences between model training and inference.
+
+    if given_betas is not None:
+        betas = given_betas
+    else:
+        betas = make_beta_schedule(
+            beta_schedule,
+            timesteps,
+            linear_start=linear_start,
+            linear_end=linear_end,
+            cosine_s=cosine_s)
+
+    alphas = 1. - betas
+    alphas_cumprod = np.cumprod(alphas, axis=0)
+    timesteps, = betas.shape
+    self.num_timesteps = int(timesteps)
+    self.linear_start = linear_start
+    self.linear_end = linear_end
+    sigmas = torch.tensor(((1 - alphas_cumprod) / alphas_cumprod) ** 0.5, dtype=torch.float32)
+    self.set_sigmas(sigmas)
+    return
+
+
+def patch_all_precision():
+    ldm_patched.ldm.modules.diffusionmodules.openaimodel.timestep_embedding = patched_timestep_embedding
+    ldm_patched.modules.model_sampling.ModelSamplingDiscrete._register_schedule = patched_register_schedule
+    return

modules/private_logger.py

@@ -1,6 +1,8 @@
 import os
 import args_manager
 import modules.config
+import json
+import urllib.parse
 
 from PIL import Image
 from modules.util import generate_temp_filename
@@ -16,7 +18,7 @@ def get_current_html_path():
     return html_name
 
 
-def log(img, dic, single_line_number=3):
+def log(img, dic):
     if args_manager.args.disable_image_log:
         return
 
@@ -25,36 +27,67 @@ def log(img, dic, single_line_number=3):
     Image.fromarray(img).save(local_temp_filename)
     html_name = os.path.join(os.path.dirname(local_temp_filename), 'log.html')
 
-    existing_log = log_cache.get(html_name, None)
+    css_styles = (
+        "<style>"
+        "body { background-color: #121212; color: #E0E0E0; } "
+        "a { color: #BB86FC; } "
+        ".metadata { border-collapse: collapse; width: 100%; } "
+        ".metadata .key { width: 15%; } "
+        ".metadata .value { width: 85%; font-weight: bold; } "
+        ".metadata th, .metadata td { border: 1px solid #4d4d4d; padding: 4px; } "
+        ".image-container img { height: auto; max-width: 512px; display: block; padding-right:10px; } "
+        ".image-container div { text-align: center; padding: 4px; } "
+        "hr { border-color: gray; } "
+        "button { background-color: black; color: white; border: 1px solid grey; border-radius: 5px; padding: 5px 10px; text-align: center; display: inline-block; font-size: 16px; cursor: pointer; }"
+        "button:hover {background-color: grey; color: black;}"
+        "</style>"
+    )
 
-    if existing_log is None:
+    js = (
+        "<script>"
+        "function to_clipboard(txt) { "
+        "txt = decodeURIComponent(txt);"
+        "navigator.clipboard.writeText(txt);"
+        "alert('Copied to Clipboard!\\nPaste to prompt area to load parameters.\\nCurrent clipboard content is:\\n\\n' + txt);"
+        "}"
+        "</script>"
+    )
+
+    begin_part = f"<html><head><title>Fooocus Log {date_string}</title>{css_styles}</head><body>{js}<p>Fooocus Log {date_string} (private)</p>\n<p>All images are clean, without any hidden data/meta, and safe to share with others.</p><!--fooocus-log-split-->\n\n"
+    end_part = f'\n<!--fooocus-log-split--></body></html>'
+
+    middle_part = log_cache.get(html_name, "")
+
+    if middle_part == "":
         if os.path.exists(html_name):
-            existing_log = open(html_name, encoding='utf-8').read()
-        else:
-            existing_log = f'<p>Fooocus Log {date_string} (private)</p>\n<p>All images do not contain any hidden data.</p>'
+            existing_split = open(html_name, 'r', encoding='utf-8').read().split('<!--fooocus-log-split-->')
+            if len(existing_split) == 3:
+                middle_part = existing_split[1]
+            else:
+                middle_part = existing_split[0]
 
     div_name = only_name.replace('.', '_')
-    item = f'<div id="{div_name}">\n'
-    item += "<table><tr>"
-    item += f"<td><img src=\"{only_name}\" width=auto height=100% loading=lazy style=\"height:auto;max-width:512px\" onerror=\"document.getElementById('{div_name}').style.display = 'none';\"></img></p></td>"
-    item += f"<td style=\"padding-left:10px;\"><p>{only_name}</p>\n"
-    for i, (k, v) in enumerate(dic):
-        if i < single_line_number:
-            item += f"<p>{k}: <b>{v}</b></p>\n"
-        else:
-            if (i - single_line_number) % 2 == 0:
-                item += f"<p>{k}: <b>{v}</b>, "
-            else:
-                item += f"{k}: <b>{v}</b></p>\n"
+    item = f"<div id=\"{div_name}\" class=\"image-container\"><hr><table><tr>\n"
+    item += f"<td><a href=\"{only_name}\" target=\"_blank\"><img src='{only_name}' onerror=\"this.closest('.image-container').style.display='none';\" loading='lazy'></img></a><div>{only_name}</div></td>"
+    item += "<td><table class='metadata'>"
+    for key, value in dic:
+        value_txt = str(value).replace('\n', ' </br> ')
+        item += f"<tr><td class='key'>{key}</td><td class='value'>{value_txt}</td></tr>\n"
+    item += "</table>"
+
+    js_txt = urllib.parse.quote(json.dumps({k: v for k, v in dic}, indent=0), safe='')
+    item += f"</br><button onclick=\"to_clipboard('{js_txt}')\">Copy to Clipboard</button>"
+
     item += "</td>"
-    item += "</tr></table><hr></div>\n"
-    existing_log = item + existing_log
+    item += "</tr></table></div>\n\n"
+
+    middle_part = item + middle_part
 
     with open(html_name, 'w', encoding='utf-8') as f:
-        f.write(existing_log)
+        f.write(begin_part + middle_part + end_part)
 
     print(f'Image generated with private log at: {html_name}')
 
-    log_cache[html_name] = existing_log
+    log_cache[html_name] = middle_part
 
     return

modules/sdxl_styles.py

@@ -31,7 +31,8 @@ for x in ['sdxl_styles_fooocus.json',
           'sdxl_styles_sai.json',
           'sdxl_styles_mre.json',
           'sdxl_styles_twri.json',
-          'sdxl_styles_diva.json']:
+          'sdxl_styles_diva.json',
+          'sdxl_styles_marc_k3nt3l.json']:
     if x in styles_files:
         styles_files.remove(x)
         styles_files.append(x)

modules/style_sorter.py

@@ -15,11 +15,14 @@ def try_load_sorted_styles(style_names, default_selected):
     try:
         if os.path.exists('sorted_styles.json'):
             with open('sorted_styles.json', 'rt', encoding='utf-8') as fp:
-                sorted_styles = json.load(fp)
-                if len(sorted_styles) == len(all_styles):
-                    if all(x in all_styles for x in sorted_styles):
-                        if all(x in sorted_styles for x in all_styles):
-                            all_styles = sorted_styles
+                sorted_styles = []
+                for x in json.load(fp):
+                    if x in all_styles:
+                        sorted_styles.append(x)
+                for x in all_styles:
+                    if x not in sorted_styles:
+                        sorted_styles.append(x)
+                all_styles = sorted_styles
     except Exception as e:
         print('Load style sorting failed.')
         print(e)