Upload 43 files

.gitattributes

@@ -32,3 +32,5 @@ 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
+extensions/SD-rembg-master/preview.png filter=lfs diff=lfs merge=lfs -text
+extensions/SD-two-shot-main/gradio-3.16.2-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text

extensions/README.md

@@ -0,0 +1,162 @@
+# Stable Diffusion web UI
+A browser interface based on Gradio library for Stable Diffusion.
+
+![](screenshot.png)
+
+## Features
+[Detailed feature showcase with images](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Features):
+- Original txt2img and img2img modes
+- One click install and run script (but you still must install python and git)
+- Outpainting
+- Inpainting
+- Color Sketch
+- Prompt Matrix
+- Stable Diffusion Upscale
+- Attention, specify parts of text that the model should pay more attention to
+    - a man in a `((tuxedo))` - will pay more attention to tuxedo
+    - a man in a `(tuxedo:1.21)` - alternative syntax
+    - select text and press `Ctrl+Up` or `Ctrl+Down` to automatically adjust attention to selected text (code contributed by anonymous user)
+- Loopback, run img2img processing multiple times
+- X/Y/Z plot, a way to draw a 3 dimensional plot of images with different parameters
+- Textual Inversion
+    - have as many embeddings as you want and use any names you like for them
+    - use multiple embeddings with different numbers of vectors per token
+    - works with half precision floating point numbers
+    - train embeddings on 8GB (also reports of 6GB working)
+- Extras tab with:
+    - GFPGAN, neural network that fixes faces
+    - CodeFormer, face restoration tool as an alternative to GFPGAN
+    - RealESRGAN, neural network upscaler
+    - ESRGAN, neural network upscaler with a lot of third party models
+    - SwinIR and Swin2SR ([see here](https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/2092)), neural network upscalers
+    - LDSR, Latent diffusion super resolution upscaling
+- Resizing aspect ratio options
+- Sampling method selection
+    - Adjust sampler eta values (noise multiplier)
+    - More advanced noise setting options
+- Interrupt processing at any time
+- 4GB video card support (also reports of 2GB working)
+- Correct seeds for batches
+- Live prompt token length validation
+- Generation parameters
+     - parameters you used to generate images are saved with that image
+     - in PNG chunks for PNG, in EXIF for JPEG
+     - can drag the image to PNG info tab to restore generation parameters and automatically copy them into UI
+     - can be disabled in settings
+     - drag and drop an image/text-parameters to promptbox
+- Read Generation Parameters Button, loads parameters in promptbox to UI
+- Settings page
+- Running arbitrary python code from UI (must run with `--allow-code` to enable)
+- Mouseover hints for most UI elements
+- Possible to change defaults/mix/max/step values for UI elements via text config
+- Tiling support, a checkbox to create images that can be tiled like textures
+- Progress bar and live image generation preview
+    - Can use a separate neural network to produce previews with almost none VRAM or compute requirement
+- Negative prompt, an extra text field that allows you to list what you don't want to see in generated image
+- Styles, a way to save part of prompt and easily apply them via dropdown later
+- Variations, a way to generate same image but with tiny differences
+- Seed resizing, a way to generate same image but at slightly different resolution
+- CLIP interrogator, a button that tries to guess prompt from an image
+- Prompt Editing, a way to change prompt mid-generation, say to start making a watermelon and switch to anime girl midway
+- Batch Processing, process a group of files using img2img
+- Img2img Alternative, reverse Euler method of cross attention control
+- Highres Fix, a convenience option to produce high resolution pictures in one click without usual distortions
+- Reloading checkpoints on the fly
+- Checkpoint Merger, a tab that allows you to merge up to 3 checkpoints into one
+- [Custom scripts](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Custom-Scripts) with many extensions from community
+- [Composable-Diffusion](https://energy-based-model.github.io/Compositional-Visual-Generation-with-Composable-Diffusion-Models/), a way to use multiple prompts at once
+     - separate prompts using uppercase `AND`
+     - also supports weights for prompts: `a cat :1.2 AND a dog AND a penguin :2.2`
+- No token limit for prompts (original stable diffusion lets you use up to 75 tokens)
+- DeepDanbooru integration, creates danbooru style tags for anime prompts
+- [xformers](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Xformers), major speed increase for select cards: (add `--xformers` to commandline args)
+- via extension: [History tab](https://github.com/yfszzx/stable-diffusion-webui-images-browser): view, direct and delete images conveniently within the UI
+- Generate forever option
+- Training tab
+     - hypernetworks and embeddings options
+     - Preprocessing images: cropping, mirroring, autotagging using BLIP or deepdanbooru (for anime)
+- Clip skip
+- Hypernetworks
+- Loras (same as Hypernetworks but more pretty)
+- A sparate UI where you can choose, with preview, which embeddings, hypernetworks or Loras to add to your prompt 
+- Can select to load a different VAE from settings screen
+- Estimated completion time in progress bar
+- API
+- Support for dedicated [inpainting model](https://github.com/runwayml/stable-diffusion#inpainting-with-stable-diffusion) by RunwayML
+- via extension: [Aesthetic Gradients](https://github.com/AUTOMATIC1111/stable-diffusion-webui-aesthetic-gradients), a way to generate images with a specific aesthetic by using clip images embeds (implementation of [https://github.com/vicgalle/stable-diffusion-aesthetic-gradients](https://github.com/vicgalle/stable-diffusion-aesthetic-gradients))
+- [Stable Diffusion 2.0](https://github.com/Stability-AI/stablediffusion) support - see [wiki](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Features#stable-diffusion-20) for instructions
+- [Alt-Diffusion](https://arxiv.org/abs/2211.06679) support - see [wiki](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Features#alt-diffusion) for instructions
+- Now without any bad letters!
+- Load checkpoints in safetensors format
+- Eased resolution restriction: generated image's domension must be a multiple of 8 rather than 64
+- Now with a license!
+- Reorder elements in the UI from settings screen
+
+## Installation and Running
+Make sure the required [dependencies](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Dependencies) are met and follow the instructions available for both [NVidia](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Install-and-Run-on-NVidia-GPUs) (recommended) and [AMD](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Install-and-Run-on-AMD-GPUs) GPUs.
+
+Alternatively, use online services (like Google Colab):
+
+- [List of Online Services](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Online-Services)
+
+### Automatic Installation on Windows
+1. Install [Python 3.10.6](https://www.python.org/downloads/release/python-3106/) (Newer version of Python does not support torch), checking "Add Python to PATH".
+2. Install [git](https://git-scm.com/download/win).
+3. Download the stable-diffusion-webui repository, for example by running `git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git`.
+4. Run `webui-user.bat` from Windows Explorer as normal, non-administrator, user.
+
+### Automatic Installation on Linux
+1. Install the dependencies:
+```bash
+# Debian-based:
+sudo apt install wget git python3 python3-venv
+# Red Hat-based:
+sudo dnf install wget git python3
+# Arch-based:
+sudo pacman -S wget git python3
+```
+2. Navigate to the directory you would like the webui to be installed and execute the following command:
+```bash
+bash <(wget -qO- https://raw.githubusercontent.com/AUTOMATIC1111/stable-diffusion-webui/master/webui.sh)
+```
+3. Run `webui.sh`.
+4. Check `webui-user.sh` for options.
+### Installation on Apple Silicon
+
+Find the instructions [here](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Installation-on-Apple-Silicon).
+
+## Contributing
+Here's how to add code to this repo: [Contributing](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Contributing)
+
+## Documentation
+The documentation was moved from this README over to the project's [wiki](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki).
+
+## Credits
+Licenses for borrowed code can be found in `Settings -> Licenses` screen, and also in `html/licenses.html` file.
+
+- Stable Diffusion - https://github.com/CompVis/stable-diffusion, https://github.com/CompVis/taming-transformers
+- k-diffusion - https://github.com/crowsonkb/k-diffusion.git
+- GFPGAN - https://github.com/TencentARC/GFPGAN.git
+- CodeFormer - https://github.com/sczhou/CodeFormer
+- ESRGAN - https://github.com/xinntao/ESRGAN
+- SwinIR - https://github.com/JingyunLiang/SwinIR
+- Swin2SR - https://github.com/mv-lab/swin2sr
+- LDSR - https://github.com/Hafiidz/latent-diffusion
+- MiDaS - https://github.com/isl-org/MiDaS
+- Ideas for optimizations - https://github.com/basujindal/stable-diffusion
+- Cross Attention layer optimization - Doggettx - https://github.com/Doggettx/stable-diffusion, original idea for prompt editing.
+- Cross Attention layer optimization - InvokeAI, lstein - https://github.com/invoke-ai/InvokeAI (originally http://github.com/lstein/stable-diffusion)
+- Sub-quadratic Cross Attention layer optimization - Alex Birch (https://github.com/Birch-san/diffusers/pull/1), Amin Rezaei (https://github.com/AminRezaei0x443/memory-efficient-attention)
+- Textual Inversion - Rinon Gal - https://github.com/rinongal/textual_inversion (we're not using his code, but we are using his ideas).
+- Idea for SD upscale - https://github.com/jquesnelle/txt2imghd
+- Noise generation for outpainting mk2 - https://github.com/parlance-zz/g-diffuser-bot
+- CLIP interrogator idea and borrowing some code - https://github.com/pharmapsychotic/clip-interrogator
+- Idea for Composable Diffusion - https://github.com/energy-based-model/Compositional-Visual-Generation-with-Composable-Diffusion-Models-PyTorch
+- xformers - https://github.com/facebookresearch/xformers
+- DeepDanbooru - interrogator for anime diffusers https://github.com/KichangKim/DeepDanbooru
+- Sampling in float32 precision from a float16 UNet - marunine for the idea, Birch-san for the example Diffusers implementation (https://github.com/Birch-san/diffusers-play/tree/92feee6)
+- Instruct pix2pix - Tim Brooks (star), Aleksander Holynski (star), Alexei A. Efros (no star) - https://github.com/timothybrooks/instruct-pix2pix
+- Security advice - RyotaK
+- UniPC sampler - Wenliang Zhao - https://github.com/wl-zhao/UniPC
+- Initial Gradio script - posted on 4chan by an Anonymous user. Thank you Anonymous user.
+- (You)

extensions/SD-catppuccin-main/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Catppuccin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

extensions/SD-catppuccin-main/README.md

@@ -0,0 +1,97 @@
+<h3 align="center">
+	<img src="https://raw.githubusercontent.com/catppuccin/catppuccin/main/assets/logos/exports/1544x1544_circle.png" width="100" alt="Logo"/><br/>
+	<img src="https://raw.githubusercontent.com/catppuccin/catppuccin/main/assets/misc/transparent.png" height="30" width="0px"/>
+	Catppuccin for <a href="https://github.com/AUTOMATIC1111/stable-diffusion-webui">Stable Diffusion Web UI</a>
+	<img src="https://raw.githubusercontent.com/catppuccin/catppuccin/main/assets/misc/transparent.png" height="30" width="0px"/>
+</h3>
+
+<p align="center">
+	<a href="https://github.com/catppuccin/Stable-Diffusion-Web-Ui/stargazers"><img src="https://img.shields.io/github/stars/catppuccin/Stable-Diffusion-Web-Ui?colorA=363a4f&colorB=b7bdf8&style=for-the-badge"></a>
+	<a href="https://github.com/catppuccin/Stable-Diffusion-Web-Ui/issues"><img src="https://img.shields.io/github/issues/catppuccin/Stable-Diffusion-Web-Ui?colorA=363a4f&colorB=f5a97f&style=for-the-badge"></a>
+	<a href="https://github.com/catppuccin/Stable-Diffusion-Web-Ui/contributors"><img src="https://img.shields.io/github/contributors/catppuccin/Stable-Diffusion-Web-Ui?colorA=363a4f&colorB=a6da95&style=for-the-badge"></a>
+</p>
+
+<p align="center">
+	<img src="/assets/res.webp"/>
+</p>
+
+## Previews
+
+<details>
+<summary>🌻 Latte</summary>
+<img src="/assets/latte.webp"/>
+</details>
+<details>
+<summary>🪴 Frappé</summary>
+<img src="/assets/frappe.webp"/>
+</details>
+<details>
+<summary>🌺 Macchiato</summary>
+<img src="/assets/macchiato.webp"/>
+</details>
+<details>
+<summary>🌿 Mocha</summary>
+<img src="/assets/mocha.webp"/>
+</details>
+
+## Usage
+### Extension (Recommended)
+1. Open WebUI
+2. Click on the "Extensions" tab 
+3. Click on the "Install from URL" subsection 
+4. Paste `https://github.com/catppuccin/stable-diffusion-webui` into the URL spot, set the local directory name to `Catppuccin Theme`, and install
+5. Go to "Installed" subsection and click "Apply and restart UI"
+6. Configure the theme from the "Settings" tab under "Catppuccin Theme", afterwards you must "Apply Settings" and "Reload UI"
+
+### Extension (Extension index)
+NOTE: This method will install the theme under the name "stable-diffusion-webui". You can read more about this issue in the next section. 
+1. Open WebUI
+2. Click on the "Extensions" tab and navigate to "Available"
+3. Click "Load From:" and find and install "Catppuccin Theme" from the list 
+4. Go to "Installed" subsection and click "Apply and restart UI"
+5. Configure the theme from the "Settings" tab under "Catppuccin Theme", afterwards you must "Apply Settings" and "Reload UI"
+
+### Add directly
+1. Clone this repository locally
+2. Create the file `user.css` in your stable-diffusion-webui directory
+3. Copy the contents of the desired flavor into `user.css`
+4. Restart the Web UI or click "Reload UI" at the bottom of the screen
+
+## NOTE
+Due to catppuccin naming conventions and limitations in webui's extension names, this extension will come up as "stable-diffusion-webui" in the extension update section. I have proposed a solution to WebUI [here](https://github.com/catppuccin/stable-diffusion-webui/issues/5#issuecomment-1420599298), feel free to upvote it increase the chances of this issue being resolved. 
+
+## 🙋 FAQ
+
+-	Q: **_"I decided not to use the extennsion, how do I change the accent color?"_**\
+	A: Open `user.css` and set the variavble `--accent: var(--{preferred color});`
+	
+-	Q: **_"The theme isn't being applied???"_**\
+	A: Sometimes Web UI doesn't automatically figure out your preferred theme. Try adding `/?__theme=dark` to the url and see if the theme is applied. Below are the steps to make this change persistent on different systems:
+	- **Linux / MacOS**: Edit `webui-user.sh` and uncomment and set this variable as `export COMMANDLINE_ARGS="--theme=dark $COMMANDLINE_ARGS"`
+	- **Windows**: Edit `webui-user.bat` and set this variable by `set COMMANDLINE_ARGS=--theme=dark`. 
+	
+	If you are still having trouble then consult the relevant part of the [webui wiki](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Features#usercss). 
+	
+-	Q: **_"Why doesn't the theme look like the previews?"_**\
+	A: The main UI is constantly being changed upstream, so our previews may not match what the theme will look like for you. Though the previews may be behind, we are frequently updating the themes whenever there is a change in the Web UI repo. Though if you notice a style issue with a recent version of webui, feel free to open an issue on this repo.    
+	
+-	Q: **_"Why isn't {extension} themed?"_**\
+	A: Some extensions use their own style sheets that don't play nice with `user.css`.
+
+## 💝 Thanks to
+
+- [Kettukaa](https://github.com/Kettukaa)
+
+&nbsp;
+
+<p align="center">
+	<img src="https://raw.githubusercontent.com/catppuccin/catppuccin/main/assets/footers/gray0_ctp_on_line.svg?sanitize=true" />
+</p>
+
+<p align="center">
+	Copyright &copy; 2021-present <a href="https://github.com/catppuccin" target="_blank">Catppuccin Org</a>
+</p>
+
+<p align="center">
+	<a href="https://github.com/catppuccin/catppuccin/blob/main/LICENSE"><img src="https://img.shields.io/static/v1.svg?style=for-the-badge&label=License&message=MIT&logoColor=d9e0ee&colorA=363a4f&colorB=b7bdf8"/></a>
+</p>

extensions/SD-catppuccin-main/flavors/frappe.css

@@ -0,0 +1,565 @@
+:root, *, #context-menu {
+  --rosewater: #f2d5cf;
+  --flamingo: #eebebe;
+  --pink: #f4b8e4;
+  --mauve: #ca9ee6;
+  --red: #e78284;
+  --maroon: #ea999c;
+  --peach: #ef9f76;
+  --yellow: #e5c890;
+  --green: #a6d189;
+  --teal: #81c8be;
+  --sky: #99d1db;
+  --sapphire: #85c1dc;
+  --blue: #8caaee;
+  --lavender: #babbf1;
+  --text: #c6d0f5;
+  --subtext1: #b5bfe2;
+  --subtext0: #a5adce;
+  --overlay2: #949cbb;
+  --overlay1: #838ba7;
+  --overlay0: #737994;
+  --surface2: #626880;
+  --surface1: #51576d;
+  --surface0: #414559;
+  --base: #303446;
+  --mantle: #292c3c;
+  --crust: #232634;
+  --shadow: #010409;
+  --accent: var(--maroon);
+  color-scheme: light;
+}
+
+select, option {
+  background-color: var(--base);
+}
+
+#setting_sd_model_checkpoint > :first-child{
+  background-color: var(--base);
+}
+
+#txt2img_prompt_container,
+#img2img_prompt_container {
+  background-color: var(--mantle);
+}
+
+
+.dark .bg-white\/90, .bg-white\/90 {
+background-color: var(--base);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box span.text-gray-500, .gr-block.gr-box span.text-gray-500, 
+.dark label.block span, label.block span {
+background-color: var(--base);
+border: transparent;
+}
+
+.dark .dark\:text-gray-200, .\:text-gray-200{
+color: var(--text);
+}
+
+.dark .dark\:bg-gray-950, .\:bg-gray-950 {
+  background-color: var(--crust);
+}
+
+.dark .dark\:bg-gray-900, .\:bg-gray-900 {
+  background-color: var(--base);
+  border-radius: 10px;
+}
+
+.dark .dark\:border-gray-700, .\:border-gray-700 {
+  border-color: var(--surface0);
+}
+
+.dark .gr-panel, .gr-panel {
+  background-color: var(--mantle);
+}
+
+
+textarea, .gr-text-input {
+  background-color: var(--base) !important;
+}
+
+.dark .bg-white, .bg-white {
+  background-color: var(--mantle);
+}
+
+.dark .gr-compact, .gr-compact {
+  background-color: var(--base);
+}
+
+.dark .gr-input, .gr-input {
+  border-color: var(--surface0);
+}
+.dark .gr-form, .gr-form,
+.dark .gr-box, .gr-box {
+  background-color: transparent;
+  color: var(--text);
+}
+.dark .gr-check-radio, .gr-check-radio {
+  background-color: var(--base);
+}
+
+.dark .gr-check-radio:focus,  .gr-check-radio:focus,
+.dark .gr-check-radio:checked, .gr-check-radio:checked {
+  background-color: var(--accent);
+}
+
+.dark .gr-button-primary:hover, .gr-button-primary:hover {
+filter: brightness(130%);
+}
+.dark .gr-button-primary, .gr-button-primary {
+background-color: var(--accent) !important;
+color: var(--shadow)
+}
+
+
+.dark .gr-button-secondary:hover, .gr-button-secondary:hover {
+filter: brightness(120%);
+}
+
+button, input, optgroup, select, textarea {
+color: var(--accent);
+}
+
+.dark .gr-input-label, .gr-input-label,
+.dark .gr-button-secondary,.gr-button-secondary,
+.gr-input-label,
+.gr-button-secondary {
+  --tw-gradient-from: none;
+  --tw-gradient-to: none;
+  --tw-gradient-stops: none;
+  background-color: var(--base);
+  color: var(--text)
+}
+
+.gr-button,
+.dark .gr-button {
+border-color:var(--surface0);
+background-color: var(--base);
+background-image: unset;
+}
+
+
+.livePreview {
+  background-color: var(--base) !important;
+  height: 60vh !important;
+  width: 100% !important;
+  border-radius: 10px !important;
+}
+
+.gr-padded {
+padding: .825rem .75rem;
+}
+
+
+#mode_extras > :first-child > .bg-white {
+background-color: var(--base);
+}
+
+#interrogate_col {
+justify-content: center;
+gap: 10px;
+/* background: var(--base); */
+/* border-top-left-radius: 10px !important; */
+/* border-top-right-radius: 10px !important; */
+/* padding-top: 20px; */
+}
+
+#txt2img_toprow,
+#img2img_toprow {
+background-color: unset;
+}
+
+#txt2img_actions_column, #img2img_actions_column {
+padding: 10px;
+margin: 5px;
+border-radius: 10px !important;
+background-color: var(--base);
+}
+
+#img_inpaint_mask > div:nth-child(3),
+#img_inpaint_base > div:nth-child(3){
+border-width: 1px;
+border-color:var(--surface0);
+
+}
+
+#img2img_settings {
+border-radius: 10px;
+}
+
+#mode_img2img > :not(:first-child) {
+border-width: 0px;
+}
+
+
+#txt2img_gallery,
+#img2img_gallery,
+#extras_gallery {
+background-color: var(--base) !important;
+}
+
+#img2img_copy_to_img2img > :not(:first-child) {
+border-width: 1px !important;
+border-color: var(--surface0) !important;
+border-radius: 10px !important;
+margin-left: 10px;
+}
+
+#txt2img_interrupt, #img2img_interrupt {
+background-color: var(--red) !important;
+color: var(--mantle);
+}
+
+#txt2img_skip, #img2img_skip {
+background-color: var(--maroon) !important;
+color: var(--mantle);
+}
+
+#txt2img_batch_count,
+#txt2img_width {
+  margin-bottom: 0.625vw;
+}
+
+#txt2img_script_container > div > div {
+  margin: 0px 1vh 0.9vw 1vh;
+}
+
+#txt2img_script_container:last-child > div{
+  margin: unset;
+}
+
+.boder,
+.dark .border, .border, 
+.dark .border-gray-100,  .border-gray-100, 
+.dark .border-gray-200,  .border-gray-200, 
+.dark .border-gray-300,  .border-gray-300, 
+.dark .\!border, .\!border, 
+.dark .\!border-gray-300, .\!border-gray-300 {
+  border-color: var(--surface0);
+}
+
+
+.container {
+background-color: var(--crust);
+}
+
+fieldset span.text-gray-500, 
+.gr-block.gr-box span.text-gray-500, 
+label.block span {
+box-shadow: unset;
+}
+
+.dark .text-gray-500, .text-gray-500 {
+color: var(--text);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box, .gr-block.gr-box, 
+span.text-gray-500, 
+.dark label.block span, label.block span {
+  background-color: transparent;
+  border: transparent;
+}
+
+.dark .text-gray-700, .text-gray-700, 
+.dark .text-gray-800, .text-gray-800, 
+.dark .text-gray-900, .text-gray-900, 
+.dark .\!text-gray-700, .\!text-gray-700, 
+.dark .\!text-gray-800, .\!text-gray-800 {
+color: var(--text);
+}
+
+#txt2img_settings > div {
+  margin-top: 2vh;
+  flex-grow: 0;
+  min-width: 30%;
+}
+
+#tabs > :first-child {
+  background-color: var(--crust);
+}
+
+#tabs{
+  background-color: var(--mantle);
+}
+
+#tab_txt2img > div {
+  background-color: var(--mantle);
+}
+
+#tabs > div{
+  border-width: 0px !important;
+  border-color:var(--surface0);
+}
+
+#tabs > div:nth-child(1) {
+  flex-wrap: wrap-reverse;
+  background-color: var(--crust);
+}
+.tabs > :first-child {
+  border: none !important;
+  margin-bottom: -1px;
+  gap: 3px 0px;
+  background-color: var(--mantle);
+  padding-top: 5px;
+  z-index: 10;
+}
+
+#img2img_img2img_tab {
+border-width: 0px !important;
+}
+
+#mode_img2img > div:nth-child(1) > .bg-white {
+background-color: var(--base);
+}
+
+#tab_extensions table td, #tab_extensions table th {
+border: 1px solid var(--surface0);
+}
+
+#extras_resize_mode > :first-child {
+background-color: var(--base);
+}
+
+#extras_resize_mode > :not(:first-child)  {
+background-color: var(--mantle) !important;
+padding-top: 20px;
+border-color: transparent;
+border-radius: 0px 10px 10px 10px;
+margin-bottom: 20px;
+
+}
+
+.tabs > :first-child > button {
+  border-radius: 8px 8px 0px 0px;
+  /* outline: 1px solid var(--base) !important; */
+  border-color: var(--surface0);
+  border-width: 0px;
+  border-bottom-width: 0px;
+}
+
+
+#quicksettings {
+  background-color: transparent;
+}
+
+input[type="range"]::-ms-track {
+  background: transparent;
+}
+
+input[type="range"]::-ms-fill-lower {
+  background: var(--accent);
+  border-radius: 10px;
+}
+input[type="range"]::-ms-fill-upper {
+  background: var(--overlay0);
+  border-radius: 10px;
+}
+
+input[type="range"]:focus::-ms-fill-lower {
+  background: var(--accent);
+}
+input[type="range"]:focus::-ms-fill-upper {
+  background: var(--overlay0);
+}
+
+/* Chrome, Safari, Edge, Opera */
+input::-webkit-outer-spin-button,
+input::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+
+/* Firefox */
+input[type="number"] {
+  -moz-appearance: textfield;
+}
+.gr-box > div > div > input.gr-text-input {
+  width: 4em;
+}
+
+.progressDiv .progress {
+  background: var(--accent);
+  color: var(--shadow);
+}
+
+.dark .progressDiv, .progressDiv {
+  background-color: var(--surface0);
+}
+
+input[type="range"] {
+  font-size: 1.5rem;
+}
+
+input[type="range"] {
+  color: var(--accent);
+  --thumb-height: 0.5em;
+  --track-height: 0.125em;
+  --track-color: var(--surface0);
+  --brightness-hover: 130%;
+  --brightness-down: 80%;
+  --clip-edges: 0.125em;
+}
+
+input[type="range"].win10-thumb {
+  color: var(--accent);
+
+  --thumb-height: 0.5em;
+  --thumb-width: 0.5em;
+  --clip-edges: 0.0125em;
+}
+
+@media (prefers-color-scheme: dark) {
+  input[type="range"] {
+    color: var(--accent);
+    --track-color: var(--surface0);
+  }
+
+  input[type="range"].win10-thumb {
+    color: var(--accent);
+  }
+}
+
+/* === range commons === */
+input[type="range"] {
+  position: relative;
+  background: #fff0;
+  overflow: hidden;
+}
+
+input[type="range"]:active {
+  cursor: grabbing;
+}
+
+input[type="range"]:disabled {
+  filter: grayscale(1);
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+
+/* === WebKit specific styles === */
+input[type="range"],
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  position: relative;
+}
+
+input[type="range"]::-webkit-slider-thumb {
+  --thumb-radius: calc((var(--thumb-height) * 0.5) - 1px);
+  --clip-top: calc((var(--thumb-height) - var(--track-height)) * 0.5 - 0.5px);
+  --clip-bottom: calc(var(--thumb-height) - var(--clip-top));
+  --clip-further: calc(100% + 1px);
+  --box-fill: calc(-100vmax - var(--thumb-width, var(--thumb-height))) 0 0 100vmax currentColor;
+
+  width: var(--thumb-width, var(--thumb-height));
+  background: linear-gradient(currentColor 0 0) scroll no-repeat left center / 50% calc(var(--track-height) + 1px);
+  background-color: currentColor;
+  box-shadow: var(--box-fill);
+  border-radius: var(--thumb-width, var(--thumb-height));
+
+  filter: brightness(100%);
+  clip-path: polygon(
+    100% -1px,
+    var(--clip-edges) -1px,
+    0 var(--clip-top),
+    -100vmax var(--clip-top),
+    -100vmax var(--clip-bottom),
+    0 var(--clip-bottom),
+    var(--clip-edges) 100%,
+    var(--clip-further) var(--clip-further)
+  );
+}
+
+input[type="range"]:hover::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-hover));
+  cursor: grab;
+}
+
+input[type="range"]:active::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-down));
+  cursor: grabbing;
+}
+
+input[type="range"]::-webkit-slider-runnable-track {
+  background: linear-gradient(var(--track-color) 0 0) scroll no-repeat center / 100% calc(var(--track-height) + 1px);
+}
+
+input[type="range"]:disabled::-webkit-slider-thumb {
+  cursor: not-allowed;
+}
+
+/* === Firefox specific styles === */
+input[type="range"],
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb {
+  appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  background: #fff0;
+}
+
+input[type="range"]::-moz-range-thumb {
+  background: currentColor;
+  border: 0;
+  width: var(--thumb-width, var(--thumb-height));
+  border-radius: var(--thumb-width, var(--thumb-height));
+  cursor: grab;
+}
+
+input[type="range"]:active::-moz-range-thumb {
+  cursor: grabbing;
+}
+
+input[type="range"]::-moz-range-track {
+  width: 100%;
+  background: var(--track-color);
+}
+
+input[type="range"]::-moz-range-progress {
+  appearance: none;
+  background: currentColor;
+  transition-delay: 30ms;
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-progress {
+  height: calc(var(--track-height) + 1px);
+  border-radius: var(--track-height);
+}
+
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  filter: brightness(100%);
+}
+
+input[type="range"]:hover::-moz-range-thumb,
+input[type="range"]:hover::-moz-range-progress {
+  filter: brightness(var(--brightness-hover));
+}
+
+input[type="range"]:active::-moz-range-thumb,
+input[type="range"]:active::-moz-range-progress {
+  filter: brightness(var(--brightness-down));
+}
+
+input[type="range"]:disabled::-moz-range-thumb {
+  cursor: not-allowed;
+}
+
+/* all of the input range stuff is from this guy*/
+/* Shout out to them https://codepen.io/ShadowShahriar/pen/zYPPYrQ */

