Upload Stable-diffusion using SD-Hub extension

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Stable-diffusion/ui/BackToNature.mp3 filter=lfs diff=lfs merge=lfs -text

Stable-diffusion/ui/.gitattributes

@@ -0,0 +1,62 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+BLIP/BLIP.gif filter=lfs diff=lfs merge=lfs -text
+generative-models/assets/001_with_eval.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-inpainting/merged-leopards.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/depth2img/d2i.gif filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/depth2img/depth2img01.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/depth2img/depth2img02.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/depth2img/merged-0000.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/depth2img/merged-0004.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/depth2img/merged-0005.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/img2img/upscaling-in.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/img2img/upscaling-out.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/stable-unclip/unclip-variations.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/stable-unclip/unclip-variations_noise.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/768/merged-0001.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/768/merged-0002.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/768/merged-0003.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/768/merged-0004.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/768/merged-0005.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/768/merged-0006.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/merged-0001.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/merged-0003.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/merged-0005.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/merged-0006.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/txt2img/merged-0007.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/upscaling/merged-dog.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/upscaling/sampled-bear-x4.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-stability-ai/assets/stable-samples/upscaling/snow-leopard-x4.png filter=lfs diff=lfs merge=lfs -text
+BackToNature.mp3 filter=lfs diff=lfs merge=lfs -text

Stable-diffusion/ui/4x-AnimeSharp.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7a7de2dafd7331c1992862bbbcd9e9712a9f9f8e6303f0aaa59b4341d359bab
+size 67010245

Stable-diffusion/ui/4x-UltraSharp.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5812231fc936b42af08a5edba784195495d303d5b3248c24489ef0c4021fe01
+size 66961958

Stable-diffusion/ui/4x_NMKD-Superscale-SP_178000_G.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d1b0078fe71446e0469d8d4df59e96baa80d83cda600d68237d655830821bcc
+size 66958607

Stable-diffusion/ui/4x_RealisticRescaler_100000_G.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7381a1229143c9301a94421b610d95eb312e2555743cc9e80099a0e15ac5bd3b
+size 134051293

Stable-diffusion/ui/4x_foolhardy_Remacri.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1a73bd89c2da1ae494774746398689048b5a892bd9653e146713f9df8bca86a
+size 67025055

Stable-diffusion/ui/8x_RealESRGAN.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b72fb469d12f05a4770813d2603eb1b550f40df6fb8b37d6c7bc2db3d2bff5e
+size 67189359

Stable-diffusion/ui/ADetailer.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54efbdaea342f5fef3aad4f5a9c967b0ddd4db1087991529e355f3cb5ffb0b15
+size 148437591

Stable-diffusion/ui/BackToNature.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca2d3fc1121250e3c98019ea7a3f96168c9d547884e2fa316f305dfba8c26a42
+size 4902735

Stable-diffusion/ui/README.md

@@ -0,0 +1,3 @@
+---
+license: creativeml-openrail-m
+---

Stable-diffusion/ui/asd.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e22e725217abb4b6d8079b6be20c401393ab0945cc60c274a73e7c30b2139cf4
+size 35111

Stable-diffusion/ui/ass.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f91ef37e889b2a5ee158c155afe6636bfce6fa5c2ccce2a06e872b0945680d6d
+size 32885

Stable-diffusion/ui/cloudflared.py

@@ -0,0 +1,10 @@
+import subprocess, sys, re, cloudpickle, shlex
+from pathlib import Path
+
+port = 7860
+tunnel_class = cloudpickle.load(open("/kaggle/working/new_tunnel", "rb"), encoding="utf-8")
+tunnel = tunnel_class(port)
+tunnel.add_tunnel(command=f"cl tunnel --url localhost:{port}", name="cl", pattern=re.compile(r"[\w-]+\.trycloudflare\.com"))
+asd = f'/kaggle/venv/bin/python3 launch.py {" ".join(sys.argv[1:])}'
+with tunnel:
+    subprocess.call(shlex.split(asd))

Stable-diffusion/ui/config.json

@@ -0,0 +1,440 @@
+{
+    "gradio_theme": "NoCrypt/miku",
+    "lora_preferred_name": "Filename",
+    "samples_filename_pattern": "[datetime<%M%S>]",
+    "show_progressbar": true,
+    "show_progress_grid": true,
+    "show_progress_every_n_steps": 2,
+    "live_previews_enable": true,
+    "live_previews_image_format": "webp",
+    "live_preview_allow_lowvram_full": false,
+    "live_preview_content": "Prompt",
+    "live_preview_refresh_period": 100.0,
+    "live_preview_fast_interrupt": true,
+    "quicksettings_list": [
+        "sd_model_checkpoint",
+        "sd_vae",
+        "CLIP_stop_at_last_layers"
+    ],
+    "ui_tab_order": [
+        "txt2img",
+        "img2img",
+        "Extras",
+        "Fast PNG Info",
+        "SuperMerger"
+    ],
+    "hidden_tabs": [
+        "PNG Info",
+        "Train",
+        "Checkpoint Merger"
+    ],
+    "ldsr_steps": 100,
+    "ldsr_cached": false,
+    "SCUNET_tile": 256,
+    "SCUNET_tile_overlap": 8,
+    "SWIN_tile": 192,
+    "SWIN_tile_overlap": 8,
+    "SWIN_torch_compile": false,
+    "hypertile_enable_unet": false,
+    "hypertile_enable_unet_secondpass": false,
+    "hypertile_max_depth_unet": 3,
+    "hypertile_max_tile_unet": 256,
+    "hypertile_swap_size_unet": 3,
+    "hypertile_enable_vae": false,
+    "hypertile_max_depth_vae": 3,
+    "hypertile_max_tile_vae": 128,
+    "hypertile_swap_size_vae": 3,
+    "bmab_debug_print": false,
+    "bmab_debug_logging": false,
+    "bmab_show_extends": false,
+    "bmab_test_function": false,
+    "bmab_keep_original_setting": false,
+    "bmab_save_image_before_process": false,
+    "bmab_save_image_after_process": false,
+    "bmab_for_developer": false,
+    "bmab_use_dino_predict": false,
+    "bmab_max_detailing_element": 0,
+    "bmab_detail_full": true,
+    "bmab_optimize_vram": "None",
+    "bmab_mask_model": "sam_vit_b",
+    "bmab_use_specific_model": false,
+    "bmab_model": "",
+    "bmab_cn_openpose": "control_v11p_sd15_openpose_fp16 [73c2b67d]",
+    "bmab_cn_lineart": "control_v11p_sd15_lineart_fp16 [5c23b17d]",
+    "bmab_cn_inpaint": "control_v11p_sd15_inpaint_fp16 [be8bc0ed]",
+    "bmab_cn_tile_resample": "control_v11f1e_sd15_tile_fp16 [3b860298]",
+    "bmab_cn_inpaint_depth_hand": "control_sd15_inpaint_depth_hand_fp16 [09456e54]",
+    "bmab_cn_ipadapter": "ip-adapter-plus_sd15 [836b5c2e]",
+    "bmab_additional_checkpoint_path": "",
+    "ad_max_models": 4,
+    "ad_extra_models_dir": "",
+    "ad_save_images_dir": "",
+    "ad_save_previews": false,
+    "ad_save_images_before": false,
+    "ad_only_selected_scripts": true,
+    "ad_script_names": "dynamic_prompting,dynamic_thresholding,lora_block_weight,negpip,wildcard_recursive,wildcards",
+    "ad_bbox_sortby": "None",
+    "ad_same_seed_for_each_tab": false,
+    "ad_dynamic_denoise_power": 0,
+    "ad_match_inpaint_bbox_size": "Off",
+    "arh_javascript_aspect_ratio_show": true,
+    "arh_javascript_aspect_ratio": "1:1, 3:2, 4:3, 5:4, 16:9",
+    "arh_ui_javascript_selection_method": "Aspect Ratios Dropdown",
+    "arh_hide_accordion_by_default": true,
+    "arh_expand_by_default": false,
+    "arh_ui_component_order_key": "MaxDimensionScaler, MinDimensionScaler, PredefinedAspectRatioButtons, PredefinedPercentageButtons",
+    "arh_show_max_width_or_height": false,
+    "arh_max_width_or_height": 1024.0,
+    "arh_show_min_width_or_height": false,
+    "arh_min_width_or_height": 1024.0,
+    "arh_show_predefined_aspect_ratios": false,
+    "arh_predefined_aspect_ratio_use_max_dim": false,
+    "arh_predefined_aspect_ratios": "1:1, 4:3, 16:9, 9:16, 21:9",
+    "arh_show_predefined_percentages": false,
+    "arh_predefined_percentages": "25, 50, 75, 125, 150, 175, 200",
+    "arh_predefined_percentages_display_key": "Incremental/decremental percentage (-50%, +50%)",
+    "control_net_detectedmap_dir": "detected_maps",
+    "control_net_models_path": "",
+    "control_net_modules_path": "",
+    "control_net_unit_count": 3,
+    "control_net_model_cache_size": 2,
+    "control_net_inpaint_blur_sigma": 7,
+    "control_net_no_detectmap": false,
+    "control_net_detectmap_autosaving": false,
+    "control_net_allow_script_control": false,
+    "control_net_sync_field_args": true,
+    "controlnet_show_batch_images_in_ui": false,
+    "controlnet_increment_seed_during_batch": false,
+    "controlnet_disable_openpose_edit": false,
+    "controlnet_disable_photopea_edit": false,
+    "controlnet_photopea_warning": true,
+    "controlnet_ignore_noninpaint_mask": false,
+    "controlnet_clip_detector_on_cpu": false,
+    "controlnet_control_type_dropdown": false,
+    "encrypt_image_is_enable": "Yes",
+    "sd_model_checkpoint": "speciosa25D_v12.safetensors [e1431355af]",
+    "sd_checkpoint_hash": "e1431355afb5d23c727748fafe357ad7359822fb7b4312059a1a583cb468a885",
+    "sd_vae": "sdxl_vae.safetensors",
+    "emphasis": "No norm",
+    "multiple_tqdm": true,
+    "outdir_samples": "",
+    "outdir_txt2img_samples": "outputs/txt2img-images",
+    "outdir_img2img_samples": "outputs/img2img-images",
+    "outdir_extras_samples": "outputs/extras-images",
+    "outdir_grids": "",
+    "outdir_txt2img_grids": "outputs/txt2img-grids",
+    "outdir_img2img_grids": "outputs/img2img-grids",
+    "outdir_save": "log/images",
+    "outdir_init_images": "outputs/init-images",
+    "samples_save": true,
+    "samples_format": "png",
+    "save_images_add_number": true,
+    "save_images_replace_action": "Replace",
+    "grid_save": true,
+    "grid_format": "png",
+    "grid_extended_filename": false,
+    "grid_only_if_multiple": true,
+    "grid_prevent_empty_spots": false,
+    "grid_zip_filename_pattern": "",
+    "n_rows": -1,
+    "font": "",
+    "grid_text_active_color": "#000000",
+    "grid_text_inactive_color": "#999999",
+    "grid_background_color": "#ffffff",
+    "save_images_before_face_restoration": false,
+    "save_images_before_highres_fix": false,
+    "save_images_before_color_correction": false,
+    "save_mask": false,
+    "save_mask_composite": false,
+    "jpeg_quality": 80,
+    "webp_lossless": false,
+    "export_for_4chan": true,
+    "img_downscale_threshold": 4.0,
+    "target_side_length": 4000.0,
+    "img_max_size_mp": 200.0,
+    "use_original_name_batch": true,
+    "use_upscaler_name_as_suffix": false,
+    "save_selected_only": true,
+    "save_write_log_csv": true,
+    "save_init_img": false,
+    "temp_dir": "",
+    "clean_temp_dir_at_start": false,
+    "save_incomplete_images": true,
+    "notification_audio": true,
+    "notification_volume": 100,
+    "save_to_dirs": true,
+    "grid_save_to_dirs": true,
+    "use_save_to_dirs_for_ui": false,
+    "directories_filename_pattern": "[date]",
+    "directories_max_prompt_words": 8,
+    "auto_backcompat": true,
+    "use_old_emphasis_implementation": false,
+    "use_old_karras_scheduler_sigmas": false,
+    "no_dpmpp_sde_batch_determinism": false,
+    "use_old_hires_fix_width_height": false,
+    "hires_fix_use_firstpass_conds": false,
+    "use_old_scheduling": false,
+    "use_downcasted_alpha_bar": false,
+    "refiner_switch_by_sample_steps": false,
+    "lora_functional": false,
+    "extra_networks_show_hidden_directories": true,
+    "extra_networks_dir_button_function": false,
+    "extra_networks_hidden_models": "When searched",
+    "extra_networks_default_multiplier": 1,
+    "extra_networks_card_width": 120.0,
+    "extra_networks_card_height": 120.0,
+    "extra_networks_card_text_scale": 0.6,
+    "extra_networks_card_show_desc": false,
+    "extra_networks_card_description_is_html": false,
+    "extra_networks_card_order_field": "Path",
+    "extra_networks_card_order": "Ascending",
+    "extra_networks_tree_view_style": "Dirs",
+    "extra_networks_tree_view_default_enabled": true,
+    "extra_networks_tree_view_default_width": 180.0,
+    "extra_networks_add_text_separator": " ",
+    "ui_extra_networks_tab_reorder": "",
+    "textual_inversion_print_at_load": false,
+    "textual_inversion_add_hashes_to_infotext": true,
+    "sd_hypernetwork": "None",
+    "sd_lora": "None",
+    "lora_add_hashes_to_infotext": true,
+    "lora_bundled_ti_to_infotext": true,
+    "lora_show_all": false,
+    "lora_hide_unknown_for_versions": [],
+    "lora_in_memory_limit": 0,
+    "lora_not_found_warning_console": false,
+    "lora_not_found_gradio_warning": false,
+    "cross_attention_optimization": "Automatic",
+    "s_min_uncond": 0,
+    "s_min_uncond_all": false,
+    "token_merging_ratio": 0,
+    "token_merging_ratio_img2img": 0,
+    "token_merging_ratio_hr": 0,
+    "pad_cond_uncond": false,
+    "pad_cond_uncond_v0": false,
+    "persistent_cond_cache": true,
+    "batch_cond_uncond": true,
+    "fp8_storage": "Disable",
+    "cache_fp16_weight": false,
+    "hide_samplers": [],
+    "eta_ddim": 0,
+    "eta_ancestral": 1,
+    "ddim_discretize": "uniform",
+    "s_churn": 0,
+    "s_tmin": 0,
+    "s_tmax": 0,
+    "s_noise": 1,
+    "sigma_min": 0.0,
+    "sigma_max": 0.0,
+    "rho": 0.0,
+    "eta_noise_seed_delta": 0,
+    "always_discard_next_to_last_sigma": false,
+    "sgm_noise_multiplier": false,
+    "uni_pc_variant": "bh1",
+    "uni_pc_skip_type": "time_uniform",
+    "uni_pc_order": 3,
+    "uni_pc_lower_order_final": true,
+    "sd_noise_schedule": "Default",
+    "skip_early_cond": 0,
+    "beta_dist_alpha": 0.6,
+    "beta_dist_beta": 0.6,
+    "sd_checkpoints_limit": 1,
+    "sd_checkpoints_keep_in_cpu": true,
+    "sd_checkpoint_cache": 0,
+    "sd_unet": "Automatic",
+    "enable_quantization": false,
+    "enable_batch_seeds": true,
+    "comma_padding_backtrack": 20,
+    "sdxl_clip_l_skip": false,
+    "upcast_attn": false,
+    "randn_source": "GPU",
+    "tiling": false,
+    "hires_fix_refiner_pass": "second pass",
+    "enable_prompt_comments": true,
+    "sd3_enable_t5": false,
+    "sdxl_crop_top": 0.0,
+    "sdxl_crop_left": 0.0,
+    "sdxl_refiner_low_aesthetic_score": 2.5,
+    "sdxl_refiner_high_aesthetic_score": 6.0,
+    "sd_vae_checkpoint_cache": 0,
+    "sd_vae_overrides_per_model_preferences": true,
+    "auto_vae_precision_bfloat16": false,
+    "auto_vae_precision": true,
+    "sd_vae_encode_method": "Full",
+    "sd_vae_decode_method": "Full",
+    "inpainting_mask_weight": 1,
+    "initial_noise_multiplier": 1,
+    "img2img_extra_noise": 0,
+    "img2img_color_correction": false,
+    "img2img_fix_steps": false,
+    "img2img_background_color": "#ffffff",
+    "img2img_editor_height": 720,
+    "img2img_sketch_default_brush_color": "#ffffff",
+    "img2img_inpaint_mask_brush_color": "#ffffff",
+    "img2img_inpaint_sketch_default_brush_color": "#ffffff",
+    "return_mask": false,
+    "return_mask_composite": false,
+    "img2img_batch_show_results_limit": 32,
+    "overlay_inpaint": true,
+    "return_grid": true,
+    "do_not_show_images": false,
+    "js_modal_lightbox": true,
+    "js_modal_lightbox_initially_zoomed": true,
+    "js_modal_lightbox_gamepad": false,
+    "js_modal_lightbox_gamepad_repeat": 250.0,
+    "sd_webui_modal_lightbox_icon_opacity": 1,
+    "sd_webui_modal_lightbox_toolbar_opacity": 0.9,
+    "gallery_height": "",
+    "open_dir_button_choice": "Subdirectory",
+    "enable_pnginfo": true,
+    "save_txt": false,
+    "add_model_name_to_info": true,
+    "add_model_hash_to_info": true,
+    "add_vae_name_to_info": true,
+    "add_vae_hash_to_info": true,
+    "add_user_name_to_info": false,
+    "add_version_to_infotext": true,
+    "disable_weights_auto_swap": true,
+    "infotext_skip_pasting": [],
+    "infotext_styles": "Apply if any",
+    "show_progress_type": "TAESD",
+    "js_live_preview_in_modal_lightbox": true,
+    "prevent_screen_sleep_during_generation": true,
+    "keyedit_precision_attention": 0.1,
+    "keyedit_precision_extra": 0.05,
+    "keyedit_delimiters": ".,\\/!?%^*;:{}=`~() ",
+    "keyedit_delimiters_whitespace": [
+        "Tab",
+        "Carriage Return",
+        "Line Feed"
+    ],
+    "keyedit_move": true,
+    "disable_token_counters": false,
+    "include_styles_into_token_counters": true,
+    "extra_options_txt2img": [],
+    "extra_options_img2img": [],
+    "extra_options_cols": 1,
+    "extra_options_accordion": false,
+    "compact_prompt_box": false,
+    "samplers_in_dropdown": true,
+    "dimensions_and_batch_together": true,
+    "sd_checkpoint_dropdown_use_short": false,
+    "hires_fix_show_sampler": false,
+    "hires_fix_show_prompts": false,
+    "txt2img_settings_accordion": false,
+    "img2img_settings_accordion": false,
+    "interrupt_after_current": false,
+    "localization": "None",
+    "ui_reorder_list": [],
+    "gradio_themes_cache": true,
+    "show_progress_in_title": true,
+    "send_seed": true,
+    "send_size": true,
+    "enable_reloading_ui_scripts": false,
+    "api_enable_requests": true,
+    "api_forbid_local_requests": true,
+    "api_useragent": "",
+    "prioritized_callbacks_app_started": [],
+    "prioritized_callbacks_model_loaded": [],
+    "prioritized_callbacks_ui_tabs": [],
+    "prioritized_callbacks_ui_settings": [],
+    "prioritized_callbacks_after_component": [],
+    "prioritized_callbacks_infotext_pasted": [],
+    "prioritized_callbacks_script_unloaded": [],
+    "prioritized_callbacks_before_ui": [],
+    "prioritized_callbacks_on_reload": [],
+    "prioritized_callbacks_list_optimizers": [],
+    "prioritized_callbacks_before_token_counter": [],
+    "prioritized_callbacks_script_before_process": [],
+    "prioritized_callbacks_script_process": [],
+    "prioritized_callbacks_script_before_process_batch": [],
+    "prioritized_callbacks_script_process_batch": [],
+    "prioritized_callbacks_script_postprocess": [],
+    "prioritized_callbacks_script_postprocess_batch": [],
+    "prioritized_callbacks_script_post_sample": [],
+    "prioritized_callbacks_script_on_mask_blend": [],
+    "prioritized_callbacks_script_postprocess_image": [],
+    "prioritized_callbacks_script_postprocess_maskoverlay": [],
+    "prioritized_callbacks_script_after_component": [],
+    "profiling_enable": false,
+    "profiling_activities": [
+        "CPU"
+    ],
+    "profiling_record_shapes": true,
+    "profiling_profile_memory": true,
+    "profiling_with_stack": true,
+    "profiling_filename": "trace.json",
+    "auto_launch_browser": "Local",
+    "enable_console_prompts": false,
+    "show_warnings": false,
+    "show_gradio_deprecation_warnings": true,
+    "memmon_poll_rate": 8,
+    "samples_log_stdout": false,
+    "enable_upscale_progressbar": true,
+    "print_hypernet_extra": false,
+    "list_hidden_files": true,
+    "disable_mmap_load_safetensors": false,
+    "hide_ldm_prints": true,
+    "dump_stacks_on_signal": false,
+    "face_restoration": false,
+    "face_restoration_model": "CodeFormer",
+    "code_former_weight": 0.5,
+    "face_restoration_unload": false,
+    "postprocessing_enable_in_main_ui": [],
+    "postprocessing_disable_in_extras": [],
+    "postprocessing_operation_order": [],
+    "upscaling_max_images_in_cache": 5,
+    "postprocessing_existing_caption_action": "Ignore",
+    "ESRGAN_tile": 192,
+    "ESRGAN_tile_overlap": 8,
+    "realesrgan_enabled_models": [
+        "R-ESRGAN 4x+",
+        "R-ESRGAN 4x+ Anime6B"
+    ],
+    "dat_enabled_models": [
+        "DAT x2",
+        "DAT x3",
+        "DAT x4"
+    ],
+    "DAT_tile": 192,
+    "DAT_tile_overlap": 8,
+    "set_scale_by_when_changing_upscaler": false,
+    "unload_models_when_training": false,
+    "pin_memory": false,
+    "save_optimizer_state": false,
+    "save_training_settings_to_txt": true,
+    "dataset_filename_word_regex": "",
+    "dataset_filename_join_string": " ",
+    "training_image_repeats_per_epoch": 1,
+    "training_write_csv_every": 500.0,
+    "training_xattention_optimizations": false,
+    "training_enable_tensorboard": false,
+    "training_tensorboard_save_images": false,
+    "training_tensorboard_flush_every": 120.0,
+    "canvas_hotkey_zoom": "Alt",
+    "canvas_hotkey_adjust": "Ctrl",
+    "canvas_hotkey_shrink_brush": "Q",
+    "canvas_hotkey_grow_brush": "W",
+    "canvas_hotkey_move": "F",
+    "canvas_hotkey_fullscreen": "S",
+    "canvas_hotkey_reset": "R",
+    "canvas_hotkey_overlap": "O",
+    "canvas_show_tooltip": true,
+    "canvas_auto_expand": true,
+    "canvas_blur_prompt": false,
+    "canvas_disabled_functions": [
+        "Overlap"
+    ],
+    "interrogate_keep_models_in_memory": false,
+    "interrogate_return_ranks": false,
+    "interrogate_clip_num_beams": 1,
+    "interrogate_clip_min_length": 24,
+    "interrogate_clip_max_length": 48,
+    "interrogate_clip_dict_limit": 1500.0,
+    "interrogate_clip_skip_categories": [],
+    "interrogate_deepbooru_score_threshold": 0.5,
+    "deepbooru_sort_alpha": true,
+    "deepbooru_use_spaces": true,
+    "deepbooru_escape": true,
+    "deepbooru_filter_tags": ""
+}

