diff --git a/modules/inpaint_worker.py b/modules/inpaint_worker.py
index 88ec39d6..43a7ae23 100644
--- a/modules/inpaint_worker.py
+++ b/modules/inpaint_worker.py
@@ -4,6 +4,7 @@ import numpy as np
from PIL import Image, ImageFilter
from modules.util import resample_image, set_image_shape_ceil, get_image_shape_ceil
from modules.upscaler import perform_upscale
+import cv2
inpaint_head_model = None
@@ -28,19 +29,25 @@ def box_blur(x, k):
return np.array(x)
-def max33(x):
- x = Image.fromarray(x)
- x = x.filter(ImageFilter.MaxFilter(3))
- return np.array(x)
+def max_filter_opencv(x, ksize=3):
+ # Use OpenCV maximum filter
+ # Make sure the input type is int16
+ return cv2.dilate(x, np.ones((ksize, ksize), dtype=np.int16))
def morphological_open(x):
- x_int32 = np.zeros_like(x).astype(np.int32)
- x_int32[x > 127] = 256
- for _ in range(32):
- maxed = max33(x_int32) - 8
- x_int32 = np.maximum(maxed, x_int32)
- return x_int32.clip(0, 255).astype(np.uint8)
+ # Convert array to int16 type via threshold operation
+ x_int16 = np.zeros_like(x, dtype=np.int16)
+ x_int16[x > 127] = 256
+
+ for i in range(32):
+ # Use int16 type to avoid overflow
+ maxed = max_filter_opencv(x_int16, ksize=3) - 8
+ x_int16 = np.maximum(maxed, x_int16)
+
+ # Clip negative values to 0 and convert back to uint8 type
+ x_uint8 = np.clip(x_int16, 0, 255).astype(np.uint8)
+ return x_uint8
def up255(x, t=0):
diff --git a/modules/launch_util.py b/modules/launch_util.py
index 00fff8ae..370dc048 100644
--- a/modules/launch_util.py
+++ b/modules/launch_util.py
@@ -1,16 +1,19 @@
import os
import importlib
import importlib.util
+import shutil
import subprocess
import sys
import re
import logging
-
+import importlib.metadata
+import packaging.version
+from packaging.requirements import Requirement
logging.getLogger("torch.distributed.nn").setLevel(logging.ERROR) # sshh...
logging.getLogger("xformers").addFilter(lambda record: 'A matching Triton is not available' not in record.getMessage())
-re_requirement = re.compile(r"\s*([-_a-zA-Z0-9]+)\s*(?:==\s*([-+_.a-zA-Z0-9]+))?\s*")
+re_requirement = re.compile(r"\s*([-\w]+)\s*(?:==\s*([-+.\w]+))?\s*")
python = sys.executable
default_command_live = (os.environ.get('LAUNCH_LIVE_OUTPUT') == "1")
@@ -73,35 +76,42 @@ def run_pip(command, desc=None, live=default_command_live):
def requirements_met(requirements_file):
- """
- Does a simple parse of a requirements.txt file to determine if all rerqirements in it
- are already installed. Returns True if so, False if not installed or parsing fails.
- """
-
- import importlib.metadata
- import packaging.version
-
with open(requirements_file, "r", encoding="utf8") as file:
for line in file:
- if line.strip() == "":
+ line = line.strip()
+ if line == "" or line.startswith('#'):
continue
- m = re.match(re_requirement, line)
- if m is None:
- return False
-
- package = m.group(1).strip()
- version_required = (m.group(2) or "").strip()
-
- if version_required == "":
- continue
+ requirement = Requirement(line)
+ package = requirement.name
try:
version_installed = importlib.metadata.version(package)
- except Exception:
- return False
+ installed_version = packaging.version.parse(version_installed)
- if packaging.version.parse(version_required) != packaging.version.parse(version_installed):
+ # Check if the installed version satisfies the requirement
+ if installed_version not in requirement.specifier:
+ print(f"Version mismatch for {package}: Installed version {version_installed} does not meet requirement {requirement}")
+ return False
+ except Exception as e:
+ print(f"Error checking version for {package}: {e}")
return False
return True
+
+
+def delete_folder_content(folder, prefix=None):
+ result = True
+
+ for filename in os.listdir(folder):
+ file_path = os.path.join(folder, filename)
+ try:
+ if os.path.isfile(file_path) or os.path.islink(file_path):
+ os.unlink(file_path)
+ elif os.path.isdir(file_path):
+ shutil.rmtree(file_path)
+ except Exception as e:
+ print(f'{prefix}Failed to delete {file_path}. Reason: {e}')
+ result = False
+
+ return result
\ No newline at end of file
diff --git a/modules/meta_parser.py b/modules/meta_parser.py
index 78d73978..ff930cc0 100644
--- a/modules/meta_parser.py
+++ b/modules/meta_parser.py
@@ -1,78 +1,168 @@
import json
+import re
+from abc import ABC, abstractmethod
+from pathlib import Path
+
import gradio as gr
+from PIL import Image
+
+import fooocus_version
import modules.config
+import modules.sdxl_styles
+from modules.flags import MetadataScheme, Performance, Steps
+from modules.flags import SAMPLERS, CIVITAI_NO_KARRAS
+from modules.util import quote, unquote, extract_styles_from_prompt, is_json, get_file_from_folder_list, sha256
+
+re_param_code = r'\s*(\w[\w \-/]+):\s*("(?:\\.|[^\\"])+"|[^,]*)(?:,|$)'
+re_param = re.compile(re_param_code)
+re_imagesize = re.compile(r"^(\d+)x(\d+)$")
+
+hash_cache = {}
-def load_parameter_button_click(raw_prompt_txt):
- loaded_parameter_dict = json.loads(raw_prompt_txt)
+def load_parameter_button_click(raw_metadata: dict | str, is_generating: bool):
+ loaded_parameter_dict = raw_metadata
+ if isinstance(raw_metadata, str):
+ loaded_parameter_dict = json.loads(raw_metadata)
assert isinstance(loaded_parameter_dict, dict)
- results = [True, 1]
+ results = [len(loaded_parameter_dict) > 0]
+ get_image_number('image_number', 'Image Number', loaded_parameter_dict, results)
+ get_str('prompt', 'Prompt', loaded_parameter_dict, results)
+ get_str('negative_prompt', 'Negative Prompt', loaded_parameter_dict, results)
+ get_list('styles', 'Styles', loaded_parameter_dict, results)
+ performance = get_str('performance', 'Performance', loaded_parameter_dict, results)
+ get_steps('steps', 'Steps', loaded_parameter_dict, results)
+ get_number('overwrite_switch', 'Overwrite Switch', loaded_parameter_dict, results)
+ get_resolution('resolution', 'Resolution', loaded_parameter_dict, results)
+ get_number('guidance_scale', 'Guidance Scale', loaded_parameter_dict, results)
+ get_number('sharpness', 'Sharpness', loaded_parameter_dict, results)
+ get_adm_guidance('adm_guidance', 'ADM Guidance', loaded_parameter_dict, results)
+ get_str('refiner_swap_method', 'Refiner Swap Method', loaded_parameter_dict, results)
+ get_number('adaptive_cfg', 'CFG Mimicking from TSNR', loaded_parameter_dict, results)
+ get_number('clip_skip', 'CLIP Skip', loaded_parameter_dict, results, cast_type=int)
+ get_str('base_model', 'Base Model', loaded_parameter_dict, results)
+ get_str('refiner_model', 'Refiner Model', loaded_parameter_dict, results)
+ get_number('refiner_switch', 'Refiner Switch', loaded_parameter_dict, results)
+ get_str('sampler', 'Sampler', loaded_parameter_dict, results)
+ get_str('scheduler', 'Scheduler', loaded_parameter_dict, results)
+ get_str('vae', 'VAE', loaded_parameter_dict, results)
+ get_seed('seed', 'Seed', loaded_parameter_dict, results)
+
+ if is_generating:
+ results.append(gr.update())
+ else:
+ results.append(gr.update(visible=True))
+
+ results.append(gr.update(visible=False))
+
+ get_freeu('freeu', 'FreeU', loaded_parameter_dict, results)
+
+ # prevent performance LoRAs to be added twice, by performance and by lora
+ performance_filename = None
+ if performance is not None and performance in Performance.values():
+ performance = Performance(performance)
+ performance_filename = performance.lora_filename()
+
+ for i in range(modules.config.default_max_lora_number):
+ get_lora(f'lora_combined_{i + 1}', f'LoRA {i + 1}', loaded_parameter_dict, results, performance_filename)
+
+ return results
+
+
+def get_str(key: str, fallback: str | None, source_dict: dict, results: list, default=None) -> str | None:
try:
- h = loaded_parameter_dict.get('Prompt', None)
+ h = source_dict.get(key, source_dict.get(fallback, default))
assert isinstance(h, str)
results.append(h)
+ return h
except:
results.append(gr.update())
+ return None
- try:
- h = loaded_parameter_dict.get('Negative Prompt', None)
- assert isinstance(h, str)
- results.append(h)
- except:
- results.append(gr.update())
+def get_list(key: str, fallback: str | None, source_dict: dict, results: list, default=None):
try:
- h = loaded_parameter_dict.get('Styles', None)
+ h = source_dict.get(key, source_dict.get(fallback, default))
h = eval(h)
assert isinstance(h, list)
results.append(h)
except:
results.append(gr.update())
+
+def get_number(key: str, fallback: str | None, source_dict: dict, results: list, default=None, cast_type=float):
try:
- h = loaded_parameter_dict.get('Performance', None)
- assert isinstance(h, str)
+ h = source_dict.get(key, source_dict.get(fallback, default))
+ assert h is not None
+ h = cast_type(h)
results.append(h)
except:
results.append(gr.update())
+
+def get_image_number(key: str, fallback: str | None, source_dict: dict, results: list, default=None):
try:
- h = loaded_parameter_dict.get('Resolution', None)
+ h = source_dict.get(key, source_dict.get(fallback, default))
+ assert h is not None
+ h = int(h)
+ h = min(h, modules.config.default_max_image_number)
+ results.append(h)
+ except:
+ results.append(1)
+
+
+def get_steps(key: str, fallback: str | None, source_dict: dict, results: list, default=None):
+ try:
+ h = source_dict.get(key, source_dict.get(fallback, default))
+ assert h is not None
+ h = int(h)
+ # if not in steps or in steps and performance is not the same
+ performance_name = source_dict.get('performance', '').replace(' ', '_').replace('-', '_').casefold()
+ performance_candidates = [key for key in Steps.keys() if key.casefold() == performance_name and Steps[key] == h]
+ if len(performance_candidates) == 0:
+ results.append(h)
+ return
+ results.append(-1)
+ except:
+ results.append(-1)
+
+
+def get_resolution(key: str, fallback: str | None, source_dict: dict, results: list, default=None):
+ try:
+ h = source_dict.get(key, source_dict.get(fallback, default))
width, height = eval(h)
formatted = modules.config.add_ratio(f'{width}*{height}')
- if formatted in modules.config.available_aspect_ratios:
+ if formatted in modules.config.available_aspect_ratios_labels:
results.append(formatted)
results.append(-1)
results.append(-1)
else:
results.append(gr.update())
- results.append(width)
- results.append(height)
+ results.append(int(width))
+ results.append(int(height))
except:
results.append(gr.update())
results.append(gr.update())
results.append(gr.update())
+
+def get_seed(key: str, fallback: str | None, source_dict: dict, results: list, default=None):
try:
- h = loaded_parameter_dict.get('Sharpness', None)
+ h = source_dict.get(key, source_dict.get(fallback, default))
assert h is not None
- h = float(h)
+ h = int(h)
+ results.append(False)
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())
+
+def get_adm_guidance(key: str, fallback: str | None, source_dict: dict, results: list, default=None):
try:
- h = loaded_parameter_dict.get('ADM Guidance', None)
+ h = source_dict.get(key, source_dict.get(fallback, default))
p, n, e = eval(h)
results.append(float(p))
results.append(float(n))
@@ -82,63 +172,458 @@ def load_parameter_button_click(raw_prompt_txt):
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())
+def get_freeu(key: str, fallback: str | None, source_dict: dict, results: list, default=None):
try:
- h = loaded_parameter_dict.get('Refiner Model', None)
- assert isinstance(h, str)
- results.append(h)
+ h = source_dict.get(key, source_dict.get(fallback, default))
+ b1, b2, s1, s2 = eval(h)
+ results.append(True)
+ results.append(float(b1))
+ results.append(float(b2))
+ results.append(float(s1))
+ results.append(float(s2))
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)
+ results.append(gr.update())
+ results.append(gr.update())
+ results.append(gr.update())
+ results.append(gr.update())
+
+
+def get_lora(key: str, fallback: str | None, source_dict: dict, results: list, performance_filename: str | None):
+ try:
+ split_data = source_dict.get(key, source_dict.get(fallback)).split(' : ')
+ enabled = True
+ name = split_data[0]
+ weight = split_data[1]
+
+ if len(split_data) == 3:
+ enabled = split_data[0] == 'True'
+ name = split_data[1]
+ weight = split_data[2]
+
+ if name == performance_filename:
+ raise Exception
+
+ weight = float(weight)
+ results.append(enabled)
+ results.append(name)
+ results.append(weight)
except:
- results.append(gr.update())
- results.append(gr.update())
+ results.append(True)
+ results.append('None')
+ results.append(1)
- 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())
+def get_sha256(filepath):
+ global hash_cache
+ if filepath not in hash_cache:
+ hash_cache[filepath] = sha256(filepath)
- return results
+ return hash_cache[filepath]
+
+
+def parse_meta_from_preset(preset_content):
+ assert isinstance(preset_content, dict)
+ preset_prepared = {}
+ items = preset_content
+
+ for settings_key, meta_key in modules.config.possible_preset_keys.items():
+ if settings_key == "default_loras":
+ loras = getattr(modules.config, settings_key)
+ if settings_key in items:
+ loras = items[settings_key]
+ for index, lora in enumerate(loras[:modules.config.default_max_lora_number]):
+ preset_prepared[f'lora_combined_{index + 1}'] = ' : '.join(map(str, lora))
+ elif settings_key == "default_aspect_ratio":
+ if settings_key in items and items[settings_key] is not None:
+ default_aspect_ratio = items[settings_key]
+ width, height = default_aspect_ratio.split('*')
+ else:
+ default_aspect_ratio = getattr(modules.config, settings_key)
+ width, height = default_aspect_ratio.split('×')
+ height = height[:height.index(" ")]
+ preset_prepared[meta_key] = (width, height)
+ else:
+ preset_prepared[meta_key] = items[settings_key] if settings_key in items and items[
+ settings_key] is not None else getattr(modules.config, settings_key)
+
+ if settings_key == "default_styles" or settings_key == "default_aspect_ratio":
+ preset_prepared[meta_key] = str(preset_prepared[meta_key])
+
+ return preset_prepared
+
+
+class MetadataParser(ABC):
+ def __init__(self):
+ self.raw_prompt: str = ''
+ self.full_prompt: str = ''
+ self.raw_negative_prompt: str = ''
+ self.full_negative_prompt: str = ''
+ self.steps: int = Steps.SPEED.value
+ self.base_model_name: str = ''
+ self.base_model_hash: str = ''
+ self.refiner_model_name: str = ''
+ self.refiner_model_hash: str = ''
+ self.loras: list = []
+ self.vae_name: str = ''
+
+ @abstractmethod
+ def get_scheme(self) -> MetadataScheme:
+ raise NotImplementedError
+
+ @abstractmethod
+ def to_json(self, metadata: dict | str) -> dict:
+ raise NotImplementedError
+
+ @abstractmethod
+ def to_string(self, metadata: dict) -> str:
+ raise NotImplementedError
+
+ def set_data(self, raw_prompt, full_prompt, raw_negative_prompt, full_negative_prompt, steps, base_model_name,
+ refiner_model_name, loras, vae_name):
+ self.raw_prompt = raw_prompt
+ self.full_prompt = full_prompt
+ self.raw_negative_prompt = raw_negative_prompt
+ self.full_negative_prompt = full_negative_prompt
+ self.steps = steps
+ self.base_model_name = Path(base_model_name).stem
+
+ base_model_path = get_file_from_folder_list(base_model_name, modules.config.paths_checkpoints)
+ self.base_model_hash = get_sha256(base_model_path)
+
+ if refiner_model_name not in ['', 'None']:
+ self.refiner_model_name = Path(refiner_model_name).stem
+ refiner_model_path = get_file_from_folder_list(refiner_model_name, modules.config.paths_checkpoints)
+ self.refiner_model_hash = get_sha256(refiner_model_path)
+
+ self.loras = []
+ for (lora_name, lora_weight) in loras:
+ if lora_name != 'None':
+ lora_path = get_file_from_folder_list(lora_name, modules.config.paths_loras)
+ lora_hash = get_sha256(lora_path)
+ self.loras.append((Path(lora_name).stem, lora_weight, lora_hash))
+ self.vae_name = Path(vae_name).stem
+
+
+class A1111MetadataParser(MetadataParser):
+ def get_scheme(self) -> MetadataScheme:
+ return MetadataScheme.A1111
+
+ fooocus_to_a1111 = {
+ 'raw_prompt': 'Raw prompt',
+ 'raw_negative_prompt': 'Raw negative prompt',
+ 'negative_prompt': 'Negative prompt',
+ 'styles': 'Styles',
+ 'performance': 'Performance',
+ 'steps': 'Steps',
+ 'sampler': 'Sampler',
+ 'scheduler': 'Scheduler',
+ 'vae': 'VAE',
+ 'guidance_scale': 'CFG scale',
+ 'seed': 'Seed',
+ 'resolution': 'Size',
+ 'sharpness': 'Sharpness',
+ 'adm_guidance': 'ADM Guidance',
+ 'refiner_swap_method': 'Refiner Swap Method',
+ 'adaptive_cfg': 'Adaptive CFG',
+ 'clip_skip': 'Clip skip',
+ 'overwrite_switch': 'Overwrite Switch',
+ 'freeu': 'FreeU',
+ 'base_model': 'Model',
+ 'base_model_hash': 'Model hash',
+ 'refiner_model': 'Refiner',
+ 'refiner_model_hash': 'Refiner hash',
+ 'lora_hashes': 'Lora hashes',
+ 'lora_weights': 'Lora weights',
+ 'created_by': 'User',
+ 'version': 'Version'
+ }
+
+ def to_json(self, metadata: str) -> dict:
+ metadata_prompt = ''
+ metadata_negative_prompt = ''
+
+ done_with_prompt = False
+
+ *lines, lastline = metadata.strip().split("\n")
+ if len(re_param.findall(lastline)) < 3:
+ lines.append(lastline)
+ lastline = ''
+
+ for line in lines:
+ line = line.strip()
+ if line.startswith(f"{self.fooocus_to_a1111['negative_prompt']}:"):
+ done_with_prompt = True
+ line = line[len(f"{self.fooocus_to_a1111['negative_prompt']}:"):].strip()
+ if done_with_prompt:
+ metadata_negative_prompt += ('' if metadata_negative_prompt == '' else "\n") + line
+ else:
+ metadata_prompt += ('' if metadata_prompt == '' else "\n") + line
+
+ found_styles, prompt, negative_prompt = extract_styles_from_prompt(metadata_prompt, metadata_negative_prompt)
+
+ data = {
+ 'prompt': prompt,
+ 'negative_prompt': negative_prompt
+ }
+
+ for k, v in re_param.findall(lastline):
+ try:
+ if v != '' and v[0] == '"' and v[-1] == '"':
+ v = unquote(v)
+
+ m = re_imagesize.match(v)
+ if m is not None:
+ data['resolution'] = str((m.group(1), m.group(2)))
+ else:
+ data[list(self.fooocus_to_a1111.keys())[list(self.fooocus_to_a1111.values()).index(k)]] = v
+ except Exception:
+ print(f"Error parsing \"{k}: {v}\"")
+
+ # workaround for multiline prompts
+ if 'raw_prompt' in data:
+ data['prompt'] = data['raw_prompt']
+ raw_prompt = data['raw_prompt'].replace("\n", ', ')
+ if metadata_prompt != raw_prompt and modules.sdxl_styles.fooocus_expansion not in found_styles:
+ found_styles.append(modules.sdxl_styles.fooocus_expansion)
+
+ if 'raw_negative_prompt' in data:
+ data['negative_prompt'] = data['raw_negative_prompt']
+
+ data['styles'] = str(found_styles)
+
+ # try to load performance based on steps, fallback for direct A1111 imports
+ if 'steps' in data and 'performance' in data is None:
+ try:
+ data['performance'] = Performance.by_steps(data['steps']).value
+ except ValueError | KeyError:
+ pass
+
+ if 'sampler' in data:
+ data['sampler'] = data['sampler'].replace(' Karras', '')
+ # get key
+ for k, v in SAMPLERS.items():
+ if v == data['sampler']:
+ data['sampler'] = k
+ break
+
+ for key in ['base_model', 'refiner_model', 'vae']:
+ if key in data:
+ if key == 'vae':
+ self.add_extension_to_filename(data, modules.config.vae_filenames, 'vae')
+ else:
+ self.add_extension_to_filename(data, modules.config.model_filenames, key)
+
+ lora_data = ''
+ if 'lora_weights' in data and data['lora_weights'] != '':
+ lora_data = data['lora_weights']
+ elif 'lora_hashes' in data and data['lora_hashes'] != '' and data['lora_hashes'].split(', ')[0].count(':') == 2:
+ lora_data = data['lora_hashes']
+
+ if lora_data != '':
+ for li, lora in enumerate(lora_data.split(', ')):
+ lora_split = lora.split(': ')
+ lora_name = lora_split[0]
+ lora_weight = lora_split[2] if len(lora_split) == 3 else lora_split[1]
+ for filename in modules.config.lora_filenames:
+ path = Path(filename)
+ if lora_name == path.stem:
+ data[f'lora_combined_{li + 1}'] = f'{filename} : {lora_weight}'
+ break
+
+ return data
+
+ def to_string(self, metadata: dict) -> str:
+ data = {k: v for _, k, v in metadata}
+
+ width, height = eval(data['resolution'])
+
+ sampler = data['sampler']
+ scheduler = data['scheduler']
+
+ if sampler in SAMPLERS and SAMPLERS[sampler] != '':
+ sampler = SAMPLERS[sampler]
+ if sampler not in CIVITAI_NO_KARRAS and scheduler == 'karras':
+ sampler += f' Karras'
+
+ generation_params = {
+ self.fooocus_to_a1111['steps']: self.steps,
+ self.fooocus_to_a1111['sampler']: sampler,
+ self.fooocus_to_a1111['seed']: data['seed'],
+ self.fooocus_to_a1111['resolution']: f'{width}x{height}',
+ self.fooocus_to_a1111['guidance_scale']: data['guidance_scale'],
+ self.fooocus_to_a1111['sharpness']: data['sharpness'],
+ self.fooocus_to_a1111['adm_guidance']: data['adm_guidance'],
+ self.fooocus_to_a1111['base_model']: Path(data['base_model']).stem,
+ self.fooocus_to_a1111['base_model_hash']: self.base_model_hash,
+
+ self.fooocus_to_a1111['performance']: data['performance'],
+ self.fooocus_to_a1111['scheduler']: scheduler,
+ self.fooocus_to_a1111['vae']: Path(data['vae']).stem,
+ # workaround for multiline prompts
+ self.fooocus_to_a1111['raw_prompt']: self.raw_prompt,
+ self.fooocus_to_a1111['raw_negative_prompt']: self.raw_negative_prompt,
+ }
+
+ if self.refiner_model_name not in ['', 'None']:
+ generation_params |= {
+ self.fooocus_to_a1111['refiner_model']: self.refiner_model_name,
+ self.fooocus_to_a1111['refiner_model_hash']: self.refiner_model_hash
+ }
+
+ for key in ['adaptive_cfg', 'clip_skip', 'overwrite_switch', 'refiner_swap_method', 'freeu']:
+ if key in data:
+ generation_params[self.fooocus_to_a1111[key]] = data[key]
+
+ if len(self.loras) > 0:
+ lora_hashes = []
+ lora_weights = []
+ for index, (lora_name, lora_weight, lora_hash) in enumerate(self.loras):
+ # workaround for Fooocus not knowing LoRA name in LoRA metadata
+ lora_hashes.append(f'{lora_name}: {lora_hash}')
+ lora_weights.append(f'{lora_name}: {lora_weight}')
+ lora_hashes_string = ', '.join(lora_hashes)
+ lora_weights_string = ', '.join(lora_weights)
+ generation_params[self.fooocus_to_a1111['lora_hashes']] = lora_hashes_string
+ generation_params[self.fooocus_to_a1111['lora_weights']] = lora_weights_string
+
+ generation_params[self.fooocus_to_a1111['version']] = data['version']
+
+ if modules.config.metadata_created_by != '':
+ generation_params[self.fooocus_to_a1111['created_by']] = modules.config.metadata_created_by
+
+ generation_params_text = ", ".join(
+ [k if k == v else f'{k}: {quote(v)}' for k, v in generation_params.items() if
+ v is not None])
+ positive_prompt_resolved = ', '.join(self.full_prompt)
+ negative_prompt_resolved = ', '.join(self.full_negative_prompt)
+ negative_prompt_text = f"\nNegative prompt: {negative_prompt_resolved}" if negative_prompt_resolved else ""
+ return f"{positive_prompt_resolved}{negative_prompt_text}\n{generation_params_text}".strip()
+
+ @staticmethod
+ def add_extension_to_filename(data, filenames, key):
+ for filename in filenames:
+ path = Path(filename)
+ if data[key] == path.stem:
+ data[key] = filename
+ break
+
+
+class FooocusMetadataParser(MetadataParser):
+ def get_scheme(self) -> MetadataScheme:
+ return MetadataScheme.FOOOCUS
+
+ def to_json(self, metadata: dict) -> dict:
+ for key, value in metadata.items():
+ if value in ['', 'None']:
+ continue
+ if key in ['base_model', 'refiner_model']:
+ metadata[key] = self.replace_value_with_filename(key, value, modules.config.model_filenames)
+ elif key.startswith('lora_combined_'):
+ metadata[key] = self.replace_value_with_filename(key, value, modules.config.lora_filenames)
+ elif key == 'vae':
+ metadata[key] = self.replace_value_with_filename(key, value, modules.config.vae_filenames)
+ else:
+ continue
+
+ return metadata
+
+ def to_string(self, metadata: list) -> str:
+ for li, (label, key, value) in enumerate(metadata):
+ # remove model folder paths from metadata
+ if key.startswith('lora_combined_'):
+ name, weight = value.split(' : ')
+ name = Path(name).stem
+ value = f'{name} : {weight}'
+ metadata[li] = (label, key, value)
+
+ res = {k: v for _, k, v in metadata}
+
+ res['full_prompt'] = self.full_prompt
+ res['full_negative_prompt'] = self.full_negative_prompt
+ res['steps'] = self.steps
+ res['base_model'] = self.base_model_name
+ res['base_model_hash'] = self.base_model_hash
+
+ if self.refiner_model_name not in ['', 'None']:
+ res['refiner_model'] = self.refiner_model_name
+ res['refiner_model_hash'] = self.refiner_model_hash
+
+ res['vae'] = self.vae_name
+ res['loras'] = self.loras
+
+ if modules.config.metadata_created_by != '':
+ res['created_by'] = modules.config.metadata_created_by
+
+ return json.dumps(dict(sorted(res.items())))
+
+ @staticmethod
+ def replace_value_with_filename(key, value, filenames):
+ for filename in filenames:
+ path = Path(filename)
+ if key.startswith('lora_combined_'):
+ name, weight = value.split(' : ')
+ if name == path.stem:
+ return f'{filename} : {weight}'
+ elif value == path.stem:
+ return filename
+
+ return None
+
+
+def get_metadata_parser(metadata_scheme: MetadataScheme) -> MetadataParser:
+ match metadata_scheme:
+ case MetadataScheme.FOOOCUS:
+ return FooocusMetadataParser()
+ case MetadataScheme.A1111:
+ return A1111MetadataParser()
+ case _:
+ raise NotImplementedError
+
+
+def read_info_from_image(filepath) -> tuple[str | None, MetadataScheme | None]:
+ with Image.open(filepath) as image:
+ items = (image.info or {}).copy()
+
+ parameters = items.pop('parameters', None)
+ metadata_scheme = items.pop('fooocus_scheme', None)
+ exif = items.pop('exif', None)
+
+ if parameters is not None and is_json(parameters):
+ parameters = json.loads(parameters)
+ elif exif is not None:
+ exif = image.getexif()
+ # 0x9286 = UserComment
+ parameters = exif.get(0x9286, None)
+ # 0x927C = MakerNote
+ metadata_scheme = exif.get(0x927C, None)
+
+ if is_json(parameters):
+ parameters = json.loads(parameters)
+
+ try:
+ metadata_scheme = MetadataScheme(metadata_scheme)
+ except ValueError:
+ metadata_scheme = None
+
+ # broad fallback
+ if isinstance(parameters, dict):
+ metadata_scheme = MetadataScheme.FOOOCUS
+
+ if isinstance(parameters, str):
+ metadata_scheme = MetadataScheme.A1111
+
+ return parameters, metadata_scheme
+
+
+def get_exif(metadata: str | None, metadata_scheme: str):
+ exif = Image.Exif()
+ # tags see see https://github.com/python-pillow/Pillow/blob/9.2.x/src/PIL/ExifTags.py
+ # 0x9286 = UserComment
+ exif[0x9286] = metadata
+ # 0x0131 = Software
+ exif[0x0131] = 'Fooocus v' + fooocus_version.version
+ # 0x927C = MakerNote
+ exif[0x927C] = metadata_scheme
+ return exif
diff --git a/modules/model_loader.py b/modules/model_loader.py
index 8ba336a9..1143f75e 100644
--- a/modules/model_loader.py
+++ b/modules/model_loader.py
@@ -14,6 +14,8 @@ def load_file_from_url(
Returns the path to the downloaded file.
"""
+ domain = os.environ.get("HF_MIRROR", "https://huggingface.co").rstrip('/')
+ url = str.replace(url, "https://huggingface.co", domain, 1)
os.makedirs(model_dir, exist_ok=True)
if not file_name:
parts = urlparse(url)
diff --git a/modules/ops.py b/modules/ops.py
new file mode 100644
index 00000000..ee0e7756
--- /dev/null
+++ b/modules/ops.py
@@ -0,0 +1,19 @@
+import torch
+import contextlib
+
+
+@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
diff --git a/modules/patch.py b/modules/patch.py
index 66b243cb..3c2dd8f4 100644
--- a/modules/patch.py
+++ b/modules/patch.py
@@ -17,7 +17,6 @@ import ldm_patched.controlnet.cldm
import ldm_patched.modules.model_patcher
import ldm_patched.modules.samplers
import ldm_patched.modules.args_parser
-import modules.advanced_parameters as advanced_parameters
import warnings
import safetensors.torch
import modules.constants as constants
@@ -29,15 +28,25 @@ from modules.patch_precision import patch_all_precision
from modules.patch_clip import patch_all_clip
-sharpness = 2.0
+class PatchSettings:
+ def __init__(self,
+ sharpness=2.0,
+ adm_scaler_end=0.3,
+ positive_adm_scale=1.5,
+ negative_adm_scale=0.8,
+ controlnet_softness=0.25,
+ adaptive_cfg=7.0):
+ self.sharpness = sharpness
+ self.adm_scaler_end = adm_scaler_end
+ self.positive_adm_scale = positive_adm_scale
+ self.negative_adm_scale = negative_adm_scale
+ self.controlnet_softness = controlnet_softness
+ self.adaptive_cfg = adaptive_cfg
+ self.global_diffusion_progress = 0
+ self.eps_record = None
-adm_scaler_end = 0.3
-positive_adm_scale = 1.5
-negative_adm_scale = 0.8
-adaptive_cfg = 7.0
-global_diffusion_progress = 0
-eps_record = None
+patch_settings = {}
def calculate_weight_patched(self, patches, weight, key):
@@ -201,14 +210,13 @@ class BrownianTreeNoiseSamplerPatched:
def compute_cfg(uncond, cond, cfg_scale, t):
- global adaptive_cfg
-
- mimic_cfg = float(adaptive_cfg)
+ pid = os.getpid()
+ mimic_cfg = float(patch_settings[pid].adaptive_cfg)
real_cfg = float(cfg_scale)
real_eps = uncond + real_cfg * (cond - uncond)
- if cfg_scale > adaptive_cfg:
+ if cfg_scale > patch_settings[pid].adaptive_cfg:
mimicked_eps = uncond + mimic_cfg * (cond - uncond)
return real_eps * t + mimicked_eps * (1 - t)
else:
@@ -216,13 +224,13 @@ def compute_cfg(uncond, cond, cfg_scale, t):
def patched_sampling_function(model, x, timestep, uncond, cond, cond_scale, model_options=None, seed=None):
- global eps_record
+ pid = os.getpid()
- if math.isclose(cond_scale, 1.0):
+ if math.isclose(cond_scale, 1.0) and not model_options.get("disable_cfg1_optimization", False):
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()
+ if patch_settings[pid].eps_record is not None:
+ patch_settings[pid].eps_record = ((x - final_x0) / timestep).cpu()
return final_x0
@@ -231,16 +239,16 @@ def patched_sampling_function(model, x, timestep, uncond, cond, cond_scale, mode
positive_eps = x - positive_x0
negative_eps = x - negative_x0
- alpha = 0.001 * sharpness * global_diffusion_progress
+ alpha = 0.001 * patch_settings[pid].sharpness * patch_settings[pid].global_diffusion_progress
positive_eps_degraded = anisotropic.adaptive_anisotropic_filter(x=positive_eps, g=positive_x0)
positive_eps_degraded_weighted = positive_eps_degraded * alpha + positive_eps * (1.0 - alpha)
final_eps = compute_cfg(uncond=negative_eps, cond=positive_eps_degraded_weighted,
- cfg_scale=cond_scale, t=global_diffusion_progress)
+ cfg_scale=cond_scale, t=patch_settings[pid].global_diffusion_progress)
- if eps_record is not None:
- eps_record = (final_eps / timestep).cpu()
+ if patch_settings[pid].eps_record is not None:
+ patch_settings[pid].eps_record = (final_eps / timestep).cpu()
return x - final_eps
@@ -255,20 +263,19 @@ def round_to_64(x):
def sdxl_encode_adm_patched(self, **kwargs):
- global positive_adm_scale, negative_adm_scale
-
clip_pooled = ldm_patched.modules.model_base.sdxl_pooled(kwargs, self.noise_augmentor)
width = kwargs.get("width", 1024)
height = kwargs.get("height", 1024)
target_width = width
target_height = height
+ pid = os.getpid()
if kwargs.get("prompt_type", "") == "negative":
- width = float(width) * negative_adm_scale
- height = float(height) * negative_adm_scale
+ width = float(width) * patch_settings[pid].negative_adm_scale
+ height = float(height) * patch_settings[pid].negative_adm_scale
elif kwargs.get("prompt_type", "") == "positive":
- width = float(width) * positive_adm_scale
- height = float(height) * positive_adm_scale
+ width = float(width) * patch_settings[pid].positive_adm_scale
+ height = float(height) * patch_settings[pid].positive_adm_scale
def embedder(number_list):
h = self.embedder(torch.tensor(number_list, dtype=torch.float32))
@@ -322,7 +329,7 @@ def patched_KSamplerX0Inpaint_forward(self, x, sigma, uncond, cond, cond_scale,
def timed_adm(y, timesteps):
if isinstance(y, torch.Tensor) and int(y.dim()) == 2 and int(y.shape[1]) == 5632:
- y_mask = (timesteps > 999.0 * (1.0 - float(adm_scaler_end))).to(y)[..., None]
+ y_mask = (timesteps > 999.0 * (1.0 - float(patch_settings[os.getpid()].adm_scaler_end))).to(y)[..., None]
y_with_adm = y[..., :2816].clone()
y_without_adm = y[..., 2816:].clone()
return y_with_adm * y_mask + y_without_adm * (1.0 - y_mask)
@@ -332,6 +339,7 @@ def timed_adm(y, timesteps):
def patched_cldm_forward(self, x, hint, timesteps, context, y=None, **kwargs):
t_emb = ldm_patched.ldm.modules.diffusionmodules.openaimodel.timestep_embedding(timesteps, self.model_channels, repeat_only=False).to(x.dtype)
emb = self.time_embed(t_emb)
+ pid = os.getpid()
guided_hint = self.input_hint_block(hint, emb, context)
@@ -357,19 +365,17 @@ def patched_cldm_forward(self, x, hint, timesteps, context, y=None, **kwargs):
h = self.middle_block(h, emb, context)
outs.append(self.middle_block_out(h, emb, context))
- if advanced_parameters.controlnet_softness > 0:
+ if patch_settings[pid].controlnet_softness > 0:
for i in range(10):
k = 1.0 - float(i) / 9.0
- outs[i] = outs[i] * (1.0 - advanced_parameters.controlnet_softness * k)
+ outs[i] = outs[i] * (1.0 - patch_settings[pid].controlnet_softness * k)
return outs
def patched_unet_forward(self, x, timesteps=None, context=None, y=None, control=None, transformer_options={}, **kwargs):
- global global_diffusion_progress
-
self.current_step = 1.0 - timesteps.to(x) / 999.0
- global_diffusion_progress = float(self.current_step.detach().cpu().numpy().tolist()[0])
+ patch_settings[os.getpid()].global_diffusion_progress = float(self.current_step.detach().cpu().numpy().tolist()[0])
y = timed_adm(y, timesteps)
@@ -480,6 +486,10 @@ def build_loaded(module, loader_name):
def patch_all():
+ if ldm_patched.modules.model_management.directml_enabled:
+ ldm_patched.modules.model_management.lowvram_available = True
+ ldm_patched.modules.model_management.OOM_EXCEPTION = Exception
+
patch_all_precision()
patch_all_clip()
diff --git a/modules/patch_clip.py b/modules/patch_clip.py
index 74ee436a..06b7f01b 100644
--- a/modules/patch_clip.py
+++ b/modules/patch_clip.py
@@ -16,30 +16,12 @@ 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 modules.ops import use_patched_ops
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
diff --git a/modules/patch_precision.py b/modules/patch_precision.py
index 83569bdd..22ffda0a 100644
--- a/modules/patch_precision.py
+++ b/modules/patch_precision.py
@@ -51,6 +51,8 @@ def patched_register_schedule(self, given_betas=None, beta_schedule="linear", ti
self.linear_end = linear_end
sigmas = torch.tensor(((1 - alphas_cumprod) / alphas_cumprod) ** 0.5, dtype=torch.float32)
self.set_sigmas(sigmas)
+ alphas_cumprod = torch.tensor(alphas_cumprod, dtype=torch.float32)
+ self.set_alphas_cumprod(alphas_cumprod)
return
diff --git a/modules/private_logger.py b/modules/private_logger.py
index 83ba9e36..6fdb680c 100644
--- a/modules/private_logger.py
+++ b/modules/private_logger.py
@@ -5,26 +5,49 @@ import json
import urllib.parse
from PIL import Image
+from PIL.PngImagePlugin import PngInfo
+from modules.flags import OutputFormat
+from modules.meta_parser import MetadataParser, get_exif
from modules.util import generate_temp_filename
-
log_cache = {}
-def get_current_html_path():
+def get_current_html_path(output_format=None):
+ output_format = output_format if output_format else modules.config.default_output_format
date_string, local_temp_filename, only_name = generate_temp_filename(folder=modules.config.path_outputs,
- extension='png')
+ extension=output_format)
html_name = os.path.join(os.path.dirname(local_temp_filename), 'log.html')
return html_name
-def log(img, dic):
- if args_manager.args.disable_image_log:
- return
-
- date_string, local_temp_filename, only_name = generate_temp_filename(folder=modules.config.path_outputs, extension='png')
+def log(img, metadata, metadata_parser: MetadataParser | None = None, output_format=None, task=None) -> str:
+ path_outputs = modules.config.temp_path if args_manager.args.disable_image_log else modules.config.path_outputs
+ output_format = output_format if output_format else modules.config.default_output_format
+ date_string, local_temp_filename, only_name = generate_temp_filename(folder=path_outputs, extension=output_format)
os.makedirs(os.path.dirname(local_temp_filename), exist_ok=True)
- Image.fromarray(img).save(local_temp_filename)
+
+ parsed_parameters = metadata_parser.to_string(metadata.copy()) if metadata_parser is not None else ''
+ image = Image.fromarray(img)
+
+ if output_format == OutputFormat.PNG.value:
+ if parsed_parameters != '':
+ pnginfo = PngInfo()
+ pnginfo.add_text('parameters', parsed_parameters)
+ pnginfo.add_text('fooocus_scheme', metadata_parser.get_scheme().value)
+ else:
+ pnginfo = None
+ image.save(local_temp_filename, pnginfo=pnginfo)
+ elif output_format == OutputFormat.JPEG.value:
+ image.save(local_temp_filename, quality=95, optimize=True, progressive=True, exif=get_exif(parsed_parameters, metadata_parser.get_scheme().value) if metadata_parser else Image.Exif())
+ elif output_format == OutputFormat.WEBP.value:
+ image.save(local_temp_filename, quality=95, lossless=False, exif=get_exif(parsed_parameters, metadata_parser.get_scheme().value) if metadata_parser else Image.Exif())
+ else:
+ image.save(local_temp_filename)
+
+ if args_manager.args.disable_image_log:
+ return local_temp_filename
+
html_name = os.path.join(os.path.dirname(local_temp_filename), 'log.html')
css_styles = (
@@ -32,7 +55,7 @@ def log(img, dic):
"body { background-color: #121212; color: #E0E0E0; } "
"a { color: #BB86FC; } "
".metadata { border-collapse: collapse; width: 100%; } "
- ".metadata .key { width: 15%; } "
+ ".metadata .label { 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; } "
@@ -44,16 +67,31 @@ def log(img, dic):
)
js = (
- ""
+ """"""
)
- begin_part = f"Fooocus Log {date_string} {css_styles}{js}Fooocus Log {date_string} {css_styles}{js}
Fooocus Log {date_string} (private)
\nAll images are clean, without any hidden data/meta, and safe to share with others.
\n\n" + begin_part = f"Fooocus Log {date_string} (private)
\nMetadata is embedded if enabled in the config or developer debug mode. You can find the information for each image in line Metadata Scheme.
\n\n" end_part = f'\n' middle_part = log_cache.get(html_name, "") @@ -68,14 +106,20 @@ def log(img, dic): div_name = only_name.replace('.', '_') item = f"{only_name} | "
+ item += f"{only_name} | "
item += "
| "
@@ -90,4 +134,4 @@ def log(img, dic):
log_cache[html_name] = middle_part
- return
+ return local_temp_filename
diff --git a/modules/sample_hijack.py b/modules/sample_hijack.py
index 7d8f757b..84752ede 100644
--- a/modules/sample_hijack.py
+++ b/modules/sample_hijack.py
@@ -3,6 +3,7 @@ import ldm_patched.modules.samplers
import ldm_patched.modules.model_management
from collections import namedtuple
+from ldm_patched.contrib.external_align_your_steps import AlignYourStepsScheduler
from ldm_patched.contrib.external_custom_sampler import SDTurboScheduler
from ldm_patched.k_diffusion import sampling as k_diffusion_sampling
from ldm_patched.modules.samplers import normal_scheduler, simple_scheduler, ddim_scheduler
@@ -99,6 +100,13 @@ def sample_hacked(model, noise, positive, negative, cfg, device, sampler, sigmas
calculate_start_end_timesteps(model, negative)
calculate_start_end_timesteps(model, positive)
+ if latent_image is not None:
+ latent_image = model.process_latent_in(latent_image)
+
+ if hasattr(model, 'extra_conds'):
+ positive = encode_model_conds(model.extra_conds, positive, noise, device, "positive", latent_image=latent_image, denoise_mask=denoise_mask)
+ negative = encode_model_conds(model.extra_conds, negative, noise, device, "negative", latent_image=latent_image, denoise_mask=denoise_mask)
+
#make sure each cond area has an opposite one with the same area
for c in positive:
create_cond_with_same_area_if_none(negative, c)
@@ -111,13 +119,6 @@ def sample_hacked(model, noise, positive, negative, cfg, device, sampler, sigmas
apply_empty_x_to_equal_area(list(filter(lambda c: c.get('control_apply_to_uncond', False) == True, positive)), negative, 'control', lambda cond_cnets, x: cond_cnets[x])
apply_empty_x_to_equal_area(positive, negative, 'gligen', lambda cond_cnets, x: cond_cnets[x])
- if latent_image is not None:
- latent_image = model.process_latent_in(latent_image)
-
- if hasattr(model, 'extra_conds'):
- positive = encode_model_conds(model.extra_conds, positive, noise, device, "positive", latent_image=latent_image, denoise_mask=denoise_mask)
- negative = encode_model_conds(model.extra_conds, negative, noise, device, "negative", latent_image=latent_image, denoise_mask=denoise_mask)
-
extra_args = {"cond":positive, "uncond":negative, "cond_scale": cfg, "model_options": model_options, "seed":seed}
if current_refiner is not None and hasattr(current_refiner.model, 'extra_conds'):
@@ -174,7 +175,10 @@ def calculate_sigmas_scheduler_hacked(model, scheduler_name, steps):
elif scheduler_name == "sgm_uniform":
sigmas = normal_scheduler(model, steps, sgm=True)
elif scheduler_name == "turbo":
- sigmas = SDTurboScheduler().get_sigmas(namedtuple('Patcher', ['model'])(model=model), steps)[0]
+ sigmas = SDTurboScheduler().get_sigmas(model=model, steps=steps, denoise=1.0)[0]
+ elif scheduler_name == "align_your_steps":
+ model_type = 'SDXL' if isinstance(model.latent_format, ldm_patched.modules.latent_formats.SDXL) else 'SD1'
+ sigmas = AlignYourStepsScheduler().get_sigmas(model_type=model_type, steps=steps, denoise=1.0)[0]
else:
raise TypeError("error invalid scheduler")
return sigmas
diff --git a/modules/sdxl_styles.py b/modules/sdxl_styles.py
index f5bb6276..12ab6c5c 100644
--- a/modules/sdxl_styles.py
+++ b/modules/sdxl_styles.py
@@ -1,14 +1,13 @@
import os
import re
import json
+import math
-from modules.util import get_files_from_folder
-
+from modules.extra_utils import get_files_from_folder
+from random import Random
# cannot use modules.config - validators causing circular imports
styles_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '../sdxl_styles/'))
-wildcards_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '../wildcards/'))
-wildcards_max_bfs_depth = 64
def normalize_key(k):
@@ -24,7 +23,6 @@ def normalize_key(k):
styles = {}
-
styles_files = get_files_from_folder(styles_path, ['.json'])
for x in ['sdxl_styles_fooocus.json',
@@ -50,8 +48,13 @@ for styles_file in styles_files:
print(f'Failed to load style file {styles_file}')
style_keys = list(styles.keys())
-fooocus_expansion = "Fooocus V2"
-legal_style_names = [fooocus_expansion] + style_keys
+fooocus_expansion = 'Fooocus V2'
+random_style_name = 'Random Style'
+legal_style_names = [fooocus_expansion, random_style_name] + style_keys
+
+
+def get_random_style(rng: Random) -> str:
+ return rng.choice(list(styles.items()))[0]
def apply_style(style, positive):
@@ -59,24 +62,36 @@ def apply_style(style, positive):
return p.replace('{prompt}', positive).splitlines(), n.splitlines()
-def apply_wildcards(wildcard_text, rng, directory=wildcards_path):
- for _ in range(wildcards_max_bfs_depth):
- placeholders = re.findall(r'__([\w-]+)__', wildcard_text)
- if len(placeholders) == 0:
- return wildcard_text
+def get_words(arrays, total_mult, index):
+ if len(arrays) == 1:
+ return [arrays[0].split(',')[index]]
+ else:
+ words = arrays[0].split(',')
+ word = words[index % len(words)]
+ index -= index % len(words)
+ index /= len(words)
+ index = math.floor(index)
+ return [word] + get_words(arrays[1:], math.floor(total_mult / len(words)), index)
- print(f'[Wildcards] processing: {wildcard_text}')
- for placeholder in placeholders:
- try:
- words = open(os.path.join(directory, f'{placeholder}.txt'), encoding='utf-8').read().splitlines()
- words = [x for x in words if x != '']
- assert len(words) > 0
- wildcard_text = wildcard_text.replace(f'__{placeholder}__', rng.choice(words), 1)
- except:
- print(f'[Wildcards] Warning: {placeholder}.txt missing or empty. '
- f'Using "{placeholder}" as a normal word.')
- wildcard_text = wildcard_text.replace(f'__{placeholder}__', placeholder)
- print(f'[Wildcards] {wildcard_text}')
- print(f'[Wildcards] BFS stack overflow. Current text: {wildcard_text}')
- return wildcard_text
+def apply_arrays(text, index):
+ arrays = re.findall(r'\[\[(.*?)\]\]', text)
+ if len(arrays) == 0:
+ return text
+
+ print(f'[Arrays] processing: {text}')
+ mult = 1
+ for arr in arrays:
+ words = arr.split(',')
+ mult *= len(words)
+
+ index %= mult
+ chosen_words = get_words(arrays, mult, index)
+
+ i = 0
+ for arr in arrays:
+ text = text.replace(f'[[{arr}]]', chosen_words[i], 1)
+ i = i+1
+
+ return text
+
diff --git a/modules/ui_gradio_extensions.py b/modules/ui_gradio_extensions.py
index e59b151b..409c7e33 100644
--- a/modules/ui_gradio_extensions.py
+++ b/modules/ui_gradio_extensions.py
@@ -30,6 +30,7 @@ def javascript_html():
edit_attention_js_path = webpath('javascript/edit-attention.js')
viewer_js_path = webpath('javascript/viewer.js')
image_viewer_js_path = webpath('javascript/imageviewer.js')
+ samples_path = webpath(os.path.abspath('./sdxl_styles/samples/fooocus_v2.jpg'))
head = f'\n'
head += f'\n'
head += f'\n'
@@ -38,6 +39,7 @@ def javascript_html():
head += f'\n'
head += f'\n'
head += f'\n'
+ head += f'\n'
if args_manager.args.theme:
head += f'\n'
diff --git a/modules/util.py b/modules/util.py
index fce7efd7..5003f79a 100644
--- a/modules/util.py
+++ b/modules/util.py
@@ -1,14 +1,41 @@
+from pathlib import Path
+
import numpy as np
import datetime
import random
import math
import os
+import cv2
+import re
+from typing import List, Tuple, AnyStr, NamedTuple
+
+import json
+import hashlib
from PIL import Image
+import modules.config
+import modules.sdxl_styles
+from modules.flags import Performance
LANCZOS = (Image.Resampling.LANCZOS if hasattr(Image, 'Resampling') else Image.LANCZOS)
+# Regexp compiled once. Matches entries with the following pattern:
+#