extensions/SD-catppuccin-main/flavors/latte.css

@@ -0,0 +1,565 @@
+:root, *, #context-menu{
+  --rosewater: #dc8a78;
+  --flamingo: #dd7878;
+  --pink: #ea76cb;
+  --mauve: #8839ef;
+  --red: #d20f39;
+  --maroon: #e64553;
+  --peach: #fe640b;
+  --yellow: #df8e1d;
+  --green: #40a02b;
+  --teal: #179299;
+  --sky: #04a5e5;
+  --sapphire: #209fb5;
+  --blue: #1e66f5;
+  --lavender: #7287fd;
+  --text: #4c4f69;
+  --subtext1: #5c5f77;
+  --subtext0: #6c6f85;
+  --overlay2: #7c7f93;
+  --overlay1: #8c8fa1;
+  --overlay0: #9ca0b0;
+  --surface2: #acb0be;
+  --surface1: #bcc0cc;
+  --surface0: #ccd0da;
+  --base: #eff1f5;
+  --mantle: #e6e9ef;
+  --crust: #dce0e8;
+  --shadow: #dbdfef;
+  --accent: var(--maroon);
+   color-scheme: light;
+}
+
+select, option {
+  background-color: var(--base);
+}
+
+#setting_sd_model_checkpoint > :first-child{
+  background-color: var(--base);
+}
+
+#txt2img_prompt_container,
+#img2img_prompt_container {
+  background-color: var(--mantle);
+}
+
+
+.dark .bg-white\/90, .bg-white\/90 {
+background-color: var(--base);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box span.text-gray-500, .gr-block.gr-box span.text-gray-500, 
+.dark label.block span, label.block span {
+background-color: var(--base);
+border: transparent;
+}
+
+.dark .dark\:text-gray-200, .\:text-gray-200{
+color: var(--text);
+}
+
+.dark .dark\:bg-gray-950, .\:bg-gray-950 {
+  background-color: var(--crust);
+}
+
+.dark .dark\:bg-gray-900, .\:bg-gray-900 {
+  background-color: var(--base);
+  border-radius: 10px;
+}
+
+.dark .dark\:border-gray-700, .\:border-gray-700 {
+  border-color: var(--surface0);
+}
+
+.dark .gr-panel, .gr-panel {
+  background-color: var(--mantle);
+}
+
+
+textarea, .gr-text-input {
+  background-color: var(--base) !important;
+}
+
+.dark .bg-white, .bg-white {
+  background-color: var(--mantle);
+}
+
+.dark .gr-compact, .gr-compact {
+  background-color: var(--base);
+}
+
+.dark .gr-input, .gr-input {
+  border-color: var(--surface0);
+}
+.dark .gr-form, .gr-form,
+.dark .gr-box, .gr-box {
+  background-color: transparent;
+  color: var(--text);
+}
+.dark .gr-check-radio, .gr-check-radio {
+  background-color: var(--base);
+}
+
+.dark .gr-check-radio:focus,  .gr-check-radio:focus,
+.dark .gr-check-radio:checked, .gr-check-radio:checked {
+  background-color: var(--accent);
+}
+
+.dark .gr-button-primary:hover, .gr-button-primary:hover {
+filter: brightness(130%);
+}
+.dark .gr-button-primary, .gr-button-primary {
+background-color: var(--accent) !important;
+color: var(--shadow)
+}
+
+
+.dark .gr-button-secondary:hover, .gr-button-secondary:hover {
+filter: brightness(120%);
+}
+
+button, input, optgroup, select, textarea {
+color: var(--accent);
+}
+
+.dark .gr-input-label, .gr-input-label,
+.dark .gr-button-secondary,.gr-button-secondary,
+.gr-input-label,
+.gr-button-secondary {
+  --tw-gradient-from: none;
+  --tw-gradient-to: none;
+  --tw-gradient-stops: none;
+  background-color: var(--base);
+  color: var(--text)
+}
+
+.gr-button,
+.dark .gr-button {
+border-color:var(--surface0);
+background-color: var(--base);
+background-image: unset;
+}
+
+
+.livePreview {
+  background-color: var(--base) !important;
+  height: 60vh !important;
+  width: 100% !important;
+  border-radius: 10px !important;
+}
+
+.gr-padded {
+padding: .825rem .75rem;
+}
+
+
+#mode_extras > :first-child > .bg-white {
+background-color: var(--base);
+}
+
+#interrogate_col {
+justify-content: center;
+gap: 10px;
+/* background: var(--base); */
+/* border-top-left-radius: 10px !important; */
+/* border-top-right-radius: 10px !important; */
+/* padding-top: 20px; */
+}
+
+#txt2img_toprow,
+#img2img_toprow {
+background-color: unset;
+}
+
+#txt2img_actions_column, #img2img_actions_column {
+padding: 10px;
+margin: 5px;
+border-radius: 10px !important;
+background-color: var(--base);
+}
+
+#img_inpaint_mask > div:nth-child(3),
+#img_inpaint_base > div:nth-child(3){
+border-width: 1px;
+border-color:var(--surface0);
+
+}
+
+#img2img_settings {
+border-radius: 10px;
+}
+
+#mode_img2img > :not(:first-child) {
+border-width: 0px;
+}
+
+
+#txt2img_gallery,
+#img2img_gallery,
+#extras_gallery {
+background-color: var(--base) !important;
+}
+
+#img2img_copy_to_img2img > :not(:first-child) {
+border-width: 1px !important;
+border-color: var(--surface0) !important;
+border-radius: 10px !important;
+margin-left: 10px;
+}
+
+#txt2img_interrupt, #img2img_interrupt {
+background-color: var(--red) !important;
+color: var(--mantle);
+}
+
+#txt2img_skip, #img2img_skip {
+background-color: var(--maroon) !important;
+color: var(--mantle);
+}
+
+#txt2img_batch_count,
+#txt2img_width {
+  margin-bottom: 0.625vw;
+}
+
+#txt2img_script_container > div > div {
+  margin: 0px 1vh 0.9vw 1vh;
+}
+
+#txt2img_script_container:last-child > div{
+  margin: unset;
+}
+
+.boder,
+.dark .border, .border, 
+.dark .border-gray-100,  .border-gray-100, 
+.dark .border-gray-200,  .border-gray-200, 
+.dark .border-gray-300,  .border-gray-300, 
+.dark .\!border, .\!border, 
+.dark .\!border-gray-300, .\!border-gray-300 {
+  border-color: var(--surface0);
+}
+
+
+.container {
+background-color: var(--crust);
+}
+
+fieldset span.text-gray-500, 
+.gr-block.gr-box span.text-gray-500, 
+label.block span {
+box-shadow: unset;
+}
+
+.dark .text-gray-500, .text-gray-500 {
+color: var(--text);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box, .gr-block.gr-box, 
+span.text-gray-500, 
+.dark label.block span, label.block span {
+  background-color: transparent;
+  border: transparent;
+}
+
+.dark .text-gray-700, .text-gray-700, 
+.dark .text-gray-800, .text-gray-800, 
+.dark .text-gray-900, .text-gray-900, 
+.dark .\!text-gray-700, .\!text-gray-700, 
+.dark .\!text-gray-800, .\!text-gray-800 {
+color: var(--text);
+}
+
+#txt2img_settings > div {
+  margin-top: 2vh;
+  flex-grow: 0;
+  min-width: 30%;
+}
+
+#tabs > :first-child {
+  background-color: var(--crust);
+}
+
+#tabs{
+  background-color: var(--mantle);
+}
+
+#tab_txt2img > div {
+  background-color: var(--mantle);
+}
+
+#tabs > div{
+  border-width: 0px !important;
+  border-color:var(--surface0);
+}
+
+#tabs > div:nth-child(1) {
+  flex-wrap: wrap-reverse;
+  background-color: var(--crust);
+}
+.tabs > :first-child {
+  border: none !important;
+  margin-bottom: -1px;
+  gap: 3px 0px;
+  background-color: var(--mantle);
+  padding-top: 5px;
+  z-index: 10;
+}
+
+#img2img_img2img_tab {
+border-width: 0px !important;
+}
+
+#mode_img2img > div:nth-child(1) > .bg-white {
+background-color: var(--base);
+}
+
+#tab_extensions table td, #tab_extensions table th {
+border: 1px solid var(--surface0);
+}
+
+#extras_resize_mode > :first-child {
+background-color: var(--base);
+}
+
+#extras_resize_mode > :not(:first-child)  {
+background-color: var(--mantle) !important;
+padding-top: 20px;
+border-color: transparent;
+border-radius: 0px 10px 10px 10px;
+margin-bottom: 20px;
+
+}
+
+.tabs > :first-child > button {
+  border-radius: 8px 8px 0px 0px;
+  /* outline: 1px solid var(--base) !important; */
+  border-color: var(--surface0);
+  border-width: 0px;
+  border-bottom-width: 0px;
+}
+
+
+#quicksettings {
+  background-color: transparent;
+}
+
+input[type="range"]::-ms-track {
+  background: transparent;
+}
+
+input[type="range"]::-ms-fill-lower {
+  background: var(--accent);
+  border-radius: 10px;
+}
+input[type="range"]::-ms-fill-upper {
+  background: var(--overlay0);
+  border-radius: 10px;
+}
+
+input[type="range"]:focus::-ms-fill-lower {
+  background: var(--accent);
+}
+input[type="range"]:focus::-ms-fill-upper {
+  background: var(--overlay0);
+}
+
+/* Chrome, Safari, Edge, Opera */
+input::-webkit-outer-spin-button,
+input::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+
+/* Firefox */
+input[type="number"] {
+  -moz-appearance: textfield;
+}
+.gr-box > div > div > input.gr-text-input {
+  width: 4em;
+}
+
+.progressDiv .progress {
+  background: var(--accent);
+  color: var(--shadow);
+}
+
+.dark .progressDiv, .progressDiv {
+  background-color: var(--surface0);
+}
+
+input[type="range"] {
+  font-size: 1.5rem;
+}
+
+input[type="range"] {
+  color: var(--accent);
+  --thumb-height: 0.5em;
+  --track-height: 0.125em;
+  --track-color: var(--surface0);
+  --brightness-hover: 130%;
+  --brightness-down: 80%;
+  --clip-edges: 0.125em;
+}
+
+input[type="range"].win10-thumb {
+  color: var(--accent);
+
+  --thumb-height: 0.5em;
+  --thumb-width: 0.5em;
+  --clip-edges: 0.0125em;
+}
+
+@media (prefers-color-scheme: dark) {
+  input[type="range"] {
+    color: var(--accent);
+    --track-color: var(--surface0);
+  }
+
+  input[type="range"].win10-thumb {
+    color: var(--accent);
+  }
+}
+
+/* === range commons === */
+input[type="range"] {
+  position: relative;
+  background: #fff0;
+  overflow: hidden;
+}
+
+input[type="range"]:active {
+  cursor: grabbing;
+}
+
+input[type="range"]:disabled {
+  filter: grayscale(1);
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+
+/* === WebKit specific styles === */
+input[type="range"],
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  position: relative;
+}
+
+input[type="range"]::-webkit-slider-thumb {
+  --thumb-radius: calc((var(--thumb-height) * 0.5) - 1px);
+  --clip-top: calc((var(--thumb-height) - var(--track-height)) * 0.5 - 0.5px);
+  --clip-bottom: calc(var(--thumb-height) - var(--clip-top));
+  --clip-further: calc(100% + 1px);
+  --box-fill: calc(-100vmax - var(--thumb-width, var(--thumb-height))) 0 0 100vmax currentColor;
+
+  width: var(--thumb-width, var(--thumb-height));
+  background: linear-gradient(currentColor 0 0) scroll no-repeat left center / 50% calc(var(--track-height) + 1px);
+  background-color: currentColor;
+  box-shadow: var(--box-fill);
+  border-radius: var(--thumb-width, var(--thumb-height));
+
+  filter: brightness(100%);
+  clip-path: polygon(
+    100% -1px,
+    var(--clip-edges) -1px,
+    0 var(--clip-top),
+    -100vmax var(--clip-top),
+    -100vmax var(--clip-bottom),
+    0 var(--clip-bottom),
+    var(--clip-edges) 100%,
+    var(--clip-further) var(--clip-further)
+  );
+}
+
+input[type="range"]:hover::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-hover));
+  cursor: grab;
+}
+
+input[type="range"]:active::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-down));
+  cursor: grabbing;
+}
+
+input[type="range"]::-webkit-slider-runnable-track {
+  background: linear-gradient(var(--track-color) 0 0) scroll no-repeat center / 100% calc(var(--track-height) + 1px);
+}
+
+input[type="range"]:disabled::-webkit-slider-thumb {
+  cursor: not-allowed;
+}
+
+/* === Firefox specific styles === */
+input[type="range"],
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb {
+  appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  background: #fff0;
+}
+
+input[type="range"]::-moz-range-thumb {
+  background: currentColor;
+  border: 0;
+  width: var(--thumb-width, var(--thumb-height));
+  border-radius: var(--thumb-width, var(--thumb-height));
+  cursor: grab;
+}
+
+input[type="range"]:active::-moz-range-thumb {
+  cursor: grabbing;
+}
+
+input[type="range"]::-moz-range-track {
+  width: 100%;
+  background: var(--track-color);
+}
+
+input[type="range"]::-moz-range-progress {
+  appearance: none;
+  background: currentColor;
+  transition-delay: 30ms;
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-progress {
+  height: calc(var(--track-height) + 1px);
+  border-radius: var(--track-height);
+}
+
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  filter: brightness(100%);
+}
+
+input[type="range"]:hover::-moz-range-thumb,
+input[type="range"]:hover::-moz-range-progress {
+  filter: brightness(var(--brightness-hover));
+}
+
+input[type="range"]:active::-moz-range-thumb,
+input[type="range"]:active::-moz-range-progress {
+  filter: brightness(var(--brightness-down));
+}
+
+input[type="range"]:disabled::-moz-range-thumb {
+  cursor: not-allowed;
+}
+
+/* all of the input range stuff is from this guy*/
+/* Shout out to them https://codepen.io/ShadowShahriar/pen/zYPPYrQ */

extensions/SD-catppuccin-main/flavors/macchiato.css