Stable-diffusion/ui/custom_hires_fix.py

@@ -0,0 +1,416 @@
+import math
+from os.path import exists
+
+from tqdm import trange
+from modules import scripts, shared, processing, sd_samplers, script_callbacks, rng
+from modules import devices, prompt_parser, sd_models, extra_networks
+import modules.images as images
+import k_diffusion
+
+import gradio as gr
+import numpy as np
+from PIL import Image, ImageEnhance
+import torch
+import importlib
+
+
+def safe_import(import_name, pkg_name = None):
+    try:
+        __import__(import_name)
+    except Exception:
+        pkg_name = pkg_name or import_name
+        import pip
+        if hasattr(pip, 'main'):
+            pip.main(['install', pkg_name])
+        else:
+            pip._internal.main(['install', pkg_name])
+        __import__(import_name)
+
+
+safe_import('kornia')
+safe_import('omegaconf')
+safe_import('pathlib')
+from omegaconf import DictConfig, OmegaConf
+from pathlib import Path
+import kornia
+from skimage import exposure
+
+config_path = Path(__file__).parent.resolve() / '../config.yaml'
+
+
+class CustomHiresFix(scripts.Script):
+    def __init__(self):
+        super().__init__()
+        if not exists(config_path):
+            open(config_path, 'w').close()
+        self.config: DictConfig = OmegaConf.load(config_path)
+        self.callback_set = False
+        self.orig_clip_skip = None
+        self.orig_cfg = None
+        self.p: processing.StableDiffusionProcessing = None
+        self.pp = None
+        self.sampler = []
+        self.cond = None
+        self.uncond = None
+        self.step = None
+        self.tv = None
+        self.width = None
+        self.height = None
+        self.use_cn = False
+        self.external_code = None
+        self.cn_image = None
+        self.cn_units = []
+
+    def title(self):
+        return "Custom Hires Fix"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        with gr.Accordion(label='Custom hires fix', open=False):
+            enable = gr.Checkbox(label='Enable extension', value=self.config.get('enable', False))
+            with gr.Row():
+                width = gr.Slider(minimum=512, maximum=2048, step=8,
+                                  label="Upscale width to",
+                                  value=self.config.get('width', 1024), allow_flagging='never', show_progress=False)
+                height = gr.Slider(minimum=512, maximum=2048, step=8,
+                                   label="Upscale height to",
+                                   value=self.config.get('height', 0), allow_flagging='never', show_progress=False)
+                steps = gr.Slider(minimum=8, maximum=25, step=1,
+                                  label="Steps",
+                                  value=self.config.get('steps', 15))
+            with gr.Row():
+                prompt = gr.Textbox(label='Prompt for upscale (added to generation prompt)',
+                                    placeholder='Leave empty for using generation prompt',
+                                    value=self.config.get('prompt', ''))
+            with gr.Row():
+                negative_prompt = gr.Textbox(label='Negative prompt for upscale (replaces generation prompt)',
+                                             placeholder='Leave empty for using generation negative prompt',
+                                             value=self.config.get('negative_prompt', ''))
+            with gr.Row():
+                first_upscaler = gr.Dropdown([*[x.name for x in shared.sd_upscalers
+                                                if x.name not in ['None', 'Nearest', 'LDSR']]],
+                                             label='First upscaler',
+                                             value=self.config.get('first_upscaler', 'R-ESRGAN 4x+'))
+                second_upscaler = gr.Dropdown([*[x.name for x in shared.sd_upscalers
+                                                 if x.name not in ['None', 'Nearest', 'LDSR']]],
+                                              label='Second upscaler',
+                                              value=self.config.get('second_upscaler', 'R-ESRGAN 4x+'))
+            with gr.Row():
+                first_latent = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, 
+                                         label="Latent upscale ratio (1)",
+                                         value=self.config.get('first_latent', 0.3))
+                second_latent = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, 
+                                         label="Latent upscale ratio (2)",
+                                         value=self.config.get('second_latent', 0.1))
+            with gr.Row():
+                filter = gr.Dropdown(['Noise sync (sharp)', 'Morphological (smooth)', 'Combined (balanced)'],
+                                     label='Filter mode',
+                                     value=self.config.get('filter', 'Noise sync (sharp)'))
+                strength = gr.Slider(minimum=1.0, maximum=3.5, step=0.1, label="Generation strength",
+                                     value=self.config.get('strength', 2.0))
+                denoise_offset = gr.Slider(minimum=-0.05, maximum=0.15, step=0.01,
+                                           label="Denoise offset",
+                                           value=self.config.get('denoise_offset', 0.05))
+            with gr.Accordion(label='Extra', open=False):
+                with gr.Row():
+                    filter_offset = gr.Slider(minimum=-1.0, maximum=1.0, step=0.1,
+                                              label="Filter offset (higher - smoother)",
+                                              value=self.config.get('filter_offset', 0.0))
+                    clip_skip = gr.Slider(minimum=0, maximum=5, step=1,
+                                          label="Clip skip for upscale (0 - not change)",
+                                          value=self.config.get('clip_skip', 0))
+                with gr.Row():
+                    start_control_at = gr.Slider(minimum=0.0, maximum=0.7, step=0.01,
+                                                 label="CN start for enabled units",
+                                                 value=self.config.get('start_control_at', 0.0))
+                    cn_ref = gr.Checkbox(label='Use last image for reference', value=self.config.get('cn_ref', False))
+                with gr.Row():
+                    sampler = gr.Dropdown(['Restart', 'DPM++ 2M', 'DPM++ 2M Karras', 'DPM++ 2M SDE', 'DPM++ 2M SDE Karras', 'DPM++ 2M SDE Heun', 'DPM++ 2M SDE Heun Karras', 'DPM++ 3M SDE', 'DPM++ 3M SDE Karras', 'Restart + DPM++ 3M SDE'],
+                                     label='Sampler',
+                                     value=self.config.get('sampler', 'DPM++ 2M Karras'))
+
+        if is_img2img:
+            width.change(fn=lambda x: gr.update(value=0), inputs=width, outputs=height)
+            height.change(fn=lambda x: gr.update(value=0), inputs=height, outputs=width)
+        else:
+            width.change(fn=lambda x: gr.update(value=0), inputs=width, outputs=height)
+            height.change(fn=lambda x: gr.update(value=0), inputs=height, outputs=width)
+
+        ui = [enable, width, height, steps, first_upscaler, second_upscaler, first_latent, second_latent, prompt, 
+              negative_prompt, strength, filter, filter_offset, denoise_offset, clip_skip, sampler, cn_ref, start_control_at]
+        for elem in ui:
+            setattr(elem, "do_not_save_to_config", True)
+        return ui
+
+    def process(self, p, *args, **kwargs):
+        self.p = p
+        self.cn_units = []
+        try:
+            self.external_code = importlib.import_module('extensions.sd-webui-controlnet.scripts.external_code', 'external_code')
+            cn_units = self.external_code.get_all_units_in_processing(p)
+            for unit in cn_units:
+                self.cn_units += [unit]
+            self.use_cn = len(self.cn_units) > 0
+        except ImportError:
+            self.use_cn = False
+        
+    def postprocess_image(self, p, pp: scripts.PostprocessImageArgs,
+                          enable, width, height, steps, first_upscaler, second_upscaler, first_latent, second_latent, prompt,
+                          negative_prompt, strength, filter, filter_offset, denoise_offset, clip_skip, sampler, cn_ref, start_control_at
+                          ):
+        if not enable:
+            return
+        self.step = 0
+        self.pp = pp
+        self.config.width = width
+        self.config.height = height
+        self.config.prompt = prompt.strip()
+        self.config.negative_prompt = negative_prompt.strip()
+        self.config.steps = steps
+        self.config.first_upscaler = first_upscaler
+        self.config.second_upscaler = second_upscaler
+        self.config.first_latent = first_latent
+        self.config.second_latent = second_latent
+        self.config.strength = strength
+        self.config.filter = filter
+        self.config.filter_offset = filter_offset
+        self.config.denoise_offset = denoise_offset
+        self.config.clip_skip = clip_skip
+        self.config.sampler = sampler
+        self.config.cn_ref = cn_ref
+        self.config.start_control_at = start_control_at
+        self.orig_clip_skip = shared.opts.CLIP_stop_at_last_layers
+        self.orig_cfg = p.cfg_scale
+        
+        if clip_skip > 0:
+            shared.opts.CLIP_stop_at_last_layers = clip_skip
+        if 'Restart' in self.config.sampler:
+            self.sampler = sd_samplers.create_sampler('Restart', p.sd_model)
+        else:
+            self.sampler = sd_samplers.create_sampler(sampler, p.sd_model)
+
+        def denoise_callback(params: script_callbacks.CFGDenoiserParams):
+            if params.sampling_step > 0:
+                p.cfg_scale = self.orig_cfg
+            if self.step == 1 and self.config.strength != 1.0:
+                params.sigma[-1] = params.sigma[0] * (1 - (1 - self.config.strength) / 100)
+            elif self.step == 2 and self.config.filter == 'Noise sync (sharp)':
+                params.sigma[-1] = params.sigma[0] * (1 - (self.tv - 1 + self.config.filter_offset - (self.config.denoise_offset * 5)) / 50)
+            elif self.step == 2 and self.config.filter == 'Combined (balanced)':
+                params.sigma[-1] = params.sigma[0] * (1 - (self.tv - 1 + self.config.filter_offset - (self.config.denoise_offset * 5)) / 100)
+
+        if self.callback_set is False:
+            script_callbacks.on_cfg_denoiser(denoise_callback)
+            self.callback_set = True
+
+        _, loras_act = extra_networks.parse_prompt(prompt)
+        extra_networks.activate(p, loras_act)
+        _, loras_deact = extra_networks.parse_prompt(negative_prompt)
+        extra_networks.deactivate(p, loras_deact)
+        
+        self.cn_image = pp.image
+        
+        with devices.autocast():
+            shared.state.nextjob()
+            x = self.gen(pp.image)
+            shared.state.nextjob()
+            x = self.filter(x)
+        shared.opts.CLIP_stop_at_last_layers = self.orig_clip_skip
+        sd_models.apply_token_merging(p.sd_model, p.get_token_merging_ratio())
+        pp.image = x
+        extra_networks.deactivate(p, loras_act)
+        OmegaConf.save(self.config, config_path)
+
+    def enable_cn(self, image: np.ndarray):
+        for unit in self.cn_units:
+            if unit.model != 'None':
+                unit.guidance_start = self.config.start_control_at if unit.enabled else unit.guidance_start
+                unit.processor_res = min(image.shape[0], image.shape[0])
+                unit.enabled = True
+                if unit.image is None:
+                    unit.image = image
+                self.p.width = image.shape[1]
+                self.p.height = image.shape[0]
+        self.external_code.update_cn_script_in_processing(self.p, self.cn_units)
+        for script in self.p.scripts.alwayson_scripts:
+            if script.title().lower() == 'controlnet':
+                script.controlnet_hack(self.p)
+
+    def process_prompt(self):
+        prompt = self.p.prompt.strip().split('AND', 1)[0]
+        if self.config.prompt != '':
+            prompt = f'{prompt} {self.config.prompt}'
+
+        if self.config.negative_prompt != '':
+            negative_prompt = self.config.negative_prompt
+        else:
+            negative_prompt = self.p.negative_prompt.strip()
+
+        with devices.autocast():
+            if self.width is not None and self.height is not None and hasattr(prompt_parser, 'SdConditioning'):
+                c = prompt_parser.SdConditioning([prompt], False, self.width, self.height)
+                uc = prompt_parser.SdConditioning([negative_prompt], False, self.width, self.height)
+            else:
+                c = [prompt]
+                uc = [negative_prompt]
+            self.cond = prompt_parser.get_multicond_learned_conditioning(shared.sd_model, c, self.config.steps)
+            self.uncond = prompt_parser.get_learned_conditioning(shared.sd_model, uc, self.config.steps)
+
+    def gen(self, x):
+        self.step = 1
+        ratio = x.width / x.height
+        self.width = self.config.width if self.config.width > 0 else int(self.config.height * ratio)
+        self.height = self.config.height if self.config.height > 0 else int(self.config.width / ratio)
+        self.width = int((self.width - x.width) // 2 + x.width)
+        self.height = int((self.height - x.height) // 2 + x.height)
+        sd_models.apply_token_merging(self.p.sd_model, self.p.get_token_merging_ratio(for_hr=True) / 2)
+        
+        if self.use_cn:
+            self.enable_cn(np.array(self.cn_image.resize((self.width, self.height))))
+            
+        with devices.autocast(), torch.inference_mode():
+            self.process_prompt()
+        
+        x_big = None
+        if self.config.first_latent > 0:
+            image = np.array(x).astype(np.float32) / 255.0
+            image = np.moveaxis(image, 2, 0)
+            decoded_sample = torch.from_numpy(image)
+            decoded_sample = decoded_sample.to(shared.device).to(devices.dtype_vae)
+            decoded_sample = 2.0 * decoded_sample - 1.0
+            encoded_sample = shared.sd_model.encode_first_stage(decoded_sample.unsqueeze(0).to(devices.dtype_vae))
+            sample = shared.sd_model.get_first_stage_encoding(encoded_sample)
+            x_big = torch.nn.functional.interpolate(sample, (self.height // 8, self.width // 8), mode='nearest')
+            
+        if self.config.first_latent < 1:
+            x = images.resize_image(0, x, self.width, self.height,
+                                    upscaler_name=self.config.first_upscaler)
+            image = np.array(x).astype(np.float32) / 255.0
+            image = np.moveaxis(image, 2, 0)
+            decoded_sample = torch.from_numpy(image)
+            decoded_sample = decoded_sample.to(shared.device).to(devices.dtype_vae)
+            decoded_sample = 2.0 * decoded_sample - 1.0
+            encoded_sample = shared.sd_model.encode_first_stage(decoded_sample.unsqueeze(0).to(devices.dtype_vae))
+            sample = shared.sd_model.get_first_stage_encoding(encoded_sample)
+        else:
+            sample = x_big
+        if x_big is not None and self.config.first_latent != 1:
+            sample = (sample * (1 - self.config.first_latent)) + (x_big * self.config.first_latent)
+        image_conditioning = self.p.img2img_image_conditioning(decoded_sample, sample)
+        
+        noise = torch.zeros_like(sample)
+        noise = kornia.augmentation.RandomGaussianNoise(mean=0.0, std=1.0, p=1.0)(noise)
+        steps = int(max(((self.p.steps - self.config.steps) / 2) + self.config.steps, self.config.steps))
+        self.p.denoising_strength = 0.45 + self.config.denoise_offset * 0.2
+        self.p.cfg_scale = self.orig_cfg + 0
+
+        def denoiser_override(n):
+            sigmas = k_diffusion.sampling.get_sigmas_polyexponential(n, 0.01, 15, 0.5, devices.device)
+            return sigmas
+        
+        self.p.rng = rng.ImageRNG(sample.shape[1:], self.p.seeds, subseeds=self.p.subseeds, 
+                                  subseed_strength=self.p.subseed_strength, 
+                                  seed_resize_from_h=self.p.seed_resize_from_h, seed_resize_from_w=self.p.seed_resize_from_w)
+        
+        self.p.sampler_noise_scheduler_override = denoiser_override
+        self.p.batch_size = 1
+        sample = self.sampler.sample_img2img(self.p, sample.to(devices.dtype), noise, self.cond, self.uncond,
+                                             steps=steps, image_conditioning=image_conditioning).to(devices.dtype_vae)
+        b, c, w, h = sample.size()
+        self.tv = kornia.losses.TotalVariation()(sample).mean() / (w * h)
+        devices.torch_gc()
+        decoded_sample = processing.decode_first_stage(shared.sd_model, sample)
+        if math.isnan(decoded_sample.min()):
+            devices.torch_gc()
+            sample = torch.clamp(sample, -3, 3)
+            decoded_sample = processing.decode_first_stage(shared.sd_model, sample)
+        decoded_sample = torch.clamp((decoded_sample + 1.0) / 2.0, min=0.0, max=1.0).squeeze()
+        x_sample = 255. * np.moveaxis(decoded_sample.cpu().numpy(), 0, 2)
+        x_sample = x_sample.astype(np.uint8)
+        image = Image.fromarray(x_sample)
+        return image
+
+    def filter(self, x):
+        if 'Restart' == self.config.sampler:
+            self.sampler = sd_samplers.create_sampler('Restart', shared.sd_model)
+        elif 'Restart + DPM++ 3M SDE' == self.config.sampler:
+            self.sampler = sd_samplers.create_sampler('DPM++ 3M SDE', shared.sd_model)
+        self.step = 2
+        ratio = x.width / x.height
+        self.width = self.config.width if self.config.width > 0 else int(self.config.height * ratio)
+        self.height = self.config.height if self.config.height > 0 else int(self.config.width / ratio)
+        sd_models.apply_token_merging(self.p.sd_model, self.p.get_token_merging_ratio(for_hr=True))
+        
+        if self.use_cn:
+            self.cn_image = x if self.config.cn_ref else self.cn_image
+            self.enable_cn(np.array(self.cn_image.resize((self.width, self.height))))
+        
+        with devices.autocast(), torch.inference_mode():
+            self.process_prompt()
+        
+        x_big = None
+        if self.config.second_latent > 0:
+            image = np.array(x).astype(np.float32) / 255.0
+            image = np.moveaxis(image, 2, 0)
+            decoded_sample = torch.from_numpy(image)
+            decoded_sample = decoded_sample.to(shared.device).to(devices.dtype_vae)
+            decoded_sample = 2.0 * decoded_sample - 1.0
+            encoded_sample = shared.sd_model.encode_first_stage(decoded_sample.unsqueeze(0).to(devices.dtype_vae))
+            sample = shared.sd_model.get_first_stage_encoding(encoded_sample)
+            x_big = torch.nn.functional.interpolate(sample, (self.height // 8, self.width // 8), mode='nearest')
+            
+        if self.config.second_latent < 1:
+            x = images.resize_image(0, x, self.width, self.height, upscaler_name=self.config.second_upscaler)
+            image = np.array(x).astype(np.float32) / 255.0
+            image = np.moveaxis(image, 2, 0)
+            decoded_sample = torch.from_numpy(image)
+            decoded_sample = decoded_sample.to(shared.device).to(devices.dtype_vae)
+            decoded_sample = 2.0 * decoded_sample - 1.0
+            encoded_sample = shared.sd_model.encode_first_stage(decoded_sample.unsqueeze(0).to(devices.dtype_vae))
+            sample = shared.sd_model.get_first_stage_encoding(encoded_sample)
+        else:
+            sample = x_big
+        if x_big is not None and self.config.second_latent != 1:
+            sample = (sample * (1 - self.config.second_latent)) + (x_big * self.config.second_latent)
+        image_conditioning = self.p.img2img_image_conditioning(decoded_sample, sample)
+        
+        noise = torch.zeros_like(sample)
+        noise = kornia.augmentation.RandomGaussianNoise(mean=0.0, std=1.0, p=1.0)(noise)
+        self.p.denoising_strength = 0.45 + self.config.denoise_offset
+        self.p.cfg_scale = self.orig_cfg + 3
+
+        if self.config.filter == 'Morphological (smooth)':
+            noise_mask = kornia.morphology.gradient(sample, torch.ones(5, 5).to(devices.device))
+            noise_mask = kornia.filters.median_blur(noise_mask, (3, 3))
+            noise_mask = (0.1 + noise_mask / noise_mask.max()) * (max(
+                (1.75 - (self.tv - 1) * 4), 1.75) - self.config.filter_offset)
+            noise = noise * noise_mask
+        elif self.config.filter == 'Combined (balanced)':
+            noise_mask = kornia.morphology.gradient(sample, torch.ones(5, 5).to(devices.device))
+            noise_mask = kornia.filters.median_blur(noise_mask, (3, 3))
+            noise_mask = (0.1 + noise_mask / noise_mask.max()) * (max(
+                (1.75 - (self.tv - 1) / 2), 1.75) - self.config.filter_offset)
+            noise = noise * noise_mask
+
+        def denoiser_override(n):
+            return k_diffusion.sampling.get_sigmas_polyexponential(n, 0.01, 7, 0.5, devices.device)
+
+        self.p.sampler_noise_scheduler_override = denoiser_override
+        self.p.batch_size = 1
+        samples = self.sampler.sample_img2img(self.p, sample.to(devices.dtype), noise, self.cond, self.uncond,
+                                              steps=self.config.steps, image_conditioning=image_conditioning
+                                              ).to(devices.dtype_vae)
+        devices.torch_gc()
+        self.p.iteration += 1
+        decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+        if math.isnan(decoded_sample.min()):
+            devices.torch_gc()
+            samples = torch.clamp(samples, -3, 3)
+            decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+        decoded_sample = torch.clamp((decoded_sample + 1.0) / 2.0, min=0.0, max=1.0).squeeze()
+        x_sample = 255. * np.moveaxis(decoded_sample.cpu().numpy(), 0, 2)
+        x_sample = x_sample.astype(np.uint8)
+        image = Image.fromarray(x_sample)
+        return image

Stable-diffusion/ui/embeddings.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:793d2c9d60623bb3e7ff229d17777d95cef08c73c98d23ea3565de0de8519208
+size 5621788

Stable-diffusion/ui/encrypt_image.py

@@ -0,0 +1,206 @@
+import base64
+import io
+from pathlib import Path
+from modules import shared,script_callbacks,scripts as md_scripts,images
+from modules.api import api
+from modules.shared import opts
+from scripts.core.core import get_sha256,dencrypt_image,dencrypt_image_v2,encrypt_image_v2
+from PIL import PngImagePlugin,_util,ImagePalette
+from PIL import Image as PILImage
+from io import BytesIO
+from typing import Optional
+from fastapi import FastAPI
+from gradio import Blocks
+from fastapi import FastAPI, Request, Response
+import sys
+from urllib.parse import unquote
+from colorama import Fore, Back, Style
+
+repo_dir = md_scripts.basedir()
+password = getattr(shared.cmd_opts, 'encrypt_pass', None)
+
+
+def hook_http_request(app: FastAPI):
+    @app.middleware("http")
+    async def image_dencrypt(req: Request, call_next):
+        endpoint:str = req.scope.get('path', 'err')
+        endpoint='/'+endpoint.strip('/')
+        # 兼容无边浏览器
+        if endpoint.startswith('/infinite_image_browsing/image-thumbnail') or endpoint.startswith('/infinite_image_browsing/file'):
+            query_string:str = req.scope.get('query_string').decode('utf-8')
+            query_string = unquote(query_string)
+            if query_string and query_string.index('path=')>=0:
+                query = query_string.split('&')
+                path = ''
+                for sub in query:
+                    if sub.startswith('path='):
+                        path = sub[sub.index('=')+1:]
+                if path:
+                    endpoint = '/file=' + path
+        # 模型预览图
+        if endpoint.startswith('/sd_extra_networks/thumb'):
+            query_string:str = req.scope.get('query_string').decode('utf-8')
+            query_string = unquote(query_string)
+            if query_string and query_string.index('filename=')>=0:
+                query = query_string.split('&')
+                path = ''
+                for sub in query:
+                    if sub.startswith('filename='):
+                        path = sub[sub.index('=')+1:]
+                if path:
+                    endpoint = '/file=' + path
+        if endpoint.startswith('/file='):
+            file_path = endpoint[6:] or ''
+            if not file_path: return await call_next(req)
+            if file_path.rfind('.') == -1: return await call_next(req)
+            if not file_path[file_path.rfind('.'):]: return await call_next(req)
+            if file_path[file_path.rfind('.'):].lower() in ['.png','.jpg','.jpeg','.webp','.abcd']:
+                image = PILImage.open(file_path)
+                pnginfo = image.info or {}
+                if 'Encrypt' in pnginfo:
+                    buffered = BytesIO()
+                    info = PngImagePlugin.PngInfo()
+                    for key in pnginfo.keys():
+                        if pnginfo[key]:
+                            info.add_text(key,pnginfo[key])
+                    image.save(buffered, format=PngImagePlugin.PngImageFile.format, pnginfo=info)
+                    decrypted_image_data = buffered.getvalue()
+                    response: Response = Response(content=decrypted_image_data, media_type="image/png")
+                    return response
+        
+        return await call_next(req)
+    
+def set_shared_options():
+    # 传递插件状态到前端
+    section = ("encrypt_image_is_enable",'图片加密' if shared.opts.localization == 'zh_CN' else "encrypt image" )
+    option = shared.OptionInfo(
+            default="是",
+            label='是否启用了加密插件' if shared.opts.localization == 'zh_CN' else "Whether the encryption plug-in is enabled",
+            section=section,
+        )
+    option.do_not_save = True
+    shared.opts.add_option(
+        "encrypt_image_is_enable",
+        option,
+    )
+    shared.opts.data['encrypt_image_is_enable'] = "是"
+
+def app_started_callback(_: Blocks, app: FastAPI):
+    set_shared_options()
+    
+
+if PILImage.Image.__name__ != 'EncryptedImage':
+    super_open = PILImage.open
+    super_encode_pil_to_base64 = api.encode_pil_to_base64
+    super_modules_images_save_image = images.save_image
+    super_api_middleware = api.api_middleware
+    class EncryptedImage(PILImage.Image):
+        __name__ = "EncryptedImage"
+        
+        @staticmethod
+        def from_image(image:PILImage.Image):
+            image = image.copy()
+            img = EncryptedImage()
+            img.im = image.im
+            img._mode = image.mode
+            if image.im.mode:
+                try:
+                    img.mode = image.im.mode
+                except Exception as e:
+                    ''
+            img._size = image.size
+            img.format = image.format
+            if image.mode in ("P", "PA"):
+                if image.palette:
+                    img.palette = image.palette.copy()
+                else:
+                    img.palette = ImagePalette.ImagePalette()
+            img.info = image.info.copy()
+            return img
+            
+        def save(self, fp, format=None, **params):
+            filename = ""
+            if isinstance(fp, Path):
+                filename = str(fp)
+            elif _util.is_path(fp):
+                filename = fp
+            elif fp == sys.stdout:
+                try:
+                    fp = sys.stdout.buffer
+                except AttributeError:
+                    pass
+            if not filename and hasattr(fp, "name") and _util.is_path(fp.name):
+                # only set the name for metadata purposes
+                filename = fp.name
+            
+            if not filename or not password:
+                # 如果没有密码或不保存到硬盘，直接保存
+                super().save(fp, format = format, **params)
+                return
+            
+            if 'Encrypt' in self.info and (self.info['Encrypt'] == 'pixel_shuffle' or self.info['Encrypt'] == 'pixel_shuffle_2'):
+                super().save(fp, format = format, **params)
+                return
+            
+            encrypt_image_v2(self, get_sha256(password))
+            self.format = PngImagePlugin.PngImageFile.format
+            pnginfo = params.get('pnginfo', PngImagePlugin.PngInfo())
+            if not pnginfo:
+                pnginfo = PngImagePlugin.PngInfo()
+            pnginfo.add_text('Encrypt', 'pixel_shuffle_2')
+            pnginfo.add_text('EncryptPwdSha', get_sha256(f'{get_sha256(password)}Encrypt'))
+            for key in (self.info or {}).keys():
+                if self.info[key]:
+                    pnginfo.add_text(key,str(self.info[key]))
+            params.update(pnginfo=pnginfo)
+            super().save(fp, format=self.format, **params)
+            # 保存到文件后解密内存内的图片，让直接在内存内使用时图片正常
+            dencrypt_image_v2(self, get_sha256(password))
+            
+
+
+    def open(fp,*args, **kwargs):
+        image = super_open(fp,*args, **kwargs)
+        if password and image.format.lower() == PngImagePlugin.PngImageFile.format.lower():
+            pnginfo = image.info or {}
+            if 'Encrypt' in pnginfo and pnginfo["Encrypt"] == 'pixel_shuffle':
+                dencrypt_image(image, get_sha256(password))
+                pnginfo["Encrypt"] = None
+                image = EncryptedImage.from_image(image=image)
+                return image
+            if 'Encrypt' in pnginfo and pnginfo["Encrypt"] == 'pixel_shuffle_2':
+                dencrypt_image_v2(image, get_sha256(password))
+                pnginfo["Encrypt"] = None
+                image = EncryptedImage.from_image(image=image)
+                return image
+        return EncryptedImage.from_image(image=image)
+    
+    def encode_pil_to_base64(image:PILImage.Image):
+        with io.BytesIO() as output_bytes:
+            image.save(output_bytes, format="PNG", quality=opts.jpeg_quality)
+            pnginfo = image.info or {}
+            if 'Encrypt' in pnginfo and pnginfo["Encrypt"] == 'pixel_shuffle':
+                dencrypt_image(image, get_sha256(password))
+                pnginfo["Encrypt"] = None
+            if 'Encrypt' in pnginfo and pnginfo["Encrypt"] == 'pixel_shuffle_2':
+                dencrypt_image_v2(image, get_sha256(password))
+                pnginfo["Encrypt"] = None
+            bytes_data = output_bytes.getvalue()
+        return base64.b64encode(bytes_data)
+  
+    def api_middleware(app: FastAPI):
+        super_api_middleware(app)
+        hook_http_request(app)
+  
+    if password:
+        PILImage.Image = EncryptedImage
+        PILImage.open = open
+        api.encode_pil_to_base64 = encode_pil_to_base64
+        api.api_middleware = api_middleware
+        
+if password:
+    script_callbacks.on_app_started(app_started_callback)
+    print(f'{Fore.GREEN}[-] Image Encryption started.{Style.RESET_ALL}')
+
+else:
+    print(f'{Fore.RED}[-] Image Encryption DISABLED.{Style.RESET_ALL}')

Stable-diffusion/ui/encrypt_images_info.js

@@ -0,0 +1,27 @@
+lsLoad = false;
+onUiUpdate(function () {
+  if (lsLoad) return;
+  if (!opts) return;
+  if (!opts["encrypt_image_is_enable"]) return;
+  lsLoad = true;
+  let enable = opts["encrypt_image_is_enable"] == "是";
+
+  function renderInfo(txtOrImg2img, isEnable) {
+    let info = document.getElementById("encrypt_image_" + txtOrImg2img + "2img_info");
+    let top = document.getElementById(txtOrImg2img + "2img_neg_prompt");
+    if (!top) return;
+
+    if (!info) {
+      let parent = top.parentNode;
+      info = document.createElement("div");
+      info.style.minWidth = "100%";
+      info.style.textAlign = "center";
+      info.style.opacity = 0.5;
+      info.style.fontSize = ".89em";
+      info.id = "encrypt_image_" + txtOrImg2img + "2img_info";
+      parent.insertBefore(info, top.nextSibling);
+    }
+  }
+  renderInfo("txt", enable);
+  renderInfo("img", enable);
+});

Stable-diffusion/ui/hashes.py

@@ -0,0 +1,81 @@
+import hashlib
+import os.path
+
+from modules import shared
+import modules.cache
+
+dump_cache = modules.cache.dump_cache
+cache = modules.cache.cache
+
+
+def calculate_sha256(filename):
+    hash_sha256 = hashlib.sha256()
+    blksize = 1024 * 1024
+
+    with open(filename, "rb") as f:
+        for chunk in iter(lambda: f.read(blksize), b""):
+            hash_sha256.update(chunk)
+
+    return hash_sha256.hexdigest()
+
+
+def sha256_from_cache(filename, title, use_addnet_hash=False):
+    hashes = cache("hashes-addnet") if use_addnet_hash else cache("hashes")
+    try:
+        ondisk_mtime = os.path.getmtime(filename)
+    except FileNotFoundError:
+        return None
+
+    if title not in hashes:
+        return None
+
+    cached_sha256 = hashes[title].get("sha256", None)
+    cached_mtime = hashes[title].get("mtime", 0)
+
+    if ondisk_mtime > cached_mtime or cached_sha256 is None:
+        return None
+
+    return cached_sha256
+
+
+def sha256(filename, title, use_addnet_hash=False):
+    hashes = cache("hashes-addnet") if use_addnet_hash else cache("hashes")
+
+    sha256_value = sha256_from_cache(filename, title, use_addnet_hash)
+    if sha256_value is not None:
+        return sha256_value
+
+    if shared.cmd_opts.no_hashing:
+        return None
+
+    if use_addnet_hash:
+        with open(filename, "rb") as file:
+            sha256_value = addnet_hash_safetensors(file)
+    else:
+        sha256_value = calculate_sha256(filename)
+
+    hashes[title] = {
+        "mtime": os.path.getmtime(filename),
+        "sha256": sha256_value,
+    }
+
+    dump_cache()
+
+    return sha256_value
+
+
+def addnet_hash_safetensors(b):
+    """kohya-ss hash for safetensors from https://github.com/kohya-ss/sd-scripts/blob/main/library/train_util.py"""
+    hash_sha256 = hashlib.sha256()
+    blksize = 1024 * 1024
+
+    b.seek(0)
+    header = b.read(8)
+    n = int.from_bytes(header, "little")
+
+    offset = n + 8
+    b.seek(offset)
+    for chunk in iter(lambda: b.read(blksize), b""):
+        hash_sha256.update(chunk)
+
+    return hash_sha256.hexdigest()

Stable-diffusion/ui/lora_block_weight.py

@@ -0,0 +1,1152 @@
+import cv2
+import json
+import os
+import gc
+import re
+import sys
+import torch
+import shutil
+import math
+import importlib
+import numpy as np
+import gradio as gr
+import os.path
+import random
+from pprint import pprint
+import modules.ui
+import modules.scripts as scripts
+from PIL import Image, ImageFont, ImageDraw
+import modules.shared as shared
+from modules import devices, sd_models, images,cmd_args, extra_networks, sd_hijack
+from modules.shared import cmd_opts, opts, state
+from modules.processing import process_images, Processed
+from modules.script_callbacks import CFGDenoiserParams, on_cfg_denoiser
+
+LBW_T = "customscript/lora_block_weight.py/txt2img/Active/value"
+LBW_I = "customscript/lora_block_weight.py/img2img/Active/value"
+
+if os.path.exists(cmd_opts.ui_config_file):
+    with open(cmd_opts.ui_config_file, 'r', encoding="utf-8") as json_file:
+        ui_config = json.load(json_file)
+else:
+    print("ui config file not found, using default values")
+    ui_config = {}
+
+startup_t = ui_config[LBW_T] if LBW_T in ui_config else None
+startup_i = ui_config[LBW_I] if LBW_I in ui_config else None
+active_t = "Active" if startup_t else "Not Active"
+active_i = "Active" if startup_i else "Not Active"
+
+lxyz = ""
+lzyx = ""
+prompts = ""
+xyelem = ""
+princ = False
+
+try:
+    from ldm_patched.modules import model_management
+    forge = True
+except:
+    forge = False
+
+BLOCKID26=["BASE","IN00","IN01","IN02","IN03","IN04","IN05","IN06","IN07","IN08","IN09","IN10","IN11","M00","OUT00","OUT01","OUT02","OUT03","OUT04","OUT05","OUT06","OUT07","OUT08","OUT09","OUT10","OUT11"]
+BLOCKID17=["BASE","IN01","IN02","IN04","IN05","IN07","IN08","M00","OUT03","OUT04","OUT05","OUT06","OUT07","OUT08","OUT09","OUT10","OUT11"]
+BLOCKID12=["BASE","IN04","IN05","IN07","IN08","M00","OUT00","OUT01","OUT02","OUT03","OUT04","OUT05"]
+BLOCKID20=["BASE","IN00","IN01","IN02","IN03","IN04","IN05","IN06","IN07","IN08","M00","OUT00","OUT01","OUT02","OUT03","OUT04","OUT05","OUT06","OUT07","OUT08"]
+BLOCKNUMS = [12,17,20,26]
+BLOCKIDS=[BLOCKID12,BLOCKID17,BLOCKID20,BLOCKID26]
+
+BLOCKS=["encoder",
+"diffusion_model_input_blocks_0_",
+"diffusion_model_input_blocks_1_",
+"diffusion_model_input_blocks_2_",
+"diffusion_model_input_blocks_3_",
+"diffusion_model_input_blocks_4_",
+"diffusion_model_input_blocks_5_",
+"diffusion_model_input_blocks_6_",
+"diffusion_model_input_blocks_7_",
+"diffusion_model_input_blocks_8_",
+"diffusion_model_input_blocks_9_",
+"diffusion_model_input_blocks_10_",
+"diffusion_model_input_blocks_11_",
+"diffusion_model_middle_block_",
+"diffusion_model_output_blocks_0_",
+"diffusion_model_output_blocks_1_",
+"diffusion_model_output_blocks_2_",
+"diffusion_model_output_blocks_3_",
+"diffusion_model_output_blocks_4_",
+"diffusion_model_output_blocks_5_",
+"diffusion_model_output_blocks_6_",
+"diffusion_model_output_blocks_7_",
+"diffusion_model_output_blocks_8_",
+"diffusion_model_output_blocks_9_",
+"diffusion_model_output_blocks_10_",
+"diffusion_model_output_blocks_11_",
+"embedders"]
+
+loopstopper = True
+
+ATYPES =["none","Block ID","values","seed","Original Weights","elements"]
+
+DEF_WEIGHT_PRESET = "\
+NONE:0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n\
+ALL:1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1\n\
+INS:1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0\n\
+IND:1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0\n\
+INALL:1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0\n\
+MIDD:1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0\n\
+OUTD:1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0\n\
+OUTS:1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1\n\
+OUTALL:1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1\n\
+ALL0.5:0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5"
+
+scriptpath = os.path.dirname(os.path.abspath(__file__))
+
+class Script(modules.scripts.Script):
+    def __init__(self):
+        self.log = {}
+        self.stops = {}
+        self.starts = {}
+        self.active = False
+        self.lora = {}
+        self.lycoris = {}
+        self.networks = {}
+
+        self.stopsf = []
+        self.startsf = []
+        self.uf = []
+        self.lf = []
+        self.ef = []
+
+    def title(self):
+        return "LoRA Block Weight"
+
+    def show(self, is_img2img):
+        return modules.scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        LWEIGHTSPRESETS = DEF_WEIGHT_PRESET
+
+        runorigin = scripts.scripts_txt2img.run
+        runorigini = scripts.scripts_img2img.run
+
+        scriptpath = os.path.dirname(os.path.abspath(__file__))
+        path_root = scripts.basedir()
+
+        extpath = os.path.join(scriptpath, "lbwpresets.txt")
+        extpathe = os.path.join(scriptpath, "elempresets.txt")
+        filepath = os.path.join(path_root,"scripts", "lbwpresets.txt")
+        filepathe = os.path.join(path_root,"scripts", "elempresets.txt")
+
+        if os.path.isfile(filepath) and not os.path.isfile(extpath):
+            shutil.move(filepath,extpath)
+    
+        if os.path.isfile(filepathe) and not os.path.isfile(extpathe):
+            shutil.move(filepathe,extpathe)
+
+        lbwpresets=""
+
+        try:
+            with open(extpath,encoding="utf-8") as f:
+                lbwpresets = f.read()
+        except OSError as e:
+                lbwpresets=LWEIGHTSPRESETS
+                if not os.path.isfile(extpath):
+                    try:
+                        with open(extpath,mode = 'w',encoding="utf-8") as f:
+                            f.write(lbwpresets)
+                    except:
+                        pass
+
+        try:
+            with open(extpathe,encoding="utf-8") as f:
+                elempresets = f.read()
+        except OSError as e:
+                elempresets=ELEMPRESETS
+                if not os.path.isfile(extpathe):
+                    try:
+                        with open(extpathe,mode = 'w',encoding="utf-8") as f:
+                            f.write(elempresets)
+                    except:
+                        pass
+
+        loraratios=lbwpresets.splitlines()
+        lratios={}
+        for i,l in enumerate(loraratios):
+            if checkloadcond(l) : continue
+            lratios[l.split(":")[0]]=l.split(":")[1]
+        ratiostags = [k for k in lratios.keys()]
+        ratiostags = ",".join(ratiostags)
+
+        if os.environ.get('IGNORE_CMD_ARGS_ERRORS', None) is None:
+            args = cmd_args.parser.parse_args()
+        else:
+            args, _ = cmd_args.parser.parse_known_args()
+        if args.api:
+            register()
+
+        with gr.Accordion(f"LoRA Block Weight : {active_i if is_img2img else active_t}",open = False) as acc:
+            with gr.Row():
+                with gr.Column(min_width = 50, scale=1):
+                    lbw_useblocks =  gr.Checkbox(value = True,label="Active",interactive =True,elem_id="lbw_active")
+                    debug =  gr.Checkbox(value = False,label="Debug",interactive =True,elem_id="lbw_debug")
+                with gr.Column(scale=5):
+                    bw_ratiotags= gr.TextArea(label="",value=ratiostags,visible =True,interactive =True,elem_id="lbw_ratios") 
+            with gr.Accordion("XYZ plot",open = False):
+                gr.HTML(value='<p style= "word-wrap:break-word;">changeable blocks : BASE,IN00,IN01,IN02,IN03,IN04,IN05,IN06,IN07,IN08,IN09,IN10,IN11,M00,OUT00,OUT01,OUT02,OUT03,OUT04,OUT05,OUT06,OUT07,OUT08,OUT09,OUT10,OUT11</p>')
+                xyzsetting = gr.Radio(label = "Active",choices = ["Disable","XYZ plot","Effective Block Analyzer"], value ="Disable",type = "index") 
+                with gr.Row(visible = False) as esets:
+                    diffcol = gr.Radio(label = "diff image color",choices = ["black","white"], value ="black",type = "value",interactive =True) 
+                    revxy = gr.Checkbox(value = False,label="change X-Y",interactive =True,elem_id="lbw_changexy")
+                    thresh = gr.Textbox(label="difference threshold",lines=1,value="20",interactive =True,elem_id="diff_thr")
+                xtype = gr.Dropdown(label="X Types", choices=[x for x in ATYPES], value=ATYPES [2],interactive =True,elem_id="lbw_xtype")
+                xmen = gr.Textbox(label="X Values",lines=1,value="0,0.25,0.5,0.75,1",interactive =True,elem_id="lbw_xmen")
+                ytype = gr.Dropdown(label="Y Types", choices=[y for y in ATYPES], value=ATYPES [1],interactive =True,elem_id="lbw_ytype")    
+                ymen = gr.Textbox(label="Y Values" ,lines=1,value="IN05-OUT05",interactive =True,elem_id="lbw_ymen")
+                ztype = gr.Dropdown(label="Z type", choices=[z for z in ATYPES], value=ATYPES[0],interactive =True,elem_id="lbw_ztype")    
+                zmen = gr.Textbox(label="Z values",lines=1,value="",interactive =True,elem_id="lbw_zmen")
+
+                exmen = gr.Textbox(label="Range",lines=1,value="0.5,1",interactive =True,elem_id="lbw_exmen",visible = False) 
+                eymen = gr.Textbox(label="Blocks (12ALL,17ALL,20ALL,26ALL also can be used)" ,lines=1,value="BASE,IN00,IN01,IN02,IN03,IN04,IN05,IN06,IN07,IN08,IN09,IN10,IN11,M00,OUT00,OUT01,OUT02,OUT03,OUT04,OUT05,OUT06,OUT07,OUT08,OUT09,OUT10,OUT11",interactive =True,elem_id="lbw_eymen",visible = False)  
+                ecount = gr.Number(value=1, label="number of seed", interactive=True, visible = True)           
+
+            with gr.Accordion("Weights setting",open = True):
+                with gr.Row():
+                    reloadtext = gr.Button(value="Reload Presets",variant='primary',elem_id="lbw_reload")
+                    reloadtags = gr.Button(value="Reload Tags",variant='primary',elem_id="lbw_reload")
+                    savetext = gr.Button(value="Save Presets",variant='primary',elem_id="lbw_savetext")
+                    openeditor = gr.Button(value="Open TextEditor",variant='primary',elem_id="lbw_openeditor")
+                lbw_loraratios = gr.TextArea(label="",value=lbwpresets,visible =True,interactive  = True,elem_id="lbw_ratiospreset")      
+            
+            with gr.Accordion("Elemental",open = False):  
+                with gr.Row():
+                    e_reloadtext = gr.Button(value="Reload Presets",variant='primary',elem_id="lbw_reload")
+                    e_savetext = gr.Button(value="Save Presets",variant='primary',elem_id="lbw_savetext")
+                    e_openeditor = gr.Button(value="Open TextEditor",variant='primary',elem_id="lbw_openeditor")
+                elemsets = gr.Checkbox(value = False,label="print change",interactive =True,elem_id="lbw_print_change")
+                elemental = gr.TextArea(label="Identifer:BlockID:Elements:Ratio,...,separated by empty line ",value = elempresets,interactive =True,elem_id="element") 
+
+                d_true = gr.Checkbox(value = True,visible = False)
+                d_false = gr.Checkbox(value = False,visible = False)
+            
+            lbw_useblocks.change(fn=lambda x:gr.update(label = f"LoRA Block Weight : {'Active' if x else 'Not Active'}"),inputs=lbw_useblocks, outputs=[acc])
+
+        import subprocess
+        def openeditors(b):
+            path = extpath if b else extpathe
+            subprocess.Popen(['start', path], shell=True)
+                  
+        def reloadpresets(isweight):
+            if isweight:
+                try:
+                    with open(extpath,encoding="utf-8") as f:
+                        return f.read()
+                except OSError as e:
+                    pass
+            else:
+                try:
+                    with open(extpath,encoding="utf-8") as f:
+                        return f.read()
+                except OSError as e:
+                    pass
+
+        def tagdicter(presets):
+            presets=presets.splitlines()
+            wdict={}
+            for l in presets:
+                if checkloadcond(l) : continue
+                w=[]
+                if ":" in l :
+                    key = l.split(":",1)[0]
+                    w = l.split(":",1)[1]
+                if any(len([w for w in w.split(",")]) == x for x in BLOCKNUMS):
+                    wdict[key.strip()]=w
+            return ",".join(list(wdict.keys()))
+
+        def savepresets(text,isweight):
+            if isweight:
+                with open(extpath,mode = 'w',encoding="utf-8") as f:
+                    f.write(text)
+            else:
+                with open(extpathe,mode = 'w',encoding="utf-8") as f:
+                    f.write(text)
+
+        reloadtext.click(fn=reloadpresets,inputs=[d_true],outputs=[lbw_loraratios])
+        reloadtags.click(fn=tagdicter,inputs=[lbw_loraratios],outputs=[bw_ratiotags])
+        savetext.click(fn=savepresets,inputs=[lbw_loraratios,d_true],outputs=[])
+        openeditor.click(fn=openeditors,inputs=[d_true],outputs=[])
+
+        e_reloadtext.click(fn=reloadpresets,inputs=[d_false],outputs=[elemental])
+        e_savetext.click(fn=savepresets,inputs=[elemental,d_false],outputs=[])
+        e_openeditor.click(fn=openeditors,inputs=[d_false],outputs=[])
+
+        def urawaza(active):
+            if active > 0:
+                register()
+                scripts.scripts_txt2img.run = newrun
+                scripts.scripts_img2img.run = newrun
+                if active == 1:return [*[gr.update(visible = True) for x in range(6)],*[gr.update(visible = False) for x in range(4)]]
+                else:return [*[gr.update(visible = False) for x in range(6)],*[gr.update(visible = True) for x in range(4)]]
+            else:
+                scripts.scripts_txt2img.run = runorigin
+                scripts.scripts_img2img.run = runorigini
+                return [*[gr.update(visible = True) for x in range(6)],*[gr.update(visible = False) for x in range(4)]]
+
+        xyzsetting.change(fn=urawaza,inputs=[xyzsetting],outputs =[xtype,xmen,ytype,ymen,ztype,zmen,exmen,eymen,ecount,esets])
+
+        return lbw_loraratios,lbw_useblocks,xyzsetting,xtype,xmen,ytype,ymen,ztype,zmen,exmen,eymen,ecount,diffcol,thresh,revxy,elemental,elemsets,debug
+
+    def process(self, p, loraratios,useblocks,xyzsetting,xtype,xmen,ytype,ymen,ztype,zmen,exmen,eymen,ecount,diffcol,thresh,revxy,elemental,elemsets,debug):
+        #print("self =",self,"p =",p,"presets =",loraratios,"useblocks =",useblocks,"xyzsettings =",xyzsetting,"xtype =",xtype,"xmen =",xmen,"ytype =",ytype,"ymen =",ymen,"ztype =",ztype,"zmen =",zmen)
+        #Note that this does not use the default arg syntax because the default args are supposed to be at the end of the function
+        if(loraratios == None):
+            loraratios = DEF_WEIGHT_PRESET
+        if(useblocks == None):
+            useblocks = True
+
+        lorachecker(self)
+        self.log["enable LBW"] = useblocks
+        self.log["registerd"] = registerd
+            
+        if useblocks:
+            self.active = True
+            loraratios=loraratios.splitlines()
+            elemental = elemental.split("\n\n") if elemental is not None else []
+            lratios={}
+            elementals={}
+            for l in loraratios:
+                if checkloadcond(l) : continue
+                l0=l.split(":",1)[0]
+                lratios[l0.strip()]=l.split(":",1)[1]
+            for e in elemental:
+                if ":" not in e: continue
+                e0=e.split(":",1)[0]
+                elementals[e0.strip()]=e.split(":",1)[1]
+            if elemsets : print(xyelem)
+            if xyzsetting and "XYZ" in p.prompt:
+                lratios["XYZ"] = lxyz
+                lratios["ZYX"] = lzyx
+            if xyelem != "":
+                if "XYZ" in elementals.keys():
+                    elementals["XYZ"] = elementals["XYZ"] + ","+ xyelem
+                else:
+                    elementals["XYZ"] = xyelem
+            self.lratios = lratios
+            self.elementals = elementals
+            global princ
+            princ = elemsets
+
+            if not hasattr(self,"lbt_dr_callbacks"):
+                self.lbt_dr_callbacks = on_cfg_denoiser(self.denoiser_callback)
+
+    def denoiser_callback(self, params: CFGDenoiserParams):
+        def setparams(self, key, te, u ,sets):
+            for dicts in [self.lora,self.lycoris,self.networks]:
+                for lora in dicts:
+                    if lora.name.split("_in_LBW_")[0] == key:
+                        lora.te_multiplier = te
+                        lora.unet_multiplier = u
+                        sets.append(key)
+
+        if forge and self.active:
+            if params.sampling_step in self.startsf:
+                shared.sd_model.forge_objects.unet.unpatch_model(device_to=devices.device)
+                for key, vals in shared.sd_model.forge_objects.unet.patches.items():
+                    n_vals = []
+                    lvals = [val for val in vals if val[1][0] in LORAS]
+                    for s, v, m, l, e in zip(self.startsf, lvals, self.uf, self.lf, self.ef):
+                        if s is not None and s == params.sampling_step:
+                            ratio, errormodules = ratiodealer(key.replace(".","_"), l, e)
+                            n_vals.append((ratio * m, *v[1:]))
+                        else:
+                            n_vals.append(v)
+                    shared.sd_model.forge_objects.unet.patches[key] = n_vals
+                shared.sd_model.forge_objects.unet.patch_model()
+
+            if params.sampling_step in self.stopsf:
+                shared.sd_model.forge_objects.unet.unpatch_model(device_to=devices.device)
+                for key, vals in shared.sd_model.forge_objects.unet.patches.items():
+                    n_vals = []
+                    lvals = [val for val in vals if val[1][0] in LORAS]
+                    for s, v, m, l, e in zip(self.stopsf, lvals, self.uf, self.lf, self.ef):
+                        if s is not None and s == params.sampling_step:
+                            n_vals.append((0, *v[1:]))
+                        else:
+                            n_vals.append(v)
+                    shared.sd_model.forge_objects.unet.patches[key] = n_vals
+                shared.sd_model.forge_objects.unet.patch_model()
+
+        elif self.active:
+            if self.starts and params.sampling_step == 0:
+                for key, step_te_u in self.starts.items():
+                    setparams(self, key, 0, 0, [])
+                    #print("\nstart 0", self, key, 0, 0, [])
+
+            if self.starts:
+                sets = []
+                for key, step_te_u in self.starts.items():
+                    step, te, u = step_te_u
+                    if params.sampling_step > step - 2:
+                        setparams(self, key, te, u, sets)
+                        #print("\nstart", self, key, u, te, sets)
+                for key in sets:
+                    del self.starts[key]
+
+            if self.stops:
+                sets = []
+                for key, step in self.stops.items():
+                    if params.sampling_step > step - 2:
+                        setparams(self, key, 0, 0, sets)
+                        #print("\nstop", self, key, 0, 0, sets)
+                for key in sets:
+                    del self.stops[key]
+    
+    def before_process_batch(self, p, loraratios,useblocks,*args,**kwargs):
+        if useblocks:
+            resetmemory()
+            if not self.isnet: p.disable_extra_networks = False
+            global prompts
+            prompts = kwargs["prompts"].copy()
+
+    def process_batch(self, p, loraratios,useblocks,*args,**kwargs):
+        if useblocks:
+            if not self.isnet: p.disable_extra_networks = True
+
+            o_prompts = [p.prompt]
+            for prompt in prompts:
+                if "<lora" in prompt or "<lyco" in prompt:
+                    o_prompts = prompts.copy()
+            if not self.isnet: loradealer(self, o_prompts ,self.lratios,self.elementals)
+
+    def postprocess(self, p, processed, presets,useblocks,xyzsetting,xtype,xmen,ytype,ymen,ztype,zmen,exmen,eymen,ecount,diffcol,thresh,revxy,elemental,elemsets,debug,*args):
+        if not useblocks:
+            return
+        lora = importer(self)
+        emb_db = sd_hijack.model_hijack.embedding_db
+
+        for net in lora.loaded_loras:
+            if hasattr(net,"bundle_embeddings"):
+                for emb_name, embedding in net.bundle_embeddings.items():
+                    if embedding.loaded:
+                        emb_db.register_embedding_by_name(None, shared.sd_model, emb_name)
+
+        lora.loaded_loras.clear()
+
+        if forge:
+            sd_models.model_data.get_sd_model().current_lora_hash = None
+            shared.sd_model.forge_objects_after_applying_lora.unet.unpatch_model()
+            shared.sd_model.forge_objects_after_applying_lora.clip.patcher.unpatch_model()
+
+        global lxyz,lzyx,xyelem             
+        lxyz = lzyx = xyelem = ""
+        if debug:
+            print(self.log)
+        gc.collect()
+
+    def after_extra_networks_activate(self, p, presets,useblocks, *args, **kwargs):
+        if useblocks:
+            loradealer(self, kwargs["prompts"] ,self.lratios,self.elementals,kwargs["extra_network_data"])
+
+    def run(self,p,presets,useblocks,xyzsetting,xtype,xmen,ytype,ymen,ztype,zmen,exmen,eymen,ecount,diffcol,thresh,revxy,elemental,elemsets,debug):
+        if not useblocks:
+            return
+        self.__init__()
+        self.log["pass XYZ"] = True
+        self.log["XYZsets"] = xyzsetting
+        self.log["enable LBW"] = useblocks
+
+        if xyzsetting >0:
+            lorachecker(self)
+            lora = importer(self)
+            loraratios=presets.splitlines()
+            lratios={}
+            for l in loraratios:
+                if checkloadcond(l) : continue
+                l0=l.split(":",1)[0]
+                lratios[l0.strip()]=l.split(":",1)[1]
+
+            if "XYZ" in p.prompt:
+                base = lratios["XYZ"] if "XYZ" in lratios.keys() else "1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1"
+            else: return
+
+            for i, all in enumerate(["12ALL","17ALL","20ALL","26ALL"]):
+                if eymen == all:
+                    eymen = ",".join(BLOCKIDS[i])
+
+            if xyzsetting > 1: 
+                xmen,ymen = exmen,eymen
+                xtype,ytype = "values","ID"
+                ebase = xmen.split(",")[1]
+                ebase = [ebase.strip()]*26
+                base = ",".join(ebase)
+                ztype = ""
+                if ecount > 1:
+                    ztype = "seed"
+                    zmen = ",".join([str(random.randrange(4294967294)) for x in range(int(ecount))])
+
+            #ATYPES =["none","Block ID","values","seed","Base Weights"]
+
+            def dicedealer(am):
+                for i,a in enumerate(am):
+                    if a =="-1": am[i] = str(random.randrange(4294967294))
+                print(f"the die was thrown : {am}")
+
+            if p.seed == -1: p.seed = str(random.randrange(4294967294))
+                
+            #print(f"xs:{xmen},ys:{ymen},zs:{zmen}")
+
+            def adjuster(a,at):
+                if "none" in at:a = ""
+                a = [a.strip() for a in a.split(',')]
+                if "seed" in at:dicedealer(a)
+                return a
+            
+            xs = adjuster(xmen,xtype)
+            ys = adjuster(ymen,ytype)
+            zs = adjuster(zmen,ztype)
+
+            ids = alpha =seed = ""
+            p.batch_size = 1
+
+            print(f"xs:{xs},ys:{ys},zs:{zs}")
+
+            images = []
+
+            def weightsdealer(alpha,ids,base):
+                #print(f"weights from : {base}")
+                ids = [z.strip() for z in ids.split(' ')]
+                weights_t = [w.strip() for w in base.split(',')]
+                blockid =  BLOCKIDS[BLOCKNUMS.index(len(weights_t))] 
+                if ids[0]!="NOT":
+                    flagger=[False]*len(weights_t)
+                    changer = True
+                else:
+                    flagger=[True]*len(weights_t)
+                    changer = False
+                for id in ids:
+                    if id =="NOT":continue
+                    if "-" in id:
+                        it = [it.strip() for it in id.split('-')]
+                        if  blockid.index(it[1]) > blockid.index(it[0]):
+                            flagger[blockid.index(it[0]):blockid.index(it[1])+1] = [changer]*(blockid.index(it[1])-blockid.index(it[0])+1)
+                        else:
+                            flagger[blockid.index(it[1]):blockid.index(it[0])+1] = [changer]*(blockid.index(it[0])-blockid.index(it[1])+1)
+                    else:
+                        flagger[blockid.index(id)] =changer    
+                for i,f in enumerate(flagger):
+                    if f:weights_t[i]=alpha
+                outext = ",".join(weights_t)
+                #print(f"weights changed: {outext}")
+                return outext
+
+            generatedbases=[]
+            def xyzdealer(a,at):
+                nonlocal ids,alpha,p,base,c_base,generatedbases
+                if "ID" in at:return
+                if "values" in at:alpha = a
+                if "seed" in at:
+                    p.seed = int(a)
+                    generatedbases=[]
+                if "Weights" in at:base =c_base = lratios[a]
+                if "elements" in at:
+                    global xyelem
+                    xyelem = a
+
+            def imagedupewatcher(baselist,basetocheck,currentiteration):
+                for idx,alreadygenerated in enumerate(baselist):
+                    if (basetocheck == alreadygenerated):
+                        # E.g., we already generated IND+OUTS and this is now OUTS+IND with identical weights.
+                        baselist.insert(currentiteration-1, basetocheck)
+                        return idx
+                return -1
+
+            def strThree(someNumber): # Returns 1.12345 as 1.123 and 1.0000 as 1
+                return format(someNumber, ".3f").rstrip('0').rstrip('.')
+
+            # Adds X and Y together using array addition.
+            # If both X and Y have a value in the same block then Y's is set to 0;
+            # both values are used due to both XY and YX being generated, but the diagonal then only show the first value.
+            # imagedupwatcher prevents duplicate images from being generated;
+            # when X and Y have non-overlapping blocks then the upper triangular images are identical to the lower ones.
+            def xyoriginalweightsdealer(x,y):
+                xweights = np.asarray(lratios[x].split(','), dtype=np.float32) # np array easier to add later
+                yweights = np.asarray(lratios[y].split(','), dtype=np.float32)
+                for idx,xval in np.ndenumerate(xweights):
+                    yval = yweights[idx]
+                    if xval != 0 and yval != 0:
+                        yweights[idx] = 0
+                # Add xweights to yweights, round to 3 places,
+                # map floats to string with format of 3 decimals trailing zeroes and decimal stripped
+                baseListToStrings = list(map(strThree, np.around(np.add(xweights,yweights,),3).tolist()))
+                return ",".join(baseListToStrings)
+
+            grids = []
+            images =[]
+
+            totalcount = len(xs)*len(ys)*len(zs) if xyzsetting < 2 else len(xs)*len(ys)*len(zs)  //2 +1
+            shared.total_tqdm.updateTotal(totalcount)
+            xc = yc =zc = 0
+            state.job_count = totalcount 
+            totalcount = len(xs)*len(ys)*len(zs)
+            c_base = base
+
+            for z in zs:
+                generatedbases=[] 
+                images = []
+                yc = 0
+                xyzdealer(z,ztype)
+                for y in ys:
+                    xc = 0
+                    xyzdealer(y,ytype)
+                    for x in xs:
+                        xyzdealer(x,xtype)
+                        if "Weights" in xtype and "Weights" in ytype:
+                            c_base = xyoriginalweightsdealer(x,y)
+                        else:
+                            if "ID" in xtype:
+                                if "values" in ytype:c_base = weightsdealer(y,x,base)
+                                if "values" in ztype:c_base = weightsdealer(z,x,base)
+                            if "ID" in ytype:
+                                if "values" in xtype:c_base = weightsdealer(x,y,base)
+                                if "values" in ztype:c_base = weightsdealer(z,y,base)
+                        if "ID" in ztype:
+                            if "values" in xtype:c_base = weightsdealer(x,z,base)
+                            if "values" in ytype:c_base = weightsdealer(y,z,base)
+
+                        iteration = len(xs)*len(ys)*zc + yc*len(xs) +xc +1
+                        print(f"X:{xtype}, {x},Y: {ytype},{y}, Z:{ztype},{z}, base:{c_base} ({iteration}/{totalcount})")
+
+                        dupe_index = imagedupewatcher(generatedbases,c_base,iteration)
+                        if dupe_index > -1:
+                            print(f"Skipping generation of duplicate base:{c_base}")
+                            images.append(images[dupe_index].copy())
+                            xc += 1
+                            continue
+
+                        global lxyz,lzyx
+                        lxyz = c_base
+
+                        cr_base = c_base.split(",")
+                        cr_base_t=[]
+                        for x in cr_base:
+                            if not identifier(x):
+                                cr_base_t.append(str(1-float(x)))
+                            else:
+                                cr_base_t.append(x)
+                        lzyx = ",".join(cr_base_t)
+
+                        if not(xc == 1 and not (yc ==0 ) and xyzsetting >1):
+                            lora.loaded_loras.clear()
+                            p.cached_c = [None,None]
+                            p.cached_uc = [None,None]
+                            p.cached_hr_c = [None, None]
+                            p.cached_hr_uc = [None, None]
+                            processed:Processed = process_images(p)
+                            images.append(processed.images[0])
+                            generatedbases.insert(iteration-1, c_base)
+                        xc += 1
+                    yc += 1
+                zc += 1
+                origin = loranames(processed.all_prompts) + ", "+ znamer(ztype,z,base)
+                images,xst,yst = effectivechecker(images,xs.copy(),ys.copy(),diffcol,thresh,revxy) if xyzsetting >1 else (images,xs.copy(),ys.copy())
+                grids.append(smakegrid(images,xst,yst,origin,p))
+            processed.images= grids
+            lora.loaded_loras.clear()
+            return processed
+
+def identifier(char):
+    return char[0] in ["R", "U", "X"]
+
+def znamer(at,a,base):
+    if "ID" in at:return f"Block : {a}"
+    if "values" in at:return f"value : {a}"
+    if "seed" in at:return f"seed : {a}"
+    if "Weights" in at:return f"original weights :\n {base}"
+    else: return ""
+
+def loranames(all_prompts):
+    _, extra_network_data = extra_networks.parse_prompts(all_prompts[0:1])
+    calledloras = extra_network_data["lora"] if "lyco" not in extra_network_data.keys() else extra_network_data["lyco"]
+    names = ""
+    for called in calledloras:
+        if len(called.items) <3:continue
+        names += called.items[0] 
+    return names
+
+def lorachecker(self):
+    try:
+        import networks
+        self.isnet = True
+        self.layer_name = "network_layer_name"
+    except:
+        self.isnet = False
+        self.layer_name = "lora_layer_name"  
+    try:
+        import lora
+        self.islora = True
+    except:
+        pass
+    try:
+        import lycoris
+        self.islyco = True
+    except:
+        pass
+    self.onlyco = (not self.islora) and self.islyco
+    self.isxl = hasattr(shared.sd_model,"conditioner")
+    
+    self.log["isnet"] = self.isnet 
+    self.log["isxl"] = self.isxl
+    self.log["islora"] = self.islora
+
+def resetmemory():
+    try:
+        import networks as nets
+        nets.networks_in_memory = {}
+        gc.collect()
+
+    except:
+        pass
+
+def importer(self):
+    if self.onlyco:
+        # lycorisモジュールを動的にインポート
+        lora_module = importlib.import_module("lycoris")
+        return lora_module
+    else:
+        # loraモジュールを動的にインポート
+        lora_module = importlib.import_module("lora")
+        return lora_module
+
+def loradealer(self, prompts,lratios,elementals, extra_network_data = None):
+    if extra_network_data is None:
+        _, extra_network_data = extra_networks.parse_prompts(prompts)
+    moduletypes = extra_network_data.keys()
+
+    for ltype in moduletypes:
+        lorans = []
+        lorars = []
+        te_multipliers = []
+        unet_multipliers = []
+        elements = []
+        starts = []
+        stops = []
+        fparams = []
+        load = False
+        go_lbw = False
+        
+        if not (ltype == "lora" or ltype == "lyco") : continue
+        for called in extra_network_data[ltype]:
+            items = called.items
+            setnow = False
+            name = items[0]
+            te = syntaxdealer(items,"te=",1)
+            unet = syntaxdealer(items,"unet=",2)
+            te,unet = multidealer(te,unet)
+
+            weights = syntaxdealer(items,"lbw=",2) if syntaxdealer(items,"lbw=",2) is not None else syntaxdealer(items,"w=",2)
+            elem = syntaxdealer(items, "lbwe=",3)
+            start = syntaxdealer(items,"start=",None)
+            stop = syntaxdealer(items,"stop=",None)
+            start, stop = stepsdealer(syntaxdealer(items,"step=",None), start, stop)
+            
+            if weights is not None and (weights in lratios or any(weights.count(",") == x - 1 for x in BLOCKNUMS)):
+                wei = lratios[weights] if weights in lratios else weights
+                ratios = [w.strip() for w in wei.split(",")]
+                for i,r in enumerate(ratios):
+                    if r =="R":
+                        ratios[i] = round(random.random(),3)
+                    elif r == "U":
+                        ratios[i] = round(random.uniform(-0.5,1.5),3)
+                    elif r[0] == "X":
+                        base = syntaxdealer(items,"x=", 3) if len(items) >= 4 else 1
+                        ratios[i] = getinheritedweight(base, r)
+                    else:
+                        ratios[i] = float(r)
+                        
+                if len(ratios) != 26:
+                    ratios = to26(ratios)
+                setnow = True
+            else:
+                ratios = [1] * 26
+
+            if elem in elementals:
+                setnow = True
+                elem = elementals[elem]
+            else:
+                elem = ""
+
+            if setnow:
+                go_lbw = True
+            fparams.append([unet,ratios,elem])
+            settolist([lorans,te_multipliers,unet_multipliers,lorars,elements,starts,stops],[name,te,unet,ratios,elem,start,stop])
+
+            if start:
+                self.starts[name] = [int(start),te,unet]
+                self.log["starts"] = load = True
+
+            if stop:
+                self.stops[name] = int(stop)
+                self.log["stops"] = load = True
+        
+        self.startsf = [int(s) if s is not None else None for s in starts]
+        self.stopsf = [int(s) if s is not None else None for s in stops]
+        self.uf = unet_multipliers
+        self.lf = lorars
+        self.ef = elements
+
+        if self.isnet: ltype = "nets"
+        if forge: ltype = "forge"
+        if go_lbw or load: load_loras_blocks(self, lorans,lorars,te_multipliers,unet_multipliers,elements,ltype, starts=starts)
+
+def stepsdealer(step, start, stop):
+    if step is None or "-" not in step:
+        return start, stop
+    return step.split("-")
+
+def settolist(ls,vs):
+    for l, v in zip(ls,vs):
+        l.append(v)
+
+def syntaxdealer(items,target,index): #type "unet=", "x=", "lwbe=" 
+    for item in items:
+        if target in item:
+            return item.replace(target,"")
+    if index is None or index + 1> len(items): return None
+    if "=" in items[index]:return None
+    return items[index] if "@" not in items[index] else 1
+
+def isfloat(t):
+    try:
+        float(t)
+        return True
+    except:
+        return False
+
+def multidealer(t, u):
+    if t is None and u is None:
+        return 1,1
+    elif t is None:
+        return float(u),float(u)
+    elif u is None:
+        return float(t), float(t)
+    else:
+        return float(t),float(u)
+
+re_inherited_weight = re.compile(r"X([+-])?([\d.]+)?")
+
+def getinheritedweight(weight, offset):
+    match = re_inherited_weight.search(offset)
+    if match.group(1) == "+":
+        return float(weight) + float(match.group(2))
+    elif match.group(1) == "-":
+        return float(weight) - float(match.group(2))  
+    else:
+        return float(weight) 
+
+def load_loras_blocks(self, names, lwei,te,unet,elements,ltype = "lora", starts = None):
+    oldnew=[]
+    if "lora" == ltype:
+        lora = importer(self)
+        self.lora = lora.loaded_loras
+        for loaded in lora.loaded_loras:
+            for n, name in enumerate(names):
+                if name == loaded.name:
+                    if lwei[n] == [1] * 26 and elements[n] == "": continue
+                    lbw(loaded,lwei[n],elements[n])
+                    setall(loaded,te[n],unet[n])
+                    newname = loaded.name +"_in_LBW_"+ str(round(random.random(),3))
+                    oldname = loaded.name
+                    loaded.name = newname
+                    oldnew.append([oldname,newname])
+
+    elif "lyco" == ltype:
+        import lycoris as lycomo
+        self.lycoris = lycomo.loaded_lycos
+        for loaded in lycomo.loaded_lycos:
+            for n, name in enumerate(names):
+                if name == loaded.name:
+                    lbw(loaded,lwei[n],elements[n])
+                    setall(loaded,te[n],unet[n])
+
+    elif "nets" == ltype:
+        import networks as nets
+        self.networks = nets.loaded_networks
+        for loaded in nets.loaded_networks:
+            for n, name in enumerate(names):
+                if name == loaded.name:
+                    lbw(loaded,lwei[n],elements[n])
+                    setall(loaded,te[n],unet[n])
+    
+    elif "forge" == ltype:
+        lbwf(te, unet, lwei, elements, starts)
+
+    try:
+        import lora_ctl_network as ctl
+        for old,new in oldnew:
+            if old in ctl.lora_weights.keys():
+                ctl.lora_weights[new] = ctl.lora_weights[old]
+    except:
+        pass
+
+def setall(m,te,unet):
+    m.name = m.name + "_in_LBW_"+ str(round(random.random(),3))
+    m.te_multiplier = te
+    m.unet_multiplier = unet
+    m.multiplier = unet
+
+def smakegrid(imgs,xs,ys,currentmodel,p):
+    ver_texts = [[images.GridAnnotation(y)] for y in ys]
+    hor_texts = [[images.GridAnnotation(x)] for x in xs]
+
+    w, h = imgs[0].size
+    grid = Image.new('RGB', size=(len(xs) * w, len(ys) * h), color='black')
+
+    for i, img in enumerate(imgs):
+        grid.paste(img, box=(i % len(xs) * w, i // len(xs) * h))
+
+    grid = images.draw_grid_annotations(grid,w, h, hor_texts, ver_texts)
+    grid = draw_origin(grid, currentmodel,w*len(xs),h*len(ys),w)
+    if opts.grid_save:
+        images.save_image(grid, opts.outdir_txt2img_grids, "xy_grid", extension=opts.grid_format, prompt=p.prompt, seed=p.seed, grid=True, p=p)
+
+    return grid
+
+def get_font(fontsize):
+    fontpath = os.path.join(scriptpath, "Roboto-Regular.ttf")
+    try:
+        return ImageFont.truetype(opts.font or fontpath, fontsize)
+    except Exception:
+        return ImageFont.truetype(fontpath, fontsize)
+
+def draw_origin(grid, text,width,height,width_one):
+    grid_d= Image.new("RGB", (grid.width,grid.height), "white")
+    grid_d.paste(grid,(0,0))
+
+    d= ImageDraw.Draw(grid_d)
+    color_active = (0, 0, 0)
+    fontsize = (width+height)//25
+    fnt = get_font(fontsize)
+
+    if grid.width != width_one:
+        while d.multiline_textsize(text, font=fnt)[0] > width_one*0.75 and fontsize > 0:
+            fontsize -=1
+            fnt = get_font(fontsize)
+    d.multiline_text((0,0), text, font=fnt, fill=color_active,align="center")
+    return grid_d
+
+def newrun(p, *args):
+        script_index = args[0]
+
+        if args[0] ==0:
+            script = None
+            for obj in scripts.scripts_txt2img.alwayson_scripts:
+                if "lora_block_weight" in obj.filename:
+                    script = obj 
+                    script_args = args[script.args_from:script.args_to]
+        else:
+            script = scripts.scripts_txt2img.selectable_scripts[script_index-1]
+            
+            if script is None:
+                return None
+
+            script_args = args[script.args_from:script.args_to]
+
+        processed = script.run(p, *script_args)
+
+        shared.total_tqdm.clear()
+
+        return processed
+
+registerd = False
+
+def register():
+    global registerd
+    registerd = True
+    for obj in scripts.scripts_txt2img.alwayson_scripts:
+        if "lora_block_weight" in obj.filename:
+            if obj not in scripts.scripts_txt2img.selectable_scripts:
+                scripts.scripts_txt2img.selectable_scripts.append(obj)
+                scripts.scripts_txt2img.titles.append("LoRA Block Weight")
+    for obj in scripts.scripts_img2img.alwayson_scripts:
+        if "lora_block_weight" in obj.filename:
+            if obj not in scripts.scripts_img2img.selectable_scripts:
+                scripts.scripts_img2img.selectable_scripts.append(obj)
+                scripts.scripts_img2img.titles.append("LoRA Block Weight")
+
+def effectivechecker(imgs,ss,ls,diffcol,thresh,revxy):
+    orig = imgs[1]
+    imgs = imgs[::2]
+    diffs = []
+    outnum =[]
+
+    for img in imgs:
+        abs_diff = cv2.absdiff(np.array(img) ,  np.array(orig))
+
+        abs_diff_t = cv2.threshold(abs_diff, int(thresh), 255, cv2.THRESH_BINARY)[1]        
+        res = abs_diff_t.astype(np.uint8)
+        percentage = (np.count_nonzero(res) * 100)/ res.size
+        if "white" in diffcol: abs_diff = cv2.bitwise_not(abs_diff)
+        outnum.append(percentage)
+
+        abs_diff = Image.fromarray(abs_diff)     
+
+        diffs.append(abs_diff)
+            
+    outs = []
+    for i in range(len(ls)):
+        ls[i] = ls[i] + "\n Diff : " + str(round(outnum[i],3)) + "%"
+
+    if not revxy:
+        for diff,img in zip(diffs,imgs):
+            outs.append(diff)
+            outs.append(img)
+            outs.append(orig)
+        ss = ["diff",ss[0],"source"]
+        return outs,ss,ls
+    else:
+        outs = [orig]*len(diffs)  + imgs + diffs
+        ss = ["source",ss[0],"diff"]
+        return outs,ls,ss
+
+def lbw(lora,lwei,elemental):
+    elemental = elemental.split(",")
+    for key in lora.modules.keys():
+        ratio, errormodules = ratiodealer(key, lwei, elemental)
+
+        ltype = type(lora.modules[key]).__name__
+        set = False
+        if ltype in LORAANDSOON.keys():
+            if "OFT" not in ltype:
+                setattr(lora.modules[key],LORAANDSOON[ltype],torch.nn.Parameter(getattr(lora.modules[key],LORAANDSOON[ltype]) * ratio))
+            else:
+                setattr(lora.modules[key],LORAANDSOON[ltype],getattr(lora.modules[key],LORAANDSOON[ltype]) * ratio)
+            set = True
+        else:
+            if hasattr(lora.modules[key],"up_model"):
+                lora.modules[key].up_model.weight= torch.nn.Parameter(lora.modules[key].up_model.weight *ratio)
+                #print("LoRA using LoCON")
+                set = True
+            else:
+                lora.modules[key].up.weight= torch.nn.Parameter(lora.modules[key].up.weight *ratio)
+                #print("LoRA")
+                set = True
+        if not set : 
+            print("unkwon LoRA")
+
+    if len(errormodules) > 0:
+        print(errormodules)
+    return lora
+
+LORAS = ["lora", "loha", "lokr"]
+
+def lbwf(mt, mu, lwei, elemental, starts):
+    for key, vals in shared.sd_model.forge_objects_after_applying_lora.unet.patches.items():
+        n_vals = []
+        lvals = [val for val in vals if val[1][0] in LORAS]
+        for v, m, l, e ,s in zip(lvals, mu, lwei, elemental, starts):
+            ratio, errormodules = ratiodealer(key.replace(".","_"), l, e)
+            n_vals.append((ratio * m if s is None else 0, *v[1:]))
+        shared.sd_model.forge_objects_after_applying_lora.unet.patches[key] = n_vals
+
+    for key, vals in shared.sd_model.forge_objects_after_applying_lora.clip.patcher.patches.items():
+        n_vals = []
+        lvals = [val for val in vals if val[1][0] in LORAS]
+        for v, m, l, e in zip(lvals, mt, lwei, elemental):
+            ratio, errormodules = ratiodealer(key.replace(".","_"), l, e)
+            n_vals.append((ratio * m, *v[1:]))
+        shared.sd_model.forge_objects_after_applying_lora.clip.patcher.patches[key] = n_vals  
+
+def ratiodealer(key, lwei, elemental):
+    ratio = 1
+    picked = False
+    errormodules = []
+    currentblock = 0
+    
+    for i,block in enumerate(BLOCKS):
+        if block in key:
+            if i == 26:
+                i = 0
+            ratio = lwei[i] 
+            picked = True
+            currentblock = i
+
+    if not picked:
+        errormodules.append(key)
+
+    if len(elemental) > 0:
+        skey = key + BLOCKID26[currentblock]
+        for d in elemental:
+            if d.count(":") != 2 :continue
+            dbs,dws,dr = (hyphener(d.split(":")[0]),d.split(":")[1],d.split(":")[2])
+            dbs,dws = (dbs.split(" "), dws.split(" "))
+            dbn,dbs = (True,dbs[1:]) if dbs[0] == "NOT" else (False,dbs)
+            dwn,dws = (True,dws[1:]) if dws[0] == "NOT" else (False,dws)
+            flag = dbn
+            for db in dbs:
+                if db in skey:
+                    flag = not dbn
+            if flag:flag = dwn
+            else:continue
+            for dw in dws:
+                if dw in skey:
+                    flag = not dwn
+            if flag:
+                dr = float(dr)
+                if princ :print(dbs,dws,key,dr)
+                ratio = dr
+    
+    return ratio, errormodules
+
+LORAANDSOON = {
+    "LoraHadaModule" : "w1a",
+    "LycoHadaModule" : "w1a",
+    "NetworkModuleHada": "w1a",
+    "FullModule" : "weight",
+    "NetworkModuleFull": "weight",
+    "IA3Module" : "w",
+    "NetworkModuleIa3" : "w",
+    "LoraKronModule" : "w1",
+    "LycoKronModule" : "w1",
+    "NetworkModuleLokr": "w1",
+    "NetworkModuleGLora": "w1a",
+    "NetworkModuleNorm": "w_norm",
+    "NetworkModuleOFT": "scale"
+}
+
+def hyphener(t):
+    t = t.split(" ")
+    for i,e in enumerate(t):
+        if "-" in e:
+            e = e.split("-")
+            if  BLOCKID26.index(e[1]) > BLOCKID26.index(e[0]):
+                t[i] = " ".join(BLOCKID26[BLOCKID26.index(e[0]):BLOCKID26.index(e[1])+1])
+            else:
+                t[i] = " ".join(BLOCKID26[BLOCKID26.index(e[1]):BLOCKID26.index(e[0])+1])
+    return " ".join(t)
+
+ELEMPRESETS="\
+ATTNDEEPON:IN05-OUT05:attn:1\n\n\
+ATTNDEEPOFF:IN05-OUT05:attn:0\n\n\
+PROJDEEPOFF:IN05-OUT05:proj:0\n\n\
+XYZ:::1"
+
+def to26(ratios):
+    ids = BLOCKIDS[BLOCKNUMS.index(len(ratios))]
+    output = [0]*26
+    for i, id in enumerate(ids):
+        output[BLOCKID26.index(id)] = ratios[i]
+    return output
+
+def checkloadcond(l:str)->bool:
+    # ここの条件分岐は読み込んだ行がBlock Waightの書式にあっているかを確認している。
+    # [:]が含まれ、16個(LoRa)か25個(LyCORIS),11,19(XL),のカンマが含まれる形式であるうえ、
+    # それがコメントアウト行(# foobar)でないことが求められている。
+    # 逆に言うとコメントアウトしたいなら絶対"# "から始めることを要求している。
+
+    # This conditional branch is checking whether the loaded line conforms to the Block Weight format.
+    # It is required that "[:]" is included, and the format contains either 16 commas (for LoRa) or 25 commas (for LyCORIS),
+    # and it's not a comment line (e.g., "# foobar").
+    # Conversely, if you want to comment out, it requires that it absolutely starts with "# ".
+    res=(":" not in l) or (not any(l.count(",") == x - 1  for x in BLOCKNUMS)) or ("#" in l)
+    #print("[debug]", res,repr(l))
+    return res

Stable-diffusion/ui/nenen88.py

@@ -0,0 +1,52 @@
+import os, sys, time, shlex, subprocess
+from IPython import get_ipython
+from pathlib import Path
+
+xxx = Path("/kaggle/working")
+zzz = Path("/kaggle/working/asd")
+tmp = Path("/kaggle/temp")
+
+pantat = f"curl -sLo {xxx}/pantat88.py https://raw.githubusercontent.com/gutris1/segsmaker/main/kaggle/script/pantat88.py"
+get_ipython().system(pantat)
+
+sys.path.append(str(xxx))
+from pantat88 import pull, say, download
+
+def nenen():
+    os.chdir(zzz)
+    say("【 {red} Installing Stable Diffusion {d} 】 {red}")
+    
+    time.sleep(2)
+    pull(f"https://github.com/gutris1/segsmaker asd {zzz}")
+    
+    req_list = [
+        f"https://huggingface.co/pantat88/ui/resolve/main/embeddings.zip {zzz}",
+        f"https://huggingface.co/pantat88/ui/resolve/main/4x-UltraSharp.pth {zzz}/models/ESRGAN",
+        f"https://huggingface.co/pantat88/ui/resolve/main/4x-AnimeSharp.pth {zzz}/models/ESRGAN",
+        f"https://huggingface.co/pantat88/ui/resolve/main/4x_NMKD-Superscale-SP_178000_G.pth {zzz}/models/ESRGAN",
+        f"https://huggingface.co/pantat88/ui/resolve/main/4x_RealisticRescaler_100000_G.pth {zzz}/models/ESRGAN",
+        f"https://huggingface.co/pantat88/ui/resolve/main/8x_RealESRGAN.pth {zzz}/models/ESRGAN",
+        f"https://huggingface.co/pantat88/ui/resolve/main/4x_foolhardy_Remacri.pth {zzz}/models/ESRGAN",
+        f"https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.safetensors {zzz}/models/VAE"]
+    
+    for lines in req_list:
+        download(lines)
+    
+    unzip = f"unzip -qo {zzz}/embeddings.zip -d {zzz}/embeddings && rm {zzz}/embeddings.zip"
+    get_ipython().system(unzip)
+    
+    cmd = [
+        f"rm -rf {tmp}/* {zzz}/models/Stable-diffusion/tmp_ckpt {zzz}/models/Lora/tmp_lora {zzz}/outputs",
+        f"mkdir -p {zzz}/models/Lora",
+        f"ln -vs {tmp}/ckpt {zzz}/models/Stable-diffusion/tmp_ckpt",
+        f"ln -vs {tmp}/lora {zzz}/models/Lora/tmp_lora",
+        f"ln -vs {tmp}/outputs {zzz}/outputs",
+        f"mkdir -p {tmp}/ckpt {tmp}/lora {tmp}/outputs {tmp}/svd {tmp}/z123"]
+    
+    for lines in cmd:
+        subprocess.run(shlex.split(lines), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+nenen()
+(xxx / 'nenen88.py').unlink()
+get_ipython().run_line_magic('run', f'{xxx}/pantat88.py')
+os.chdir(xxx)

Stable-diffusion/ui/venv.py

@@ -0,0 +1,77 @@
+import subprocess, sys, os, time, errno, shlex
+from IPython.display import clear_output, Image, display
+from IPython import get_ipython
+from pathlib import Path
+
+xxx = Path('/kaggle/working')
+script = xxx / 'venv.py'
+img = xxx / "loading.png"
+vnv = Path('/kaggle/venv')
+url = 'https://huggingface.co/pantat88/back_up/resolve/main/venv-torch241-cu121.tar.lz4'
+fn = Path(url).name
+
+os.chdir(xxx)
+sys.path.append(str(xxx))
+
+get_ipython().system('curl -sLO https://raw.githubusercontent.com/gutris1/segsmaker/main/script/loading.png')
+get_ipython().system('curl -sLO https://raw.githubusercontent.com/gutris1/segsmaker/main/kaggle/script/pantat88.py')
+display(Image(filename=str(img)))
+time.sleep(1)
+
+from pantat88 import say, download
+say('【{red} Installing VENV{d} 】{red}')
+
+req_list = [
+    "curl -LO https://github.com/DEX-1101/sd-webui-notebook/raw/main/res/new_tunnel",
+    "curl -Lo /usr/bin/cl https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64",
+    "apt-get update",
+    "apt -y install pv",
+    "pip install -q aria2 cloudpickle",
+    "chmod +x /usr/bin/cl"
+]
+
+for items in req_list:
+    subprocess.run(shlex.split(items), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+def she_bang():
+    vnv_bin = vnv / 'bin'
+    old_shebang = b'#!/home/studio-lab-user/tmp/venv/bin/python3\n'
+    new_shebang = f"#!{vnv}/bin/python3\n"
+    
+    for script in vnv_bin.glob('*'):
+        if script.is_file():
+            try:
+                with open(script, 'r+b') as file:
+                    lines = file.readlines()
+                    if lines and lines[0] == old_shebang:
+                        lines[0] = new_shebang.encode('utf-8')
+                        file.seek(0)
+                        file.writelines(lines)
+                        file.truncate()
+                        print(f"Updated shebang in {script.name} to {new_shebang.strip()}")
+
+            except OSError as e:
+                if e.errno == 26:
+                    print(f"Skipped {script.name}")
+                else:
+                    print(f"Failed to update {script.name}: {e}")
+
+def venv_install():
+    os.chdir('/kaggle')
+    download(url)
+    
+    extract_venv = f'pv {fn} | lz4 -d | tar xf -'
+    get_ipython().system(extract_venv)
+    Path(fn).unlink()
+
+    get_ipython().system(f'rm -rf {vnv / "bin" / "pip*"}')
+    get_ipython().system(f'rm -rf {vnv / "bin" / "python*"}')
+    get_ipython().system(f'python3 -m venv {vnv}')
+    get_ipython().system(f'{vnv}/bin/python3 -m pip install -q --upgrade --force-reinstall pip')
+
+venv_install()
+she_bang()
+
+clear_output(wait=True)
+script.unlink()
+os.chdir(xxx)

Stable-diffusion/ui/venv161.py

@@ -0,0 +1,97 @@
+import subprocess
+import select
+import errno
+import pty
+import sys
+import os
+import re
+
+xxx = "/kaggle/working"
+zzz = "/kaggle/working/asd"
+
+os.system(f'wget -q https://raw.githubusercontent.com/gutris1/segsmaker/main/kaggle/script/pantat88.py -O {xxx}/pantat88.py')
+sys.path.append(xxx)
+
+def venv_in():
+    from pantat88 import say
+    os.chdir('/kaggle')
+    say('【 {red} Installing VENV {d} 】 {red}')
+    os.system('apt -y install lz4 pv aria2 > /dev/null 2>&1')
+    url = 'https://huggingface.co/pantat88/back_up/resolve/main/venv-1_6_1.tar.lz4'
+    fn = 'venv-1_6_1.tar.lz4'
+    fc = f"aria2c --console-log-level=error --summary-interval=1 -c -x16 -s16 -k1M -j5 '{url}' -o '{fn}'"
+    woiii, appaa = pty.openpty()
+    qqqqq = subprocess.Popen(fc, shell=True, stdin=appaa, stdout=appaa, stderr=subprocess.STDOUT, close_fds=True)
+    os.close(appaa)
+
+    malam = ""
+    while True:
+        r, _, _ = select.select([woiii], [], [], 0.1)
+        if woiii in r:
+            try:
+                petualangan = os.read(woiii, 8192).decode()
+                malam += petualangan
+                for minggu in petualangan.splitlines():
+                    if re.match(r'\[#\w{6}\s.*\]', minggu):
+                        sys.stdout.write("\r" + " "*80 + "\r")
+                        sys.stdout.write(f"  {minggu}")
+                        sys.stdout.flush()
+                        break
+                        
+            except OSError as e:
+                if e.errno == errno.EIO:
+                    break
+
+        if qqqqq.poll() is not None and not r:
+            break
+                   
+    kemarin = malam.find("Download Results:")
+    if kemarin != -1:
+        hhhhh = malam[kemarin:]
+        jjjjj = hhhhh.splitlines()
+        kkkkk = False
+        for ggggg in jjjjj:
+            if ggggg.strip().startswith("======+====+==========="):
+                kkkkk = True
+                print("\n" + f"  {ggggg}")
+                continue
+            elif ggggg.strip().startswith("Status Legend:"):
+                break
+            elif kkkkk:
+                print(f"  {ggggg}")
+
+    qqqqq.wait()
+    os.close(woiii)
+    
+    extract_tar = f'pv {fn} | lz4 -d | tar xf -'
+    
+    ikan, asin = pty.openpty()
+    proc = subprocess.Popen(extract_tar, shell=True, stdin=asin, stdout=asin, stderr=asin, close_fds=True)
+    os.close(asin)
+
+    while True:
+        r, _, _ = select.select([ikan], [], [], 0.1)
+        if ikan in r:
+            try:
+                jemuran = os.read(ikan, 1024).decode('utf-8', 'ignore')
+                print(jemuran, end='')
+            except OSError as e:
+                if e.errno == errno.EIO:
+                    break
+        if proc.poll() is not None:
+            break
+
+    proc.wait()
+    os.close(ikan)
+    os.remove(fn)
+    
+    oppai = '/kaggle/venv'
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "pip*")}')
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "python*")}')
+    os.system(f'python -m venv {oppai}')
+    say('【 {red} Setup Completed {d} 】 {red}')
+
+if __name__ == '__main__':
+    venv_in()
+    assu = os.path.join(xxx, 'venv.py')
+    os.remove(assu)

Stable-diffusion/ui/venv180.py

@@ -0,0 +1,105 @@
+import subprocess
+import select
+import errno
+import pty
+import sys
+import os
+import re
+
+xxx = "/kaggle/working"
+zzz = "/kaggle/working/asd"
+
+os.system('apt-get update > /dev/null 2>&1')
+os.system('apt -y install lz4 pv aria2 > /dev/null 2>&1')
+
+os.system(f'curl -sLo {xxx}/pantat88.py https://raw.githubusercontent.com/gutris1/segsmaker/main/kaggle/script/pantat88.py')
+os.system(f'curl -sLo {xxx}/nenen88.py https://huggingface.co/pantat88/ui/resolve/main/nenen88.py')
+sys.path.append(xxx)
+
+def venv_in():
+    from pantat88 import say
+    os.chdir('/kaggle')
+    say('【 {red} Installing VENV {d} 】 {red}')
+
+    url = 'https://huggingface.co/pantat88/back_up/resolve/main/venv-1_8_0.tar.lz4'
+    fn = 'venv-1_8_0.tar.lz4'
+    fc = f"aria2c --console-log-level=error --summary-interval=1 -c -x16 -s16 -k1M -j5 '{url}' -o '{fn}'"
+    woiii, appaa = pty.openpty()
+    qqqqq = subprocess.Popen(fc, shell=True, stdin=appaa, stdout=appaa, stderr=subprocess.STDOUT, close_fds=True)
+    os.close(appaa)
+
+    malam = ""
+    while True:
+        r, _, _ = select.select([woiii], [], [], 0.1)
+        if woiii in r:
+            try:
+                petualangan = os.read(woiii, 8192).decode()
+                malam += petualangan
+                for minggu in petualangan.splitlines():
+                    if re.match(r'\[#\w{6}\s.*\]', minggu):
+                        sys.stdout.write("\r" + " "*80 + "\r")
+                        sys.stdout.write(f"  {minggu}")
+                        sys.stdout.flush()
+                        break
+                        
+            except OSError as e:
+                if e.errno == errno.EIO:
+                    break
+
+        if qqqqq.poll() is not None and not r:
+            break
+                   
+    kemarin = malam.find("Download Results:")
+    if kemarin != -1:
+        hhhhh = malam[kemarin:]
+        jjjjj = hhhhh.splitlines()
+        kkkkk = False
+        for ggggg in jjjjj:
+            if ggggg.strip().startswith("======+====+==========="):
+                kkkkk = True
+                print("\n" + f"  {ggggg}")
+                continue
+            elif ggggg.strip().startswith("Status Legend:"):
+                break
+            elif kkkkk:
+                print(f"  {ggggg}")
+
+    qqqqq.wait()
+    os.close(woiii)
+    
+    extract_tar = f'pv {fn} | lz4 -d | tar xf -'
+    
+    ikan, asin = pty.openpty()
+    proc = subprocess.Popen(extract_tar, shell=True, stdin=asin, stdout=asin, stderr=asin, close_fds=True)
+    os.close(asin)
+
+    while True:
+        r, _, _ = select.select([ikan], [], [], 0.1)
+        if ikan in r:
+            try:
+                jemuran = os.read(ikan, 1024).decode('utf-8', 'ignore')
+                print(jemuran, end='')
+            except OSError as e:
+                if e.errno == errno.EIO:
+                    break
+        if proc.poll() is not None:
+            break
+
+    proc.wait()
+    os.close(ikan)
+    if os.path.exists(fn):
+        os.remove(fn)
+    else:
+        print(f"Warning: File {fn} not found, skipping removal.")
+
+    
+    oppai = '/kaggle/venv'
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "pip*")}')
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "python*")}')
+    os.system(f'python -m venv {oppai}')
+    say('【 {red} Setup Completed {d} 】 {red}')
+
+if __name__ == '__main__':
+    venv_in()
+    assu = os.path.join(xxx, 'venv.py')
+    os.remove(assu)

Stable-diffusion/ui/venv220.py

@@ -0,0 +1,62 @@
+import subprocess, sys, os, time, select, pty, errno
+
+xxx = '/kaggle/working'
+
+assu = os.path.join(xxx, 'venv.py')
+os.chdir(xxx)
+os.system(f'curl -sLO https://raw.githubusercontent.com/gutris1/segsmaker/main/kaggle/script/pantat88.py')
+sys.path.append(xxx)
+time.sleep(1)
+from pantat88 import say, download
+say('【{red} Installing VENV{d} 】{red}')
+
+auuuwooo = [
+    f"curl -LO https://github.com/DEX-1101/sd-webui-notebook/raw/main/res/get_ip.py",
+    f"curl -LO https://github.com/DEX-1101/sd-webui-notebook/raw/main/res/new_tunnel",
+    f"curl -Lo /usr/bin/cl https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64",
+    f"apt-get update",
+    f"apt -y install lz4 pv aria2",
+    f"pip install -q git+https://github.com/DEX-1101/colablib",
+    f"npm install -g localtunnel",
+    f"chmod +x /usr/bin/cl"]
+
+for tarzan in auuuwooo:
+    subprocess.run(tarzan.split(), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+def venv_in():
+    os.chdir('/kaggle')
+    url = 'https://huggingface.co/pantat88/back_up/resolve/main/venv_torch220.tar.lz4'
+    fn = 'venv_torch220.tar.lz4'
+    download(url)
+    
+    extract_tar = f'pv {fn} | lz4 -d | tar xf -'
+    ikan, asin = pty.openpty()
+    proc = subprocess.Popen(extract_tar, shell=True, stdin=asin, stdout=asin, stderr=asin, close_fds=True)
+    os.close(asin)
+    while True:
+        r, _, _ = select.select([ikan], [], [], 0.1)
+        if ikan in r:
+            try:
+                jemuran = os.read(ikan, 1024).decode('utf-8', 'ignore')
+                print(jemuran, end='')
+                
+            except OSError as e:
+                if e.errno == errno.EIO:
+                    break
+                    
+        if proc.poll() is not None:
+            break
+
+    proc.wait()
+    os.close(ikan)
+    os.remove(fn)
+
+    oppai = '/kaggle/venv'
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "pip*")}')
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "python*")}')
+    os.system(f'python -m venv {oppai}')
+
+venv_in()
+os.chdir(xxx)
+say('【{red} VENV Setup Completed{d} 】{red}')
+os.remove(assu)

