Upload folder using huggingface_hub

extensions-builtin/sdw-wd14-tagger/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+.vscode/
+.venv/
+.env
+
+presets/

extensions-builtin/sdw-wd14-tagger/CHANGELOG.md

@@ -0,0 +1,105 @@
+# v1.1.2 (2023-08-26)
+
+Explain recursive path usage better in ui
+Fix sending tags via buttons to txt2img and img2img
+type additions, inadvertently pushed, later retouched.
+allow setting gpu device via flag
+Fix inverted cumulative checkbox
+wrap_gradio_gpu_call fallback
+Fix for preload shared access
+preload update
+A few ui changes
+Fix not clearing the tags after writing them to files
+Fix: Tags were still added, beyond count threshold
+fix search/replace bug
+(here int based weights were reverted)
+circumvent when unable to load tensorflow
+fix for too many exclude_tags
+add db.json validation schema, add schema validation
+return fix for fastapi
+pick up huggingface cache dir from env, with default, configurable also via settings.
+leave tensorflow requirements to the user.
+Fix for Reappearance of gradio bug: duplicate image edit
+(index based weights, but later reverted)
+Instead of cache_dir use local_dir, leav
+
+
+# v1.1.1 eada050 (2023-07-20) 
+
+Internal cleanup, no separate interrogation for inverse
+Fix issues with search and sending selection to keep/exclude
+Fix issue #14, picking up last edit box changes
+Fix 2 issues reported by guansss
+fix huggingface reload issues. Thanks to Atoli and coder168 for reporting
+experimental tensorflow unloading, but after some discussion, maybe conversion to onxx can solve this. See #17, thanks again Sean Wang.
+add gallery tab, rudimentary.
+fix some hf download issues
+fixes for fastapi
+added ML-Danbooru support, thanks to [CCRcmcpe](github.com/CCRcmcpe)
+
+
+# v1.1.0 87706b7 (2023-07-16)
+
+fix: failed to install onnxruntime package on MacOS thanks to heady713
+fastapi: remote unload model, picked up from [here](https://github.com/toriato/stable-diffusion-webui-wd14-tagger/pull/109)
+attribute error fix from aria1th also reported by yjunej
+re-allowed weighted tags files, now configured in settings -> tagger.
+wzgrx pointed out there were some modules not installed by default, so I've added a requirements.txt file that will auto-install required dependencies. However, the initial requirements.txt had issues. I ran to create the requirements.txt:
+```
+pipreqs --force `pwd`
+sed -i s/==.*$//g requirements.txt
+```
+but it ended up adding external modules that were shadowing webui modules. If you have installed those, you may find you are not even able to start the webui until you remove them. Change to the directory of my extension and
+```
+pip uninstall webui
+pip uninstall modules
+pip uninstall launch
+```
+In particular installing a module named modules was a serious problem. Python should flag that name as illegal.
+
+There were some interrogators that were not working unless you have them installed manually. Now they are only listed if you have them.
+
+Thanks to wzgrx for testing and reporting these last two issues.
+changed internal file structure, thanks to idiotcomerce #4
+more regex usage in search and exclusion tags
+fixed a bug where some exclusion tags were not reflected in the tags file
+changed internal error handling, It is a bit quirky, which I intend to fix, still.
+If you find it keeps complaining about an input field without reason, just try editing that one again (e.g. add a space there and remove it).
+
+
+# v1.0.0 a1b59d6 (2023-07-10)
+
+You may have to remove the presets/default.json and save a new one.witth your desired defaults. Otherwise checkboxes may not have the right default values.
+
+General changes:
+
+Weights, when enabled, are not printed in the tags list. Weights are displayed in the list below already as bars, so they do not add information, only obfuscate the list IMO.
+There is an settings entry for the tagger, several options have been moved there.
+The list of tags weights stops at a number specified on the settings tab (the slider)
+There is both an included and excluded rags tab
+tags in the tags list on top are clickable.
+Tags below are also clickable. There is a difference if you click on the dotted line or on the actual word. a click on the word will add it to a search/kept tag (dependent on which was last active) on the dotted line will add it to the input box next to it.
+interrogations can be combined (checkbox), also for a single image.
+Make the labels listed clickable again, a click will add it to the selected listbox. This also functions when you are on the discarded tags tab.
+Added search and replace input lists.
+Changed behavior: when clicking on the dotted line, inserted is in the exclude/replace input list, if not the tag is inserted in the additional/search input list
+Added a Mininmum fraction for tags slider. This filters tags based on the fraction of images and interrogations per image that has this tag with the selected weight threshold. I find this kind of filtering makes more sense than limiting the tags list to a number, though that is ok to prevent cluttering up the view,
+
+Added a string search selected tags input field (top right) and two buttons:
+Move visible tags to keep tags
+Move visible tags to exclude tags
+
+For batch processing:
+After each update a db.json is written in the images folder. The db contains the weights for queries, a rerun of the same images using an interrogator just rereads this db.json. This also works after a stable diffusion reload or a reboot, as long as this db.json is there.
+
+There is a huge batch implementation, but I was unable to test, not the right tensorflow version. EXPERIMENTAL. It is only enabled if you have the right tf version, but it's likely buggy due to my lack of testing. feel free to send me a patch if you can improve it. also see here
+pre- or appending weights to weighed tag files, i.e. with weights enabled, will instead have the weights averaged
+
+After batch processing the combined tag count average is listed, for all processed files, and the corrected average when combining the weighed tags. This is not limited to the tag_count_threshold, as it relates to the weights of all tag files. Conversely, the already existing threshold slider does affect this list length.
+search tag can be a single regex or as many as replacements, comma separated. Currently a single regex or multiple as many strings in search an replace are allowed, but this is going to change in the near future, to allow all regexes and back referencing per replacements as in a re.sub().
+added a 'verbose setting'.
+a comma was previously missing when appending tags
+several of the interrogators have been fixed.
+
+
+

extensions-builtin/sdw-wd14-tagger/CONTRIBUTING.md

@@ -0,0 +1,71 @@
+Thanks for the time to contrribute to this project.
+
+The followiing is a set of guidelines for contributing to this project. These are just guidelines, not rules, use your best judgment and this document is also subject to change.
+
+Table of Contents
+=================
+1. Contribution Workflow
+ * Styleguides
+ * Git Commit Messages
+ * Styleguides, general notes
+ * JavaScript Styleguide
+ * Python Styleguide
+ * Documentation Styleguide
+2. License 
+3. Questions
+
+# Contribution Workflow
+* Fork the repo and create your branch from master.
+* If you've added code that should be tested, add tests.
+* If you've changed APIs, update the documentation.
+* Ensure the test suite passes.
+* Make sure your code lints.
+* Issue that pull request!
+
+# Styleguides
+## Git Commit Messages
+* Use the present tense ("Add feature" not "Added feature")
+* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+* Limit the first line to 72 characters or less
+* Reference issues and pull requests liberally after the first line
+* When only changing documentation, include [ci skip] in the commit title
+* Consider starting the commit message with an applicable emoji.
+* A sign-off is not required, but encouraged using the -s flag. Example: git commit -s -m "Adding a new feature"
+
+Example commit message:
+```
+:rocket: Adds `launch()` method
+
+The launch method accepts a single argument for the speed of the launch.
+This method is necessary to get to the moon and fixes #76.
+This commit closes issue #34
+
+Signed-off-by: Jane Doe <Jane.doe@hotmail.com>
+```
+
+## Styleguides, general notes
+The current code does not follow the below proposed styleguides everywhere. Please try to follow the styleguides as much as possible, but if you see something that is not following the styleguides, please do not change it. Commits should be atomic and only change one thing, and changing the style obfuscates the changes. The same goes for whitespace changes.
+
+* If you change current code, please do use the styleguides, even if the code around it does not follow it.
+* If you do not adhere to the styleguides, that is ok as well, but please make sure your code is readable and easy to understand.
+
+
+## JavaScript Styleguide
+All JavaScript must adhere to [JavaScript Standard Style](https://standardjs.com/). [![JavaScript Style Guide](https://cdn.rawgit.com/standard/standard/master/badge.svg)](JS%20Style%20Guide)
+
+## Python Styleguide
+Try to adhere to [PEP 8](https://www.python.org/dev/peps/pep-0008/). It is not required, but it is recommended.
+
+## Documentation Styleguide
+Use [JSDoc](http://usejsdoc.org/) syntax to document code.
+Use [GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/) syntax to format documentation.
+
+Thank you for your interest in contributing to this project!
+
+# License
+Largely public domain, I think tagger/dbimutils,py was [MIT](https://choosealicense.com/licenses/mit/)
+
+# Questions
+If you have any questions about the repo, open an issue or contact me directly at [email](mailto:pi.co.0o.byte@gmail.com).
+
+

extensions-builtin/sdw-wd14-tagger/README.ko.md

@@ -0,0 +1,61 @@
+[Automatic1111 웹UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)를 위한 태깅(라벨링) 확장 기능
+---
+DeepDanbooru 와 같은 모델을 통해 단일 또는 여러 이미지로부터 부루에서 사용하는 태그를 알아냅니다.
+
+[You don't know how to read Korean? Read it in English here!](README.md)
+
+## 들어가기 앞서
+모델과 대부분의 코드는 제가 만들지 않았고 [DeepDanbooru](https://github.com/KichangKim/DeepDanbooru) 와 MrSmillingWolf 의 태거에서 가져왔습니다.
+
+## 설치하기
+1. *확장기능* -> *URL로부터 확장기능 설치* -> 이 레포지토리 주소 입력 -> *설치*
+   - 또는 이 레포지토리를 `extensions/` 디렉터리 내에 클론합니다.
+      ```sh
+      $ git clone https://github.com/picobyte/stable-diffusion-webui-wd14-tagger.git extensions/tagger
+      ```
+
+1. 모델 추가하기
+   - #### *MrSmilingWolf's model (a.k.a. Waifu Diffusion 1.4 tagger)*
+      처음 실행할 때 [HuggingFace 레포지토리](https://huggingface.co/SmilingWolf/wd-v1-4-vit-tagger)로부터 자동으로 받아옵니다.
+
+      모델과 관련된 또는 추가 학습에 대한 질문은 원작자인 MrSmilingWolf#5991 으로 물어봐주세요.
+
+   - #### *DeepDanbooru*
+      1. 다양한 모델 파일은 아래 주소에서 찾을 수 있습니다.
+         - [DeepDanbooru model](https://github.com/KichangKim/DeepDanbooru/releases)
+         - [e621 model by 🐾Zack🐾#1984](https://discord.gg/BDFpq9Yb7K)
+            *(NSFW 주의!)*
+
+      1. 모델과 설정 파일이 포함된 프로젝트 폴더를 `models/deepdanbooru` 경로로 옮깁니다.
+
+      1. 파일 구조는 다음과 같습니다:
+         ```
+         models/
+         └╴deepdanbooru/
+           ├╴deepdanbooru-v3-20211112-sgd-e28/
+           │ ├╴project.json
+           │ └╴...
+           │
+           ├╴deepdanbooru-v4-20200814-sgd-e30/
+           │ ├╴project.json
+           │ └╴...
+           │
+           ├╴e621-v3-20221117-sgd-e32/
+           │ ├╴project.json
+           │ └╴...
+           │
+           ...
+         ```
+
+1. 웹UI 를 시작하거나 재시작합니다.
+   - 또는 *Interrogator* 드롭다운 상자 우측에 있는 새로고침 버튼을 누릅니다.
+
+
+## 스크린샷
+![Screenshot](docs/screenshot.png)
+
+Artwork made by [hecattaart](https://vk.com/hecattaart?w=wall-89063929_3767)
+
+## 저작권
+
+빌려온 코드(예: `dbimutils.py`)를 제외하고 모두 Public domain 

extensions-builtin/sdw-wd14-tagger/README.md

@@ -0,0 +1,63 @@
+Tagger for [Automatic1111's WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)
+---
+Interrogate booru style tags for single or multiple image files using various models, such as DeepDanbooru.
+
+[한국어를 사용하시나요? 여기에 한국어 설명서가 있습니다!](README.ko.md)
+
+## Disclaimer
+I didn't make any models, and most of the code was heavily borrowed from the [DeepDanbooru](https://github.com/KichangKim/DeepDanbooru) and MrSmillingWolf's tagger.
+
+## Installation
+1. *Extensions* -> *Install from URL* -> Enter URL of this repository -> Press *Install* button
+   - or clone this repository under `extensions/`
+      ```sh
+      $ git clone https://github.com/picobyte/stable-diffusion-webui-wd14-tagger.git extensions/tagger
+      ```
+
+1. *(optional)* Add interrogate model
+   - #### [*Waifu Diffusion 1.4 Tagger by MrSmilingWolf*](docs/what-is-wd14-tagger.md)
+      Downloads automatically from the [HuggingFace repository](https://huggingface.co/SmilingWolf/wd-v1-4-vit-tagger) the first time you run it.
+
+   - #### *DeepDanbooru*
+      1. Various model files can be found below.
+         - [DeepDanbooru models](https://github.com/KichangKim/DeepDanbooru/releases)
+         - [e621 model by 🐾Zack🐾#1984](https://discord.gg/BDFpq9Yb7K)
+            *(link contains NSFW contents!)*
+
+      1. Move the project folder containing the model and config to `models/deepdanbooru`
+
+      1. The file structure should look like:
+         ```
+         models/
+         └╴deepdanbooru/
+           ├╴deepdanbooru-v3-20211112-sgd-e28/
+           │ ├╴project.json
+           │ └╴...
+           │
+           ├╴deepdanbooru-v4-20200814-sgd-e30/
+           │ ├╴project.json
+           │ └╴...
+           │
+           ├╴e621-v3-20221117-sgd-e32/
+           │ ├╴project.json
+           │ └╴...
+           │
+           ...
+         ```
+
+1. Start or restart the WebUI.
+   - or you can press refresh button after *Interrogator* dropdown box.
+   - "You must close stable diffusion completely after installation and re-run it!"
+
+
+## Model comparison
+[Model comparison](docs/model-comparison.md)
+
+## Screenshot
+![Screenshot](docs/screenshot.png)
+
+Artwork made by [hecattaart](https://vk.com/hecattaart?w=wall-89063929_3767)
+
+## Copyright
+
+Public domain, except borrowed parts (e.g. `dbimutils.py`)

extensions-builtin/sdw-wd14-tagger/docs/model-comparison.md

@@ -0,0 +1,49 @@
+Model comparison
+---
+
+* Used image: [hecattaart's artwork](https://vk.com/hecattaart?w=wall-89063929_3767)
+* Threshold: `0.5`
+
+### DeepDanbooru
+
+#### [`deepdanbooru-v3-20211112-sgd-e28`](https://github.com/KichangKim/DeepDanbooru/releases/tag/v3-20211112-sgd-e28)
+```
+1girl, animal ears, cat ears, cat tail, clothes writing, full body, rating:safe, shiba inu, shirt, shoes, simple background, sneakers, socks, solo, standing, t-shirt, tail, white background, white shirt
+```
+
+#### [`deepdanbooru-v4-20200814-sgd-e30`](https://github.com/KichangKim/DeepDanbooru/releases/tag/v4-20200814-sgd-e30)
+```
+1girl, animal, animal ears, bottomless, clothes writing, full body, rating:safe, shirt, shoes, short sleeves, sneakers, solo, standing, t-shirt, tail, white background, white shirt
+```
+
+#### `e621-v3-20221117-sgd-e32`
+```
+anthro, bottomwear, clothing, footwear, fur, hi res, mammal, shirt, shoes, shorts, simple background, sneakers, socks, solo, standing, text on clothing, text on topwear, topwear, white background
+```
+
+### Waifu Diffusion Tagger
+
+#### [`wd14-vit`](https://huggingface.co/SmilingWolf/wd-v1-4-vit-tagger)
+```
+1boy, animal ears, dog, furry, leg hair, male focus, shirt, shoes, simple background, socks, solo, tail, white background
+```
+
+#### [`wd14-convnext`](https://huggingface.co/SmilingWolf/wd-v1-4-convnext-tagger)
+```
+full body, furry, shirt, shoes, simple background, socks, solo, tail, white background
+```
+
+#### [`wd14-vit-v2`](https://huggingface.co/SmilingWolf/wd-v1-4-vit-tagger-v2)
+```
+1boy, animal ears, cat, furry, male focus, shirt, shoes, simple background, socks, solo, tail, white background
+```
+
+#### [`wd14-convnext-v2`](https://huggingface.co/SmilingWolf/wd-v1-4-convnext-tagger-v2)
+```
+animal focus, clothes writing, earrings, full body, meme, shirt, shoes, simple background, socks, solo, sweat, tail, white background, white shirt
+```
+
+#### [`wd14-swinv2-v2`](https://huggingface.co/SmilingWolf/wd-v1-4-swinv2-tagger-v2)
+```
+1boy, arm hair, black footwear, cat, dirty, full body, furry, leg hair, male focus, shirt, shoes, simple background, socks, solo, standing, tail, white background, white shirt
+```

extensions-builtin/sdw-wd14-tagger/docs/what-is-wd14-tagger.md

@@ -0,0 +1,30 @@
+What is Waifu Diffison 1.4 Tagger?
+---
+
+Image to text model created and maintained by [MrSmilingWolf](https://huggingface.co/SmilingWolf), which was used to train Waifu Diffusion.
+
+Please ask the original author `MrSmilingWolf#5991` for questions related to model or additional training.
+
+## SwinV2 vs Convnext vs ViT
+> It's got characters now, the HF space has been updated too. Model of choice for classification is SwinV2 now. ConvNext was used to extract features because SwinV2 is a bit of a pain cuz it is twice as slow and more memory intensive
+
+— [this message](https://discord.com/channels/930499730843250783/930499731451428926/1066830289382408285) from the [東方Project AI discord server](https://discord.com/invite/touhouai)
+
+> To make it clear: the ViT model is the one used to tag images for WD 1.4. That's why the repo was originally called like that. This one has been trained on the same data and tags, but has got no other relation to WD 1.4, aside from stemming from the same coordination effort. They were trained in parallel, and the best one at the time was selected for WD 1.4
+>
+> This particular model was trained later and might actually be slightly better than the ViT one. Difference is in the noise range tho 
+
+— [this thread](https://discord.com/channels/930499730843250783/1052283314997837955) from the [東方Project AI discord server](https://discord.com/invite/touhouai)
+
+## Performance
+> I stack them together and get a 1.1GB model with higher validation metrics than the three separated, so they each do their own thing and averaging the predictions sorta helps covering for each models failures. I suppose.
+> As for my impression for each model:
+> - SwinV2: a memory and GPU hog. Best metrics of the bunch, my model is compatible with timm weights (so it can be used on PyTorch if somebody ports it) but slooow. Good for a few predictions, would reconsider for massive tagging jobs if you're pressed for time
+> - ConvNext: nice perfs, good metrics. A sweet spot. The 1024 final embedding size provides ample space for training the Dense layer on other datasets, like E621.
+> - ViT: fastest of the bunch, at least on TPU, probably on GPU too? Slightly less then stellar metrics when compared with the other two. Onnxruntime and Tensorflow keep adding optimizations for Transformer models so that's good too.
+
+— [this message](https://discord.com/channels/930499730843250783/930499731451428926/1066833768112996384) from the [東方Project AI discord server](https://discord.com/invite/touhouai)
+
+## Links
+- [MrSmilingWolf's HuggingFace profile](https://huggingface.co/SmilingWolf)
+- [MrSmilingWolf's GitHub profile](https://github.com/SmilingWolf)

extensions-builtin/sdw-wd14-tagger/install.py

@@ -0,0 +1,13 @@
+"""Install requirements for WD14-tagger."""
+import os
+import sys
+
+from launch import run  # pylint: disable=import-error
+
+NAME = "WD14-tagger"
+req_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                        "requirements.txt")
+print(f"loading {NAME} reqs from {req_file}")
+run(f'"{sys.executable}" -m pip install -q -r "{req_file}"',
+    f"Checking {NAME} requirements.",
+    f"Couldn't install {NAME} requirements.")

extensions-builtin/sdw-wd14-tagger/javascript/tagger.js

@@ -0,0 +1,180 @@
+/**
+ * wait until element is loaded and returns
+ * @param {string} selector
+ * @param {number} timeout 
+ * @param {Element} $rootElement
+ * @returns {Promise<HTMLElement>}
+ */
+function waitQuerySelector(selector, timeout = 5000, $rootElement = gradioApp()) {
+    return new Promise((resolve, reject) => {
+        const element = $rootElement.querySelector(selector)
+        if (document.querySelector(element)) {
+            return resolve(element)
+        }
+
+        let timeoutId
+
+        const observer = new MutationObserver(() => {
+            const element = $rootElement.querySelector(selector)
+            if (!element) {
+                return
+            }
+
+            if (timeoutId) {
+                clearInterval(timeoutId)
+            }
+
+            observer.disconnect()
+            resolve(element)
+        })
+
+        timeoutId = setTimeout(() => {
+            observer.disconnect()
+            reject(new Error(`timeout, cannot find element by '${selector}'`))
+        }, timeout)
+
+        observer.observe($rootElement, {
+            childList: true,
+            subtree: true
+        })
+    })
+}
+
+function tag_clicked(tag, is_inverse) {
+  // escaped characters
+  const escapedTag = tag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+  // add the tag to the selected textarea
+  let $selectedTextarea;
+  if (is_inverse) {
+    $selectedTextarea = document.getElementById('keep-tags');
+  } else {
+    $selectedTextarea = document.getElementById('exclude-tags');
+  }
+  let value = $selectedTextarea.querySelector('textarea').value;
+  // ignore if tag is already exist in textbox
+  const pattern = new RegExp(`(^|,)\\s{0,}${escapedTag}\\s{0,}($|,)`);
+  if (pattern.test(value)) {
+    return;
+  }
+  const emptyRegex = new RegExp(`^\\s*$`);
+  if (!emptyRegex.test(value)) {
+    value += ', ';
+  }
+  // besides setting the value an event needs to be triggered or the value isn't actually stored.
+  const input_event = new Event('input');
+  $selectedTextarea.querySelector('textarea').value = value + escapedTag;
+  $selectedTextarea.dispatchEvent(input_event);
+  const input_event2 = new Event('blur');
+  $selectedTextarea.dispatchEvent(input_event2);
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    Promise.all([
+        // option texts
+        waitQuerySelector('#keep-tags'),
+        waitQuerySelector('#exclude-tags'),
+        waitQuerySelector('#search-tags'),
+        waitQuerySelector('#replace-tags'),
+
+        // tag-confident labels
+        waitQuerySelector('#rating-confidences'),
+        waitQuerySelector('#tag-confidences'),
+        waitQuerySelector('#discard-tag-confidences')
+    ]).then(elements => {
+
+        const $keepTags = elements[0];
+        const $excludeTags = elements[1];
+        const $searchTags = elements[2];
+        const $replaceTags = elements[3];
+        const $ratingConfidents = elements[4];
+        const $tagConfidents = elements[5];
+        const $discardTagConfidents = elements[6];
+
+        let $selectedTextarea = $keepTags;
+
+        /**
+         * @this {HTMLElement}
+         * @param {MouseEvent} e
+         * @listens document#click
+         */
+        function onClickTextarea(e) {
+            $selectedTextarea = this;
+        }
+
+        $keepTags.addEventListener('click', onClickTextarea);
+        $excludeTags.addEventListener('click', onClickTextarea);
+        $searchTags.addEventListener('click', onClickTextarea);
+        $replaceTags.addEventListener('click', onClickTextarea);
+
+        /**
+         * @this {HTMLElement}
+         * @param {MouseEvent} e
+         * @listens document#click
+         */
+        function onClickLabels(e) {
+            // find clicked label item's wrapper element
+            let tag = e.target.innerText;
+
+            // when clicking unlucky, you get all tags and percentages. Prevent inserting those here.
+            const multiTag = new RegExp(`\\n.*\\n`);
+            if (tag.match(multiTag)) {
+                return;
+            }
+
+            // when clicking on the dotted line or the percentage, you get the percentage as well. Don't include it in the tags.
+            // use this fact to choose whether to insert in positive or negative. May require some getting used to, but saves
+            // having to select the input field.
+            const pctPattern = new RegExp(`\\n?([0-9.]+)%$`);
+            let percentage = tag.match(pctPattern);
+            if (percentage) {
+                tag = tag.replace(pctPattern, '');
+                if (tag == '') {
+                    //percentage = percentage[1];
+                    // could trigger a set Thresold value event
+                    return;
+                }
+                // when clicking on athe dotted line, insert in either the exclude or replace list
+                // when not clicking on the dotted line, insert in the additingal or search list
+                if ($selectedTextarea == $keepTags) {
+                    $selectedTextarea = $excludeTags;
+                } else if ($selectedTextarea == $searchTags) {
+                    $selectedTextarea = $replaceTags;
+                }
+            } else if ($selectedTextarea == $excludeTags) {
+                $selectedTextarea = $keepTags;
+            } else if ($selectedTextarea == $replaceTags) {
+                $selectedTextarea = $searchTags;
+            }
+
+            let value = $selectedTextarea.querySelector('textarea').value;
+            // except replace_tag because multiple can be replaced with the same
+            if ($selectedTextarea != $replaceTags) {
+                // ignore if tag is already exist in textbox
+                const escapedTag = tag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const pattern = new RegExp(`(^|,)\\s{0,}${escapedTag}\\s{0,}($|,)`);
+                if (pattern.test(value)) {
+                    return;
+                }
+            }
+
+            // besides setting the value an event needs to be triggered or the value isn't actually stored.
+            const spaceOrAlreadyWithComma = new RegExp(`(^|.*,)\\s*$`);
+            if (!spaceOrAlreadyWithComma.test(value)) {
+                value += ', ';
+            }
+            const input_event = new Event('input');
+            $selectedTextarea.querySelector('textarea').value = value + tag;
+            $selectedTextarea.querySelector('textarea').dispatchEvent(input_event);
+            const input_event2 = new Event('blur');
+            $selectedTextarea.querySelector('textarea').dispatchEvent(input_event2);
+
+        }
+
+        $tagConfidents.addEventListener('click', onClickLabels)
+        $discardTagConfidents.addEventListener('click', onClickLabels)
+
+    }).catch(err => {
+        console.error(err)
+    })
+})

extensions-builtin/sdw-wd14-tagger/json_schema/db_json_v1_schema.json

@@ -0,0 +1,52 @@
+{
+    "type": "object",
+    "properties": {
+        "rating": { "$ref": "#/$defs/weighted_label" },
+        "tag": { "$ref": "#/$defs/weighted_label" },
+        "query": {
+            "type": "object",
+            "patternProperties": {
+                "^[0-9a-f]{64}.*$": {
+                    "type": "array",
+                    "prefixItems": [
+                        {"type": "string" },
+                        {"type": "number", "minimum": 0}
+                    ],
+                    "minContains": 2,
+                    "maxContains": 2
+                }
+            }
+        },
+        "meta": {
+            "type": "object",
+            "properties": {
+              "index_shift": {
+                "type": "integer",
+                "minimum": 0,
+                "maximum": 16
+              }
+            }
+        },
+        "add": { "type": "string" },
+        "exclude": { "type": "string" },
+        "keep": { "type": "string" },
+        "repl": { "type": "string" },
+        "search": { "type": "string" }
+    },
+    "required": ["rating", "tag", "query"],
+    "additionalProperties": false,
+    "$defs": {
+        "weighted_label": {
+            "type": "object",
+            "patternProperties": {
+                "^[^,]+$": {
+                    "type": "array",
+                    "items": {
+                        "type": "number",
+                        "minimum": 0
+                    }
+                }
+            }
+        }
+    }
+}

extensions-builtin/sdw-wd14-tagger/preload.py

@@ -0,0 +1,26 @@
+""" Preload module for DeepDanbooru or onnxtagger. """
+from argparse import ArgumentParser
+
+
+def preload(parser: ArgumentParser):
+    """ Preload module for DeepDanbooru or onnxtagger. """
+    # default deepdanbooru use different paths:
+    # models/deepbooru and models/torch_deepdanbooru
+    # https://github.com/AUTOMATIC1111/stable-diffusion-webui/commit/c81d440d876dfd2ab3560410f37442ef56fc6632
+
+    parser.add_argument(
+        '--deepdanbooru-projects-path',
+        type=str,
+        help='Path to directory with DeepDanbooru project(s).'
+    )
+    parser.add_argument(
+        '--onnxtagger-path',
+        type=str,
+        help='Path to directory with Onnyx project(s).'
+    )
+    # TODO allow using devices in parallel, specified as comma separed list
+    parser.add_argument(
+        '--additional-device-ids',
+        type=str,
+        help='Device ID to use. cpu:0, gpu:0 or gpu:1, etc.',
+    )

extensions-builtin/sdw-wd14-tagger/pyproject.toml

@@ -0,0 +1,38 @@
+[tool.ruff]
+
+target-version = "py39"
+
+extend-select = [
+  "B",
+  "C",
+  "I",
+  "W",
+]
+
+exclude = [
+	"addons",
+]
+
+ignore = [
+	"E501", # Line too long
+	"E731", # Do not assign a `lambda` expression, use a `def`
+	
+	"I001", # Import block is un-sorted or un-formatted
+	"C901", # Function is too complex
+	"C408", # Rewrite as a literal
+	"W605", # invalid escape sequence, messes with some docstrings
+]
+
+#[tool.ruff.per-file-ignores]
+#"webui.py" = ["E402"]  # Module level import not at top of file
+
+#[tool.ruff.flake8-bugbear]
+# Allow default arguments like, e.g., `data: List[str] = fastapi.Query(None)`.
+#extend-immutable-calls = ["fastapi.Depends", "fastapi.security.HTTPBasic"]
+
+[tool.pytest.ini_options]
+base_url = "http://127.0.0.1:7860"
+
+[tool.pylint.'MESSAGES CONTROL']
+extension-pkg-whitelist = ["pydantic"]
+disable= ["C", "R", "W", "E", "I"]

extensions-builtin/sdw-wd14-tagger/requirements.txt

@@ -0,0 +1,18 @@
+deepdanbooru
+onnxruntime; python_version != '3.9' and sys_platform == 'darwin' and platform_machine != 'arm64'
+onnxruntime-coreml; python_version == '3.9' and sys_platform == 'darwin' and platform_machine != 'arm64'
+onnxruntime-silicon; sys_platform == 'darwin' and platform_machine == 'arm64'
+onnxruntime-gpu; sys_platform != 'darwin'
+jsonschema
+fastapi
+gradio
+huggingface_hub
+numpy
+opencv_contrib_python
+opencv_python
+opencv_python_headless
+packaging
+pandas
+Pillow
+tensorflow
+tqdm

extensions-builtin/sdw-wd14-tagger/scripts/tagger.py

@@ -0,0 +1,21 @@
+"""Tagger module entry point."""
+from PIL import Image, ImageFile
+
+from modules import script_callbacks  # pylint: disable=import-error
+from tagger.api import on_app_started  # pylint: disable=import-error
+from tagger.ui import on_ui_tabs  # pylint: disable=import-error
+from tagger.settings import on_ui_settings  # pylint: disable=import-error
+
+
+# if you do not initialize the Image object
+# Image.registered_extensions() returns only PNG
+Image.init()
+
+# PIL spits errors when loading a truncated image by default
+# https://pillow.readthedocs.io/en/stable/reference/ImageFile.html#PIL.ImageFile.LOAD_TRUNCATED_IMAGES
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+script_callbacks.on_app_started(on_app_started)
+script_callbacks.on_ui_tabs(on_ui_tabs)
+script_callbacks.on_ui_settings(on_ui_settings)

extensions-builtin/sdw-wd14-tagger/style.css

@@ -0,0 +1,43 @@
+#rating-confidences .output-label>div:not(:first-child) {
+    cursor: pointer;
+}
+
+#tag-confidences .output-label>div:not(:first-child) {
+    cursor: pointer;
+}
+
+#rating-confidences .output-label>div:not(:first-child):hover {
+    foreground-color: #f5f5f5;
+}
+
+#tag-confidences .output-label>div:not(:first-child):hover {
+    foreground-color: #f5f5f5;
+}
+
+#rating-confidences .output-label>div:not(:first-child):active {
+    foreground-color: #e6e6e6;
+}
+
+#tag-confidences .output-label>div:not(:first-child):active {
+    foreground-color: #e6e6e6;
+}
+
+#discard-tag-confidences .output-label>div:not(:first-child) {
+    cursor: pointer;
+}
+
+#discard-tag-confidences .output-label>div:not(:first-child):hover {
+    foreground-color: #f5f5f5;
+}
+
+#discard-tag-confidences .output-label>div:not(:first-child):active {
+    foreground-color: #e6e6e6;
+}
+#tags a {
+    font-weight: inherit;
+    color: #888;
+}
+#tags a:hover {
+    color: #f5f5f5;
+}
+

extensions-builtin/sdw-wd14-tagger/tag_based_image_dedup.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# this script is for deduping images based on tags after they have been interrogated using this extension
+#
+# the file removal instructions are written to remove_instructions.sh
+# you have to manually run remove_instructions.sh to remove the files
+# this script requires exiftool and feh
+# TODO: implement this in the extension
+#
+# Usage:
+# repo_dir=/path/to/repo
+# cd /path/to/images
+#
+
+# use tabs as field separator
+while read -r -d '\t' first_file second_file etc; do
+  # images may be jpg jpeg or png
+  first_image=$(basename "$first_file" ".txt")
+  if [[ -f "$first_image.jpg" ]]; then
+    first_image="$first_image.jpg"
+  elif [[ -f "$first_image.jpeg" ]]; then
+    first_image="$first_image.jpeg"
+  elif [[ -f "$first_image.png" ]]; then
+    first_image="$first_image.png"
+  else
+    echo "No image file found for $first_file" 1>&2
+    continue
+  fi
+  second_image=$(basename "$second_file" ".txt")
+  if [[ -f "$second_image.jpg" ]]; then
+    second_image="$second_image.jpg"
+  elif [[ -f "$second_image.jpeg" ]]; then
+    second_image="$second_image.jpeg"
+  elif [[ -f "$second_image.png" ]]; then
+    second_image="$second_image.png"
+  else
+    echo "No image file found for $second_file" 1>&2
+    continue
+  fi
+  feh -g 950x800+5+30 -Z --scale-down -d -S filename --title "$first_image" "$first_image"&
+  pid1=$!
+  feh -g 950x800+963+30 -Z --scale-down -d -S filename --title "$second_image" "$second_image"&
+  pid2=$!
+  read -p "Are $first_image and $second_image the same? " -n 1 -r REPLY </dev/tty 1>&2
+  if  [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Not the same" 1>&2
+    continue
+  fi
+  # keep file with largest dimensions
+  first_width=$(exiftool "$first_image" | grep -E '^Image Width' | cut -d ':' -f 2)
+  first_height=$(exiftool "$first_image" | grep -E '^Image Height' | cut -d ':' -f 2)
+  second_width=$(exiftool "$second_image" | grep -E '^Image Width' | cut -d ':' -f 2)
+  second_height=$(exiftool "$second_image" | grep -E '^Image Height' | cut -d ':' -f 2)
+  echo -e "$first_image: ${first_width}x${first_height}\t-\t$second_image: ${second_width}x${second_height}" 1>&2
+  first_product=$((first_width * first_height))
+  second_product=$((second_width * second_height))
+
+  if [ $first_product -eq $second_product ]; then
+    read -p "Same size for 1) $first_image and 2) $second_image. Which one do you want to keep? (1/2) [skip]" -n 1 -r REPLY </dev/tty 1>&2
+    if [[ $REPLY =~ ^[1]$ ]]; then
+      echo "Keeping $first_file" 1>&2
+      echo rm "$second_file" "$second_image"
+    elif [[ $REPLY =~ ^[2]$ ]]; then
+      echo "Keeping $second_file" 1>&2
+      echo rm "$first_file" "$first_image"
+    else
+      echo "Skipping" 1>&2
+    fi
+  elif [ $((first_width * first_height)) -gt $((second_width * second_height)) ]; then
+    echo "Keeping $first_file" 1>&2
+    echo rm "$second_file" "$second_image"
+  else
+    echo "Keeping $second_file" 1>&2
+    echo rm "$first_file" "$first_image"
+  fi
+  kill $pid1 $pid2
+done < <(
+ls -1 *.txt | while read f; do
+  sed 's/, /\n/g' "$f" | sort | tr '\n' ',' | sed "s~,$~\t$f\n~"
+done | sort | awk -F'\t' '{
+  a[$1] = a[$1] == "" ? $2 : a[$1]"\t"$2;
+} END {
+  for (i in a) {
+    if (index(a[i], "\t") != 0) {
+      print a[i];
+    }
+  }
+}') > remove_instructions.sh

extensions-builtin/sdw-wd14-tagger/tagger/api.py

@@ -0,0 +1,119 @@
+"""API module for FastAPI"""
+from typing import Callable
+from threading import Lock
+from secrets import compare_digest
+
+from modules import shared  # pylint: disable=import-error
+from modules.api.api import decode_base64_to_image  # pylint: disable=E0401
+from modules.call_queue import queue_lock  # pylint: disable=import-error
+from fastapi import FastAPI, Depends, HTTPException
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+
+from tagger import utils  # pylint: disable=import-error
+from tagger import api_models as models  # pylint: disable=import-error
+from tagger.uiset import QData  # pylint: disable=import-error
+
+
+class Api:
+    """Api class for FastAPI"""
+    def __init__(
+        self, app: FastAPI, qlock: Lock, prefix: str = None
+    ) -> None:
+        if shared.cmd_opts.api_auth:
+            self.credentials = {}
+            for auth in shared.cmd_opts.api_auth.split(","):
+                user, password = auth.split(":")
+                self.credentials[user] = password
+
+        self.app = app
+        self.queue_lock = qlock
+        self.prefix = prefix
+
+        self.add_api_route(
+            'interrogate',
+            self.endpoint_interrogate,
+            methods=['POST'],
+            response_model=models.TaggerInterrogateResponse
+        )
+
+        self.add_api_route(
+            'interrogators',
+            self.endpoint_interrogators,
+            methods=['GET'],
+            response_model=models.InterrogatorsResponse
+        )
+
+        self.add_api_route(
+            "unload-interrogators",
+            self.endpoint_unload_interrogators,
+            methods=["POST"],
+            response_model=str,
+        )
+
+    def auth(self, creds: HTTPBasicCredentials = None):
+        if creds is None:
+            creds = Depends(HTTPBasic())
+        if creds.username in self.credentials:
+            if compare_digest(creds.password,
+                              self.credentials[creds.username]):
+                return True
+
+        raise HTTPException(
+            status_code=401,
+            detail="Incorrect username or password",
+            headers={
+                "WWW-Authenticate": "Basic"
+            })
+
+    def add_api_route(self, path: str, endpoint: Callable, **kwargs):
+        if self.prefix:
+            path = f'{self.prefix}/{path}'
+
+        if shared.cmd_opts.api_auth:
+            return self.app.add_api_route(path, endpoint, dependencies=[
+                   Depends(self.auth)], **kwargs)
+        return self.app.add_api_route(path, endpoint, **kwargs)
+
+    def endpoint_interrogate(self, req: models.TaggerInterrogateRequest):
+        if req.image is None:
+            raise HTTPException(404, 'Image not found')
+
+        if req.model not in utils.interrogators.keys():
+            raise HTTPException(404, 'Model not found')
+
+        image = decode_base64_to_image(req.image)
+        interrogator = utils.interrogators[req.model]
+
+        with self.queue_lock:
+            QData.tags.clear()
+            QData.ratings.clear()
+            QData.in_db.clear()
+            QData.for_tags_file.clear()
+            data = ('', '', '') + interrogator.interrogate(image)
+            QData.apply_filters(data)
+            output = QData.finalize(1)
+
+        return models.TaggerInterrogateResponse(
+            caption={
+                **output[0],
+                **output[1],
+                **output[2],
+            })
+
+    def endpoint_interrogators(self):
+        return models.InterrogatorsResponse(
+            models=list(utils.interrogators.keys())
+        )
+
+    def endpoint_unload_interrogators(self):
+        unloaded_models = 0
+
+        for i in utils.interrogators.values():
+            if i.unload():
+                unloaded_models = unloaded_models + 1
+
+        return f"Successfully unload {unloaded_models} model(s)"
+
+
+def on_app_started(_, app: FastAPI):
+    Api(app, queue_lock, '/tagger/v1')

extensions-builtin/sdw-wd14-tagger/tagger/api_models.py

@@ -0,0 +1,37 @@
+"""Purpose: Pydantic models for the API."""
+from typing import List, Dict
+
+from modules.api import models as sd_models  # pylint: disable=E0401
+from pydantic import BaseModel, Field
+
+
+class TaggerInterrogateRequest(sd_models.InterrogateRequest):
+    """Interrogate request model"""
+    model: str = Field(
+        title='Model',
+        description='The interrogate model used.'
+    )
+
+    threshold: float = Field(
+        default=0.35,
+        title='Threshold',
+        description='',
+        ge=0,
+        le=1
+    )
+
+
+class TaggerInterrogateResponse(BaseModel):
+    """Interrogate response model"""
+    caption: Dict[str, float] = Field(
+        title='Caption',
+        description='The generated caption for the image.'
+    )
+
+
+class InterrogatorsResponse(BaseModel):
+    """Interrogators response model"""
+    models: List[str] = Field(
+        title='Models',
+        description=''
+    )

extensions-builtin/sdw-wd14-tagger/tagger/dbimutils.py

@@ -0,0 +1,81 @@
+"""DanBooru IMage Utility functions"""
+
+import cv2
+import numpy as np
+from PIL import Image
+
+
+def fill_transparent(image: Image.Image, color='WHITE'):
+    image = image.convert('RGBA')
+    new_image = Image.new('RGBA', image.size, color)
+    new_image.paste(image, mask=image)
+    image = new_image.convert('RGB')
+    return image
+
+
+def resize(pic: Image.Image, size: int, keep_ratio=True) -> Image.Image:
+    if not keep_ratio:
+        target_size = (size, size)
+    else:
+        min_edge = min(pic.size)
+        target_size = (
+            int(pic.size[0] / min_edge * size),
+            int(pic.size[1] / min_edge * size),
+        )
+
+    target_size = (target_size[0] & ~3, target_size[1] & ~3)
+
+    return pic.resize(target_size, resample=Image.Resampling.LANCZOS)
+
+
+def smart_imread(img, flag=cv2.IMREAD_UNCHANGED):
+    """ Read an image, convert to 24-bit if necessary """
+    if img.endswith(".gif"):
+        img = Image.open(img)
+        img = img.convert("RGB")
+        img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+    else:
+        img = cv2.imread(img, flag)
+    return img
+
+
+def smart_24bit(img):
+    """ Convert an image to 24-bit if necessary """
+    if img.dtype is np.dtype(np.uint16):
+        img = (img / 257).astype(np.uint8)
+
+    if len(img.shape) == 2:
+        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+    elif img.shape[2] == 4:
+        trans_mask = img[:, :, 3] == 0
+        img[trans_mask] = [255, 255, 255, 255]
+        img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+    return img
+
+
+def make_square(img, target_size):
+    """ Make an image square """
+    old_size = img.shape[:2]
+    desired_size = max(old_size)
+    desired_size = max(desired_size, target_size)
+
+    delta_w = desired_size - old_size[1]
+    delta_h = desired_size - old_size[0]
+    top, bottom = delta_h // 2, delta_h - (delta_h // 2)
+    left, right = delta_w // 2, delta_w - (delta_w // 2)
+
+    color = [255, 255, 255]
+    new_im = cv2.copyMakeBorder(
+        img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
+    )
+    return new_im
+
+
+def smart_resize(img, size):
+    """ Resize an image """
+    # Assumes the image has already gone through make_square
+    if img.shape[0] > size:
+        img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA)
+    elif img.shape[0] < size:
+        img = cv2.resize(img, (size, size), interpolation=cv2.INTER_CUBIC)
+    return img

extensions-builtin/sdw-wd14-tagger/tagger/format.py

@@ -0,0 +1,46 @@
+"""Format module, for formatting output filenames"""
+import re
+import hashlib
+
+from typing import Dict, Callable, NamedTuple
+from pathlib import Path
+
+
+class Info(NamedTuple):
+    path: Path
+    output_ext: str
+
+
+def hashfun(i: Info, algo='sha1') -> str:
+    try:
+        hasher = hashlib.new(algo)
+    except ImportError as err:
+        raise ValueError(f"'{algo}' is invalid hash algorithm") from err
+
+    with open(i.path, 'rb') as file:
+        hasher.update(file.read())
+
+    return hasher.hexdigest()
+
+
+pattern = re.compile(r'\[([\w:]+)\]')
+
+# all function must returns string or raise TypeError or ValueError
+# other errors will cause the extension error
+available_formats: Dict[str, Callable] = {
+    'name': lambda i: i.path.stem,
+    'extension': lambda i: i.path.suffix[1:],
+    'hash': hashfun,
+
+    'output_extension': lambda i: i.output_ext
+}
+
+
+def parse(match: re.Match, info: Info) -> str:
+    matches = match[1].split(':')
+    name, args = matches[0], matches[1:]
+
+    if name not in available_formats:
+        return match[0]
+
+    return available_formats[name](info, *args)

extensions-builtin/sdw-wd14-tagger/tagger/generator/tf_data_reader.py

@@ -0,0 +1,133 @@
+""" Credits to SmilingWolf """
+
+import tensorflow as tf
+try:
+    import tensorflow_io as tfio  # pylint: disable=import-error
+except ImportError:
+    tfio = None
+
+def is_webp(contents):
+    """Checks if the image is a webp image"""
+    riff_header = tf.strings.substr(contents, 0, 4)
+    webp_header = tf.strings.substr(contents, 8, 4)
+
+    is_riff = riff_header == b"RIFF"
+    is_fourcc_webp = webp_header == b"WEBP"
+    return is_riff and is_fourcc_webp
+
+
+class DataGenerator:
+    """ Data generator for the dataset """
+    def __init__(self, file_list, target_height, target_width, batch_size):
+        self.file_list = file_list
+        self.target_width = target_width
+        self.target_height = target_height
+        self.batch_size = batch_size
+
+    def read_image(self, filename):
+        image_bytes = tf.io.read_file(filename)
+        return filename, image_bytes
+
+    def parse_single_image(self, filename, image_bytes):
+        """ Parses a single image """
+        if is_webp(image_bytes):
+            image = tfio.image.decode_webp(image_bytes)
+        else:
+            image = tf.io.decode_image(
+                image_bytes, channels=0, dtype=tf.uint8,
+                expand_animations=False
+            )
+
+        # Black and white image
+        if tf.shape(image)[2] == 1:
+            image = tf.repeat(image, 3, axis=-1)
+
+        # Black and white image with alpha
+        elif tf.shape(image)[2] == 2:
+            image, mask = tf.unstack(image, num=2, axis=-1)
+            mask = tf.expand_dims(mask, axis=-1)
+            image = tf.expand_dims(image, axis=-1)
+            image = tf.repeat(image, 3, axis=-1)
+            image = tf.concat([image, mask], -1)
+
+        # Alpha to white
+        if tf.shape(image)[2] == 4:
+            alpha_mask = image[:, :, 3]
+            alpha_mask = tf.cast(alpha_mask, tf.float32) / 255
+            alpha_mask = tf.repeat(tf.expand_dims(alpha_mask, -1), 4, axis=-1)
+
+            matte = tf.ones_like(image, dtype=tf.uint8) * [255, 255, 255, 255]
+
+            weighted_matte = tf.cast(matte, dtype=alpha_mask.dtype) * (1 - alpha_mask)  # noqa: E501
+            weighted_image = tf.cast(image, dtype=alpha_mask.dtype) * alpha_mask  # noqa: E501
+            image = weighted_image + weighted_matte
+
+            # Remove alpha channel
+            image = tf.cast(image, dtype=tf.uint8)[:, :, :-1]
+
+        # Pillow/Tensorflow RGB -> OpenCV BGR
+        image = image[:, :, ::-1]
+        return filename, image
+
+    def resize_single_image(self, filename, image):
+        """ Resizes a single image """
+        height, width, _ = tf.unstack(tf.shape(image))
+
+        if height <= self.target_height and width <= self.target_width:
+            return filename, image
+
+        image = tf.image.resize(
+            image,
+            (self.target_height, self.target_width),
+            method=tf.image.ResizeMethod.AREA,
+            preserve_aspect_ratio=True,
+        )
+        image = tf.cast(tf.math.round(image), dtype=tf.uint8)
+        return filename, image
+
+    def pad_single_image(self, filename, image):
+        """ Pads a single image """
+        height, width, _ = tf.unstack(tf.shape(image))
+
+        float_h = tf.cast(height, dtype=tf.float32)
+        float_w = tf.cast(width, dtype=tf.float32)
+        float_target_h = tf.cast(self.target_height, dtype=tf.float32)
+        float_target_w = tf.cast(self.target_width, dtype=tf.float32)
+
+        padding_top = tf.cast((float_target_h - float_h) / 2, dtype=tf.int32)
+        padding_right = tf.cast((float_target_w - float_w) / 2, dtype=tf.int32)
+        padding_bottom = self.target_height - padding_top - height
+        padding_left = self.target_width - padding_right - width
+
+        padding = [[padding_top, padding_bottom],
+                   [padding_right, padding_left], [0, 0]]
+        image = tf.pad(image, padding, mode="CONSTANT", constant_values=255)
+        return filename, image
+
+    def gen_ds(self):
+        """ Generates the dataset """
+        if tfio is None:
+            print("Tensorflow IO is not installed, try\n"
+                  "`pip install tensorflow_io' or use another interrogator")
+            return []
+        images_list = tf.data.Dataset.from_tensor_slices(self.file_list)
+
+        images_data = images_list.map(
+            self.read_image, num_parallel_calls=tf.data.AUTOTUNE
+        )
+        images_data = images_data.map(
+            self.parse_single_image, num_parallel_calls=tf.data.AUTOTUNE
+        )
+        images_data = images_data.map(
+            self.resize_single_image, num_parallel_calls=tf.data.AUTOTUNE
+        )
+        images_data = images_data.map(
+            self.pad_single_image, num_parallel_calls=tf.data.AUTOTUNE
+        )
+
+        images_list = images_data.batch(
+            self.batch_size, drop_remainder=False,
+            num_parallel_calls=tf.data.AUTOTUNE
+        )
+        images_list = images_list.prefetch(tf.data.AUTOTUNE)
+        return images_list

extensions-builtin/sdw-wd14-tagger/tagger/interrogator.py

@@ -0,0 +1,660 @@
+""" Interrogator class and subclasses for tagger """
+import os
+from pathlib import Path
+import io
+import json
+import inspect
+from re import match as re_match
+from platform import system, uname
+from typing import Tuple, List, Dict, Callable
+from pandas import read_csv
+from PIL import Image, UnidentifiedImageError
+from numpy import asarray, float32, expand_dims, exp
+from tqdm import tqdm
+from huggingface_hub import hf_hub_download
+
+from modules.paths import extensions_dir
+from modules import shared
+from tagger import settings  # pylint: disable=import-error
+from tagger.uiset import QData, IOData  # pylint: disable=import-error
+from . import dbimutils  # pylint: disable=import-error # noqa
+
+Its = settings.InterrogatorSettings
+
+# select a device to process
+use_cpu = ('all' in shared.cmd_opts.use_cpu) or (
+    'interrogate' in shared.cmd_opts.use_cpu)
+
+# https://onnxruntime.ai/docs/execution-providers/
+# https://github.com/toriato/stable-diffusion-webui-wd14-tagger/commit/e4ec460122cf674bbf984df30cdb10b4370c1224#r92654958
+onnxrt_providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+
+if shared.cmd_opts.additional_device_ids is not None:
+    m = re_match(r'([cg])pu:\d+$', shared.cmd_opts.additional_device_ids)
+    if m is None:
+        raise ValueError('--device-id is not cpu:<nr> or gpu:<nr>')
+    if m.group(1) == 'c':
+        onnxrt_providers.pop(0)
+    TF_DEVICE_NAME = f'/{shared.cmd_opts.additional_device_ids}'
+elif use_cpu:
+    TF_DEVICE_NAME = '/cpu:0'
+    onnxrt_providers.pop(0)
+else:
+    TF_DEVICE_NAME = '/gpu:0'
+
+print(f'== WD14 tagger {TF_DEVICE_NAME}, {uname()} ==')
+
+
+class Interrogator:
+    """ Interrogator class for tagger """
+    # the raw input and output.
+    input = {
+        "cumulative": False,
+        "large_query": False,
+        "unload_after": False,
+        "add": '',
+        "keep": '',
+        "exclude": '',
+        "search": '',
+        "replace": '',
+        "output_dir": '',
+    }
+    output = None
+    odd_increment = 0
+
+    @classmethod
+    def flip(cls, key):
+        def toggle():
+            cls.input[key] = not cls.input[key]
+        return toggle
+
+    @staticmethod
+    def get_errors() -> str:
+        errors = ''
+        if len(IOData.err) > 0:
+            # write errors in html pointer list, every error in a <li> tag
+            errors = IOData.error_msg()
+        if len(QData.err) > 0:
+            errors += 'Fix to write correct output:<br><ul><li>' + \
+                      '</li><li>'.join(QData.err) + '</li></ul>'
+        return errors
+
+    @classmethod
+    def set(cls, key: str) -> Callable[[str], Tuple[str, str]]:
+        def setter(val) -> Tuple[str, str]:
+            if key == 'input_glob':
+                IOData.update_input_glob(val)
+                return (val, cls.get_errors())
+            if val != cls.input[key]:
+                tgt_cls = IOData if key == 'output_dir' else QData
+                getattr(tgt_cls, "update_" + key)(val)
+                cls.input[key] = val
+            return (cls.input[key], cls.get_errors())
+
+        return setter
+
+    @staticmethod
+    def load_image(path: str) -> Image:
+        try:
+            return Image.open(path)
+        except FileNotFoundError:
+            print(f'${path} not found')
+        except UnidentifiedImageError:
+            # just in case, user has mysterious file...
+            print(f'${path} is not a  supported image type')
+        except ValueError:
+            print(f'${path} is not readable or StringIO')
+        return None
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.model = None
+        self.tags = None
+        # run_mode 0 is dry run, 1 means run (alternating), 2 means disabled
+        self.run_mode = 0 if hasattr(self, "large_batch_interrogate") else 2
+
+    def load(self):
+        raise NotImplementedError()
+
+    def large_batch_interrogate(self, images: List, dry_run=False) -> str:
+        raise NotImplementedError()
+
+    def unload(self) -> bool:
+        unloaded = False
+
+        if self.model is not None:
+            del self.model
+            self.model = None
+            unloaded = True
+            print(f'Unloaded {self.name}')
+
+        if hasattr(self, 'tags'):
+            del self.tags
+            self.tags = None
+
+        return unloaded
+
+    def interrogate_image(self, image: Image) -> None:
+        sha = IOData.get_bytes_hash(image.tobytes())
+        QData.clear(1 - Interrogator.input["cumulative"])
+
+        fi_key = sha + self.name
+        count = 0
+
+        if fi_key in QData.query:
+            # this file was already queried for this interrogator.
+            QData.single_data(fi_key)
+        else:
+            # single process
+            count += 1
+            data = ('', '', fi_key) + self.interrogate(image)
+            # When drag-dropping an image, the path [0] is not known
+            if Interrogator.input["unload_after"]:
+                self.unload()
+
+            QData.apply_filters(data)
+
+        for got in QData.in_db.values():
+            QData.apply_filters(got)
+
+        Interrogator.output = QData.finalize(count)
+
+    def batch_interrogate_image(self, index: int) -> None:
+        # if outputpath is '', no tags file will be written
+        if len(IOData.paths[index]) == 5:
+            path, out_path, output_dir, image_hash, image = IOData.paths[index]
+        elif len(IOData.paths[index]) == 4:
+            path, out_path, output_dir, image_hash = IOData.paths[index]
+            image = Interrogator.load_image(path)
+            # should work, we queried before to get the image_hash
+        else:
+            path, out_path, output_dir = IOData.paths[index]
+            image = Interrogator.load_image(path)
+            if image is None:
+                return
+
+            image_hash = IOData.get_bytes_hash(image.tobytes())
+            IOData.paths[index].append(image_hash)
+            if getattr(shared.opts, 'tagger_store_images', False):
+                IOData.paths[index].append(image)
+
+            if output_dir:
+                output_dir.mkdir(0o755, True, True)
+                # next iteration we don't need to create the directory
+                IOData.paths[index][2] = ''
+        QData.image_dups[image_hash].add(path)
+
+        abspath = str(path.absolute())
+        fi_key = image_hash + self.name
+
+        if fi_key in QData.query:
+            # this file was already queried for this interrogator.
+            i = QData.get_index(fi_key, abspath)
+            # this file was already queried and stored
+            QData.in_db[i] = (abspath, out_path, '', {}, {})
+        else:
+            data = (abspath, out_path, fi_key) + self.interrogate(image)
+            # also the tags can indicate that the image is a duplicate
+            no_floats = sorted(filter(lambda x: not isinstance(x[0], float),
+                                      data[3].items()), key=lambda x: x[0])
+            sorted_tags = ','.join(f'({k},{v:.1f})' for (k, v) in no_floats)
+            QData.image_dups[sorted_tags].add(abspath)
+            QData.apply_filters(data)
+            QData.had_new = True
+
+    def batch_interrogate(self) -> None:
+        """ Interrogate all images in the input list """
+        QData.clear(1 - Interrogator.input["cumulative"])
+
+        if Interrogator.input["large_query"] is True and self.run_mode < 2:
+            # TODO: write specified tags files instead of simple .txt
+            image_list = [str(x[0].resolve()) for x in IOData.paths]
+            self.large_batch_interrogate(image_list, self.run_mode == 0)
+
+            # alternating dry run and run modes
+            self.run_mode = (self.run_mode + 1) % 2
+            count = len(image_list)
+            Interrogator.output = QData.finalize(count)
+        else:
+            verb = getattr(shared.opts, 'tagger_verbose', True)
+            count = len(QData.query)
+
+            for i in tqdm(range(len(IOData.paths)), disable=verb, desc='Tags'):
+                self.batch_interrogate_image(i)
+
+            if Interrogator.input["unload_after"]:
+                self.unload()
+
+            count = len(QData.query) - count
+            Interrogator.output = QData.finalize_batch(count)
+
+    def interrogate(
+        self,
+        image: Image
+    ) -> Tuple[
+        Dict[str, float],  # rating confidences
+        Dict[str, float]  # tag confidences
+    ]:
+        raise NotImplementedError()
+
+
+class DeepDanbooruInterrogator(Interrogator):
+    """ Interrogator for DeepDanbooru models """
+    def __init__(self, name: str, project_path: os.PathLike) -> None:
+        super().__init__(name)
+        self.project_path = project_path
+        self.model = None
+        self.tags = None
+
+    def load(self) -> None:
+        print(f'Loading {self.name} from {str(self.project_path)}')
+
+        # deepdanbooru package is not include in web-sd anymore
+        # https://github.com/AUTOMATIC1111/stable-diffusion-webui/commit/c81d440d876dfd2ab3560410f37442ef56fc663
+        from launch import is_installed, run_pip
+        if not is_installed('deepdanbooru'):
+            package = os.environ.get(
+                'DEEPDANBOORU_PACKAGE',
+                'git+https://github.com/KichangKim/DeepDanbooru.'
+                'git@d91a2963bf87c6a770d74894667e9ffa9f6de7ff'
+            )
+
+            run_pip(
+                f'install {package} tensorflow tensorflow-io', 'deepdanbooru')
+
+        import tensorflow as tf
+
+        # tensorflow maps nearly all vram by default, so we limit this
+        # https://www.tensorflow.org/guide/gpu#limiting_gpu_memory_growth
+        # TODO: only run on the first run
+        for device in tf.config.experimental.list_physical_devices('GPU'):
+            try:
+                tf.config.experimental.set_memory_growth(device, True)
+            except RuntimeError as err:
+                print(err)
+
+        with tf.device(TF_DEVICE_NAME):
+            import deepdanbooru.project as ddp
+
+            self.model = ddp.load_model_from_project(
+                project_path=self.project_path,
+                compile_model=False
+            )
+
+            print(f'Loaded {self.name} model from {str(self.project_path)}')
+
+            self.tags = ddp.load_tags_from_project(
+                project_path=self.project_path
+            )
+
+    def unload(self) -> bool:
+        return False
+
+    def interrogate(
+        self,
+        image: Image
+    ) -> Tuple[
+        Dict[str, float],  # rating confidences
+        Dict[str, float]  # tag confidences
+    ]:
+        # init model
+        if self.model is None:
+            self.load()
+
+        import deepdanbooru.data as ddd
+
+        # convert an image to fit the model
+        image_bufs = io.BytesIO()
+        image.save(image_bufs, format='PNG')
+        image = ddd.load_image_for_evaluate(
+            image_bufs,
+            self.model.input_shape[2],
+            self.model.input_shape[1]
+        )
+
+        image = image.reshape((1, *image.shape[0:3]))
+
+        # evaluate model
+        result = self.model.predict(image)
+
+        confidences = result[0].tolist()
+        ratings = {}
+        tags = {}
+
+        for i, tag in enumerate(self.tags):
+            if tag[:7] != "rating:":
+                tags[tag] = confidences[i]
+            else:
+                ratings[tag[7:]] = confidences[i]
+
+        return ratings, tags
+
+    def large_batch_interrogate(self, images: List, dry_run=False) -> str:
+        raise NotImplementedError()
+
+
+# FIXME this is silly, in what scenario would the env change from MacOS to
+# another OS? TODO: remove if the author does not respond.
+def get_onnxrt():
+    try:
+        import onnxruntime
+        return onnxruntime
+    except ImportError:
+        # only one of these packages should be installed at one time in an env
+        # https://onnxruntime.ai/docs/get-started/with-python.html#install-onnx-runtime
+        # TODO: remove old package when the environment changes?
+        from launch import is_installed, run_pip
+        if not is_installed('onnxruntime'):
+            if system() == "Darwin":
+                package_name = "onnxruntime-silicon"
+            else:
+                package_name = "onnxruntime-gpu"
+            package = os.environ.get(
+                'ONNXRUNTIME_PACKAGE',
+                package_name
+            )
+
+            run_pip(f'install {package}', 'onnxruntime')
+
+    import onnxruntime
+    return onnxruntime
+
+
+class WaifuDiffusionInterrogator(Interrogator):
+    """ Interrogator for Waifu Diffusion models """
+    def __init__(
+        self,
+        name: str,
+        model_path='model.onnx',
+        tags_path='selected_tags.csv',
+        repo_id=None,
+        is_hf=True,
+    ) -> None:
+        super().__init__(name)
+        self.repo_id = repo_id
+        self.model_path = model_path
+        self.tags_path = tags_path
+        self.tags = None
+        self.model = None
+        self.tags = None
+        self.local_model = None
+        self.local_tags = None
+        self.is_hf = is_hf
+
+    def download(self) -> None:
+        mdir = Path(shared.models_path, 'interrogators')
+        if self.is_hf:
+            cache = getattr(shared.opts, 'tagger_hf_cache_dir', Its.hf_cache)
+            print(f"Loading {self.name} model file from {self.repo_id}, "
+                  f"{self.model_path}")
+
+            model_path = hf_hub_download(
+                repo_id=self.repo_id,
+                filename=self.model_path,
+                cache_dir=cache)
+            tags_path = hf_hub_download(
+                repo_id=self.repo_id,
+                filename=self.tags_path,
+                cache_dir=cache)
+        else:
+            model_path = self.local_model
+            tags_path = self.local_tags
+
+        download_model = {
+            'name': self.name,
+            'model_path': model_path,
+            'tags_path': tags_path,
+        }
+        mpath = Path(mdir, 'model.json')
+
+        data = [download_model]
+
+        if not os.path.exists(mdir):
+            os.mkdir(mdir)
+
+        elif os.path.exists(mpath):
+            with io.open(file=mpath, mode='r', encoding='utf-8') as filename:
+                try:
+                    data = json.load(filename)
+                    # No need to append if it's already contained
+                    if download_model not in data:
+                        data.append(download_model)
+                except json.JSONDecodeError as err:
+                    print(f'Adding download_model {mpath} raised {repr(err)}')
+                    data = [download_model]
+
+        with io.open(mpath, 'w', encoding='utf-8') as filename:
+            json.dump(data, filename)
+        return model_path, tags_path
+
+    def load(self) -> None:
+        model_path, tags_path = self.download()
+        ort = get_onnxrt()
+        self.model = ort.InferenceSession(model_path,
+                                          providers=onnxrt_providers)
+
+        print(f'Loaded {self.name} model from {self.repo_id}')
+        self.tags = read_csv(tags_path)
+
+    def interrogate(
+        self,
+        image: Image
+    ) -> Tuple[
+        Dict[str, float],  # rating confidences
+        Dict[str, float]  # tag confidences
+    ]:
+        # init model
+        if self.model is None:
+            self.load()
+
+        # code for converting the image and running the model is taken from the
+        # link below. thanks, SmilingWolf!
+        # https://huggingface.co/spaces/SmilingWolf/wd-v1-4-tags/blob/main/app.py
+
+        # convert an image to fit the model
+        _, height, _, _ = self.model.get_inputs()[0].shape
+
+        # alpha to white
+        image = dbimutils.fill_transparent(image)
+
+        image = asarray(image)
+        # PIL RGB to OpenCV BGR
+        image = image[:, :, ::-1]
+
+        tags = dict
+
+        image = dbimutils.make_square(image, height)
+        image = dbimutils.smart_resize(image, height)
+        image = image.astype(float32)
+        image = expand_dims(image, 0)
+
+        # evaluate model
+        input_name = self.model.get_inputs()[0].name
+        label_name = self.model.get_outputs()[0].name
+        confidences = self.model.run([label_name], {input_name: image})[0]
+
+        tags = self.tags[:][['name']]
+        tags['confidences'] = confidences[0]
+
+        # first 4 items are for rating (general, sensitive, questionable,
+        # explicit)
+        ratings = dict(tags[:4].values)
+
+        # rest are regular tags
+        tags = dict(tags[4:].values)
+
+        return ratings, tags
+
+    def dry_run(self, images) -> Tuple[str, Callable[[str], None]]:
+
+        def process_images(filepaths, _):
+            lines = []
+            for image_path in filepaths:
+                image_path = image_path.numpy().decode("utf-8")
+                lines.append(f"{image_path}\n")
+            with io.open("dry_run_read.txt", "a", encoding="utf-8") as filen:
+                filen.writelines(lines)
+
+        scheduled = [f"{image_path}\n" for image_path in images]
+
+        # Truncate the file from previous runs
+        print("updating dry_run_read.txt")
+        io.open("dry_run_read.txt", "w", encoding="utf-8").close()
+        with io.open("dry_run_scheduled.txt", "w", encoding="utf-8") as filen:
+            filen.writelines(scheduled)
+        return process_images
+
+    def run(self, images, pred_model) -> Tuple[str, Callable[[str], None]]:
+        threshold = QData.threshold
+        self.tags["sanitized_name"] = self.tags["name"].map(
+            lambda i: i if i in Its.kaomojis else i.replace("_", " ")
+        )
+
+        def process_images(filepaths, images):
+            preds = pred_model(images).numpy()
+
+            for ipath, pred in zip(filepaths, preds):
+                ipath = ipath.numpy().decode("utf-8")
+
+                self.tags["preds"] = pred
+                generic = self.tags[self.tags["category"] == 0]
+                chosen = generic[generic["preds"] > threshold]
+                chosen = chosen.sort_values(by="preds", ascending=False)
+                tags_names = chosen["sanitized_name"]
+
+                key = ipath.split("/")[-1].split(".")[0] + "_" + self.name
+                QData.add_tags = tags_names
+                QData.apply_filters((ipath, '', {}, {}), key, False)
+
+                tags_string = ", ".join(tags_names)
+                txtfile = Path(ipath).with_suffix(".txt")
+                with io.open(txtfile, "w", encoding="utf-8") as filename:
+                    filename.write(tags_string)
+        return images, process_images
+
+    def large_batch_interrogate(self, images, dry_run=True) -> None:
+        """ Interrogate a large batch of images. """
+
+        # init model
+        if not hasattr(self, 'model') or self.model is None:
+            self.load()
+
+        os.environ["TF_XLA_FLAGS"] = '--tf_xla_auto_jit=2 '\
+                                     '--tf_xla_cpu_global_jit'
+        # Reduce logging
+        # os.environ["TF_CPP_MIN_LOG_LEVEL"] = "1"
+
+        import tensorflow as tf
+
+        from tagger.generator.tf_data_reader import DataGenerator
+
+        # tensorflow maps nearly all vram by default, so we limit this
+        # https://www.tensorflow.org/guide/gpu#limiting_gpu_memory_growth
+        # TODO: only run on the first run
+        gpus = tf.config.experimental.list_physical_devices("GPU")
+        if gpus:
+            for device in gpus:
+                try:
+                    tf.config.experimental.set_memory_growth(device, True)
+                except RuntimeError as err:
+                    print(err)
+
+        if dry_run:  # dry run
+            height, width = 224, 224
+            process_images = self.dry_run(images)
+        else:
+            _, height, width, _ = self.model.inputs[0].shape
+
+            @tf.function
+            def pred_model(model):
+                return self.model(model, training=False)
+
+            process_images = self.run(images, pred_model)
+
+        generator = DataGenerator(
+            file_list=images, target_height=height, target_width=width,
+            batch_size=getattr(shared.opts, 'tagger_batch_size', 1024)
+        ).gen_ds()
+
+        orig_add_tags = QData.add_tags
+        for filepaths, image_list in tqdm(generator):
+            process_images(filepaths, image_list)
+        QData.add_tag = orig_add_tags
+        del os.environ["TF_XLA_FLAGS"]
+
+
+class MLDanbooruInterrogator(Interrogator):
+    """ Interrogator for the MLDanbooru model. """
+    def __init__(
+        self,
+        name: str,
+        repo_id: str,
+        model_path: str,
+        tags_path='classes.json',
+    ) -> None:
+        super().__init__(name)
+        self.model_path = model_path
+        self.tags_path = tags_path
+        self.repo_id = repo_id
+        self.tags = None
+        self.model = None
+
+    def download(self) -> Tuple[str, str]:
+        print(f"Loading {self.name} model file from {self.repo_id}")
+        cache = getattr(shared.opts, 'tagger_hf_cache_dir', Its.hf_cache)
+
+        model_path = hf_hub_download(
+            repo_id=self.repo_id,
+            filename=self.model_path,
+            cache_dir=cache
+        )
+        tags_path = hf_hub_download(
+            repo_id=self.repo_id,
+            filename=self.tags_path,
+            cache_dir=cache
+        )
+        return model_path, tags_path
+
+    def load(self) -> None:
+        model_path, tags_path = self.download()
+
+        ort = get_onnxrt()
+        self.model = ort.InferenceSession(model_path,
+                                          providers=onnxrt_providers)
+        print(f'Loaded {self.name} model from {model_path}')
+
+        with open(tags_path, 'r', encoding='utf-8') as filen:
+            self.tags = json.load(filen)
+
+    def interrogate(
+        self,
+        image: Image
+    ) -> Tuple[
+        Dict[str, float],  # rating confidents
+        Dict[str, float]  # tag confidents
+    ]:
+        # init model
+        if self.model is None:
+            self.load()
+
+        image = dbimutils.fill_transparent(image)
+        image = dbimutils.resize(image, 448)  # TODO CUSTOMIZE
+
+        x = asarray(image, dtype=float32) / 255
+        # HWC -> 1CHW
+        x = x.transpose((2, 0, 1))
+        x = expand_dims(x, 0)
+
+        input_ = self.model.get_inputs()[0]
+        output = self.model.get_outputs()[0]
+        # evaluate model
+        y, = self.model.run([output.name], {input_.name: x})
+
+        # Softmax
+        y = 1 / (1 + exp(-y))
+
+        tags = {tag: float(conf) for tag, conf in zip(self.tags, y.flatten())}
+        return {}, tags
+
+    def large_batch_interrogate(self, images: List, dry_run=False) -> str:
+        raise NotImplementedError()

extensions-builtin/sdw-wd14-tagger/tagger/preset.py

@@ -0,0 +1,108 @@
+"""Module for Tagger, to save and load presets."""
+import os
+import json
+
+from typing import Tuple, List, Dict
+from pathlib import Path
+from gradio.context import Context
+from modules.images import sanitize_filename_part  # pylint: disable=E0401
+
+PresetDict = Dict[str, Dict[str, any]]
+
+
+class Preset:
+    """Preset class for Tagger, to save and load presets."""
+    base_dir: Path
+    default_filename: str
+    default_values: PresetDict
+    components: List[object]
+
+    def __init__(
+        self,
+        base_dir: os.PathLike,
+        default_filename='default.json'
+    ) -> None:
+        self.base_dir = Path(base_dir)
+        self.default_filename = default_filename
+        self.default_values = self.load(default_filename)[1]
+        self.components = []
+
+    def component(self, component_class: object, **kwargs) -> object:
+        # find all the top components from the Gradio context and create a path
+        parent = Context.block
+        paths = [kwargs['label']]
+
+        while parent is not None:
+            if hasattr(parent, 'label'):
+                paths.insert(0, parent.label)
+
+            parent = parent.parent
+
+        path = '/'.join(paths)
+
+        component = component_class(**{
+            **kwargs,
+            **self.default_values.get(path, {})
+        })
+
+        component.path = path
+
+        self.components.append(component)
+        return component
+
+    def load(self, filename: str) -> Tuple[str, PresetDict]:
+        if not filename.endswith('.json'):
+            filename += '.json'
+
+        path = self.base_dir.joinpath(sanitize_filename_part(filename))
+        configs = {}
+
+        if path.is_file():
+            configs = json.loads(path.read_text(encoding='utf-8'))
+
+        return path, configs
+
+    def save(self, filename: str, *values) -> Tuple:
+        path, configs = self.load(filename)
+
+        for index, component in enumerate(self.components):
+            config = configs.get(component.path, {})
+            config['value'] = values[index]
+
+            for attr in ['visible', 'min', 'max', 'step']:
+                if hasattr(component, attr):
+                    config[attr] = config.get(attr, getattr(component, attr))
+
+            configs[component.path] = config
+
+        self.base_dir.mkdir(0o777, True, True)
+        path.write_text(json.dumps(configs, indent=4), encoding='utf-8')
+
+        return 'successfully saved the preset'
+
+    def apply(self, filename: str) -> Tuple:
+        values = self.load(filename)[1]
+        outputs = []
+
+        for component in self.components:
+            config = values.get(component.path, {})
+
+            if 'value' in config and hasattr(component, 'choices'):
+                if config['value'] not in component.choices:
+                    config['value'] = None
+
+            outputs.append(component.update(**config))
+
+        return (*outputs, 'successfully loaded the preset')
+
+    def list(self) -> List[str]:
+        presets = [
+            p.name
+            for p in self.base_dir.glob('*.json')
+            if p.is_file()
+        ]
+
+        if len(presets) < 1:
+            presets.append(self.default_filename)
+
+        return presets

extensions-builtin/sdw-wd14-tagger/tagger/settings.py

@@ -0,0 +1,157 @@
+"""Settings tab entries for the tagger module"""
+import os
+from typing import List
+from modules import shared  # pylint: disable=import-error
+from gradio import inputs as gr
+
+# kaomoji from WD 1.4 tagger csv. thanks, Meow-San#5400!
+DEFAULT_KAMOJIS = '0_0, (o)_(o), +_+, +_-, ._., <o>_<o>, <|>_<|>, =_=, >_<, 3_3, 6_9, >_o, @_@, ^_^, o_o, u_u, x_x, |_|, ||_||'  # pylint: disable=line-too-long # noqa: E501
+
+DEFAULT_OFF = '[name].[output_extension]'
+
+HF_CACHE = os.environ.get('HF_HOME', os.environ.get('HUGGINGFACE_HUB_CACHE',
+           str(os.path.join(shared.models_path, 'interrogators'))))
+
+def slider_wrapper(value, elem_id, **kwargs):
+    # required or else gradio will throw errors
+    return gr.Slider(**kwargs)
+
+
+def on_ui_settings():
+    """Called when the UI settings tab is opened"""
+    Its = InterrogatorSettings
+    section = 'tagger', 'Tagger'
+    shared.opts.add_option(
+        key='tagger_out_filename_fmt',
+        info=shared.OptionInfo(
+            DEFAULT_OFF,
+            label='Tag file output format. Leave blank to use same filename or'
+            ' e.g. "[name].[hash:sha1].[output_extension]". Also allowed are '
+            '[extension] or any other [hash:<algorithm>] supported by hashlib',
+            section=section,
+        ),
+    )
+    shared.opts.onchange(
+        key='tagger_out_filename_fmt',
+        func=Its.set_output_filename_format
+    )
+    shared.opts.add_option(
+        key='tagger_count_threshold',
+        info=shared.OptionInfo(
+            100.0,
+            label="Maximum number of tags to be shown in the UI",
+            section=section,
+            component=slider_wrapper,
+            component_args={"minimum": 1.0, "maximum": 500.0, "step": 1.0},
+        ),
+    )
+    shared.opts.add_option(
+        key='tagger_batch_recursive',
+        info=shared.OptionInfo(
+            True,
+            label='Glob recursively with input directory pattern',
+            section=section,
+        ),
+    )
+    shared.opts.add_option(
+        key='tagger_auto_serde_json',
+        info=shared.OptionInfo(
+            True,
+            label='Auto load and save JSON database',
+            section=section,
+        ),
+    )
+    shared.opts.add_option(
+        key='tagger_store_images',
+        info=shared.OptionInfo(
+            False,
+            label='Store images in database',
+            section=section,
+        ),
+    )
+    shared.opts.add_option(
+        key='tagger_weighted_tags_files',
+        info=shared.OptionInfo(
+            False,
+            label='Write weights to tags files',
+            section=section,
+        ),
+    )
+    shared.opts.add_option(
+        key='tagger_verbose',
+        info=shared.OptionInfo(
+            False,
+            label='Console log tag counts per file, no progress bar',
+            section=section,
+        ),
+    )
+    shared.opts.add_option(
+        key='tagger_repl_us',
+        info=shared.OptionInfo(
+            True,
+            label='Use spaces instead of underscore',
+            section=section,
+        ),
+    )
+    shared.opts.add_option(
+        key='tagger_repl_us_excl',
+        info=shared.OptionInfo(
+            DEFAULT_KAMOJIS,
+            label='Excudes (split by comma)',
+            section=section,
+        ),
+    )
+    shared.opts.onchange(
+        key='tagger_repl_us_excl',
+        func=Its.set_us_excl
+    )
+    shared.opts.add_option(
+        key='tagger_escape',
+        info=shared.OptionInfo(
+            False,
+            label='Escape brackets',
+            section=section,
+        ),
+    )
+    shared.opts.add_option(
+        key='tagger_batch_size',
+        info=shared.OptionInfo(
+            1024,
+            label='batch size for large queries',
+            section=section,
+        ),
+    )
+    # see huggingface_hub guides/manage-cache
+    shared.opts.add_option(
+        key='tagger_hf_cache_dir',
+        info=shared.OptionInfo(
+            HF_CACHE,
+            label='HuggingFace cache directory, '
+            'see huggingface_hub guides/manage-cache',
+            section=section,
+        ),
+    )
+
+
+def split_str(string: str, separator=',') -> List[str]:
+    return [x.strip() for x in string.split(separator) if x]
+
+
+class InterrogatorSettings:
+    kamojis = set(split_str(DEFAULT_KAMOJIS))
+    output_filename_format = DEFAULT_OFF
+    hf_cache = HF_CACHE
+
+    @classmethod
+    def set_us_excl(cls):
+        ruxs = getattr(shared.opts, 'tagger_repl_us_excl', DEFAULT_KAMOJIS)
+        cls.kamojis = set(split_str(ruxs))
+
+    @classmethod
+    def set_output_filename_format(cls):
+        fnfmt = getattr(shared.opts, 'tagger_out_filename_fmt', DEFAULT_OFF)
+        if fnfmt[-12:] == '.[extension]':
+            print("refused to write an image extension")
+            fnfmt = fnfmt[:-12] + '.[output_extension]'
+
+        cls.output_filename_format = fnfmt.strip()

extensions-builtin/sdw-wd14-tagger/tagger/ui.py

@@ -0,0 +1,482 @@
+""" This module contains the ui for the tagger tab. """
+from typing import Dict, Tuple, List, Optional
+import gradio as gr
+import re
+from PIL import Image
+from packaging import version
+
+try:
+    from tensorflow import __version__ as tf_version
+except ImportError:
+    def tf_version():
+        return '0.0.0'
+
+from html import escape as html_esc
+
+from modules import ui  # pylint: disable=import-error
+from modules import generation_parameters_copypaste as parameters_copypaste  # pylint: disable=import-error # noqa
+
+try:
+    from modules.call_queue import wrap_gradio_gpu_call
+except ImportError:
+    from webui import wrap_gradio_gpu_call  # pylint: disable=import-error
+from tagger import utils  # pylint: disable=import-error
+from tagger.interrogator import Interrogator as It  # pylint: disable=E0401
+from tagger.uiset import IOData, QData  # pylint: disable=import-error
+
+TAG_INPUTS = ["add", "keep", "exclude", "search", "replace"]
+COMMON_OUTPUT = Tuple[
+    Optional[str],               # tags as string
+    Optional[str],               # html tags as string
+    Optional[str],               # discarded tags as string
+    Optional[Dict[str, float]],  # rating confidences
+    Optional[Dict[str, float]],  # tag confidences
+    Optional[Dict[str, float]],  # excluded tag confidences
+    str,               # error message
+]
+
+
+def unload_interrogators() -> Tuple[str]:
+    unloaded_models = 0
+    remaining_models = ''
+
+    for i in utils.interrogators.values():
+        if i.unload():
+            unloaded_models = unloaded_models + 1
+        elif i.model is not None:
+            if remaining_models == '':
+                remaining_models = f', remaining models:<ul><li>{i.name}</li>'
+            else:
+                remaining_models = remaining_models + f'<li>{i.name}</li>'
+    if remaining_models != '':
+        remaining_models = remaining_models + "Some tensorflow models could "\
+                           "not be unloaded, a known issue."
+    QData.clear(1)
+
+    return (f'{unloaded_models} model(s) unloaded{remaining_models}',)
+
+
+def on_interrogate(
+    input_glob: str, output_dir: str, name: str, filt: str, *args
+) -> COMMON_OUTPUT:
+    # input glob should always be rechecked for new files
+    IOData.update_input_glob(input_glob)
+    if output_dir != It.input["output_dir"]:
+        IOData.update_output_dir(output_dir)
+        It.input["output_dir"] = output_dir
+
+    if len(IOData.err) > 0:
+        return (None,) * 6 + (IOData.error_msg(),)
+
+    for i, val in enumerate(args):
+        part = TAG_INPUTS[i]
+        if val != It.input[part]:
+            getattr(QData, "update_" + part)(val)
+            It.input[part] = val
+
+    interrogator: It = next((i for i in utils.interrogators.values() if
+                             i.name == name), None)
+    if interrogator is None:
+        return (None,) * 6 + (f"'{name}': invalid interrogator",)
+
+    interrogator.batch_interrogate()
+    return search_filter(filt)
+
+
+def on_gallery() -> List:
+    return QData.get_image_dups()
+
+
+def on_interrogate_image(*args) -> COMMON_OUTPUT:
+    # hack brcause image interrogaion occurs twice
+    It.odd_increment = It.odd_increment + 1
+    if It.odd_increment & 1 == 1:
+        return (None,) * 6 + ('',)
+    return on_interrogate_image_submit(*args)
+
+
+def on_interrogate_image_submit(
+    image: Image, name: str, filt: str, *args
+) -> COMMON_OUTPUT:
+    for i, val in enumerate(args):
+        part = TAG_INPUTS[i]
+        if val != It.input[part]:
+            getattr(QData, "update_" + part)(val)
+            It.input[part] = val
+
+    if image is None:
+        return (None,) * 6 + ('No image selected',)
+    interrogator: It = next((i for i in utils.interrogators.values() if
+                             i.name == name), None)
+    if interrogator is None:
+        return (None,) * 6 + (f"'{name}': invalid interrogator",)
+
+    interrogator.interrogate_image(image)
+    return search_filter(filt)
+
+
+def move_selection_to_input(
+    filt: str, field: str
+) -> Tuple[Optional[str], Optional[str], str]:
+    """ moves the selected to the input field """
+    if It.output is None:
+        return (None, None, '')
+    tags = It.output[1]
+    got = It.input[field]
+    existing = set(got.split(', '))
+    if filt:
+        re_part = re.compile('(' + re.sub(', ?', '|', filt) + ')')
+        tags = {k: v for k, v in tags.items() if re_part.search(k) and
+                k not in existing}
+        print("Tags remaining: ", tags)
+
+    if len(tags) == 0:
+        return ('', None, '')
+
+    if got != '':
+        got = got + ', '
+
+    (data, info) = It.set(field)(got + ', '.join(tags.keys()))
+    return ('', data, info)
+
+
+def move_selection_to_keep(
+    tag_search_filter: str
+) -> Tuple[Optional[str], Optional[str], str]:
+    return move_selection_to_input(tag_search_filter, "keep")
+
+
+def move_selection_to_exclude(
+    tag_search_filter: str
+) -> Tuple[Optional[str], Optional[str], str]:
+    return move_selection_to_input(tag_search_filter, "exclude")
+
+
+def search_filter(filt: str) -> COMMON_OUTPUT:
+    """ filters the tags and lost tags for the search field """
+    ratings, tags, lost, info = It.output
+    if ratings is None:
+        return (None,) * 6 + (info,)
+    if filt:
+        re_part = re.compile('(' + re.sub(', ?', '|', filt) + ')')
+        tags = {k: v for k, v in tags.items() if re_part.search(k)}
+        lost = {k: v for k, v in lost.items() if re_part.search(k)}
+
+    h_tags = ', '.join(f'<a href="javascript:tag_clicked(\'{html_esc(k)}\','
+                       f'true)">{k}</a>' for k in tags.keys())
+    h_lost = ', '.join(f'<a href="javascript:tag_clicked(\'{html_esc(k)}\','
+                       f'false)">{k}</a>' for k in lost.keys())
+
+    return (', '.join(tags.keys()), h_tags, h_lost, ratings, tags, lost, info)
+
+
+def on_ui_tabs():
+    """ configures the ui on the tagger tab """
+    # If checkboxes misbehave you have to adapt the default.json preset
+    tag_input = {}
+
+    with gr.Blocks(analytics_enabled=False) as tagger_interface:
+        with gr.Row():
+            with gr.Column(variant='panel'):
+
+                # input components
+                with gr.Tabs():
+                    with gr.TabItem(label='Single process'):
+                        image = gr.Image(
+                            label='Source',
+                            source='upload',
+                            interactive=True,
+                            type="pil"
+                        )
+                        image_submit = gr.Button(
+                            value='Interrogate image',
+                            variant='primary'
+                        )
+
+                    with gr.TabItem(label='Batch from directory'):
+                        input_glob = utils.preset.component(
+                            gr.Textbox,
+                            value='',
+                            label='Input directory - To recurse use ** or */* '
+                                  'in your glob; also check the settings tab.',
+                            placeholder='/path/to/images or to/images/**/*'
+                        )
+                        output_dir = utils.preset.component(
+                            gr.Textbox,
+                            value=It.input["output_dir"],
+                            label='Output directory',
+                            placeholder='Leave blank to save images '
+                                        'to the same path.'
+                        )
+
+                        batch_submit = gr.Button(
+                            value='Interrogate',
+                            variant='primary'
+                        )
+                        with gr.Row(variant='compact'):
+                            with gr.Column(variant='panel'):
+                                large_query = utils.preset.component(
+                                    gr.Checkbox,
+                                    label='huge batch query (TF 2.10, '
+                                    'experimental)',
+                                    value=False,
+                                    interactive=version.parse(tf_version) ==
+                                    version.parse('2.10')
+                                )
+                            with gr.Column(variant='panel'):
+                                save_tags = utils.preset.component(
+                                    gr.Checkbox,
+                                    label='Save to tags files',
+                                    value=True
+                                )
+
+                info = gr.HTML(
+                    label='Info',
+                    interactive=False,
+                    elem_classes=['info']
+                )
+
+                # interrogator selector
+                with gr.Column():
+                    # preset selector
+                    with gr.Row(variant='compact'):
+                        available_presets = utils.preset.list()
+                        selected_preset = gr.Dropdown(
+                            label='Preset',
+                            choices=available_presets,
+                            value=available_presets[0]
+                        )
+
+                        save_preset_button = gr.Button(
+                            value=ui.save_style_symbol
+                        )
+
+                        ui.create_refresh_button(
+                            selected_preset,
+                            lambda: None,
+                            lambda: {'choices': utils.preset.list()},
+                            'refresh_preset'
+                        )
+
+                    with gr.Row(variant='compact'):
+                        def refresh():
+                            utils.refresh_interrogators()
+                            return sorted(x.name for x in utils.interrogators
+                                                               .values())
+                        interrogator_names = refresh()
+                        interrogator = utils.preset.component(
+                            gr.Dropdown,
+                            label='Interrogator',
+                            choices=interrogator_names,
+                            value=(
+                                None
+                                if len(interrogator_names) < 1 else
+                                interrogator_names[-1]
+                            )
+                        )
+
+                        ui.create_refresh_button(
+                            interrogator,
+                            lambda: None,
+                            lambda: {'choices': refresh()},
+                            'refresh_interrogator'
+                        )
+
+                    unload_all_models = gr.Button(
+                        value='Unload all interrogate models'
+                    )
+                    with gr.Row(variant='compact'):
+                        tag_input["add"] = utils.preset.component(
+                            gr.Textbox,
+                            label='Additional tags (comma split)',
+                            elem_id='additional-tags'
+                        )
+                    with gr.Row(variant='compact'):
+                        threshold = utils.preset.component(
+                            gr.Slider,
+                            label='Weight threshold',
+                            minimum=0,
+                            maximum=1,
+                            value=QData.threshold
+                        )
+                        tag_frac_threshold = utils.preset.component(
+                            gr.Slider,
+                            label='Min tag fraction in batch and '
+                                  'interrogations',
+                            minimum=0,
+                            maximum=1,
+                            value=QData.tag_frac_threshold,
+                        )
+                    with gr.Row(variant='compact'):
+                        cumulative = utils.preset.component(
+                            gr.Checkbox,
+                            label='Combine interrogations',
+                            value=False
+                        )
+                        unload_after = utils.preset.component(
+                            gr.Checkbox,
+                            label='Unload model after running',
+                            value=False
+                        )
+                    with gr.Row(variant='compact'):
+                        tag_input["search"] = utils.preset.component(
+                            gr.Textbox,
+                            label='Search tag, .. ->',
+                            elem_id='search-tags'
+                        )
+                        tag_input["replace"] = utils.preset.component(
+                            gr.Textbox,
+                            label='-> Replace tag, ..',
+                            elem_id='replace-tags'
+                        )
+                    with gr.Row(variant='compact'):
+                        tag_input["keep"] = utils.preset.component(
+                            gr.Textbox,
+                            label='Keep tag, ..',
+                            elem_id='keep-tags'
+                        )
+                        tag_input["exclude"] = utils.preset.component(
+                            gr.Textbox,
+                            label='Exclude tag, ..',
+                            elem_id='exclude-tags'
+                        )
+
+            # output components
+            with gr.Column(variant='panel'):
+                with gr.Row(variant='compact'):
+                    with gr.Column(variant='compact'):
+                        mv_selection_to_keep = gr.Button(
+                            value='Move visible tags to keep tags',
+                            variant='secondary'
+                        )
+                        mv_selection_to_exclude = gr.Button(
+                            value='Move visible tags to exclude tags',
+                            variant='secondary'
+                        )
+                    with gr.Column(variant='compact'):
+                        tag_search_selection = utils.preset.component(
+                            gr.Textbox,
+                            label='Multi string search: part1, part2.. '
+                                  '(Enter key to update)',
+                        )
+                with gr.Tabs():
+                    with gr.TabItem(label='Ratings and included tags'):
+                        # clickable tags to populate excluded tags
+                        tags = gr.State(value="")
+                        html_tags = gr.HTML(
+                            label='Tags',
+                            elem_id='tags',
+                        )
+
+                        with gr.Row():
+                            parameters_copypaste.bind_buttons(
+                                parameters_copypaste.create_buttons(
+                                    ["txt2img", "img2img"],
+                                ),
+                                None,
+                                tags
+                            )
+                        rating_confidences = gr.Label(
+                            label='Rating confidences',
+                            elem_id='rating-confidences',
+                        )
+                        tag_confidences = gr.Label(
+                            label='Tag confidences',
+                            elem_id='tag-confidences',
+                        )
+                    with gr.TabItem(label='Excluded tags'):
+                        # clickable tags to populate keep tags
+                        discarded_tags = gr.HTML(
+                            label='Tags',
+                            elem_id='tags',
+                        )
+                        excluded_tag_confidences = gr.Label(
+                            label='Excluded Tag confidences',
+                            elem_id='discard-tag-confidences',
+                        )
+                    tab_gallery = gr.TabItem(label='Gallery')
+                    with tab_gallery:
+                        gallery = gr.Gallery(
+                            label='Gallery',
+                            elem_id='gallery',
+                            columns=[2],
+                            rows=[8],
+                            object_fit="contain",
+                            height="auto"
+                        )
+
+        # register events
+        # Checkboxes
+        cumulative.input(fn=It.flip('cumulative'), inputs=[], outputs=[])
+        large_query.input(fn=It.flip('large_query'), inputs=[], outputs=[])
+        unload_after.input(fn=It.flip('unload_after'), inputs=[], outputs=[])
+
+        save_tags.input(fn=IOData.flip_save_tags(), inputs=[], outputs=[])
+
+        # Preset and unload buttons
+        selected_preset.change(fn=utils.preset.apply, inputs=[selected_preset],
+                               outputs=[*utils.preset.components, info])
+
+        save_preset_button.click(fn=utils.preset.save, inputs=[selected_preset,
+                                 *utils.preset.components], outputs=[info])
+
+        unload_all_models.click(fn=unload_interrogators, outputs=[info])
+
+        # Sliders
+        threshold.input(fn=QData.set("threshold"), inputs=[threshold],
+                        outputs=[])
+        threshold.release(fn=QData.set("threshold"), inputs=[threshold],
+                          outputs=[])
+
+        tag_frac_threshold.input(fn=QData.set("tag_frac_threshold"),
+                                 inputs=[tag_frac_threshold], outputs=[])
+        tag_frac_threshold.release(fn=QData.set("tag_frac_threshold"),
+                                   inputs=[tag_frac_threshold], outputs=[])
+
+        # Input textboxes (blur == lose focus)
+        for tag in TAG_INPUTS:
+            tag_input[tag].blur(fn=wrap_gradio_gpu_call(It.set(tag)),
+                                inputs=[tag_input[tag]],
+                                outputs=[tag_input[tag], info])
+
+        input_glob.blur(fn=wrap_gradio_gpu_call(It.set("input_glob")),
+                        inputs=[input_glob], outputs=[input_glob, info])
+        output_dir.blur(fn=wrap_gradio_gpu_call(It.set("output_dir")),
+                        inputs=[output_dir], outputs=[output_dir, info])
+
+        tab_gallery.select(fn=on_gallery, inputs=[], outputs=[gallery])
+
+        common_output = [tags, html_tags, discarded_tags, rating_confidences,
+                         tag_confidences, excluded_tag_confidences, info]
+
+        # search input textbox
+        for fun in [tag_search_selection.change, tag_search_selection.submit]:
+            fun(fn=wrap_gradio_gpu_call(search_filter),
+                inputs=[tag_search_selection], outputs=common_output)
+
+        # buttons to move tags (right)
+        mv_selection_to_keep.click(
+            fn=wrap_gradio_gpu_call(move_selection_to_keep),
+            inputs=[tag_search_selection],
+            outputs=[tag_search_selection, tag_input["keep"], info])
+
+        mv_selection_to_exclude.click(
+            fn=wrap_gradio_gpu_call(move_selection_to_exclude),
+            inputs=[tag_search_selection],
+            outputs=[tag_search_selection, tag_input["exclude"], info])
+
+        common_input = [interrogator, tag_search_selection] + \
+                       [tag_input[tag] for tag in TAG_INPUTS]
+
+        # interrogation events
+        image_submit.click(fn=wrap_gradio_gpu_call(on_interrogate_image_submit),
+             inputs=[image] + common_input, outputs=common_output)
+
+        image.change(fn=wrap_gradio_gpu_call(on_interrogate_image),
+             inputs=[image] + common_input, outputs=common_output)
+
+        batch_submit.click(fn=wrap_gradio_gpu_call(on_interrogate),
+                           inputs=[input_glob, output_dir] + common_input,
+                           outputs=common_output)
+
+    return [(tagger_interface, "Tagger", "tagger")]

extensions-builtin/sdw-wd14-tagger/tagger/uiset.py

@@ -0,0 +1,634 @@
+""" for handling ui settings """
+
+from typing import List, Dict, Tuple, Callable, Set, Optional
+import os
+from pathlib import Path
+from glob import glob
+from math import ceil
+from hashlib import sha256
+from re import compile as re_comp, sub as re_sub, match as re_match, IGNORECASE
+from json import dumps, loads
+from jsonschema import validate, ValidationError
+from functools import partial
+from collections import defaultdict
+from PIL import Image
+
+from modules import shared  # pylint: disable=import-error
+from modules.deepbooru import re_special  # pylint: disable=import-error
+from tagger import format as tags_format  # pylint: disable=import-error
+from tagger import settings  # pylint: disable=import-error
+
+Its = settings.InterrogatorSettings
+
+# PIL.Image.registered_extensions() returns only PNG if you call early
+supported_extensions = {
+    e
+    for e, f in Image.registered_extensions().items()
+    if f in Image.OPEN
+}
+
+# interrogator return type
+ItRetTP = Tuple[
+    Dict[str, float],  # rating confidences
+    Dict[str, float],  # tag confidences
+    Dict[str, float],  # excluded tag confidences
+    str,               # error message
+]
+
+
+class IOData:
+    """ data class for input and output paths """
+    last_path_mtimes = None
+    base_dir = None
+    output_root = None
+    paths = []
+    save_tags = True
+    err = set()
+
+    @classmethod
+    def error_msg(cls) -> str:
+        return "Errors:<ul>" + ''.join(f'<li>{x}</li>' for x in cls.err) + \
+               "</ul>"
+
+    @classmethod
+    def flip_save_tags(cls) -> callable:
+        def toggle():
+            cls.save_tags = not cls.save_tags
+        return toggle
+
+    @classmethod
+    def toggle_save_tags(cls) -> None:
+        cls.save_tags = not cls.save_tags
+
+    @classmethod
+    def update_output_dir(cls, output_dir: str) -> None:
+        """ update output directory, and set input and output paths """
+        pout = Path(output_dir)
+        if pout != cls.output_root:
+            paths = [x[0] for x in cls.paths]
+            cls.paths = []
+            cls.output_root = pout
+            cls.set_batch_io(paths)
+
+    @staticmethod
+    def get_bytes_hash(data) -> str:
+        """ get sha256 checksum of file """
+        # Note: the checksum from an image is not the same as from file
+        return sha256(data).hexdigest()
+
+    @classmethod
+    def get_hashes(cls) -> Set[str]:
+        """ get hashes of all files """
+        ret = set()
+        for entries in cls.paths:
+            if len(entries) == 4:
+                ret.add(entries[3])
+            else:
+                # if there is no checksum, calculate it
+                image = Image.open(entries[0])
+                checksum = cls.get_bytes_hash(image.tobytes())
+                entries.append(checksum)
+                ret.add(checksum)
+        return ret
+
+    @classmethod
+    def update_input_glob(cls, input_glob: str) -> None:
+        """ update input glob pattern, and set input and output paths """
+        input_glob = input_glob.strip()
+
+        paths = []
+
+        # if there is no glob pattern, insert it automatically
+        if not input_glob.endswith('*'):
+            if not input_glob.endswith(os.sep):
+                input_glob += os.sep
+            input_glob += '*'
+
+        # get root directory of input glob pattern
+        base_dir = input_glob.replace('?', '*')
+        base_dir = base_dir.split(os.sep + '*').pop(0)
+        msg = 'Invalid input directory'
+        if not os.path.isdir(base_dir):
+            cls.err.add(msg)
+            return
+        cls.err.discard(msg)
+
+        recursive = getattr(shared.opts, 'tagger_batch_recursive', True)
+        path_mtimes = []
+        for filename in glob(input_glob, recursive=recursive):
+            if not os.path.isdir(filename):
+                ext = os.path.splitext(filename)[1].lower()
+                if ext in supported_extensions:
+                    path_mtimes.append(os.path.getmtime(filename))
+                    paths.append(filename)
+                elif ext != '.txt' and 'db.json' not in filename:
+                    print(f'{filename}: not an image extension: "{ext}"')
+
+        # interrogating in a directory with no pics, still flush the cache
+        if len(path_mtimes) > 0 and cls.last_path_mtimes == path_mtimes:
+            print('No changed images')
+            return
+
+        QData.clear(2)
+        cls.last_path_mtimes = path_mtimes
+
+        if not cls.output_root:
+            cls.output_root = Path(base_dir)
+        elif cls.base_dir and cls.output_root == Path(cls.base_dir):
+            cls.output_root = Path(base_dir)
+
+        # XXX what is this basedir magic trying to achieve?
+        cls.base_dir_last = Path(base_dir).parts[-1]
+        cls.base_dir = base_dir
+
+        QData.read_json(cls.output_root)
+
+        print(f'found {len(paths)} image(s)')
+        cls.set_batch_io(paths)
+
+    @classmethod
+    def set_batch_io(cls, paths: List[str]) -> None:
+        """ set input and output paths for batch mode """
+        checked_dirs = set()
+        cls.paths = []
+        for path in paths:
+            path = Path(path)
+            if not cls.save_tags:
+                cls.paths.append([path, '', ''])
+                continue
+
+            # guess the output path
+            base_dir_last_idx = path.parts.index(cls.base_dir_last)
+            # format output filename
+
+            info = tags_format.Info(path, 'txt')
+            fmt = partial(lambda info, m: tags_format.parse(m, info), info)
+
+            msg = 'Invalid output format'
+            cls.err.discard(msg)
+            try:
+                formatted_output_filename = tags_format.pattern.sub(
+                    fmt,
+                    Its.output_filename_format
+                )
+            except (TypeError, ValueError):
+                cls.err.add(msg)
+
+            output_dir = cls.output_root.joinpath(
+                *path.parts[base_dir_last_idx + 1:]).parent
+
+            tags_out = output_dir.joinpath(formatted_output_filename)
+
+            if output_dir in checked_dirs:
+                cls.paths.append([path, tags_out, ''])
+            else:
+                checked_dirs.add(output_dir)
+                if os.path.exists(output_dir):
+                    msg = 'output_dir: not a directory.'
+                    if os.path.isdir(output_dir):
+                        cls.paths.append([path, tags_out, ''])
+                        cls.err.discard(msg)
+                    else:
+                        cls.err.add(msg)
+                else:
+                    cls.paths.append([path, tags_out, output_dir])
+
+
+class QData:
+    """ Query data: contains parameters for the query """
+    add_tags = []
+    keep_tags = set()
+    exclude_tags = []
+    search_tags = {}
+    replace_tags = []
+    threshold = 0.35
+    tag_frac_threshold = 0.05
+
+    # read from db.json, update with what should be written to db.json:
+    json_db = None
+    weighed = (defaultdict(list), defaultdict(list))
+    query = {}
+
+    # representing the (cumulative) current interrogations
+    ratings = defaultdict(float)
+    tags = defaultdict(list)
+    discarded_tags = defaultdict(list)
+    in_db = {}
+    for_tags_file = defaultdict(lambda: defaultdict(float))
+
+    had_new = False
+    err = set()
+    image_dups = defaultdict(set)
+
+    @classmethod
+    def set(cls, key: str) -> Callable[[str], Tuple[str]]:
+        def setter(val) -> Tuple[str]:
+            setattr(cls, key, val)
+        return setter
+
+    @classmethod
+    def set(cls, key: str) -> Callable[[str], Tuple[str]]:
+        def setter(val) -> Tuple[str]:
+            setattr(cls, key, val)
+        return setter
+
+    @classmethod
+    def clear(cls, mode: int) -> None:
+        """ clear tags and ratings """
+        cls.tags.clear()
+        cls.discarded_tags.clear()
+        cls.ratings.clear()
+        cls.for_tags_file.clear()
+        if mode > 0:
+            cls.in_db.clear()
+            cls.image_dups.clear()
+        if mode > 1:
+            cls.json_db = None
+            cls.weighed = (defaultdict(list), defaultdict(list))
+            cls.query = {}
+        if mode > 2:
+            cls.add_tags = []
+            cls.keep_tags = set()
+            cls.exclude_tags = []
+            cls.search_tags = {}
+            cls.replace_tags = []
+
+    @classmethod
+    def test_add(cls, tag: str, current: str, incompatible: list) -> None:
+        """ check if there are incompatible collections """
+        msg = f'Empty tag in {current} tags'
+        if tag == '':
+            cls.err.add(msg)
+            return
+        cls.err.discard(msg)
+        for bad in incompatible:
+            if current < bad:
+                msg = f'"{tag}" is both in {bad} and {current} tags'
+            else:
+                msg = f'"{tag}" is both in {current} and {bad} tags'
+            attr = getattr(cls, bad + '_tags')
+            if bad == 'search':
+                for rex in attr.values():
+                    if rex.match(tag):
+                        cls.err.add(msg)
+                        return
+            elif bad in 'exclude':
+                if any(rex.match(tag) for rex in attr):
+                    cls.err.add(msg)
+                    return
+            else:
+                if tag in attr:
+                    cls.err.add(msg)
+                    return
+
+        attr = getattr(cls, current + '_tags')
+        if current in ['add', 'replace']:
+            attr.append(tag)
+        elif current == 'keep':
+            attr.add(tag)
+        else:
+            rex = cls.compile_rex(tag)
+            if rex:
+                if current == 'exclude':
+                    attr.append(rex)
+                elif current == 'search':
+                    attr[len(attr)] = rex
+            else:
+                cls.err.add(f'empty regex in {current} tags')
+
+    @classmethod
+    def update_keep(cls, keep: str) -> None:
+        cls.keep_tags = set()
+        if keep == '':
+            return
+        un_re = re_comp(r' keep(?: and \w+)? tags')
+        cls.err = {err for err in cls.err if not un_re.search(err)}
+        for tag in map(str.strip, keep.split(',')):
+            cls.test_add(tag, 'keep', ['exclude', 'search'])
+
+    @classmethod
+    def update_add(cls, add: str) -> None:
+        cls.add_tags = []
+        if add == '':
+            return
+        un_re = re_comp(r' add(?: and \w+)? tags')
+        cls.err = {err for err in cls.err if not un_re.search(err)}
+        for tag in map(str.strip, add.split(',')):
+            cls.test_add(tag, 'add', ['exclude', 'search'])
+
+        # silently raise count threshold to avoid issue in apply_filters
+        count_threshold = getattr(shared.opts, 'tagger_count_threshold', 100)
+        if len(cls.add_tags) > count_threshold:
+            shared.opts.tagger_count_threshold = len(cls.add_tags)
+
+    @staticmethod
+    def compile_rex(rex: str) -> Optional:
+        if rex in {'', '^', '$', '^$'}:
+            return None
+        if rex[0] == '^':
+            rex = rex[1:]
+        if rex[-1] == '$':
+            rex = rex[:-1]
+        return re_comp('^'+rex+'$', flags=IGNORECASE)
+
+    @classmethod
+    def update_exclude(cls, exclude: str) -> None:
+        cls.exclude_tags = []
+        if exclude == '':
+            return
+        un_re = re_comp(r' exclude(?: and \w+)? tags')
+        cls.err = {err for err in cls.err if not un_re.search(err)}
+        for excl in map(str.strip, exclude.split(',')):
+            incompatible = ['add', 'keep', 'search', 'replace']
+            cls.test_add(excl, 'exclude', incompatible)
+
+    @classmethod
+    def update_search(cls, search_str: str) -> None:
+        cls.search_tags = {}
+        if search_str == '':
+            return
+        un_re = re_comp(r' search(?: and \w+)? tags')
+        cls.err = {err for err in cls.err if not un_re.search(err)}
+        for rex in map(str.strip, search_str.split(',')):
+            incompatible = ['add', 'keep', 'exclude', 'replace']
+            cls.test_add(rex, 'search', incompatible)
+
+        msg = 'Unequal number of search and replace tags'
+        if len(cls.search_tags) != len(cls.replace_tags):
+            cls.err.add(msg)
+        else:
+            cls.err.discard(msg)
+
+    @classmethod
+    def update_replace(cls, replace: str) -> None:
+        cls.replace_tags = []
+        if replace == '':
+            return
+        un_re = re_comp(r' replace(?: and \w+)? tags')
+        cls.err = {err for err in cls.err if not un_re.search(err)}
+        for repl in map(str.strip, replace.split(',')):
+            cls.test_add(repl, 'replace', ['exclude', 'search'])
+        msg = 'Unequal number of search and replace tags'
+        if len(cls.search_tags) != len(cls.replace_tags):
+            cls.err.add(msg)
+        else:
+            cls.err.discard(msg)
+
+    @classmethod
+    def get_i_wt(cls, stored: int) -> Tuple[int, float]:
+        """
+        in db.json or QData.weighed, the weights & increment in the list are
+        encoded. Each filestamp-interrogation corresponds to an incrementing
+        index. The index is above the floating point, the weight is below.
+        """
+        i = ceil(stored) - 1
+        return i, stored - i
+
+    @classmethod
+    def read_json(cls, outdir) -> None:
+        """ read db.json if it exists, validate it, and update cls """
+        cls.json_db = None
+        if getattr(shared.opts, 'tagger_auto_serde_json', True):
+            cls.json_db = outdir.joinpath('db.json')
+            if cls.json_db.is_file():
+                print(f'Reading {cls.json_db}')
+                cls.had_new = False
+                msg = f'Error reading {cls.json_db}'
+                cls.err.discard(msg)
+                # validate json using either json_schema/db_jon_v1_schema.json
+                # or json_schema/db_jon_v2_schema.json
+
+                schema = Path(__file__).parent.parent.joinpath(
+                    'json_schema', 'db_json_v1_schema.json'
+                )
+                try:
+                    data = loads(cls.json_db.read_text())
+                    validate(data, loads(schema.read_text()))
+
+                    # convert v2 back to v1
+                    if "meta" in data:
+                        cls.had_new = True  # <- force write for v2 -> v1
+                except (ValidationError, IndexError) as err:
+                    print(f'{msg}: {repr(err)}')
+                    cls.err.add(msg)
+                    data = {"query": {}, "tag": [], "rating": []}
+
+                cls.query = data["query"]
+                cls.weighed = (
+                    defaultdict(list, data["rating"]),
+                    defaultdict(list, data["tag"])
+                )
+                print(f'Read {cls.json_db}: {len(cls.query)} interrogations, '
+                      f'{len(cls.tags)} tags.')
+
+    @classmethod
+    def write_json(cls) -> None:
+        """ write db.json """
+        if cls.json_db is not None:
+            data = {
+                "rating": cls.weighed[0],
+                "tag": cls.weighed[1],
+                "query": cls.query,
+            }
+            cls.json_db.write_text(dumps(data, indent=2))
+            print(f'Wrote {cls.json_db}: {len(cls.query)} interrogations, '
+                  f'{len(cls.tags)} tags.')
+
+    @classmethod
+    def get_index(cls, fi_key: str, path='') -> int:
+        """ get index for filestamp-interrogator """
+        if path and path != cls.query[fi_key][0]:
+            if cls.query[fi_key][0] != '':
+                print(f'Dup or rename: Identical checksums for {path}\n'
+                      f'and: {cls.query[fi_key][0]} (path updated)')
+                cls.had_new = True
+            cls.query[fi_key] = (path, cls.query[fi_key][1])
+
+        return cls.query[fi_key][1]
+
+    @classmethod
+    def single_data(cls, fi_key: str) -> None:
+        """ get tags and ratings for filestamp-interrogator """
+        index = cls.query.get(fi_key)[1]
+        data = ({}, {})
+        for j in range(2):
+            for ent, lst in cls.weighed[j].items():
+                for i, val in map(cls.get_i_wt, lst):
+                    if i == index:
+                        data[j][ent] = val
+
+        QData.in_db[index] = ('', '', '') + data
+
+    @classmethod
+    def is_excluded(cls, ent: str) -> bool:
+        """ check if tag is excluded """
+        return any(re_match(x, ent) for x in cls.exclude_tags)
+
+    @classmethod
+    def correct_tag(cls, tag: str) -> str:
+        """ correct tag for display """
+        replace_underscore = getattr(shared.opts, 'tagger_repl_us', True)
+        if replace_underscore and tag not in Its.kamojis:
+            tag = tag.replace('_', ' ')
+
+        if getattr(shared.opts, 'tagger_escape', False):
+            tag = re_special.sub(r'\\\1', tag)  # tag_escape_pattern
+
+        if len(cls.search_tags) == len(cls.replace_tags):
+            for i, regex in cls.search_tags.items():
+                if re_match(regex, tag):
+                    tag = re_sub(regex, cls.replace_tags[i], tag)
+                    break
+
+        return tag
+
+    @classmethod
+    def apply_filters(cls, data) -> None:
+        """ apply filters to query data, store in db.json if required """
+        # data = (path, fi_key, tags, ratings, new)
+        # fi_key == '' means this is a new file or interrogation for that file
+
+        tags = sorted(data[4].items(), key=lambda x: x[1], reverse=True)
+
+        fi_key = data[2]
+        index = len(cls.query)
+
+        ratings = sorted(data[3].items(), key=lambda x: x[1], reverse=True)
+        # loop over ratings
+        for rating, val in ratings:
+            if fi_key != '':
+                cls.weighed[0][rating].append(val + index)
+            cls.ratings[rating] += val
+
+        count_threshold = getattr(shared.opts, 'tagger_count_threshold', 100)
+        max_ct = count_threshold - len(cls.add_tags)
+        count = 0
+        # loop over tags with db update
+        for tag, val in tags:
+            if isinstance(tag, float):
+                print(f'bad return from interrogator, float: {tag} {val}')
+                # FIXME: why does this happen? what does it mean?
+                continue
+
+            if fi_key != '' and val >= 0.005:
+                cls.weighed[1][tag].append(val + index)
+
+            if count < max_ct:
+                tag = cls.correct_tag(tag)
+                if tag not in cls.keep_tags:
+                    if cls.is_excluded(tag) or val < cls.threshold:
+                        if tag not in cls.add_tags and \
+                           len(cls.discarded_tags) < max_ct:
+                            cls.discarded_tags[tag].append(val)
+                        continue
+                if data[1] != '':
+                    current = cls.for_tags_file[data[1]].get(tag, 0.0)
+                    cls.for_tags_file[data[1]][tag] = min(val + current, 1.0)
+                count += 1
+                if tag not in cls.add_tags:
+                    # those are already added
+                    cls.tags[tag].append(val)
+            elif fi_key == '':
+                break
+
+        if getattr(shared.opts, 'tagger_verbose', True):
+            print(f'{data[0]}: {count}/{len(tags)} tags kept')
+
+        if fi_key != '':
+            cls.query[fi_key] = (data[0], index)
+
+    @classmethod
+    def finalize_batch(cls, count: int) -> ItRetTP:
+        """ finalize the batch query """
+        if cls.json_db and cls.had_new:
+            cls.write_json()
+            cls.had_new = False
+
+        # collect the weights per file/interrogation of the prior in db stored.
+        for index in range(2):
+            for ent, lst in cls.weighed[index].items():
+                for i, val in map(cls.get_i_wt, lst):
+                    if i not in cls.in_db:
+                        continue
+                    cls.in_db[i][3+index][ent] = val
+
+        # process the retrieved from db and add them to the stats
+        for got in cls.in_db.values():
+            no_floats = sorted(filter(lambda x: not isinstance(x[0], float),
+                               got[3].items()), key=lambda x: x[0])
+            sorted_tags = ','.join(f'({k},{v:.1f})' for (k, v) in no_floats)
+            QData.image_dups[sorted_tags].add(got[0])
+            cls.apply_filters(got)
+
+        # average
+        return cls.finalize(count)
+
+    @staticmethod
+    def sort_tags(tags: Dict[str, float]) -> List[Tuple[str, float]]:
+        """ sort tags by value, return list of tuples """
+        return sorted(tags.items(), key=lambda x: x[1], reverse=True)
+
+    @classmethod
+    def get_image_dups(cls) -> List[str]:
+        # first sort values so that those without a comma come first
+        ordered = sorted(cls.image_dups.items(), key=lambda x: ',' in x[0])
+        return [str(x) for s in ordered if len(s[1]) > 1 for x in s[1]]
+
+    @classmethod
+    def finalize(cls, count: int) -> ItRetTP:
+        """ finalize the query, return the results """
+
+        count += len(cls.in_db)
+        if count == 0:
+            return None, None, None, 'no results for query'
+
+        ratings, tags, discarded_tags = {}, {}, {}
+
+        for n in cls.for_tags_file.keys():
+            for k in cls.add_tags:
+                cls.for_tags_file[n][k] = 1.0 * count
+
+        for k in cls.add_tags:
+            tags[k] = 1.0
+
+        for k, lst in cls.tags.items():
+            # len(!) fraction of the all interrogations was above the threshold
+            fraction_of_queries = len(lst) / count
+
+            if fraction_of_queries >= cls.tag_frac_threshold:
+                # store the average of those interrogations sum(!) / count
+                tags[k] = sum(lst) / count
+                # trigger an event to place the tag in the active tags list
+                # replace if k interferes with html code
+            else:
+                discarded_tags[k] = sum(lst) / count
+                for n in cls.for_tags_file.keys():
+                    if k in cls.for_tags_file[n]:
+                        if k not in cls.add_tags and k not in cls.keep_tags:
+                            del cls.for_tags_file[n][k]
+
+        for k, lst in cls.discarded_tags.items():
+            fraction_of_queries = len(lst) / count
+            discarded_tags[k] = sum(lst) / count
+
+        for ent, val in cls.ratings.items():
+            ratings[ent] = val / count
+
+        weighted_tags_files = getattr(shared.opts,
+                                      'tagger_weighted_tags_files', False)
+        for file, remaining_tags in cls.for_tags_file.items():
+            sorted_tags = cls.sort_tags(remaining_tags)
+            if weighted_tags_files:
+                sorted_tags = [f'({k}:{v})' for k, v in sorted_tags]
+            else:
+                sorted_tags = [k for k, v in sorted_tags]
+            file.write_text(', '.join(sorted_tags), encoding='utf-8')
+
+        warn = ""
+        if len(QData.err) > 0:
+            warn = "Warnings (fix and try again - it should be cheap):<ul>" + \
+                   ''.join([f'<li>{x}</li>' for x in QData.err]) + "</ul>"
+
+        if count > 1 and len(cls.get_image_dups()) > 0:
+            warn += "There were duplicates, see gallery tab"
+        return ratings, tags, discarded_tags, warn

extensions-builtin/sdw-wd14-tagger/tagger/utils.py

@@ -0,0 +1,131 @@
+"""Utility functions for the tagger module"""
+import os
+
+from typing import List, Dict
+from pathlib import Path
+
+from modules import shared, scripts  # pylint: disable=import-error
+from modules.shared import models_path  # pylint: disable=import-error
+
+default_ddp_path = Path(models_path, 'deepdanbooru')
+default_onnx_path = Path(models_path, 'TaggerOnnx')
+from tagger.preset import Preset  # pylint: disable=import-error
+from tagger.interrogator import Interrogator, DeepDanbooruInterrogator, \
+                                MLDanbooruInterrogator  # pylint: disable=E0401 # noqa: E501
+from tagger.interrogator import WaifuDiffusionInterrogator  # pylint: disable=E0401 # noqa: E501
+
+preset = Preset(Path(scripts.basedir(), 'presets'))
+
+interrogators: Dict[str, Interrogator] = {
+    'wd14-vit.v1': WaifuDiffusionInterrogator(
+        'WD14 ViT v1',
+        repo_id='SmilingWolf/wd-v1-4-vit-tagger'
+    ),
+    'wd14-vit.v2': WaifuDiffusionInterrogator(
+        'WD14 ViT v2',
+        repo_id='SmilingWolf/wd-v1-4-vit-tagger-v2',
+    ),
+    'wd14-convnext.v1': WaifuDiffusionInterrogator(
+        'WD14 ConvNeXT v1',
+        repo_id='SmilingWolf/wd-v1-4-convnext-tagger'
+    ),
+    'wd14-convnext.v2': WaifuDiffusionInterrogator(
+        'WD14 ConvNeXT v2',
+        repo_id='SmilingWolf/wd-v1-4-convnext-tagger-v2',
+    ),
+    'wd14-convnextv2.v1': WaifuDiffusionInterrogator(
+        'WD14 ConvNeXTV2 v1',
+        # the name is misleading, but it's v1
+        repo_id='SmilingWolf/wd-v1-4-convnextv2-tagger-v2',
+    ),
+    'wd14-swinv2-v1': WaifuDiffusionInterrogator(
+        'WD14 SwinV2 v1',
+        # again misleading name
+        repo_id='SmilingWolf/wd-v1-4-swinv2-tagger-v2',
+    ),
+    'wd-v1-4-moat-tagger.v2': WaifuDiffusionInterrogator(
+        'WD14 moat tagger v2',
+        repo_id='SmilingWolf/wd-v1-4-moat-tagger-v2'
+    ),
+    'mld-caformer.dec-5-97527': MLDanbooruInterrogator(
+        'ML-Danbooru Caformer dec-5-97527',
+        repo_id='deepghs/ml-danbooru-onnx',
+        model_path='ml_caformer_m36_dec-5-97527.onnx'
+    ),
+    'mld-tresnetd.6-30000': MLDanbooruInterrogator(
+        'ML-Danbooru TResNet-D 6-30000',
+        repo_id='deepghs/ml-danbooru-onnx',
+        model_path='TResnet-D-FLq_ema_6-30000.onnx'
+    ),
+}
+
+
+def refresh_interrogators() -> List[str]:
+    """Refreshes the interrogators list"""
+    # load deepdanbooru project
+    ddp_path = shared.cmd_opts.deepdanbooru_projects_path
+    if ddp_path is None:
+        ddp_path = default_ddp_path
+    onnx_path = shared.cmd_opts.onnxtagger_path
+    if onnx_path is None:
+        onnx_path = default_onnx_path
+    os.makedirs(ddp_path, exist_ok=True)
+    os.makedirs(onnx_path, exist_ok=True)
+
+    for path in os.scandir(ddp_path):
+        print(f"Scanning {path} as deepdanbooru project")
+        if not path.is_dir():
+            print(f"Warning: {path} is not a directory, skipped")
+            continue
+
+        if not Path(path, 'project.json').is_file():
+            print(f"Warning: {path} has no project.json, skipped")
+            continue
+
+        interrogators[path.name] = DeepDanbooruInterrogator(path.name, path)
+    # scan for onnx models as well
+    for path in os.scandir(onnx_path):
+        print(f"Scanning {path} as onnx model")
+        if not path.is_dir():
+            print(f"Warning: {path} is not a directory, skipped")
+            continue
+
+        onnx_files = [x for x in os.scandir(path) if x.name.endswith('.onnx')]
+        if len(onnx_files) != 1:
+            print(f"Warning: {path} requires exactly one .onnx model, skipped")
+            continue
+        local_path = Path(path, onnx_files[0].name)
+
+        csv = [x for x in os.scandir(path) if x.name.endswith('.csv')]
+        if len(csv) == 0:
+            print(f"Warning: {path} has no selected tags .csv file, skipped")
+            continue
+
+        def tag_select_csvs_up_front(k):
+            sum(-1 if t in k.name.lower() else 1 for t in ["tag", "select"])
+
+        csv.sort(key=tag_select_csvs_up_front)
+        tags_path = Path(path, csv[0])
+
+        if path.name not in interrogators:
+            if path.name == 'wd-v1-4-convnextv2-tagger-v2':
+                interrogators[path.name] = WaifuDiffusionInterrogator(
+                    path.name,
+                    repo_id='SmilingWolf/SW-CV-ModelZoo',
+                    is_hf=False
+                )
+            elif path.name == 'Z3D-E621-Convnext':
+                interrogators[path.name] = WaifuDiffusionInterrogator(
+                    'Z3D-E621-Convnext', is_hf=False)
+            else:
+                raise NotImplementedError(f"Add {path.name} resolution similar"
+                                          "to above here")
+
+        interrogators[path.name].local_model = str(local_path)
+        interrogators[path.name].local_tags = str(tags_path)
+
+    return sorted(interrogators.keys())
+
+
+def split_str(string: str, separator=',') -> List[str]:
+    return [x.strip() for x in string.split(separator) if x]