@@ -0,0 +1,565 @@
+:root, *, #context-menu{
+  --rosewater: #f4dbd6;
+  --flamingo: #f0c6c6;
+  --pink: #f5bde6;
+  --mauve: #c6a0f6;
+  --red: #ed8796;
+  --maroon: #ee99a0;
+  --peach: #f5a97f;
+  --yellow: #eed49f;
+  --green: #a6da95;
+  --teal: #8bd5ca;
+  --sky: #91d7e3;
+  --sapphire: #7dc4e4;
+  --blue: #8aadf4;
+  --lavender: #b7bdf8;
+  --text: #cad3f5;
+  --subtext1: #b8c0e0;
+  --subtext0: #a5adcb;
+  --overlay2: #939ab7;
+  --overlay1: #8087a2;
+  --overlay0: #6e738d;
+  --surface2: #5b6078;
+  --surface1: #494d64;
+  --surface0: #363a4f;
+  --base: #24273a;
+  --mantle: #1e2030;
+  --crust: #181926;
+  --shadow: #010409;
+  --accent: var(--maroon);
+  color-scheme: dark;
+}
+
+select, option {
+  background-color: var(--base);
+}
+
+#setting_sd_model_checkpoint > :first-child{
+  background-color: var(--base);
+}
+
+#txt2img_prompt_container,
+#img2img_prompt_container {
+  background-color: var(--mantle);
+}
+
+
+.dark .bg-white\/90, .bg-white\/90 {
+background-color: var(--base);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box span.text-gray-500, .gr-block.gr-box span.text-gray-500, 
+.dark label.block span, label.block span {
+background-color: var(--base);
+border: transparent;
+}
+
+.dark .dark\:text-gray-200, .\:text-gray-200{
+color: var(--text);
+}
+
+.dark .dark\:bg-gray-950, .\:bg-gray-950 {
+  background-color: var(--crust);
+}
+
+.dark .dark\:bg-gray-900, .\:bg-gray-900 {
+  background-color: var(--base);
+  border-radius: 10px;
+}
+
+.dark .dark\:border-gray-700, .\:border-gray-700 {
+  border-color: var(--surface0);
+}
+
+.dark .gr-panel, .gr-panel {
+  background-color: var(--mantle);
+}
+
+
+textarea, .gr-text-input {
+  background-color: var(--base) !important;
+}
+
+.dark .bg-white, .bg-white {
+  background-color: var(--mantle);
+}
+
+.dark .gr-compact, .gr-compact {
+  background-color: var(--base);
+}
+
+.dark .gr-input, .gr-input {
+  border-color: var(--surface0);
+}
+.dark .gr-form, .gr-form,
+.dark .gr-box, .gr-box {
+  background-color: transparent;
+  color: var(--text);
+}
+.dark .gr-check-radio, .gr-check-radio {
+  background-color: var(--base);
+}
+
+.dark .gr-check-radio:focus,  .gr-check-radio:focus,
+.dark .gr-check-radio:checked, .gr-check-radio:checked {
+  background-color: var(--accent);
+}
+
+.dark .gr-button-primary:hover, .gr-button-primary:hover {
+filter: brightness(130%);
+}
+.dark .gr-button-primary, .gr-button-primary {
+background-color: var(--accent) !important;
+color: var(--shadow)
+}
+
+
+.dark .gr-button-secondary:hover, .gr-button-secondary:hover {
+filter: brightness(120%);
+}
+
+button, input, optgroup, select, textarea {
+color: var(--accent);
+}
+
+.dark .gr-input-label, .gr-input-label,
+.dark .gr-button-secondary,.gr-button-secondary,
+.gr-input-label,
+.gr-button-secondary {
+  --tw-gradient-from: none;
+  --tw-gradient-to: none;
+  --tw-gradient-stops: none;
+  background-color: var(--base);
+  color: var(--text)
+}
+
+.gr-button,
+.dark .gr-button {
+border-color:var(--surface0);
+background-color: var(--base);
+background-image: unset;
+}
+
+
+.livePreview {
+  background-color: var(--base) !important;
+  height: 60vh !important;
+  width: 100% !important;
+  border-radius: 10px !important;
+}
+
+.gr-padded {
+padding: .825rem .75rem;
+}
+
+
+#mode_extras > :first-child > .bg-white {
+background-color: var(--base);
+}
+
+#interrogate_col {
+justify-content: center;
+gap: 10px;
+/* background: var(--base); */
+/* border-top-left-radius: 10px !important; */
+/* border-top-right-radius: 10px !important; */
+/* padding-top: 20px; */
+}
+
+#txt2img_toprow,
+#img2img_toprow {
+background-color: unset;
+}
+
+#txt2img_actions_column, #img2img_actions_column {
+padding: 10px;
+margin: 5px;
+border-radius: 10px !important;
+background-color: var(--base);
+}
+
+#img_inpaint_mask > div:nth-child(3),
+#img_inpaint_base > div:nth-child(3){
+border-width: 1px;
+border-color:var(--surface0);
+
+}
+
+#img2img_settings {
+border-radius: 10px;
+}
+
+#mode_img2img > :not(:first-child) {
+border-width: 0px;
+}
+
+
+#txt2img_gallery,
+#img2img_gallery,
+#extras_gallery {
+background-color: var(--base) !important;
+}
+
+#img2img_copy_to_img2img > :not(:first-child) {
+border-width: 1px !important;
+border-color: var(--surface0) !important;
+border-radius: 10px !important;
+margin-left: 10px;
+}
+
+#txt2img_interrupt, #img2img_interrupt {
+background-color: var(--red) !important;
+color: var(--mantle);
+}
+
+#txt2img_skip, #img2img_skip {
+background-color: var(--maroon) !important;
+color: var(--mantle);
+}
+
+#txt2img_batch_count,
+#txt2img_width {
+  margin-bottom: 0.625vw;
+}
+
+#txt2img_script_container > div > div {
+  margin: 0px 1vh 0.9vw 1vh;
+}
+
+#txt2img_script_container:last-child > div{
+  margin: unset;
+}
+
+.boder,
+.dark .border, .border, 
+.dark .border-gray-100,  .border-gray-100, 
+.dark .border-gray-200,  .border-gray-200, 
+.dark .border-gray-300,  .border-gray-300, 
+.dark .\!border, .\!border, 
+.dark .\!border-gray-300, .\!border-gray-300 {
+  border-color: var(--surface0);
+}
+
+
+.container {
+background-color: var(--crust);
+}
+
+fieldset span.text-gray-500, 
+.gr-block.gr-box span.text-gray-500, 
+label.block span {
+box-shadow: unset;
+}
+
+.dark .text-gray-500, .text-gray-500 {
+color: var(--text);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box, .gr-block.gr-box, 
+span.text-gray-500, 
+.dark label.block span, label.block span {
+  background-color: transparent;
+  border: transparent;
+}
+
+.dark .text-gray-700, .text-gray-700, 
+.dark .text-gray-800, .text-gray-800, 
+.dark .text-gray-900, .text-gray-900, 
+.dark .\!text-gray-700, .\!text-gray-700, 
+.dark .\!text-gray-800, .\!text-gray-800 {
+color: var(--text);
+}
+
+#txt2img_settings > div {
+  margin-top: 2vh;
+  flex-grow: 0;
+  min-width: 30%;
+}
+
+#tabs > :first-child {
+  background-color: var(--crust);
+}
+
+#tabs{
+  background-color: var(--mantle);
+}
+
+#tab_txt2img > div {
+  background-color: var(--mantle);
+}
+
+#tabs > div{
+  border-width: 0px !important;
+  border-color:var(--surface0);
+}
+
+#tabs > div:nth-child(1) {
+  flex-wrap: wrap-reverse;
+  background-color: var(--crust);
+}
+.tabs > :first-child {
+  border: none !important;
+  margin-bottom: -1px;
+  gap: 3px 0px;
+  background-color: var(--mantle);
+  padding-top: 5px;
+  z-index: 10;
+}
+
+#img2img_img2img_tab {
+border-width: 0px !important;
+}
+
+#mode_img2img > div:nth-child(1) > .bg-white {
+background-color: var(--base);
+}
+
+#tab_extensions table td, #tab_extensions table th {
+border: 1px solid var(--surface0);
+}
+
+#extras_resize_mode > :first-child {
+background-color: var(--base);
+}
+
+#extras_resize_mode > :not(:first-child)  {
+background-color: var(--mantle) !important;
+padding-top: 20px;
+border-color: transparent;
+border-radius: 0px 10px 10px 10px;
+margin-bottom: 20px;
+
+}
+
+.tabs > :first-child > button {
+  border-radius: 8px 8px 0px 0px;
+  /* outline: 1px solid var(--base) !important; */
+  border-color: var(--surface0);
+  border-width: 0px;
+  border-bottom-width: 0px;
+}
+
+
+#quicksettings {
+  background-color: transparent;
+}
+
+input[type="range"]::-ms-track {
+  background: transparent;
+}
+
+input[type="range"]::-ms-fill-lower {
+  background: var(--accent);
+  border-radius: 10px;
+}
+input[type="range"]::-ms-fill-upper {
+  background: var(--overlay0);
+  border-radius: 10px;
+}
+
+input[type="range"]:focus::-ms-fill-lower {
+  background: var(--accent);
+}
+input[type="range"]:focus::-ms-fill-upper {
+  background: var(--overlay0);
+}
+
+/* Chrome, Safari, Edge, Opera */
+input::-webkit-outer-spin-button,
+input::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+
+/* Firefox */
+input[type="number"] {
+  -moz-appearance: textfield;
+}
+.gr-box > div > div > input.gr-text-input {
+  width: 4em;
+}
+
+.progressDiv .progress {
+  background: var(--accent);
+  color: var(--shadow);
+}
+
+.dark .progressDiv, .progressDiv {
+  background-color: var(--surface0);
+}
+
+input[type="range"] {
+  font-size: 1.5rem;
+}
+
+input[type="range"] {
+  color: var(--accent);
+  --thumb-height: 0.5em;
+  --track-height: 0.125em;
+  --track-color: var(--surface0);
+  --brightness-hover: 130%;
+  --brightness-down: 80%;
+  --clip-edges: 0.125em;
+}
+
+input[type="range"].win10-thumb {
+  color: var(--accent);
+
+  --thumb-height: 0.5em;
+  --thumb-width: 0.5em;
+  --clip-edges: 0.0125em;
+}
+
+@media (prefers-color-scheme: dark) {
+  input[type="range"] {
+    color: var(--accent);
+    --track-color: var(--surface0);
+  }
+
+  input[type="range"].win10-thumb {
+    color: var(--accent);
+  }
+}
+
+/* === range commons === */
+input[type="range"] {
+  position: relative;
+  background: #fff0;
+  overflow: hidden;
+}
+
+input[type="range"]:active {
+  cursor: grabbing;
+}
+
+input[type="range"]:disabled {
+  filter: grayscale(1);
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+
+/* === WebKit specific styles === */
+input[type="range"],
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  position: relative;
+}
+
+input[type="range"]::-webkit-slider-thumb {
+  --thumb-radius: calc((var(--thumb-height) * 0.5) - 1px);
+  --clip-top: calc((var(--thumb-height) - var(--track-height)) * 0.5 - 0.5px);
+  --clip-bottom: calc(var(--thumb-height) - var(--clip-top));
+  --clip-further: calc(100% + 1px);
+  --box-fill: calc(-100vmax - var(--thumb-width, var(--thumb-height))) 0 0 100vmax currentColor;
+
+  width: var(--thumb-width, var(--thumb-height));
+  background: linear-gradient(currentColor 0 0) scroll no-repeat left center / 50% calc(var(--track-height) + 1px);
+  background-color: currentColor;
+  box-shadow: var(--box-fill);
+  border-radius: var(--thumb-width, var(--thumb-height));
+
+  filter: brightness(100%);
+  clip-path: polygon(
+    100% -1px,
+    var(--clip-edges) -1px,
+    0 var(--clip-top),
+    -100vmax var(--clip-top),
+    -100vmax var(--clip-bottom),
+    0 var(--clip-bottom),
+    var(--clip-edges) 100%,
+    var(--clip-further) var(--clip-further)
+  );
+}
+
+input[type="range"]:hover::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-hover));
+  cursor: grab;
+}
+
+input[type="range"]:active::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-down));
+  cursor: grabbing;
+}
+
+input[type="range"]::-webkit-slider-runnable-track {
+  background: linear-gradient(var(--track-color) 0 0) scroll no-repeat center / 100% calc(var(--track-height) + 1px);
+}
+
+input[type="range"]:disabled::-webkit-slider-thumb {
+  cursor: not-allowed;
+}
+
+/* === Firefox specific styles === */
+input[type="range"],
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb {
+  appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  background: #fff0;
+}
+
+input[type="range"]::-moz-range-thumb {
+  background: currentColor;
+  border: 0;
+  width: var(--thumb-width, var(--thumb-height));
+  border-radius: var(--thumb-width, var(--thumb-height));
+  cursor: grab;
+}
+
+input[type="range"]:active::-moz-range-thumb {
+  cursor: grabbing;
+}
+
+input[type="range"]::-moz-range-track {
+  width: 100%;
+  background: var(--track-color);
+}
+
+input[type="range"]::-moz-range-progress {
+  appearance: none;
+  background: currentColor;
+  transition-delay: 30ms;
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-progress {
+  height: calc(var(--track-height) + 1px);
+  border-radius: var(--track-height);
+}
+
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  filter: brightness(100%);
+}
+
+input[type="range"]:hover::-moz-range-thumb,
+input[type="range"]:hover::-moz-range-progress {
+  filter: brightness(var(--brightness-hover));
+}
+
+input[type="range"]:active::-moz-range-thumb,
+input[type="range"]:active::-moz-range-progress {
+  filter: brightness(var(--brightness-down));
+}
+
+input[type="range"]:disabled::-moz-range-thumb {
+  cursor: not-allowed;
+}
+
+/* all of the input range stuff is from this guy*/
+/* Shout out to them https://codepen.io/ShadowShahriar/pen/zYPPYrQ */

extensions/SD-catppuccin-main/flavors/mocha.css

@@ -0,0 +1,567 @@
+:root,
+*,
+#context-menu {
+  --rosewater: #f5e0dc;
+  --flamingo: #f2cdcd;
+  --pink: #f5c2e7;
+  --mauve: #cba6f7;
+  --red: #f38ba8;
+  --maroon: #eba0ac;
+  --peach: #fab387;
+  --yellow: #f9e2af;
+  --green: #a6e3a1;
+  --teal: #94e2d5;
+  --sky: #89dceb;
+  --sapphire: #74c7ec;
+  --lavender: #b4befe;
+  --blue: #89b4fa;
+  --text: #cdd6f4;
+  --subtext1: #bac2de;
+  --subtext0: #a6adc8;
+  --overlay2: #9399b2;
+  --overlay1: #7f849c;
+  --overlay0: #6c7086;
+  --surface2: #585b70;
+  --surface1: #45475a;
+  --surface0: #313244;
+  --base: #1e1e2e;
+  --mantle: #181825;
+  --crust: #11111b;
+  --shadow: #010409;
+  --accent: var(--maroon);
+  color-scheme: dark;
+}
+
+select, option {
+  background-color: var(--base);
+}
+
+#setting_sd_model_checkpoint > :first-child{
+  background-color: var(--base);
+}
+
+#txt2img_prompt_container,
+#img2img_prompt_container {
+  background-color: var(--mantle);
+}
+
+
+.dark .bg-white\/90, .bg-white\/90 {
+background-color: var(--base);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box span.text-gray-500, .gr-block.gr-box span.text-gray-500, 
+.dark label.block span, label.block span {
+background-color: var(--base);
+border: transparent;
+}
+
+.dark .dark\:text-gray-200, .\:text-gray-200{
+color: var(--text);
+}
+
+.dark .dark\:bg-gray-950, .\:bg-gray-950 {
+  background-color: var(--crust);
+}
+
+.dark .dark\:bg-gray-900, .\:bg-gray-900 {
+  background-color: var(--base);
+  border-radius: 10px;
+}
+
+.dark .dark\:border-gray-700, .\:border-gray-700 {
+  border-color: var(--surface0);
+}
+
+.dark .gr-panel, .gr-panel {
+  background-color: var(--mantle);
+}
+
+
+textarea, .gr-text-input {
+  background-color: var(--base) !important;
+}
+
+.dark .bg-white, .bg-white {
+  background-color: var(--mantle);
+}
+
+.dark .gr-compact, .gr-compact {
+  background-color: var(--base);
+}
+
+.dark .gr-input, .gr-input {
+  border-color: var(--surface0);
+}
+.dark .gr-form, .gr-form,
+.dark .gr-box, .gr-box {
+  background-color: transparent;
+  color: var(--text);
+}
+.dark .gr-check-radio, .gr-check-radio {
+  background-color: var(--base);
+}
+
+.dark .gr-check-radio:focus,  .gr-check-radio:focus,
+.dark .gr-check-radio:checked, .gr-check-radio:checked {
+  background-color: var(--accent);
+}
+
+.dark .gr-button-primary:hover, .gr-button-primary:hover {
+filter: brightness(130%);
+}
+.dark .gr-button-primary, .gr-button-primary {
+background-color: var(--accent) !important;
+color: var(--shadow)
+}
+
+
+.dark .gr-button-secondary:hover, .gr-button-secondary:hover {
+filter: brightness(120%);
+}
+
+button, input, optgroup, select, textarea {
+color: var(--accent);
+}
+
+.dark .gr-input-label, .gr-input-label,
+.dark .gr-button-secondary,.gr-button-secondary,
+.gr-input-label,
+.gr-button-secondary {
+  --tw-gradient-from: none;
+  --tw-gradient-to: none;
+  --tw-gradient-stops: none;
+  background-color: var(--base);
+  color: var(--text)
+}
+
+.gr-button,
+.dark .gr-button {
+border-color:var(--surface0);
+background-color: var(--base);
+background-image: unset;
+}
+
+
+.livePreview {
+  background-color: var(--base) !important;
+  height: 60vh !important;
+  width: 100% !important;
+  border-radius: 10px !important;
+}
+
+.gr-padded {
+padding: .825rem .75rem;
+}
+
+
+#mode_extras > :first-child > .bg-white {
+background-color: var(--base);
+}
+
+#interrogate_col {
+justify-content: center;
+gap: 10px;
+/* background: var(--base); */
+/* border-top-left-radius: 10px !important; */
+/* border-top-right-radius: 10px !important; */
+/* padding-top: 20px; */
+}
+
+#txt2img_toprow,
+#img2img_toprow {
+background-color: unset;
+}
+
+#txt2img_actions_column, #img2img_actions_column {
+padding: 10px;
+margin: 5px;
+border-radius: 10px !important;
+background-color: var(--base);
+}
+
+#img_inpaint_mask > div:nth-child(3),
+#img_inpaint_base > div:nth-child(3){
+border-width: 1px;
+border-color:var(--surface0);
+
+}
+
+#img2img_settings {
+border-radius: 10px;
+}
+
+#mode_img2img > :not(:first-child) {
+border-width: 0px;
+}
+
+
+#txt2img_gallery,
+#img2img_gallery,
+#extras_gallery {
+background-color: var(--base) !important;
+}
+
+#img2img_copy_to_img2img > :not(:first-child) {
+border-width: 1px !important;
+border-color: var(--surface0) !important;
+border-radius: 10px !important;
+margin-left: 10px;
+}
+
+#txt2img_interrupt, #img2img_interrupt {
+background-color: var(--red) !important;
+color: var(--mantle);
+}
+
+#txt2img_skip, #img2img_skip {
+background-color: var(--maroon) !important;
+color: var(--mantle);
+}
+
+#txt2img_batch_count,
+#txt2img_width {
+  margin-bottom: 0.625vw;
+}
+
+#txt2img_script_container > div > div {
+  margin: 0px 1vh 0.9vw 1vh;
+}
+
+#txt2img_script_container:last-child > div{
+  margin: unset;
+}
+
+.boder,
+.dark .border, .border, 
+.dark .border-gray-100,  .border-gray-100, 
+.dark .border-gray-200,  .border-gray-200, 
+.dark .border-gray-300,  .border-gray-300, 
+.dark .\!border, .\!border, 
+.dark .\!border-gray-300, .\!border-gray-300 {
+  border-color: var(--surface0);
+}
+
+
+.container {
+background-color: var(--crust);
+}
+
+fieldset span.text-gray-500, 
+.gr-block.gr-box span.text-gray-500, 
+label.block span {
+box-shadow: unset;
+}
+
+.dark .text-gray-500, .text-gray-500 {
+color: var(--text);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box, .gr-block.gr-box, 
+span.text-gray-500, 
+.dark label.block span, label.block span {
+  background-color: transparent;
+  border: transparent;
+}
+
+.dark .text-gray-700, .text-gray-700, 
+.dark .text-gray-800, .text-gray-800, 
+.dark .text-gray-900, .text-gray-900, 
+.dark .\!text-gray-700, .\!text-gray-700, 
+.dark .\!text-gray-800, .\!text-gray-800 {
+color: var(--text);
+}
+
+#txt2img_settings > div {
+  margin-top: 2vh;
+  flex-grow: 0;
+  min-width: 30%;
+}
+
+#tabs > :first-child {
+  background-color: var(--crust);
+}
+
+#tabs{
+  background-color: var(--mantle);
+}
+
+#tab_txt2img > div {
+  background-color: var(--mantle);
+}
+
+#tabs > div{
+  border-width: 0px !important;
+  border-color:var(--surface0);
+}
+
+#tabs > div:nth-child(1) {
+  flex-wrap: wrap-reverse;
+  background-color: var(--crust);
+}
+.tabs > :first-child {
+  border: none !important;
+  margin-bottom: -1px;
+  gap: 3px 0px;
+  background-color: var(--mantle);
+  padding-top: 5px;
+  z-index: 10;
+}
+
+#img2img_img2img_tab {
+border-width: 0px !important;
+}
+
+#mode_img2img > div:nth-child(1) > .bg-white {
+background-color: var(--base);
+}
+
+#tab_extensions table td, #tab_extensions table th {
+border: 1px solid var(--surface0);
+}
+
+#extras_resize_mode > :first-child {
+background-color: var(--base);
+}
+
+#extras_resize_mode > :not(:first-child)  {
+background-color: var(--mantle) !important;
+padding-top: 20px;
+border-color: transparent;
+border-radius: 0px 10px 10px 10px;
+margin-bottom: 20px;
+
+}
+
+.tabs > :first-child > button {
+  border-radius: 8px 8px 0px 0px;
+  /* outline: 1px solid var(--base) !important; */
+  border-color: var(--surface0);
+  border-width: 0px;
+  border-bottom-width: 0px;
+}
+
+
+#quicksettings {
+  background-color: transparent;
+}
+
+input[type="range"]::-ms-track {
+  background: transparent;
+}
+
+input[type="range"]::-ms-fill-lower {
+  background: var(--accent);
+  border-radius: 10px;
+}
+input[type="range"]::-ms-fill-upper {
+  background: var(--overlay0);
+  border-radius: 10px;
+}
+
+input[type="range"]:focus::-ms-fill-lower {
+  background: var(--accent);
+}
+input[type="range"]:focus::-ms-fill-upper {
+  background: var(--overlay0);
+}
+
+/* Chrome, Safari, Edge, Opera */
+input::-webkit-outer-spin-button,
+input::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+
+/* Firefox */
+input[type="number"] {
+  -moz-appearance: textfield;
+}
+.gr-box > div > div > input.gr-text-input {
+  width: 4em;
+}
+
+.progressDiv .progress {
+  background: var(--accent);
+  color: var(--shadow);
+}
+
+.dark .progressDiv, .progressDiv {
+  background-color: var(--surface0);
+}
+
+input[type="range"] {
+  font-size: 1.5rem;
+}
+
+input[type="range"] {
+  color: var(--accent);
+  --thumb-height: 0.5em;
+  --track-height: 0.125em;
+  --track-color: var(--surface0);
+  --brightness-hover: 130%;
+  --brightness-down: 80%;
+  --clip-edges: 0.125em;
+}
+
+input[type="range"].win10-thumb {
+  color: var(--accent);
+
+  --thumb-height: 0.5em;
+  --thumb-width: 0.5em;
+  --clip-edges: 0.0125em;
+}
+
+@media (prefers-color-scheme: dark) {
+  input[type="range"] {
+    color: var(--accent);
+    --track-color: var(--surface0);
+  }
+
+  input[type="range"].win10-thumb {
+    color: var(--accent);
+  }
+}
+
+/* === range commons === */
+input[type="range"] {
+  position: relative;
+  background: #fff0;
+  overflow: hidden;
+}
+
+input[type="range"]:active {
+  cursor: grabbing;
+}
+
+input[type="range"]:disabled {
+  filter: grayscale(1);
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+
+/* === WebKit specific styles === */
+input[type="range"],
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  position: relative;
+}
+
+input[type="range"]::-webkit-slider-thumb {
+  --thumb-radius: calc((var(--thumb-height) * 0.5) - 1px);
+  --clip-top: calc((var(--thumb-height) - var(--track-height)) * 0.5 - 0.5px);
+  --clip-bottom: calc(var(--thumb-height) - var(--clip-top));
+  --clip-further: calc(100% + 1px);
+  --box-fill: calc(-100vmax - var(--thumb-width, var(--thumb-height))) 0 0 100vmax currentColor;
+
+  width: var(--thumb-width, var(--thumb-height));
+  background: linear-gradient(currentColor 0 0) scroll no-repeat left center / 50% calc(var(--track-height) + 1px);
+  background-color: currentColor;
+  box-shadow: var(--box-fill);
+  border-radius: var(--thumb-width, var(--thumb-height));
+
+  filter: brightness(100%);
+  clip-path: polygon(
+    100% -1px,
+    var(--clip-edges) -1px,
+    0 var(--clip-top),
+    -100vmax var(--clip-top),
+    -100vmax var(--clip-bottom),
+    0 var(--clip-bottom),
+    var(--clip-edges) 100%,
+    var(--clip-further) var(--clip-further)
+  );
+}
+
+input[type="range"]:hover::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-hover));
+  cursor: grab;
+}
+
+input[type="range"]:active::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-down));
+  cursor: grabbing;
+}
+
+input[type="range"]::-webkit-slider-runnable-track {
+  background: linear-gradient(var(--track-color) 0 0) scroll no-repeat center / 100% calc(var(--track-height) + 1px);
+}
+
+input[type="range"]:disabled::-webkit-slider-thumb {
+  cursor: not-allowed;
+}
+
+/* === Firefox specific styles === */
+input[type="range"],
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb {
+  appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  background: #fff0;
+}
+
+input[type="range"]::-moz-range-thumb {
+  background: currentColor;
+  border: 0;
+  width: var(--thumb-width, var(--thumb-height));
+  border-radius: var(--thumb-width, var(--thumb-height));
+  cursor: grab;
+}
+
+input[type="range"]:active::-moz-range-thumb {
+  cursor: grabbing;
+}
+
+input[type="range"]::-moz-range-track {
+  width: 100%;
+  background: var(--track-color);
+}
+
+input[type="range"]::-moz-range-progress {
+  appearance: none;
+  background: currentColor;
+  transition-delay: 30ms;
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-progress {
+  height: calc(var(--track-height) + 1px);
+  border-radius: var(--track-height);
+}
+
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  filter: brightness(100%);
+}
+
+input[type="range"]:hover::-moz-range-thumb,
+input[type="range"]:hover::-moz-range-progress {
+  filter: brightness(var(--brightness-hover));
+}
+
+input[type="range"]:active::-moz-range-thumb,
+input[type="range"]:active::-moz-range-progress {
+  filter: brightness(var(--brightness-down));
+}
+
+input[type="range"]:disabled::-moz-range-thumb {
+  cursor: not-allowed;
+}
+
+/* all of the input range stuff is from this guy*/
+/* Shout out to them https://codepen.io/ShadowShahriar/pen/zYPPYrQ */