Stable-diffusion/ui/venv_19-6-2024.py

@@ -0,0 +1,62 @@
+import subprocess, sys, os, time, select, pty, errno
+
+xxx = '/kaggle/working'
+
+assu = os.path.join(xxx, 'venv.py')
+os.chdir(xxx)
+os.system(f'curl -sLO https://raw.githubusercontent.com/gutris1/segsmaker/main/kaggle/script/pantat88.py')
+sys.path.append(xxx)
+time.sleep(1)
+from pantat88 import say, download
+say('【{red} Installing VENV{d} 】{red}')
+
+auuuwooo = [
+    f"curl -LO https://github.com/DEX-1101/sd-webui-notebook/raw/main/res/get_ip.py",
+    f"curl -LO https://github.com/DEX-1101/sd-webui-notebook/raw/main/res/new_tunnel",
+    f"curl -Lo /usr/bin/cl https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64",
+    f"apt-get update",
+    f"apt -y install lz4 pv aria2",
+    f"pip install -q git+https://github.com/DEX-1101/colablib",
+    f"npm install -g localtunnel",
+    f"chmod +x /usr/bin/cl"]
+
+for tarzan in auuuwooo:
+    subprocess.run(tarzan.split(), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+def venv_in():
+    os.chdir('/kaggle')
+    url = 'https://huggingface.co/pantat88/back_up/resolve/main/venv_19-6-2024.tar.lz4'
+    fn = 'venv_19-6-2024.tar.lz4'
+    download(url)
+    
+    extract_tar = f'pv {fn} | lz4 -d | tar xf -'
+    ikan, asin = pty.openpty()
+    proc = subprocess.Popen(extract_tar, shell=True, stdin=asin, stdout=asin, stderr=asin, close_fds=True)
+    os.close(asin)
+    while True:
+        r, _, _ = select.select([ikan], [], [], 0.1)
+        if ikan in r:
+            try:
+                jemuran = os.read(ikan, 1024).decode('utf-8', 'ignore')
+                print(jemuran, end='')
+                
+            except OSError as e:
+                if e.errno == errno.EIO:
+                    break
+                    
+        if proc.poll() is not None:
+            break
+
+    proc.wait()
+    os.close(ikan)
+    os.remove(fn)
+
+    oppai = '/kaggle/venv'
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "pip*")}')
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "python*")}')
+    os.system(f'python -m venv {oppai}')
+
+venv_in()
+os.chdir(xxx)
+say('【{red} VENV Setup Completed{d} 】{red}')
+os.remove(assu)

