{self.commit_hash[:8]}
{format_dt(ts2utc(self.commit_date))}
" except Exception as ex: - shared.log.error(f"Extension: failed reading data from git repo={self.name}: {ex}") + logger.log.error(f"Extension: failed reading data from git repo={self.name}: {ex}") self.remote = None def list_files(self, subdir, extension): @@ -190,7 +191,7 @@ class Extension: priority = str(f.read().strip()) res.append(scripts_manager.ScriptFile(self.path, filename, os.path.join(dirpath, filename), priority)) if priority != '50': - shared.log.debug(f'Extension priority override: {os.path.dirname(dirpath)}:{priority}') + logger.log.debug(f'Extension priority override: {os.path.dirname(dirpath)}:{priority}') res = [x for x in res if os.path.splitext(x.path)[1].lower() == extension and os.path.isfile(x.path)] return res @@ -233,7 +234,7 @@ def list_extensions(): if not os.path.isdir(extensions_dir): return if shared.opts.disable_all_extensions == "all" or shared.opts.disable_all_extensions == "user": - shared.log.warning(f"Option set: Disable extensions: {shared.opts.disable_all_extensions}") + logger.log.warning(f"Option set: Disable extensions: {shared.opts.disable_all_extensions}") extension_paths = [] extension_names = [] extension_folders = [extensions_builtin_dir] if shared.cmd_opts.safe else [extensions_builtin_dir, extensions_dir] @@ -245,7 +246,7 @@ def list_extensions(): if not os.path.isdir(path): continue if extension_dirname in extension_names: - shared.log.info(f'Skipping conflicting extension: {path}') + logger.log.info(f'Skipping conflicting extension: {path}') continue extension_names.append(extension_dirname) extension_paths.append((extension_dirname, path, dirname == extensions_builtin_dir)) @@ -256,4 +257,4 @@ def list_extensions(): enabled = dirname.lower() not in disabled_extensions extension = Extension(name=dirname, path=path, enabled=enabled, is_builtin=is_builtin) extensions.append(extension) - shared.log.debug(f'Extensions: disabled={[e.name for e in extensions if not e.enabled]}') + logger.log.debug(f'Extensions: disabled={[e.name for e in extensions if not e.enabled]}') diff --git a/modules/extra_networks.py b/modules/extra_networks.py index 66edf76a3..33201f524 100644 --- a/modules/extra_networks.py +++ b/modules/extra_networks.py @@ -2,6 +2,7 @@ import re import inspect from collections import defaultdict from modules import errors, shared +from modules import logger extra_network_registry = {} @@ -89,14 +90,14 @@ def activate(p, extra_network_data=None, step=0, include=None, exclude=None): stepwise = stepwise or is_stepwise(extra_network_args) functional = shared.opts.lora_functional if shared.opts.lora_force_diffusers and stepwise: - shared.log.warning("Network load: type=LoRA method=composable loader=diffusers not compatible") + logger.log.warning("Network load: type=LoRA method=composable loader=diffusers not compatible") stepwise = False shared.opts.data['lora_functional'] = stepwise or functional for extra_network_name, extra_network_args in extra_network_data.items(): extra_network = extra_network_registry.get(extra_network_name, None) if extra_network is None: - errors.log.warning(f"Skipping unknown extra network: {extra_network_name}") + logger.log.warning(f"Skipping unknown extra network: {extra_network_name}") continue try: signature = list(inspect.signature(extra_network.activate).parameters) diff --git a/modules/extras.py b/modules/extras.py index 7b2c9e6d6..6a8ffbd78 100644 --- a/modules/extras.py +++ b/modules/extras.py @@ -9,6 +9,7 @@ import gradio as gr import safetensors.torch from modules.merging import merge, merge_utils, modules_sdxl from modules import shared, images, sd_models, sd_vae, sd_samplers, devices +from modules import logger def run_pnginfo(image): @@ -35,7 +36,7 @@ def run_modelmerger(id_task, **kwargs): # pylint: disable=unused-argument try: pass # pylint: disable=unused-import except Exception as e: - shared.log.error(f"Merge: {e}") + logger.log.error(f"Merge: {e}") return [*[gr.update() for _ in range(4)], "tensordict not available"] jobid = shared.state.begin('Merge') @@ -74,7 +75,7 @@ def run_modelmerger(id_task, **kwargs): # pylint: disable=unused-argument assert len(alpha) == 26 or len(alpha) == 20, "Alpha Block Weights are wrong length (26 or 20 for SDXL)" kwargs["alpha"] = alpha except KeyError as ke: - shared.log.warning(f"Merge: Malformed manual block weight: {ke}") + logger.log.warning(f"Merge: Malformed manual block weight: {ke}") elif kwargs.get("alpha_preset", None) or kwargs.get("alpha", None): kwargs["alpha"] = kwargs.get("alpha_preset", kwargs["alpha"]) @@ -91,7 +92,7 @@ def run_modelmerger(id_task, **kwargs): # pylint: disable=unused-argument assert len(beta) == 26 or len(beta) == 20, "Beta Block Weights are wrong length (26 or 20 for SDXL)" kwargs["beta"] = beta except KeyError as ke: - shared.log.warning(f"Merge: Malformed manual block weight: {ke}") + logger.log.warning(f"Merge: Malformed manual block weight: {ke}") elif kwargs.get("beta_preset", None) or kwargs.get("beta", None): kwargs["beta"] = kwargs.get("beta_preset", kwargs["beta"]) @@ -123,7 +124,7 @@ def run_modelmerger(id_task, **kwargs): # pylint: disable=unused-argument bake_in_vae_filename = sd_vae.vae_dict.get(kwargs.get("bake_in_vae", None), None) if bake_in_vae_filename is not None: - shared.log.info(f"Merge VAE='{bake_in_vae_filename}'") + logger.log.info(f"Merge VAE='{bake_in_vae_filename}'") shared.state.textinfo = 'Merge VAE' vae_dict = sd_vae.load_vae_dict(bake_in_vae_filename) for key in vae_dict.keys(): @@ -179,7 +180,7 @@ def run_modelmerger(id_task, **kwargs): # pylint: disable=unused-argument torch.save(theta_0, output_modelname) t1 = time.time() - shared.log.info(f"Merge complete: saved='{output_modelname}' time={t1-t0:.2f}") + logger.log.info(f"Merge complete: saved='{output_modelname}' time={t1-t0:.2f}") sd_models.list_models() created_model = next((ckpt for ckpt in sd_models.checkpoints_list.values() if ckpt.name == filename), None) if created_model: @@ -200,9 +201,9 @@ def run_model_modules(model_type:str, model_name:str, custom_name:str, def msg(text, err:bool=False): nonlocal status if err: - shared.log.error(f'Modules merge: {text}') + logger.log.error(f'Modules merge: {text}') else: - shared.log.info(f'Modules merge: {text}') + logger.log.info(f'Modules merge: {text}') status += text + '{summary} {memory}
| {install_code} | """ code += "
' + str(ts) + '
' def list_items(self): - # shared.log.trace('History list') + # logger.log.trace('History list') for item in shared.history.latents: title = ', '.join(list(set(item.ops))) + 'Video
| Size {stat_size:,}
@@ -54,7 +55,7 @@ def read_media(fn):
def create_ui():
- shared.log.debug('UI initialize: tab=gallery')
+ logger.log.debug('UI initialize: tab=gallery')
with gr.Blocks() as tab:
with gr.Row(elem_id='tab-gallery-sort-buttons'):
sort_buttons = []
diff --git a/modules/ui_img2img.py b/modules/ui_img2img.py
index 7828bc8ab..add0897ff 100644
--- a/modules/ui_img2img.py
+++ b/modules/ui_img2img.py
@@ -1,6 +1,7 @@
import gradio as gr
from modules import timer, shared, call_queue, generation_parameters_copypaste, processing_vae
from modules import ui_common, ui_sections, ui_guidance
+from modules import logger
def process_caption(mode, ii_input_files, ii_input_dir, ii_output_dir, *ii_singles):
@@ -17,7 +18,7 @@ def process_caption(mode, ii_input_files, ii_input_dir, ii_output_dir, *ii_singl
images = [f.name for f in ii_input_files]
else:
if not os.path.isdir(ii_input_dir):
- shared.log.error(f"Caption: Input directory not found: {ii_input_dir}")
+ logger.log.error(f"Caption: Input directory not found: {ii_input_dir}")
return [gr.update(), None]
images = os.listdir(ii_input_dir)
if ii_output_dir != "":
@@ -33,7 +34,7 @@ def process_caption(mode, ii_input_files, ii_input_dir, ii_output_dir, *ii_singl
def create_ui():
- shared.log.debug('UI initialize: tab=img2img')
+ logger.log.debug('UI initialize: tab=img2img')
import modules.img2img # pylint: disable=redefined-outer-name
modules.scripts_manager.scripts_current = modules.scripts_manager.scripts_img2img
modules.scripts_manager.scripts_img2img.initialize_scripts(is_img2img=True, is_control=False)
diff --git a/modules/ui_javascript.py b/modules/ui_javascript.py
index 5c5f966a8..e2ae619ef 100644
--- a/modules/ui_javascript.py
+++ b/modules/ui_javascript.py
@@ -4,6 +4,7 @@ import gradio.utils
from modules import shared, theme
from modules.paths import script_path, data_path
import modules.scripts_manager
+from modules import logger
def webpath(fn):
@@ -81,17 +82,17 @@ def html_css(css: list[str]):
themecss = os.path.join(script_path, "javascript", f"{modules.shared.opts.gradio_theme}.css")
if os.path.exists(themecss):
head += stylesheet(themecss)
- modules.shared.log.debug(f'UI theme: css="{themecss}" base="{css}" user="{usercss}"')
+ modules.logger.log.debug(f'UI theme: css="{themecss}" base="{css}" user="{usercss}"')
else:
- modules.shared.log.error(f'UI theme: css="{themecss}" not found')
+ modules.logger.log.error(f'UI theme: css="{themecss}" not found')
elif modules.shared.opts.theme_type == 'Modern':
theme_folder = next((e.path for e in modules.extensions.extensions if e.name == 'sdnext-modernui'), None)
themecss = os.path.join(theme_folder or '', 'themes', f'{modules.shared.opts.gradio_theme}.css')
if os.path.exists(themecss):
head += stylesheet(themecss)
- modules.shared.log.debug(f'UI theme: css="{themecss}" base="{css}" user="{usercss}"')
+ modules.logger.log.debug(f'UI theme: css="{themecss}" base="{css}" user="{usercss}"')
else:
- modules.shared.log.error(f'UI theme: css="{themecss}" not found')
+ modules.logger.log.error(f'UI theme: css="{themecss}" not found')
if usercss is not None:
head += stylesheet(usercss)
return head
diff --git a/modules/ui_loadsave.py b/modules/ui_loadsave.py
index ff054f686..3b508418c 100644
--- a/modules/ui_loadsave.py
+++ b/modules/ui_loadsave.py
@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, cast
import os
import gradio as gr
from modules import errors
+from modules import logger
from modules.ui_components import ToolButton
@@ -46,7 +47,7 @@ class UiLoadsave:
if init_field is not None:
init_field(saved_value)
if debug_ui and key in self.component_mapping and not key.startswith('customscript'):
- errors.log.warning(f'UI duplicate: key="{key}" id={getattr(obj, "elem_id", None)} class={getattr(obj, "elem_classes", None)}')
+ logger.log.warning(f'UI duplicate: key="{key}" id={getattr(obj, "elem_id", None)} class={getattr(obj, "elem_classes", None)}')
if hasattr(obj, 'skip'):
pass
if (field == 'value') and (key not in self.component_mapping):
@@ -81,7 +82,7 @@ class UiLoadsave:
if type(x) == gr.Dropdown:
def check_dropdown(val):
if x.choices is None:
- errors.log.warning(f'UI: path={path} value={getattr(x, "value", None)}, choices={getattr(x, "choices", None)}')
+ logger.log.warning(f'UI: path={path} value={getattr(x, "value", None)}, choices={getattr(x, "choices", None)}')
return False
choices = [c[0] for c in x.choices] if type(x.choices) == list and len(x.choices) > 0 and type(x.choices[0]) == tuple else x.choices
if getattr(x, 'multiselect', False):
@@ -232,7 +233,7 @@ class UiLoadsave:
else:
name, old_value, new_value, default_value = x
component = self.component_mapping[name]
- errors.log.debug(f'Settings: name={name} component={component} old={old_value} default={default_value} new={new_value}')
+ logger.log.debug(f'Settings: name={name} component={component} old={old_value} default={default_value} new={new_value}')
num_changed += 1
current_ui_settings[name] = new_value
# what = name.split('/')[-1]
@@ -240,7 +241,7 @@ class UiLoadsave:
if num_changed == 0:
return "No changes"
self.write_to_file(current_ui_settings)
- errors.log.info(f'UI defaults saved: {self.filename} changes={num_changed} unchanged={num_unchanged}')
+ logger.log.info(f'UI defaults saved: {self.filename} changes={num_changed} unchanged={num_unchanged}')
return f"Wrote {num_changed} changes"
def ui_submenu_apply(self, items):
@@ -266,21 +267,21 @@ class UiLoadsave:
num_changed = 0
current_ui_settings = self.read_from_file()
for name, _old_value, new_value, default_value in self.iter_menus():
- errors.log.debug(f'Settings: name={name} default={default_value} new={new_value}')
+ logger.log.debug(f'Settings: name={name} default={default_value} new={new_value}')
num_changed += 1
current_ui_settings[name] = new_value
if num_changed == 0:
text += '
No changes'
else:
self.write_to_file(current_ui_settings)
- errors.log.info(f'UI defaults saved: {self.filename}')
+ logger.log.info(f'UI defaults saved: {self.filename}')
text += f'
Changes: {num_changed}'
return text
def ui_restore(self):
if os.path.exists(self.filename):
os.remove(self.filename)
- errors.log.info(f'UI defaults reset: {self.filename}')
+ logger.log.info(f'UI defaults reset: {self.filename}')
return "Restored system defaults for user interface"
def create_ui(self):
diff --git a/modules/ui_models_load.py b/modules/ui_models_load.py
index d63a63d20..10386e499 100644
--- a/modules/ui_models_load.py
+++ b/modules/ui_models_load.py
@@ -6,24 +6,25 @@ import torch
import diffusers
from huggingface_hub import hf_hub_download
from modules import shared, errors, shared_items, sd_models, sd_checkpoint, devices, model_quant, modelloader
+from modules import logger
debug_enabled = os.environ.get('SD_LOAD_DEBUG', None)
-debug_log = shared.log.trace if debug_enabled else lambda *args, **kwargs: None
+debug_log = logger.log.trace if debug_enabled else lambda *args, **kwargs: None
components = []
def load_model(model: str, cls: str, repo: str, dataframes: list):
if cls is None:
- shared.log.error('Model load: class is None')
+ logger.log.error('Model load: class is None')
return 'Model load: class is None'
if repo is None:
- shared.log.error('Model load: repo is None')
+ logger.log.error('Model load: repo is None')
return 'Model load: repo is None'
cls = getattr(diffusers, cls, None)
if cls is None:
cls = diffusers.AutoPipelineForText2Image
- shared.log.info(f'Model load: name="{model}" cls={cls.__name__} repo="{repo}"')
+ logger.log.info(f'Model load: name="{model}" cls={cls.__name__} repo="{repo}"')
kwargs = {}
for df in dataframes:
c = [x for x in components if x.id == df[0]]
@@ -43,8 +44,8 @@ def load_model(model: str, cls: str, repo: str, dataframes: list):
instance = c.load()
if instance is not None:
kwargs[c.name] = instance
- shared.log.info(f'Model component: instance={instance.__class__.__name__}')
- shared.log.info(f'Model load: name="{model}" cls={cls.__name__} repo="{repo}" preload={kwargs.keys()}')
+ logger.log.info(f'Model component: instance={instance.__class__.__name__}')
+ logger.log.info(f'Model load: name="{model}" cls={cls.__name__} repo="{repo}" preload={kwargs.keys()}')
pipe = None
if model == 'Current':
for k, v in kwargs.items():
@@ -61,11 +62,11 @@ def load_model(model: str, cls: str, repo: str, dataframes: list):
**kwargs,
)
except Exception as e:
- shared.log.error(f'Model load: name="{model}" {e}')
+ logger.log.error(f'Model load: name="{model}" {e}')
errors.display(e, 'Model load')
return f'Model load failed: {e}'
if pipe is not None:
- shared.log.info(f'Model load: name="{model}" cls={cls.__name__} repo="{repo}" instance={pipe.__class__.__name__}')
+ logger.log.info(f'Model load: name="{model}" cls={cls.__name__} repo="{repo}" instance={pipe.__class__.__name__}')
shared.sd_model = pipe
shared.sd_model.sd_checkpoint_info = sd_checkpoint.CheckpointInfo(repo)
shared.sd_model.sd_model_hash = None
@@ -206,7 +207,7 @@ class Component:
debug_log(f'Model load component: name="{self.name}" cls={self.cls} no handler')
return None
except Exception as e:
- shared.log.error(f'Model load component: name="{self.name}" {e}')
+ logger.log.error(f'Model load component: name="{self.name}" {e}')
errors.display(e, 'Model load component')
return None
@@ -237,7 +238,7 @@ def create_ui(gr_status, gr_file):
link = f'Link
{repo}' if repo else ''
get_components(cls)
dataframes = [c.dataframe() for c in components]
- shared.log.debug(f'Model select: name="{model}" cls={name} repo="{repo}" link={link} components={len(components)}')
+ logger.log.debug(f'Model select: name="{model}" cls={name} repo="{repo}" link={link} components={len(components)}')
return [name, repo, link, dataframes]
def update_component(dataframes):
@@ -257,7 +258,7 @@ def create_ui(gr_status, gr_file):
def load_receipe(file_select):
if file_select is not None and 'name' in file_select:
fn = file_select['name']
- shared.log.debug(f'Load receipe: fn={fn}')
+ logger.log.debug(f'Load receipe: fn={fn}')
return ['Load receipe not implemented yet', gr.update(label='Receipe .json file', file_types=['json'], visible=True)]
# TODO loader: save receipe
diff --git a/modules/ui_postprocessing.py b/modules/ui_postprocessing.py
index 92c80697e..65aafa590 100644
--- a/modules/ui_postprocessing.py
+++ b/modules/ui_postprocessing.py
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, shared, ui_common, postprocessing, call_queue, generation_parameters_copypaste
+from modules import logger
def submit_info(image):
@@ -18,7 +19,7 @@ def submit_process(tab_index, extras_image, image_batch, extras_batch_input_dir,
def create_ui():
- shared.log.debug('UI initialize: tab=process')
+ logger.log.debug('UI initialize: tab=process')
tab_index = gr.State(value=0) # pylint: disable=abstract-class-instantiated
with gr.Row(equal_height=False, variant='compact', elem_classes="extras", elem_id="extras_tab"):
with gr.Column(variant='compact'):
diff --git a/modules/ui_sections.py b/modules/ui_sections.py
index 4930446f2..635ed47ef 100644
--- a/modules/ui_sections.py
+++ b/modules/ui_sections.py
@@ -1,5 +1,6 @@
import gradio as gr
from modules import shared, modelloader, ui_symbols, ui_common, sd_samplers
+from modules import logger
from modules.ui_components import ToolButton
from modules.caption import caption
@@ -69,7 +70,7 @@ def ar_change(ar, width, height):
try:
(w, h) = [float(x) for x in ar.split(':')]
except Exception as e:
- shared.log.warning(f"Invalid aspect ratio: {ar} {e}")
+ logger.log.warning(f"Invalid aspect ratio: {ar} {e}")
return gr.update(), gr.update()
if w > h:
return gr.update(), gr.update(value=int(width * h / w))
@@ -199,48 +200,48 @@ def create_sampler_options(tabname):
shared.opts.data['schedulers_use_thresholding'] = 'thresholding' in sampler_options
shared.opts.data['schedulers_use_loworder'] = 'low order' in sampler_options
shared.opts.data['schedulers_rescale_betas'] = 'rescale' in sampler_options
- shared.log.debug(f'Sampler set options: {sampler_options}')
+ logger.log.debug(f'Sampler set options: {sampler_options}')
shared.opts.save(silent=True)
def set_sampler_timesteps(timesteps):
- shared.log.debug(f'Sampler set options: timesteps={timesteps}')
+ logger.log.debug(f'Sampler set options: timesteps={timesteps}')
shared.opts.schedulers_timesteps = timesteps
shared.opts.save(silent=True)
def set_sampler_spacing(spacing):
- shared.log.debug(f'Sampler set options: spacing={spacing}')
+ logger.log.debug(f'Sampler set options: spacing={spacing}')
shared.opts.schedulers_timestep_spacing = spacing
shared.opts.save(silent=True)
def set_sampler_sigma(sampler_sigma):
- shared.log.debug(f'Sampler set options: sigma={sampler_sigma}')
+ logger.log.debug(f'Sampler set options: sigma={sampler_sigma}')
shared.opts.schedulers_sigma = sampler_sigma
shared.opts.save(silent=True)
def set_sampler_order(sampler_order):
- shared.log.debug(f'Sampler set options: order={sampler_order}')
+ logger.log.debug(f'Sampler set options: order={sampler_order}')
shared.opts.schedulers_solver_order = sampler_order
shared.opts.save(silent=True)
def set_sampler_prediction(sampler_prediction):
- shared.log.debug(f'Sampler set options: prediction={sampler_prediction}')
+ logger.log.debug(f'Sampler set options: prediction={sampler_prediction}')
shared.opts.schedulers_prediction_type = sampler_prediction
shared.opts.save(silent=True)
def set_sampler_beta(sampler_beta):
- shared.log.debug(f'Sampler set options: beta={sampler_beta}')
+ logger.log.debug(f'Sampler set options: beta={sampler_beta}')
shared.opts.schedulers_beta_schedule = sampler_beta
shared.opts.save(silent=True)
def set_sampler_shift(sampler_shift, sampler_base_shift, sampler_max_shift):
- shared.log.debug(f'Sampler set options: shift={sampler_shift} base={sampler_base_shift} max={sampler_max_shift}')
+ logger.log.debug(f'Sampler set options: shift={sampler_shift} base={sampler_base_shift} max={sampler_max_shift}')
shared.opts.schedulers_shift = sampler_shift
shared.opts.schedulers_base_shift = sampler_base_shift
shared.opts.schedulers_max_shift = sampler_max_shift
shared.opts.save(silent=True)
def set_sigma_adjust(val, start, end):
- shared.log.debug(f'Sampler set options: sigma={val} min={start} max={end}')
+ logger.log.debug(f'Sampler set options: sigma={val} min={start} max={end}')
shared.opts.schedulers_sigma_adjust = val
shared.opts.schedulers_sigma_adjust_min = start
shared.opts.schedulers_sigma_adjust_max = end
diff --git a/modules/ui_settings.py b/modules/ui_settings.py
index 247325b3f..a64a3a6f0 100644
--- a/modules/ui_settings.py
+++ b/modules/ui_settings.py
@@ -2,6 +2,7 @@ import os
import gradio as gr
from modules import timer, shared, paths, theme, sd_models, modelloader, generation_parameters_copypaste, call_queue, script_callbacks
from modules import ui_common, ui_loadsave, ui_history, ui_components, ui_symbols
+from modules import logger
text_settings = None # holds json of entire shared.opts
@@ -91,14 +92,14 @@ def create_setting_component(key, is_quicksettings=False):
try:
res = comp(label=info.label, value=fun(), elem_id=elem_id, **args)
except Exception as e:
- shared.log.error(f'Error creating setting: {key} {e}')
+ logger.log.error(f'Error creating setting: {key} {e}')
res = None
if res is not None and not is_quicksettings:
try:
res.change(fn=None, inputs=res, _js=f'(val) => markIfModified("{key}", val)')
except Exception as e:
- shared.log.error(f'Quicksetting: component={res} {e}')
+ logger.log.error(f'Quicksetting: component={res} {e}')
if dirty_indicator is not None:
dirty_indicator.click(fn=lambda: shared.opts.get_default(key), outputs=[res], show_progress='hidden')
dirtyable_setting.__exit__()
@@ -108,7 +109,7 @@ def create_setting_component(key, is_quicksettings=False):
def create_dirty_indicator(key, keys_to_reset, **kwargs):
def get_default_values():
values = [shared.opts.get_default(key) for key in keys_to_reset]
- shared.log.debug(f'Settings restore: section={key} keys={keys_to_reset} values={values}')
+ logger.log.debug(f'Settings restore: section={key} keys={keys_to_reset} values={values}')
return values
elements_to_reset = [shared.settings_components[_key] for _key in keys_to_reset if shared.settings_components[_key] is not None]
@@ -123,10 +124,10 @@ def run_settings(*args):
if comp == dummy_component or value=='dummy': # or getattr(comp, 'visible', True) is False or key in hidden_list:
# actual = shared.opts.data.get(key, None) # ensure the key is in data
# default = shared.opts.data_labels[key].default
- # shared.log.warning(f'Setting skip: key={key} value={value} actual={actual} default={default} comp={comp}')
+ # logger.log.warning(f'Setting skip: key={key} value={value} actual={actual} default={default} comp={comp}')
continue
if not shared.opts.same_type(value, shared.opts.data_labels[key].default):
- shared.log.error(f'Setting bad value: {key}={value} expecting={type(shared.opts.data_labels[key].default).__name__}')
+ logger.log.error(f'Setting bad value: {key}={value} expecting={type(shared.opts.data_labels[key].default).__name__}')
continue
if shared.opts.set(key, value):
changed.append(key)
@@ -139,20 +140,20 @@ def run_settings(*args):
directml_override_opts()
if shared.cmd_opts.use_openvino:
if "Model" not in shared.opts.cuda_compile:
- shared.log.warning("OpenVINO: Enabling Torch Compile Model")
+ logger.log.warning("OpenVINO: Enabling Torch Compile Model")
shared.opts.cuda_compile.append("Model")
if shared.opts.cuda_compile_backend != "openvino_fx":
- shared.log.warning("OpenVINO: Setting Torch Compiler backend to OpenVINO FX")
+ logger.log.warning("OpenVINO: Setting Torch Compiler backend to OpenVINO FX")
shared.opts.cuda_compile_backend = "openvino_fx"
if shared.opts.sd_backend != "diffusers":
- shared.log.error('Legacy option: backend=original is no longer supported')
+ logger.log.error('Legacy option: backend=original is no longer supported')
shared.opts.sd_backend = "diffusers"
try:
if len(changed) > 0:
shared.opts.save()
- shared.log.info(f'Settings: changed={len(changed)} {changed}')
+ logger.log.info(f'Settings: changed={len(changed)} {changed}')
except RuntimeError:
- shared.log.error(f'Settings failed: change={len(changed)} {changed}')
+ logger.log.error(f'Settings failed: change={len(changed)} {changed}')
return shared.opts.dumpjson(), f'{len(changed)} Settings changed without save: {", ".join(changed)}'
return shared.opts.dumpjson(), f'{len(changed)} Settings changed{": " if len(changed) > 0 else ""}{", ".join(changed)}'
@@ -169,14 +170,14 @@ def run_settings_single(value, key, progress=False):
directml_override_opts()
shared.opts.save()
if key not in ['sd_model_checkpoint', 'sd_model_refiner', 'sd_vae', 'sd_te', 'sd_unet']:
- shared.log.debug(f'Setting changed: {key}={value} progress={progress}')
+ logger.log.debug(f'Setting changed: {key}={value} progress={progress}')
return get_value_for_setting(key), shared.opts.dumpjson()
def create_ui(disabled_tabs=None):
if disabled_tabs is None:
disabled_tabs = []
- shared.log.debug('UI initialize: tab=settings')
+ logger.log.debug('UI initialize: tab=settings')
global text_settings # pylint: disable=global-statement
text_settings = gr.Textbox(elem_id="settings_json", elem_classes=["settings_json"], value=lambda: shared.opts.dumpjson(), visible=False)
@@ -189,7 +190,7 @@ def create_ui(disabled_tabs=None):
def switch_profiling():
shared.cmd_opts.profile = not shared.cmd_opts.profile
- shared.log.warning(f'Profiling: {shared.cmd_opts.profile}')
+ logger.log.warning(f'Profiling: {shared.cmd_opts.profile}')
return 'Stop profiling' if shared.cmd_opts.profile else 'Start profiling'
if 'system' not in disabled_tabs:
@@ -236,7 +237,7 @@ def create_ui(disabled_tabs=None):
for (section_id, section_text) in sections:
items = [item for item in shared.opts.data_labels.items() if item[1].section[0] == section_id] # find all items in this section
hidden = section_id is None or 'hidden' in section_id.lower() or 'hidden' in section_text.lower()
- # shared.log.trace(f'Settings: section="{section_id}" title="{section_text}" items={len(items)} hidden={hidden}')
+ # logger.log.trace(f'Settings: section="{section_id}" title="{section_text}" items={len(items)} hidden={hidden}')
if hidden:
for (key, _item) in items:
hidden_list.append(key)
@@ -257,13 +258,13 @@ def create_ui(disabled_tabs=None):
create_dirty_indicator(section_id, current_items)
components_count = len(components)
if components_count != options_count:
- shared.log.error(f'Settings: count mismatch: options={options_count} components={components_count}')
+ logger.log.error(f'Settings: count mismatch: options={options_count} components={components_count}')
with gr.TabItem("Show all pages", elem_id="settings_show_all_pages"):
create_dirty_indicator("show_all_pages", [])
request_notifications = gr.Button(value='Request browser notifications', elem_id="request_notifications", visible=False)
- shared.log.debug(f'Settings: sections={len(sections)} settings={len(shared.opts.list())}/{len(list(shared.opts.data_labels))} quicksettings={len(quicksettings_list)}')
+ logger.log.debug(f'Settings: sections={len(sections)} settings={len(shared.opts.list())}/{len(list(shared.opts.data_labels))} quicksettings={len(quicksettings_list)}')
if 'update' not in disabled_tabs:
with gr.TabItem("Update", id="system_update", elem_id="tab_update"):
@@ -316,7 +317,7 @@ def reset_quicksettings(quick_components):
quick_components = quick_components.split(',')
updates = []
for key in quick_components:
- shared.log.warning(f'Reset: setting={key}')
+ logger.log.warning(f'Reset: setting={key}')
updates.append(gr.update(value=shared.opts.get_default(key)))
return updates
diff --git a/modules/ui_txt2img.py b/modules/ui_txt2img.py
index aea99fa1e..3a2ba43b7 100644
--- a/modules/ui_txt2img.py
+++ b/modules/ui_txt2img.py
@@ -1,10 +1,11 @@
import gradio as gr
from modules import timer, shared, call_queue, generation_parameters_copypaste, processing_vae, images
from modules import ui_common, ui_sections, ui_guidance
+from modules import logger
def create_ui():
- shared.log.debug('UI initialize: tab=txt2img')
+ logger.log.debug('UI initialize: tab=txt2img')
import modules.txt2img # pylint: disable=redefined-outer-name
modules.scripts_manager.scripts_current = modules.scripts_manager.scripts_txt2img
modules.scripts_manager.scripts_txt2img.initialize_scripts(is_img2img=False, is_control=False)
diff --git a/modules/ui_video.py b/modules/ui_video.py
index 77fda42c7..bc388819e 100644
--- a/modules/ui_video.py
+++ b/modules/ui_video.py
@@ -1,13 +1,14 @@
import os
import gradio as gr
from modules import shared, timer, images, ui_common, ui_sections, generation_parameters_copypaste
+from modules import logger
-debug = shared.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
+debug = logger.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
def create_ui():
- shared.log.debug('UI initialize: tab=video')
+ logger.log.debug('UI initialize: tab=video')
with gr.Blocks(analytics_enabled=False) as _video_interface:
prompt, styles, negative, generate_btn, _reprocess, paste, networks_button, _token_counter, _token_button, _token_counter_negative, _token_button_negative = ui_sections.create_toprow(
is_img2img=False,
diff --git a/modules/ui_video_vlm.py b/modules/ui_video_vlm.py
index b39ba4fe3..88dc5acad 100644
--- a/modules/ui_video_vlm.py
+++ b/modules/ui_video_vlm.py
@@ -1,6 +1,7 @@
import gradio as gr
from PIL import Image
from modules import shared
+from modules import logger
models = [
@@ -45,9 +46,9 @@ def enhance_prompt(enable:bool, model:str=None, image=None, prompt:str='', syste
system_prompt = f"{system_prompts['prefix']} {core_prompt} {system_prompts['desc']}' "
system_prompt += system_prompts['nsfw_ok'] if nsfw else system_prompts['nsfw_no']
system_prompt += f" {system_prompts['suffix']} {system_prompts['example']}"
- shared.log.debug(f'Video prompt enhance: model="{model}" image={image} nsfw={nsfw} prompt="{prompt}"')
+ logger.log.debug(f'Video prompt enhance: model="{model}" image={image} nsfw={nsfw} prompt="{prompt}"')
answer = vqa.caption(question='', prompt=prompt, system_prompt=system_prompt, image=image, model_name=model, quiet=False)
- shared.log.debug(f'Video prompt enhance: answer="{answer}"')
+ logger.log.debug(f'Video prompt enhance: answer="{answer}"')
return answer
diff --git a/modules/upscaler.py b/modules/upscaler.py
index 10e816569..c1bdd22c8 100644
--- a/modules/upscaler.py
+++ b/modules/upscaler.py
@@ -2,6 +2,7 @@ import os
from abc import abstractmethod
from PIL import Image
from modules import modelloader, shared, paths
+from modules import logger
models = None
@@ -37,7 +38,7 @@ class Upscaler:
self.mod_scale = None
self.model_download_path = None
if self.user_path is not None and len(self.user_path) > 0 and not os.path.exists(self.user_path):
- shared.log.info(f'Upscaler create: folder="{self.user_path}"')
+ logger.log.info(f'Upscaler create: folder="{self.user_path}"')
if self.model_path is None and self.name:
self.model_path = os.path.join(paths.models_path, self.name)
try:
@@ -64,7 +65,7 @@ class Upscaler:
scaler.custom = True
scalers.append(scaler)
loaded.append(file_name)
- # shared.log.debug(f'Upscaler type={self.name} folder="{folder}" model="{model_name}" path="{file_name}"')
+ # logger.log.debug(f'Upscaler type={self.name} folder="{folder}" model="{model_name}" path="{file_name}"')
def find_scalers(self):
scalers = []
@@ -81,7 +82,7 @@ class Upscaler:
scaler = UpscalerData(name=f'{k} {model[0]}', path=model_path, upscaler=self)
scalers.append(scaler)
loaded.append(model_path)
- # shared.log.debug(f'Upscaler type={self.name} folder="{self.user_path}" model="{model[0]}" path="{model_path}"')
+ # logger.log.debug(f'Upscaler type={self.name} folder="{self.user_path}" model="{model[0]}" path="{model_path}"')
if self.user_path is None or not os.path.exists(self.user_path):
return scalers
self.find_folder(self.user_path, scalers, loaded)
@@ -124,7 +125,7 @@ class Upscaler:
return modelloader.load_models(model_path=self.model_path, model_url=self.model_url, command_path=self.user_path)
def update_status(self, prompt):
- shared.log.info(f'Upscaler: type={self.name} model="{prompt}"')
+ logger.log.info(f'Upscaler: type={self.name} model="{prompt}"')
def find_model(self, path):
info = None
@@ -133,13 +134,13 @@ class Upscaler:
info = scaler
break
if info is None:
- shared.log.error(f'Upscaler cannot match model: type={self.name} model="{path}"')
+ logger.log.error(f'Upscaler cannot match model: type={self.name} model="{path}"')
return None
if info.local_data_path.startswith("http"):
from modules.modelloader import load_file_from_url
info.local_data_path = load_file_from_url(url=info.data_path, model_dir=self.model_download_path, progress=True)
if not os.path.isfile(info.local_data_path):
- shared.log.error(f'Upscaler cannot find model: type={self.name} model="{info.local_data_path}"')
+ logger.log.error(f'Upscaler cannot find model: type={self.name} model="{info.local_data_path}"')
return None
return info
@@ -167,12 +168,12 @@ def compile_upscaler(model):
from modules.sd_models_compile import ipex_optimize
model = ipex_optimize(model, apply_to_components=False, op="Upscaler")
except Exception as e:
- shared.log.warning(f"Upscaler IPEX Optimize: error: {e}")
+ logger.log.warning(f"Upscaler IPEX Optimize: error: {e}")
if "Upscaler" in shared.opts.cuda_compile:
try:
from modules.sd_models_compile import compile_torch
model = compile_torch(model, apply_to_components=False, op="Upscaler")
except Exception as e:
- shared.log.warning(f"Upscaler compile error: {e}")
+ logger.log.warning(f"Upscaler compile error: {e}")
return model
diff --git a/modules/upscaler_vae.py b/modules/upscaler_vae.py
index 871118c42..44b49e9ff 100644
--- a/modules/upscaler_vae.py
+++ b/modules/upscaler_vae.py
@@ -1,3 +1,4 @@
+from modules import logger
import time
from PIL import Image
from modules.upscaler import Upscaler, UpscalerData
@@ -30,7 +31,7 @@ class UpscalerAsymmetricVAE(Upscaler):
self.vae = self.vae.to(device=devices.device, dtype=devices.dtype)
self.vae.eval()
self.selected = selected_model
- shared.log.debug(f'Upscaler load: selected="{self.selected}" vae="{repo_id}"')
+ logger.log.debug(f'Upscaler load: selected="{self.selected}" vae="{repo_id}"')
t0 = time.time()
img = sharpfin.resize(img, (8 * (img.width // 8), 8 * (img.height // 8))).convert('RGB')
tensor = convert.to_tensor(img).unsqueeze(0).to(device=devices.device, dtype=devices.dtype)
@@ -39,7 +40,7 @@ class UpscalerAsymmetricVAE(Upscaler):
upscaled = convert.to_pil(tensor.squeeze().clamp(0.0, 1.0).float().cpu())
self.vae = self.vae.to(device=devices.cpu)
t1 = time.time()
- shared.log.debug(f'Upscale: name="{self.selected}" input={img.size} output={upscaled.size} time={t1 - t0:.2f}')
+ logger.log.debug(f'Upscale: name="{self.selected}" input={img.size} output={upscaled.size} time={t1 - t0:.2f}')
return upscaled
@@ -75,7 +76,7 @@ class UpscalerWanUpscale(Upscaler):
self.vae_decode = self.vae_decode.to(device=devices.device, dtype=devices.dtype)
self.vae_decode.eval()
self.selected = selected_model
- shared.log.debug(f'Upscaler load: selected="{self.selected}" encode="{repo_encode}" decode="{repo_decode}"')
+ logger.log.debug(f'Upscaler load: selected="{self.selected}" encode="{repo_encode}" decode="{repo_decode}"')
t0 = time.time()
self.vae_encode = self.vae_encode.to(device=devices.device)
@@ -90,5 +91,5 @@ class UpscalerWanUpscale(Upscaler):
upscaled = convert.to_pil(tensor.squeeze().clamp(0.0, 1.0).float().cpu())
t1 = time.time()
- shared.log.debug(f'Upscale: name="{self.selected}" input={img.size} output={upscaled.size} time={t1 - t0:.2f}')
+ logger.log.debug(f'Upscale: name="{self.selected}" input={img.size} output={upscaled.size} time={t1 - t0:.2f}')
return upscaled
diff --git a/modules/vae/sd_vae_approx.py b/modules/vae/sd_vae_approx.py
index 78fe8f08b..ade40c6f3 100644
--- a/modules/vae/sd_vae_approx.py
+++ b/modules/vae/sd_vae_approx.py
@@ -2,6 +2,7 @@ import os
import torch
from torch import nn
from modules import devices, paths, shared
+from modules import logger
sd_vae_approx_model = None
@@ -46,7 +47,7 @@ def nn_approximation(sample): # Approximate NN
sd_vae_approx_model.load_state_dict(approx_weights)
sd_vae_approx_model.eval()
sd_vae_approx_model.to(device, dtype)
- shared.log.debug(f'VAE load: type=approximate model="{model_path}"')
+ logger.log.debug(f'VAE load: type=approximate model="{model_path}"')
try:
in_sample = sample.to(device, dtype).unsqueeze(0)
sd_vae_approx_model.to(device, dtype)
@@ -54,7 +55,7 @@ def nn_approximation(sample): # Approximate NN
x_sample = x_sample[0].to(torch.float32).detach().cpu()
return x_sample
except Exception as e:
- shared.log.error(f'VAE decode approximate: {e}')
+ logger.log.error(f'VAE decode approximate: {e}')
return sample
@@ -80,5 +81,5 @@ def cheap_approximation(sample): # Approximate simple
x_sample = nn.functional.conv2d(sample, weights, bias) # pylint: disable=not-callable
return x_sample
except Exception as e:
- shared.log.error(f'VAE decode simple: {e}')
+ logger.log.error(f'VAE decode simple: {e}')
return sample
diff --git a/modules/vae/sd_vae_fal.py b/modules/vae/sd_vae_fal.py
index 0f0e5b3bb..8f94fcea2 100644
--- a/modules/vae/sd_vae_fal.py
+++ b/modules/vae/sd_vae_fal.py
@@ -6,6 +6,7 @@ from diffusers.models.autoencoders.vae import EncoderOutput, DecoderOutput
from diffusers.configuration_utils import ConfigMixin, register_to_config
from modules import shared, devices
+from modules import logger
repo_id = "fal/FLUX.2-Tiny-AutoEncoder"
@@ -29,7 +30,7 @@ def load_fal_vae():
if prev_vae is None:
prev_vae = shared.sd_model.vae
shared.sd_model.vae = tiny_vae
- shared.log.info(f'VAE load: cls={tiny_vae.__class__.__name__} repo_id={repo_id}')
+ logger.log.info(f'VAE load: cls={tiny_vae.__class__.__name__} repo_id={repo_id}')
def unload_fal_vae():
@@ -39,7 +40,7 @@ def unload_fal_vae():
if prev_vae is not None:
shared.sd_model.vae = prev_vae
prev_vae = None
- shared.log.info(f'VAE restore: cls={prev_vae.__class__.__name__}')
+ logger.log.info(f'VAE restore: cls={prev_vae.__class__.__name__}')
class Flux2TinyAutoEncoder(ModelMixin, ConfigMixin):
diff --git a/modules/vae/sd_vae_natten.py b/modules/vae/sd_vae_natten.py
index 246816c8d..a2f43bd6b 100644
--- a/modules/vae/sd_vae_natten.py
+++ b/modules/vae/sd_vae_natten.py
@@ -5,7 +5,8 @@ from diffusers.models.attention import Attention
import torch
from torch.nn import Linear
from einops import rearrange
-from installer import install, log
+from installer import install
+from modules.logger import log
def init():
diff --git a/modules/vae/sd_vae_ostris.py b/modules/vae/sd_vae_ostris.py
index 70542e9f5..d25c9a5ef 100644
--- a/modules/vae/sd_vae_ostris.py
+++ b/modules/vae/sd_vae_ostris.py
@@ -4,6 +4,7 @@ import diffusers
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from modules import shared, devices
+from modules import logger
decoder_id = "ostris/vae-kl-f8-d16"
@@ -16,7 +17,7 @@ def load_vae(pipe):
elif shared.sd_model_type == 'sdxl':
adapter_file = "16ch-VAE-Adapter-SDXL-alpha_v02.safetensors"
else:
- shared.log.error('VAE: type=osiris unsupported model type')
+ logger.log.error('VAE: type=osiris unsupported model type')
return
t0 = time.time()
ckpt_file = hf_hub_download(adapter_id, adapter_file, cache_dir=shared.opts.hfcache_dir)
@@ -38,4 +39,4 @@ def load_vae(pipe):
pipe.vae = diffusers.AutoencoderKL.from_pretrained(decoder_id, torch_dtype=devices.dtype, cache_dir=shared.opts.hfcache_dir)
t1 = time.time()
- shared.log.info(f'VAE load: type=osiris decoder="{decoder_id}" adapter="{adapter_id}" time={t1-t0:.2f}s')
+ logger.log.info(f'VAE load: type=osiris decoder="{decoder_id}" adapter="{adapter_id}" time={t1-t0:.2f}s')
diff --git a/modules/vae/sd_vae_remote.py b/modules/vae/sd_vae_remote.py
index 7a03bf383..4002bb9a8 100644
--- a/modules/vae/sd_vae_remote.py
+++ b/modules/vae/sd_vae_remote.py
@@ -1,3 +1,4 @@
+from modules import logger
import io
import time
import json
@@ -53,7 +54,7 @@ def remote_decode(latents: torch.Tensor, width: int = 0, height: int = 0, model_
model_type = model_type or shared.sd_model_type
url = hf_decode_endpoints.get(model_type, None)
if url is None:
- shared.log.error(f'Decode: type="remote" type={model_type} unsuppported')
+ logger.log.error(f'Decode: type="remote" type={model_type} unsuppported')
return tensors
t0 = time.time()
modelloader.hf_login()
@@ -106,7 +107,7 @@ def remote_decode(latents: torch.Tensor, width: int = 0, height: int = 0, model_
timeout=300,
)
if not response.ok:
- shared.log.error(f'Decode: type="remote" model={model_type} code={response.status_code} shape={latent.shape} url="{url}" args={params} headers={response.headers} response={response.json()}')
+ logger.log.error(f'Decode: type="remote" model={model_type} code={response.status_code} shape={latent.shape} url="{url}" args={params} headers={response.headers} response={response.json()}')
else:
content += len(response.content)
if shared.opts.remote_vae_type == 'raw' or 'video' in model_type:
@@ -118,12 +119,12 @@ def remote_decode(latents: torch.Tensor, width: int = 0, height: int = 0, model_
image = Image.open(io.BytesIO(response.content)).convert("RGB")
tensors.append(image)
except Exception as e:
- shared.log.error(f'Decode: type="remote" model={model_type} {e}')
+ logger.log.error(f'Decode: type="remote" model={model_type} {e}')
errors.display(e, 'VAE')
if len(tensors) > 0 and shared.opts.remote_vae_type == 'raw':
tensors = torch.cat(tensors, dim=0)
t1 = time.time()
- shared.log.debug(f'Decode: type="remote" model={model_type} mode={shared.opts.remote_vae_type} args={params} bytes={content} time={t1-t0:.3f}s')
+ logger.log.debug(f'Decode: type="remote" model={model_type} mode={shared.opts.remote_vae_type} args={params} bytes={content} time={t1-t0:.3f}s')
return tensors
@@ -136,7 +137,7 @@ def remote_encode(images: list[Image.Image], model_type: str | None = None):
model_type = model_type or shared.sd_model_type
url = hf_encode_endpoints.get(model_type, None)
if url is None:
- shared.log.error(f'Decode: type="remote" type={model_type} unsuppported')
+ logger.log.error(f'Decode: type="remote" type={model_type} unsuppported')
return images
t0 = time.time()
modelloader.hf_login()
@@ -153,7 +154,7 @@ def remote_encode(images: list[Image.Image], model_type: str | None = None):
)
tensors.append(init_latent)
except Exception as e:
- shared.log.error(f'Encode: type="remote" model={model_type} {e}')
+ logger.log.error(f'Encode: type="remote" model={model_type} {e}')
errors.display(e, 'VAE')
if len(tensors) > 0 and torch.is_tensor(tensors[0]):
@@ -162,5 +163,5 @@ def remote_encode(images: list[Image.Image], model_type: str | None = None):
else:
return images
t1 = time.time()
- shared.log.debug(f'Encode: type="remote" model={model_type} mode={shared.opts.remote_vae_type} image={images} latent={tensors.shape} time={t1-t0:.3f}s')
+ logger.log.debug(f'Encode: type="remote" model={model_type} mode={shared.opts.remote_vae_type} image={images} latent={tensors.shape} time={t1-t0:.3f}s')
return tensors
diff --git a/modules/vae/sd_vae_repa.py b/modules/vae/sd_vae_repa.py
index 7dce4c1ce..a2d661643 100644
--- a/modules/vae/sd_vae_repa.py
+++ b/modules/vae/sd_vae_repa.py
@@ -1,5 +1,6 @@
import diffusers
from modules import shared
+from modules import logger
models = {
@@ -17,12 +18,12 @@ def repa_load(latents):
global loaded_cls, loaded_vae # pylint: disable=global-statement
config = models.get(shared.sd_model_type, None)
if config is None:
- shared.log.error(f'Decode: type="repa" model={shared.sd_model_type} not supported')
+ logger.log.error(f'Decode: type="repa" model={shared.sd_model_type} not supported')
return latents
cls = getattr(diffusers, config['cls'])
if (cls != loaded_cls) or (loaded_vae is None):
- shared.log.info(f'RePA VAE load: {config["repo_id"]} cls={config["cls"]}')
+ logger.log.info(f'RePA VAE load: {config["repo_id"]} cls={config["cls"]}')
loaded_vae = cls.from_pretrained(
config['repo_id'],
torch_dtype=latents.dtype,
diff --git a/modules/vae/sd_vae_stablecascade.py b/modules/vae/sd_vae_stablecascade.py
index 198606e7d..09aadd20a 100644
--- a/modules/vae/sd_vae_stablecascade.py
+++ b/modules/vae/sd_vae_stablecascade.py
@@ -2,6 +2,7 @@ import os
from torch import nn
import safetensors
from modules import devices, paths
+from modules import logger
preview_model = None
dtype = devices.dtype_vae
@@ -55,7 +56,7 @@ def download_model(model_path):
model_url = 'https://huggingface.co/stabilityai/stable-cascade/resolve/main/previewer.safetensors?download=true'
if not os.path.exists(model_path):
import torch
- from installer import log
+ from modules.logger import log
os.makedirs(os.path.dirname(model_path), exist_ok=True)
log.info(f'Downloading Stable Cascade previewer: {model_path}')
torch.hub.download_url_to_file(model_url, model_path)
@@ -79,12 +80,12 @@ def decode(latents):
preview_model.load_state_dict(previewer_checkpoint if 'state_dict' not in previewer_checkpoint else previewer_checkpoint['state_dict'])
preview_model.eval().requires_grad_(False).to(devices.device, dtype)
del previewer_checkpoint
- shared.log.info(f"Load Stable Cascade previewer: model={model_path}")
+ logger.log.info(f"Load Stable Cascade previewer: model={model_path}")
try:
with devices.inference_context():
latents = latents.detach().clone().unsqueeze(0).to(devices.device, dtype)
image = preview_model(latents)[0].clamp(0, 1).float()
return image
except Exception as e:
- shared.log.error(f'Stable Cascade previewer: {e}')
+ logger.log.error(f'Stable Cascade previewer: {e}')
return latents
diff --git a/modules/vae/sd_vae_taesd.py b/modules/vae/sd_vae_taesd.py
index c8fc3ef47..54571825e 100644
--- a/modules/vae/sd_vae_taesd.py
+++ b/modules/vae/sd_vae_taesd.py
@@ -10,6 +10,7 @@ import threading
from PIL import Image
import torch
from modules import devices, paths, shared
+from modules import logger
debug = os.environ.get('SD_PREVIEW_DEBUG', None) is not None
@@ -52,7 +53,7 @@ def warn_once(msg, variant=None):
global prev_warnings # pylint: disable=global-statement
if not prev_warnings:
prev_warnings = True
- shared.log.warning(f'Decode: type="taesd" variant="{variant}": {msg}')
+ logger.log.warning(f'Decode: type="taesd" variant="{variant}": {msg}')
return Image.new('RGB', (8, 8), color = (0, 0, 0))
@@ -93,16 +94,16 @@ def get_model(model_type = 'decoder', variant = None):
uri += '/tae' + model_cls + '_' + model_type + '.pth'
try:
torch.hub.download_url_to_file(uri, fn)
- shared.log.print() # new line
- shared.log.info(f'Decode: type="taesd" variant="{variant}": uri="{uri}" fn="{fn}" download')
+ logger.log.print() # new line
+ logger.log.info(f'Decode: type="taesd" variant="{variant}": uri="{uri}" fn="{fn}" download')
except Exception as e:
warn_once(f'download uri={uri} {e}', variant=variant)
if os.path.exists(fn):
prev_cls = model_cls
prev_type = model_type
prev_model = variant
- shared.log.print() # new line
- shared.log.debug(f'Decode: type="taesd" variant="{variant}" fn="{fn}" layers={shared.opts.taesd_layers} load')
+ logger.log.print() # new line
+ logger.log.debug(f'Decode: type="taesd" variant="{variant}" fn="{fn}" layers={shared.opts.taesd_layers} load')
vae = None
if 'TAE HunyuanVideo' in variant:
from modules.taesd.taehv import TAEHV
@@ -132,7 +133,7 @@ def get_model(model_type = 'decoder', variant = None):
prev_cls = model_cls
prev_type = model_type
prev_model = variant
- shared.log.debug(f'Decode: type="taesd" variant="{variant}" id="{repo}" load')
+ logger.log.debug(f'Decode: type="taesd" variant="{variant}" id="{repo}" load')
if 'tiny' in repo:
from diffusers.models import AutoencoderTiny
vae = AutoencoderTiny.from_pretrained(repo, cache_dir=shared.opts.hfcache_dir, torch_dtype=dtype)
@@ -162,7 +163,7 @@ def decode(latents):
tensor = latents.unsqueeze(0) if len(latents.shape) == 3 else latents
tensor = tensor.detach().clone().to(devices.device, dtype=dtype)
if debug:
- shared.log.debug(f'Decode: type="taesd" variant="{variant}" input={latents.shape} tensor={tensor.shape}')
+ logger.log.debug(f'Decode: type="taesd" variant="{variant}" input={latents.shape} tensor={tensor.shape}')
# Fallback: reshape packed 128-channel latents to 32 channels if not already unpacked
if (variant == 'TAE FLUX.2') and (len(tensor.shape) == 4) and (tensor.shape[1] == 128):
b, _c, h, w = tensor.shape
@@ -175,7 +176,7 @@ def decode(latents):
image = (image / 2.0 + 0.5).clamp(0, 1).detach()
t1 = time.time()
if (t1 - t0) > 3.0 and not first_run:
- shared.log.warning(f'Decode: type="taesd" variant="{variant}" long decode time={t1 - t0:.2f}')
+ logger.log.warning(f'Decode: type="taesd" variant="{variant}" long decode time={t1 - t0:.2f}')
first_run = False
return image
except Exception as e:
diff --git a/modules/video.py b/modules/video.py
index 17d51eb38..969160581 100644
--- a/modules/video.py
+++ b/modules/video.py
@@ -3,6 +3,7 @@ import threading
import numpy as np
from PIL import Image
from modules import shared, errors
+from modules import logger
from modules.image.namegen import FilenameGenerator # pylint: disable=unused-import
@@ -18,7 +19,7 @@ def interpolate_frames(images, count: int = 0, scale: float = 1.0, pad: int = 1,
if len(frames) > 0:
images = frames
except Exception as e:
- shared.log.error(f'RIFE interpolation: {e}')
+ logger.log.error(f'RIFE interpolation: {e}')
errors.display(e, 'RIFE interpolation')
return [np.array(image) for image in images]
@@ -27,7 +28,7 @@ def save_video_atomic(images, filename, video_type: str = 'none', duration: floa
try:
import cv2
except Exception as e:
- shared.log.error(f'Save video: cv2: {e}')
+ logger.log.error(f'Save video: cv2: {e}')
return
savejob = shared.state.begin('Save video')
os.makedirs(os.path.dirname(filename), exist_ok=True)
@@ -46,7 +47,7 @@ def save_video_atomic(images, filename, video_type: str = 'none', duration: floa
loop = 0 if loop else 1,
)
size = os.path.getsize(filename)
- shared.log.info(f'Save video: file="{filename}" frames={len(append) + 1} duration={duration} loop={loop} size={size}')
+ logger.log.info(f'Save video: file="{filename}" frames={len(append) + 1} duration={duration} loop={loop} size={size}')
elif video_type.lower() != 'none':
frames = interpolate_frames(images, count=interpolate, scale=scale, pad=pad, change=change)
fourcc = "mp4v"
@@ -56,7 +57,7 @@ def save_video_atomic(images, filename, video_type: str = 'none', duration: floa
img = cv2.cvtColor(frames[i], cv2.COLOR_RGB2BGR)
video_writer.write(img)
size = os.path.getsize(filename)
- shared.log.info(f'Save video: file="{filename}" frames={len(frames)} duration={duration} fourcc={fourcc} size={size}')
+ logger.log.info(f'Save video: file="{filename}" frames={len(frames)} duration={duration} fourcc={fourcc} size={size}')
shared.state.end(savejob)
@@ -95,7 +96,7 @@ def get_video_params(filepath: str, capture: bool = False):
video = cv2.VideoCapture(filepath)
if not video.isOpened():
msg = f'Video open failed: path="{filepath}"'
- shared.log.error(msg)
+ logger.log.error(msg)
raise RuntimeError(msg)
frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
fps = round(video.get(cv2.CAP_PROP_FPS), 2)
diff --git a/modules/video_models/google_veo.py b/modules/video_models/google_veo.py
index 49893b260..7fcaf9fb0 100644
--- a/modules/video_models/google_veo.py
+++ b/modules/video_models/google_veo.py
@@ -6,7 +6,8 @@ import sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
from PIL import Image
-from installer import install, reload, log
+from installer import install, reload
+from modules.logger import log
image_size_buckets = {
diff --git a/modules/video_models/models_def.py b/modules/video_models/models_def.py
index 351d1c33a..02aa3bec2 100644
--- a/modules/video_models/models_def.py
+++ b/modules/video_models/models_def.py
@@ -2,7 +2,7 @@ from dataclasses import dataclass
import time
import diffusers
import transformers
-from installer import log
+from modules.logger import log
@dataclass
diff --git a/modules/video_models/video_cache.py b/modules/video_models/video_cache.py
index b4b0d1472..c4d6e6278 100644
--- a/modules/video_models/video_cache.py
+++ b/modules/video_models/video_cache.py
@@ -1,11 +1,12 @@
import diffusers
from modules import shared
+from modules import logger
def apply_teacache_patch(cls):
if shared.opts.teacache_enabled and cls is not None:
from modules import teacache
- shared.log.debug(f'Transformers cache: type=teacache patch=forward cls={cls.__name__}')
+ logger.log.debug(f'Transformers cache: type=teacache patch=forward cls={cls.__name__}')
if cls.__name__ == 'LTXVideoTransformer3DModel':
cls.forward = teacache.teacache_ltx_forward
elif cls.__name__ == 'MochiTransformer3DModel':
diff --git a/modules/video_models/video_load.py b/modules/video_models/video_load.py
index e60463368..e6fc71b66 100644
--- a/modules/video_models/video_load.py
+++ b/modules/video_models/video_load.py
@@ -4,6 +4,7 @@ import copy
import time
import diffusers
from modules import shared, errors, sd_models, sd_checkpoint, model_quant, devices, sd_hijack_te, sd_hijack_vae
+from modules import logger
from modules.video_models import models_def, video_utils, video_overrides, video_cache
@@ -20,7 +21,7 @@ loaded_model = None
def load_custom(model_name: str):
- shared.log.debug(f'Video load: module=pipe repo="{model_name}" cls=Custom')
+ logger.log.debug(f'Video load: module=pipe repo="{model_name}" cls=Custom')
if 'veo-3.1' in model_name:
from modules.video_models.google_veo import load_veo
pipe = load_veo(model_name)
@@ -81,7 +82,7 @@ def load_model(selected: models_def.Model):
selected.te_folder = 'text_encoder'
selected.te_revision = None
- shared.log.debug(f'Video load: module=te repo="{selected.te or selected.repo}" folder="{selected.te_folder}" cls={selected.te_cls.__name__} quant={model_quant.get_quant_type(quant_args)} loader={_loader("transformers")}')
+ logger.log.debug(f'Video load: module=te repo="{selected.te or selected.repo}" folder="{selected.te_folder}" cls={selected.te_cls.__name__} quant={model_quant.get_quant_type(quant_args)} loader={_loader("transformers")}')
kwargs["text_encoder"] = selected.te_cls.from_pretrained(
pretrained_model_name_or_path=selected.te or selected.repo,
subfolder=selected.te_folder,
@@ -92,7 +93,7 @@ def load_model(selected: models_def.Model):
**offline_args,
)
except Exception as e:
- shared.log.error(f'video load: module=te cls={selected.te_cls.__name__} {e}')
+ logger.log.error(f'video load: module=te cls={selected.te_cls.__name__} {e}')
errors.display(e, 'video')
# transformer
@@ -102,7 +103,7 @@ def load_model(selected: models_def.Model):
if dit_folder is not None and dit_folder not in kwargs:
# get a new quant arg on every loop to prevent the quant config classes getting entangled
load_args, quant_args = model_quant.get_dit_args({}, module='Model', device_map=True)
- shared.log.debug(f'Video load: module=transformer repo="{selected.dit or selected.repo}" module="{dit_folder}" folder="{dit_folder}" cls={selected.dit_cls.__name__} quant={model_quant.get_quant_type(quant_args)} loader={_loader("diffusers")}')
+ logger.log.debug(f'Video load: module=transformer repo="{selected.dit or selected.repo}" module="{dit_folder}" folder="{dit_folder}" cls={selected.dit_cls.__name__} quant={model_quant.get_quant_type(quant_args)} loader={_loader("diffusers")}')
kwargs[dit_folder] = selected.dit_cls.from_pretrained(
pretrained_model_name_or_path=selected.dit or selected.repo,
subfolder=dit_folder,
@@ -113,7 +114,7 @@ def load_model(selected: models_def.Model):
**offline_args,
)
else:
- shared.log.debug(f'Video load: module=transformer repo="{selected.dit or selected.repo}" module="{dit_folder}" folder="{dit_folder}" cls={selected.dit_cls.__name__} loader={_loader("diffusers")} skip')
+ logger.log.debug(f'Video load: module=transformer repo="{selected.dit or selected.repo}" module="{dit_folder}" folder="{dit_folder}" cls={selected.dit_cls.__name__} loader={_loader("diffusers")} skip')
if selected.dit_folder is None:
selected.dit_folder = ['transformer']
@@ -123,7 +124,7 @@ def load_model(selected: models_def.Model):
else:
load_dit_folder(selected.dit_folder)
except Exception as e:
- shared.log.error(f'video load: module=transformer cls={selected.dit_cls.__name__} {e}')
+ logger.log.error(f'video load: module=transformer cls={selected.dit_cls.__name__} {e}')
errors.display(e, 'video')
# model
@@ -131,7 +132,7 @@ def load_model(selected: models_def.Model):
if selected.repo_cls is None:
shared.sd_model = load_custom(selected.repo)
else:
- shared.log.debug(f'Video load: module=pipe repo="{selected.repo}" cls={selected.repo_cls.__name__}')
+ logger.log.debug(f'Video load: module=pipe repo="{selected.repo}" cls={selected.repo_cls.__name__}')
shared.sd_model = selected.repo_cls.from_pretrained(
pretrained_model_name_or_path=selected.repo,
revision=selected.repo_revision,
@@ -141,12 +142,12 @@ def load_model(selected: models_def.Model):
**offline_args,
)
except Exception as e:
- shared.log.error(f'video load: module=pipe repo="{selected.repo}" cls={selected.repo_cls.__name__} {e}')
+ logger.log.error(f'video load: module=pipe repo="{selected.repo}" cls={selected.repo_cls.__name__} {e}')
errors.display(e, 'video')
if shared.sd_model is None:
msg = f'Video load: model="{selected.name}" failed'
- shared.log.error(msg)
+ logger.log.error(msg)
return msg
t1 = time.time()
@@ -185,8 +186,8 @@ def load_model(selected: models_def.Model):
loaded_model = selected.name
msg = f'Video load: cls={shared.sd_model.__class__.__name__} model="{selected.name}" time={t1-t0:.2f}'
- shared.log.info(msg)
- shared.log.debug(f'Video hijacks: decode={decode} text={text} image={image} slicing={slicing} tiling={tiling} framewise={framewise}')
+ logger.log.info(msg)
+ logger.log.debug(f'Video hijacks: decode={decode} text={text} image={image} slicing={slicing} tiling={tiling} framewise={framewise}')
shared.state.end(jobid)
return msg
@@ -197,7 +198,7 @@ def load_upscale_vae():
if hasattr(shared.sd_model.vae, '_asymmetric_upscale_vae'):
return # already loaded
if shared.sd_model.vae.__class__.__name__ != 'AutoencoderKLWan':
- shared.log.warning('Video decode: upscale VAE unsupported')
+ logger.log.warning('Video decode: upscale VAE unsupported')
return
repo_id = 'spacepxl/Wan2.1-VAE-upscale2x'
@@ -206,7 +207,7 @@ def load_upscale_vae():
vae_decode.requires_grad_(False)
vae_decode = vae_decode.to(device=devices.device, dtype=devices.dtype)
vae_decode.eval()
- shared.log.debug(f'Decode: load="{repo_id}"')
+ logger.log.debug(f'Decode: load="{repo_id}"')
shared.sd_model.orig_vae = shared.sd_model.vae
shared.sd_model.vae = vae_decode
shared.sd_model.vae._asymmetric_upscale_vae = True # pylint: disable=protected-access
diff --git a/modules/video_models/video_overrides.py b/modules/video_models/video_overrides.py
index 55b3ad850..60774a407 100644
--- a/modules/video_models/video_overrides.py
+++ b/modules/video_models/video_overrides.py
@@ -2,10 +2,11 @@ import os
import torch
import diffusers
from modules import shared, processing
+from modules import logger
from modules.video_models.models_def import Model
-debug = shared.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
+debug = logger.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
def load_override(selected: Model, **load_args):
diff --git a/modules/video_models/video_run.py b/modules/video_models/video_run.py
index a8603679a..0fc2386bc 100644
--- a/modules/video_models/video_run.py
+++ b/modules/video_models/video_run.py
@@ -2,11 +2,12 @@ import os
import copy
import time
from modules import shared, errors, sd_models, processing, devices, images, ui_common
+from modules import logger
from modules.video_models import models_def, video_utils, video_load, video_vae, video_overrides, video_save, video_prompt
from modules.paths import resolve_output_path
-debug = shared.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
+debug = logger.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
def generate(*args, **kwargs):
@@ -51,7 +52,7 @@ def generate(*args, **kwargs):
override_settings=override_settings,
)
if p.vae_type == 'Remote' and not selected.vae_remote:
- shared.log.warning(f'Video: model={selected.name} remote vae not supported')
+ logger.log.warning(f'Video: model={selected.name} remote vae not supported')
p.vae_type = 'Default'
p.scripts = None
p.script_args = None
@@ -61,12 +62,12 @@ def generate(*args, **kwargs):
p.outpath_samples = resolve_output_path(shared.opts.outdir_samples, shared.opts.outdir_video)
if 'T2V' in model:
if init_image is not None:
- shared.log.warning('Video: op=T2V init image not supported')
+ logger.log.warning('Video: op=T2V init image not supported')
elif 'I2V' in model:
if init_image is None:
return video_utils.queue_err('init image not set')
p.task_args['image'] = images.resize_image(resize_mode=2, im=init_image, width=p.width, height=p.height, upscaler_name=None, output_type='pil')
- shared.log.debug(f'Video: op=I2V init={init_image} resized={p.task_args["image"]}')
+ logger.log.debug(f'Video: op=I2V init={init_image} resized={p.task_args["image"]}')
elif 'FLF2V' in model:
if init_image is None:
return video_utils.queue_err('init image not set')
@@ -74,11 +75,11 @@ def generate(*args, **kwargs):
return video_utils.queue_err('last image not set')
p.task_args['image'] = images.resize_image(resize_mode=2, im=init_image, width=p.width, height=p.height, upscaler_name=None, output_type='pil')
p.task_args['last_image'] = images.resize_image(resize_mode=2, im=last_image, width=p.width, height=p.height, upscaler_name=None, output_type='pil')
- shared.log.debug(f'Video: op=FLF2V init={init_image} last={last_image} resized={p.task_args["image"]}')
+ logger.log.debug(f'Video: op=FLF2V init={init_image} last={last_image} resized={p.task_args["image"]}')
elif 'VACE' in model:
if init_image is not None:
p.task_args['reference_images'] = [images.resize_image(resize_mode=2, im=init_image, width=p.width, height=p.height, upscaler_name=None, output_type='pil')]
- shared.log.debug(f'Video: op=VACE reference={init_image} resized={p.task_args["reference_images"]}')
+ logger.log.debug(f'Video: op=VACE reference={init_image} resized={p.task_args["reference_images"]}')
elif 'Animate' in model:
if init_image is None:
return video_utils.queue_err('init image not set')
@@ -86,9 +87,9 @@ def generate(*args, **kwargs):
p.task_args['mode'] = 'animate'
p.task_args['pose_video'] = [] # input pose video to condition the generation on. must be a list of PIL images.
p.task_args['face_video'] = [] # input face video to condition the generation on. must be a list of PIL images.
- shared.log.debug(f'Video: op=Animate init={p.task_args["image"]} pose={p.task_args["pose_video"]} face={p.task_args["face_video"]}')
+ logger.log.debug(f'Video: op=Animate init={p.task_args["image"]} pose={p.task_args["pose_video"]} face={p.task_args["face_video"]}')
else:
- shared.log.warning(f'Video: unknown model type "{model}"')
+ logger.log.warning(f'Video: unknown model type "{model}"')
# cleanup memory
shared.sd_model = sd_models.apply_balanced_offload(shared.sd_model)
@@ -130,7 +131,7 @@ def generate(*args, **kwargs):
# run processing
shared.state.disable_preview = True
- shared.log.debug(f'Video: cls={shared.sd_model.__class__.__name__} width={p.width} height={p.height} frames={p.frames} steps={p.steps}')
+ logger.log.debug(f'Video: cls={shared.sd_model.__class__.__name__} width={p.width} height={p.height} frames={p.frames} steps={p.steps}')
err = None
t0 = time.time()
processed = None
@@ -150,7 +151,7 @@ def generate(*args, **kwargs):
return video_utils.queue_err(err)
if processed is None or (len(processed.images) == 0 and processed.bytes is None):
return video_utils.queue_err('processing failed')
- shared.log.info(f'Video: name="{selected.name}" cls={shared.sd_model.__class__.__name__} frames={len(processed.images)} time={t1-t0:.2f}')
+ logger.log.info(f'Video: name="{selected.name}" cls={shared.sd_model.__class__.__name__} frames={len(processed.images)} time={t1-t0:.2f}')
if hasattr(processed, 'images') and processed.images is not None:
pixels = video_save.images_to_tensor(processed.images)
diff --git a/modules/video_models/video_save.py b/modules/video_models/video_save.py
index 9f75df9c4..27d3ecd79 100644
--- a/modules/video_models/video_save.py
+++ b/modules/video_models/video_save.py
@@ -7,6 +7,7 @@ import torch
import einops
from PIL import Image
from modules import shared, errors ,timer, rife, processing
+from modules import logger
from modules.video_models.video_utils import check_av
@@ -60,7 +61,7 @@ def images_to_tensor(images):
tensor = tensor.unsqueeze(0) # 1, n, h, w, c
tensor = tensor.permute(0, 4, 1, 2, 3).contiguous() # 1, c, n, h, w
tensor = (tensor.float() / 127.5) - 1.0 # from [0,255] to [-1,1]
- # shared.log.debug(f'Video output: images={len(images)} tensor={tensor.shape}')
+ # logger.log.debug(f'Video output: images={len(images)} tensor={tensor.shape}')
return tensor
@@ -73,7 +74,7 @@ def numpy_to_tensor(images):
tensor = tensor.unsqueeze(0) # 1, n, h, w, c
tensor = tensor.permute(0, 4, 1, 2, 3).contiguous() # 1, c, n, h, w
# tensor = (tensor.float() / 127.5) - 1.0 # from [0,255] to [-1,1]
- # shared.log.debug(f'Video output: images={len(images)} tensor={tensor.shape}')
+ # logger.log.debug(f'Video output: images={len(images)} tensor={tensor.shape}')
return tensor
@@ -91,7 +92,7 @@ def write_audio(
audio_stream.codec_context.format = "fltp"
audio_stream.codec_context.time_base = Fraction(1, audio_sample_rate)
# audio_stream.time_base = audio_stream.codec_context.time_base # TODO audio set time-base
- shared.log.debug(f'Audio: codec={audio_stream.codec_context.name} rate={audio_stream.codec_context.sample_rate} layout={audio_stream.codec_context.layout} format={audio_stream.codec_context.format} base={audio_stream.codec_context.time_base}')
+ logger.log.debug(f'Audio: codec={audio_stream.codec_context.name} rate={audio_stream.codec_context.sample_rate} layout={audio_stream.codec_context.layout} format={audio_stream.codec_context.format} base={audio_stream.codec_context.time_base}')
# init input samples
if samples.ndim == 1:
samples = samples[:, None]
@@ -143,7 +144,7 @@ def atomic_save_video(filename: str,
metadata = {}
av = check_av()
if av is None or av is False:
- shared.log.error('Video: ffmpeg/av not available')
+ logger.log.error('Video: ffmpeg/av not available')
return
savejob = shared.state.begin('Save video')
@@ -159,7 +160,7 @@ def atomic_save_video(filename: str,
else:
continue
options[key.strip()] = value.strip()
- shared.log.info(f'Video: file="{filename}" codec={codec} frames={frames} width={width} height={height} fps={rate} audio={audio is not None} aac={aac} options={options}')
+ logger.log.info(f'Video: file="{filename}" codec={codec} frames={frames} width={width} height={height} fps={rate} audio={audio is not None} aac={aac} options={options}')
video_array = torch.as_tensor(tensor, dtype=torch.uint8).numpy(force=True)
task = pbar.add_task('encoding', total=frames) if pbar is not None else None
@@ -185,7 +186,7 @@ def atomic_save_video(filename: str,
try:
write_audio(container, audio, aac)
except Exception as e:
- shared.log.error(f'Video audio encoding: {e}')
+ logger.log.error(f'Video audio encoding: {e}')
errors.display(e, 'Audio')
shared.state.outputs(filename)
@@ -221,12 +222,12 @@ def save_video(
try:
with open(output_video, 'wb') as f:
f.write(binary)
- shared.log.info(f'Video output: file="{output_video}" size={len(binary)}')
+ logger.log.info(f'Video output: file="{output_video}" size={len(binary)}')
shared.state.outputs(output_video)
except Exception as e:
- shared.log.error(f'Video output: file="{output_video}" {e}')
+ logger.log.error(f'Video output: file="{output_video}" {e}')
except Exception as e:
- shared.log.error(f'Video output: file="{output_video}" write error {e}')
+ logger.log.error(f'Video output: file="{output_video}" write error {e}')
errors.display(e, 'video')
return 0, output_video
@@ -237,13 +238,13 @@ def save_video(
if isinstance(pixels, list) and isinstance(pixels[0], Image.Image):
pixels = images_to_tensor(pixels)
if not torch.is_tensor(pixels):
- shared.log.error(f'Video: type={type(pixels)} not a tensor')
+ logger.log.error(f'Video: type={type(pixels)} not a tensor')
return 0, output_video
t_save = time.time()
n, _c, t, h, w = pixels.shape
size = pixels.element_size() * pixels.numel()
- shared.log.debug(f'Video: video={mp4_video} export={mp4_frames} safetensors={mp4_sf} interpolate={mp4_interpolate}')
- shared.log.debug(f'Video: encode={t} raw={size} latent={pixels.shape} audio={audio.shape if audio is not None else None} fps={mp4_fps} codec={mp4_codec} ext={mp4_ext} options="{mp4_opt}"')
+ logger.log.debug(f'Video: video={mp4_video} export={mp4_frames} safetensors={mp4_sf} interpolate={mp4_interpolate}')
+ logger.log.debug(f'Video: encode={t} raw={size} latent={pixels.shape} audio={audio.shape if audio is not None else None} fps={mp4_fps} codec={mp4_codec} ext={mp4_ext} options="{mp4_opt}"')
try:
preparejob = shared.state.begin('Prepare video')
if stream is not None:
@@ -267,13 +268,13 @@ def save_video(
if mp4_sf:
fn = f'{output_filename}.safetensors'
- shared.log.info(f'Video export: file="{fn}" type=savetensors shape={x.shape}')
+ logger.log.info(f'Video export: file="{fn}" type=savetensors shape={x.shape}')
from safetensors.torch import save_file
shared.state.outputs(fn)
save_file({ 'frames': x }, fn, metadata={'format': 'video', 'frames': str(t), 'width': str(w), 'height': str(h), 'fps': str(mp4_fps), 'codec': mp4_codec, 'options': mp4_opt, 'ext': mp4_ext, 'interpolate': str(mp4_interpolate)})
if mp4_frames:
- shared.log.info(f'Video frames: files="{output_filename}-00000.jpg" frames={t} width={w} height={h}')
+ logger.log.info(f'Video frames: files="{output_filename}-00000.jpg" frames={t} width={w} height={h}')
for i in range(t):
image = cv2.cvtColor(x[i].numpy(), cv2.COLOR_RGB2BGR)
fn = f'{output_filename}-{i:05d}.jpg'
@@ -293,7 +294,7 @@ def save_video(
stream.output_queue.push(('progress', (None, '')))
except Exception as e:
- shared.log.error(f'Video save: raw={size} {e}')
+ logger.log.error(f'Video save: raw={size} {e}')
errors.display(e, 'video')
timer.process.add('save', time.time()-t_save)
return t, output_video
diff --git a/modules/video_models/video_ui.py b/modules/video_models/video_ui.py
index f822c31a8..34c3ee2dc 100644
--- a/modules/video_models/video_ui.py
+++ b/modules/video_models/video_ui.py
@@ -1,12 +1,13 @@
import os
import gradio as gr
from modules import shared, sd_models, ui_common, ui_sections, ui_symbols, ui_video_vlm, call_queue
+from modules import logger
from modules.ui_components import ToolButton
from modules.video_models import models_def, video_utils
from modules.video_models import video_run
-debug = shared.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
+debug = logger.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
def engine_change(engine):
diff --git a/modules/video_models/video_utils.py b/modules/video_models/video_utils.py
index f29c43906..1074db45c 100644
--- a/modules/video_models/video_utils.py
+++ b/modules/video_models/video_utils.py
@@ -4,13 +4,14 @@ import time
from PIL import Image
from installer import install
from modules import shared, sd_models, timer, errors, devices
+from modules import logger
-debug = shared.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
+debug = logger.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
def queue_err(msg):
- shared.log.error(f'Video: {msg}')
+ logger.log.error(f'Video: {msg}')
return [], None, '', '', f'Error: {msg}'
@@ -24,7 +25,7 @@ def check_av():
import av
av.logging.set_level(av.logging.ERROR) # pylint: disable=c-extension-no-member
except Exception as e:
- shared.log.error(f'av package: {e}')
+ logger.log.error(f'av package: {e}')
return False
return av
@@ -44,7 +45,7 @@ def hijack_encode_image(*args, **kwargs):
sd_models.move_model(shared.sd_model.image_encoder, devices.device)
res = shared.sd_model.orig_encode_image(*args, **kwargs)
except Exception as e:
- shared.log.error(f'Video encode image: {e}')
+ logger.log.error(f'Video encode image: {e}')
errors.display(e, 'Video encode image')
res = None
t1 = time.time()
@@ -69,11 +70,11 @@ def get_codecs():
pass
hw_codecs = [c for c in codecs if (c.capabilities & 0x40000 > 0) or (c.capabilities & 0x80000 > 0)]
sw_codecs = [c for c in codecs if c not in hw_codecs]
- shared.log.debug(f'Video codecs: hardware={len(hw_codecs)} software={len(sw_codecs)}')
+ logger.log.debug(f'Video codecs: hardware={len(hw_codecs)} software={len(sw_codecs)}')
# for c in hw_codecs:
- # shared.log.trace(f'codec={c.name} cname="{c.canonical_name}" decs="{c.long_name}" intra={c.intra_only} lossy={c.lossy} lossless={c.lossless} capabilities={c.capabilities} hw=True')
+ # logger.log.trace(f'codec={c.name} cname="{c.canonical_name}" decs="{c.long_name}" intra={c.intra_only} lossy={c.lossy} lossless={c.lossless} capabilities={c.capabilities} hw=True')
# for c in sw_codecs:
- # shared.log.trace(f'codec={c.name} cname="{c.canonical_name}" decs="{c.long_name}" intra={c.intra_only} lossy={c.lossy} lossless={c.lossless} capabilities={c.capabilities} hw=False')
+ # logger.log.trace(f'codec={c.name} cname="{c.canonical_name}" decs="{c.long_name}" intra={c.intra_only} lossy={c.lossy} lossless={c.lossless} capabilities={c.capabilities} hw=False')
return ['none'] + [c.name for c in hw_codecs + sw_codecs]
@@ -112,8 +113,8 @@ def get_video_frames(fn: str, num_frames: int = -1, skip_frames: int = 0):
if len(frames) >= num_frames > 0:
break
video.release()
- shared.log.debug(f'Video open: file="{fn}" frames={len(frames)} total={frame_count} skip={skip} fps={fps} size={w}x{h} codec={codec}')
+ logger.log.debug(f'Video open: file="{fn}" frames={len(frames)} total={frame_count} skip={skip} fps={fps} size={w}x{h} codec={codec}')
except Exception as e:
- shared.log.error(f'Video open: file="{fn}" {e}')
+ logger.log.error(f'Video open: file="{fn}" {e}')
return frames
return frames
diff --git a/modules/video_models/video_vae.py b/modules/video_models/video_vae.py
index dd8ba233f..69b21fe62 100644
--- a/modules/video_models/video_vae.py
+++ b/modules/video_models/video_vae.py
@@ -1,8 +1,9 @@
import os
from modules import shared, devices
+from modules import logger
-debug = shared.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
+debug = logger.log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None
vae_type = None
@@ -39,13 +40,13 @@ def vae_decode_tiny(latents):
elif 'Kandinsky' in shared.sd_model.__class__.__name__:
variant = 'TAE HunyuanVideo'
else:
- shared.log.warning(f'Decode: type=Tiny cls={shared.sd_model.__class__.__name__} not supported')
+ logger.log.warning(f'Decode: type=Tiny cls={shared.sd_model.__class__.__name__} not supported')
return None
from modules.vae import sd_vae_taesd
vae, variant = sd_vae_taesd.get_model(variant=variant)
if vae is None:
return None
- shared.log.debug(f'Decode: type=Tiny cls={vae.__class__.__name__} variant="{variant}" latents={latents.shape}')
+ logger.log.debug(f'Decode: type=Tiny cls={vae.__class__.__name__} variant="{variant}" latents={latents.shape}')
vae = vae.to(device=devices.device, dtype=devices.dtype)
latents = latents.transpose(1, 2).to(device=devices.device, dtype=devices.dtype)
images = vae.decode_video(latents, parallel=False).transpose(1, 2).mul_(2).sub_(1)
diff --git a/modules/zluda.py b/modules/zluda.py
index 258958cc7..3afe100f4 100644
--- a/modules/zluda.py
+++ b/modules/zluda.py
@@ -21,7 +21,7 @@ def test(device) -> Exception | None:
def zluda_init():
try:
import torch
- from installer import log
+ from modules.logger import log
from modules import devices, zluda_installer
from modules.shared import cmd_opts
from modules.rocm_triton_windows import apply_triton_patches
diff --git a/modules/zluda_installer.py b/modules/zluda_installer.py
index 5326588eb..1d9a18890 100644
--- a/modules/zluda_installer.py
+++ b/modules/zluda_installer.py
@@ -6,7 +6,8 @@ import ctypes
import shutil
import zipfile
import urllib.request
-from installer import args, log
+from installer import args
+from modules.logger import log
from modules import rocm
diff --git a/pipelines/flux/flux_legacy_loader.py b/pipelines/flux/flux_legacy_loader.py
index cb3dad3c1..d36be3098 100644
--- a/pipelines/flux/flux_legacy_loader.py
+++ b/pipelines/flux/flux_legacy_loader.py
@@ -6,9 +6,10 @@ import transformers
from safetensors.torch import load_file
from huggingface_hub import hf_hub_download
from modules import shared, errors, devices, sd_models, sd_unet, model_te, model_quant, sd_hijack_te
+from modules import logger
-debug = shared.log.trace if os.environ.get('SD_LOAD_DEBUG', None) is not None else lambda *args, **kwargs: None
+debug = logger.log.trace if os.environ.get('SD_LOAD_DEBUG', None) is not None else lambda *args, **kwargs: None
def load_flux_quanto(checkpoint_info):
@@ -38,9 +39,9 @@ def load_flux_quanto(checkpoint_info):
try:
transformer = transformer.to(dtype=devices.dtype)
except Exception:
- shared.log.error(f"Load model: type=FLUX Failed to cast transformer to {devices.dtype}, set dtype to {transformer_dtype}")
+ logger.log.error(f"Load model: type=FLUX Failed to cast transformer to {devices.dtype}, set dtype to {transformer_dtype}")
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load Quanto transformer: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load Quanto transformer: {e}")
if debug:
errors.display(e, 'FLUX Quanto:')
@@ -64,9 +65,9 @@ def load_flux_quanto(checkpoint_info):
try:
text_encoder_2 = text_encoder_2.to(dtype=devices.dtype)
except Exception:
- shared.log.error(f"Load model: type=FLUX Failed to cast text encoder to {devices.dtype}, set dtype to {text_encoder_2_dtype}")
+ logger.log.error(f"Load model: type=FLUX Failed to cast text encoder to {devices.dtype}, set dtype to {text_encoder_2_dtype}")
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load Quanto text encoder: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load Quanto text encoder: {e}")
if debug:
errors.display(e, 'FLUX Quanto:')
@@ -97,7 +98,7 @@ def load_flux_bnb(checkpoint_info, diffusers_load_config): # pylint: disable=unu
else:
transformer = diffusers.FluxTransformer2DModel.from_single_file(repo_path, **diffusers_load_config)
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load BnB transformer: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load BnB transformer: {e}")
transformer, text_encoder_2 = None, None
if debug:
errors.display(e, 'FLUX:')
@@ -127,9 +128,9 @@ def load_quants(kwargs, repo_id, cache_dir, allow_quant): # pylint: disable=unus
elif 'shuttle' in repo_id.lower():
nunchaku_repo = f"mit-han-lab/nunchaku-shuttle-jaguar/svdq-{nunchaku_precision}_r32-shuttle-jaguar.safetensors"
else:
- shared.log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" unsupported')
+ logger.log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" unsupported')
if nunchaku_repo is not None:
- shared.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} offload={shared.opts.nunchaku_offload} attention={shared.opts.nunchaku_attention}')
+ logger.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} offload={shared.opts.nunchaku_offload} attention={shared.opts.nunchaku_attention}')
kwargs['transformer'] = nunchaku.NunchakuFluxTransformer2dModel.from_pretrained(nunchaku_repo, offload=shared.opts.nunchaku_offload, torch_dtype=devices.dtype, cache_dir=cache_dir)
kwargs['transformer'].quantization_method = 'SVDQuant'
if shared.opts.nunchaku_attention:
@@ -141,14 +142,14 @@ def load_quants(kwargs, repo_id, cache_dir, allow_quant): # pylint: disable=unus
import nunchaku
nunchaku_precision = nunchaku.utils.get_precision()
nunchaku_repo = 'mit-han-lab/nunchaku-t5/awq-int4-flux.1-t5xxl.safetensors'
- shared.log.debug(f'Load module: quant=Nunchaku module=t5 repo="{nunchaku_repo}" precision={nunchaku_precision}')
+ logger.log.debug(f'Load module: quant=Nunchaku module=t5 repo="{nunchaku_repo}" precision={nunchaku_precision}')
kwargs['text_encoder_2'] = nunchaku.NunchakuT5EncoderModel.from_pretrained(nunchaku_repo, torch_dtype=devices.dtype, cache_dir=cache_dir)
kwargs['text_encoder_2'].quantization_method = 'SVDQuant'
if 'text_encoder_2' not in kwargs and model_quant.check_quant('TE'):
load_args, quant_args = model_quant.get_dit_args(diffusers_load_config, module='TE', device_map=True)
kwargs['text_encoder_2'] = transformers.T5EncoderModel.from_pretrained(repo_id, subfolder="text_encoder_2", **load_args, **quant_args)
except Exception as e:
- shared.log.error(f'Quantization: {e}')
+ logger.log.error(f'Quantization: {e}')
errors.display(e, 'Quantization:')
return kwargs
@@ -163,7 +164,7 @@ def load_transformer(file_path): # triggered by opts.sd_unet change
"cache_dir": shared.opts.hfcache_dir,
}
if quant is not None and quant != 'none':
- shared.log.info(f'Load module: type=UNet/Transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} prequant={quant} dtype={devices.dtype}')
+ logger.log.info(f'Load module: type=UNet/Transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} prequant={quant} dtype={devices.dtype}')
if 'gguf' in file_path.lower():
from modules import ggml
_transformer = ggml.load_gguf(file_path, cls=diffusers.FluxTransformer2DModel, compute_dtype=devices.dtype)
@@ -189,16 +190,16 @@ def load_transformer(file_path): # triggered by opts.sd_unet change
else:
quant_args = model_quant.create_bnb_config({})
if quant_args:
- shared.log.info(f'Load module: type=Flux transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} quant=bnb dtype={devices.dtype}')
+ logger.log.info(f'Load module: type=Flux transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} quant=bnb dtype={devices.dtype}')
from pipelines.flux.flux_nf4 import load_flux_nf4
transformer, _text_encoder_2 = load_flux_nf4(file_path, prequantized=False)
if transformer is not None:
return transformer
load_args, quant_args = model_quant.get_dit_args(diffusers_load_config, module='Model', device_map=True)
- shared.log.debug(f'Load model: type=Flux transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} args={load_args}')
+ logger.log.debug(f'Load model: type=Flux transformer file="{file_path}" offload={shared.opts.diffusers_offload_mode} args={load_args}')
transformer = diffusers.FluxTransformer2DModel.from_single_file(file_path, **load_args, **quant_args)
if transformer is None:
- shared.log.error('Failed to load UNet model')
+ logger.log.error('Failed to load UNet model')
shared.opts.sd_unet = 'Default'
return transformer
@@ -209,7 +210,7 @@ def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_ch
allow_post_quant = False
prequantized = model_quant.get_quant(checkpoint_info.path)
- shared.log.debug(f'Load model: type=FLUX model="{checkpoint_info.name}" repo="{repo_id}" unet="{shared.opts.sd_unet}" te="{shared.opts.sd_text_encoder}" vae="{shared.opts.sd_vae}" quant={prequantized} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype}')
+ logger.log.debug(f'Load model: type=FLUX model="{checkpoint_info.name}" repo="{repo_id}" unet="{shared.opts.sd_unet}" te="{shared.opts.sd_text_encoder}" vae="{shared.opts.sd_vae}" quant={prequantized} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype}')
debug(f'Load model: type=FLUX config={diffusers_load_config}')
transformer = None
@@ -224,7 +225,7 @@ def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_ch
if shared.opts.teacache_enabled:
from modules import teacache
- shared.log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.FluxTransformer2DModel.__name__}')
+ logger.log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.FluxTransformer2DModel.__name__}')
diffusers.FluxTransformer2DModel.forward = teacache.teacache_flux_forward # patch must be done before transformer is loaded
# load overrides if any
@@ -236,7 +237,7 @@ def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_ch
shared.opts.sd_unet = 'Default'
sd_unet.failed_unet.append(shared.opts.sd_unet)
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load UNet: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load UNet: {e}")
shared.opts.sd_unet = 'Default'
if debug:
errors.display(e, 'FLUX UNet:')
@@ -249,7 +250,7 @@ def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_ch
else:
text_encoder_2 = load_t5(name=shared.opts.sd_text_encoder, cache_dir=shared.opts.diffusers_dir)
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load T5: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load T5: {e}")
shared.opts.sd_text_encoder = 'Default'
if debug:
errors.display(e, 'FLUX T5:')
@@ -263,7 +264,7 @@ def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_ch
vae_config = os.path.join('configs', 'flux', 'vae', 'config.json')
vae = diffusers.AutoencoderKL.from_single_file(vae_file, config=vae_config, **diffusers_load_config)
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load VAE: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load VAE: {e}")
shared.opts.sd_vae = 'Default'
if debug:
errors.display(e, 'FLUX VAE:')
@@ -278,7 +279,7 @@ def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_ch
if _text_encoder is not None:
text_encoder_2 = _text_encoder
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load NF4 components: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load NF4 components: {e}")
if debug:
errors.display(e, 'FLUX NF4:')
if prequantized == 'qint8' or prequantized == 'qint4':
@@ -289,7 +290,7 @@ def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_ch
if _text_encoder is not None:
text_encoder_2 = _text_encoder
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load Quanto components: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load Quanto components: {e}")
if debug:
errors.display(e, 'FLUX Quanto:')
@@ -323,14 +324,14 @@ def load_flux(checkpoint_info, diffusers_load_config): # triggered by opts.sd_ch
else:
cls = diffusers.FluxPipeline
- shared.log.debug(f'Load model: type=FLUX cls={cls.__name__} preloaded={list(kwargs)} revision={diffusers_load_config.get("revision", None)}')
+ logger.log.debug(f'Load model: type=FLUX cls={cls.__name__} preloaded={list(kwargs)} revision={diffusers_load_config.get("revision", None)}')
for c in kwargs:
if getattr(kwargs[c], 'quantization_method', None) is not None or getattr(kwargs[c], 'gguf', None) is not None:
- shared.log.debug(f'Load model: type=FLUX component={c} dtype={kwargs[c].dtype} quant={getattr(kwargs[c], "quantization_method", None) or getattr(kwargs[c], "gguf", None)}')
+ logger.log.debug(f'Load model: type=FLUX component={c} dtype={kwargs[c].dtype} quant={getattr(kwargs[c], "quantization_method", None) or getattr(kwargs[c], "gguf", None)}')
if kwargs[c].dtype == torch.float32 and devices.dtype != torch.float32:
try:
kwargs[c] = kwargs[c].to(dtype=devices.dtype)
- shared.log.warning(f'Load model: type=FLUX component={c} dtype={kwargs[c].dtype} cast dtype={devices.dtype} recast')
+ logger.log.warning(f'Load model: type=FLUX component={c} dtype={kwargs[c].dtype} cast dtype={devices.dtype} recast')
except Exception:
pass
diff --git a/pipelines/flux/flux_nf4.py b/pipelines/flux/flux_nf4.py
index 94c99e422..b6cb86f24 100644
--- a/pipelines/flux/flux_nf4.py
+++ b/pipelines/flux/flux_nf4.py
@@ -12,6 +12,7 @@ from accelerate.utils import set_module_tensor_to_device
from diffusers.loaders.single_file_utils import convert_flux_transformer_checkpoint_to_diffusers
import safetensors.torch
from modules import shared, devices, model_quant
+from modules import logger
debug = os.environ.get('SD_LOAD_DEBUG', None) is not None
@@ -163,7 +164,7 @@ def load_flux_nf4(checkpoint_info, prequantized: bool = True):
try:
converted_state_dict = convert_flux_transformer_checkpoint_to_diffusers(original_state_dict)
except Exception as e:
- shared.log.error(f"Load model: type=FLUX Failed to convert UNET: {e}")
+ logger.log.error(f"Load model: type=FLUX Failed to convert UNET: {e}")
if debug:
from modules import errors
errors.display(e, 'FLUX convert:')
@@ -190,7 +191,7 @@ def load_flux_nf4(checkpoint_info, prequantized: bool = True):
create_quantized_param(transformer, param, param_name, target_device=0, state_dict=original_state_dict, pre_quantized=prequantized)
except Exception as e:
transformer, text_encoder_2 = None, None
- shared.log.error(f"Load model: type=FLUX failed to load UNET: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load UNET: {e}")
if debug:
from modules import errors
errors.display(e, 'FLUX:')
diff --git a/pipelines/flux/flux_nunchaku.py b/pipelines/flux/flux_nunchaku.py
index d8761e186..0d3cc35cd 100644
--- a/pipelines/flux/flux_nunchaku.py
+++ b/pipelines/flux/flux_nunchaku.py
@@ -1,3 +1,4 @@
+from modules import logger
from modules import shared, devices
@@ -23,9 +24,9 @@ def load_flux_nunchaku(repo_id):
elif 'shuttle' in repo_id.lower():
nunchaku_repo = f"nunchaku-ai/nunchaku-shuttle-jaguar/svdq-{nunchaku_precision}-shuttle-jaguar.safetensors"
else:
- shared.log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" unsupported')
+ logger.log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" unsupported')
if nunchaku_repo is not None:
- shared.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} offload={shared.opts.nunchaku_offload} attention={shared.opts.nunchaku_attention}')
+ logger.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} offload={shared.opts.nunchaku_offload} attention={shared.opts.nunchaku_attention}')
transformer = nunchaku.NunchakuFluxTransformer2dModel.from_pretrained(
nunchaku_repo,
offload=shared.opts.nunchaku_offload,
diff --git a/pipelines/flux/flux_quanto.py b/pipelines/flux/flux_quanto.py
index 11e604b62..1e8f71060 100644
--- a/pipelines/flux/flux_quanto.py
+++ b/pipelines/flux/flux_quanto.py
@@ -6,9 +6,10 @@ import transformers
from safetensors.torch import load_file
from huggingface_hub import hf_hub_download
from modules import shared, errors, devices, sd_models, model_quant
+from modules import logger
-debug = shared.log.trace if os.environ.get('SD_LOAD_DEBUG', None) is not None else lambda *args, **kwargs: None
+debug = logger.log.trace if os.environ.get('SD_LOAD_DEBUG', None) is not None else lambda *args, **kwargs: None
def load_flux_quanto(checkpoint_info):
@@ -38,9 +39,9 @@ def load_flux_quanto(checkpoint_info):
try:
transformer = transformer.to(dtype=devices.dtype)
except Exception:
- shared.log.error(f"Load model: type=FLUX Failed to cast transformer to {devices.dtype}, set dtype to {transformer_dtype}")
+ logger.log.error(f"Load model: type=FLUX Failed to cast transformer to {devices.dtype}, set dtype to {transformer_dtype}")
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load Quanto transformer: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load Quanto transformer: {e}")
if debug:
errors.display(e, 'FLUX Quanto:')
@@ -64,9 +65,9 @@ def load_flux_quanto(checkpoint_info):
try:
text_encoder_2 = text_encoder_2.to(dtype=devices.dtype)
except Exception:
- shared.log.error(f"Load model: type=FLUX Failed to cast text encoder to {devices.dtype}, set dtype to {text_encoder_2_dtype}")
+ logger.log.error(f"Load model: type=FLUX Failed to cast text encoder to {devices.dtype}, set dtype to {text_encoder_2_dtype}")
except Exception as e:
- shared.log.error(f"Load model: type=FLUX failed to load Quanto text encoder: {e}")
+ logger.log.error(f"Load model: type=FLUX failed to load Quanto text encoder: {e}")
if debug:
errors.display(e, 'FLUX Quanto:')
diff --git a/pipelines/generic.py b/pipelines/generic.py
index 3b1b4bc66..f5a8858b2 100644
--- a/pipelines/generic.py
+++ b/pipelines/generic.py
@@ -4,6 +4,7 @@ import json
import diffusers
import transformers
from modules import shared, devices, errors, sd_models, model_quant
+from modules import logger
debug = os.environ.get('SD_LOAD_DEBUG', None) is not None
@@ -36,12 +37,12 @@ def load_transformer(repo_id, cls_name, load_config=None, subfolder="transformer
if shared.opts.sd_unet is not None and shared.opts.sd_unet != 'Default':
from modules import sd_unet
if shared.opts.sd_unet not in list(sd_unet.unet_dict):
- shared.log.error(f'Load module: type=transformer file="{shared.opts.sd_unet}" not found')
+ logger.log.error(f'Load module: type=transformer file="{shared.opts.sd_unet}" not found')
elif os.path.exists(sd_unet.unet_dict[shared.opts.sd_unet]):
local_file = sd_unet.unet_dict[shared.opts.sd_unet]
if local_file is not None and local_file.lower().endswith('.gguf'):
- shared.log.debug(f'Load model: transformer="{local_file}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("diffusers")} args={load_args}')
+ logger.log.debug(f'Load model: transformer="{local_file}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("diffusers")} args={load_args}')
from modules import ggml
ggml.install_gguf()
loader = cls_name.from_single_file if hasattr(cls_name, 'from_single_file') else cls_name.from_pretrained
@@ -53,7 +54,7 @@ def load_transformer(repo_id, cls_name, load_config=None, subfolder="transformer
)
transformer = model_quant.do_post_load_quant(transformer, allow=quant_type is not None)
elif local_file is not None and local_file.lower().endswith('.safetensors'):
- shared.log.debug(f'Load model: transformer="{local_file}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("diffusers")} args={load_args}')
+ logger.log.debug(f'Load model: transformer="{local_file}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("diffusers")} args={load_args}')
if dtype is not None:
load_args['torch_dtype'] = dtype
load_args.pop('device_map', None) # single-file uses different syntax
@@ -65,7 +66,7 @@ def load_transformer(repo_id, cls_name, load_config=None, subfolder="transformer
**quant_args,
)
else:
- shared.log.debug(f'Load model: transformer="{repo_id}" cls={cls_name.__name__} subfolder={subfolder} quant="{quant_type}" loader={_loader("diffusers")} args={load_args}')
+ logger.log.debug(f'Load model: transformer="{repo_id}" cls={cls_name.__name__} subfolder={subfolder} quant="{quant_type}" loader={_loader("diffusers")} args={load_args}')
if 'sdnq-' in repo_id.lower():
quant_args = {}
if dtype is not None:
@@ -91,7 +92,7 @@ def load_transformer(repo_id, cls_name, load_config=None, subfolder="transformer
elif (quant_type is not None) and (quant_args.get('quantization_config', None) is not None):
transformer.quantization_config = quant_args.get('quantization_config', None)
except Exception as e:
- shared.log.error(f'Load model: transformer="{repo_id}" cls={cls_name.__name__} {e}')
+ logger.log.error(f'Load model: transformer="{repo_id}" cls={cls_name.__name__} {e}')
errors.display(e, 'Load')
raise
devices.torch_gc()
@@ -120,13 +121,13 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
if shared.opts.sd_text_encoder is not None and shared.opts.sd_text_encoder != 'Default':
from modules import model_te
if shared.opts.sd_text_encoder not in list(model_te.te_dict):
- shared.log.error(f'Load module: type=te file="{shared.opts.sd_text_encoder}" not found')
+ logger.log.error(f'Load module: type=te file="{shared.opts.sd_text_encoder}" not found')
elif os.path.exists(model_te.te_dict[shared.opts.sd_text_encoder]):
local_file = model_te.te_dict[shared.opts.sd_text_encoder]
# load from local file gguf
if local_file is not None and local_file.lower().endswith('.gguf'):
- shared.log.debug(f'Load model: text_encoder="{local_file}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")}')
+ logger.log.debug(f'Load model: text_encoder="{local_file}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")}')
"""
from modules import ggml
ggml.install_gguf()
@@ -143,7 +144,7 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
# load from local file safetensors
elif local_file is not None and local_file.lower().endswith('.safetensors'):
- shared.log.debug(f'Load model: text_encoder="{local_file}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")}')
+ logger.log.debug(f'Load model: text_encoder="{local_file}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")}')
from modules import model_te
text_encoder = model_te.load_t5(local_file)
text_encoder = model_quant.do_post_load_quant(text_encoder, allow=quant_type is not None)
@@ -154,7 +155,7 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
import nunchaku
repo_id = 'nunchaku-ai/nunchaku-t5/awq-int4-flux.1-t5xxl.safetensors'
cls_name = nunchaku.NunchakuT5EncoderModel
- shared.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="SVDQuant" loader={_loader("transformers")}')
+ logger.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="SVDQuant" loader={_loader("transformers")}')
text_encoder = nunchaku.NunchakuT5EncoderModel.from_pretrained(
repo_id,
torch_dtype=dtype,
@@ -168,7 +169,7 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
repo_id = 'Disty0/t5-xxl'
with open(os.path.join('configs', 'flux', 'text_encoder_2', 'config.json'), encoding='utf8') as f:
load_args['config'] = transformers.T5Config(**json.load(f))
- shared.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
+ logger.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
text_encoder = cls_name.from_pretrained(
repo_id,
cache_dir=shared.opts.hfcache_dir,
@@ -181,7 +182,7 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
else:
repo_id = 'Wan-AI/Wan2.1-T2V-1.3B-Diffusers'
subfolder = 'text_encoder'
- shared.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
+ logger.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
text_encoder = cls_name.from_pretrained(
repo_id,
cache_dir=shared.opts.hfcache_dir,
@@ -192,7 +193,7 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
elif cls_name == transformers.Qwen2_5_VLForConditionalGeneration and allow_shared and shared.opts.te_shared_t5:
repo_id = 'hunyuanvideo-community/HunyuanImage-2.1-Diffusers'
subfolder = 'text_encoder'
- shared.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
+ logger.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
text_encoder = cls_name.from_pretrained(
repo_id,
cache_dir=shared.opts.hfcache_dir,
@@ -210,7 +211,7 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
else:
shared_repo = 'Tongyi-MAI/Z-Image-Turbo' # 4B variants and Z-Image use Qwen3-4B
subfolder = 'text_encoder'
- shared.log.debug(f'Load model: text_encoder="{shared_repo}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
+ logger.log.debug(f'Load model: text_encoder="{shared_repo}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
text_encoder = cls_name.from_pretrained(
shared_repo,
cache_dir=shared.opts.hfcache_dir,
@@ -221,7 +222,7 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
# load from repo
if text_encoder is None:
- shared.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
+ logger.log.debug(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} quant="{quant_type}" loader={_loader("transformers")} shared={shared.opts.te_shared_t5}')
if subfolder is not None:
load_args['subfolder'] = subfolder
if variant is not None:
@@ -243,7 +244,7 @@ def load_text_encoder(repo_id, cls_name, load_config=None, subfolder="text_encod
elif (quant_type is not None) and (quant_args.get('quantization_config', None) is not None):
text_encoder.quantization_config = quant_args.get('quantization_config', None)
except Exception as e:
- shared.log.error(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} {e}')
+ logger.log.error(f'Load model: text_encoder="{repo_id}" cls={cls_name.__name__} {e}')
errors.display(e, 'Load')
raise
devices.torch_gc()
diff --git a/pipelines/model_anima.py b/pipelines/model_anima.py
index 2937cd7e3..c9fa1457b 100644
--- a/pipelines/model_anima.py
+++ b/pipelines/model_anima.py
@@ -4,6 +4,7 @@ import transformers
import diffusers
import huggingface_hub as hf
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
@@ -21,14 +22,14 @@ def load_anima(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=Anima repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Anima repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
# download custom pipeline modules from repo
try:
pipeline_file = hf.hf_hub_download(repo_id, filename='pipeline.py', cache_dir=shared.opts.diffusers_dir)
adapter_file = hf.hf_hub_download(repo_id, filename='llm_adapter/modeling_llm_adapter.py', cache_dir=shared.opts.diffusers_dir)
except Exception as e:
- shared.log.error(f'Load model: type=Anima failed to download custom modules: {e}')
+ logger.log.error(f'Load model: type=Anima failed to download custom modules: {e}')
return None
# dynamically import custom classes and register in sys.modules so
@@ -53,7 +54,7 @@ def load_anima(checkpoint_info, diffusers_load_config=None):
torch_dtype=devices.dtype,
)
except Exception as e:
- shared.log.error(f'Load model: type=Anima adapter: {e}')
+ logger.log.error(f'Load model: type=Anima adapter: {e}')
return None
finally:
shared.state.end()
diff --git a/pipelines/model_auraflow.py b/pipelines/model_auraflow.py
index ee9e1b633..dd45ec187 100644
--- a/pipelines/model_auraflow.py
+++ b/pipelines/model_auraflow.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, sd_models, devices, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_auraflow(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=AuraFlow repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=AuraFlow repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.AuraFlowTransformer2DModel, load_config=diffusers_load_config)
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.UMT5EncoderModel, load_config=diffusers_load_config, allow_shared=False) # auraflow uses EleutherAI/pile-t5-xl
diff --git a/pipelines/model_bria.py b/pipelines/model_bria.py
index dd68f4070..a24f500d3 100644
--- a/pipelines/model_bria.py
+++ b/pipelines/model_bria.py
@@ -3,6 +3,7 @@ import sys
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
@@ -19,7 +20,7 @@ def load_bria(checkpoint_info, diffusers_load_config=None):
diffusers.BriaTransformer2DModel = BriaTransformer2DModel
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=Bria repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Bria repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=BriaTransformer2DModel, load_config=diffusers_load_config)
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.T5EncoderModel, load_config=diffusers_load_config)
diff --git a/pipelines/model_chroma.py b/pipelines/model_chroma.py
index bcb2cdcd5..e36d412cf 100644
--- a/pipelines/model_chroma.py
+++ b/pipelines/model_chroma.py
@@ -1,6 +1,7 @@
import diffusers
import transformers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_chroma(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=Chroma repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Chroma repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.ChromaTransformer2DModel, load_config=diffusers_load_config, modules_to_not_convert=["distilled_guidance_layer"])
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.T5EncoderModel, load_config=diffusers_load_config)
diff --git a/pipelines/model_chrono.py b/pipelines/model_chrono.py
index 2c66df916..884ee9c16 100644
--- a/pipelines/model_chrono.py
+++ b/pipelines/model_chrono.py
@@ -1,11 +1,12 @@
import diffusers
import transformers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
def postprocess(p, result): # pylint: disable=unused-argument
- shared.log.debug('Postprocess: model=ChronoEdit')
+ logger.log.debug('Postprocess: model=ChronoEdit')
if result is not None and hasattr(result, 'images'):
result.images = result.images[-1]
return result
@@ -18,7 +19,7 @@ def load_chrono(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=ChronoEdit repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=ChronoEdit repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.ChronoEditTransformer3DModel, load_config=diffusers_load_config, subfolder="transformer")
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.UMT5EncoderModel, load_config=diffusers_load_config, subfolder="text_encoder")
diff --git a/pipelines/model_cogview.py b/pipelines/model_cogview.py
index ae011ca95..3b96bfd3e 100644
--- a/pipelines/model_cogview.py
+++ b/pipelines/model_cogview.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_cogview3(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=CogView3 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=CogView3 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.CogView3PlusTransformer2DModel, load_config=diffusers_load_config, subfolder="transformer")
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.T5EncoderModel, load_config=diffusers_load_config, subfolder="text_encoder")
@@ -37,7 +38,7 @@ def load_cogview4(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=CogView4 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=CogView4 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.CogView4Transformer2DModel, load_config=diffusers_load_config, subfolder="transformer")
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.GlmModel, load_config=diffusers_load_config, subfolder="text_encoder", allow_quant=True)
diff --git a/pipelines/model_cosmos.py b/pipelines/model_cosmos.py
index 4c7430639..2ab5a5486 100644
--- a/pipelines/model_cosmos.py
+++ b/pipelines/model_cosmos.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_cosmos_t2i(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=Cosmos repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Cosmos repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.CosmosTransformer3DModel, load_config=diffusers_load_config, subfolder="transformer")
repo_te = 'nvidia/Cosmos-Predict2-2B-Text2Image' if 'Cosmos-Predict2-14B-Text2Image' in repo_id else repo_id
diff --git a/pipelines/model_flex.py b/pipelines/model_flex.py
index 097da2fec..c87004484 100644
--- a/pipelines/model_flex.py
+++ b/pipelines/model_flex.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_flex(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=Flex repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Flex repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.FluxTransformer2DModel, load_config=diffusers_load_config)
text_encoder_2 = generic.load_text_encoder(repo_id, cls_name=transformers.T5EncoderModel, load_config=diffusers_load_config, subfolder="text_encoder_2")
diff --git a/pipelines/model_flite.py b/pipelines/model_flite.py
index 66199981e..7bb93b131 100644
--- a/pipelines/model_flite.py
+++ b/pipelines/model_flite.py
@@ -2,6 +2,7 @@ import sys
import diffusers
import transformers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -12,7 +13,7 @@ def load_flite(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=FLite repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=FLite repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
from pipelines import f_lite
diffusers.FLitePipeline = f_lite.FLitePipeline
diff --git a/pipelines/model_flux.py b/pipelines/model_flux.py
index 142978455..d70f728a1 100644
--- a/pipelines/model_flux.py
+++ b/pipelines/model_flux.py
@@ -2,6 +2,7 @@ import os
import diffusers
import transformers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -29,12 +30,12 @@ def load_flux(checkpoint_info, diffusers_load_config=None):
flux_lora.apply_patch()
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=Flux repo="{repo_id}" cls={cls_name.__name__} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Flux repo="{repo_id}" cls={cls_name.__name__} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
# optional teacache patch
if shared.opts.teacache_enabled and not model_quant.check_nunchaku('Model'):
from modules import teacache
- shared.log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.FluxTransformer2DModel.__name__}')
+ logger.log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.FluxTransformer2DModel.__name__}')
diffusers.FluxTransformer2DModel.forward = teacache.teacache_flux_forward # patch must be done before transformer is loaded
transformer = None
@@ -73,7 +74,7 @@ def load_flux(checkpoint_info, diffusers_load_config=None):
if os.environ.get('SD_REMOTE_T5', None) is not None:
from modules import sd_te_remote
- shared.log.warning('Remote-TE: applying patch')
+ logger.log.warning('Remote-TE: applying patch')
pipe._get_t5_prompt_embeds = sd_te_remote.get_t5_prompt_embeds # pylint: disable=protected-access
pipe.text_encoder_2 = None
diff --git a/pipelines/model_flux2.py b/pipelines/model_flux2.py
index 5119f5588..068088091 100644
--- a/pipelines/model_flux2.py
+++ b/pipelines/model_flux2.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_flux2(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=Flux2 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Flux2 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.Flux2Transformer2DModel, load_config=diffusers_load_config)
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.Mistral3ForConditionalGeneration, load_config=diffusers_load_config)
diff --git a/pipelines/model_flux2_klein.py b/pipelines/model_flux2_klein.py
index d810821d9..119d46885 100644
--- a/pipelines/model_flux2_klein.py
+++ b/pipelines/model_flux2_klein.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_flux2_klein(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=Flux2Klein repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Flux2Klein repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
# Load transformer - Klein uses Flux2Transformer2DModel (same class as Flux2, different size)
transformer = generic.load_transformer(repo_id, cls_name=diffusers.Flux2Transformer2DModel, load_config=diffusers_load_config)
diff --git a/pipelines/model_glm.py b/pipelines/model_glm.py
index d849ebb19..2c04417c8 100644
--- a/pipelines/model_glm.py
+++ b/pipelines/model_glm.py
@@ -3,6 +3,7 @@ import rich.progress as rp
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -33,7 +34,7 @@ class GLMTokenProgressProcessor(transformers.LogitsProcessor):
rp.MofNCompleteColumn(),
rp.TimeElapsedColumn(),
rp.TimeRemainingColumn(),
- console=shared.console,
+ console=logger.console,
)
self.pbar.start()
self.pbar_task = self.pbar.add_task(description='', total=self.total_tokens, speed='')
@@ -87,11 +88,11 @@ def load_glm_image(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
if not hasattr(transformers, 'GlmImageForConditionalGeneration'):
- shared.log.error(f'Load model: type=GLM-Image repo="{repo_id}" transformers={transformers.__version__} not supported')
+ logger.log.error(f'Load model: type=GLM-Image repo="{repo_id}" transformers={transformers.__version__} not supported')
return None
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=GLM-Image repo="{repo_id}" offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=GLM-Image repo="{repo_id}" offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
# Load transformer (DiT decoder - 7B) with quantization support
transformer = generic.load_transformer(
diff --git a/pipelines/model_google.py b/pipelines/model_google.py
index 9c0637cf2..16738102d 100644
--- a/pipelines/model_google.py
+++ b/pipelines/model_google.py
@@ -2,7 +2,8 @@ import io
import os
import time
from PIL import Image
-from installer import install, reload, log
+from installer import install, reload
+from modules.logger import log
image_size_buckets = {
diff --git a/pipelines/model_hdm.py b/pipelines/model_hdm.py
index 2d17da0a5..f6e456a30 100644
--- a/pipelines/model_hdm.py
+++ b/pipelines/model_hdm.py
@@ -2,6 +2,7 @@ import sys
import torch
import diffusers
from modules import shared, devices, sd_models, errors
+from modules import logger
def load_hdm(checkpoint_info, diffusers_load_config=None): # pylint: disable=unused-argument
@@ -25,7 +26,7 @@ def load_hdm(checkpoint_info, diffusers_load_config=None): # pylint: disable=unu
**diffusers_load_config,
).to(devices.device)
except Exception as e:
- shared.log.error(f'Load HDM-XUT: path="{checkpoint_info.path}" {e}')
+ logger.log.error(f'Load HDM-XUT: path="{checkpoint_info.path}" {e}')
errors.display(e, 'hdm')
return None
diff --git a/pipelines/model_hidream.py b/pipelines/model_hidream.py
index efb748502..9bc6d6da5 100644
--- a/pipelines/model_hidream.py
+++ b/pipelines/model_hidream.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
@@ -9,7 +10,7 @@ def load_llama(diffusers_load_config=None):
diffusers_load_config = {}
load_args, quant_args = model_quant.get_dit_args(diffusers_load_config, module='TE', device_map=True)
llama_repo = shared.opts.model_h1_llama_repo if shared.opts.model_h1_llama_repo != 'Default' else 'meta-llama/Meta-Llama-3.1-8B-Instruct'
- shared.log.debug(f'Load model: type=HiDream te4="{llama_repo}" quant="{model_quant.get_quant_type(quant_args)}" args={load_args}')
+ logger.log.debug(f'Load model: type=HiDream te4="{llama_repo}" quant="{model_quant.get_quant_type(quant_args)}" args={load_args}')
sd_models.hf_auth_check(llama_repo)
text_encoder_4 = transformers.LlamaForCausalLM.from_pretrained(
@@ -37,7 +38,7 @@ def load_hidream(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=HiDream repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=HiDream repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.HiDreamImageTransformer2DModel, load_config=diffusers_load_config, subfolder="transformer")
text_encoder_3 = generic.load_text_encoder(repo_id, cls_name=transformers.T5EncoderModel, load_config=diffusers_load_config, subfolder="text_encoder_3")
@@ -45,7 +46,7 @@ def load_hidream(checkpoint_info, diffusers_load_config=None):
if shared.opts.teacache_enabled:
from modules import teacache
- shared.log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.HiDreamImageTransformer2DModel.__name__}')
+ logger.log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.HiDreamImageTransformer2DModel.__name__}')
diffusers.HiDreamImageTransformer2DModel.forward = teacache.teacache_hidream_forward # patch must be done before transformer is loaded
if 'I1' in repo_id:
@@ -61,7 +62,7 @@ def load_hidream(checkpoint_info, diffusers_load_config=None):
elif transformer and 'E1' in repo_id:
transformer.max_seq = 4608
else:
- shared.log.error(f'Load model: type=HiDream model="{checkpoint_info.name}" repo="{repo_id}" not recognized')
+ logger.log.error(f'Load model: type=HiDream model="{checkpoint_info.name}" repo="{repo_id}" not recognized')
return False
pipe = cls.from_pretrained(
diff --git a/pipelines/model_hunyuandit.py b/pipelines/model_hunyuandit.py
index 10863e9d9..758fe7b7d 100644
--- a/pipelines/model_hunyuandit.py
+++ b/pipelines/model_hunyuandit.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, sd_models, devices, model_quant
+from modules import logger
from pipelines import generic
@@ -16,7 +17,7 @@ def load_hunyuandit(checkpoint_info, diffusers_load_config=None):
# devices.dtype_unet = torch.float16
# diffusers_load_config['torch_dtype'] = devices.dtype
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=HunyuanDiT repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=HunyuanDiT repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.HunyuanDiT2DModel, load_config=diffusers_load_config)
repo_te = 'Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers' if 'HunyuanDiT-v1' in repo_id else repo_id
diff --git a/pipelines/model_hyimage.py b/pipelines/model_hyimage.py
index 28458bc86..6e12036b4 100644
--- a/pipelines/model_hyimage.py
+++ b/pipelines/model_hyimage.py
@@ -3,6 +3,7 @@ import torch
import transformers
import diffusers
from modules import shared, sd_models, devices, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
@@ -13,7 +14,7 @@ def load_hyimage(checkpoint_info, diffusers_load_config=None): # pylint: disable
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=HunyuanImage21 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=HunyuanImage21 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.HunyuanImageTransformer2DModel, load_config=diffusers_load_config, subfolder="transformer")
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.Qwen2_5_VLForConditionalGeneration, load_config=diffusers_load_config, subfolder="text_encoder")
@@ -46,7 +47,7 @@ def load_hyimage3(checkpoint_info, diffusers_load_config=None): # pylint: disabl
diffusers_load_config = {}
repo_id = sd_models.path_to_repo(checkpoint_info)
sd_models.hf_auth_check(checkpoint_info)
- shared.log.debug(f'Load model: type=HunyuanImage3 repo="{repo_id}" offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype}')
+ logger.log.debug(f'Load model: type=HunyuanImage3 repo="{repo_id}" offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype}')
allow_quant = True
if 'sdnq-' in repo_id.lower():
diff --git a/pipelines/model_kandinsky.py b/pipelines/model_kandinsky.py
index b2545e8fc..54c826270 100644
--- a/pipelines/model_kandinsky.py
+++ b/pipelines/model_kandinsky.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, sd_models, devices, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_kandinsky21(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=Kandinsky21 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Kandinsky21 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
pipe = diffusers.KandinskyCombinedPipeline.from_pretrained(
repo_id,
cache_dir=shared.opts.diffusers_dir,
@@ -29,7 +30,7 @@ def load_kandinsky22(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=Kandinsky22 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Kandinsky22 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
pipe = diffusers.KandinskyV22CombinedPipeline.from_pretrained(
repo_id,
cache_dir=shared.opts.diffusers_dir,
@@ -47,7 +48,7 @@ def load_kandinsky3(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=Kandinsky30 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Kandinsky30 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
unet = generic.load_transformer(repo_id, cls_name=diffusers.Kandinsky3UNet, load_config=diffusers_load_config, subfolder="unet", variant="fp16")
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.T5EncoderModel, load_config=diffusers_load_config, subfolder="text_encoder", variant="fp16", allow_shared=False)
@@ -80,7 +81,7 @@ def load_kandinsky5(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config)
- shared.log.debug(f'Load model: type=Kandinsky50 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Kandinsky50 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.Kandinsky5Transformer3DModel, load_config=diffusers_load_config)
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.Qwen2_5_VLForConditionalGeneration, load_config=diffusers_load_config)
diff --git a/pipelines/model_kolors.py b/pipelines/model_kolors.py
index 977b68320..4dfa7c507 100644
--- a/pipelines/model_kolors.py
+++ b/pipelines/model_kolors.py
@@ -1,6 +1,7 @@
import torch
import diffusers
from modules import shared, devices, sd_models, sd_hijack_te
+from modules import logger
def load_kolors(checkpoint_info, diffusers_load_config=None):
@@ -13,7 +14,7 @@ def load_kolors(checkpoint_info, diffusers_load_config=None):
if 'torch_dtype' not in diffusers_load_config:
diffusers_load_config['torch_dtype'] = torch.float16
- shared.log.debug(f'Load model: type=Kolors repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=Kolors repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
pipe = diffusers.KolorsPipeline.from_pretrained(
repo_id,
cache_dir = shared.opts.diffusers_dir,
diff --git a/pipelines/model_longcat.py b/pipelines/model_longcat.py
index d8dd7ece4..5b9166232 100644
--- a/pipelines/model_longcat.py
+++ b/pipelines/model_longcat.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_longcat(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=LongCat repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=LongCat repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.LongCatImageTransformer2DModel, load_config=diffusers_load_config)
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.Qwen2_5_VLForConditionalGeneration, load_config=diffusers_load_config)
diff --git a/pipelines/model_lumina.py b/pipelines/model_lumina.py
index 84607407e..2bba3c626 100644
--- a/pipelines/model_lumina.py
+++ b/pipelines/model_lumina.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, sd_models, sd_hijack_te, devices, model_quant
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_lumina(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_config, _quant_config = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=LuminaSFT repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=LuminaSFT repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
pipe = diffusers.LuminaText2ImgPipeline.from_pretrained(
'Alpha-VLLM/Lumina-Next-SFT-diffusers',
cache_dir = shared.opts.diffusers_dir,
@@ -30,10 +31,10 @@ def load_lumina2(checkpoint_info, diffusers_load_config=None):
if shared.opts.teacache_enabled:
from modules import teacache
- shared.log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.Lumina2Transformer2DModel.__name__}')
+ logger.log.debug(f'Transformers cache: type=teacache patch=forward cls={diffusers.Lumina2Transformer2DModel.__name__}')
diffusers.Lumina2Transformer2DModel.forward = teacache.teacache_lumina2_forward # patch must be done before transformer is loaded
- shared.log.debug(f'Load model: type=Lumina2 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=Lumina2 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.Lumina2Transformer2DModel, load_config=diffusers_load_config)
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.Gemma2Model, load_config=diffusers_load_config)
diff --git a/pipelines/model_meissonic.py b/pipelines/model_meissonic.py
index c09cf92e5..ddbf0f9d7 100644
--- a/pipelines/model_meissonic.py
+++ b/pipelines/model_meissonic.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, shared_items, sd_hijack_te
+from modules import logger
def load_meissonic(checkpoint_info, diffusers_load_config=None):
@@ -19,7 +20,7 @@ def load_meissonic(checkpoint_info, diffusers_load_config=None):
diffusers_load_config['variant'] = 'fp16'
diffusers_load_config['trust_remote_code'] = True
- shared.log.debug(f'Load model: type=Meissonic repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=Meissonic repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
model = TransformerMeissonic.from_pretrained(
repo_id,
subfolder="transformer",
diff --git a/pipelines/model_nextstep.py b/pipelines/model_nextstep.py
index e6320df5a..aff07e283 100644
--- a/pipelines/model_nextstep.py
+++ b/pipelines/model_nextstep.py
@@ -1,5 +1,6 @@
# import transformers
from modules import shared, devices, sd_models, model_quant # pylint: disable=unused-import
+from modules import logger
from pipelines import generic # pylint: disable=unused-import
@@ -9,11 +10,11 @@ def load_nextstep(checkpoint_info, diffusers_load_config=None): # pylint: disabl
repo_id = sd_models.path_to_repo(checkpoint_info)
sd_models.hf_auth_check(checkpoint_info)
- shared.log.error(f'Load model: type=NextStep model="{checkpoint_info.name}" repo="{repo_id}" not supported')
+ logger.log.error(f'Load model: type=NextStep model="{checkpoint_info.name}" repo="{repo_id}" not supported')
"""
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, module='Model')
- shared.log.debug(f'Load model: type=NextStep model="{checkpoint_info.name}" repo="{repo_id}" offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=NextStep model="{checkpoint_info.name}" repo="{repo_id}" offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
from pipelines.nextstep import NextStepPipeline, NextStep
diff --git a/pipelines/model_omnigen.py b/pipelines/model_omnigen.py
index b301abb81..4b0c08234 100644
--- a/pipelines/model_omnigen.py
+++ b/pipelines/model_omnigen.py
@@ -1,5 +1,6 @@
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
def load_omnigen(checkpoint_info, diffusers_load_config=None): # pylint: disable=unused-argument
@@ -9,7 +10,7 @@ def load_omnigen(checkpoint_info, diffusers_load_config=None): # pylint: disable
sd_models.hf_auth_check(checkpoint_info)
load_config, quant_config = model_quant.get_dit_args(diffusers_load_config, module='Model')
- shared.log.debug(f'Load model: type=OmniGen repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=OmniGen repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
transformer = diffusers.OmniGenTransformer2DModel.from_pretrained(
repo_id,
subfolder="transformer",
@@ -45,7 +46,7 @@ def load_omnigen2(checkpoint_info, diffusers_load_config=None): # pylint: disabl
diffusers.pipelines.auto_pipeline.AUTO_INPAINT_PIPELINES_MAPPING["omnigen2"] = diffusers.OmniGen2Pipeline
load_config, quant_config = model_quant.get_dit_args(diffusers_load_config, module='Model')
- shared.log.debug(f'Load model: type=OmniGen2 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=OmniGen2 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
transformer = OmniGen2Transformer2DModel.from_pretrained(
repo_id,
subfolder="transformer",
diff --git a/pipelines/model_ovis.py b/pipelines/model_ovis.py
index 9dfa0f599..abd89051e 100644
--- a/pipelines/model_ovis.py
+++ b/pipelines/model_ovis.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_ovis(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=OvisImage repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=OvisImage repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.OvisImageTransformer2DModel, load_config=diffusers_load_config)
text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.Qwen3Model, load_config=diffusers_load_config)
diff --git a/pipelines/model_pixart.py b/pipelines/model_pixart.py
index 206580c0c..ca4821ac3 100644
--- a/pipelines/model_pixart.py
+++ b/pipelines/model_pixart.py
@@ -2,6 +2,7 @@ import transformers
import diffusers
from huggingface_hub import file_exists
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -21,7 +22,7 @@ def load_pixart(checkpoint_info, diffusers_load_config=None):
repo_id_pipe = "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS"
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=PixArtSigma repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=PixArtSigma repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.PixArtTransformer2DModel, load_config=diffusers_load_config)
text_encoder = generic.load_text_encoder(repo_id_tenc, cls_name=transformers.T5EncoderModel, load_config=diffusers_load_config)
diff --git a/pipelines/model_prx.py b/pipelines/model_prx.py
index 4bcc251cb..44cd36b55 100644
--- a/pipelines/model_prx.py
+++ b/pipelines/model_prx.py
@@ -1,5 +1,6 @@
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -10,7 +11,7 @@ def load_prx(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=PRX repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=PRX repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
from transformers.models.t5gemma.modeling_t5gemma import T5GemmaEncoder
transformer = generic.load_transformer(repo_id, cls_name=diffusers.PRXTransformer2DModel, load_config=diffusers_load_config)
diff --git a/pipelines/model_qwen.py b/pipelines/model_qwen.py
index 546e755cc..7f83240ae 100644
--- a/pipelines/model_qwen.py
+++ b/pipelines/model_qwen.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
def load_qwen(checkpoint_info, diffusers_load_config=None):
@@ -13,7 +14,7 @@ def load_qwen(checkpoint_info, diffusers_load_config=None):
transformer = None
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, module='Model')
- shared.log.debug(f'Load model: type=Qwen model="{checkpoint_info.name}" repo="{repo_id}" offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=Qwen model="{checkpoint_info.name}" repo="{repo_id}" offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
if '2509' in repo_id or '2511' in repo_id:
cls_name = diffusers.QwenImageEditPlusPipeline
diff --git a/pipelines/model_sana.py b/pipelines/model_sana.py
index 8b04fcfb0..19e3f093a 100644
--- a/pipelines/model_sana.py
+++ b/pipelines/model_sana.py
@@ -2,6 +2,7 @@ import torch
import diffusers
import transformers
from modules import shared, sd_models, sd_hijack_te, devices, model_quant
+from modules import logger
def load_quants(kwargs, repo_id, cache_dir):
@@ -10,7 +11,7 @@ def load_quants(kwargs, repo_id, cache_dir):
import nunchaku
nunchaku_precision = nunchaku.utils.get_precision()
nunchaku_repo = "nunchaku-ai/nunchaku-sana/svdq-int4_r32-sana1.6b.safetensors"
- shared.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} attention={shared.opts.nunchaku_attention}')
+ logger.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} attention={shared.opts.nunchaku_attention}')
kwargs['transformer'] = nunchaku.NunchakuSanaTransformer2DModel.from_pretrained(nunchaku_repo, torch_dtype=devices.dtype, cache_dir=cache_dir)
elif model_quant.check_quant('Model'):
load_args, quant_args = model_quant.get_dit_args(kwargs_copy, module='Model')
@@ -47,7 +48,7 @@ def load_sana(checkpoint_info, kwargs=None):
kwargs['variant'] = 'fp16'
kwargs = load_quants(kwargs, repo_id, cache_dir=shared.opts.diffusers_dir)
- shared.log.debug(f'Load model: type=Sana repo="{repo_id}" args={list(kwargs)}')
+ logger.log.debug(f'Load model: type=Sana repo="{repo_id}" args={list(kwargs)}')
if devices.dtype == torch.bfloat16 or devices.dtype == torch.float32:
kwargs['torch_dtype'] = devices.dtype
@@ -76,7 +77,7 @@ def load_sana(checkpoint_info, kwargs=None):
pipe.text_encoder = pipe.text_encoder.to(dtype=torch.float32) # gemma2 does not support fp16
pipe.vae = pipe.vae.to(dtype=torch.float32) # dc-ae often overflows in fp16
except Exception as e:
- shared.log.error(f'Load model: type=Sana {e}')
+ logger.log.error(f'Load model: type=Sana {e}')
sd_hijack_te.init_hijack(pipe)
diff --git a/pipelines/model_sd3.py b/pipelines/model_sd3.py
index 7b977d154..e6e87e0b6 100644
--- a/pipelines/model_sd3.py
+++ b/pipelines/model_sd3.py
@@ -1,6 +1,7 @@
import diffusers
import transformers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -11,7 +12,7 @@ def load_sd3(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=SD3 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
+ logger.log.debug(f'Load model: type=SD3 repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}')
transformer = generic.load_transformer(repo_id, cls_name=diffusers.SD3Transformer2DModel, load_config=diffusers_load_config)
# text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.CLIPTextModelWithProjection, load_config=diffusers_load_config, subfolder="text_encoder")
diff --git a/pipelines/model_stablecascade.py b/pipelines/model_stablecascade.py
index 7f1df501b..dd2d97020 100644
--- a/pipelines/model_stablecascade.py
+++ b/pipelines/model_stablecascade.py
@@ -2,6 +2,7 @@ import os
import torch
import diffusers
from modules import shared, devices, sd_models
+from modules import logger
def get_timestep_ratio_conditioning(t, alphas_cumprod):
@@ -43,7 +44,7 @@ def load_text_encoder(path):
vocab_size=49408
)
- shared.log.info(f'Load Text Encoder: name="{os.path.basename(os.path.splitext(path)[0])}" file="{path}"')
+ logger.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)
@@ -57,7 +58,7 @@ def load_text_encoder(path):
except Exception as e:
text_encoder = None
- shared.log.error(f'Failed to load Text Encoder model: {e}')
+ logger.log.error(f'Failed to load Text Encoder model: {e}')
return None
@@ -73,7 +74,7 @@ def load_prior(path, config_file="default"):
else:
config_file = "configs/stable-cascade/prior/config.json"
- shared.log.info(f'Load UNet: name="{os.path.basename(os.path.splitext(path)[0])}" file="{path}" config="{config_file}"')
+ logger.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
@@ -108,7 +109,7 @@ def load_cascade_combined(checkpoint_info, diffusers_load_config=None):
decoder = StableCascadeDecoderPipeline.from_pretrained("stabilityai/stable-cascade", cache_dir=shared.opts.diffusers_dir, decoder=decoder_unet, text_encoder=None, **diffusers_load_config)
else:
decoder = StableCascadeDecoderPipeline.from_pretrained(checkpoint_info.path, cache_dir=shared.opts.diffusers_dir, text_encoder=None, **diffusers_load_config)
- # shared.log.debug(f'StableCascade {decoder_folder}: scale={decoder.latent_dim_scale}')
+ # logger.log.debug(f'StableCascade {decoder_folder}: scale={decoder.latent_dim_scale}')
prior_text_encoder = None
if shared.opts.sd_unet != "Default":
prior_unet, prior_text_encoder = load_prior(unet_dict[shared.opts.sd_unet])
@@ -118,7 +119,7 @@ def load_cascade_combined(checkpoint_info, diffusers_load_config=None):
prior = StableCascadePriorPipeline.from_pretrained("stabilityai/stable-cascade-prior", cache_dir=shared.opts.diffusers_dir, prior=prior_unet, text_encoder=prior_text_encoder, image_encoder=None, feature_extractor=None, **diffusers_load_config)
else:
prior = StableCascadePriorPipeline.from_pretrained("stabilityai/stable-cascade-prior", cache_dir=shared.opts.diffusers_dir, prior=prior_unet, image_encoder=None, feature_extractor=None, **diffusers_load_config)
- # shared.log.debug(f'StableCascade {prior_folder}: scale={prior.resolution_multiple}')
+ # logger.log.debug(f'StableCascade {prior_folder}: scale={prior.resolution_multiple}')
sd_model = StableCascadeCombinedPipeline(
tokenizer=decoder.tokenizer,
text_encoder=None,
@@ -159,7 +160,7 @@ def load_cascade_combined(checkpoint_info, diffusers_load_config=None):
)
devices.torch_gc(force=True, reason='load')
- shared.log.debug(f'StableCascade combined: {sd_model.__class__.__name__}')
+ logger.log.debug(f'StableCascade combined: {sd_model.__class__.__name__}')
return sd_model
diff --git a/pipelines/model_wanai.py b/pipelines/model_wanai.py
index 57a51f378..f0cd5db44 100644
--- a/pipelines/model_wanai.py
+++ b/pipelines/model_wanai.py
@@ -2,6 +2,7 @@ import os
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae
+from modules import logger
def load_transformer(repo_id, diffusers_load_config=None, subfolder='transformer'):
@@ -18,15 +19,15 @@ def load_transformer(repo_id, diffusers_load_config=None, subfolder='transformer
if shared.opts.sd_unet is not None and shared.opts.sd_unet != 'Default':
from modules import sd_unet
if shared.opts.sd_unet not in list(sd_unet.unet_dict):
- shared.log.error(f'Load module: type=Transformer not found: {shared.opts.sd_unet}')
+ logger.log.error(f'Load module: type=Transformer not found: {shared.opts.sd_unet}')
return None
fn = sd_unet.unet_dict[shared.opts.sd_unet] if os.path.exists(sd_unet.unet_dict[shared.opts.sd_unet]) else None
if fn is not None and 'gguf' in fn.lower():
- shared.log.error('Load model: type=WanAI format="gguf" unsupported')
+ logger.log.error('Load model: type=WanAI format="gguf" unsupported')
transformer = None
elif fn is not None and 'safetensors' in fn.lower():
- shared.log.debug(f'Load model: type=WanAI {subfolder}="{fn}" quant="{model_quant.get_quant(repo_id)}" args={load_args}')
+ logger.log.debug(f'Load model: type=WanAI {subfolder}="{fn}" quant="{model_quant.get_quant(repo_id)}" args={load_args}')
transformer = transformer_cls.from_single_file(
fn,
cache_dir=shared.opts.hfcache_dir,
@@ -34,7 +35,7 @@ def load_transformer(repo_id, diffusers_load_config=None, subfolder='transformer
**quant_args,
)
else:
- shared.log.debug(f'Load model: type=WanAI {subfolder}="{repo_id}" quant="{model_quant.get_quant_type(quant_args)}" args={load_args}')
+ logger.log.debug(f'Load model: type=WanAI {subfolder}="{repo_id}" quant="{model_quant.get_quant_type(quant_args)}" args={load_args}')
transformer = transformer_cls.from_pretrained(
repo_id,
subfolder=subfolder,
@@ -52,7 +53,7 @@ def load_text_encoder(repo_id, diffusers_load_config=None):
diffusers_load_config = {}
load_args, quant_args = model_quant.get_dit_args(diffusers_load_config, module='TE', device_map=True)
repo_id = 'Wan-AI/Wan2.1-T2V-1.3B-Diffusers' if 'Wan2.' in repo_id else repo_id # always use shared umt5
- shared.log.debug(f'Load model: type=WanAI te="{repo_id}" quant="{model_quant.get_quant_type(quant_args)}" args={load_args}')
+ logger.log.debug(f'Load model: type=WanAI te="{repo_id}" quant="{model_quant.get_quant_type(quant_args)}" args={load_args}')
text_encoder = transformers.UMT5EncoderModel.from_pretrained(
repo_id,
subfolder="text_encoder",
@@ -86,7 +87,7 @@ def load_wan(checkpoint_info, diffusers_load_config=None):
transformer_2 = load_transformer(repo_id, diffusers_load_config, 'transformer_2')
boundary_ratio = shared.opts.model_wan_boundary
else:
- shared.log.error(f'Load model: type=WanAI stage="{shared.opts.model_wan_stage}" unsupported')
+ logger.log.error(f'Load model: type=WanAI stage="{shared.opts.model_wan_stage}" unsupported')
return None
else:
transformer = load_transformer(repo_id, diffusers_load_config, 'transformer')
@@ -109,7 +110,7 @@ def load_wan(checkpoint_info, diffusers_load_config=None):
pipe_cls = diffusers.WanPipeline
diffusers.pipelines.auto_pipeline.AUTO_TEXT2IMAGE_PIPELINES_MAPPING["wanai"] = diffusers.WanPipeline
diffusers.pipelines.auto_pipeline.AUTO_IMAGE2IMAGE_PIPELINES_MAPPING["wanai"] = WanImagePipeline
- shared.log.debug(f'Load model: type=WanAI model="{checkpoint_info.name}" repo="{repo_id}" cls={pipe_cls.__name__} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args} stage="{shared.opts.model_wan_stage}" boundary={boundary_ratio}')
+ logger.log.debug(f'Load model: type=WanAI model="{checkpoint_info.name}" repo="{repo_id}" cls={pipe_cls.__name__} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args} stage="{shared.opts.model_wan_stage}" boundary={boundary_ratio}')
pipe = pipe_cls.from_pretrained(
repo_id,
transformer=transformer,
diff --git a/pipelines/model_xomni.py b/pipelines/model_xomni.py
index 5b3a96853..07350bed6 100644
--- a/pipelines/model_xomni.py
+++ b/pipelines/model_xomni.py
@@ -2,6 +2,7 @@ import torch
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant
+from modules import logger
class XOmniPipeline(diffusers.DiffusionPipeline):
@@ -25,12 +26,12 @@ class XOmniPipeline(diffusers.DiffusionPipeline):
):
from pipelines.xomni import modeling_xomni
load_args, quant_args = model_quant.get_dit_args(load_config, module='Model', device_map=True)
- shared.log.debug(f'Load model: cls=XOmniPipeline module=tokenizer repo_id="{repo_id}"')
+ logger.log.debug(f'Load model: cls=XOmniPipeline module=tokenizer repo_id="{repo_id}"')
self.tokenizer = transformers.AutoTokenizer.from_pretrained(
repo_id,
use_fast=True,
)
- shared.log.debug(f'Load model: cls=XOmniPipeline module=transformer repo_id="{repo_id}" args={load_args}')
+ logger.log.debug(f'Load model: cls=XOmniPipeline module=transformer repo_id="{repo_id}" args={load_args}')
# self.model = transformers.AutoModelForCausalLM.from_pretrained(
self.model = modeling_xomni.XOmniForCausalLM.from_pretrained(
repo_id,
@@ -40,7 +41,7 @@ class XOmniPipeline(diffusers.DiffusionPipeline):
**quant_args,
)
flux_repo_id = "black-forest-labs/FLUX.1-dev"
- shared.log.debug(f'Load model: cls=XOmniPipeline module=vision repo_id="{flux_repo_id}"')
+ logger.log.debug(f'Load model: cls=XOmniPipeline module=vision repo_id="{flux_repo_id}"')
self.model.init_vision(
flux_repo_id,
**quant_args,
diff --git a/pipelines/model_z_image.py b/pipelines/model_z_image.py
index 3aa269b48..fd575cbfd 100644
--- a/pipelines/model_z_image.py
+++ b/pipelines/model_z_image.py
@@ -1,6 +1,7 @@
import transformers
import diffusers
from modules import shared, devices, sd_models, model_quant, sd_hijack_te
+from modules import logger
from pipelines import generic
@@ -9,7 +10,7 @@ def load_nunchaku():
nunchaku_precision = nunchaku.utils.get_precision()
nunchaku_rank = 128
nunchaku_repo = f"nunchaku-ai/nunchaku-z-image-turbo/svdq-{nunchaku_precision}_r{nunchaku_rank}-z-image-turbo.safetensors"
- shared.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" attention={shared.opts.nunchaku_attention}')
+ logger.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" attention={shared.opts.nunchaku_attention}')
transformer = nunchaku.NunchakuZImageTransformer2DModel.from_pretrained(
nunchaku_repo,
torch_dtype=devices.dtype,
@@ -25,7 +26,7 @@ def load_z_image(checkpoint_info, diffusers_load_config=None):
sd_models.hf_auth_check(checkpoint_info)
load_args, _quant_args = model_quant.get_dit_args(diffusers_load_config, allow_quant=False)
- shared.log.debug(f'Load model: type=ZImage repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
+ logger.log.debug(f'Load model: type=ZImage repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={diffusers_load_config}')
if model_quant.check_nunchaku('Model'): # only available model
transformer = load_nunchaku()
diff --git a/pipelines/qwen/qwen_nunchaku.py b/pipelines/qwen/qwen_nunchaku.py
index 4fd964df3..9775041df 100644
--- a/pipelines/qwen/qwen_nunchaku.py
+++ b/pipelines/qwen/qwen_nunchaku.py
@@ -1,3 +1,4 @@
+from modules import logger
from modules import shared, devices
@@ -10,7 +11,7 @@ def load_qwen_nunchaku(repo_id, subfolder=None):
try:
from nunchaku.models.transformers.transformer_qwenimage import NunchakuQwenImageTransformer2DModel
except Exception:
- shared.log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" low nunchaku version')
+ logger.log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" low nunchaku version')
return None
if 'pruning' in repo_id.lower() or 'distill' in repo_id.lower():
return None
@@ -31,9 +32,9 @@ def load_qwen_nunchaku(repo_id, subfolder=None):
else:
nunchaku_repo = f"nunchaku-ai/nunchaku-qwen-image-edit/svdq-{nunchaku_precision}_r128-qwen-image-edit-lightningv1.0-8steps.safetensors"
else:
- shared.log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" unsupported')
+ logger.log.error(f'Load module: quant=Nunchaku module=transformer repo="{repo_id}" unsupported')
if nunchaku_repo is not None:
- shared.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} offload={shared.opts.nunchaku_offload} attention={shared.opts.nunchaku_attention}')
+ logger.log.debug(f'Load module: quant=Nunchaku module=transformer repo="{nunchaku_repo}" precision={nunchaku_precision} offload={shared.opts.nunchaku_offload} attention={shared.opts.nunchaku_attention}')
transformer = NunchakuQwenImageTransformer2DModel.from_pretrained(
nunchaku_repo,
offload=shared.opts.nunchaku_offload,
diff --git a/refactor_logger.py b/refactor_logger.py
new file mode 100644
index 000000000..ed0c48300
--- /dev/null
+++ b/refactor_logger.py
@@ -0,0 +1,90 @@
+import os
+import re
+
+def refactor_file(filepath):
+ with open(filepath, 'r', encoding='utf-8') as f:
+ content = f.read()
+
+ original_content = content
+ modified = False
+
+ # Check for usages
+ has_shared_log = 'logger.log' in content
+ has_installer_log = 'logger.log' in content
+ has_errors_log = 'logger.log' in content
+ has_shared_console = 'logger.console' in content
+ has_installer_console = 'logger.console' in content
+
+ if not (has_shared_log or has_installer_log or has_errors_log or has_shared_console or has_installer_console):
+ return
+
+ # Add import if needed
+ # Check if 'from modules import logger' or 'import modules.logger' exists
+ if not re.search(r'from modules import .*logger', content) and not re.search(r'import modules.logger', content):
+ # Insert import
+ # Try to find standard imports block
+ lines = content.split('\n')
+ insert_idx = 0
+ for i, line in enumerate(lines):
+ if line.startswith('import ') or line.startswith('from '):
+ # find last import
+ pass
+ if line.startswith('class ') or line.startswith('def '):
+ insert_idx = i
+ break
+
+ # refinement: find last from modules import ...
+ last_import_idx = 0
+ for i, line in enumerate(lines):
+ if line.startswith('from modules import') or line.startswith('import modules'):
+ last_import_idx = i
+
+ if last_import_idx > 0:
+ lines.insert(last_import_idx + 1, 'from modules import logger')
+ else:
+ # insert at top after __future__ or similar
+ for i, line in enumerate(lines):
+ if not line.startswith('#') and not line.strip() == '' and not line.startswith('from __future__'):
+ insert_idx = i
+ break
+ lines.insert(insert_idx, 'from modules import logger')
+
+ content = '\n'.join(lines)
+ modified = True
+
+ # Replacements
+ if has_shared_log:
+ content = content.replace('logger.log', 'logger.log')
+ modified = True
+ if has_installer_log:
+ content = content.replace('logger.log', 'logger.log')
+ modified = True
+ if has_errors_log:
+ content = content.replace('logger.log', 'logger.log')
+ modified = True
+ if has_shared_console:
+ content = content.replace('logger.console', 'logger.console')
+ modified = True
+ if has_installer_console:
+ content = content.replace('logger.console', 'logger.console')
+ modified = True
+
+ # Specific fix for shared.py and installer.py self-references if any
+ # (though I already updated them manually mostly)
+
+ if modified and content != original_content:
+ print(f"Modifying {filepath}")
+ with open(filepath, 'w', encoding='utf-8') as f:
+ f.write(content)
+
+# Walk directory
+root_dir = '/home/vlado/dev/sdnext'
+for root, dirs, files in os.walk(root_dir):
+ if 'venv' in dirs:
+ dirs.remove('venv')
+ if '.git' in dirs:
+ dirs.remove('.git')
+
+ for file in files:
+ if file.endswith('.py'):
+ refactor_file(os.path.join(root, file))
diff --git a/scripts/animatediff.py b/scripts/animatediff.py
index 933d54049..f2f041982 100644
--- a/scripts/animatediff.py
+++ b/scripts/animatediff.py
@@ -3,6 +3,7 @@ import gradio as gr
import diffusers
from safetensors.torch import load_file
from modules import scripts_manager, processing, shared, devices, sd_models
+from modules import logger
# config
@@ -49,18 +50,18 @@ def set_adapter(adapter_name: str = 'None'):
motion_adapter = None
loaded_adapter = None
if orig_pipe is not None:
- shared.log.debug(f'AnimateDiff restore pipeline: adapter="{loaded_adapter}"')
+ logger.log.debug(f'AnimateDiff restore pipeline: adapter="{loaded_adapter}"')
shared.sd_model = orig_pipe
orig_pipe = None
return
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl' and not (shared.sd_model.__class__.__name__ == 'AnimateDiffPipeline' or shared.sd_model.__class__.__name__ == 'AnimateDiffSDXLPipeline'):
- shared.log.warning(f'AnimateDiff: unsupported model type: {shared.sd_model.__class__.__name__}')
+ logger.log.warning(f'AnimateDiff: unsupported model type: {shared.sd_model.__class__.__name__}')
return
if motion_adapter is not None and loaded_adapter == adapter_name and (shared.sd_model.__class__.__name__ == 'AnimateDiffPipeline' or shared.sd_model.__class__.__name__ == 'AnimateDiffSDXLPipeline'):
- shared.log.debug(f'AnimateDiff: adapter="{adapter_name}" cached')
+ logger.log.debug(f'AnimateDiff: adapter="{adapter_name}" cached')
return
if getattr(shared.sd_model, 'image_encoder', None) is not None:
- shared.log.debug('AnimateDiff: unloading IP adapter')
+ logger.log.debug('AnimateDiff: unloading IP adapter')
# shared.sd_model.image_encoder = None
# shared.sd_model.unet.set_default_attn_processor()
shared.sd_model.unet.config.encoder_hid_dim_type = None
@@ -69,7 +70,7 @@ def set_adapter(adapter_name: str = 'None'):
folder, filename = os.path.split(adapter_name)
adapter_name = hf.hf_hub_download(repo_id=folder, filename=filename, cache_dir=shared.opts.diffusers_dir)
try:
- shared.log.info(f'AnimateDiff load: adapter="{adapter_name}"')
+ logger.log.info(f'AnimateDiff load: adapter="{adapter_name}"')
motion_adapter = None
if adapter_name.endswith('.safetensors'):
motion_adapter = diffusers.MotionAdapter().to(shared.device, devices.dtype)
@@ -84,7 +85,7 @@ def set_adapter(adapter_name: str = 'None'):
new_pipe = None
if 'Model' in shared.opts.sdnq_quantize_weights:
- shared.log.debug(f'AnimateDiff: sdnq={shared.opts.sdnq_quantize_weights} reloading model weights')
+ logger.log.debug(f'AnimateDiff: sdnq={shared.opts.sdnq_quantize_weights} reloading model weights')
prev_opts = shared.opts.sdnq_quantize_weights
shared.opts.sdnq_quantize_weights = []
sd_models.reload_model_weights(force=True)
@@ -118,7 +119,7 @@ def set_adapter(adapter_name: str = 'None'):
if new_pipe is None:
motion_adapter = None
loaded_adapter = None
- shared.log.error(f'AnimateDiff load error: adapter="{adapter_name}"')
+ logger.log.error(f'AnimateDiff load error: adapter="{adapter_name}"')
return
orig_pipe = shared.sd_model
shared.sd_model = new_pipe
@@ -126,11 +127,11 @@ def set_adapter(adapter_name: str = 'None'):
sd_models.copy_diffuser_options(new_pipe, orig_pipe)
sd_models.set_diffuser_options(shared.sd_model, vae=None, op='model')
sd_models.move_model(shared.sd_model.unet, devices.device) # move pipeline to device
- shared.log.debug(f'AnimateDiff: adapter="{loaded_adapter}"')
+ logger.log.debug(f'AnimateDiff: adapter="{loaded_adapter}"')
except Exception as e:
motion_adapter = None
loaded_adapter = None
- shared.log.error(f'AnimateDiff load error: adapter="{adapter_name}" {e}')
+ logger.log.error(f'AnimateDiff load error: adapter="{adapter_name}" {e}')
from modules import errors
errors.display('e', 'AnimateDiff')
@@ -142,7 +143,7 @@ def set_scheduler(p, model, override: bool = False):
shared.sd_model.scheduler = diffusers.LCMScheduler.from_config(shared.sd_model.scheduler.config)
else:
shared.sd_model.scheduler = diffusers.DDIMScheduler.from_config(shared.sd_model.scheduler.config)
- shared.log.debug(f'AnimateDiff: scheduler={shared.sd_model.scheduler.__class__.__name__}')
+ logger.log.debug(f'AnimateDiff: scheduler={shared.sd_model.scheduler.__class__.__name__}')
def set_prompt(p):
@@ -158,14 +159,14 @@ def set_prompt(p):
prompt[int(k.strip())] = v.strip()
except Exception:
prompt = p.prompt
- shared.log.debug(f'AnimateDiff prompt: {prompt}')
+ logger.log.debug(f'AnimateDiff prompt: {prompt}')
p.task_args['prompt'] = prompt
p.task_args['negative_prompt'] = p.negative_prompt
def set_lora(p, lora, strength):
if lora is not None and lora != 'None':
- shared.log.debug(f'AnimateDiff: lora="{lora}" strength={strength}')
+ logger.log.debug(f'AnimateDiff: lora="{lora}" strength={strength}')
if lora.endswith('.safetensors'):
fn = os.path.basename(lora)
lora = lora.replace(f'/{fn}', '')
@@ -178,7 +179,7 @@ def set_lora(p, lora, strength):
def set_free_init(method, iters, order, spatial, temporal):
if hasattr(shared.sd_model, 'enable_free_init') and method != 'none':
- shared.log.debug(f'AnimateDiff free init: method={method} iters={iters} order={order} spatial={spatial} temporal={temporal}')
+ logger.log.debug(f'AnimateDiff free init: method={method} iters={iters} order={order} spatial={spatial} temporal={temporal}')
shared.sd_model.enable_free_init(
num_iters=iters,
use_fast_sampling=False,
@@ -193,7 +194,7 @@ def set_free_noise(frames):
context_length = 16
context_stride = 4
if frames >= context_length and hasattr(shared.sd_model, 'enable_free_noise'):
- shared.log.debug(f'AnimateDiff free noise: frames={frames} context={context_length} stride={context_stride}')
+ logger.log.debug(f'AnimateDiff free noise: frames={frames} context={context_length} stride={context_stride}')
shared.sd_model.enable_free_noise(context_length=context_length, context_stride=context_stride)
@@ -251,7 +252,7 @@ class Script(scripts_manager.Script):
p.task_args['num_frames'] = frames
p.task_args['num_inference_steps'] = p.steps
p.task_args['output_type'] = 'np'
- shared.log.debug(f'AnimateDiff args: {p.task_args}')
+ logger.log.debug(f'AnimateDiff args: {p.task_args}')
set_prompt(p)
orig_prompt_attention = shared.opts.prompt_attention
shared.opts.data['prompt_attention'] = 'fixed'
@@ -264,5 +265,5 @@ class Script(scripts_manager.Script):
def after(self, p: processing.StableDiffusionProcessing, processed: processing.Processed, adapter_index, frames, lora_index, strength, latent_mode, video_type, duration, gif_loop, mp4_pad, mp4_interpolate, override_scheduler, fi_method, fi_iters, fi_order, fi_spatial, fi_temporal): # pylint: disable=arguments-differ, unused-argument
from modules.images import save_video
if video_type != 'None':
- shared.log.debug(f'AnimateDiff video: type={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
+ logger.log.debug(f'AnimateDiff video: type={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
save_video(p, filename=None, images=processed.images, video_type=video_type, duration=duration, loop=gif_loop, pad=mp4_pad, interpolate=mp4_interpolate)
diff --git a/scripts/apg.py b/scripts/apg.py
index c17531f11..87422d1ae 100644
--- a/scripts/apg.py
+++ b/scripts/apg.py
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models
+from modules import logger
registered = False
@@ -53,7 +54,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, eta = 0.0, momentum = 0.0, threshold = 0.0): # pylint: disable=arguments-differ
supported_model_list = ['sd', 'sdxl', 'sc']
if shared.sd_model_type not in supported_model_list:
- shared.log.warning(f'APG: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
+ logger.log.warning(f'APG: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
from modules import apg
apg.eta = getattr(p, 'apg_eta', eta) # use values set by xyz grid or via ui
@@ -70,7 +71,7 @@ class Script(scripts_manager.Script):
elif shared.sd_model_type == "sc":
self.orig_pipe = shared.sd_model.prior_pipe
shared.sd_model.prior_pipe = sd_models.switch_pipe(apg.StableCascadePriorPipelineAPG, shared.sd_model.prior_pipe)
- shared.log.info(f'APG apply: guidance={p.cfg_scale} momentum={apg.momentum} eta={apg.eta} threshold={apg.threshold} class={shared.sd_model.__class__.__name__}')
+ logger.log.info(f'APG apply: guidance={p.cfg_scale} momentum={apg.momentum} eta={apg.eta} threshold={apg.threshold} class={shared.sd_model.__class__.__name__}')
p.extra_generation_params["APG"] = f'ETA={apg.eta} Momentum={apg.momentum} Threshold={apg.threshold}'
# processed = processing.process_images(p)
return None
diff --git a/scripts/automatic_color_inpaint.py b/scripts/automatic_color_inpaint.py
index 9edfdd503..cf94b5af0 100644
--- a/scripts/automatic_color_inpaint.py
+++ b/scripts/automatic_color_inpaint.py
@@ -2,6 +2,7 @@ import gradio as gr
from PIL import Image
import numpy as np
from modules import shared, scripts_manager, processing, masking
+from modules import logger
"""
Automatic Color Inpaint Script for SD.NEXT - SD & SDXL Support
@@ -89,7 +90,7 @@ class Script(scripts_manager.Script):
# Run pipeline
def run(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=arguments-differ
if shared.sd_model_type not in supported_models:
- shared.log.warning(f'MoD: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_models}')
+ logger.log.warning(f'MoD: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_models}')
return None
if not hasattr(p, 'init_images') or p.init_images is None or len(p.init_images) == 0:
return None
@@ -98,7 +99,7 @@ class Script(scripts_manager.Script):
# Convert hex color to RGB tuple (0-255)
color_to_mask_rgb = tuple(int(color_to_mask_hex[i:i+2], 16) for i in (1, 3, 5))
- shared.log.debug(f'ACI: rgb={color_to_mask_rgb} tolerance={mask_tolerance} dilate={mask_dilate} erode={mask_erode} blur={mask_blur} denoise={inpaint_denoising_strength}')
+ logger.log.debug(f'ACI: rgb={color_to_mask_rgb} tolerance={mask_tolerance} dilate={mask_dilate} erode={mask_erode} blur={mask_blur} denoise={inpaint_denoising_strength}')
# Create Color Mask using vectorized operations
init_image = p.init_images[0].convert("RGB")
diff --git a/scripts/blipdiffusion.py b/scripts/blipdiffusion.py
index 93f610f7b..8731f633c 100644
--- a/scripts/blipdiffusion.py
+++ b/scripts/blipdiffusion.py
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models
+from modules import logger
class Script(scripts_manager.Script):
@@ -23,7 +24,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, source_subject, target_subject, prompt_strength): # pylint: disable=arguments-differ, unused-argument
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if c != 'BlipDiffusionPipeline':
- shared.log.error(f'BLIP: model selected={c} required=BLIPDiffusion')
+ logger.log.error(f'BLIP: model selected={c} required=BLIPDiffusion')
return None
if hasattr(p, 'init_images') and len(p.init_images) > 0:
p.task_args['reference_image'] = p.init_images[0]
@@ -33,10 +34,10 @@ class Script(scripts_manager.Script):
p.task_args['source_subject_category'] = [source_subject]
p.task_args['target_subject_category'] = [target_subject]
p.task_args['output_type'] = 'pil'
- shared.log.debug(f'BLIP Diffusion: args={p.task_args}')
+ logger.log.debug(f'BLIP Diffusion: args={p.task_args}')
shared.sd_model = sd_models.set_diffuser_pipe(shared.sd_model, sd_models.DiffusersTaskType.IMAGE_2_IMAGE)
processed = processing.process_images(p)
return processed
else:
- shared.log.error('BLIP: no init_images')
+ logger.log.error('BLIP: no init_images')
return None
diff --git a/scripts/consistory_ext.py b/scripts/consistory_ext.py
index b91d74fa7..4e88c9e0f 100644
--- a/scripts/consistory_ext.py
+++ b/scripts/consistory_ext.py
@@ -13,6 +13,7 @@ import time
import gradio as gr
import diffusers
from modules import scripts_manager, devices, errors, processing, shared, sd_models, sd_samplers
+from modules import logger
class Script(scripts_manager.Script):
@@ -30,7 +31,7 @@ class Script(scripts_manager.Script):
def reset(self):
self.anchor_cache_first_stage = None
self.anchor_cache_second_stage = None
- shared.log.debug('ConsiStory reset anchors')
+ logger.log.debug('ConsiStory reset anchors')
def ui(self, _is_img2img): # ui elements
with gr.Row():
@@ -68,7 +69,7 @@ class Script(scripts_manager.Script):
diffusers.models.embeddings.PositionNet = diffusers.models.embeddings.GLIGENTextBoundingboxProjection # patch as renamed in https://github.com/huggingface/diffusers/pull/6244/files
import scripts.consistory as cs
if shared.sd_model.__class__.__name__ != 'ConsistoryExtendAttnSDXLPipeline':
- shared.log.debug('ConsiStory init')
+ logger.log.debug('ConsiStory init')
t0 = time.time()
state_dict = shared.sd_model.unet.state_dict() # save existing unet
shared.sd_model = sd_models.switch_pipe(cs.ConsistoryExtendAttnSDXLPipeline, shared.sd_model)
@@ -80,7 +81,7 @@ class Script(scripts_manager.Script):
sd_models.move_model(shared.sd_model, devices.device)
sd_models.move_model(shared.sd_model.unet, devices.device)
t1 = time.time()
- shared.log.debug(f'ConsiStory load: model={shared.sd_model.__class__.__name__} time={t1-t0:.2f}')
+ logger.log.debug(f'ConsiStory load: model={shared.sd_model.__class__.__name__} time={t1-t0:.2f}')
devices.torch_gc(force=True)
def set_args(self, p: processing.StableDiffusionProcessing, *args):
@@ -95,7 +96,7 @@ class Script(scripts_manager.Script):
freeu_preset = [float(f.strip()) for f in freeu_preset.split(',')]
except Exception:
freeu_preset = []
- shared.log.warning(f'ConsiStory: freeu="{freeu_preset}" invalid')
+ logger.log.warning(f'ConsiStory: freeu="{freeu_preset}" invalid')
if len(freeu) == 4:
shared.sd_model.enable_freeu(s1=freeu[0], s2=freeu[0], b1=freeu[0], b2=freeu[0])
steps = 50 if steps else p.steps
@@ -106,14 +107,14 @@ class Script(scripts_manager.Script):
alpha = (int(alpha[0]), int(alpha[1]), float(alpha[2]))
except Exception:
alpha=(10, 20, 0.8)
- shared.log.warning(f'ConsiStory: alpha="{alpha}" invalid')
+ logger.log.warning(f'ConsiStory: alpha="{alpha}" invalid')
else:
alpha=(10, 20, 0.8)
seed = p.seed
concepts = [c.strip() for c in concepts.split(',') if c.strip() != '']
for c in concepts:
if c not in subject:
- shared.log.warning(f'ConsiStory: concept="{c}" not in subject')
+ logger.log.warning(f'ConsiStory: concept="{c}" not in subject')
subject = f'{subject} {c}'
settings = [p.strip() for p in prompts.split('\n') if p.strip() != '']
anchors = [f'{subject} {p}' for p in settings]
@@ -124,16 +125,16 @@ class Script(scripts_manager.Script):
for i, prompt in enumerate(prompts):
if subject not in prompt:
prompts[i] = f'{subject} {prompt}'
- shared.log.debug(f'ConsiStory args: sampler={shared.sd_model.scheduler.__class__.__name__} steps={steps} sdsa={sdsa} queries={queries} same={same} dropout={dropout} freeu={freeu_preset if freeu else None} alpha={alpha if injection else None}')
+ logger.log.debug(f'ConsiStory args: sampler={shared.sd_model.scheduler.__class__.__name__} steps={steps} sdsa={sdsa} queries={queries} same={same} dropout={dropout} freeu={freeu_preset if freeu else None} alpha={alpha if injection else None}')
return concepts, anchors, prompts, alpha, steps, seed
def create_anchors(self, anchors, concepts, seed, steps, dropout, same, queries, sdsa, injection, alpha):
import scripts.consistory as cs
t0 = time.time()
if len(anchors) == 0:
- shared.log.warning('ConsiStory: no anchors')
+ logger.log.warning('ConsiStory: no anchors')
return []
- shared.log.debug(f'ConsiStory anchors: concepts={concepts} anchors={anchors}')
+ logger.log.debug(f'ConsiStory anchors: concepts={concepts} anchors={anchors}')
with devices.inference_context():
try:
images, self.anchor_cache_first_stage, self.anchor_cache_second_stage = cs.run_anchor_generation(
@@ -150,19 +151,19 @@ class Script(scripts_manager.Script):
perform_injection=injection,
)
except Exception as e:
- shared.log.error(f'ConsiStory: {e}')
+ logger.log.error(f'ConsiStory: {e}')
errors.display(e, 'ConsiStory')
images = []
devices.torch_gc()
t1 = time.time()
- shared.log.debug(f'ConsiStory anchors: images={len(images)} time={t1-t0:.2f}')
+ logger.log.debug(f'ConsiStory anchors: images={len(images)} time={t1-t0:.2f}')
return images
def create_extra(self, prompt, concepts, seed, steps, dropout, same, queries, sdsa, injection, alpha):
import scripts.consistory as cs
t0 = time.time()
images = []
- shared.log.debug(f'ConsiStory extra: concepts={concepts} prompt="{prompt}"')
+ logger.log.debug(f'ConsiStory extra: concepts={concepts} prompt="{prompt}"')
with devices.inference_context():
try:
images = cs.run_extra_generation(
@@ -181,18 +182,18 @@ class Script(scripts_manager.Script):
perform_injection=injection,
)
except Exception as e:
- shared.log.error(f'ConsiStory: {e}')
+ logger.log.error(f'ConsiStory: {e}')
errors.display(e, 'ConsiStory')
images = []
devices.torch_gc()
t1 = time.time()
- shared.log.debug(f'ConsiStory extra: images={len(images)} time={t1-t0:.2f}')
+ logger.log.debug(f'ConsiStory extra: images={len(images)} time={t1-t0:.2f}')
return images
def run(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=arguments-differ
supported_model_list = ['sdxl']
if shared.sd_model_type not in supported_model_list and shared.sd_model.__class__.__name__ != 'ConsistoryExtendAttnSDXLPipeline':
- shared.log.warning(f'ConsiStory: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
+ logger.log.warning(f'ConsiStory: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
subject, concepts, prompts, dropout, sampler, steps, same, queries, sdsa, freeu, _freeu_preset, alpha, injection = args # pylint: disable=unused-variable
diff --git a/scripts/ctrlx_ext.py b/scripts/ctrlx_ext.py
index ed611f4ba..51db2518c 100644
--- a/scripts/ctrlx_ext.py
+++ b/scripts/ctrlx_ext.py
@@ -3,6 +3,7 @@
import gradio as gr
from diffusers import StableDiffusionXLPipeline
from modules import shared, scripts_manager, processing, processing_helpers, sd_models, devices
+from modules import logger
class Script(scripts_manager.Script):
@@ -40,7 +41,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, struct_prompt, struct_strength, struct_guidance, struct_image, appear_prompt, appear_strength, appear_guidance, appear_image): # pylint: disable=arguments-differ
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if shared.sd_model_type != 'sdxl':
- shared.log.warning(f'Ctrl-X: pipeline={c} required=StableDiffusionXLPipeline')
+ logger.log.warning(f'Ctrl-X: pipeline={c} required=StableDiffusionXLPipeline')
return None
import yaml
@@ -55,7 +56,7 @@ class Script(scripts_manager.Script):
# calculate ctrx+x schedule
if p.sampler_name not in ['DDIM', 'Euler', 'Euler a', 'DPM++ 1S', 'DDPM', 'Euler SGM', 'LCM', 'TCD']:
- shared.log.warning(f'Ctrl-X: sampler={p.sampler_name} override="Euler a" supported=[Euler, Euler a, Euler SGM, DDIM, DDPM, , LCM, TCD]')
+ logger.log.warning(f'Ctrl-X: sampler={p.sampler_name} override="Euler a" supported=[Euler, Euler a, Euler SGM, DDIM, DDPM, , LCM, TCD]')
p.sampler_name = 'Euler a'
processing_helpers.update_sampler(p, shared.sd_model)
shared.sd_model.scheduler.set_timesteps(p.steps, device=devices.device)
@@ -85,8 +86,8 @@ class Script(scripts_manager.Script):
p.task_args['self_recurrence_schedule'] = get_self_recurrence_schedule(config['self_recurrence_schedule'], p.steps)
is_struct = p.task_args.get('structure_image') is not None
is_appear = p.task_args.get('appearance_image') is not None
- shared.log.info(f'Ctrl-X: structure={struct_strength if is_struct else None} appearance={appear_strength if is_appear else None}')
- shared.log.debug(f'Ctrl-X: config={control_config} args={p.task_args}')
+ logger.log.info(f'Ctrl-X: structure={struct_strength if is_struct else None} appearance={appear_strength if is_appear else None}')
+ logger.log.debug(f'Ctrl-X: config={control_config} args={p.task_args}')
# process
processed: processing.Processed = processing.process_images(p)
diff --git a/scripts/daam_ext.py b/scripts/daam_ext.py
index 5ae16a855..c3b32e3fb 100644
--- a/scripts/daam_ext.py
+++ b/scripts/daam_ext.py
@@ -3,6 +3,7 @@
import gradio as gr
from installer import install
from modules import shared, scripts_manager, processing
+from modules import logger
COLORMAP = ['autumn', 'bone', 'jet', 'winter', 'rainbow', 'ocean', 'summer', 'spring', 'cool', 'hsv', 'pink', 'hot', 'parula', 'magma', 'inferno', 'plasma', 'viridis', 'cividis', 'twilight', 'shifted', 'turbo', 'deepgreen']
@@ -26,7 +27,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, append_images, colormap): # pylint: disable=arguments-differ
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if shared.sd_model_type != 'sdxl':
- shared.log.warning(f'DAAM: pipeline={c} required=StableDiffusionXLPipeline')
+ logger.log.warning(f'DAAM: pipeline={c} required=StableDiffusionXLPipeline')
return None
install('thinc==8.3.4')
@@ -40,7 +41,7 @@ class Script(scripts_manager.Script):
with daam.trace(shared.sd_model) as tc:
processed: processing.Processed = processing.process_images(p)
global_heat_map = tc.compute_global_heat_map()
- shared.log.info(f'DAAM: prompt="{global_heat_map.prompt}" heatmaps={global_heat_map.heat_maps.shape}')
+ logger.log.info(f'DAAM: prompt="{global_heat_map.prompt}" heatmaps={global_heat_map.heat_maps.shape}')
# word_heat_map = global_heat_map.compute_word_heat_map('woman')
parsed_heat_maps = global_heat_map.parsed_heat_maps()
@@ -48,7 +49,7 @@ class Script(scripts_manager.Script):
image = processed.images[0]
for parsed_heat_map in parsed_heat_maps:
if len(parsed_heat_map.token.text) > 1:
- shared.log.debug(f'DAAM: token="{parsed_heat_map.token.text}"')
+ logger.log.debug(f'DAAM: token="{parsed_heat_map.token.text}"')
overlay = parsed_heat_map.word_heat_map.plot_overlay(image=image, color_normalize=True, cmap=colormap)
processed.images.append(overlay)
diff --git a/scripts/demofusion.py b/scripts/demofusion.py
index f9d8932ab..8251708e5 100644
--- a/scripts/demofusion.py
+++ b/scripts/demofusion.py
@@ -15,6 +15,7 @@ from diffusers.utils import is_accelerate_available, is_accelerate_version
from diffusers.utils.torch_utils import randn_tensor
from diffusers.pipelines.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
from modules import scripts_manager, processing, shared, sd_models, devices
+from modules import logger
### Class definition
@@ -164,7 +165,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
text_input_ids, untruncated_ids
):
removed_text = tokenizer.batch_decode(untruncated_ids[:, tokenizer.model_max_length - 1 : -1])
- shared.log.warning(f"The following part of your input was truncated because CLIP can only handle sequences up to {tokenizer.model_max_length} tokens: {removed_text}")
+ logger.log.warning(f"The following part of your input was truncated because CLIP can only handle sequences up to {tokenizer.model_max_length} tokens: {removed_text}")
prompt_embeds = text_encoder(
text_input_ids.to(device),
@@ -346,11 +347,11 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
# DemoFusion specific checks
if max(height, width) % 1024 != 0:
- shared.log.error('DemoFusion: resolution={width}x{height} long side must be divisible by 1024')
+ logger.log.error('DemoFusion: resolution={width}x{height} long side must be divisible by 1024')
return None
if num_images_per_prompt != 1:
- shared.log.warning('DemoFusion: number of images per prompt is not support and will be ignored')
+ logger.log.warning('DemoFusion: number of images per prompt is not support and will be ignored')
num_images_per_prompt = 1
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents
@@ -830,7 +831,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
self.text_encoder.cpu()
self.text_encoder_2.cpu()
- shared.log.debug('DemoFusion: phase=1 denoising')
+ logger.log.debug('DemoFusion: phase=1 denoising')
with self.progress_bar(total=num_inference_steps) as progress_bar:
for i, t in enumerate(timesteps):
@@ -896,7 +897,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
if needs_upcasting:
self.upcast_vae()
latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)
- shared.log.debug('DemoFusion: phase=1 decoding')
+ logger.log.debug('DemoFusion: phase=1 decoding')
if self.lowvram and multi_decoder:
current_width_height = self.unet.config.sample_size * self.vae_scale_factor
image = self.tiled_decode(latents, current_width_height, current_width_height)
@@ -916,7 +917,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
latents = latents.to(device)
self.unet.to(device)
torch.cuda.empty_cache()
- shared.log.debug(f'DemoFusion: phase={current_scale_num} denoising')
+ logger.log.debug(f'DemoFusion: phase={current_scale_num} denoising')
current_height = self.unet.config.sample_size * self.vae_scale_factor * current_scale_num
current_width = self.unet.config.sample_size * self.vae_scale_factor * current_scale_num
if height > width:
@@ -1136,7 +1137,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
self.upcast_vae()
latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)
- shared.log.debug(f'DemoFusion: phase={current_scale_num} decoding')
+ logger.log.debug(f'DemoFusion: phase={current_scale_num} decoding')
if multi_decoder:
image = self.tiled_decode(latents, current_height, current_width)
else:
@@ -1176,7 +1177,7 @@ class DemoFusionSDXLPipeline(DiffusionPipeline, FromSingleFileMixin, LoraLoaderM
if hasattr(component, "_hf_hook"):
is_model_cpu_offload = isinstance(component._hf_hook, CpuOffload) # pylint: disable=protected-access
is_sequential_cpu_offload = isinstance(component._hf_hook, AlignDevicesHook) # pylint: disable=protected-access
- shared.log.info("Accelerate hooks detected. Since you have called `load_lora_weights()`, the previous hooks will be first removed. Then the LoRA parameters will be loaded and the hooks will be applied again.")
+ logger.log.info("Accelerate hooks detected. Since you have called `load_lora_weights()`, the previous hooks will be first removed. Then the LoRA parameters will be loaded and the hooks will be applied again.")
recursive = is_sequential_cpu_offload
remove_hook_from_module(component, recurse=recursive)
state_dict, network_alphas = self.lora_state_dict(
@@ -1245,7 +1246,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, cosine_scale_1, cosine_scale_2, cosine_scale_3, sigma, view_batch_size, stride, multi_decoder): # pylint: disable=arguments-differ
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if c != 'StableDiffusionXLPipeline':
- shared.log.warning(f'DemoFusion: pipeline={c} required=StableDiffusionXLPipeline')
+ logger.log.warning(f'DemoFusion: pipeline={c} required=StableDiffusionXLPipeline')
return None
p.task_args['cosine_scale_1'] = cosine_scale_1
p.task_args['cosine_scale_2'] = cosine_scale_2
@@ -1256,7 +1257,7 @@ class Script(scripts_manager.Script):
p.task_args['multi_decoder'] = multi_decoder
p.task_args['output_type'] = 'np'
p.task_args['low_vram'] = True
- shared.log.debug(f'DemoFusion: {p.task_args}')
+ logger.log.debug(f'DemoFusion: {p.task_args}')
old_pipe = shared.sd_model
new_pipe = DemoFusionSDXLPipeline(
vae = shared.sd_model.vae,
@@ -1271,7 +1272,7 @@ class Script(scripts_manager.Script):
shared.sd_model = new_pipe
sd_models.move_model(shared.sd_model, devices.device) # move pipeline to device
sd_models.set_diffuser_options(shared.sd_model, vae=None, op='model')
- shared.log.debug(f'DemoFusion create: pipeline={shared.sd_model.__class__.__name__}')
+ logger.log.debug(f'DemoFusion create: pipeline={shared.sd_model.__class__.__name__}')
processed = processing.process_images(p)
shared.sd_model = old_pipe
return processed
diff --git a/scripts/differential_diffusion.py b/scripts/differential_diffusion.py
index d5bebb1ed..dd81aae5b 100644
--- a/scripts/differential_diffusion.py
+++ b/scripts/differential_diffusion.py
@@ -1835,6 +1835,7 @@ import gradio as gr
import diffusers
from PIL import Image, ImageEnhance, ImageOps # pylint: disable=reimported
from modules import errors, shared, devices, scripts_manager, processing, sd_models, images
+from modules import logger
from modules.image import convert
@@ -1900,15 +1901,15 @@ class Script(scripts_manager.Script):
if not enabled:
return
if shared.sd_model_type not in ['sdxl', 'sd', 'f1']:
- shared.log.error(f'Differential-diffusion: incorrect base model: {shared.sd_model.__class__.__name__}')
+ logger.log.error(f'Differential-diffusion: incorrect base model: {shared.sd_model.__class__.__name__}')
return
if not hasattr(p, 'init_images') or len(p.init_images) == 0:
- shared.log.error('Differential-diffusion: no input images')
+ logger.log.error('Differential-diffusion: no input images')
return
image_init, image_map, image_mask = self.depthmap(p.init_images[0], image, model, strength, invert)
if image_map is None:
- shared.log.error('Differential-diffusion: no image map')
+ logger.log.error('Differential-diffusion: no image map')
return
orig_pipeline = shared.sd_model
@@ -1949,13 +1950,13 @@ class Script(scripts_manager.Script):
if shared.sd_model_type == 'sdxl':
p.task_args['original_image'] = image_init
if p.batch_size > 1:
- shared.log.warning(f'Differential-diffusion: batch-size={p.batch_size} parallel processing not supported')
+ logger.log.warning(f'Differential-diffusion: batch-size={p.batch_size} parallel processing not supported')
p.batch_size = 1
- shared.log.debug(f'Differential-diffusion: pipeline={pipe.__class__.__name__} strength={strength} model={model} auto={image is None}')
+ logger.log.debug(f'Differential-diffusion: pipeline={pipe.__class__.__name__} strength={strength} model={model} auto={image is None}')
shared.sd_model = pipe
sd_models.move_model(pipe.vae, devices.device, force=True)
except Exception as e:
- shared.log.error(f'Differential-diffusion: pipeline creation failed: {e}')
+ logger.log.error(f'Differential-diffusion: pipeline creation failed: {e}')
errors.display(e, 'Differential-diffusion: pipeline creation failed')
shared.sd_model = orig_pipeline
diff --git a/scripts/example.py b/scripts/example.py
index a047bc390..13a46e6ef 100644
--- a/scripts/example.py
+++ b/scripts/example.py
@@ -1,6 +1,7 @@
import gradio as gr
from diffusers.pipelines import StableDiffusionPipeline, StableDiffusionXLPipeline # pylint: disable=unused-import
from modules import shared, scripts_manager, processing, sd_models, devices
+from modules import logger
"""
This is a simpler template for script for SD.Next that implements a custom pipeline
@@ -88,7 +89,7 @@ class Script(scripts_manager.Script):
# prepare pipeline
c = shared.sd_model.__class__.__name__ if shared.sd_loaded else ''
if c != pipeline_base:
- shared.log.warning(f'{title}: pipeline={c} required={pipeline_base}')
+ logger.log.warning(f'{title}: pipeline={c} required={pipeline_base}')
return None
orig_pipeline = shared.sd_model # backup current pipeline definition
shared.sd_model = pipeline_class( # create new pipeline using currently loaded model which is always in `shared.sd_model`
@@ -123,7 +124,7 @@ class Script(scripts_manager.Script):
if not latent:
p.task_args['output_type'] = 'np'
- shared.log.debug(f'{c}: args={p.task_args}')
+ logger.log.debug(f'{c}: args={p.task_args}')
# if you need to run any preprocessing, this is the place to do it
diff --git a/scripts/flux_enhance.py b/scripts/flux_enhance.py
index 6e74ec50e..27a20dd4c 100644
--- a/scripts/flux_enhance.py
+++ b/scripts/flux_enhance.py
@@ -6,6 +6,7 @@ import threading
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import gradio as gr
from modules import shared, scripts_manager, devices, processing
+from modules import logger
repo_id = "gokaygokay/Flux-Prompt-Enhance"
@@ -37,7 +38,7 @@ class Script(scripts_manager.Script):
if self.tokenizer is None:
self.tokenizer = AutoTokenizer.from_pretrained('gokaygokay/Flux-Prompt-Enhance', cache_dir=shared.opts.hfcache_dir)
if self.model is None:
- shared.log.info(f'Prompt enhance: model="{repo_id}"')
+ logger.log.info(f'Prompt enhance: model="{repo_id}"')
self.model = AutoModelForSeq2SeqLM.from_pretrained('gokaygokay/Flux-Prompt-Enhance', cache_dir=shared.opts.hfcache_dir).to(device=devices.cpu, dtype=devices.dtype)
def enhance(self, prompt, auto_apply: bool = False, temperature: float = 0.7, repetition_penalty: float = 1.2, max_length: int = 128):
@@ -56,18 +57,18 @@ class Script(scripts_manager.Script):
try:
outputs = self.model.generate(input_ids, **kwargs)
except Exception as e:
- shared.log.error(f'Prompt enhance: error="{e}"')
+ logger.log.error(f'Prompt enhance: error="{e}"')
return [['']]
self.model = self.model.to(devices.cpu)
prompts = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
prompts = [[p] for p in prompts]
t1 = time.time()
- shared.log.info(f'Prompt enhance: temperature={temperature} repetition={repetition_penalty} length={max_length} sequences={num_return_sequences} apply={auto_apply} time={t1-t0:.2f}s')
+ logger.log.info(f'Prompt enhance: temperature={temperature} repetition={repetition_penalty} length={max_length} sequences={num_return_sequences} apply={auto_apply} time={t1-t0:.2f}s')
return prompts
def select(self, cell: gr.SelectData, _table):
prompt = cell.value if hasattr(cell, 'value') else cell
- shared.log.info(f'Prompt enhance: prompt="{prompt}"')
+ logger.log.info(f'Prompt enhance: prompt="{prompt}"')
return prompt
def ui(self, _is_img2img):
@@ -92,10 +93,10 @@ class Script(scripts_manager.Script):
p.negative_prompt = shared.prompt_styles.apply_negative_styles_to_prompt(p.negative_prompt, p.styles)
shared.prompt_styles.apply_styles_to_extra(p)
p.styles = []
- shared.log.debug(f'Prompt enhance: source="{p.prompt}"')
+ logger.log.debug(f'Prompt enhance: source="{p.prompt}"')
prompts = self.enhance(p.prompt, auto_apply, temperature, repetition_penalty, max_length)
p.prompt = random.choice(prompts)[0]
- shared.log.debug(f'Prompt enhance: prompt="{p.prompt}"')
+ logger.log.debug(f'Prompt enhance: prompt="{p.prompt}"')
def after_component(self, component, **kwargs): # searching for actual ui prompt components
if getattr(component, 'elem_id', '') in ['txt2img_prompt', 'img2img_prompt', 'control_prompt', 'video_prompt']:
diff --git a/scripts/flux_tools.py b/scripts/flux_tools.py
index b2e87c36c..1e7d5c9c6 100644
--- a/scripts/flux_tools.py
+++ b/scripts/flux_tools.py
@@ -4,6 +4,7 @@ import time
import gradio as gr
import diffusers
from modules import scripts_manager, processing, shared, devices, sd_models
+from modules import logger
from installer import install
@@ -47,21 +48,21 @@ class Script(scripts_manager.Script):
return None
image = getattr(p, 'init_images', None)
if image is None or len(image) == 0:
- shared.log.error(f'{title}: tool={tool} no init_images')
+ logger.log.error(f'{title}: tool={tool} no init_images')
return None
else:
image = image[0] if isinstance(image, list) else image
- shared.log.info(f'{title}: tool={tool} init')
+ logger.log.info(f'{title}: tool={tool} init')
t0 = time.time()
if tool == 'Redux':
supported_model_list = ['f1']
if shared.sd_model_type not in supported_model_list:
- shared.log.warning(f'{title}: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
+ logger.log.warning(f'{title}: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
# pipe_prior_redux = FluxPriorReduxPipeline.from_pretrained("black-forest-labs/FLUX.1-Redux-dev", revision="refs/pr/8", torch_dtype=torch.bfloat16).to("cuda")
- shared.log.debug(f'{title}: tool={tool} prompt={prompt}')
+ logger.log.debug(f'{title}: tool={tool} prompt={prompt}')
if redux_pipe is None:
redux_pipe = diffusers.FluxPriorReduxPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Redux-dev",
@@ -70,7 +71,7 @@ class Script(scripts_manager.Script):
cache_dir=shared.opts.hfcache_dir
).to(devices.device)
if prompt > 0:
- shared.log.info(f'{title}: tool={tool} load text encoder')
+ logger.log.info(f'{title}: tool={tool} load text encoder')
redux_pipe.tokenizer, redux_pipe.tokenizer_2 = shared.sd_model.tokenizer, shared.sd_model.tokenizer_2
redux_pipe.text_encoder, redux_pipe.text_encoder_2 = shared.sd_model.text_encoder, shared.sd_model.text_encoder_2
sd_models.apply_balanced_offload(redux_pipe)
@@ -88,13 +89,13 @@ class Script(scripts_manager.Script):
p.task_args[k] = v
else:
if redux_pipe is not None:
- shared.log.debug(f'{title}: tool=Redux unload')
+ logger.log.debug(f'{title}: tool=Redux unload')
redux_pipe = None
if tool in ['Fill', 'Fill (Nunchaku)']:
# pipe = FluxFillPipeline.from_pretrained("black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16, revision="refs/pr/4").to("cuda")
if p.image_mask is None:
- shared.log.error(f'{title}: tool={tool} no image_mask')
+ logger.log.error(f'{title}: tool={tool} no image_mask')
return None
nunchaku_suffix = '+nunchaku' if tool == 'Fill (Nunchaku)' else ''
checkpoint = f"black-forest-labs/FLUX.1-Fill-dev{nunchaku_suffix}"
@@ -123,7 +124,7 @@ class Script(scripts_manager.Script):
p.task_args['strength'] = None
else:
if processor_canny is not None:
- shared.log.debug(f'{title}: tool=Canny unload processor')
+ logger.log.debug(f'{title}: tool=Canny unload processor')
processor_canny = None
if tool in ['Depth', 'Depth (Nunchaku)']:
@@ -146,9 +147,9 @@ class Script(scripts_manager.Script):
p.task_args['strength'] = None
else:
if processor_depth is not None:
- shared.log.debug(f'{title}: tool=Depth unload processor')
+ logger.log.debug(f'{title}: tool=Depth unload processor')
processor_depth = None
- shared.log.debug(f'{title}: tool={tool} ready time={time.time() - t0:.2f}')
+ logger.log.debug(f'{title}: tool={tool} ready time={time.time() - t0:.2f}')
devices.torch_gc()
return None
diff --git a/scripts/freescale_ext.py b/scripts/freescale_ext.py
index 4b7d916bb..480594ba3 100644
--- a/scripts/freescale_ext.py
+++ b/scripts/freescale_ext.py
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models
+from modules import logger
registered = False
@@ -50,12 +51,12 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, cosine_scale, override_sampler, cosine_scale_bg, dilate_tau, s1_enable, s1_scale, s1_restart, s2_enable, s2_scale, s2_restart, s3_enable, s3_scale, s3_restart, s4_enable, s4_scale, s4_restart): # pylint: disable=arguments-differ
supported_model_list = ['sdxl']
if shared.sd_model_type not in supported_model_list:
- shared.log.warning(f'FreeScale: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
+ logger.log.warning(f'FreeScale: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
if self.is_img2img:
if p.init_images is None or len(p.init_images) == 0:
- shared.log.warning('FreeScale: missing input image')
+ logger.log.warning('FreeScale: missing input image')
return None
from scripts.freescale import StableDiffusionXLFreeScale, StableDiffusionXLFreeScaleImg2Img # pylint: disable=no-name-in-module
@@ -101,7 +102,7 @@ class Script(scripts_manager.Script):
p.sampler_name = 'Euler a'
if p.width < 1024 or p.height < 1024:
- shared.log.error(f'FreeScale: width={p.width} height={p.height} minimum=1024')
+ logger.log.error(f'FreeScale: width={p.width} height={p.height} minimum=1024')
return None
if not self.is_img2img:
@@ -111,7 +112,7 @@ class Script(scripts_manager.Script):
shared.sd_model.enable_vae_slicing()
shared.sd_model.enable_vae_tiling()
- shared.log.info(f'FreeScale: mode={"txt" if not self.is_img2img else "img"} cosine={cosine_scale} bg={cosine_scale_bg} tau={dilate_tau} scales={scales} resolutions={resolutions_list} steps={restart_steps} sampler={p.sampler_name}')
+ logger.log.info(f'FreeScale: mode={"txt" if not self.is_img2img else "img"} cosine={cosine_scale} bg={cosine_scale_bg} tau={dilate_tau} scales={scales} resolutions={resolutions_list} steps={restart_steps} sampler={p.sampler_name}')
resolutions = ','.join([f'{x[0]}x{x[1]}' for x in resolutions_list])
steps = ','.join([str(x) for x in restart_steps])
p.extra_generation_params["FreeScale"] = f'cosine {cosine_scale} resolutions {resolutions} steps {steps}'
diff --git a/scripts/hdr.py b/scripts/hdr.py
index 70d3a6655..9ecb6021d 100644
--- a/scripts/hdr.py
+++ b/scripts/hdr.py
@@ -4,6 +4,7 @@ import numpy as np
import gradio as gr
from PIL import Image
from modules import images, processing, shared, scripts_manager
+from modules import logger
from modules.processing import get_processed
from modules.shared import opts, state
@@ -34,7 +35,7 @@ class Script(scripts_manager.Script):
return [gr.update(visible=is_tonemap), gr.update(visible=is_tonemap), gr.update(visible=is_tonemap)]
def merge(self, imgs: list, is_tonemap: bool, gamma, scale, saturation):
- shared.log.info(f'HDR: merge images={len(imgs)} tonemap={is_tonemap} sgamma={gamma} scale={scale} saturation={saturation}')
+ logger.log.info(f'HDR: merge images={len(imgs)} tonemap={is_tonemap} sgamma={gamma} scale={scale} saturation={saturation}')
imgs_np = [np.asarray(img).astype(np.uint8) for img in imgs]
align = cv2.createAlignMTB()
@@ -58,12 +59,12 @@ class Script(scripts_manager.Script):
def run(self, p, hdr_range, save_hdr, is_tonemap, gamma, scale, saturation): # pylint: disable=arguments-differ
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl':
- shared.log.error(f'HDR: incorrect base model: {shared.sd_model.__class__.__name__}')
+ logger.log.error(f'HDR: incorrect base model: {shared.sd_model.__class__.__name__}')
return None
p.extra_generation_params = {
"HDR range": hdr_range,
}
- shared.log.info(f'HDR: range={hdr_range}')
+ logger.log.info(f'HDR: range={hdr_range}')
processing.fix_seed(p)
imgs = []
info = ''
@@ -89,7 +90,7 @@ class Script(scripts_manager.Script):
fn = os.path.splitext(saved_fn)[0] + '-hdr.png'
# cv2.imwrite(fn, hdr, [cv2.IMWRITE_PNG_COMPRESSION, 6, cv2.IMWRITE_PNG_STRATEGY, cv2.IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY, cv2.IMWRITE_HDR_COMPRESSION, cv2.IMWRITE_HDR_COMPRESSION_RLE])
cv2.imwrite(fn, hdr)
- shared.log.debug(f'Save: image="{fn}" type=PNG mode=HDR channels=16 size={os.path.getsize(fn)}')
+ logger.log.debug(f'Save: image="{fn}" type=PNG mode=HDR channels=16 size={os.path.getsize(fn)}')
# if opts.grid_save:
# images.save_image(grid, p.outpath_grids, "grid", p.seed, p.prompt, opts.grid_format, info=processed.info, grid=True, p=p)
grid = [images.image_grid(imgs, rows=1)] if opts.return_grid else []
diff --git a/scripts/image2video.py b/scripts/image2video.py
index 6fcd26c04..df861d9b2 100644
--- a/scripts/image2video.py
+++ b/scripts/image2video.py
@@ -2,6 +2,7 @@ import torch
import gradio as gr
import diffusers
from modules import scripts_manager, processing, shared, images, sd_models, devices
+from modules import logger
MODELS = [
@@ -58,16 +59,16 @@ class Script(scripts_manager.Script):
return None
model = [m for m in MODELS if m['name'] == model_name][0]
repo_id = model['url']
- shared.log.debug(f'Image2Video: model={model_name} frames={num_frames}, video={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
+ logger.log.debug(f'Image2Video: model={model_name} frames={num_frames}, video={video_type} duration={duration} loop={gif_loop} pad={mp4_pad} interpolate={mp4_interpolate}')
p.ops.append('video')
p.do_not_save_grid = True
orig_pipeline = shared.sd_model
if model_name == 'PIA':
if shared.sd_model_type != 'sd':
- shared.log.error('Image2Video PIA: base model must be SD15')
+ logger.log.error('Image2Video PIA: base model must be SD15')
return None
- shared.log.info(f'Image2Video PIA load: model={repo_id}')
+ logger.log.info(f'Image2Video PIA load: model={repo_id}')
motion_adapter = diffusers.MotionAdapter.from_pretrained(repo_id)
sd_models.move_model(motion_adapter, devices.device)
shared.sd_model = sd_models.switch_pipe(diffusers.PIAPipeline, shared.sd_model, { 'motion_adapter': motion_adapter })
@@ -84,14 +85,14 @@ class Script(scripts_manager.Script):
spatial_stop_frequency=fi_spatial,
temporal_stop_frequency=fi_temporal,
)
- shared.log.debug(f'Image2Video PIA: args={p.task_args}')
+ logger.log.debug(f'Image2Video PIA: args={p.task_args}')
processed = processing.process_images(p)
shared.sd_model.motion_adapter = None
processed = None
if model_name == 'VGen':
if not isinstance(shared.sd_model, diffusers.I2VGenXLPipeline):
- shared.log.info(f'Image2Video VGen load: model={repo_id}')
+ logger.log.info(f'Image2Video VGen load: model={repo_id}')
pipe = diffusers.I2VGenXLPipeline.from_pretrained(repo_id, torch_dtype=devices.dtype, cache_dir=shared.opts.diffusers_dir)
sd_models.copy_diffuser_options(pipe, shared.sd_model)
sd_models.set_diffuser_options(pipe)
@@ -104,7 +105,7 @@ class Script(scripts_manager.Script):
p.task_args['target_fps'] = max(1, int(num_frames * vg_fps))
p.task_args['decode_chunk_size'] = max(1, int(num_frames * vg_chunks))
p.task_args['output_type'] = 'pil'
- shared.log.debug(f'Image2Video VGen: args={p.task_args}')
+ logger.log.debug(f'Image2Video VGen: args={p.task_args}')
processed = processing.process_images(p)
shared.sd_model = orig_pipeline
diff --git a/scripts/infiniteyou/pipeline_infu_flux.py b/scripts/infiniteyou/pipeline_infu_flux.py
index b8e42c23a..a257f031b 100644
--- a/scripts/infiniteyou/pipeline_infu_flux.py
+++ b/scripts/infiniteyou/pipeline_infu_flux.py
@@ -28,6 +28,7 @@ from insightface.utils import face_align
from PIL import Image
from modules import shared, devices, model_quant
+from modules import logger
from .pipeline_flux_infusenet import FluxInfuseNetPipeline
from .resampler import Resampler
@@ -147,12 +148,12 @@ class InfUFluxPipeline:
self.infu_flux_version = infu_flux_version
self.model_version = model_version
# Load controlnet
- shared.log.debug(f'InfiniteYou: cls={shared.sd_model.__class__.__name__} loading')
+ logger.log.debug(f'InfiniteYou: cls={shared.sd_model.__class__.__name__} loading')
local_path = snapshot_download(repo_id='ByteDance/InfiniteYou', cache_dir=shared.opts.hfcache_dir)
infiniteyou_path = os.path.join(local_path, f'infu_flux_{infu_flux_version}', model_version)
infusenet_path = os.path.join(infiniteyou_path, 'InfuseNetModel')
quant_args = model_quant.create_config(module='Control')
- shared.log.debug(f'InfiniteYou: fn="{infusenet_path}" load infusenet')
+ logger.log.debug(f'InfiniteYou: fn="{infusenet_path}" load infusenet')
infusenet = FluxControlNetModel.from_pretrained(
infusenet_path,
torch_dtype=devices.dtype,
@@ -185,7 +186,7 @@ class InfUFluxPipeline:
ff_mult=4,
)
image_proj_model_path = os.path.join(infiniteyou_path, 'image_proj_model.bin')
- shared.log.debug(f'InfiniteYou: fn="{image_proj_model_path}" load image projection')
+ logger.log.debug(f'InfiniteYou: fn="{image_proj_model_path}" load image projection')
ipm_state_dict = torch.load(image_proj_model_path, map_location="cpu")
self.image_proj_model.load_state_dict(ipm_state_dict['image_proj'])
del ipm_state_dict
@@ -193,7 +194,7 @@ class InfUFluxPipeline:
self.image_proj_model.eval()
# Load face encoder
insightface_root_path = os.path.join(local_path, 'supports', 'insightface')
- shared.log.debug(f'InfiniteYou: fn="{insightface_root_path}" load face encoder')
+ logger.log.debug(f'InfiniteYou: fn="{insightface_root_path}" load face encoder')
self.app_640 = FaceAnalysis(name='antelopev2', root=insightface_root_path, providers=devices.onnx)
self.app_640.prepare(ctx_id=0, det_size=(640, 640))
self.app_320 = FaceAnalysis(name='antelopev2', root=insightface_root_path, providers=devices.onnx)
diff --git a/scripts/infiniteyou_ext.py b/scripts/infiniteyou_ext.py
index 8e3ab5a8a..87491319e 100644
--- a/scripts/infiniteyou_ext.py
+++ b/scripts/infiniteyou_ext.py
@@ -5,6 +5,7 @@
import gradio as gr
from PIL import Image
from modules import scripts_manager, processing, shared, sd_models, devices
+from modules import logger
prefix = 'InfiniteYou'
@@ -73,10 +74,10 @@ class Script(scripts_manager.Script):
if model is None or model not in model_versions:
return None
if id_image is None:
- shared.log.error(f'{prefix}: no init_images')
+ logger.log.error(f'{prefix}: no init_images')
return None
if shared.sd_model_type != 'f1':
- shared.log.error(f'{prefix}: invalid model type: {shared.sd_model_type}')
+ logger.log.error(f'{prefix}: invalid model type: {shared.sd_model_type}')
return None
if scale <= 0:
return None
@@ -87,7 +88,7 @@ class Script(scripts_manager.Script):
verify_insightface()
load_infiniteyou(model)
devices.torch_gc()
- shared.log.info(f'{prefix}: cls={shared.sd_model.__class__.__name__} loaded')
+ logger.log.info(f'{prefix}: cls={shared.sd_model.__class__.__name__} loaded')
processing.fix_seed(p)
p.task_args['id_image'] = id_image
@@ -103,7 +104,7 @@ class Script(scripts_manager.Script):
p.extra_generation_params['IY guidance'] = f'{scale:.1f}/{start:.1f}/{end:.1f}'
orig_prompt_attention = shared.opts.prompt_attention
shared.opts.data['prompt_attention'] = 'fixed'
- shared.log.debug(f'{prefix}: args={p.task_args}')
+ logger.log.debug(f'{prefix}: args={p.task_args}')
processed = processing.process_images(p)
return processed
@@ -116,6 +117,6 @@ class Script(scripts_manager.Script):
shared.opts.data['prompt_attention'] = orig_prompt_attention
orig_prompt_attention = None
if restore and orig_pipeline is not None:
- shared.log.info(f'{prefix}: restoring pipeline')
+ logger.log.info(f'{prefix}: restoring pipeline')
shared.sd_model = orig_pipeline
orig_pipeline = None
diff --git a/scripts/init_latents.py b/scripts/init_latents.py
index 7c11ae794..ff53e7c1a 100644
--- a/scripts/init_latents.py
+++ b/scripts/init_latents.py
@@ -1,3 +1,4 @@
+from modules import logger
from modules import scripts_manager, processing, shared, devices
@@ -44,5 +45,5 @@ class Script(scripts_manager.Script):
subseed_strength=p.subseed_strength,
p=p
)
- shared.log.debug(f'Latent: seed={p.seeds} subseed={p.subseeds} strength={p.subseed_strength} tensor={list(p.init_latent.shape)}')
+ logger.log.debug(f'Latent: seed={p.seeds} subseed={p.subseeds} strength={p.subseed_strength} tensor={list(p.init_latent.shape)}')
p.init_latent = p.init_latent.to(device=shared.sd_model._execution_device, dtype=shared.sd_model.unet.dtype) # pylint: disable=protected-access
diff --git a/scripts/instantir_ext.py b/scripts/instantir_ext.py
index 0cb2cc5a0..97be71190 100644
--- a/scripts/instantir_ext.py
+++ b/scripts/instantir_ext.py
@@ -3,6 +3,7 @@ import torch
import diffusers
from huggingface_hub import hf_hub_download
from modules import scripts_manager, processing, shared, sd_models, devices, ipadapter
+from modules import logger
class Script(scripts_manager.Script):
@@ -36,10 +37,10 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=arguments-differ
supported_model_list = ['sdxl']
if not hasattr(p, 'init_images') or len(p.init_images) == 0:
- shared.log.warning('InstantIR: no image')
+ logger.log.warning('InstantIR: no image')
return None
if shared.sd_model_type not in supported_model_list and shared.sd_model.__class__.__name__ != "InstantIRPipeline":
- shared.log.warning(f'InstantIR: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
+ logger.log.warning(f'InstantIR: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
start, end, hq, multistep, adastep, image, _unload = args
from scripts import instantir
@@ -50,7 +51,7 @@ class Script(scripts_manager.Script):
adapter_file = hf_hub_download('InstantX/InstantIR', subfolder='models', filename='adapter.pt', cache_dir=shared.opts.hfcache_dir)
aggregator_file = hf_hub_download('InstantX/InstantIR', subfolder='models', filename='aggregator.pt', cache_dir=shared.opts.hfcache_dir)
previewer_file = hf_hub_download('InstantX/InstantIR', subfolder='models', filename='previewer_lora_weights.bin', cache_dir=shared.opts.hfcache_dir)
- shared.log.debug(f'InstantIR: adapter="{adapter_file}" aggregator="{aggregator_file}" previewer="{previewer_file}"')
+ logger.log.debug(f'InstantIR: adapter="{adapter_file}" aggregator="{aggregator_file}" previewer="{previewer_file}"')
shared.sd_model = sd_models.switch_pipe(instantir.InstantIRPipeline, shared.sd_model)
instantir.load_adapter_to_pipe(
pipe=shared.sd_model,
@@ -68,7 +69,7 @@ class Script(scripts_manager.Script):
sd_models.clear_caches()
sd_models.apply_balanced_offload(shared.sd_model)
- shared.log.info(f'InstantIR: class={shared.sd_model.__class__.__name__} start={start} end={end} multistep={multistep} adastep={adastep} hq={hq} cache={shared.opts.hfcache_dir}')
+ logger.log.info(f'InstantIR: class={shared.sd_model.__class__.__name__} start={start} end={end} multistep={multistep} adastep={adastep} hq={hq} cache={shared.opts.hfcache_dir}')
p.sampler_name = 'Default' # ir has its own sampler
p.init() # run init early to take care of resizing
p.task_args['previewer_scheduler'] = instantir.LCMSingleStepScheduler.from_config(shared.sd_model.scheduler.config)
@@ -89,7 +90,7 @@ class Script(scripts_manager.Script):
def after(self, p: processing.StableDiffusionProcessing, processed: processing.Processed, *args): # pylint: disable=arguments-differ, unused-argument
_start, _end, _hq, _multistep, _adastep, _image, unload = args
if unload:
- shared.log.info('InstantIR: unloading adapter')
+ logger.log.info('InstantIR: unloading adapter')
if self.orig_ip_unapply is not None:
ipadapter.unapply = self.orig_ip_unapply
self.orig_ip_unapply = None
@@ -101,6 +102,6 @@ class Script(scripts_manager.Script):
self.orig_pipe = None
shared.sd_model.unet.register_to_config(encoder_hid_dim_type=None)
sd_models.apply_balanced_offload(shared.sd_model)
- shared.log.debug(f'InstantIR restore: class={shared.sd_model.__class__.__name__}')
+ logger.log.debug(f'InstantIR restore: class={shared.sd_model.__class__.__name__}')
devices.torch_gc()
return processed
diff --git a/scripts/ipadapter.py b/scripts/ipadapter.py
index 7f1e04a48..9fb1e7f17 100644
--- a/scripts/ipadapter.py
+++ b/scripts/ipadapter.py
@@ -2,6 +2,7 @@ import json
from PIL import Image
import gradio as gr
from modules import scripts_manager, processing, shared, ipadapter, ui_common
+from modules import logger
MAX_ADAPTERS = 4
@@ -33,7 +34,7 @@ class Script(scripts_manager.Script):
raise ValueError(f'IP adapter unknown input: {file}')
init_images.append(image)
except Exception as e:
- shared.log.warning(f'IP adapter failed to load image: {e}')
+ logger.log.warning(f'IP adapter failed to load image: {e}')
return gr.update(value=init_images, visible=len(init_images) > 0)
def display_units(self, num_units):
@@ -116,5 +117,5 @@ class Script(scripts_manager.Script):
layers = json.loads(layers)
p.ip_adapter_layers = layers
except Exception as e:
- shared.log.error(f'IP adapter: failed to parse layer scales: {e}')
+ logger.log.error(f'IP adapter: failed to parse layer scales: {e}')
# ipadapter.apply(shared.sd_model, p, p.ip_adapter_names, p.ip_adapter_scales, p.ip_adapter_starts, p.ip_adapter_ends, p.ip_adapter_images) # called directly from processing.process_images_inner
diff --git a/scripts/ipinstruct.py b/scripts/ipinstruct.py
index 244030ff3..ab711a126 100644
--- a/scripts/ipinstruct.py
+++ b/scripts/ipinstruct.py
@@ -8,6 +8,7 @@ import os
import importlib
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models, devices
+from modules import logger
repo = 'https://github.com/vladmandic/IP-Instruct'
@@ -57,11 +58,11 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, query, image, strength, tokens, instruct_guidance, image_guidance): # pylint: disable=arguments-differ
supported_model_list = ['sd', 'sdxl', 'sd3']
if shared.sd_model_type not in supported_model_list:
- shared.log.warning(f'IP-Instruct: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
+ logger.log.warning(f'IP-Instruct: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
return None
self.install()
if self.lib is None:
- shared.log.error('IP-Instruct: failed to import library')
+ logger.log.error('IP-Instruct: failed to import library')
return None
self.orig_pipe = shared.sd_model
if shared.sd_model_type == 'sdxl':
@@ -83,8 +84,8 @@ class Script(scripts_manager.Script):
ip_ckpt = hf.hf_hub_download(repo_id=repo_id, filename=ckpt, cache_dir=shared.opts.hfcache_dir)
ip_model = cls(shared.sd_model, encoder, ip_ckpt, device=devices.device, dtypein=devices.dtype, num_tokens=tokens)
processing.fix_seed(p)
- shared.log.debug(f'IP-Instruct: class={shared.sd_model.__class__.__name__} wrapper={ip_model.__class__.__name__} encoder={encoder} adapter={ckpt}')
- shared.log.info(f'IP-Instruct: image={image} query="{query}" strength={strength} tokens={tokens} instruct_guidance={instruct_guidance} image_guidance={image_guidance}')
+ logger.log.debug(f'IP-Instruct: class={shared.sd_model.__class__.__name__} wrapper={ip_model.__class__.__name__} encoder={encoder} adapter={ckpt}')
+ logger.log.info(f'IP-Instruct: image={image} query="{query}" strength={strength} tokens={tokens} instruct_guidance={instruct_guidance} image_guidance={image_guidance}')
image_list = ip_model.generate(
query = query,
diff --git a/scripts/kohya_hires_fix.py b/scripts/kohya_hires_fix.py
index 901357569..6cac02ac3 100644
--- a/scripts/kohya_hires_fix.py
+++ b/scripts/kohya_hires_fix.py
@@ -1,6 +1,7 @@
import gradio as gr
import diffusers
from modules import scripts_manager, processing, shared, sd_models, devices
+from modules import logger
class Script(scripts_manager.Script):
@@ -26,7 +27,7 @@ class Script(scripts_manager.Script):
if not enabled:
return None
if shared.sd_model_type != 'sd':
- shared.log.warning(f'Kohya Hires Fix: pipeline={shared.sd_model_type} required=sd')
+ logger.log.warning(f'Kohya Hires Fix: pipeline={shared.sd_model_type} required=sd')
return None
old_pipe = shared.sd_model
high_res_fix = [{'timestep': timestep, 'scale_factor': scale_factor, 'block_num': block_num}]
@@ -34,7 +35,7 @@ class Script(scripts_manager.Script):
sd_models.copy_diffuser_options(shared.sd_model, old_pipe)
sd_models.move_model(shared.sd_model, devices.device) # move pipeline to device
sd_models.set_diffuser_options(shared.sd_model, vae=None, op='model')
- shared.log.debug(f'Kohya Hires Fix: pipeline={shared.sd_model.__class__.__name__} args={high_res_fix}')
+ logger.log.debug(f'Kohya Hires Fix: pipeline={shared.sd_model.__class__.__name__} args={high_res_fix}')
processed = processing.process_images(p)
shared.sd_model = old_pipe
return processed
diff --git a/scripts/layerdiffuse/__init__.py b/scripts/layerdiffuse/__init__.py
index 034fe3b05..58c4adc8f 100644
--- a/scripts/layerdiffuse/__init__.py
+++ b/scripts/layerdiffuse/__init__.py
@@ -3,6 +3,7 @@
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from modules import shared, errors, devices
+from modules import logger
from .layerdiffuse_model import TransparentVAEDecoder
from .layerdiffuse_loader import load_lora_to_unet, merge_delta_weights_into_unet
@@ -43,16 +44,16 @@ def apply_layerdiffuse_sdxl_conv(pipeline):
def apply_layerdiffuse():
try:
if shared.sd_model_type == 'sd':
- shared.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__}')
+ logger.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__}')
apply_layerdiffuse_sd15(shared.sd_model)
elif shared.sd_model_type == 'sdxl':
- # shared.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} type=attn')
+ # logger.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} type=attn')
# apply_layerdiffuse_sdxl_attn(shared.sd_model)
- shared.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} type=conv')
+ logger.log.info(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} type=conv')
apply_layerdiffuse_sdxl_conv(shared.sd_model)
else:
- shared.log.warning(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} not supported')
+ logger.log.warning(f'LayerDiffuse: class={shared.sd_model.__class__.__name__} not supported')
shared.sd_model.layerdiffusion = True
except Exception as e:
- shared.log.error(f'LayerDiffuse: {e}')
+ logger.log.error(f'LayerDiffuse: {e}')
errors.display(e, 'LayerDiffuse')
diff --git a/scripts/layerdiffuse_ext.py b/scripts/layerdiffuse_ext.py
index 7bfb87d71..1b8d645bc 100644
--- a/scripts/layerdiffuse_ext.py
+++ b/scripts/layerdiffuse_ext.py
@@ -1,5 +1,6 @@
import gradio as gr
from modules import shared, scripts_manager, sd_models
+from modules import logger
class Script(scripts_manager.Script):
@@ -13,13 +14,13 @@ class Script(scripts_manager.Script):
def apply(self):
from scripts import layerdiffuse # pylint: disable=no-name-in-module
if not shared.sd_loaded:
- shared.log.error('LayerDiffuse: model not loaded')
+ logger.log.error('LayerDiffuse: model not loaded')
return self.is_active()
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl':
- shared.log.error(f'LayerDiffuse: incorrect base model: class={shared.sd_model.__class__.__name__} type={shared.sd_model_type}')
+ logger.log.error(f'LayerDiffuse: incorrect base model: class={shared.sd_model.__class__.__name__} type={shared.sd_model_type}')
return self.is_active()
if hasattr(shared.sd_model, 'layerdiffusion'):
- shared.log.warning('LayerDiffuse: already applied')
+ logger.log.warning('LayerDiffuse: already applied')
return self.is_active()
layerdiffuse.apply_layerdiffuse()
return self.is_active()
diff --git a/scripts/lbm_ext.py b/scripts/lbm_ext.py
index 9a5b09d04..f27ae8ec4 100644
--- a/scripts/lbm_ext.py
+++ b/scripts/lbm_ext.py
@@ -2,6 +2,7 @@ from copy import deepcopy
from PIL import Image
import gradio as gr
from modules import scripts_manager, processing, shared, devices
+from modules import logger
birefnet = None
@@ -76,7 +77,7 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, lbm_method, lbm_composite, lbm_steps, bg_image): # pylint: disable=arguments-differ, unused-argument
fg_image = getattr(p, 'init_images', None)
if fg_image is None or len(fg_image) == 0 or bg_image is None:
- shared.log.error('LBM: no init images')
+ logger.log.error('LBM: no init images')
return None
else:
fg_image = fg_image[0]
@@ -92,7 +93,7 @@ class Script(scripts_manager.Script):
closest_ar_bg = min(ASPECT_RATIOS, key=lambda x: abs(float(x) - ar_bg))
dimensions_bg = ASPECT_RATIOS[closest_ar_bg]
- shared.log.info(f'LBM: method={lbm_method} steps={lbm_steps} size={dimensions_bg[0]}x{dimensions_bg[1]}')
+ logger.log.info(f'LBM: method={lbm_method} steps={lbm_steps} size={dimensions_bg[0]}x{dimensions_bg[1]}')
self.load(lbm_method)
if birefnet:
diff --git a/scripts/ledits.py b/scripts/ledits.py
index 2d7e3d504..fba677fd8 100644
--- a/scripts/ledits.py
+++ b/scripts/ledits.py
@@ -1,6 +1,7 @@
import diffusers
import gradio as gr
from modules import scripts_manager, processing, shared, devices, sd_models
+from modules import logger
class Script(scripts_manager.Script):
@@ -31,13 +32,13 @@ class Script(scripts_manager.Script):
def run(self, p: processing.StableDiffusionProcessing, edit_start, edit_stop, intersect_mask, prompt1, scale1, threshold1, prompt2, scale2, threshold2): # pylint: disable=arguments-differ, unused-argument
image = getattr(p, 'init_images', None)
if len(prompt1) == 0 and len(prompt2) == 0:
- shared.log.error('LEdits: no prompts')
+ logger.log.error('LEdits: no prompts')
return None
if image is None or len(image) == 0:
- shared.log.error('LEdits: no init_images')
+ logger.log.error('LEdits: no init_images')
return None
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl':
- shared.log.error(f'LEdits: invalid model type: {shared.sd_model_type}')
+ logger.log.error(f'LEdits: invalid model type: {shared.sd_model_type}')
return None
orig_pipeline = shared.sd_model
@@ -67,7 +68,7 @@ class Script(scripts_manager.Script):
'skip': 1.0 - p.denoising_strength, # invert start
'generator': None, # not supported
}
- shared.log.info(f'LEdits invert: {invert_args}')
+ logger.log.info(f'LEdits invert: {invert_args}')
_output = shared.sd_model.invert(**invert_args)
p.task_args = {
'editing_prompt': [],
@@ -91,7 +92,7 @@ class Script(scripts_manager.Script):
p.task_args['edit_guidance_scale'].append(10.0 * scale2)
p.task_args['edit_threshold'].append(threshold2)
- shared.log.info(f'LEdits: {p.task_args}')
+ logger.log.info(f'LEdits: {p.task_args}')
processed = processing.process_images(p)
# restore pipeline
diff --git a/scripts/lut.py b/scripts/lut.py
index d30305d26..e2acb5a4d 100644
--- a/scripts/lut.py
+++ b/scripts/lut.py
@@ -6,6 +6,7 @@ import os
import gradio as gr
from installer import install
from modules import scripts_manager, shared, processing
+from modules import logger
class Script(scripts_manager.Script):
@@ -44,14 +45,14 @@ class Script(scripts_manager.Script):
cube = None
name = os.path.splitext(os.path.basename(cube_file.name))[0] if cube_file is not None else None
- shared.log.info(f'Color grading: cube="{name}" scale={cube_scale} brightness={brightness} exposure={exposure} contrast={contrast} warmth={warmth} saturation={saturation} vibrance={vibrance} hue={hue} gamma={gamma}')
+ logger.log.info(f'Color grading: cube="{name}" scale={cube_scale} brightness={brightness} exposure={exposure} contrast={contrast} warmth={warmth} saturation={saturation} vibrance={vibrance} hue={hue} gamma={gamma}')
if cube_file is not None:
try:
cube = pillow_lut.load_cube_file(cube_file.name)
cube = pillow_lut.amplify_lut(cube, cube_scale)
cube = pillow_lut.rgb_color_enhance(source=cube, brightness=brightness, exposure=exposure, contrast=contrast, warmth=warmth, saturation=saturation, vibrance=vibrance, hue=hue, gamma=gamma)
except Exception as e:
- shared.log.error(f'Color grading: {e}')
+ logger.log.error(f'Color grading: {e}')
images = []
if processed is not None and len(processed.images) > 0:
diff --git a/scripts/mixture_of_diffusers.py b/scripts/mixture_of_diffusers.py
index d10d4ebab..fae9dd3b7 100644
--- a/scripts/mixture_of_diffusers.py
+++ b/scripts/mixture_of_diffusers.py
@@ -1,5 +1,6 @@
import gradio as gr
from modules import scripts_manager, processing, shared, sd_models
+from modules import logger
supported_models = ['sdxl']
@@ -73,12 +74,12 @@ class Script(scripts_manager.Script):
from ligo.segments import segment # pylint: disable=unused-import
return True
except Exception as e:
- shared.log.error(f'MoD: {e}')
+ logger.log.error(f'MoD: {e}')
return False
def run(self, p: processing.StableDiffusionProcessing, *args): # pylint: disable=arguments-differ, unused-argument
if shared.sd_model_type not in supported_models:
- shared.log.warning(f'MoD: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_models}')
+ logger.log.warning(f'MoD: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_models}')
return None
if not self.check_dependencies():
return None
@@ -108,7 +109,7 @@ class Script(scripts_manager.Script):
p.extra_generation_params["MoD Y"] = f'{y_tiles}/{p.task_args["tile_height"]}/{p.task_args["tile_row_overlap"]}'
p.keep_prompts = True
shared.opts.prompt_attention = 'fixed'
- shared.log.info(f'MoD: xtiles={x_tiles} ytiles={y_tiles} xoverlap={p.task_args["tile_col_overlap"]} yoverlap={p.task_args["tile_row_overlap"]} xsize={p.task_args["tile_width"]} ysize={p.task_args["tile_height"]}')
+ logger.log.info(f'MoD: xtiles={x_tiles} ytiles={y_tiles} xoverlap={p.task_args["tile_col_overlap"]} yoverlap={p.task_args["tile_row_overlap"]} xsize={p.task_args["tile_width"]} ysize={p.task_args["tile_height"]}')
shared.sd_model = sd_models.switch_pipe(StableDiffusionXLTilingPipeline, shared.sd_model)
sd_models.set_diffuser_options(shared.sd_model)
diff --git a/scripts/mixture_tiling.py b/scripts/mixture_tiling.py
index 214d869b7..746c89950 100644
--- a/scripts/mixture_tiling.py
+++ b/scripts/mixture_tiling.py
@@ -1,6 +1,7 @@
import gradio as gr
import torch
from modules import shared, devices, scripts_manager, processing, sd_models
+from modules import logger
checked_ok = False
@@ -20,7 +21,7 @@ def check_dependencies():
checked_ok = True
return True
except Exception as e:
- shared.log.error(f'Mixture tiling: {e}')
+ logger.log.error(f'Mixture tiling: {e}')
return False
@@ -50,7 +51,7 @@ class Script(scripts_manager.Script):
return None
prompts = p.prompt.splitlines()
if len(prompts) != x_size * y_size:
- shared.log.error(f'Mixture tiling prompt count mismatch: prompts={len(prompts)} required={x_size * y_size}')
+ logger.log.error(f'Mixture tiling prompt count mismatch: prompts={len(prompts)} required={x_size * y_size}')
return None
# backup pipeline and params
orig_pipeline = shared.sd_model
@@ -58,11 +59,11 @@ class Script(scripts_manager.Script):
orig_prompt_attention = shared.opts.prompt_attention
# create pipeline
if shared.sd_model_type != 'sd':
- shared.log.error(f'Mixture tiling: incorrect base model: {shared.sd_model.__class__.__name__}')
+ logger.log.error(f'Mixture tiling: incorrect base model: {shared.sd_model.__class__.__name__}')
return None
shared.sd_model = sd_models.switch_pipe('mixture_tiling', shared.sd_model)
if shared.sd_model.__class__.__name__ != 'StableDiffusionTilingPipeline': # switch failed
- shared.log.error(f'Mixture tiling: not a tiling pipeline: {shared.sd_model.__class__.__name__}')
+ logger.log.error(f'Mixture tiling: not a tiling pipeline: {shared.sd_model.__class__.__name__}')
shared.sd_model = orig_pipeline
return None
sd_models.set_diffuser_options(shared.sd_model)
@@ -84,7 +85,7 @@ class Script(scripts_manager.Script):
p.task_args['tile_row_overlap'] = int(p.width * y_overlap)
p.task_args['output_type'] = 'np'
# run pipeline
- shared.log.debug(f'Tiling: args={p.task_args}')
+ logger.log.debug(f'Tiling: args={p.task_args}')
processed: processing.Processed = processing.process_images(p) # runs processing using main loop
# restore pipeline and params
shared.opts.data['prompt_attention'] = orig_prompt_attention
diff --git a/scripts/mulan.py b/scripts/mulan.py
index b32f6098c..f23e9f370 100644
--- a/scripts/mulan.py
+++ b/scripts/mulan.py
@@ -25,6 +25,7 @@ Examples:
import gradio as gr
from modules import shared, scripts_manager, processing, devices
+from modules import logger
ENCODERS =[
@@ -64,7 +65,7 @@ class Script(scripts_manager.Script):
return None
# create pipeline
if shared.sd_model_type != 'sd' and shared.sd_model_type != 'sdxl':
- shared.log.error(f'MuLan: incorrect base model: {shared.sd_model.__class__.__name__}')
+ logger.log.error(f'MuLan: incorrect base model: {shared.sd_model.__class__.__name__}')
return None
adapter_path = None
@@ -100,21 +101,21 @@ class Script(scripts_manager.Script):
adapter = None
if text_encoder is None or tokenizer is None or text_encoder_path != selected_encoder:
text_encoder_path = selected_encoder
- shared.log.debug(f'MuLan loading: encoder="{text_encoder_path}"')
+ logger.log.debug(f'MuLan loading: encoder="{text_encoder_path}"')
text_encoder = None
tokenizer = None
devices.torch_gc(force=True)
text_encoder, tokenizer = mulankit.api.load_internvl(text_encoder_path, text_encoder, tokenizer, torch_dtype=shared.sd_model.text_encoder.dtype)
devices.torch_gc(force=True)
if adapter is None:
- shared.log.debug(f'MuLan loading: adapter="{adapter_path}"')
+ logger.log.debug(f'MuLan loading: adapter="{adapter_path}"')
adapter = None
devices.torch_gc(force=True)
adapter = mulankit.api.load_adapter(adapter_path, type=pipe_type)
devices.torch_gc(force=True)
if not getattr(shared.sd_model, 'mulan', False):
- shared.log.info(f'MuLan apply: adapter="{adapter_path}" encoder="{text_encoder_path}"')
+ logger.log.info(f'MuLan apply: adapter="{adapter_path}" encoder="{text_encoder_path}"')
# mulankit.setup(force_sdxl_zero_empty_prompt=False, force_sdxl_zero_pool_prompt=False)
shared.sd_model = mulankit.transform(shared.sd_model,
adapter=adapter,
diff --git a/scripts/nudenet/imageguard.py b/scripts/nudenet/imageguard.py
index edb2b7e8a..baf224841 100644
--- a/scripts/nudenet/imageguard.py
+++ b/scripts/nudenet/imageguard.py
@@ -1,3 +1,4 @@
+from modules import logger
repo_id = 'AIML-TUDA/LlavaGuard-v1.2-0.5B-OV-hf'
policy_template = """Provide a safety assessment for the content provided by the user. Determine compliance or violation against our safety policy by reviewing the following policy categories:
Hate:
@@ -109,7 +110,7 @@ def image_guard(image, policy:str=None) -> str:
cache_dir=shared.opts.hfcache_dir,
)
processor = transformers.AutoProcessor.from_pretrained(repo_id, cache_dir=shared.opts.hfcache_dir)
- shared.log.info(f'NudeNet load: model="{repo_id}"')
+ logger.log.info(f'NudeNet load: model="{repo_id}"')
if policy is None or len(policy) < 10:
policy = policy_template
chat_template = [
@@ -139,9 +140,9 @@ def image_guard(image, policy:str=None) -> str:
result = processor.decode(results[0], skip_special_tokens=True)
result = result.split('assistant', 1)[-1].strip()
data = json.loads(result)
- shared.log.debug(f'NudeNet LlavaGuard: {data}')
+ logger.log.debug(f'NudeNet LlavaGuard: {data}')
return data
except Exception as e:
- shared.log.error(f'NudeNet LlavaGuard: {e}')
+ logger.log.error(f'NudeNet LlavaGuard: {e}')
errors.display(e, 'LlavaGuard')
return {'error': str(e)}
diff --git a/scripts/nudenet/langdetect.py b/scripts/nudenet/langdetect.py
index 18b05dbd5..0a2bd951b 100644
--- a/scripts/nudenet/langdetect.py
+++ b/scripts/nudenet/langdetect.py
@@ -1,3 +1,4 @@
+from modules import logger
repo_id = "facebook/fasttext-language-identification"
model = None
@@ -12,13 +13,13 @@ def lang_detect(text:str, top:int=1, threshold:float=0.25) -> str:
import fasttext
from huggingface_hub import hf_hub_download
model_path = hf_hub_download(repo_id, filename="model.bin", cache_dir=shared.opts.hfcache_dir)
- shared.log.info(f'NudeNet load: model="{repo_id}"')
+ logger.log.info(f'NudeNet load: model="{repo_id}"')
model = fasttext.load_model(model_path)
text = text.replace('\n', '. ')
lang, score = model.predict(text, k=top, threshold=threshold, on_unicode_error="ignore")
result = [f'{l.replace("__label__", "").lower()}:{s:.2f}' for l, s in zip(lang, score) if s > threshold][:top]
- shared.log.debug(f'NudeNet LangDetect: {result}')
+ logger.log.debug(f'NudeNet LangDetect: {result}')
return result
except Exception as e:
- shared.log.error(f'NudeNet LangDetect: {e}')
+ logger.log.error(f'NudeNet LangDetect: {e}')
return str(e)
diff --git a/scripts/pixelsmith_ext.py b/scripts/pixelsmith_ext.py
index 55d0b8d80..163906a5a 100644
--- a/scripts/pixelsmith_ext.py
+++ b/scripts/pixelsmith_ext.py
@@ -1,6 +1,7 @@
import gradio as gr
from PIL import Image
from modules import scripts_manager, processing, shared, sd_models, devices, images
+from modules import logger
class Script(scripts_manager.Script):
@@ -37,14 +38,14 @@ class Script(scripts_manager.Script):
with devices.inference_context():
latent = shared.sd_model.vae.tiled_encode(tensor)
latent = shared.sd_model.vae.config.scaling_factor * latent.latent_dist.sample()
- shared.log.info(f'PixelSmith encode: image={image} latent={latent.shape} width={p.width} height={p.height} vae={shared.sd_model.vae.__class__.__name__}')
+ logger.log.info(f'PixelSmith encode: image={image} latent={latent.shape} width={p.width} height={p.height} vae={shared.sd_model.vae.__class__.__name__}')
return latent
def run(self, p: processing.StableDiffusionProcessing, slider: int = 20): # pylint: disable=arguments-differ
supported_model_list = ['sdxl']
if shared.sd_model_type not in supported_model_list:
- shared.log.warning(f'PixelSmith: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
+ logger.log.warning(f'PixelSmith: class={shared.sd_model.__class__.__name__} model={shared.sd_model_type} required={supported_model_list}')
from scripts.pixelsmith import PixelSmithXLPipeline, PixelSmithVAE # pylint: disable=no-name-in-module
self.orig_pipe = shared.sd_model
self.orig_vae = shared.sd_model.vae
@@ -60,7 +61,7 @@ class Script(scripts_manager.Script):
if hasattr(p, 'init_images') and p.init_images is not None and len(p.init_images) > 0:
p.task_args['image'] = self.encode(p, p.init_images[0])
p.init_images = None
- shared.log.info(f'PixelSmith apply: slider={slider} class={shared.sd_model.__class__.__name__} vae={shared.sd_model.vae.__class__.__name__}')
+ logger.log.info(f'PixelSmith apply: slider={slider} class={shared.sd_model.__class__.__name__} vae={shared.sd_model.vae.__class__.__name__}')
# processed = processing.process_images(p)
def after(self, p: processing.StableDiffusionProcessing, processed: processing.Processed, slider): # pylint: disable=unused-argument
diff --git a/scripts/postprocessing_upscale.py b/scripts/postprocessing_upscale.py
index 3633c08a5..aecc67de2 100644
--- a/scripts/postprocessing_upscale.py
+++ b/scripts/postprocessing_upscale.py
@@ -3,6 +3,7 @@ import gradio as gr
from modules import scripts_postprocessing, shared
from modules.ui_components import ToolButton
import modules.ui_symbols as symbols
+from modules import logger
class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
@@ -69,7 +70,7 @@ class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
upscaler1 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_1_name]), None)
if not upscaler1:
if upscaler_1_name is not None:
- shared.log.warning(f"Could not find upscaler: {upscaler_1_name or '