extensions/SD-catppuccin-main/scripts/main.py

@@ -0,0 +1,50 @@
+import os
+import re
+import shutil
+import gradio as gr
+from modules import script_callbacks
+from modules import shared, scripts
+import modules.scripts as scripts
+
+accents = ['rosewater', 'flamingo', 'pink' , 'mauve' ,'red', 'maroon' ,'peach', 'yellow', 'green', 'teal', 'sky', 'blue', 'sapphire', 'lavender']
+flavors = ['latte', 'frappe', 'macchiato', 'mocha']
+script_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+
+def on_ui_settings():
+    section = ('ctp', 'Catppuccin Theme')
+    shared.opts.add_option("ctp_flavor", 
+                            shared.OptionInfo(
+                                default='mocha', 
+                                label="Catppuccin Flavor",  
+                                component=gr.Radio, 
+                                component_args={"choices": flavors}, 
+                                onchange=on_ui_settings_change, 
+                                section=section))
+
+    shared.opts.add_option("accent_color", 
+                            shared.OptionInfo(
+                                default='maroon',
+                                label='Accent',
+                                component=gr.Radio,
+                                component_args={"choices": accents},
+                                onchange=on_accent_color_change,
+                                section=section
+                            ))
+
+def on_accent_color_change():
+    pattern = re.compile(r"--accent:\s*(.*)")
+    # replace the accent color
+    with open(os.path.join(script_path,'style.css'), "r+") as file:
+        text = re.sub(pattern, f'--accent: var(--{shared.opts.accent_color});', file.read(), count=1)
+        file.seek(0)
+        file.write(text)
+        file.truncate()
+
+def on_ui_settings_change():
+    # Move css over
+    shutil.copy(os.path.join(script_path,f'flavors/{shared.opts.ctp_flavor}.css'), os.path.join(script_path, 'style.css'))
+    
+    # reappply accent color
+    on_accent_color_change()
+
+script_callbacks.on_ui_settings(on_ui_settings)

extensions/SD-catppuccin-main/style.css

@@ -0,0 +1,565 @@
+:root,
+*,
+#context-menu {
+  --rosewater: #f5e0dc;
+  --flamingo: #f2cdcd;
+  --pink: #f5c2e7;
+  --mauve: #cba6f7;
+  --red: #f38ba8;
+  --maroon: #eba0ac;
+  --peach: #fab387;
+  --yellow: #f9e2af;
+  --green: #a6e3a1;
+  --teal: #94e2d5;
+  --sky: #89dceb;
+  --sapphire: #74c7ec;
+  --lavender: #b4befe;
+  --blue: #89b4fa;
+  --text: #cdd6f4;
+  --subtext1: #bac2de;
+  --subtext0: #a6adc8;
+  --overlay2: #9399b2;
+  --overlay1: #7f849c;
+  --overlay0: #6c7086;
+  --surface2: #585b70;
+  --surface1: #45475a;
+  --surface0: #313244;
+  --base: #1e1e2e;
+  --mantle: #181825;
+  --crust: #11111b;
+  --shadow: #010409;
+  --accent: var(--maroon);
+  color-scheme: dark;
+}
+select, option {
+  background-color: var(--base);
+}
+
+#setting_sd_model_checkpoint > :first-child{
+  background-color: var(--base);
+}
+
+#txt2img_prompt_container,
+#img2img_prompt_container {
+  background-color: var(--mantle);
+}
+
+
+.dark .bg-white\/90, .bg-white\/90 {
+background-color: var(--base);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box span.text-gray-500, .gr-block.gr-box span.text-gray-500, 
+.dark label.block span, label.block span {
+background-color: var(--base);
+border: transparent;
+}
+
+.dark .dark\:text-gray-200, .\:text-gray-200{
+color: var(--text);
+}
+
+.dark .dark\:bg-gray-950, .\:bg-gray-950 {
+  background-color: var(--crust);
+}
+
+.dark .dark\:bg-gray-900, .\:bg-gray-900 {
+  background-color: var(--base);
+  border-radius: 10px;
+}
+
+.dark .dark\:border-gray-700, .\:border-gray-700 {
+  border-color: var(--surface0);
+}
+
+.dark .gr-panel, .gr-panel {
+  background-color: var(--mantle);
+}
+
+
+textarea, .gr-text-input {
+  background-color: var(--base) !important;
+}
+
+.dark .bg-white, .bg-white {
+  background-color: var(--mantle);
+}
+
+.dark .gr-compact, .gr-compact {
+  background-color: var(--base);
+}
+
+.dark .gr-input, .gr-input {
+  border-color: var(--surface0);
+}
+.dark .gr-form, .gr-form,
+.dark .gr-box, .gr-box {
+  background-color: transparent;
+  color: var(--text);
+}
+.dark .gr-check-radio, .gr-check-radio {
+  background-color: var(--base);
+}
+
+.dark .gr-check-radio:checked, .gr-check-radio:checked {
+  background-color: var(--accent);
+}
+
+.dark .gr-button-primary:hover, .gr-button-primary:hover {
+filter: brightness(130%);
+}
+.dark .gr-button-primary, .gr-button-primary {
+background-color: var(--accent) !important;
+color: var(--shadow)
+}
+
+
+.dark .gr-button-secondary:hover, .gr-button-secondary:hover {
+filter: brightness(120%);
+}
+
+button, input, optgroup, select, textarea {
+color: var(--accent);
+}
+
+.dark .gr-input-label, .gr-input-label,
+.dark .gr-button-secondary,.gr-button-secondary,
+.gr-input-label,
+.gr-button-secondary {
+  --tw-gradient-from: none;
+  --tw-gradient-to: none;
+  --tw-gradient-stops: none;
+  background-color: var(--base);
+  color: var(--text)
+}
+
+.gr-button,
+.dark .gr-button {
+border-color:var(--surface0);
+background-color: var(--base);
+background-image: unset;
+}
+
+
+.livePreview {
+  background-color: var(--base) !important;
+  height: 60vh !important;
+  width: 100% !important;
+  border-radius: 10px !important;
+}
+
+.gr-padded {
+padding: .825rem .75rem;
+}
+
+
+#mode_extras > :first-child > .bg-white {
+background-color: var(--base);
+}
+
+#interrogate_col {
+justify-content: center;
+gap: 10px;
+/* background: var(--base); */
+/* border-top-left-radius: 10px !important; */
+/* border-top-right-radius: 10px !important; */
+/* padding-top: 20px; */
+}
+
+#txt2img_toprow,
+#img2img_toprow {
+background-color: unset;
+}
+
+#txt2img_actions_column, #img2img_actions_column {
+padding: 10px;
+margin: 5px;
+border-radius: 10px !important;
+background-color: var(--base);
+}
+
+#img_inpaint_mask > div:nth-child(3),
+#img_inpaint_base > div:nth-child(3){
+border-width: 1px;
+border-color:var(--surface0);
+
+}
+
+#img2img_settings {
+border-radius: 10px;
+}
+
+#mode_img2img > :not(:first-child) {
+border-width: 0px;
+}
+
+
+#txt2img_gallery,
+#img2img_gallery,
+#extras_gallery {
+background-color: var(--base) !important;
+}
+
+#img2img_copy_to_img2img > :not(:first-child) {
+border-width: 1px !important;
+border-color: var(--surface0) !important;
+border-radius: 10px !important;
+margin-left: 10px;
+}
+
+#txt2img_interrupt, #img2img_interrupt {
+background-color: var(--red) !important;
+color: var(--mantle);
+}
+
+#txt2img_skip, #img2img_skip {
+background-color: var(--maroon) !important;
+color: var(--mantle);
+}
+
+#txt2img_batch_count,
+#txt2img_width {
+  margin-bottom: 0.625vw;
+}
+
+#txt2img_script_container > div > div {
+  margin: 0px 1vh 0.9vw 1vh;
+}
+
+#txt2img_script_container:last-child > div{
+  margin: unset;
+}
+
+.boder,
+.dark .border, .border, 
+.dark .border-gray-100,  .border-gray-100, 
+.dark .border-gray-200,  .border-gray-200, 
+.dark .border-gray-300,  .border-gray-300, 
+.dark .\!border, .\!border, 
+.dark .\!border-gray-300, .\!border-gray-300 {
+  border-color: var(--surface0);
+}
+
+
+.container {
+background-color: var(--crust);
+}
+
+fieldset span.text-gray-500, 
+.gr-block.gr-box span.text-gray-500, 
+label.block span {
+box-shadow: unset;
+}
+
+.dark .text-gray-500, .text-gray-500 {
+color: var(--text);
+}
+
+.dark fieldset span.text-gray-500, fieldset span.text-gray-500, 
+.dark .gr-block.gr-box, .gr-block.gr-box, 
+span.text-gray-500, 
+.dark label.block span, label.block span {
+  background-color: transparent;
+  border: transparent;
+}
+
+.dark .text-gray-700, .text-gray-700, 
+.dark .text-gray-800, .text-gray-800, 
+.dark .text-gray-900, .text-gray-900, 
+.dark .\!text-gray-700, .\!text-gray-700, 
+.dark .\!text-gray-800, .\!text-gray-800 {
+color: var(--text);
+}
+
+#txt2img_settings > div {
+  margin-top: 2vh;
+  flex-grow: 0;
+  min-width: 30%;
+}
+
+#tabs > :first-child {
+  background-color: var(--crust);
+}
+
+#tabs{
+  background-color: var(--mantle);
+}
+
+#tab_txt2img > div {
+  background-color: var(--mantle);
+}
+
+#tabs > div{
+  border-width: 0px !important;
+  border-color:var(--surface0);
+}
+
+#tabs > div:nth-child(1) {
+  flex-wrap: wrap-reverse;
+  background-color: var(--crust);
+}
+.tabs > :first-child {
+  border: none !important;
+  margin-bottom: -1px;
+  gap: 3px 0px;
+  background-color: var(--mantle);
+  padding-top: 5px;
+  z-index: 10;
+}
+
+#img2img_img2img_tab {
+border-width: 0px !important;
+}
+
+#mode_img2img > div:nth-child(1) > .bg-white {
+background-color: var(--base);
+}
+
+#tab_extensions table td, #tab_extensions table th {
+border: 1px solid var(--surface0);
+}
+
+#extras_resize_mode > :first-child {
+background-color: var(--base);
+}
+
+#extras_resize_mode > :not(:first-child)  {
+background-color: var(--mantle) !important;
+padding-top: 20px;
+border-color: transparent;
+border-radius: 0px 10px 10px 10px;
+margin-bottom: 20px;
+
+}
+
+.tabs > :first-child > button {
+  border-radius: 8px 8px 0px 0px;
+  /* outline: 1px solid var(--base) !important; */
+  border-color: var(--surface0);
+  border-width: 0px;
+  border-bottom-width: 0px;
+}
+
+
+#quicksettings {
+  background-color: transparent;
+}
+
+input[type="range"]::-ms-track {
+  background: transparent;
+}
+
+input[type="range"]::-ms-fill-lower {
+  background: var(--accent);
+  border-radius: 10px;
+}
+input[type="range"]::-ms-fill-upper {
+  background: var(--overlay0);
+  border-radius: 10px;
+}
+
+input[type="range"]:focus::-ms-fill-lower {
+  background: var(--accent);
+}
+input[type="range"]:focus::-ms-fill-upper {
+  background: var(--overlay0);
+}
+
+/* Chrome, Safari, Edge, Opera */
+input::-webkit-outer-spin-button,
+input::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+
+/* Firefox */
+input[type="number"] {
+  -moz-appearance: textfield;
+}
+.gr-box > div > div > input.gr-text-input {
+  width: 4em;
+}
+
+.progressDiv .progress {
+  background: var(--accent);
+  color: var(--shadow);
+}
+
+.dark .progressDiv, .progressDiv {
+  background-color: var(--surface0);
+}
+
+input[type="range"] {
+  font-size: 1.5rem;
+}
+
+input[type="range"] {
+  color: var(--accent);
+  --thumb-height: 0.5em;
+  --track-height: 0.125em;
+  --track-color: var(--surface0);
+  --brightness-hover: 130%;
+  --brightness-down: 80%;
+  --clip-edges: 0.125em;
+}
+
+input[type="range"].win10-thumb {
+  color: var(--accent);
+
+  --thumb-height: 0.5em;
+  --thumb-width: 0.5em;
+  --clip-edges: 0.0125em;
+}
+
+@media (prefers-color-scheme: dark) {
+  input[type="range"] {
+    color: var(--accent);
+    --track-color: var(--surface0);
+  }
+
+  input[type="range"].win10-thumb {
+    color: var(--accent);
+  }
+}
+
+/* === range commons === */
+input[type="range"] {
+  position: relative;
+  background: #fff0;
+  overflow: hidden;
+}
+
+input[type="range"]:active {
+  cursor: grabbing;
+}
+
+input[type="range"]:disabled {
+  filter: grayscale(1);
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+
+/* === WebKit specific styles === */
+input[type="range"],
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-webkit-slider-runnable-track,
+input[type="range"]::-webkit-slider-thumb {
+  position: relative;
+}
+
+input[type="range"]::-webkit-slider-thumb {
+  --thumb-radius: calc((var(--thumb-height) * 0.5) - 1px);
+  --clip-top: calc((var(--thumb-height) - var(--track-height)) * 0.5 - 0.5px);
+  --clip-bottom: calc(var(--thumb-height) - var(--clip-top));
+  --clip-further: calc(100% + 1px);
+  --box-fill: calc(-100vmax - var(--thumb-width, var(--thumb-height))) 0 0 100vmax currentColor;
+
+  width: var(--thumb-width, var(--thumb-height));
+  background: linear-gradient(currentColor 0 0) scroll no-repeat left center / 50% calc(var(--track-height) + 1px);
+  background-color: currentColor;
+  box-shadow: var(--box-fill);
+  border-radius: var(--thumb-width, var(--thumb-height));
+
+  filter: brightness(100%);
+  clip-path: polygon(
+    100% -1px,
+    var(--clip-edges) -1px,
+    0 var(--clip-top),
+    -100vmax var(--clip-top),
+    -100vmax var(--clip-bottom),
+    0 var(--clip-bottom),
+    var(--clip-edges) 100%,
+    var(--clip-further) var(--clip-further)
+  );
+}
+
+input[type="range"]:hover::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-hover));
+  cursor: grab;
+}
+
+input[type="range"]:active::-webkit-slider-thumb {
+  filter: brightness(var(--brightness-down));
+  cursor: grabbing;
+}
+
+input[type="range"]::-webkit-slider-runnable-track {
+  background: linear-gradient(var(--track-color) 0 0) scroll no-repeat center / 100% calc(var(--track-height) + 1px);
+}
+
+input[type="range"]:disabled::-webkit-slider-thumb {
+  cursor: not-allowed;
+}
+
+/* === Firefox specific styles === */
+input[type="range"],
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb {
+  appearance: none;
+  transition: all ease 100ms;
+  height: var(--thumb-height);
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  background: #fff0;
+}
+
+input[type="range"]::-moz-range-thumb {
+  background: currentColor;
+  border: 0;
+  width: var(--thumb-width, var(--thumb-height));
+  border-radius: var(--thumb-width, var(--thumb-height));
+  cursor: grab;
+}
+
+input[type="range"]:active::-moz-range-thumb {
+  cursor: grabbing;
+}
+
+input[type="range"]::-moz-range-track {
+  width: 100%;
+  background: var(--track-color);
+}
+
+input[type="range"]::-moz-range-progress {
+  appearance: none;
+  background: currentColor;
+  transition-delay: 30ms;
+}
+
+input[type="range"]::-moz-range-track,
+input[type="range"]::-moz-range-progress {
+  height: calc(var(--track-height) + 1px);
+  border-radius: var(--track-height);
+}
+
+input[type="range"]::-moz-range-thumb,
+input[type="range"]::-moz-range-progress {
+  filter: brightness(100%);
+}
+
+input[type="range"]:hover::-moz-range-thumb,
+input[type="range"]:hover::-moz-range-progress {
+  filter: brightness(var(--brightness-hover));
+}
+
+input[type="range"]:active::-moz-range-thumb,
+input[type="range"]:active::-moz-range-progress {
+  filter: brightness(var(--brightness-down));
+}
+
+input[type="range"]:disabled::-moz-range-thumb {
+  cursor: not-allowed;
+}
+
+/* all of the input range stuff is from this guy*/
+/* Shout out to them https://codepen.io/ShadowShahriar/pen/zYPPYrQ */

extensions/SD-huggingface-main/.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: camenduru
+open_collective: # Replace with a single Open Collective username
+ko_fi: camenduru
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

extensions/SD-huggingface-main/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

extensions/SD-huggingface-main/README.md