Stable-diffusion/ui/venvv.py

@@ -0,0 +1,62 @@
+import subprocess, sys, os, time, select, pty, errno
+
+xxx = '/kaggle/working'
+
+assu = os.path.join(xxx, 'venv.py')
+os.chdir(xxx)
+os.system(f'curl -sLO https://raw.githubusercontent.com/gutris1/segsmaker/main/kaggle/script/pantat88.py')
+sys.path.append(xxx)
+time.sleep(1)
+from pantat88 import say, download
+say('【{red} Installing VENV{d} 】{red}')
+
+auuuwooo = [
+    f"curl -LO https://github.com/DEX-1101/sd-webui-notebook/raw/main/res/get_ip.py",
+    f"curl -LO https://github.com/DEX-1101/sd-webui-notebook/raw/main/res/new_tunnel",
+    f"curl -Lo /usr/bin/cl https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64",
+    f"apt-get update",
+    f"apt -y install lz4 pv aria2",
+    f"pip install -q git+https://github.com/DEX-1101/colablib",
+    f"npm install -g localtunnel",
+    f"chmod +x /usr/bin/cl"]
+
+for tarzan in auuuwooo:
+    subprocess.run(tarzan.split(), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+def venv_in():
+    os.chdir('/kaggle')
+    url = 'https://huggingface.co/pantat88/back_up/resolve/main/venv_torch220.tar.lz4'
+    fn = 'venv_torch220.tar.lz4'
+    download(url)
+    
+    extract_tar = f'pv {fn} | lz4 -d | tar xf -'
+    ikan, asin = pty.openpty()
+    proc = subprocess.Popen(extract_tar, shell=True, stdin=asin, stdout=asin, stderr=asin, close_fds=True)
+    os.close(asin)
+    while True:
+        r, _, _ = select.select([ikan], [], [], 0.1)
+        if ikan in r:
+            try:
+                jemuran = os.read(ikan, 1024).decode('utf-8', 'ignore')
+                print(jemuran, end='')
+                
+            except OSError as e:
+                if e.errno == errno.EIO:
+                    break
+                    
+        if proc.poll() is not None:
+            break
+
+    proc.wait()
+    os.close(ikan)
+    os.remove(fn)
+
+    oppai = '/kaggle/venv'
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "pip*")}')
+    os.system(f'rm -rf {os.path.join(oppai, "bin", "python*")}')
+    os.system(f'python -m venv {oppai}')
+    say('【{red} VENV Setup Completed{d} 】{red}')
+
+venv_in()
+os.chdir(xxx)
+os.remove(assu)

Stable-diffusion/ui/zzzzzz.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:054e950e72181bb45ddbc7106d3625de406477725b5b313a91fe4522f03dbe0a
+size 6865699

Stable-diffusion/venv-fusion.tar.lz4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2186577551c3e55c2c1c8420cf3cb8bab234aceb7ca5f2463181a1abf95c745
+size 4731403914

Stable-diffusion/venv-sd-trainer.tar.lz4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73a61eabc0e539b54d42dbfdea652279a9744df660e1841e62a29938138ed2fb
+size 5481814036