@@ -0,0 +1,12 @@
+🐣 Please follow me for new updates https://twitter.com/camenduru <br />
+🔥 Please join our discord server https://discord.gg/k5BwmmvJJU
+
+# Push to 🤗 Hugging Face
+
+![Push Folder to Hugging Face](https://user-images.githubusercontent.com/54370274/216768707-4efb8a30-6826-409e-8bf1-6e74fc26fdab.jpg)
+
+To install it, clone the repo into the `extensions` directory and restart the web ui:
+
+`git clone https://github.com/camenduru/stable-diffusion-webui-huggingface`
+
+`pip install huggingface-hub==0.11.1`

extensions/SD-huggingface-main/install.py

@@ -0,0 +1,4 @@
+import launch
+
+if not launch.is_installed("huggingface_hub"):
+    launch.run_pip("install huggingface-hub==0.11.0", "requirements for Push to Hugging Face extension")

extensions/SD-huggingface-main/scripts/huggingface.py

@@ -0,0 +1,121 @@
+import os
+import numpy as np
+import gradio as gr
+from huggingface_hub import model_info, create_repo, create_branch, upload_folder, upload_file
+from huggingface_hub.utils import RepositoryNotFoundError, RevisionNotFoundError
+from modules import scripts, script_callbacks
+from subprocess import getoutput
+
+def run(command):
+    out = getoutput(f"{command}")
+    return out
+
+def push_folder(folder_from, folder_to, branch, token):
+    try:
+        repo_exists = True
+        r_info = model_info(folder_to, token=token)
+    except RepositoryNotFoundError:
+        repo_exists = False
+    finally:
+        if repo_exists:
+            print(r_info)
+        else:
+            create_repo(folder_to, private=True, token=token)
+    try:
+        branch_exists = True
+        b_info = model_info(folder_to, revision=branch, token=token)
+    except RevisionNotFoundError:
+        branch_exists = False
+    finally:
+        if branch_exists:
+            print(b_info)
+        else:
+            create_branch(folder_to, branch=branch, token=token)    
+    upload_folder(folder_path=folder_from, path_in_repo="", revision=branch, repo_id=folder_to, commit_message=f"folder", token=token)
+    return "push folder done!"
+ 
+def push_file(file_from, file_to, file_name, branch, token):
+    try:
+        repo_exists = True
+        r_info = model_info(file_to, token=token)
+    except RepositoryNotFoundError:
+        repo_exists = False
+    finally:
+        if repo_exists:
+            print(r_info)
+        else:
+            create_repo(file_to, private=True, token=token)
+    try:
+        branch_exists = True
+        b_info = model_info(file_to, revision=branch, token=token)
+    except RevisionNotFoundError:
+        branch_exists = False
+    finally:
+        if branch_exists:
+            print(b_info)
+        else:
+            create_branch(file_to, branch=branch, token=token)    
+    upload_file(path_or_fileobj=file_from, path_in_repo=file_name, revision=branch, repo_id=file_to, commit_message=f"file", token=token)
+    return "push file done!"   
+
+def on_ui_tabs():     
+    with gr.Blocks() as huggingface:
+        gr.Markdown(
+        """
+        ### Push Folder to 🤗 Hugging Face
+        folder_from = 🖼 Windows: C:\\Users\\PC\\Desktop\\MyModelFolder 🐧 Linux: /home/user/app/stable-diffusion-webui/my-model-folder<br />
+        folder_to = camenduru/mymodel <br />
+        branch = main <br />
+        token = get from [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens) new token role=write
+        """)
+        with gr.Group():
+            with gr.Box():
+                with gr.Row().style(equal_height=True):
+                    text_folder_from = gr.Textbox(show_label=False, max_lines=1, placeholder="folder_from")
+                    text_folder_to = gr.Textbox(show_label=False, max_lines=1, placeholder="folder_to")
+                    text_folder_branch = gr.Textbox(show_label=False, value="main", max_lines=1, placeholder="branch")
+                    text_folder_token = gr.Textbox(show_label=False, max_lines=1, placeholder="🤗 token")
+                    out_folder = gr.Textbox(show_label=False)
+                with gr.Row().style(equal_height=True):
+                    btn_push_folder = gr.Button("Push Folder To 🤗")
+            btn_push_folder.click(push_folder, inputs=[text_folder_from, text_folder_to, text_folder_branch, text_folder_token], outputs=out_folder)
+        gr.Markdown(
+        """
+        ### Push File to 🤗 Hugging Face
+        file_from = 🖼 Windows: C:\\Users\\PC\\Desktop\\MyModelFolder\\model.ckpt 🐧 Linux: /home/user/app/stable-diffusion-webui/my-model-folder/model.ckpt<br />
+        file_to = camenduru/mymodel <br />
+        file_name = model.ckpt <br />
+        branch = main <br />
+        token = get from [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens) new token role=write
+        """)
+        with gr.Group():
+            with gr.Box():
+                with gr.Row().style(equal_height=True):
+                    text_file_from = gr.Textbox(show_label=False, max_lines=1, placeholder="file_from")
+                    text_file_to = gr.Textbox(show_label=False, max_lines=1, placeholder="file_to")
+                    text_file_name = gr.Textbox(show_label=False, max_lines=1, placeholder="file_name")
+                    text_file_branch = gr.Textbox(show_label=False, value="main", max_lines=1, placeholder="branch")
+                    text_file_token = gr.Textbox(show_label=False, max_lines=1, placeholder="🤗 token")
+                    out_file = gr.Textbox(show_label=False)
+                with gr.Row().style(equal_height=True):
+                    btn_push_file = gr.Button("Push File To 🤗")
+            btn_push_file.click(push_file, inputs=[text_file_from, text_file_to, text_file_name, text_file_branch, text_file_token], outputs=out_file)
+        gr.Markdown(
+        """
+        ### 🦒 Colab Run Command
+        ```py
+        model: wget https://huggingface.co/ckpt/anything-v4.5-vae-swapped/resolve/main/anything-v4.5-vae-swapped.safetensors -O /content/stable-diffusion-webui/models/Stable-diffusion/anything-v4.5-vae-swapped.safetensors
+        lora:  wget https://huggingface.co/embed/Sakimi-Chan_LoRA/resolve/main/Sakimi-Chan_LoRA.safetensors -O /content/stable-diffusion-webui/extensions/sd-webui-additional-networks/models/lora/Sakimi-Chan_LoRA.safetensors
+        embed: wget https://huggingface.co/embed/bad_prompt/resolve/main/bad_prompt_version2.pt -O /content/stable-diffusion-webui/embeddings/bad_prompt_version2.pt
+        vae:   wget https://huggingface.co/ckpt/trinart_characters_19.2m_stable_diffusion_v1/resolve/main/autoencoder_fix_kl-f8-trinart_characters.ckpt -O /content/stable-diffusion-webui/models/VAE/autoencoder_fix_kl-f8-trinart_characters.vae.pt
+        zip outputs folder: zip -r /content/outputs.zip /content/stable-diffusion-webui/outputs
+        ```
+        """)
+        with gr.Group():
+            with gr.Box():
+                command = gr.Textbox(show_label=False, max_lines=1, placeholder="command")
+                out_text = gr.Textbox(show_label=False)
+                btn_run = gr.Button("run command")
+                btn_run.click(run, inputs=command, outputs=out_text)
+    return (huggingface, "Hugging Face", "huggingface"),
+script_callbacks.on_ui_tabs(on_ui_tabs)

extensions/SD-images-browser-main/.gitignore

@@ -0,0 +1 @@
+path_recorder.txt

extensions/SD-images-browser-main/README.md

@@ -0,0 +1,32 @@
+## stable-diffusion-webui-images-browser
+
+A custom extension for [AUTOMATIC1111/stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui).
+
+This is an image browser for browsing past generated pictures, view their generated informations, send that information to txt2img, img2img and others, collect images to your "favorites" folder and delete the images you no longer need.
+
+## Installation
+
+The extension can be installed directly from within the **Extensions** tab within the Webui.
+
+You can also install it manually by running the following command from within the webui directory:
+
+	git clone https://github.com/AlUlkesh/stable-diffusion-webui-images-browser/ extensions/stable-diffusion-webui-images-browser
+
+and restart your stable-diffusion-webui, then you can see the new tab "Image Browser".
+
+Please be aware that when scanning a directory for the first time, the png-cache will be built. This can take several minutes, depending on the amount of images.
+
+## Recent updates
+- Additional sorting and filtering by EXIF data including .txt file information
+- Recyle bin option
+- Add/Remove from saved directories, via buttons
+- New dropdown with subdirs
+- Option to not show the images from subdirs
+- Refresh button
+- Sort order
+- View and save favorites with individual folder depth
+- Now also supports jpg
+
+## Credit
+
+Credit goes to the original maintainer of this extension: https://github.com/yfszzx and to major contributor https://github.com/Klace

extensions/SD-images-browser-main/install.py

@@ -0,0 +1,4 @@
+import launch
+
+if not launch.is_installed("send2trash"):
+    launch.run_pip("install Send2Trash", "requirement for images-browser")

extensions/SD-images-browser-main/javascript/images_history.js

@@ -0,0 +1,234 @@
+var images_history_click_image = function(){
+    if (!this.classList?.contains("transform")){        
+        var gallery = images_history_get_parent_by_class(this, "images_history_cantainor");
+        var buttons = gallery.querySelectorAll(".gallery-item");
+        var i = 0;
+        var hidden_list = [];
+        buttons.forEach(function(e){
+            if (e.style.display == "none"){
+                hidden_list.push(i);
+            }
+            i += 1;
+        })
+        if (hidden_list.length > 0){
+            setTimeout(images_history_hide_buttons, 10, hidden_list, gallery);
+        }        
+    }    
+    images_history_set_image_info(this); 
+}
+
+function images_history_get_parent_by_class(item, class_name){
+    var parent = item.parentElement;
+    while(!parent.classList.contains(class_name)){
+        parent = parent.parentElement;
+    }
+    return parent;  
+}
+
+function images_history_get_parent_by_tagname(item, tagname){
+    var parent = item.parentElement;
+    tagname = tagname.toUpperCase()
+    while(parent.tagName != tagname){
+        parent = parent.parentElement;
+    }  
+    return parent;
+}
+
+function images_history_hide_buttons(hidden_list, gallery){
+    var buttons = gallery.querySelectorAll(".gallery-item");
+    var num = 0;
+    buttons.forEach(function(e){
+        if (e.style.display == "none"){
+            num += 1;
+        }
+    });
+    if (num == hidden_list.length){
+        setTimeout(images_history_hide_buttons, 10, hidden_list, gallery);
+    } 
+    for( i in hidden_list){
+        buttons[hidden_list[i]].style.display = "none";
+    }    
+}
+
+function images_history_set_image_info(button){
+    var buttons = images_history_get_parent_by_tagname(button, "DIV").querySelectorAll(".gallery-item");
+    var index = -1;
+    var i = 0;
+    buttons.forEach(function(e){
+        if(e == button){
+            index = i;
+        }
+        if(e.style.display != "none"){
+            i += 1;
+        }        
+    });
+    var gallery = images_history_get_parent_by_class(button, "images_history_cantainor");
+    var set_btn = gallery.querySelector(".images_history_set_index");
+    var curr_idx = set_btn.getAttribute("img_index", index);  
+    if (curr_idx != index) {
+        set_btn.setAttribute("img_index", index);        
+    }
+    set_btn.click();
+    
+}
+
+function images_history_get_current_img(tabname, img_index, page_index){
+    return [
+        tabname, 
+        gradioApp().getElementById(tabname + '_images_history_set_index').getAttribute("img_index"),       
+        page_index
+    ];
+}
+
+function images_history_delete(del_num, tabname, image_index){
+    image_index = parseInt(image_index);
+    var tab = gradioApp().getElementById(tabname + '_images_history');
+    var set_btn = tab.querySelector(".images_history_set_index");
+    var buttons = [];
+    tab.querySelectorAll(".gallery-item").forEach(function(e){
+        if (e.style.display != 'none'){
+            buttons.push(e);
+        }
+    });    
+    var img_num = buttons.length / 2;
+    del_num = Math.min(img_num - image_index, del_num)    
+    if (img_num <= del_num){
+        setTimeout(function(tabname){
+            gradioApp().getElementById(tabname + '_images_history_renew_page').click();
+        }, 30, tabname); 
+    } else {
+        var next_img  
+        for (var i = 0; i < del_num; i++){
+            buttons[image_index + i].style.display = 'none';
+            buttons[image_index + i + img_num].style.display = 'none';
+            next_img = image_index + i + 1
+        }
+        var btn;
+        if (next_img  >= img_num){
+            btn = buttons[image_index - 1];
+        } else {            
+            btn = buttons[next_img];          
+        } 
+        setTimeout(function(btn){btn.click()}, 30, btn);
+    }
+
+}
+
+function images_history_turnpage(tabname){
+    var buttons = gradioApp().getElementById(tabname + '_images_history').querySelectorAll(".gallery-item");
+    buttons.forEach(function(elem) {
+        elem.style.display = 'block';
+    });   
+}
+
+function images_history_init(){ 
+    var tabnames = gradioApp().getElementById("images_history_tabnames_list")   
+    if (tabnames){  
+        images_history_tab_list = tabnames.querySelector("textarea").value.split(",")    
+        for (var i in images_history_tab_list ){
+            var tab = images_history_tab_list[i];
+            gradioApp().getElementById(tab + '_images_history').classList.add("images_history_cantainor");
+            gradioApp().getElementById(tab + '_images_history_set_index').classList.add("images_history_set_index");
+            gradioApp().getElementById(tab + '_images_history_del_button').classList.add("images_history_del_button");
+            gradioApp().getElementById(tab + '_images_history_gallery').classList.add("images_history_gallery");  
+            }
+
+        //preload
+        var tab_btns = gradioApp().getElementById("images_history_tab").querySelector("div").querySelectorAll("button"); 
+        for (var i in images_history_tab_list){               
+            var tabname = images_history_tab_list[i]
+            tab_btns[i].setAttribute("tabname", tabname);
+            tab_btns[i].addEventListener('click', function(){
+                 var tabs_box = gradioApp().getElementById("images_history_tab");
+                    if (!tabs_box.classList.contains(this.getAttribute("tabname"))) {
+                        gradioApp().getElementById(this.getAttribute("tabname") + "_images_history_renew_page").click();
+                        tabs_box.classList.add(this.getAttribute("tabname"))
+                    }         
+            });
+        }     
+        if (gradioApp().getElementById("images_history_preload").querySelector("input").checked ){
+             setTimeout(function(){tab_btns[0].click()}, 100);
+        }   
+       
+    } else {
+        setTimeout(images_history_init, 500);
+    } 
+}
+
+let timer
+var images_history_tab_list = "";
+setTimeout(images_history_init, 500);
+document.addEventListener("DOMContentLoaded", function() {
+    var mutationObserver = new MutationObserver(function(m){
+        if (images_history_tab_list != ""){
+
+            for (var i in images_history_tab_list ){
+                let tabname = images_history_tab_list[i]
+                var buttons = gradioApp().querySelectorAll('#' + tabname + '_images_history .gallery-item');
+                buttons.forEach(function(button){    
+                    button.addEventListener('click', images_history_click_image, true);
+                    document.onkeyup = function(e) {
+                        if (!checkImageBrowserActive()) {
+                            return;
+                        }
+                        clearTimeout(timer)
+                        timer = setTimeout(() => {
+                            var gallery_btn = gradioApp().getElementById(getCurrentTabName() +"_images_history_gallery").getElementsByClassName('gallery-item !flex-none !h-9 !w-9 transition-all duration-75 !ring-2 !ring-orange-500 hover:!ring-orange-500 svelte-1g9btlg');
+                            gallery_btn = gallery_btn && gallery_btn.length > 0 ? gallery_btn[0] : null;
+                            if (gallery_btn) {
+                                images_history_click_image.call(gallery_btn)
+                            }
+                        }, 500);
+                    }
+                });
+
+                var cls_btn = gradioApp().getElementById(tabname + '_images_history_gallery').querySelector("svg");
+                if (cls_btn){
+                    cls_btn.addEventListener('click', function(){
+                        gradioApp().getElementById(tabname + '_images_history_renew_page').click();
+                    }, false);
+                }
+
+            }     
+        }
+    });
+    mutationObserver.observe(gradioApp(), { childList:true, subtree:true });
+});
+
+function getCurrentTabName() {
+    var tabs = gradioApp().getElementById("images_history_tab").querySelectorAll('[id$="_images_history_container"]');
+
+    for (const element of tabs) {
+      if (element.style.display === "block") {
+        const id = element.id;
+        const index = id.indexOf("_images_history_container");
+        const tabname = id.substring(0, index);
+        return tabname;
+      }
+    }
+}
+
+function checkImageBrowserActive() {
+    var ext_active = gradioApp().getElementById("tab_images_history");
+    return ext_active && ext_active.style.display !== "none";
+}
+
+gradioApp().addEventListener("keydown", function(event) {
+    // If we are not on the Image Browser Extension, dont listen for keypresses
+    if (!checkImageBrowserActive()) {
+        return;
+    }
+
+    // Listens for keypresses 0-5 and updates the corresponding ranking (0 is the last option, None)
+    if (event.code >= "Digit0" && event.code <= "Digit5") {
+        var selectedValue = event.code.charAt(event.code.length - 1);
+        var radioInputs = gradioApp().getElementById( getCurrentTabName() + "_images_ranking").getElementsByTagName("input");
+        for (const input of radioInputs) {
+            if (input.value === selectedValue || (selectedValue === '0' && input === radioInputs[radioInputs.length - 1])) {
+                input.checked = true;
+                input.dispatchEvent(new Event("change"));
+                break;
+            }
+        }
+    }
+});

extensions/SD-images-browser-main/scripts/images_history.py

@@ -0,0 +1,776 @@
+import gradio as gr
+import json
+import logging
+import os
+import random
+import re
+import shutil
+import stat
+import time
+import modules.extras
+import modules.ui
+from modules import script_callbacks
+from modules import shared, scripts, images
+from modules.shared import opts, cmd_opts
+from modules.ui_common import plaintext_to_html
+from modules.ui_components import ToolButton
+from scripts.wib import wib_db
+from PIL import Image
+from PIL.ExifTags import TAGS
+from PIL.JpegImagePlugin import JpegImageFile
+from PIL.PngImagePlugin import PngImageFile
+from pathlib import Path
+from send2trash import send2trash
+from typing import List, Tuple
+
+yappi_do = False
+favorite_tab_name = "Favorites"
+tabs_list = ["txt2img", "img2img", "txt2img-grids", "img2img-grids", "Extras", favorite_tab_name, "Others"] #txt2img-grids and img2img-grids added by HaylockGrant
+num_of_imgs_per_page = 0
+loads_files_num = 0
+image_ext_list = [".png", ".jpg", ".jpeg", ".bmp", ".gif", ".webp"]
+cur_ranking_value="0"
+finfo_aes = {}
+exif_cache = {}
+finfo_exif = {}
+aes_cache = {}
+none_select = "Nothing selected"
+refresh_symbol = '\U0001f504'  # 🔄
+up_symbol = '\U000025b2'  # ▲
+down_symbol = '\U000025bc'  # ▼
+current_depth = 0
+init = True
+
+logger = logging.getLogger(__name__)
+logger_mode = logging.ERROR
+if hasattr(opts, "images_logger_warning"):
+    if opts.images_logger_warning:
+        logger_mode = logging.WARNING
+if hasattr(opts, "images_logger_debug"):
+    if opts.images_logger_debug:
+        logger_mode = logging.DEBUG
+logger.setLevel(logger_mode)
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logger_mode)
+logger.addHandler(console_handler)
+
+def delete_recycle(filename):
+    if opts.images_delete_recycle:
+        send2trash(filename)
+    else:
+        os.remove(filename)
+    return
+
+def img_path_subdirs_get(img_path):
+    subdirs = []
+    subdirs.append(none_select)
+    for item in os.listdir(img_path):
+        item_path = os.path.join(img_path, item)
+        if os.path.isdir(item_path):
+            subdirs.append(item_path)
+    return gr.update(choices=subdirs)
+
+def img_path_add_remove(img_dir, path_recorder, add_remove, img_path_depth):
+    if add_remove == "add" or (add_remove == "remove" and img_dir in path_recorder):
+        if add_remove == "add":
+            path_recorder[img_dir] = {
+                "depth": int(img_path_depth),
+                "path_display": f"{img_dir} [{int(img_path_depth)}]"
+            }
+            wib_db.update_path_recorder(img_dir, path_recorder[img_dir]["depth"], path_recorder[img_dir]["path_display"])
+        else:
+            del path_recorder[img_dir]
+            wib_db.delete_path_recorder(img_dir)
+        path_recorder_formatted = [value.get("path_display") for key, value in path_recorder.items()]
+        path_recorder_formatted = sorted(path_recorder_formatted, key=lambda x: natural_keys(x.lower()))
+
+    if add_remove == "remove":
+        selected = None
+    else:
+        selected = path_recorder[img_dir]["path_display"]
+    return path_recorder, gr.update(choices=path_recorder_formatted, value=selected)
+
+def sort_order_flip(turn_page_switch, sort_order):
+    if sort_order == up_symbol:
+        sort_order = down_symbol
+    else:
+        sort_order = up_symbol
+    return 1, -turn_page_switch, sort_order
+
+def read_path_recorder(path_recorder, path_recorder_formatted):
+    path_recorder = wib_db.load_path_recorder()
+    path_recorder_formatted = [value.get("path_display") for key, value in path_recorder.items()]
+    path_recorder_formatted = sorted(path_recorder_formatted, key=lambda x: natural_keys(x.lower()))
+
+    return path_recorder, path_recorder_formatted
+
+def pure_path(path):
+    if path == []:
+        return path, 0
+    match = re.search(r" \[(\d+)\]$", path)
+    if match:
+        path = path[:match.start()]
+        depth = int(match.group(1))
+    else:
+        depth = 0
+    return path, depth
+
+def history2path(img_path_history):
+    img_path, _ = pure_path(img_path_history)
+    return img_path
+
+def totxt(file):
+    base, _ = os.path.splitext(file)
+    file_txt = base + '.txt'
+
+    return file_txt
+
+def reduplicative_file_move(src, dst):
+    def same_name_file(basename, path):
+        name, ext = os.path.splitext(basename)
+        f_list = os.listdir(path)
+        max_num = 0
+        for f in f_list:
+            if len(f) <= len(basename):
+                continue
+            f_ext = f[-len(ext):] if len(ext) > 0 else ""
+            if f[:len(name)] == name and f_ext == ext:                
+                if f[len(name)] == "(" and f[-len(ext)-1] == ")":
+                    number = f[len(name)+1:-len(ext)-1]
+                    if number.isdigit():
+                        if int(number) > max_num:
+                            max_num = int(number)
+        return f"{name}({max_num + 1}){ext}"
+    name = os.path.basename(src)
+    save_name = os.path.join(dst, name)
+    src_txt_exists = False
+    if opts.images_txt_files:
+        src_txt = totxt(src)
+        if os.path.exists(src_txt):
+            src_txt_exists = True
+    if not os.path.exists(save_name):
+        if opts.images_copy_image:
+            shutil.copy2(src, dst)
+            if opts.images_txt_files and src_txt_exists:
+                shutil.copy2(src_txt, dst)
+        else:
+            shutil.move(src, dst)
+            if opts.images_txt_files and src_txt_exists:
+                shutil.move(src_txt, dst)
+    else:
+        name = same_name_file(name, dst)
+        if opts.images_copy_image:
+            shutil.copy2(src, os.path.join(dst, name))
+            if opts.images_txt_files and src_txt_exists:
+                shutil.copy2(src_txt, totxt(os.path.join(dst, name)))
+        else:
+            shutil.move(src, os.path.join(dst, name))
+            if opts.images_txt_files and src_txt_exists:
+                shutil.move(src_txt, totxt(os.path.join(dst, name)))
+
+def save_image(file_name, filenames, page_index, turn_page_switch):
+    if file_name is not None and os.path.exists(file_name):
+        reduplicative_file_move(file_name, opts.outdir_save)
+        if opts.images_copy_image:
+            message = "<div style='color:#999'>Copied to favorites</div>"
+        else:
+            message = "<div style='color:#999'>Moved to favorites</div>"
+            # Force page refresh with checking filenames
+            filenames = []
+            turn_page_switch = -turn_page_switch
+    else:
+        message = "<div style='color:#999'>Image not found (may have been already moved)</div>"
+
+    return message, filenames, page_index, turn_page_switch
+
+def delete_image(delete_num, name, filenames, image_index, visible_num):
+    if name == "":
+        return filenames, delete_num
+    else:
+        delete_num = int(delete_num)
+        visible_num = int(visible_num)
+        image_index = int(image_index)
+        index = list(filenames).index(name)
+        i = 0
+        new_file_list = []
+        for name in filenames:
+            if i >= index and i < index + delete_num:
+                if os.path.exists(name):
+                    if visible_num == image_index:
+                        new_file_list.append(name)
+                        i += 1
+                        continue
+                    if opts.images_delete_message:
+                        print(f"Deleting file {name}")
+                    delete_recycle(name)
+                    visible_num -= 1
+                    if opts.images_txt_files:
+                        txt_file = totxt(name)
+                        if os.path.exists(txt_file):
+                            delete_recycle(txt_file)
+                else:
+                    print(f"File does not exist {name}")
+            else:
+                new_file_list.append(name)
+            i += 1
+    return new_file_list, 1, visible_num
+
+def traverse_all_files(curr_path, image_list, tabname_box, img_path_depth) -> List[Tuple[str, os.stat_result, str, int]]:
+    global current_depth
+    if curr_path == "":
+        return image_list
+    f_list = [(os.path.join(curr_path, entry.name), entry.stat()) for entry in os.scandir(curr_path)]
+    for f_info in f_list:
+        fname, fstat = f_info
+        if os.path.splitext(fname)[1] in image_ext_list:
+            image_list.append(f_info)
+        elif stat.S_ISDIR(fstat.st_mode):
+            if opts.images_history_with_subdirs or (tabname_box == "Others" and img_path_depth != 0 and (current_depth < img_path_depth or img_path_depth < 0)):
+                current_depth = current_depth + 1
+                image_list = traverse_all_files(fname, image_list, tabname_box, img_path_depth)
+                current_depth = current_depth - 1
+    return image_list
+
+def cache_exif(fileinfos):
+    global finfo_exif, exif_cache, finfo_aes, aes_cache
+
+    if yappi_do:
+        import yappi
+        import pandas as pd
+        yappi.set_clock_type("wall")
+        yappi.start()
+    
+    cache_exif_start = time.time()
+    new_exif = 0
+    new_aes = 0
+    conn, cursor = wib_db.transaction_begin()
+    for fi_info in fileinfos:
+        if any(fi_info[0].endswith(ext) for ext in image_ext_list):
+            found_exif = False
+            found_aes = False
+            if fi_info[0] in exif_cache:
+                finfo_exif[fi_info[0]] = exif_cache[fi_info[0]]
+                found_exif = True
+            if fi_info[0] in aes_cache:
+                finfo_aes[fi_info[0]] = aes_cache[fi_info[0]]
+                found_aes = True
+            if not found_exif or not found_aes:
+                finfo_exif[fi_info[0]] = "0"
+                exif_cache[fi_info[0]] = "0"
+                finfo_aes[fi_info[0]] = "0"
+                aes_cache[fi_info[0]] = "0"
+                if fi_info[0].endswith(image_ext_list[0]):
+                    image = PngImageFile(fi_info[0])
+                else:
+                    image = JpegImageFile(fi_info[0])
+                allExif = modules.extras.run_pnginfo(image)[1]
+                if allExif:
+                    finfo_exif[fi_info[0]] = allExif
+                    exif_cache[fi_info[0]] = allExif
+                    wib_db.update_exif_data(conn, fi_info[0], allExif)
+                    new_exif = new_exif + 1
+                    m = re.search("(?:aesthetic_score:|Score:) (\d+.\d+)", allExif)
+                    if m:
+                        aes_value = m.group(1)
+                    else:
+                        aes_value = "0"
+                    finfo_aes[fi_info[0]] = aes_value
+                    aes_cache[fi_info[0]] = aes_value
+                    wib_db.update_aes_data(conn, fi_info[0], aes_value)
+                    new_aes = new_aes + 1
+                else:
+                    try:
+                        filename = os.path.splitext(fi_info[0])[0] + ".txt"
+                        geninfo = ""
+                        with open(filename) as f:
+                            for line in f:
+                                geninfo += line
+                        finfo_exif[fi_info[0]] = geninfo
+                        exif_cache[fi_info[0]] = geninfo
+                        wib_db.update_exif_data(conn, fi_info[0], geninfo)
+                        new_exif = new_exif + 1
+                        m = re.search("(?:aesthetic_score:|Score:) (\d+.\d+)", geninfo)
+                        if m:
+                            aes_value = m.group(1)
+                        else:
+                            aes_value = "0"
+                        finfo_aes[fi_info[0]] = aes_value
+                        aes_cache[fi_info[0]] = aes_value
+                        wib_db.update_aes_data(conn, fi_info[0], aes_value)
+                        new_aes = new_aes + 1
+                    except Exception:
+                        logger.warning(f"No EXIF in PNG/JPG or txt file for {fi_info[0]}")
+                        # Saved with defaults to not scan it again next time
+                        finfo_exif[fi_info[0]] = "0"
+                        exif_cache[fi_info[0]] = "0"
+                        allExif = "0"
+                        wib_db.update_exif_data(conn, fi_info[0], allExif)
+                        new_exif = new_exif + 1
+                        aes_value = "0"
+                        finfo_aes[fi_info[0]] = aes_value
+                        aes_cache[fi_info[0]] = aes_value
+                        wib_db.update_aes_data(conn, fi_info[0], aes_value)
+                        new_aes = new_aes + 1
+    
+    wib_db.transaction_end(conn, cursor)
+
+    if yappi_do:
+        yappi.stop()
+        pd.set_option('display.float_format', lambda x: '%.6f' % x)
+        yappi_stats = yappi.get_func_stats().strip_dirs()
+        data = [(s.name, s.ncall, s.tsub, s.ttot, s.ttot/s.ncall) for s in yappi_stats]
+        df = pd.DataFrame(data, columns=['name', 'ncall', 'tsub', 'ttot', 'tavg'])
+        print(df.to_string(index=False))
+        yappi.get_thread_stats().print_all()
+
+    cache_exif_end = time.time()
+    logger.debug(f"cache_exif: {new_exif}/{len(fileinfos)} cache_aes: {new_aes}/{len(fileinfos)} {round(cache_exif_end - cache_exif_start, 1)} seconds")
+
+def atof(text):
+    try:
+        retval = float(text)
+    except ValueError:
+        retval = text
+    return retval
+
+def natural_keys(text):
+    '''
+    alist.sort(key=natural_keys) sorts in human order
+    http://nedbatchelder.com/blog/200712/human_sorting.html
+    (See Toothy's implementation in the comments)
+    float regex comes from https://stackoverflow.com/a/12643073/190597
+    '''
+    return [ atof(c) for c in re.split(r'[+-]?([0-9]+(?:[.][0-9]*)?|[.][0-9]+)', text) ]
+
+
+def get_all_images(dir_name, sort_by, sort_order, keyword, tabname_box, img_path_depth, ranking_filter, aes_filter, exif_keyword, negative_prompt_search):
+    global current_depth
+    current_depth = 0
+    fileinfos = traverse_all_files(dir_name, [], tabname_box, img_path_depth)
+    keyword = keyword.strip(" ")
+    
+    if opts.images_scan_exif:
+        cache_exif(fileinfos)
+    
+    if len(keyword) != 0:
+        fileinfos = [x for x in fileinfos if keyword.lower() in x[0].lower()]
+        filenames = [finfo[0] for finfo in fileinfos]
+    if len(exif_keyword) != 0:
+        if negative_prompt_search == "Yes":
+            fileinfos = [x for x in fileinfos if exif_keyword.lower() in finfo_exif[x[0]].lower()]
+        else:
+            result = []
+            for file_info in fileinfos:
+                file_name = file_info[0]
+                file_exif = finfo_exif[file_name].lower()
+                start_index = file_exif.find("negative prompt: ")
+                end_index = file_exif.find("\n", start_index)
+                if negative_prompt_search == "Only":
+                    sub_string = file_exif[start_index:end_index].split("negative prompt: ")[-1].strip()
+                    if exif_keyword.lower() in sub_string:
+                        result.append(file_info)
+                else:
+                    sub_string = file_exif[start_index:end_index].strip()
+                    file_exif = file_exif.replace(sub_string, "")
+                    
+                    if exif_keyword.lower() in file_exif:
+                        result.append(file_info)
+            fileinfos = result
+        filenames = [finfo[0] for finfo in fileinfos]
+    if len(aes_filter) != 0:
+        fileinfos = [x for x in fileinfos if finfo_aes[x[0]] >= aes_filter]
+        filenames = [finfo[0] for finfo in fileinfos]   
+    if ranking_filter != "All":
+        fileinfos = [x for x in fileinfos if get_ranking(x[0]) in ranking_filter]
+        filenames = [finfo[0] for finfo in fileinfos]
+    if sort_by == "date":
+        if sort_order == up_symbol:
+            fileinfos = sorted(fileinfos, key=lambda x: x[1].st_mtime)
+        else:
+            fileinfos = sorted(fileinfos, key=lambda x: -x[1].st_mtime)
+        filenames = [finfo[0] for finfo in fileinfos]
+    elif sort_by == "path name":
+        if sort_order == up_symbol:
+            fileinfos = sorted(fileinfos)
+        else:
+            fileinfos = sorted(fileinfos, reverse=True)
+        filenames = [finfo[0] for finfo in fileinfos]
+    elif sort_by == "random":
+        random.shuffle(fileinfos)
+        filenames = [finfo[0] for finfo in fileinfos]
+    elif sort_by == "ranking":
+        finfo_ranked = {}
+        for fi_info in fileinfos:
+            finfo_ranked[fi_info[0]] = get_ranking(fi_info[0])
+        if not down_symbol:
+            fileinfos = dict(sorted(finfo_ranked.items(), key=lambda x: (x[1], x[0])))
+        else:
+            fileinfos = dict(reversed(sorted(finfo_ranked.items(), key=lambda x: (x[1], x[0]))))
+        filenames = [finfo for finfo in fileinfos]
+    elif sort_by == "aesthetic_score":
+        fileinfo_aes = {}
+        for finfo in fileinfos:
+            fileinfo_aes[finfo[0]] = finfo_aes[finfo[0]]
+        if down_symbol:
+            fileinfos = dict(reversed(sorted(fileinfo_aes.items(), key=lambda x: (x[1], x[0]))))
+        else:
+            fileinfos = dict(sorted(fileinfo_aes.items(), key=lambda x: (x[1], x[0])))
+        filenames = [finfo for finfo in fileinfos]
+    else:
+        sort_values = {}
+        exif_info = dict(finfo_exif)
+        if exif_info:
+            for k, v in exif_info.items():
+                match = re.search(r'(?<='+ sort_by.lower() + ":" ').*?(?=(,|$))', v.lower())
+                if match:
+                    sort_values[k] = match.group()
+                else:
+                    sort_values[k] = "0"
+            if down_symbol:
+                fileinfos = dict(reversed(sorted(fileinfos, key=lambda x: natural_keys(sort_values[x[0]]))))
+            else:
+                fileinfos = dict(sorted(fileinfos, key=lambda x: natural_keys(sort_values[x[0]])))
+            filenames = [finfo for finfo in fileinfos]
+        else:
+            filenames = [finfo for finfo in fileinfos]
+    return filenames
+
+def get_image_page(img_path, page_index, filenames, keyword, sort_by, sort_order, tabname_box, img_path_depth, ranking_filter, aes_filter, exif_keyword, negative_prompt_search):
+    if img_path == "":
+        return [], page_index, [],  "", "",  "", 0, ""
+
+    img_path, _ = pure_path(img_path)
+    if page_index == 1 or page_index == 0 or len(filenames) == 0:
+        filenames = get_all_images(img_path, sort_by, sort_order, keyword, tabname_box, img_path_depth, ranking_filter, aes_filter, exif_keyword, negative_prompt_search)
+    page_index = int(page_index)
+    length = len(filenames)
+    max_page_index = length // num_of_imgs_per_page + 1
+    page_index = max_page_index if page_index == -1 else page_index
+    page_index = 1 if page_index < 1 else page_index
+    page_index = max_page_index if page_index > max_page_index else page_index
+    idx_frm = (page_index - 1) * num_of_imgs_per_page
+    image_list = filenames[idx_frm:idx_frm + num_of_imgs_per_page]
+    
+    visible_num = num_of_imgs_per_page if  idx_frm + num_of_imgs_per_page < length else length % num_of_imgs_per_page 
+    visible_num = num_of_imgs_per_page if visible_num == 0 else visible_num
+
+    load_info = "<div style='color:#999' align='center'>"
+    load_info += f"{length} images in this directory, divided into {int((length + 1) // num_of_imgs_per_page  + 1)} pages"
+    load_info += "</div>"
+    return filenames, gr.update(value=page_index, label=f"Page Index (of {max_page_index} pages)"), image_list,  "", "",  "", visible_num, load_info
+
+def get_current_file(tabname_box, num, page_index, filenames):
+    file = filenames[int(num) + int((page_index - 1) * num_of_imgs_per_page)]
+    return file
+    
+def show_image_info(tabname_box, num, page_index, filenames):
+    file = filenames[int(num) + int((page_index - 1) * num_of_imgs_per_page)]
+    tm =   "<div style='color:#999' align='right'>" + time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(os.path.getmtime(file))) + "</div>"
+    return file, tm, num, file, ""
+
+def show_next_image_info(tabname_box, num, page_index, filenames, auto_next):
+    file = filenames[int(num) + int((page_index - 1) * num_of_imgs_per_page)]
+    tm =   "<div style='color:#999' align='right'>" + time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(os.path.getmtime(file))) + "</div>"
+    if auto_next:
+        num = int(num) + 1
+    return file, tm, num, file, ""
+
+def change_dir(img_dir, path_recorder, load_switch, img_path_history, img_path_depth, img_path):
+    warning = None
+    img_path, _ = pure_path(img_path)
+    img_path_depth_org = img_path_depth
+    if img_dir == none_select:
+        return warning, gr.update(visible=False), img_path_history, path_recorder, load_switch, img_path, img_path_depth
+    else:
+        img_dir, img_path_depth = pure_path(img_dir)
+        if warning is None:
+            try:
+                if os.path.exists(img_dir):
+                    try:
+                        f = os.listdir(img_dir)                
+                    except:
+                        warning = f"'{img_dir} is not a directory"
+                else:
+                    warning = "The directory does not exist"
+            except:
+                warning = "The format of the directory is incorrect"   
+        if warning is None: 
+            return "", gr.update(visible=True), img_path_history, path_recorder, img_dir, img_dir, img_path_depth
+        else:
+            return warning, gr.update(visible=False), img_path_history, path_recorder, load_switch, img_path, img_path_depth_org
+
+def update_move_text(unused):
+    return f'{"Move" if not opts.images_copy_image else "Copy"} to favorites'
+
+def get_ranking(filename):
+    ranking_value = wib_db.select_ranking(filename)
+    return ranking_value
+
+def create_tab(tabname):
+    global init, exif_cache, aes_cache
+    custom_dir = False
+    path_recorder = {}
+    path_recorder_formatted = []
+
+    if init:
+        wib_db.check()
+        exif_cache = wib_db.load_exif_data(exif_cache)
+        aes_cache = wib_db.load_aes_data(aes_cache)
+        init = False
+
+    if tabname == "txt2img":
+        dir_name = opts.outdir_txt2img_samples
+    elif tabname == "img2img":
+        dir_name = opts.outdir_img2img_samples
+    elif tabname == "txt2img-grids":    #added by HaylockGrant to add a new tab for grid images
+        dir_name = opts.outdir_txt2img_grids
+    elif tabname == "img2img-grids":    #added by HaylockGrant to add a new tab for grid images
+        dir_name = opts.outdir_img2img_grids
+    elif tabname == "Extras":
+        dir_name = opts.outdir_extras_samples
+    elif tabname == favorite_tab_name:
+        dir_name = opts.outdir_save
+    else:
+        custom_dir = True
+        dir_name = None        
+        path_recorder, path_recorder_formatted = read_path_recorder(path_recorder, path_recorder_formatted)
+
+    if not custom_dir:
+        dir_name = str(Path(dir_name))
+        if not os.path.exists(dir_name):
+            os.makedirs(dir_name)
+
+    with gr.Row():                 
+        warning_box = gr.HTML("<p>&nbsp") 
+
+    with gr.Row(visible= custom_dir): 
+        with gr.Column(scale=10):
+            img_path = gr.Textbox(dir_name, label="Images directory", placeholder="Input images directory", interactive=custom_dir)  
+        with gr.Column(scale=1):
+            img_path_depth = gr.Number(value="0", label="Sub directory depth")
+        with gr.Column(scale=1):
+            img_path_save_button = gr.Button(value="Add to / replace in saved directories")
+
+    with gr.Row(visible= custom_dir): 
+        with gr.Column(scale=10):
+            img_path_history = gr.Dropdown(choices=path_recorder_formatted, label="Saved directories")
+        with gr.Column(scale=1):
+            img_path_remove_button = gr.Button(value="Remove from saved directories")
+            path_recorder = gr.State(path_recorder)
+
+    with gr.Row(visible= custom_dir): 
+        with gr.Column(scale=10):
+            img_path_subdirs = gr.Dropdown(choices=[none_select], value=none_select, label="Sub directories", interactive=True, elem_id="img_path_subdirs")
+        with gr.Column(scale=1):
+            img_path_subdirs_button = gr.Button(value="Get sub directories")
+        
+    with gr.Row(visible= not custom_dir, elem_id=tabname + "_images_history") as main_panel:
+        with gr.Column():  
+            with gr.Row():    
+                with gr.Column(scale=2):    
+                    with gr.Row():       
+                        first_page = gr.Button('First Page')
+                        prev_page = gr.Button('Prev Page')
+                        page_index = gr.Number(value=1, label="Page Index")
+                        refresh_index_button = ToolButton(value=refresh_symbol)
+                        next_page = gr.Button('Next Page')
+                        end_page = gr.Button('End Page') 
+                    with gr.Column(scale=10):                            
+                        ranking = gr.Radio(value="None", choices=["1", "2", "3", "4", "5", "None"], label="ranking", elem_id=f"{tabname}_images_ranking", interactive=True, visible=False)
+                        auto_next = gr.Checkbox(label="Next Image After Ranking (To be implemented)", interactive=False, visible=False)
+                    history_gallery = gr.Gallery(show_label=False, elem_id=tabname + "_images_history_gallery").style(grid=opts.images_history_page_columns)
+                    with gr.Row() as delete_panel:
+                        with gr.Column(scale=1):
+                            delete_num = gr.Number(value=1, interactive=True, label="delete next")
+                        with gr.Column(scale=3):
+                            delete = gr.Button('Delete', elem_id=tabname + "_images_history_del_button")
+                
+                with gr.Column(scale=1): 
+                    with gr.Row(scale=0.5):
+                        sort_by = gr.Dropdown(value="date", choices=["path name", "date", "aesthetic_score", "random", "cfg scale", "steps", "seed", "sampler", "size", "model", "model hash", "ranking"], label="sort by")
+                        sort_order = ToolButton(value=down_symbol)
+                    with gr.Row():
+                        keyword = gr.Textbox(value="", label="filename keyword")
+                    with gr.Row():
+                            exif_keyword = gr.Textbox(value="", label="exif keyword")
+                            negative_prompt_search = gr.Radio(value="No", choices=["No", "Yes", "Only"], label="Include negative prompt in exif search", interactive=True)
+                    with gr.Column():
+                        ranking_filter = gr.Radio(value="All", choices=["All", "1", "2", "3", "4", "5", "None"], label="ranking filter", interactive=True)
+                    with gr.Row():  
+                        aes_filter = gr.Textbox(value="", label="minimum aesthetic_score")
+                    with gr.Row():
+                        with gr.Column():
+                            img_file_info = gr.Textbox(label="Generate Info", interactive=False, lines=6)
+                            img_file_name = gr.Textbox(value="", label="File Name", interactive=False)
+                            img_file_time= gr.HTML()
+                    with gr.Row(elem_id=tabname + "_images_history_button_panel") as button_panel:
+                        if tabname != favorite_tab_name:
+                            save_btn = gr.Button(f'{"Move" if not opts.images_copy_image else "Copy"} to favorites')
+                        try:
+                            send_to_buttons = modules.generation_parameters_copypaste.create_buttons(["txt2img", "img2img", "inpaint", "extras"])
+                        except:
+                            pass
+                    with gr.Row():
+                        collected_warning = gr.HTML()
+                    
+                            
+                    # hidden items
+                    with gr.Row(visible=False): 
+                        renew_page = gr.Button("Renew Page", elem_id=tabname + "_images_history_renew_page")
+                        visible_img_num = gr.Number()                     
+                        tabname_box = gr.Textbox(tabname)
+                        image_index = gr.Textbox(value=-1)
+                        set_index = gr.Button('set_index', elem_id=tabname + "_images_history_set_index")
+                        filenames = gr.State([])
+                        all_images_list = gr.State()
+                        hidden = gr.Image(type="pil")
+                        info1 = gr.Textbox()
+                        info2 = gr.Textbox()
+                        load_switch = gr.Textbox(value="load_switch", label="load_switch")
+                        turn_page_switch = gr.Number(value=1, label="turn_page_switch")
+                        img_path_add = gr.Textbox(value="add")
+                        img_path_remove = gr.Textbox(value="remove")
+
+    change_dir_outputs = [warning_box, main_panel, img_path_history, path_recorder, load_switch, img_path, img_path_depth]
+    img_path.submit(change_dir, inputs=[img_path, path_recorder, load_switch, img_path_history, img_path_depth, img_path], outputs=change_dir_outputs)
+    img_path_history.change(change_dir, inputs=[img_path_history, path_recorder, load_switch, img_path_history, img_path_depth, img_path], outputs=change_dir_outputs)
+    # img_path_history.change(history2path, inputs=[img_path_history], outputs=[img_path])
+
+    #delete
+    delete.click(delete_image, inputs=[delete_num, img_file_name, filenames, image_index, visible_img_num], outputs=[filenames, delete_num, visible_img_num])
+    delete.click(fn=None, _js="images_history_delete", inputs=[delete_num, tabname_box, image_index], outputs=None) 
+    if tabname != favorite_tab_name: 
+        save_btn.click(save_image, inputs=[img_file_name, filenames, page_index, turn_page_switch], outputs=[collected_warning, filenames, page_index, turn_page_switch])
+        img_file_name.change(fn=update_move_text, inputs=[img_file_name], outputs=[save_btn])
+
+    #turn page
+    first_page.click(lambda s:(1, -s) , inputs=[turn_page_switch], outputs=[page_index, turn_page_switch])
+    next_page.click(lambda p, s: (p + 1, -s), inputs=[page_index, turn_page_switch], outputs=[page_index, turn_page_switch])
+    prev_page.click(lambda p, s: (p - 1, -s), inputs=[page_index, turn_page_switch], outputs=[page_index, turn_page_switch])
+    end_page.click(lambda s: (-1, -s), inputs=[turn_page_switch], outputs=[page_index, turn_page_switch])    
+    load_switch.change(lambda s:(1, -s), inputs=[turn_page_switch], outputs=[page_index, turn_page_switch])
+    keyword.submit(lambda s:(1, -s), inputs=[turn_page_switch], outputs=[page_index, turn_page_switch])
+    exif_keyword.submit(lambda s:(1, -s), inputs=[turn_page_switch], outputs=[page_index, turn_page_switch])
+    aes_filter.submit(lambda s:(1, -s), inputs=[turn_page_switch], outputs=[page_index, turn_page_switch])
+    sort_by.change(lambda s:(1, -s), inputs=[turn_page_switch], outputs=[page_index, turn_page_switch])
+    ranking_filter.change(lambda s:(1, -s), inputs=[turn_page_switch], outputs=[page_index, turn_page_switch])
+    page_index.submit(lambda s: -s, inputs=[turn_page_switch], outputs=[turn_page_switch])
+    renew_page.click(lambda s: -s, inputs=[turn_page_switch], outputs=[turn_page_switch])
+    refresh_index_button.click(lambda p, s:(p, -s), inputs=[page_index, turn_page_switch], outputs=[page_index, turn_page_switch])
+    img_path_depth.change(lambda s: -s, inputs=[turn_page_switch], outputs=[turn_page_switch])
+
+    turn_page_switch.change(
+        fn=get_image_page, 
+        inputs=[img_path, page_index, filenames, keyword, sort_by, sort_order, tabname_box, img_path_depth, ranking_filter, aes_filter, exif_keyword, negative_prompt_search], 
+        outputs=[filenames, page_index, history_gallery, img_file_name, img_file_time, img_file_info, visible_img_num, warning_box]
+    )
+    turn_page_switch.change(fn=None, inputs=[tabname_box], outputs=None, _js="images_history_turnpage")
+    turn_page_switch.change(fn=lambda:(gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)), inputs=None, outputs=[delete_panel, button_panel, ranking])
+
+    sort_order.click(
+        fn=sort_order_flip,
+        inputs=[turn_page_switch, sort_order],
+        outputs=[page_index, turn_page_switch, sort_order]
+    )
+
+    # Others
+    img_path_subdirs_button.click(
+        fn=img_path_subdirs_get, 
+        inputs=[img_path], 
+        outputs=[img_path_subdirs]
+    )
+    img_path_subdirs.change(
+        fn=change_dir, 
+        inputs=[img_path_subdirs, path_recorder, load_switch, img_path_history, img_path_depth, img_path], 
+        outputs=change_dir_outputs
+    )
+    img_path_save_button.click(
+        fn=img_path_add_remove, 
+        inputs=[img_path, path_recorder, img_path_add, img_path_depth], 
+        outputs=[path_recorder, img_path_history]
+    )
+    img_path_remove_button.click(
+        fn=img_path_add_remove, 
+        inputs=[img_path, path_recorder, img_path_remove], 
+        outputs=[path_recorder, img_path_history]
+    )
+
+    # other functions
+    set_index.click(show_image_info, _js="images_history_get_current_img", inputs=[tabname_box, image_index, page_index, filenames], outputs=[img_file_name, img_file_time, image_index, hidden])
+    set_index.click(fn=lambda:(gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)), inputs=None, outputs=[delete_panel, button_panel, ranking])
+    img_file_name.change(fn=lambda : "", inputs=None, outputs=[collected_warning])
+    img_file_name.change(get_ranking, inputs=img_file_name, outputs=ranking)
+
+   
+    hidden.change(fn=run_pnginfo, inputs=[hidden, img_path, img_file_name], outputs=[info1, img_file_info, info2])
+    
+    #ranking
+    ranking.change(wib_db.update_ranking, inputs=[img_file_name, ranking])
+    #ranking.change(show_next_image_info, _js="images_history_get_current_img", inputs=[tabname_box, image_index, page_index, auto_next], outputs=[img_file_name, img_file_time, image_index, hidden])
+        
+    try:
+        modules.generation_parameters_copypaste.bind_buttons(send_to_buttons, hidden, img_file_info)
+    except:
+        pass
+    
+def run_pnginfo(image, image_path, image_file_name):
+    if image is None:
+        return '', '', ''
+    geninfo, items = images.read_info_from_image(image)
+    items = {**{'parameters': geninfo}, **items}
+
+    info = ''
+    for key, text in items.items():
+        info += f"""
+<div>
+<p><b>{plaintext_to_html(str(key))}</b></p>
+<p>{plaintext_to_html(str(text))}</p>
+</div>
+""".strip()+"\n"
+    
+    if geninfo is None:
+        try:
+            filename = os.path.splitext(image_file_name)[0] + ".txt"
+            geninfo = ""
+            with open(filename) as f:
+                for line in f:
+                    geninfo += line
+        except Exception:
+            logger.warning(f"No EXIF in PNG or txt file")
+    return '', geninfo, info
+
+
+def on_ui_tabs():
+    global num_of_imgs_per_page
+    global loads_files_num
+    num_of_imgs_per_page = int(opts.images_history_page_columns * opts.images_history_page_rows)
+    loads_files_num = int(opts.images_history_pages_perload * num_of_imgs_per_page)
+    with gr.Blocks(analytics_enabled=False) as images_history:
+        with gr.Tabs(elem_id="images_history_tab") as tabs:
+            for tab in tabs_list:
+                with gr.Tab(tab, elem_id=f"{tab}_images_history_container"):
+                    with gr.Blocks(analytics_enabled=False) :
+                        create_tab(tab)
+        gr.Checkbox(opts.images_history_preload, elem_id="images_history_preload", visible=False)         
+        gr.Textbox(",".join(tabs_list), elem_id="images_history_tabnames_list", visible=False) 
+    return (images_history , "Image Browser", "images_history"),
+
+def on_ui_settings():
+    section = ('images-history', "Images Browser")
+    shared.opts.add_option("images_history_with_subdirs", shared.OptionInfo(True, "Include images in sub directories", section=section))
+    shared.opts.add_option("images_history_preload", shared.OptionInfo(False, "Preload images at startup", section=section))
+    shared.opts.add_option("images_copy_image", shared.OptionInfo(False, "Move to favorites button copies instead of moving", section=section))
+    shared.opts.add_option("images_delete_message", shared.OptionInfo(True, "Print image deletion messages to the console", section=section))
+    shared.opts.add_option("images_txt_files", shared.OptionInfo(True, "Move/Copy/Delete matching .txt files", section=section))
+    shared.opts.add_option("images_logger_warning", shared.OptionInfo(False, "Print warning logs to the console", section=section))
+    shared.opts.add_option("images_logger_debug", shared.OptionInfo(False, "Print debug logs to the console", section=section))
+    shared.opts.add_option("images_delete_recycle", shared.OptionInfo(False, "Use recycle bin when deleting images", section=section))
+    shared.opts.add_option("images_scan_exif", shared.OptionInfo(True, "Scan Exif-/.txt-data (slower, but required for exif-keyword-search)", section=section))
+
+    shared.opts.add_option("images_history_page_columns", shared.OptionInfo(6, "Number of columns on the page", section=section))
+    shared.opts.add_option("images_history_page_rows", shared.OptionInfo(6, "Number of rows on the page", section=section))
+    shared.opts.add_option("images_history_pages_perload", shared.OptionInfo(20, "Minimum number of pages per load", section=section))
+
+
+script_callbacks.on_ui_settings(on_ui_settings)
+script_callbacks.on_ui_tabs(on_ui_tabs)

extensions/SD-images-browser-main/scripts/wib/wib_db.py

@@ -0,0 +1,340 @@
+import json
+import os
+import sqlite3
+from modules import scripts
+
+path_recorder_file = os.path.join(scripts.basedir(), "path_recorder.txt")
+aes_cache_file = os.path.join(scripts.basedir(), "aes_scores.json")
+exif_cache_file = os.path.join(scripts.basedir(), "exif_data.json")
+ranking_file = os.path.join(scripts.basedir(), "ranking.json")
+archive = os.path.join(scripts.basedir(), "archive")
+db_file = os.path.join(scripts.basedir(), "wib.sqlite3")
+np = "Negative prompt: "
+st = "Steps: "
+
+def create_db(cursor):
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS db_data (
+            key TEXT PRIMARY KEY,
+            value TEXT
+        )
+    ''')
+
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS path_recorder (
+            path TEXT PRIMARY KEY,
+            depth INT,
+            path_display TEXT,
+            created TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+
+    cursor.execute('''
+        CREATE TRIGGER path_recorder_tr 
+        AFTER UPDATE ON path_recorder
+        BEGIN
+            UPDATE path_recorder SET updated = CURRENT_TIMESTAMP WHERE path = OLD.path;
+        END;
+    ''')
+
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS exif_data (
+            file TEXT,
+            key TEXT,
+            value TEXT,
+            created TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (file, key)
+        )
+    ''')
+
+    cursor.execute('''
+        CREATE INDEX IF NOT EXISTS exif_data_key ON exif_data (key)
+    ''')
+
+    cursor.execute('''
+        CREATE TRIGGER exif_data_tr 
+        AFTER UPDATE ON exif_data
+        BEGIN
+            UPDATE exif_data SET updated = CURRENT_TIMESTAMP WHERE file = OLD.file AND key = OLD.key;
+        END;
+    ''')
+
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS ranking (
+            file TEXT PRIMARY KEY,
+            ranking TEXT,
+            created TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+
+    cursor.execute('''
+        CREATE TRIGGER ranking_tr 
+        AFTER UPDATE ON ranking
+        BEGIN
+            UPDATE ranking SET updated = CURRENT_TIMESTAMP WHERE file = OLD.file;
+        END;
+    ''')
+
+    return
+
+def migrate_path_recorder(cursor):
+    if os.path.exists(path_recorder_file):
+        try:
+            with open(path_recorder_file) as f:
+                # json-version
+                path_recorder = json.load(f)
+            for path, values in path_recorder.items():
+                depth = values["depth"]
+                path_display = values["path_display"]
+                cursor.execute('''
+                INSERT INTO path_recorder (path, depth, path_display)
+                VALUES (?, ?, ?)
+                ''', (path, depth, path_display))
+        except json.JSONDecodeError:
+            with open(path_recorder_file) as f:
+                # old txt-version
+                path = f.readline().rstrip("\n")
+                while len(path) > 0:
+                    cursor.execute('''
+                    INSERT INTO path_recorder (path, depth, path_display)
+                    VALUES (?, ?, ?)
+                    ''', (path, 0, f"{path} [0]"))
+                    path = f.readline().rstrip("\n")
+
+    return
+
+def update_exif_data(cursor, file, info):
+    prompt = "0"
+    negative_prompt = "0"
+    key_values = "0: 0"
+    if info != "0":
+        info_list = info.split("\n")
+        prompt = ""
+        negative_prompt = ""
+        key_values = ""
+        for info_item in info_list:
+            if info_item.startswith(st):
+                key_values = info_item
+            elif info_item.startswith(np):
+                negative_prompt = info_item.replace(np, "")
+            else:
+                prompt = info_item
+    if key_values != "":
+        key_value_pairs = []
+        key_value = ""
+        quote_open = False
+        for char in key_values + ",":
+            key_value += char
+            if char == '"':
+                quote_open = not quote_open
+            if char == "," and not quote_open:
+                try:
+                    k, v = key_value.strip(" ,").split(": ")
+                except ValueError:
+                    k = key_value.strip(" ,").split(": ")[0]
+                    v = ""
+                key_value_pairs.append((k, v))
+                key_value = ""
+
+                try:
+                    cursor.execute('''
+                    INSERT INTO exif_data (file, key, value)
+                    VALUES (?, ?, ?)
+                    ''', (file, "prompt", prompt))
+                except sqlite3.IntegrityError:
+                    # Duplicate, delete all "file" entries and try again
+                    cursor.execute('''
+                    DELETE FROM exif_data
+                    WHERE file = ?
+                    ''', (file,))
+
+                    cursor.execute('''
+                    INSERT INTO exif_data (file, key, value)
+                    VALUES (?, ?, ?)
+                    ''', (file, "prompt", prompt))
+
+                cursor.execute('''
+                INSERT INTO exif_data (file, key, value)
+                VALUES (?, ?, ?)
+                ''', (file, "negative_prompt", negative_prompt))
+                
+                for (key, value) in key_value_pairs:
+                    try:
+                        cursor.execute('''
+                        INSERT INTO exif_data (file, key, value)
+                        VALUES (?, ?, ?)
+                        ''', (file, key, value))
+                    except sqlite3.IntegrityError:
+                        pass
+    
+    return
+
+def migrate_exif_data(cursor):
+    if os.path.exists(exif_cache_file):
+        with open(exif_cache_file, 'r') as file:
+        #with open("c:\\tools\\ai\\stable-diffusion-webui\\extensions\\stable-diffusion-webui-images-browser\\test.json ", 'r') as file:
+            exif_cache = json.load(file)
+        
+        for file, info in exif_cache.items():
+            update_exif_data(cursor, file, info)
+    
+    return
+
+def migrate_ranking(cursor):
+    if os.path.exists(ranking_file):
+        with open(ranking_file, 'r') as file:
+            ranking = json.load(file)
+        for file, info in ranking.items():
+            if info != "None":
+                cursor.execute('''
+                INSERT INTO ranking (file, ranking)
+                VALUES (?, ?)
+                ''', (file, info))
+
+    return
+
+def update_db_data(cursor, key, value):
+    cursor.execute('''
+    INSERT OR REPLACE
+    INTO db_data (key, value)
+    VALUES (?, ?)
+    ''', (key, value))
+    
+    return
+
+def check():
+    if not os.path.exists(db_file):
+        conn, cursor = transaction_begin()
+        create_db(cursor)
+        update_db_data(cursor, "version", "1")
+        migrate_path_recorder(cursor)
+        migrate_exif_data(cursor)
+        migrate_ranking(cursor)
+        transaction_end(conn, cursor)
+
+    return
+
+def load_path_recorder():
+    with sqlite3.connect(db_file) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+        SELECT path, depth, path_display
+        FROM path_recorder
+        ''')
+        path_recorder = {path: {"depth": depth, "path_display": path_display} for path, depth, path_display in cursor.fetchall()}
+
+    return path_recorder
+
+def select_ranking(filename):
+    with sqlite3.connect(db_file) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+        SELECT ranking
+        FROM ranking
+        WHERE file = ?
+        ''', (filename,))
+        ranking_value = cursor.fetchone()
+
+    if ranking_value is None:
+        ranking_value = ["0"]
+    return ranking_value[0]
+
+def update_ranking(file, ranking):
+    if ranking != "0":
+        with sqlite3.connect(db_file) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+            INSERT OR REPLACE
+            INTO ranking (file, ranking)
+            VALUES (?, ?)
+            ''', (file, ranking))
+    
+    return
+
+def update_path_recorder(path, depth, path_display):
+    with sqlite3.connect(db_file) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+        INSERT OR REPLACE
+        INTO path_recorder (path, depth, path_display)
+        VALUES (?, ?, ?)
+        ''', (path, depth, path_display))
+    
+    return
+
+def delete_path_recorder(path):
+    with sqlite3.connect(db_file) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+        DELETE FROM path_recorder
+        WHERE path = ?
+        ''', (path,))
+    
+    return
+
+def transaction_begin():
+    conn = sqlite3.connect(db_file)
+    conn.isolation_level = None
+    cursor = conn.cursor()
+    cursor.execute("BEGIN")
+    return conn, cursor
+
+def transaction_end(conn, cursor):
+    cursor.execute("COMMIT")
+    conn.close()
+    return
+
+def update_aes_data(cursor, file, value):
+    key = "aesthetic_score"
+
+    cursor.execute('''
+    INSERT OR REPLACE
+    INTO exif_data (file, key, value)
+    VALUES (?, ?, ?)
+    ''', (file, key, value))
+
+    return
+
+def load_exif_data(exif_cache):
+    with sqlite3.connect(db_file) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+        SELECT file, group_concat(
+            case when key = 'prompt' or key = 'negative_prompt' then key || ': ' || value || '\n'
+            else key || ': ' || value
+            end, ', ') AS string
+        FROM (
+            SELECT *
+            FROM exif_data
+            ORDER BY
+                CASE WHEN key = 'prompt' THEN 0
+                    WHEN key = 'negative_prompt' THEN 1
+                    ELSE 2 END,
+                key
+        )
+        GROUP BY file
+        ''')
+
+        rows = cursor.fetchall()
+    for row in rows:
+        exif_cache[row[0]] = row[1]
+
+    return exif_cache
+
+def load_aes_data(aes_cache):
+    with sqlite3.connect(db_file) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+        SELECT file, value
+        FROM exif_data
+        WHERE key in ("aesthetic_score", "Score")
+        ''')
+
+        rows = cursor.fetchall()
+    for row in rows:
+        aes_cache[row[0]] = row[1]
+
+    return aes_cache

extensions/SD-rembg-master/.gitignore

@@ -0,0 +1 @@
+__pycache__

extensions/SD-rembg-master/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 AUTOMATIC1111
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

extensions/SD-rembg-master/README.md

@@ -0,0 +1,15 @@
+# Rembg
+
+Extension for [webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui). Removes backgrounds from pictures.
+
+![](preview.png)
+
+Find the UI for rembg in the Extras tab after installing the extension.
+
+# Installation
+
+Install from webui's Extensions tab.
+
+# Credits
+
+* rembg library that does all the work: https://github.com/danielgatis/rembg

extensions/SD-rembg-master/install.py

@@ -0,0 +1,8 @@
+import launch
+
+if not launch.is_installed("rembg"):
+    launch.run_pip("install rembg==2.0.30 --no-deps", "rembg")
+
+for dep in ['onnxruntime', 'pymatting', 'pooch']:
+    if not launch.is_installed(dep):
+        launch.run_pip(f"install {dep}", f"{dep} for REMBG extension")

extensions/SD-rembg-master/scripts/postprocessing_rembg.py

@@ -0,0 +1,61 @@
+from modules import scripts_postprocessing
+import gradio as gr
+
+from modules.ui_components import FormRow
+import rembg
+
+models = [
+    "None",
+    "u2net",
+    "u2netp",
+    "u2net_human_seg",
+    "u2net_cloth_seg",
+    "silueta",
+]
+
+class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
+    name = "Rembg"
+    order = 20000
+    model = None
+
+    def ui(self):
+        with FormRow():
+            model = gr.Dropdown(label="Remove background", choices=models, value="None")
+            return_mask = gr.Checkbox(label="Return mask", value=False)
+            alpha_matting = gr.Checkbox(label="Alpha matting", value=False)
+
+        with FormRow(visible=False) as alpha_mask_row:
+            alpha_matting_erode_size = gr.Slider(label="Erode size", minimum=0, maximum=40, step=1, value=10)
+            alpha_matting_foreground_threshold = gr.Slider(label="Foreground threshold", minimum=0, maximum=255, step=1, value=240)
+            alpha_matting_background_threshold = gr.Slider(label="Background threshold", minimum=0, maximum=255, step=1, value=10)
+
+        alpha_matting.change(
+            fn=lambda x: gr.update(visible=x),
+            inputs=[alpha_matting],
+            outputs=[alpha_mask_row],
+        )
+
+        return {
+            "model": model,
+            "return_mask": return_mask,
+            "alpha_matting": alpha_matting,
+            "alpha_matting_foreground_threshold": alpha_matting_foreground_threshold,
+            "alpha_matting_background_threshold": alpha_matting_background_threshold,
+            "alpha_matting_erode_size": alpha_matting_erode_size,
+        }
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, model, return_mask, alpha_matting, alpha_matting_foreground_threshold, alpha_matting_background_threshold, alpha_matting_erode_size):
+        if model == "None":
+            return
+
+        pp.image = rembg.remove(
+            pp.image,
+            session=rembg.new_session(model),
+            only_mask=return_mask,
+            alpha_matting=alpha_matting,
+            alpha_matting_foreground_threshold=alpha_matting_foreground_threshold,
+            alpha_matting_background_threshold=alpha_matting_background_threshold,
+            alpha_matting_erode_size=alpha_matting_erode_size,
+        )
+
+        pp.info["Rembg"] = model

extensions/SD-two-shot-main/.gitignore

@@ -0,0 +1,129 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

extensions/SD-two-shot-main/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 opparco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

extensions/SD-two-shot-main/README.md

@@ -0,0 +1,76 @@
+# Latent Couple extension (two shot diffusion port)
+This extension is an extension of the built-in Composable Diffusion.
+This allows you to determine the region of the latent space that reflects your subprompts.
+
+## How to use
+![20230303.png](./screenshots/20230303.png)
+![20230213.png](./screenshots/20230213.png)
+
+
+### Enabled
+The effect of Latent Couple appears only when Enabled is checked.
+
+### Divisions, Positions, and Weights
+Regions are created based on these parameters.
+
+### end at this step
+The processing of Latent Couple is performed until the specified step is reached.
+
+### Visualize button and Regions
+Press the Visualize button and you will get an image grid that visualizes the regions represented by the parameters.
+
+### Extra generation params and Apply button
+When you press the Send to button in PNG Info, the parameters of the saved Latent Couple are set to Extra generation params.
+Press the Apply button to actually apply the parameters.
+
+## Extra generation params
+Extra generation params provided by this extension are saved as PNG Info in the output file.
+```
+Latent Couple: "divisions=1:1,1:2,1:2 positions=0:0,0:0,0:1 weights=0.2,0.8,0.8 end at step=20"
+```
+
+## Examples
+parameters
+```
+((ultra-detailed)), ((illustration)), 2girls
+AND ((ultra-detailed)), ((illustration)), 2girls, black hair
+AND ((ultra-detailed)), ((illustration)), 2girls, blonde hair
+Negative prompt: (low quality, worst quality:1.4)
+Steps: 28, Sampler: Euler a, CFG scale: 5, Seed: 722014241, Size: 512x512, Model hash: 3f64f3baf5, Model: Anything-v3.0-fp16, ENSD: 31337, Latent Couple: "divisions=1:1,1:2,1:2 positions=0:0,0:0,0:1 weights=0.2,0.8,0.8 end at step=20", Eta: 0.67
+```
+outputs
+- end at step=20 https://imgur.com/OEaRFgh
+- end at step=4 https://imgur.com/a1kyvhX
+- end at step=0 https://imgur.com/yhGF7g8
+
+
+## ~~Prerequisite for prompt pasting~~
+## ~~Prerequisite for gradio Image and Sketch component bug fix~~
+This fix is no longer suitable for latest webui commit at 22bcc7be, with gradio dependency upgraded to 3.23. 
+
+I'll keep the fix here for people still using older versions of webui.
+
+Activate your venv in webui root directory
+
+For Windows, in cmd
+```
+venv\Scripts\activate.bat
+```
+For Linux
+```
+source venv/bin/activate
+```
+Then, install wheel distribution with bugfix applied
+```
+pip install --force-reinstall --no-deps extensions/stable-diffusion-webui-two-shot/gradio-3.16.2-py3-none-any.whl
+```
+For bugfix related modifications, see https://github.com/ashen-sensored/gradio/tree/3.16.2
+
+
+## Issues
+- ~~The extension's mask color sketching function does not work well with chrome(extreme stuttering) due to gradio's Image component bug.~~ Please keep the browser scaling at 100% while creating blank canvas to avoid the bug. 
+See prerequisite above. The fix is no longer suitable for latest webui version at 22bcc7be, with gradio dependency upgraded to 3.23. 
+
+
+## Credits
+- two shot diffusion.ipynb https://colab.research.google.com/drive/1UdElpQfKFjY5luch9v_LlmSdH7AmeiDe?usp=sharing

extensions/SD-two-shot-main/gradio-3.16.2-py3-none-any.whl

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

extensions/SD-two-shot-main/scripts/sketch_helper.py

@@ -0,0 +1,99 @@
+import numpy as np
+import cv2
+import base64
+
+    
+def count_high_freq_colors(image):
+    im = image.getcolors(maxcolors=1024*1024)
+    sorted_colors = sorted(im, key=lambda x: x[0], reverse=True)
+
+    freqs = [c[0] for c in sorted_colors]
+    mean_freq = sum(freqs) / len(freqs)
+
+    high_freq_colors = [c for c in sorted_colors if c[0] > max(2, mean_freq*1.25)]
+    return high_freq_colors
+
+def get_high_freq_colors(image, similarity_threshold=30):
+    image_copy = image.copy()
+    high_freq_colors = count_high_freq_colors(image)
+    # Check for similar colors and replace the lower frequency color with the higher frequency color in the image
+    for i, (freq1, color1) in enumerate(high_freq_colors):
+        for j, (freq2, color2) in enumerate(high_freq_colors):      
+            if (color_distance(color1, color2) < similarity_threshold) or (color_distance(color1, opaque_color_on_white(color2, 0.5)) < 5):
+              if(freq2 > freq1):
+                replace_color(image_copy, color1, color2)
+            
+    high_freq_colors = count_high_freq_colors(image_copy)
+    print(high_freq_colors)
+    return [high_freq_colors, image_copy]
+    
+def color_quantization(image, color_frequency_list):
+    # Convert the color frequency list to a set of unique colors
+    unique_colors = set([color for _, color in color_frequency_list])
+    
+    # Create a mask for the image with True where the color is in the unique colors set
+    mask = np.any(np.all(image.reshape(-1, 1, 3) == np.array(list(unique_colors)), axis=2), axis=1).reshape(image.shape[:2])
+    
+    # Create a new image with all pixels set to white
+    new_image = np.full_like(image, 255)
+    
+    # Copy the pixels from the original image that have a color in the color frequency list
+    new_image[mask] = image[mask]
+    return new_image
+
+
+def create_binary_mask(img_arr, target_color):
+    # Create mask of pixels with target color
+    mask = np.all(img_arr == target_color, axis=-1)
+
+    # Convert mask to binary matrix
+    binary_matrix = mask.astype(int)
+
+    return binary_matrix
+
+
+def create_binary_matrix_base64(img_arr, target_color):
+    # Create mask of pixels with target color
+    mask = np.all(img_arr == target_color, axis=-1)
+
+    # Convert mask to binary matrix
+    binary_matrix = mask.astype(int)
+    from datetime import datetime
+    binary_file_name = f'mask-{datetime.now().timestamp()}.png'
+    _, im_arr = cv2.imencode('.png', binary_matrix * 255)
+
+    im_bytes = im_arr.tobytes()
+    im_b64 = base64.b64encode(im_bytes).decode('ascii')
+    # binary_matrix = torch.from_numpy(binary_matrix).unsqueeze(0).unsqueeze(0)
+    return mask, im_b64
+
+def create_binary_matrix_img(img_arr, target_color):
+    # Create mask of pixels with target color
+    mask = np.all(img_arr == target_color, axis=-1)
+    
+    # Convert mask to binary matrix
+    binary_matrix = mask.astype(int)
+    from datetime import datetime
+    binary_file_name = f'mask-{datetime.now().timestamp()}.png'
+    cv2.imwrite(binary_file_name, binary_matrix * 255)
+    
+    #binary_matrix = torch.from_numpy(binary_matrix).unsqueeze(0).unsqueeze(0)
+    return binary_file_name
+
+def color_distance(color1, color2):
+    return sum((a - b) ** 2 for a, b in zip(color1, color2)) ** 0.5
+
+def replace_color(image, old_color, new_color):
+    pixels = image.load()
+    width, height = image.size
+    for x in range(width):
+        for y in range(height):
+            if pixels[x, y] == old_color:
+                pixels[x, y] = new_color
+
+def opaque_color_on_white(color, a):
+    r, g, b = color
+    opaque_red = int((1 - a) * 255 + a * r)
+    opaque_green = int((1 - a) * 255 + a * g)
+    opaque_blue = int((1 - a) * 255 + a * b)
+    return (opaque_red, opaque_green, opaque_blue)

extensions/SD-two-shot-main/scripts/two_shot.py

@@ -0,0 +1,594 @@
+import base64
+from typing import List, Dict, Optional, Tuple
+from dataclasses import dataclass
+
+import torch
+
+from scripts.sketch_helper import get_high_freq_colors, color_quantization, create_binary_matrix_base64, create_binary_mask
+import numpy as np
+import cv2
+
+from modules import devices, script_callbacks
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules.script_callbacks import CFGDenoisedParams, on_cfg_denoised
+
+from modules.processing import StableDiffusionProcessing
+
+MAX_COLORS = 12
+switch_values_symbol = '\U000021C5' # ⇅
+
+
+class ToolButton(gr.Button, gr.components.FormComponent):
+    """Small button with single emoji as text, fits inside gradio forms"""
+
+    def __init__(self, **kwargs):
+        super().__init__(variant="tool", **kwargs)
+
+    def get_block_name(self):
+        return "button"
+
+
+# abstract base class for filters
+from abc import ABC, abstractmethod
+
+
+
+
+class Filter(ABC):
+
+    @abstractmethod
+    def create_tensor(self):
+        pass
+
+
+
+@dataclass
+class Division:
+    y: float
+    x: float
+
+
+@dataclass
+class Position:
+    y: float
+    x: float
+    ey: float
+    ex: float
+
+
+
+class RectFilter(Filter):
+    def __init__(self, division: Division, position: Position, weight: float):
+        self.division = division
+        self.position = position
+        self.weight = weight
+
+    def create_tensor(self, num_channels: int, height_b: int, width_b: int) -> torch.Tensor:
+
+        x = torch.zeros(num_channels, height_b, width_b).to(devices.device)
+
+        division_height = height_b / self.division.y
+        division_width = width_b / self.division.x
+        y1 = int(division_height * self.position.y)
+        y2 = int(division_height * self.position.ey)
+        x1 = int(division_width * self.position.x)
+        x2 = int(division_width * self.position.ex)
+
+        x[:, y1:y2, x1:x2] = self.weight
+
+        return x
+
+
+class MaskFilter:
+    def __init__(self, binary_mask: np.array = None, weight: float = None, float_mask: np.array = None):
+        if float_mask is None:
+            self.mask = binary_mask.astype(np.float32) * weight
+        elif binary_mask is None and weight is None:
+            self.mask = float_mask
+        else:
+            raise ValueError('Either float_mask or binary_mask and weight must be provided')
+        self.tensor_mask = torch.tensor(self.mask).to(devices.device)
+
+    def create_tensor(self, num_channels: int, height_b: int, width_b: int) -> torch.Tensor:
+
+
+        # x = torch.zeros(num_channels, height_b, width_b).to(devices.device)
+        # mask = torch.tensor(self.mask).to(devices.device)
+        # downsample mask to x size
+        # mask_bicubic = torch.nn.functional.interpolate(mask.unsqueeze(0).unsqueeze(0), size=(height_b, width_b), mode='bicubic').squeeze(0).squeeze(0).cpu().numpy()
+        #
+        # mask_nearest_exact = torch.nn.functional.interpolate(mask.unsqueeze(0).unsqueeze(0), size=(height_b, width_b), mode='nearest-exact').squeeze(0).squeeze(0).cpu().numpy()
+        #
+        # mask_nearest = torch.nn.functional.interpolate(mask.unsqueeze(0).unsqueeze(0), size=(height_b, width_b), mode='nearest').squeeze(0).squeeze(0).cpu().numpy()
+        #
+        # mask_area = torch.nn.functional.interpolate(mask.unsqueeze(0).unsqueeze(0), size=(height_b, width_b), mode='area').squeeze(0).squeeze(0).cpu().numpy()
+
+        mask = torch.nn.functional.interpolate(self.tensor_mask.unsqueeze(0).unsqueeze(0), size=(height_b, width_b), mode='nearest-exact').squeeze(0).squeeze(0)
+        mask = mask.unsqueeze(0).repeat(num_channels, 1, 1)
+
+        return mask
+
+
+class PastePromptTextboxTracker:
+    def __init__(self):
+        self.scripts = []
+        return
+
+    def set_script(self, script):
+        self.scripts.append(script)
+
+    def on_after_component_callback(self, component, **_kwargs):
+
+        if not self.scripts:
+            return
+        if type(component) is gr.State:
+            return
+
+        script = None
+        if type(component) is gr.Textbox and component.elem_id == 'txt2img_prompt':
+            # select corresponding script
+            script = next(x for x in self.scripts if x.is_txt2img)
+            self.scripts.remove(script)
+
+        if type(component) is gr.Textbox and component.elem_id == 'img2img_prompt':
+            # select corresponding script
+            script = next(x for x in self.scripts if x.is_img2img)
+            self.scripts.remove(script)
+
+        if script is None:
+            return
+
+        script.target_paste_prompt = component
+
+
+prompt_textbox_tracker = PastePromptTextboxTracker()
+
+
+class Script(scripts.Script):
+
+    def __init__(self):
+        self.ui_root = None
+        self.num_batches: int = 0
+        self.end_at_step: int = 20
+        self.filters: List[Filter] = []
+        self.debug: bool = False
+        self.selected_twoshot_tab = 0
+        self.ndmasks = []
+        self.area_colors = []
+        self.mask_denoise = False
+        prompt_textbox_tracker.set_script(self)
+        self.target_paste_prompt = None
+
+
+    def title(self):
+        return "Latent Couple extension"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def create_rect_filters_from_ui_params(self, raw_divisions: str, raw_positions: str, raw_weights: str):
+
+        divisions = []
+        for division in raw_divisions.split(','):
+            y, x = division.split(':')
+            divisions.append(Division(float(y), float(x)))
+
+        def start_and_end_position(raw: str):
+            nums = [float(num) for num in raw.split('-')]
+            if len(nums) == 1:
+                return nums[0], nums[0] + 1.0
+            else:
+                return nums[0], nums[1]
+
+        positions = []
+        for position in raw_positions.split(','):
+            y, x = position.split(':')
+            y1, y2 = start_and_end_position(y)
+            x1, x2 = start_and_end_position(x)
+            positions.append(Position(y1, x1, y2, x2))
+
+        weights = []
+        for w in raw_weights.split(','):
+            weights.append(float(w))
+
+        # todo: assert len
+
+        return [RectFilter(division, position, weight) for division, position, weight in zip(divisions, positions, weights)]
+
+    def create_mask_filters_from_ui_params(self, raw_divisions: str, raw_positions: str, raw_weights: str):
+
+        divisions = []
+        for division in raw_divisions.split(','):
+            y, x = division.split(':')
+            divisions.append(Division(float(y), float(x)))
+
+        def start_and_end_position(raw: str):
+            nums = [float(num) for num in raw.split('-')]
+            if len(nums) == 1:
+                return nums[0], nums[0] + 1.0
+            else:
+                return nums[0], nums[1]
+
+        positions = []
+        for position in raw_positions.split(','):
+            y, x = position.split(':')
+            y1, y2 = start_and_end_position(y)
+            x1, x2 = start_and_end_position(x)
+            positions.append(Position(y1, x1, y2, x2))
+
+        weights = []
+        for w in raw_weights.split(','):
+            weights.append(float(w))
+
+        # todo: assert len
+
+        return [Filter(division, position, weight) for division, position, weight in zip(divisions, positions, weights)]
+
+    def do_visualize(self, raw_divisions: str, raw_positions: str, raw_weights: str):
+
+        self.filters = self.create_rect_filters_from_ui_params(raw_divisions, raw_positions, raw_weights)
+
+        return [f.create_tensor(1, 128, 128).squeeze(dim=0).cpu().numpy() for f in self.filters]
+
+    def do_apply(self, extra_generation_params: str):
+        #
+        # parse "Latent Couple" extra_generation_params
+        #
+        raw_params = {}
+
+        for assignment in extra_generation_params.split(' '):
+            pair = assignment.split('=', 1)
+            if len(pair) != 2:
+                continue
+            raw_params[pair[0]] = pair[1]
+
+        return raw_params.get('divisions', '1:1,1:2,1:2'), raw_params.get('positions', '0:0,0:0,0:1'), raw_params.get('weights', '0.2,0.8,0.8'), int(raw_params.get('step', '20'))
+
+    def ui(self, is_img2img):
+        process_script_params = []
+        id_part = "img2img" if is_img2img else "txt2img"
+        canvas_html = "<div id='canvas-root' style='max-width:400px; margin: 0 auto'></div>"
+        # get_js_colors = """
+        # async (canvasData) => {
+        #   const canvasEl = document.getElementById("canvas-root");
+        #   return [canvasEl._data]
+        # }
+        # """
+
+        def create_canvas(h, w):
+            return np.zeros(shape=(h, w, 3), dtype=np.uint8) + 255
+
+        def process_sketch(img_arr, input_binary_matrixes):
+            input_binary_matrixes.clear()
+            # base64_img = canvas_data['image']
+            # image_data = base64.b64decode(base64_img.split(',')[1])
+            # image = Image.open(BytesIO(image_data)).convert("RGB")
+            im2arr = img_arr
+            # colors = [tuple(map(int, rgb[4:-1].split(','))) for rgb in
+            #           ['colors']]
+            sketch_colors, color_counts = np.unique(im2arr.reshape(-1, im2arr.shape[2]), axis=0, return_counts=True)
+            colors_fixed = []
+            # if color count is less than 0.001 of total pixel count, collect it for edge color correction
+            edge_color_correction_arr = []
+            for sketch_color_idx, color in enumerate(sketch_colors[:-1]):  # exclude white
+                if color_counts[sketch_color_idx] < im2arr.shape[0] * im2arr.shape[1] * 0.002:
+                    edge_color_correction_arr.append(sketch_color_idx)
+
+            edge_fix_dict = {}
+            # TODO:for every non area color pixel in img_arr, find the nearest area color pixel and replace it with that color
+
+            area_colors = np.delete(sketch_colors, edge_color_correction_arr, axis=0)
+            if self.mask_denoise:
+                for edge_color_idx in edge_color_correction_arr:
+                    edge_color = sketch_colors[edge_color_idx]
+                    # find the nearest area_color
+
+                    color_distances = np.linalg.norm(area_colors - edge_color, axis=1)
+                    nearest_index = np.argmin(color_distances)
+                    nearest_color = area_colors[nearest_index]
+                    edge_fix_dict[edge_color_idx] = nearest_color
+                    # replace edge color with the nearest area_color
+                    cur_color_mask = np.all(im2arr == edge_color, axis=2)
+                    im2arr[cur_color_mask] = nearest_color
+
+                # recalculate area colors
+                sketch_colors, color_counts = np.unique(im2arr.reshape(-1, im2arr.shape[2]), axis=0, return_counts=True)
+                area_colors = sketch_colors
+
+            # create binary matrix for each area_color
+            area_color_maps = []
+            self.ndmasks = []
+            self.area_colors = area_colors
+            for color in area_colors:
+                r, g, b = color
+                mask, binary_matrix = create_binary_matrix_base64(im2arr, color)
+                self.ndmasks.append(mask)
+                input_binary_matrixes.append(binary_matrix)
+                colors_fixed.append(gr.update(
+                    value=f'<div style="display:flex;justify-content:center;max-height: 94px;"><img width="20%" style="object-fit: contain;flex-grow:1;margin-right: 1em;" src="data:image/png;base64,{binary_matrix}" /><div class="color-bg-item" style="background-color: rgb({r},{g},{b});width:10%;height:auto;"></div></div>'))
+
+
+
+            visibilities = []
+            sketch_colors = []
+
+            for sketch_color_idx in range(MAX_COLORS):
+                visibilities.append(gr.update(visible=False))
+                sketch_colors.append(gr.update(value=f'<div class="color-bg-item" style="background-color: black"></div>'))
+            for j in range(len(colors_fixed)-1):
+                visibilities[j] = gr.update(visible=True)
+                sketch_colors[j] = colors_fixed[j]
+
+            alpha_mask_visibility = gr.update(visible=True)
+            alpha_mask_html = colors_fixed[-1]
+            return [gr.update(visible=True), input_binary_matrixes, alpha_mask_visibility, alpha_mask_html, *visibilities, *sketch_colors]
+
+        def update_mask_filters(alpha_blend_val, general_prompt_str, *cur_weights_and_prompts):
+            cur_weight_slider_vals = cur_weights_and_prompts[:MAX_COLORS]
+            cur_prompts = cur_weights_and_prompts[MAX_COLORS:]
+            general_mask = self.ndmasks[-1]
+            final_filter_list = []
+            for m in range(len(self.ndmasks) - 1):
+                cur_float_mask = self.ndmasks[m].astype(np.float32) * float(cur_weight_slider_vals[m]) * float(1.0-alpha_blend_val)
+                mask_filter = MaskFilter(float_mask=cur_float_mask)
+                final_filter_list.append(mask_filter)
+            # subtract the sum of all masks from the general mask to get the alpha blend mask
+            initial_general_mask = np.ones(shape=general_mask.shape, dtype=np.float32)
+            alpha_blend_mask = initial_general_mask.astype(np.float32) - np.sum([f.mask for f in final_filter_list], axis=0)
+            alpha_blend_filter = MaskFilter(float_mask=alpha_blend_mask)
+            final_filter_list.insert(0, alpha_blend_filter)
+            self.filters = final_filter_list
+
+
+            sketch_colors = []
+            colors_fixed = []
+            for area_idx, color in enumerate(self.area_colors):
+                r, g, b = color
+                final_list_idx = area_idx + 1
+                if final_list_idx == len(final_filter_list):
+                    final_list_idx = 0
+                # get shape of current mask
+                height_b, width_b = final_filter_list[final_list_idx].mask.shape
+                current_mask = torch.nn.functional.interpolate(final_filter_list[final_list_idx].tensor_mask.unsqueeze(0).unsqueeze(0),
+                                                       size=(int(height_b/8), int(width_b/8)), mode='nearest-exact').squeeze(0).squeeze(0).cpu().numpy()
+                adjusted_mask = current_mask * 255
+                _, adjusted_mask_arr = cv2.imencode('.png', adjusted_mask)
+
+                adjusted_mask_b64 = base64.b64encode(adjusted_mask_arr.tobytes()).decode('ascii')
+                colors_fixed.append(gr.update(
+                    value=f'<div style="display:flex;justify-content:center;max-height: 94px;"><img width="20%" style="object-fit: contain;flex-grow:1;margin-right: 1em;" src="data:image/png;base64,{adjusted_mask_b64}" /><div class="color-bg-item" style="background-color: rgb({r},{g},{b});width:10%;height:auto;"></div></div>'))
+            for sketch_color_idx in range(MAX_COLORS):
+
+                sketch_colors.append(
+                    gr.update(value=f'<div class="color-bg-item" style="background-color: black"></div>'))
+            for j in range(len(colors_fixed)-1):
+
+                sketch_colors[j] = colors_fixed[j]
+            alpha_mask_visibility = gr.update(visible=True)
+            alpha_mask_html = colors_fixed[-1]
+            final_prompt_update = gr.update(value='\nAND '.join([general_prompt_str, *cur_prompts[:len(colors_fixed)-1]]))
+            return [final_prompt_update, alpha_mask_visibility, alpha_mask_html, *sketch_colors]
+
+
+
+        cur_weight_sliders = []
+
+        with gr.Group() as group_two_shot_root:
+            binary_matrixes = gr.State([])
+            with gr.Accordion("Latent Couple", open=False):
+                enabled = gr.Checkbox(value=False, label="Enabled")
+                with gr.Tabs(elem_id="script_twoshot_tabs") as twoshot_tabs:
+
+                    with gr.TabItem("Mask", elem_id="tab_twoshot_mask") as twoshot_tab_mask:
+
+                        canvas_data = gr.JSON(value={}, visible=False)
+                        # model = gr.Textbox(label="The id of any Hugging Face model in the diffusers format",
+                        #                    value="stabilityai/stable-diffusion-2-1-base",
+                        #                    visible=False if is_shared_ui else True)
+                        mask_denoise_checkbox = gr.Checkbox(value=False, label="Denoise Mask")
+
+                        def update_mask_denoise_flag(flag):
+                            self.mask_denoise = flag
+
+                        mask_denoise_checkbox.change(fn=update_mask_denoise_flag, inputs=[mask_denoise_checkbox], outputs=None)
+                        canvas_image = gr.Image(source='upload', mirror_webcam=False, type='numpy', tool='color-sketch',
+                                                elem_id='twoshot_canvas_sketch', interactive=True).style(height=480)
+                        # aspect = gr.Radio(["square", "horizontal", "vertical"], value="square", label="Aspect Ratio",
+                        #                   visible=False if is_shared_ui else True)
+                        button_run = gr.Button("I've finished my sketch", elem_id="main_button", interactive=True)
+
+                        prompts = []
+                        colors = []
+                        color_row = [None] * MAX_COLORS
+                        with gr.Column(visible=False) as post_sketch:
+                            with gr.Row(visible=False) as alpha_mask_row:
+                                # general_mask_label_span = gr.HTML(
+                                #     '<span class="text-gray-500 text-[0.855rem] mb-2 block dark:text-gray-200 relative z-40">General Mask</span>',
+                                #     elem_id='general_mask_label_span')
+                                with gr.Box(elem_id="alpha_mask"):
+                                    alpha_color = gr.HTML(
+                                        '<div class="alpha-mask-item" style="background-color: black"></div>')
+                            general_prompt = gr.Textbox(label="General Prompt")
+                            alpha_blend = gr.Slider(label="Alpha Blend", minimum=0.0, maximum=1.0, value=0.2, step=0.01, interactive=True)
+
+                            for n in range(MAX_COLORS):
+                                with gr.Row(visible=False) as color_row[n]:
+
+                                    with gr.Box(elem_id="color-bg"):
+                                        colors.append(gr.HTML(
+                                            '<div class="color-bg-item" style="background-color: black"></div>'))
+                                    with gr.Column():
+                                        with gr.Row():
+                                            prompts.append(gr.Textbox(label="Prompt for this mask"))
+
+                                        with gr.Row():
+                                            weight_slider = gr.Slider(label=f"Area {n+1} Weight", minimum=0.0, maximum=1.0,
+                                                                    value=1.0, step=0.01, interactive=True, elem_id=f"weight_{n+1}_slider")
+                                            cur_weight_sliders.append(weight_slider)
+
+                            button_update = gr.Button("Prompt Info Update", elem_id="update_button", interactive=True)
+                            final_prompt = gr.Textbox(label="Final Prompt", interactive=False)
+
+                        button_run.click(process_sketch, inputs=[canvas_image, binary_matrixes],
+                                         outputs=[post_sketch, binary_matrixes, alpha_mask_row, alpha_color, *color_row, *colors],
+                                         queue=False)
+
+                        button_update.click(fn=update_mask_filters, inputs=[alpha_blend, general_prompt, *cur_weight_sliders, *prompts], outputs=[final_prompt, alpha_mask_row, alpha_color, *colors])
+
+                        def paste_prompt(*input_prompts):
+                            final_prompts = input_prompts[:len(self.area_colors)]
+                            final_prompt_str = '\nAND '.join(final_prompts)
+                            return final_prompt_str
+                        source_prompts = [general_prompt, *prompts]
+                        button_update.click(fn=paste_prompt, inputs=source_prompts,
+                                            outputs=self.target_paste_prompt)
+
+
+
+                        with gr.Column():
+                            canvas_width = gr.Slider(label="Canvas Width", minimum=256, maximum=1024, value=512, step=64)
+                            canvas_height = gr.Slider(label="Canvas Height", minimum=256, maximum=1024, value=512, step=64)
+
+
+                            canvas_swap_res = ToolButton(value=switch_values_symbol)
+                            canvas_swap_res.click(lambda w, h: (h, w), inputs=[canvas_width, canvas_height],
+                                                  outputs=[canvas_width, canvas_height])
+                        create_button = gr.Button(value="Create blank canvas")
+                        create_button.click(fn=create_canvas, inputs=[canvas_height, canvas_width], outputs=[canvas_image])
+
+                    with gr.TabItem("Rectangular", elem_id="tab_twoshot_rect") as twoshot_tab_rect:
+                        with gr.Row():
+                            divisions = gr.Textbox(label="Divisions", elem_id=f"cd_{id_part}_divisions", value="1:1,1:2,1:2")
+                            positions = gr.Textbox(label="Positions", elem_id=f"cd_{id_part}_positions", value="0:0,0:0,0:1")
+                        with gr.Row():
+                            weights = gr.Textbox(label="Weights", elem_id=f"cd_{id_part}_weights", value="0.2,0.8,0.8")
+                            end_at_step = gr.Slider(minimum=0, maximum=150, step=1, label="end at this step", elem_id=f"cd_{id_part}_end_at_this_step", value=150)
+
+                        visualize_button = gr.Button(value="Visualize")
+                        visual_regions = gr.Gallery(label="Regions").style(grid=(4, 4, 4, 8), height="auto")
+
+                        visualize_button.click(fn=self.do_visualize, inputs=[divisions, positions, weights], outputs=[visual_regions])
+
+                        extra_generation_params = gr.Textbox(label="Extra generation params")
+                        apply_button = gr.Button(value="Apply")
+
+                        apply_button.click(fn=self.do_apply, inputs=[extra_generation_params], outputs=[divisions, positions, weights, end_at_step])
+
+                    def select_twosoht_tab(tab_id):
+                        self.selected_twoshot_tab = tab_id
+                    for i, elem in enumerate(
+                            [twoshot_tab_mask, twoshot_tab_rect]):
+                        elem.select(
+                            fn=lambda tab=i: select_twosoht_tab(tab),
+                            inputs=[],
+                            outputs=[],
+                    )
+
+        self.ui_root = group_two_shot_root
+
+        self.infotext_fields = [
+            (extra_generation_params, "Latent Couple")
+        ]
+        process_script_params.append(enabled)
+        process_script_params.append(divisions)
+        process_script_params.append(positions)
+        process_script_params.append(weights)
+        process_script_params.append(end_at_step)
+        process_script_params.append(alpha_blend)
+        process_script_params.extend(cur_weight_sliders)
+        return process_script_params
+
+    def denoised_callback(self, params: CFGDenoisedParams):
+
+        if self.enabled and params.sampling_step < self.end_at_step:
+
+            x = params.x
+            # x.shape = [batch_size, C, H // 8, W // 8]
+
+            num_batches = self.num_batches
+            num_prompts = x.shape[0] // num_batches
+            # ex. num_batches = 3
+            # ex. num_prompts = 3 (tensor) + 1 (uncond)
+
+            if self.debug:
+                print(f"### Latent couple ###")
+                print(f"denoised_callback x.shape={x.shape} num_batches={num_batches} num_prompts={num_prompts}")
+
+            filters = [
+                f.create_tensor(x.shape[1], x.shape[2], x.shape[3]) for f in self.filters
+            ]
+            neg_filters = [1.0 - f for f in filters]
+
+            """
+            batch #1
+              subprompt #1
+              subprompt #2
+              subprompt #3
+            batch #2
+              subprompt #1
+              subprompt #2
+              subprompt #3
+            uncond
+              batch #1
+              batch #2
+            """
+
+            tensor_off = 0
+            uncond_off = num_batches * num_prompts - num_batches
+            for b in range(num_batches):
+                uncond = x[uncond_off, :, :, :]
+
+                for p in range(num_prompts - 1):
+                    if self.debug:
+                        print(f"b={b} p={p}")
+                    if p < len(filters):
+                        tensor = x[tensor_off, :, :, :]
+                        x[tensor_off, :, :, :] = tensor * filters[p] + uncond * neg_filters[p]
+
+                    tensor_off += 1
+
+                uncond_off += 1
+
+    def process(self, p: StableDiffusionProcessing, *args, **kwargs):
+
+        enabled, raw_divisions, raw_positions, raw_weights, raw_end_at_step, alpha_blend, *cur_weight_sliders = args
+
+        self.enabled = enabled
+
+        if not self.enabled:
+            return
+
+        self.num_batches = p.batch_size
+
+        if self.selected_twoshot_tab == 0:
+            pass
+        elif self.selected_twoshot_tab == 1:
+            self.filters = self.create_rect_filters_from_ui_params(raw_divisions, raw_positions, raw_weights)
+        else:
+            raise ValueError(f"Unknown filter mode")
+
+        self.end_at_step = raw_end_at_step
+
+        # TODO: handle different cases for generation info: 'mask' and 'rect'
+        # if self.end_at_step != 0:
+        #     p.extra_generation_params["Latent Couple"] = f"divisions={raw_divisions} positions={raw_positions} weights={raw_weights} end at step={raw_end_at_step}"
+
+
+        if self.debug:
+            print(f"### Latent couple ###")
+            print(f"process num_batches={self.num_batches} end_at_step={self.end_at_step}")
+
+        if not hasattr(self, 'callbacks_added'):
+            on_cfg_denoised(self.denoised_callback)
+            self.callbacks_added = True
+
+        return
+
+    def postprocess(self, *args):
+        return
+
+
+script_callbacks.on_after_component(prompt_textbox_tracker.on_after_component_callback)

extensions/SD-two-shot-main/style.css

@@ -0,0 +1,36 @@
+
+#twoshot_canvas_sketch, #twoshot_canvas_sketch > .h-60, #twoshot_canvas_sketch > .h-60 > div, #twoshot_canvas_sketch > .h-60 > div > img
+{
+    height: 480px !important;
+    max-height: 480px !important;
+    /*min-height: 480px !important;*/
+}
+
+#color-bg > .gr-box, #color-bg > .gr-box > .transition, #color-bg > .gr-box > .transition > .output-html
+{
+    height: 100%;
+}
+
+#color-bg{
+    max-height: 110px;
+}
+
+#alpha_mask{
+    max-height: 110px;
+}
+
+#general_mask_label_span{
+    position: absolute;
+}
+
+#script_twoshot_tabs .output-html{
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}
+
+#script_twoshot_tabs .gradio-image > div.fixed-height, #script_twoshot_tabs .gradio-image > div.fixed-height img {
+    height: 480px !important;
+    max-height: 480px !important;
+    min-height: 480px !important;
+}