Upload folder using huggingface_hub

.gitattributes

@@ -0,0 +1,6 @@
+sd-civitai-browser-plus/aria2/lin/aria2 filter=lfs diff=lfs merge=lfs -text
+sd-civitai-browser-plus/aria2/win/aria2.exe filter=lfs diff=lfs merge=lfs -text
+sd-webui-controlnet/annotator/oneformer/oneformer/data/bpe_simple_vocab_16e6.txt.gz filter=lfs diff=lfs merge=lfs -text
+sd-webui-inpaint-anything/images/inpaint_anything_ui_image_1.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-webui-aesthetic-gradients/ss.png filter=lfs diff=lfs merge=lfs -text
+stable-diffusion-webui-rembg/preview.png filter=lfs diff=lfs merge=lfs -text

adetailer/.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -0,0 +1,53 @@
+name: Bug report
+description: Create a report
+title: "[Bug]: "
+labels:
+  - bug
+
+body:
+  - type: textarea
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is.
+      placeholder: |
+        Any language accepted
+        아무 언어 사용가능
+        すべての言語に対応
+        接受所有语言
+        Se aceptan todos los idiomas
+        Alle Sprachen werden akzeptiert
+        Toutes les langues sont acceptées
+        Принимаются все языки
+
+  - type: textarea
+    attributes:
+      label: Screenshots
+      description: Screenshots related to the issue.
+
+  - type: textarea
+    attributes:
+      label: Console logs, from start to end.
+      description: |
+        The full console log of your terminal.
+      placeholder: |
+        Python ...
+        Version: ...
+        Commit hash: ...
+        Installing requirements
+        ...
+
+        Launching Web UI with arguments: ...
+        [-] ADetailer initialized. version: ...
+        ...
+        ...
+
+        Traceback (most recent call last):
+        ...
+        ...
+      render: Shell
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: List of installed extensions

adetailer/.github/ISSUE_TEMPLATE/feature_request.yaml

@@ -0,0 +1,24 @@
+name: Feature request
+description: Suggest an idea for this project
+title: "[Feature Request]: "
+
+body:
+  - type: textarea
+    attributes:
+      label: Is your feature request related to a problem? Please describe.
+      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+  - type: textarea
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+
+  - type: textarea
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context or screenshots about the feature request here.

adetailer/.github/ISSUE_TEMPLATE/question.yaml

@@ -0,0 +1,10 @@
+name: Question
+description: Write a question
+labels:
+  - question
+
+body:
+  - type: textarea
+    attributes:
+      label: Question
+      description: Please do not write bug reports or feature requests here.

adetailer/.github/workflows/stale.yml

@@ -0,0 +1,13 @@
+name: 'Close stale issues and PRs'
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v8
+        with:
+          days-before-stale: 23
+          days-before-close: 3

adetailer/.gitignore

@@ -0,0 +1,196 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python,visualstudiocode
+# Edit at https://www.toptal.com/developers/gitignore?templates=python,visualstudiocode
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+# End of https://www.toptal.com/developers/gitignore/api/python,visualstudiocode
+*.ipynb

adetailer/.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: check-ast
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.14
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 23.12.1
+    hooks:
+      - id: black

adetailer/.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+    "recommendations": [
+        "ms-python.black-formatter",
+        "kevinrose.vsc-python-indent",
+        "charliermarsh.ruff",
+        "shardulm94.trailing-spaces"
+    ]
+}

adetailer/.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "explorer.fileNesting.enabled": true,
+    "explorer.fileNesting.patterns": {
+        "pyproject.toml": ".env, .gitignore, .pre-commit-config.yaml, Taskfile.yml",
+        "README.md": "LICENSE.md, CHANGELOG.md",
+        "install.py": "preload.py"
+    }
+}

adetailer/CHANGELOG.md

@@ -0,0 +1,377 @@
+# Changelog
+
+## 2024-01-23
+
+- v24.1.2
+- controlnet 모델에 `Passthrough` 옵션 추가. 입력으로 들어온 컨트롤넷 옵션을 그대로 사용
+- fastapi 엔드포인트 추가
+
+## 2024-01-10
+
+- v24.1.1
+- SDNext 호환 업데이트 (issue #466)
+  - 설정 값 state에 초기값 추가
+  - 위젯 값을 변경할 때마다 state도 변경되게 함 (기존에는 생성 버튼을 누를 때 적용되었음)
+- `inpaint_depth_hand` 컨트롤넷 모델이 depth 모델로 인식되게 함 (issue #463)
+
+## 2024-01-04
+
+- v24.1.0
+- `depth_hand_refiner` ControlNet 추가 (PR #460)
+
+## 2023-12-30
+
+- v23.12.0
+- 파일을 인자로 추가하는 몇몇 스크립트에 대해 deepcopy의 에러를 피하기 위해 script_args 복사 방법을 변경함
+- skip img2img 기능을 사용할 때 너비, 높이를 128로 고정하여 스킵 과정이 조금 더 나아짐
+- img2img inpainting 모드에서 adetailer 자동 비활성화
+- 처음 생성된 params.txt 파일을 항상 유지하도록 변경함
+
+## 2023-11-19
+
+- v23.11.1
+- 기본 스크립트 목록에 negpip 추가
+  - 기존에 설치한 사람에게 소급적용되지는 않음
+- skip img2img 옵션이 2스텝 이상일 때, 제대로 적용되지 않는 문제 수정
+- SD.Next에서 이미지가 np.ndarray로 입력되는 경우 수정
+- 컨트롤넷 경로를 sys.path에 추가하여 --data-dir등을 지정한 경우에도 임포트 에러가 일어나지 않게 함.
+
+## 2023-10-30
+
+- v23.11.0
+- 이미지의 인덱스 계산방법 변경
+  - webui 1.1.0 미만에서 adetailer 실행 불가능하게 함
+- 컨트롤넷 preprocessor 선택지 늘림
+- 추가 yolo 모델 디렉터리를 설정할 수 있는 옵션 추가
+- infotext에 `/`가 있는 항목이 exif에서 복원되지 않는 문제 수정
+  - 이전 버전에 생성된 이미지는 여전히 복원안됨
+- 같은 탭에서 항상 같은 시드를 적용하게 하는 옵션 추가
+- 컨트롤넷 1.1.411 (f2aafcf2beb99a03cbdf7db73852228ccd6bd1d6) 버전을 사용중일 경우,
+  webui 버전 1.6.0 미만에서 사용할 수 없다는 메세지 출력
+
+## 2023-10-15
+
+- v23.10.1
+- xyz grid에 prompt S/R 추가
+- img2img에서 steps가 1일때 에러가 발생하는 샘플러의 처리를 위해 샘플러 이름도 변경하게 수정
+
+## 2023-10-07
+
+- v23.10.0
+- 허깅페이스 모델을 다운로드 실패했을 때, 계속 다운로드를 시도하지 않음
+- img2img에서 img2img단계를 건너뛰는 기능 추가
+- live preview에서 감지 단계를 보여줌 (PR #352)
+
+## 2023-09-20
+
+- v23.9.3
+- ultralytics 버전 8.0.181로 업데이트 (https://github.com/ultralytics/ultralytics/pull/4891)
+- mediapipe와 ultralytics의 lazy import
+
+## 2023-09-10
+
+- v23.9.2
+- (실험적) VAE 선택 기능
+
+## 2023-09-01
+
+- v23.9.1
+- webui 1.6.0에 추가된 인자를 사용해서 생긴 하위 호환 문제 수정
+
+## 2023-08-31
+
+- v23.9.0
+- (실험적) 체크포인트 선택기능
+  - 버그가 있어 리프레시 버튼은 구현에서 빠짐
+- 1.6.0 업데이트에 따라 img2img에서 사용불가능한 샘플러를 선택했을 때 더이상 Euler로 변경하지 않음
+- 유효하지 않은 인자가 전달되었을 때, 에러를 일으키지 않고 대신 adetailer를 비활성화함
+
+
+## 2023-08-25
+
+- v23.8.1
+- xyz grid에서 model을 `None`으로 설정한 이후에 adetailer가 비활성화 되는 문제 수정
+- skip을 눌렀을 때 진행을 멈춤
+- `--medvram-sdxl`을 설정했을 때에도 cpu를 사용하게 함
+
+## 2023-08-14
+
+- v23.8.0
+- `[PROMPT]` 키워드 추가. `ad_prompt` 또는 `ad_negative_prompt`에 사용하면 입력 프롬프트로 대체됨 (PR #243)
+- Only top k largest 옵션 추가 (PR #264)
+- ultralytics 버전 업데이트
+
+
+## 2023-07-31
+
+- v23.7.11
+- separate clip skip 옵션 추가
+- install requirements 정리 (ultralytics 새 버전, mediapipe~=3.20)
+
+## 2023-07-28
+
+- v23.7.10
+- ultralytics, mediapipe import문 정리
+- traceback에서 컬러를 없앰 (api 때문), 라이브러리 버전도 보여주게 설정.
+- huggingface_hub, pydantic을 install.py에서 없앰
+- 안쓰는 컨트롤넷 관련 코드 삭제
+
+
+## 2023-07-23
+
+- v23.7.9
+- `ultralytics.utils` ModuleNotFoundError 해결 (https://github.com/ultralytics/ultralytics/issues/3856)
+- `pydantic` 2.0 이상 버전 설치안되도록 함
+- `controlnet_dir` cmd args 문제 수정 (PR #107)
+
+## 2023-07-20
+
+- v23.7.8
+- `paste_field_names` 추가했던 것을 되돌림
+
+## 2023-07-19
+
+- v23.7.7
+- 인페인팅 단계에서 별도의 샘플러를 선택할 수 있게 옵션을 추가함 (xyz그리드에도 추가)
+- webui 1.0.0-pre 이하 버전에서 batch index 문제 수정
+- 스크립트에 `paste_field_names`을 추가함. 사용되는지는 모르겠음
+
+## 2023-07-16
+
+- v23.7.6
+- `ultralytics 8.0.135`에 추가된 cpuinfo 기능을 위해 `py-cpuinfo`를 미리 설치하게 함. (미리 설치 안하면 cpu나 mps사용할 때 재시작해야함)
+- init_image가 RGB 모드가 아닐 때 RGB로 변경.
+
+## 2023-07-07
+
+- v23.7.4
+- batch count > 1일때 프롬프트의 인덱스 문제 수정
+
+- v23.7.5
+- i2i의 `cached_uc`와 `cached_c`가 p의 `cached_uc`와 `cached_c`가 다른 인스턴스가 되도록 수정
+
+## 2023-07-05
+
+- v23.7.3
+- 버그 수정
+  - `object()`가 json 직렬화 안되는 문제
+  - `process`를 호출함에 따라 배치 카운트가 2이상일 때, all_prompts가 고정되는 문제
+  - `ad-before`와 `ad-preview` 이미지 파일명이 실제 파일명과 다른 문제
+  - pydantic 2.0 호환성 문제
+
+## 2023-07-04
+
+- v23.7.2
+- `mediapipe_face_mesh_eyes_only` 모델 추가: `mediapipe_face_mesh`로 감지한 뒤 눈만 사용함.
+- 매 배치 시작 전에 `scripts.postprocess`를, 후에 `scripts.process`를 호출함.
+  - 컨트롤넷을 사용하면 소요 시간이 조금 늘어나지만 몇몇 문제 해결에 도움이 됨.
+- `lora_block_weight`를 스크립트 화이트리스트에 추가함.
+  - 한번이라도 ADetailer를 사용한 사람은 수동으로 추가해야함.
+
+## 2023-07-03
+
+- v23.7.1
+- `process_images`를 진행한 뒤 `StableDiffusionProcessing` 오브젝트의 close를 호출함
+- api 호출로 사용했는지 확인하는 속성 추가
+- `NansException`이 발생했을 때 중지하지 않고 남은 과정 계속 진행함
+
+## 2023-07-02
+
+- v23.7.0
+- `NansException`이 발생하면 로그에 표시하고 원본 이미지를 반환하게 설정
+- `rich`를 사용한 에러 트레이싱
+  - install.py에 `rich` 추가
+- 생성 중에 컴포넌트의 값을 변경하면 args의 값도 함께 변경되는 문제 수정 (issue #180)
+- 터미널 로그로 ad_prompt와 ad_negative_prompt에 적용된 실제 프롬프트 확인할 수 있음 (입력과 다를 경우에만)
+
+## 2023-06-28
+
+- v23.6.4
+- 최대 모델 수 5 -> 10개
+- ad_prompt와 ad_negative_prompt에 빈칸으로 놔두면 입력 프롬프트가 사용된다는 문구 추가
+- huggingface 모델 다운로드 실패시 로깅
+- 1st 모델이 `None`일 경우 나머지 입력을 무시하던 문제 수정
+- `--use-cpu` 에 `adetailer` 입력 시 cpu로 yolo모델을 사용함
+
+## 2023-06-20
+
+- v23.6.3
+- 컨트롤넷 inpaint 모델에 대해, 3가지 모듈을 사용할 수 있도록 함
+- Noise Multiplier 옵션 추가 (PR #149)
+- pydantic 최소 버전 1.10.8로 설정 (Issue #146)
+
+## 2023-06-05
+
+- v23.6.2
+- xyz_grid에서 ADetailer를 사용할 수 있게함.
+  - 8가지 옵션만 1st 탭에 적용되도록 함.
+
+## 2023-06-01
+
+- v23.6.1
+- `inpaint, scribble, lineart, openpose, tile` 5가지 컨트롤넷 모델 지원 (PR #107)
+- controlnet guidance start, end 인자 추가 (PR #107)
+- `modules.extensions`를 사용하여 컨트롤넷 확장을 불러오고 경로를 알아내로록 변경
+- ui에서 컨트롤넷을 별도 함수로 분리
+
+## 2023-05-30
+
+- v23.6.0
+- 스크립트의 이름을 `After Detailer`에서 `ADetailer`로 변경
+  - API 사용자는 변경 필요함
+- 몇몇 설정 변경
+  - `ad_conf` → `ad_confidence`. 0~100 사이의 int → 0.0~1.0 사이의 float
+  - `ad_inpaint_full_res` → `ad_inpaint_only_masked`
+  - `ad_inpaint_full_res_padding` → `ad_inpaint_only_masked_padding`
+- mediapipe face mesh 모델 추가
+  - mediapipe 최소 버전 `0.10.0`
+
+- rich traceback 제거함
+- huggingface 다운로드 실패할 때 에러가 나지 않게 하고 해당 모델을 제거함
+
+## 2023-05-26
+
+- v23.5.19
+- 1번째 탭에도 `None` 옵션을 추가함
+- api로 ad controlnet model에 inpaint가 아닌 다른 컨트롤넷 모델을 사용하지 못하도록 막음
+- adetailer 진행중에 total tqdm 진행바 업데이트를 멈춤
+- state.inturrupted 상태에서 adetailer 과정을 중지함
+- 컨트롤넷 process를 각 batch가 끝난 순간에만 호출하도록 변경
+
+### 2023-05-25
+
+- v23.5.18
+- 컨트롤넷 관련 수정
+  - unit의 `input_mode`를 `SIMPLE`로 모두 변경
+  - 컨트롤넷 유넷 훅과 하이잭 함수들을 adetailer를 실행할 때에만 되돌리는 기능 추가
+  - adetailer 처리가 끝난 뒤 컨트롤넷 스크립트의 process를 다시 진행함. (batch count 2 이상일때의 문제 해결)
+- 기본 활성 스크립트 목록에서 컨트롤넷을 뺌
+
+### 2023-05-22
+
+- v23.5.17
+- 컨트롤넷 확장이 있으면 컨트롤넷 스크립트를 활성화함. (컨트롤넷 관련 문제 해결)
+- 모든 컴포넌트에 elem_id 설정
+- ui에 버전을 표시함
+
+
+### 2023-05-19
+
+- v23.5.16
+- 추가한 옵션
+  - Mask min/max ratio
+  - Mask merge mode
+  - Restore faces after ADetailer
+- 옵션들을 Accordion으로 묶음
+
+### 2023-05-18
+
+- v23.5.15
+- 필요한 것만 임포트하도록 변경 (vae 로딩 오류 없어짐. 로딩 속도 빨라짐)
+
+### 2023-05-17
+
+- v23.5.14
+- `[SKIP]`으로 ad prompt 일부를 건너뛰는 기능 추가
+- bbox 정렬 옵션 추가
+- sd_webui 타입힌트를 만들어냄
+- enable checker와 관련된 api 오류 수정?
+
+### 2023-05-15
+
+- v23.5.13
+- `[SEP]`으로 ad prompt를 분리하여 적용하는 기능 추가
+- enable checker를 다시 pydantic으로 변경함
+- ui 관련 함수를 adetailer.ui 폴더로 분리함
+- controlnet을 사용할 때 모든 controlnet unit 비활성화
+- adetailer 폴더가 없으면 만들게 함
+
+### 2023-05-13
+
+- v23.5.12
+- `ad_enable`을 제외한 입력이 dict타입으로 들어오도록 변경
+  - web api로 사용할 때에 특히 사용하기 쉬움
+  - web api breaking change
+- `mask_preprocess` 인자를 넣지 않았던 오류 수정 (PR #47)
+- huggingface에서 모델을 다운로드하지 않는 옵션 추가 `--ad-no-huggingface`
+
+### 2023-05-12
+
+- v23.5.11
+- `ultralytics` 알람 제거
+- 필요없는 exif 인자 더 제거함
+- `use separate steps` 옵션 추가
+- ui 배치를 조정함
+
+### 2023-05-09
+
+- v23.5.10
+- 선택한 스크립트만 ADetailer에 적용하는 옵션 추가, 기본값 `True`. 설정 탭에서 지정가능.
+  - 기본값: `dynamic_prompting,dynamic_thresholding,wildcards,wildcard_recursive`
+- `person_yolov8s-seg.pt` 모델 추가
+- `ultralytics`의 최소 버전을 `8.0.97`로 설정 (C:\\ 문제 해결된 버전)
+
+### 2023-05-08
+
+- v23.5.9
+- 2가지 이상의 모델을 사용할 수 있음. 기본값: 2, 최대: 5
+- segment 모델을 사용할 수 있게 함. `person_yolov8n-seg.pt` 추가
+
+### 2023-05-07
+
+- v23.5.8
+- 프롬프트와 네거티브 프롬프트에 방향키 지원 (PR #24)
+- `mask_preprocess`를 추가함. 이전 버전과 시드값이 달라질 가능성 있음!
+- 이미지 처리가 일어났을 때에만 before이미지를 저장함
+- 설정창의 레이블을 ADetailer 대신 더 적절하게 수정함
+
+### 2023-05-06
+
+- v23.5.7
+- `ad_use_cfg_scale` 옵션 추가. cfg 스케일을 따로 사용할지 말지 결정함.
+- `ad_enable` 기본값을 `True`에서 `False`로 변경
+- `ad_model`의 기본값을 `None`에서 첫번째 모델로 변경
+- 최소 2개의 입력(ad_enable, ad_model)만 들어오면 작동하게 변경.
+
+- v23.5.7.post0
+- `init_controlnet_ext`을 controlnet_exists == True일때에만 실행
+- webui를 C드라이브 바로 밑에 설치한 사람들에게 `ultralytics` 경고 표시
+
+### 2023-05-05 (어린이날)
+
+- v23.5.5
+- `Save images before ADetailer` 옵션 추가
+- 입력으로 들어온 인자와 ALL_ARGS의 길이가 다르면 에러메세지
+- README.md에 설치방법 추가
+
+- v23.5.6
+- get_args에서 IndexError가 발생하면 자세한 에러메세지를 볼 수 있음
+- AdetailerArgs에 extra_params 내장
+- scripts_args를 딥카피함
+- postprocess_image를 약간 분리함
+
+- v23.5.6.post0
+- `init_controlnet_ext`에서 에러메세지를 자세히 볼 수 있음
+
+### 2023-05-04
+
+- v23.5.4
+- use pydantic for arguments validation
+- revert: ad_model to `None` as default
+- revert: `__future__` imports
+- lazily import yolo and mediapipe
+
+### 2023-05-03
+
+- v23.5.3.post0
+- remove `__future__` imports
+- change to copy scripts and scripts args
+
+- v23.5.3.post1
+- change default ad_model from `None`
+
+### 2023-05-02
+
+- v23.5.3
+- Remove `None` from model list and add `Enable ADetailer` checkbox.
+- install.py `skip_install` fix.

adetailer/LICENSE.md

@@ -0,0 +1,662 @@
+
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.

adetailer/README.md

@@ -0,0 +1,97 @@
+# ADetailer
+
+ADetailer is a extension for stable diffusion webui, similar to Detection Detailer, except it uses ultralytics instead of the mmdet.
+
+## Install
+
+(from Mikubill/sd-webui-controlnet)
+
+1. Open "Extensions" tab.
+2. Open "Install from URL" tab in the tab.
+3. Enter `https://github.com/Bing-su/adetailer.git` to "URL for extension's git repository".
+4. Press "Install" button.
+5. Wait 5 seconds, and you will see the message "Installed into stable-diffusion-webui\extensions\adetailer. Use Installed tab to restart".
+6. Go to "Installed" tab, click "Check for updates", and then click "Apply and restart UI". (The next time you can also use this method to update extensions.)
+7. Completely restart A1111 webui including your terminal. (If you do not know what is a "terminal", you can reboot your computer: turn your computer off and turn it on again.)
+
+You can now install it directly from the Extensions tab.
+
+![image](https://i.imgur.com/g6GdRBT.png)
+
+You **DON'T** need to download any model from huggingface.
+
+## Options
+
+| Model, Prompts                    |                                                                                   |                                                   |
+| --------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------- |
+| ADetailer model                   | Determine what to detect.                                                         | `None` = disable                                  |
+| ADetailer prompt, negative prompt | Prompts and negative prompts to apply                                             | If left blank, it will use the same as the input. |
+| Skip img2img                      | Skip img2img. In practice, this works by changing the step count of img2img to 1. | img2img only                                      |
+
+| Detection                            |                                                                                              |              |
+| ------------------------------------ | -------------------------------------------------------------------------------------------- | ------------ |
+| Detection model confidence threshold | Only objects with a detection model confidence above this threshold are used for inpainting. |              |
+| Mask min/max ratio                   | Only use masks whose area is between those ratios for the area of the entire image.          |              |
+| Mask only the top k largest          | Only use the k objects with the largest area of the bbox.                                    | 0 to disable |
+
+If you want to exclude objects in the background, try setting the min ratio to around `0.01`.
+
+| Mask Preprocessing              |                                                                                                                                     |                                                                                         |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| Mask x, y offset                | Moves the mask horizontally and vertically by                                                                                       |                                                                                         |
+| Mask erosion (-) / dilation (+) | Enlarge or reduce the detected mask.                                                                                                | [opencv example](https://docs.opencv.org/4.7.0/db/df6/tutorial_erosion_dilatation.html) |
+| Mask merge mode                 | `None`: Inpaint each mask<br/>`Merge`: Merge all masks and inpaint<br/>`Merge and Invert`: Merge all masks and Invert, then inpaint |                                                                                         |
+
+Applied in this order: x, y offset → erosion/dilation → merge/invert.
+
+#### Inpainting
+
+Each option corresponds to a corresponding option on the inpaint tab. Therefore, please refer to the inpaint tab for usage details on how to use each option.
+
+## ControlNet Inpainting
+
+You can use the ControlNet extension if you have ControlNet installed and ControlNet models.
+
+Support `inpaint, scribble, lineart, openpose, tile` controlnet models. Once you choose a model, the preprocessor is set automatically. It works separately from the model set by the Controlnet extension.
+
+## Advanced Options
+
+API request example: [wiki/API](https://github.com/Bing-su/adetailer/wiki/API)
+
+`ui-config.json` entries: [wiki/ui-config.json](https://github.com/Bing-su/adetailer/wiki/ui-config.json)
+
+`[SEP], [SKIP]` tokens: [wiki/Advanced](https://github.com/Bing-su/adetailer/wiki/Advanced)
+
+## Media
+
+- 🎥 [どこよりも詳しいAfter Detailer (adetailer)の使い方① 【Stable Diffusion】](https://youtu.be/sF3POwPUWCE)
+- 🎥 [どこよりも詳しいAfter Detailer (adetailer)の使い方② 【Stable Diffusion】](https://youtu.be/urNISRdbIEg)
+
+## Model
+
+| Model                 | Target                | mAP 50                        | mAP 50-95                     |
+| --------------------- | --------------------- | ----------------------------- | ----------------------------- |
+| face_yolov8n.pt       | 2D / realistic face   | 0.660                         | 0.366                         |
+| face_yolov8s.pt       | 2D / realistic face   | 0.713                         | 0.404                         |
+| hand_yolov8n.pt       | 2D / realistic hand   | 0.767                         | 0.505                         |
+| person_yolov8n-seg.pt | 2D / realistic person | 0.782 (bbox)<br/>0.761 (mask) | 0.555 (bbox)<br/>0.460 (mask) |
+| person_yolov8s-seg.pt | 2D / realistic person | 0.824 (bbox)<br/>0.809 (mask) | 0.605 (bbox)<br/>0.508 (mask) |
+| mediapipe_face_full   | realistic face        | -                             | -                             |
+| mediapipe_face_short  | realistic face        | -                             | -                             |
+| mediapipe_face_mesh   | realistic face        | -                             | -                             |
+
+The yolo models can be found on huggingface [Bingsu/adetailer](https://huggingface.co/Bingsu/adetailer).
+
+### Additional Model
+
+Put your [ultralytics](https://github.com/ultralytics/ultralytics) yolo model in `webui/models/adetailer`. The model name should end with `.pt` or `.pth`.
+
+It must be a bbox detection or segment model and use all label.
+
+## How it works
+
+ADetailer works in three simple steps.
+
+1. Create an image.
+2. Detect object with a detection model and create a mask image.
+3. Inpaint using the image from 1 and the mask from 2.

adetailer/Taskfile.yml

@@ -0,0 +1,27 @@
+# https://taskfile.dev
+
+version: "3"
+
+dotenv:
+  - .env
+
+tasks:
+  default:
+    cmds:
+      - echo "$PYTHON"
+      - echo "$WEBUI"
+    silent: true
+
+  launch:
+    dir: "{{.WEBUI}}"
+    cmds:
+      - "{{.PYTHON}} launch.py --xformers --api"
+    silent: true
+
+  lint:
+    cmds:
+      - pre-commit run -a
+
+  update:
+    cmds:
+      - "{{.PYTHON}} -m pip install -U ultralytics mediapipe ruff pre-commit black"

adetailer/adetailer/__init__.py

@@ -0,0 +1,18 @@
+from .__version__ import __version__
+from .args import ALL_ARGS, ADetailerArgs
+from .common import PredictOutput, get_models
+from .mediapipe import mediapipe_predict
+from .ultralytics import ultralytics_predict
+
+AFTER_DETAILER = "ADetailer"
+
+__all__ = [
+    "__version__",
+    "ADetailerArgs",
+    "AFTER_DETAILER",
+    "ALL_ARGS",
+    "PredictOutput",
+    "get_models",
+    "mediapipe_predict",
+    "ultralytics_predict",
+]

adetailer/adetailer/__version__.py

@@ -0,0 +1 @@
+__version__ = "24.1.2"

adetailer/adetailer/args.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+from collections import UserList
+from dataclasses import dataclass
+from functools import cached_property, partial
+from typing import Any, Literal, NamedTuple, Optional
+
+import pydantic
+from pydantic import (
+    BaseModel,
+    Extra,
+    NonNegativeFloat,
+    NonNegativeInt,
+    PositiveInt,
+    confloat,
+    conint,
+    constr,
+    validator,
+)
+
+
+@dataclass
+class SkipImg2ImgOrig:
+    steps: int
+    sampler_name: str
+    width: int
+    height: int
+
+
+class Arg(NamedTuple):
+    attr: str
+    name: str
+
+
+class ArgsList(UserList):
+    @cached_property
+    def attrs(self) -> tuple[str]:
+        return tuple(attr for attr, _ in self)
+
+    @cached_property
+    def names(self) -> tuple[str]:
+        return tuple(name for _, name in self)
+
+
+class ADetailerArgs(BaseModel, extra=Extra.forbid):
+    ad_model: str = "None"
+    ad_prompt: str = ""
+    ad_negative_prompt: str = ""
+    ad_confidence: confloat(ge=0.0, le=1.0) = 0.3
+    ad_mask_k_largest: NonNegativeInt = 0
+    ad_mask_min_ratio: confloat(ge=0.0, le=1.0) = 0.0
+    ad_mask_max_ratio: confloat(ge=0.0, le=1.0) = 1.0
+    ad_dilate_erode: int = 4
+    ad_x_offset: int = 0
+    ad_y_offset: int = 0
+    ad_mask_merge_invert: Literal["None", "Merge", "Merge and Invert"] = "None"
+    ad_mask_blur: NonNegativeInt = 4
+    ad_denoising_strength: confloat(ge=0.0, le=1.0) = 0.4
+    ad_inpaint_only_masked: bool = True
+    ad_inpaint_only_masked_padding: NonNegativeInt = 32
+    ad_use_inpaint_width_height: bool = False
+    ad_inpaint_width: PositiveInt = 512
+    ad_inpaint_height: PositiveInt = 512
+    ad_use_steps: bool = False
+    ad_steps: PositiveInt = 28
+    ad_use_cfg_scale: bool = False
+    ad_cfg_scale: NonNegativeFloat = 7.0
+    ad_use_checkpoint: bool = False
+    ad_checkpoint: Optional[str] = None
+    ad_use_vae: bool = False
+    ad_vae: Optional[str] = None
+    ad_use_sampler: bool = False
+    ad_sampler: str = "DPM++ 2M Karras"
+    ad_use_noise_multiplier: bool = False
+    ad_noise_multiplier: confloat(ge=0.5, le=1.5) = 1.0
+    ad_use_clip_skip: bool = False
+    ad_clip_skip: conint(ge=1, le=12) = 1
+    ad_restore_face: bool = False
+    ad_controlnet_model: str = "None"
+    ad_controlnet_module: str = "None"
+    ad_controlnet_weight: confloat(ge=0.0, le=1.0) = 1.0
+    ad_controlnet_guidance_start: confloat(ge=0.0, le=1.0) = 0.0
+    ad_controlnet_guidance_end: confloat(ge=0.0, le=1.0) = 1.0
+    is_api: bool = True
+
+    @validator("is_api", pre=True)
+    def is_api_validator(cls, v: Any):  # noqa: N805
+        "tuple is json serializable but cannot be made with json deserialize."
+        return type(v) is not tuple
+
+    @staticmethod
+    def ppop(
+        p: dict[str, Any],
+        key: str,
+        pops: list[str] | None = None,
+        cond: Any = None,
+    ) -> None:
+        if pops is None:
+            pops = [key]
+        if key not in p:
+            return
+        value = p[key]
+        cond = (not bool(value)) if cond is None else value == cond
+
+        if cond:
+            for k in pops:
+                p.pop(k, None)
+
+    def extra_params(self, suffix: str = "") -> dict[str, Any]:
+        if self.ad_model == "None":
+            return {}
+
+        p = {name: getattr(self, attr) for attr, name in ALL_ARGS}
+        ppop = partial(self.ppop, p)
+
+        ppop("ADetailer prompt")
+        ppop("ADetailer negative prompt")
+        ppop("ADetailer mask only top k largest", cond=0)
+        ppop("ADetailer mask min ratio", cond=0.0)
+        ppop("ADetailer mask max ratio", cond=1.0)
+        ppop("ADetailer x offset", cond=0)
+        ppop("ADetailer y offset", cond=0)
+        ppop("ADetailer mask merge invert", cond="None")
+        ppop("ADetailer inpaint only masked", ["ADetailer inpaint padding"])
+        ppop(
+            "ADetailer use inpaint width height",
+            [
+                "ADetailer use inpaint width height",
+                "ADetailer inpaint width",
+                "ADetailer inpaint height",
+            ],
+        )
+        ppop(
+            "ADetailer use separate steps",
+            ["ADetailer use separate steps", "ADetailer steps"],
+        )
+        ppop(
+            "ADetailer use separate CFG scale",
+            ["ADetailer use separate CFG scale", "ADetailer CFG scale"],
+        )
+        ppop(
+            "ADetailer use separate checkpoint",
+            ["ADetailer use separate checkpoint", "ADetailer checkpoint"],
+        )
+        ppop(
+            "ADetailer use separate VAE",
+            ["ADetailer use separate VAE", "ADetailer VAE"],
+        )
+        ppop(
+            "ADetailer use separate sampler",
+            ["ADetailer use separate sampler", "ADetailer sampler"],
+        )
+        ppop(
+            "ADetailer use separate noise multiplier",
+            ["ADetailer use separate noise multiplier", "ADetailer noise multiplier"],
+        )
+
+        ppop(
+            "ADetailer use separate CLIP skip",
+            ["ADetailer use separate CLIP skip", "ADetailer CLIP skip"],
+        )
+
+        ppop("ADetailer restore face")
+        ppop(
+            "ADetailer ControlNet model",
+            [
+                "ADetailer ControlNet model",
+                "ADetailer ControlNet module",
+                "ADetailer ControlNet weight",
+                "ADetailer ControlNet guidance start",
+                "ADetailer ControlNet guidance end",
+            ],
+            cond="None",
+        )
+        ppop("ADetailer ControlNet module", cond="None")
+        ppop("ADetailer ControlNet weight", cond=1.0)
+        ppop("ADetailer ControlNet guidance start", cond=0.0)
+        ppop("ADetailer ControlNet guidance end", cond=1.0)
+
+        if suffix:
+            p = {k + suffix: v for k, v in p.items()}
+
+        return p
+
+
+_all_args = [
+    ("ad_model", "ADetailer model"),
+    ("ad_prompt", "ADetailer prompt"),
+    ("ad_negative_prompt", "ADetailer negative prompt"),
+    ("ad_confidence", "ADetailer confidence"),
+    ("ad_mask_k_largest", "ADetailer mask only top k largest"),
+    ("ad_mask_min_ratio", "ADetailer mask min ratio"),
+    ("ad_mask_max_ratio", "ADetailer mask max ratio"),
+    ("ad_x_offset", "ADetailer x offset"),
+    ("ad_y_offset", "ADetailer y offset"),
+    ("ad_dilate_erode", "ADetailer dilate erode"),
+    ("ad_mask_merge_invert", "ADetailer mask merge invert"),
+    ("ad_mask_blur", "ADetailer mask blur"),
+    ("ad_denoising_strength", "ADetailer denoising strength"),
+    ("ad_inpaint_only_masked", "ADetailer inpaint only masked"),
+    ("ad_inpaint_only_masked_padding", "ADetailer inpaint padding"),
+    ("ad_use_inpaint_width_height", "ADetailer use inpaint width height"),
+    ("ad_inpaint_width", "ADetailer inpaint width"),
+    ("ad_inpaint_height", "ADetailer inpaint height"),
+    ("ad_use_steps", "ADetailer use separate steps"),
+    ("ad_steps", "ADetailer steps"),
+    ("ad_use_cfg_scale", "ADetailer use separate CFG scale"),
+    ("ad_cfg_scale", "ADetailer CFG scale"),
+    ("ad_use_checkpoint", "ADetailer use separate checkpoint"),
+    ("ad_checkpoint", "ADetailer checkpoint"),
+    ("ad_use_vae", "ADetailer use separate VAE"),
+    ("ad_vae", "ADetailer VAE"),
+    ("ad_use_sampler", "ADetailer use separate sampler"),
+    ("ad_sampler", "ADetailer sampler"),
+    ("ad_use_noise_multiplier", "ADetailer use separate noise multiplier"),
+    ("ad_noise_multiplier", "ADetailer noise multiplier"),
+    ("ad_use_clip_skip", "ADetailer use separate CLIP skip"),
+    ("ad_clip_skip", "ADetailer CLIP skip"),
+    ("ad_restore_face", "ADetailer restore face"),
+    ("ad_controlnet_model", "ADetailer ControlNet model"),
+    ("ad_controlnet_module", "ADetailer ControlNet module"),
+    ("ad_controlnet_weight", "ADetailer ControlNet weight"),
+    ("ad_controlnet_guidance_start", "ADetailer ControlNet guidance start"),
+    ("ad_controlnet_guidance_end", "ADetailer ControlNet guidance end"),
+]
+
+_args = [Arg(*args) for args in _all_args]
+ALL_ARGS = ArgsList(_args)
+
+BBOX_SORTBY = [
+    "None",
+    "Position (left to right)",
+    "Position (center to edge)",
+    "Area (large to small)",
+]
+MASK_MERGE_INVERT = ["None", "Merge", "Merge and Invert"]

adetailer/adetailer/common.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Union
+
+from huggingface_hub import hf_hub_download
+from PIL import Image, ImageDraw
+from rich import print
+
+repo_id = "Bingsu/adetailer"
+_download_failed = False
+
+
+@dataclass
+class PredictOutput:
+    bboxes: list[list[int | float]] = field(default_factory=list)
+    masks: list[Image.Image] = field(default_factory=list)
+    preview: Optional[Image.Image] = None
+
+
+def hf_download(file: str):
+    global _download_failed
+
+    if _download_failed:
+        return "INVALID"
+
+    try:
+        path = hf_hub_download(repo_id, file)
+    except Exception:
+        msg = f"[-] ADetailer: Failed to load model {file!r} from huggingface"
+        print(msg)
+        path = "INVALID"
+        _download_failed = True
+    return path
+
+
+def scan_model_dir(path_: str | Path) -> list[Path]:
+    if not path_ or not (path := Path(path_)).is_dir():
+        return []
+    return [p for p in path.rglob("*") if p.is_file() and p.suffix in (".pt", ".pth")]
+
+
+def get_models(
+    model_dir: str | Path, extra_dir: str | Path = "", huggingface: bool = True
+) -> OrderedDict[str, str | None]:
+    model_paths = [*scan_model_dir(model_dir), *scan_model_dir(extra_dir)]
+
+    models = OrderedDict()
+    if huggingface:
+        models.update(
+            {
+                "face_yolov8n.pt": hf_download("face_yolov8n.pt"),
+                "face_yolov8s.pt": hf_download("face_yolov8s.pt"),
+                "hand_yolov8n.pt": hf_download("hand_yolov8n.pt"),
+                "person_yolov8n-seg.pt": hf_download("person_yolov8n-seg.pt"),
+                "person_yolov8s-seg.pt": hf_download("person_yolov8s-seg.pt"),
+            }
+        )
+    models.update(
+        {
+            "mediapipe_face_full": None,
+            "mediapipe_face_short": None,
+            "mediapipe_face_mesh": None,
+            "mediapipe_face_mesh_eyes_only": None,
+        }
+    )
+
+    invalid_keys = [k for k, v in models.items() if v == "INVALID"]
+    for key in invalid_keys:
+        models.pop(key)
+
+    for path in model_paths:
+        if path.name in models:
+            continue
+        models[path.name] = str(path)
+
+    return models
+
+
+def create_mask_from_bbox(
+    bboxes: list[list[float]], shape: tuple[int, int]
+) -> list[Image.Image]:
+    """
+    Parameters
+    ----------
+        bboxes: list[list[float]]
+            list of [x1, y1, x2, y2]
+            bounding boxes
+        shape: tuple[int, int]
+            shape of the image (width, height)
+
+    Returns
+    -------
+        masks: list[Image.Image]
+        A list of masks
+
+    """
+    masks = []
+    for bbox in bboxes:
+        mask = Image.new("L", shape, 0)
+        mask_draw = ImageDraw.Draw(mask)
+        mask_draw.rectangle(bbox, fill=255)
+        masks.append(mask)
+    return masks
+
+
+def create_bbox_from_mask(
+    masks: list[Image.Image], shape: tuple[int, int]
+) -> list[list[int]]:
+    """
+    Parameters
+    ----------
+        masks: list[Image.Image]
+            A list of masks
+        shape: tuple[int, int]
+            shape of the image (width, height)
+
+    Returns
+    -------
+        bboxes: list[list[float]]
+        A list of bounding boxes
+
+    """
+    bboxes = []
+    for mask in masks:
+        mask = mask.resize(shape)
+        bbox = mask.getbbox()
+        if bbox is not None:
+            bboxes.append(list(bbox))
+    return bboxes

adetailer/adetailer/mask.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from functools import partial, reduce
+from math import dist
+
+import cv2
+import numpy as np
+from PIL import Image, ImageChops
+
+from adetailer.args import MASK_MERGE_INVERT
+from adetailer.common import PredictOutput
+
+
+class SortBy(IntEnum):
+    NONE = 0
+    LEFT_TO_RIGHT = 1
+    CENTER_TO_EDGE = 2
+    AREA = 3
+
+
+class MergeInvert(IntEnum):
+    NONE = 0
+    MERGE = 1
+    MERGE_INVERT = 2
+
+
+def _dilate(arr: np.ndarray, value: int) -> np.ndarray:
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (value, value))
+    return cv2.dilate(arr, kernel, iterations=1)
+
+
+def _erode(arr: np.ndarray, value: int) -> np.ndarray:
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (value, value))
+    return cv2.erode(arr, kernel, iterations=1)
+
+
+def dilate_erode(img: Image.Image, value: int) -> Image.Image:
+    """
+    The dilate_erode function takes an image and a value.
+    If the value is positive, it dilates the image by that amount.
+    If the value is negative, it erodes the image by that amount.
+
+    Parameters
+    ----------
+        img: PIL.Image.Image
+            the image to be processed
+        value: int
+            kernel size of dilation or erosion
+
+    Returns
+    -------
+        PIL.Image.Image
+            The image that has been dilated or eroded
+    """
+    if value == 0:
+        return img
+
+    arr = np.array(img)
+    arr = _dilate(arr, value) if value > 0 else _erode(arr, -value)
+
+    return Image.fromarray(arr)
+
+
+def offset(img: Image.Image, x: int = 0, y: int = 0) -> Image.Image:
+    """
+    The offset function takes an image and offsets it by a given x(→) and y(↑) value.
+
+    Parameters
+    ----------
+        mask: Image.Image
+            Pass the mask image to the function
+        x: int
+            →
+        y: int
+            ↑
+
+    Returns
+    -------
+        PIL.Image.Image
+            A new image that is offset by x and y
+    """
+    return ImageChops.offset(img, x, -y)
+
+
+def is_all_black(img: Image.Image) -> bool:
+    arr = np.array(img)
+    return cv2.countNonZero(arr) == 0
+
+
+def bbox_area(bbox: list[float]):
+    return (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+
+
+def mask_preprocess(
+    masks: list[Image.Image],
+    kernel: int = 0,
+    x_offset: int = 0,
+    y_offset: int = 0,
+    merge_invert: int | MergeInvert | str = MergeInvert.NONE,
+) -> list[Image.Image]:
+    """
+    The mask_preprocess function takes a list of masks and preprocesses them.
+    It dilates and erodes the masks, and offsets them by x_offset and y_offset.
+
+    Parameters
+    ----------
+        masks: list[Image.Image]
+            A list of masks
+        kernel: int
+            kernel size of dilation or erosion
+        x_offset: int
+            →
+        y_offset: int
+            ↑
+
+    Returns
+    -------
+        list[Image.Image]
+            A list of processed masks
+    """
+    if not masks:
+        return []
+
+    if x_offset != 0 or y_offset != 0:
+        masks = [offset(m, x_offset, y_offset) for m in masks]
+
+    if kernel != 0:
+        masks = [dilate_erode(m, kernel) for m in masks]
+        masks = [m for m in masks if not is_all_black(m)]
+
+    return mask_merge_invert(masks, mode=merge_invert)
+
+
+# Bbox sorting
+def _key_left_to_right(bbox: list[float]) -> float:
+    """
+    Left to right
+
+    Parameters
+    ----------
+    bbox: list[float]
+        list of [x1, y1, x2, y2]
+    """
+    return bbox[0]
+
+
+def _key_center_to_edge(bbox: list[float], *, center: tuple[float, float]) -> float:
+    """
+    Center to edge
+
+    Parameters
+    ----------
+    bbox: list[float]
+        list of [x1, y1, x2, y2]
+    image: Image.Image
+        the image
+    """
+    bbox_center = ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
+    return dist(center, bbox_center)
+
+
+def _key_area(bbox: list[float]) -> float:
+    """
+    Large to small
+
+    Parameters
+    ----------
+    bbox: list[float]
+        list of [x1, y1, x2, y2]
+    """
+    return -bbox_area(bbox)
+
+
+def sort_bboxes(
+    pred: PredictOutput, order: int | SortBy = SortBy.NONE
+) -> PredictOutput:
+    if order == SortBy.NONE or len(pred.bboxes) <= 1:
+        return pred
+
+    if order == SortBy.LEFT_TO_RIGHT:
+        key = _key_left_to_right
+    elif order == SortBy.CENTER_TO_EDGE:
+        width, height = pred.preview.size
+        center = (width / 2, height / 2)
+        key = partial(_key_center_to_edge, center=center)
+    elif order == SortBy.AREA:
+        key = _key_area
+    else:
+        raise RuntimeError
+
+    items = len(pred.bboxes)
+    idx = sorted(range(items), key=lambda i: key(pred.bboxes[i]))
+    pred.bboxes = [pred.bboxes[i] for i in idx]
+    pred.masks = [pred.masks[i] for i in idx]
+    return pred
+
+
+# Filter by ratio
+def is_in_ratio(bbox: list[float], low: float, high: float, orig_area: int) -> bool:
+    area = bbox_area(bbox)
+    return low <= area / orig_area <= high
+
+
+def filter_by_ratio(pred: PredictOutput, low: float, high: float) -> PredictOutput:
+    if not pred.bboxes:
+        return pred
+
+    w, h = pred.preview.size
+    orig_area = w * h
+    items = len(pred.bboxes)
+    idx = [i for i in range(items) if is_in_ratio(pred.bboxes[i], low, high, orig_area)]
+    pred.bboxes = [pred.bboxes[i] for i in idx]
+    pred.masks = [pred.masks[i] for i in idx]
+    return pred
+
+
+def filter_k_largest(pred: PredictOutput, k: int = 0) -> PredictOutput:
+    if not pred.bboxes or k == 0:
+        return pred
+    areas = [bbox_area(bbox) for bbox in pred.bboxes]
+    idx = np.argsort(areas)[-k:]
+    idx = idx[::-1]
+    pred.bboxes = [pred.bboxes[i] for i in idx]
+    pred.masks = [pred.masks[i] for i in idx]
+    return pred
+
+
+# Merge / Invert
+def mask_merge(masks: list[Image.Image]) -> list[Image.Image]:
+    arrs = [np.array(m) for m in masks]
+    arr = reduce(cv2.bitwise_or, arrs)
+    return [Image.fromarray(arr)]
+
+
+def mask_invert(masks: list[Image.Image]) -> list[Image.Image]:
+    return [ImageChops.invert(m) for m in masks]
+
+
+def mask_merge_invert(
+    masks: list[Image.Image], mode: int | MergeInvert | str
+) -> list[Image.Image]:
+    if isinstance(mode, str):
+        mode = MASK_MERGE_INVERT.index(mode)
+
+    if mode == MergeInvert.NONE or not masks:
+        return masks
+
+    if mode == MergeInvert.MERGE:
+        return mask_merge(masks)
+
+    if mode == MergeInvert.MERGE_INVERT:
+        merged = mask_merge(masks)
+        return mask_invert(merged)
+
+    raise RuntimeError

adetailer/adetailer/mediapipe.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from functools import partial
+
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw
+
+from adetailer import PredictOutput
+from adetailer.common import create_bbox_from_mask, create_mask_from_bbox
+
+
+def mediapipe_predict(
+    model_type: str, image: Image.Image, confidence: float = 0.3
+) -> PredictOutput:
+    mapping = {
+        "mediapipe_face_short": partial(mediapipe_face_detection, 0),
+        "mediapipe_face_full": partial(mediapipe_face_detection, 1),
+        "mediapipe_face_mesh": mediapipe_face_mesh,
+        "mediapipe_face_mesh_eyes_only": mediapipe_face_mesh_eyes_only,
+    }
+    if model_type in mapping:
+        func = mapping[model_type]
+        return func(image, confidence)
+    msg = f"[-] ADetailer: Invalid mediapipe model type: {model_type}, Available: {list(mapping.keys())!r}"
+    raise RuntimeError(msg)
+
+
+def mediapipe_face_detection(
+    model_type: int, image: Image.Image, confidence: float = 0.3
+) -> PredictOutput:
+    import mediapipe as mp
+
+    img_width, img_height = image.size
+
+    mp_face_detection = mp.solutions.face_detection
+    draw_util = mp.solutions.drawing_utils
+
+    img_array = np.array(image)
+
+    with mp_face_detection.FaceDetection(
+        model_selection=model_type, min_detection_confidence=confidence
+    ) as face_detector:
+        pred = face_detector.process(img_array)
+
+    if pred.detections is None:
+        return PredictOutput()
+
+    preview_array = img_array.copy()
+
+    bboxes = []
+    for detection in pred.detections:
+        draw_util.draw_detection(preview_array, detection)
+
+        bbox = detection.location_data.relative_bounding_box
+        x1 = bbox.xmin * img_width
+        y1 = bbox.ymin * img_height
+        w = bbox.width * img_width
+        h = bbox.height * img_height
+        x2 = x1 + w
+        y2 = y1 + h
+
+        bboxes.append([x1, y1, x2, y2])
+
+    masks = create_mask_from_bbox(bboxes, image.size)
+    preview = Image.fromarray(preview_array)
+
+    return PredictOutput(bboxes=bboxes, masks=masks, preview=preview)
+
+
+def mediapipe_face_mesh(image: Image.Image, confidence: float = 0.3) -> PredictOutput:
+    import mediapipe as mp
+
+    mp_face_mesh = mp.solutions.face_mesh
+    draw_util = mp.solutions.drawing_utils
+    drawing_styles = mp.solutions.drawing_styles
+
+    w, h = image.size
+
+    with mp_face_mesh.FaceMesh(
+        static_image_mode=True, max_num_faces=20, min_detection_confidence=confidence
+    ) as face_mesh:
+        arr = np.array(image)
+        pred = face_mesh.process(arr)
+
+        if pred.multi_face_landmarks is None:
+            return PredictOutput()
+
+        preview = arr.copy()
+        masks = []
+
+        for landmarks in pred.multi_face_landmarks:
+            draw_util.draw_landmarks(
+                image=preview,
+                landmark_list=landmarks,
+                connections=mp_face_mesh.FACEMESH_TESSELATION,
+                landmark_drawing_spec=None,
+                connection_drawing_spec=drawing_styles.get_default_face_mesh_tesselation_style(),
+            )
+
+            points = np.intp([(land.x * w, land.y * h) for land in landmarks.landmark])
+            outline = cv2.convexHull(points).reshape(-1).tolist()
+
+            mask = Image.new("L", image.size, "black")
+            draw = ImageDraw.Draw(mask)
+            draw.polygon(outline, fill="white")
+            masks.append(mask)
+
+        bboxes = create_bbox_from_mask(masks, image.size)
+        preview = Image.fromarray(preview)
+        return PredictOutput(bboxes=bboxes, masks=masks, preview=preview)
+
+
+def mediapipe_face_mesh_eyes_only(
+    image: Image.Image, confidence: float = 0.3
+) -> PredictOutput:
+    import mediapipe as mp
+
+    mp_face_mesh = mp.solutions.face_mesh
+
+    left_idx = np.array(list(mp_face_mesh.FACEMESH_LEFT_EYE)).flatten()
+    right_idx = np.array(list(mp_face_mesh.FACEMESH_RIGHT_EYE)).flatten()
+
+    w, h = image.size
+
+    with mp_face_mesh.FaceMesh(
+        static_image_mode=True, max_num_faces=20, min_detection_confidence=confidence
+    ) as face_mesh:
+        arr = np.array(image)
+        pred = face_mesh.process(arr)
+
+        if pred.multi_face_landmarks is None:
+            return PredictOutput()
+
+        preview = image.copy()
+        masks = []
+
+        for landmarks in pred.multi_face_landmarks:
+            points = np.intp([(land.x * w, land.y * h) for land in landmarks.landmark])
+            left_eyes = points[left_idx]
+            right_eyes = points[right_idx]
+            left_outline = cv2.convexHull(left_eyes).reshape(-1).tolist()
+            right_outline = cv2.convexHull(right_eyes).reshape(-1).tolist()
+
+            mask = Image.new("L", image.size, "black")
+            draw = ImageDraw.Draw(mask)
+            for outline in (left_outline, right_outline):
+                draw.polygon(outline, fill="white")
+            masks.append(mask)
+
+        bboxes = create_bbox_from_mask(masks, image.size)
+        preview = draw_preview(preview, bboxes, masks)
+        return PredictOutput(bboxes=bboxes, masks=masks, preview=preview)
+
+
+def draw_preview(
+    preview: Image.Image, bboxes: list[list[int]], masks: list[Image.Image]
+) -> Image.Image:
+    red = Image.new("RGB", preview.size, "red")
+    for mask in masks:
+        masked = Image.composite(red, preview, mask)
+        preview = Image.blend(preview, masked, 0.25)
+
+    draw = ImageDraw.Draw(preview)
+    for bbox in bboxes:
+        draw.rectangle(bbox, outline="red", width=2)
+
+    return preview

adetailer/adetailer/traceback.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import io
+import platform
+import sys
+from importlib.metadata import version
+from typing import Any, Callable
+
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.traceback import Traceback
+
+from adetailer.__version__ import __version__
+
+
+def processing(*args: Any) -> dict[str, Any]:
+    try:
+        from modules.processing import (
+            StableDiffusionProcessingImg2Img,
+            StableDiffusionProcessingTxt2Img,
+        )
+    except ImportError:
+        return {}
+
+    p = None
+    for arg in args:
+        if isinstance(
+            arg, (StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img)
+        ):
+            p = arg
+            break
+
+    if p is None:
+        return {}
+
+    info = {
+        "prompt": p.prompt,
+        "negative_prompt": p.negative_prompt,
+        "n_iter": p.n_iter,
+        "batch_size": p.batch_size,
+        "width": p.width,
+        "height": p.height,
+        "sampler_name": p.sampler_name,
+        "enable_hr": getattr(p, "enable_hr", False),
+        "hr_upscaler": getattr(p, "hr_upscaler", ""),
+    }
+
+    info.update(sd_models())
+    return info
+
+
+def sd_models() -> dict[str, str]:
+    try:
+        from modules import shared
+
+        opts = shared.opts
+    except Exception:
+        return {}
+
+    return {
+        "checkpoint": getattr(opts, "sd_model_checkpoint", "------"),
+        "vae": getattr(opts, "sd_vae", "------"),
+        "unet": getattr(opts, "sd_unet", "------"),
+    }
+
+
+def ad_args(*args: Any) -> dict[str, Any]:
+    ad_args = [
+        arg
+        for arg in args
+        if isinstance(arg, dict) and arg.get("ad_model", "None") != "None"
+    ]
+    if not ad_args:
+        return {}
+
+    arg0 = ad_args[0]
+    is_api = arg0.get("is_api", True)
+    return {
+        "version": __version__,
+        "ad_model": arg0["ad_model"],
+        "ad_prompt": arg0.get("ad_prompt", ""),
+        "ad_negative_prompt": arg0.get("ad_negative_prompt", ""),
+        "ad_controlnet_model": arg0.get("ad_controlnet_model", "None"),
+        "is_api": type(is_api) is not tuple,
+    }
+
+
+def library_version():
+    libraries = ["torch", "torchvision", "ultralytics", "mediapipe"]
+    d = {}
+    for lib in libraries:
+        try:
+            d[lib] = version(lib)
+        except Exception:  # noqa: PERF203
+            d[lib] = "Unknown"
+    return d
+
+
+def sys_info() -> dict[str, Any]:
+    try:
+        import launch
+
+        version = launch.git_tag()
+        commit = launch.commit_hash()
+    except Exception:
+        version = "Unknown (too old or vladmandic)"
+        commit = "Unknown"
+
+    return {
+        "Platform": platform.platform(),
+        "Python": sys.version,
+        "Version": version,
+        "Commit": commit,
+        "Commandline": sys.argv,
+        "Libraries": library_version(),
+    }
+
+
+def get_table(title: str, data: dict[str, Any]) -> Table:
+    table = Table(title=title, highlight=True)
+    table.add_column(" ", justify="right", style="dim")
+    table.add_column("Value")
+    for key, value in data.items():
+        if not isinstance(value, str):
+            value = repr(value)
+        table.add_row(key, value)
+
+    return table
+
+
+def rich_traceback(func: Callable) -> Callable:
+    def wrapper(*args, **kwargs):
+        string = io.StringIO()
+        width = Console().width
+        width = width - 4 if width > 4 else None
+        console = Console(file=string, width=width)
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            tables = [
+                get_table(title, data)
+                for title, data in [
+                    ("System info", sys_info()),
+                    ("Inputs", processing(*args)),
+                    ("ADetailer", ad_args(*args)),
+                ]
+                if data
+            ]
+            tables.append(Traceback(extra_lines=1))
+
+            console.print(Panel(Group(*tables)))
+            output = "\n" + string.getvalue()
+
+            try:
+                error = e.__class__(output)
+            except Exception:
+                error = RuntimeError(output)
+            raise error from None
+
+    return wrapper

adetailer/adetailer/ui.py

@@ -0,0 +1,640 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import partial
+from types import SimpleNamespace
+from typing import Any
+
+import gradio as gr
+
+from adetailer import AFTER_DETAILER, __version__
+from adetailer.args import ALL_ARGS, MASK_MERGE_INVERT
+from controlnet_ext import controlnet_exists, get_cn_models
+
+cn_module_choices = {
+    "inpaint": [
+        "inpaint_global_harmonious",
+        "inpaint_only",
+        "inpaint_only+lama",
+    ],
+    "lineart": [
+        "lineart_coarse",
+        "lineart_realistic",
+        "lineart_anime",
+        "lineart_anime_denoise",
+    ],
+    "openpose": ["openpose_full", "dw_openpose_full"],
+    "tile": ["tile_resample", "tile_colorfix", "tile_colorfix+sharp"],
+    "scribble": ["t2ia_sketch_pidi"],
+    "depth": ["depth_midas", "depth_hand_refiner"],
+}
+
+
+class Widgets(SimpleNamespace):
+    def tolist(self):
+        return [getattr(self, attr) for attr in ALL_ARGS.attrs]
+
+
+@dataclass
+class WebuiInfo:
+    ad_model_list: list[str]
+    sampler_names: list[str]
+    t2i_button: gr.Button
+    i2i_button: gr.Button
+    checkpoints_list: list[str]
+    vae_list: list[str]
+
+
+def gr_interactive(value: bool = True):
+    return gr.update(interactive=value)
+
+
+def ordinal(n: int) -> str:
+    d = {1: "st", 2: "nd", 3: "rd"}
+    return str(n) + ("th" if 11 <= n % 100 <= 13 else d.get(n % 10, "th"))
+
+
+def suffix(n: int, c: str = " ") -> str:
+    return "" if n == 0 else c + ordinal(n + 1)
+
+
+def on_widget_change(state: dict, value: Any, *, attr: str):
+    if "is_api" in state:
+        state = state.copy()
+        state.pop("is_api")
+    state[attr] = value
+    return state
+
+
+def on_generate_click(state: dict, *values: Any):
+    for attr, value in zip(ALL_ARGS.attrs, values):
+        state[attr] = value
+    state["is_api"] = ()
+    return state
+
+
+def on_cn_model_update(cn_model_name: str):
+    cn_model_name = cn_model_name.replace("inpaint_depth", "depth")
+    for t in cn_module_choices:
+        if t in cn_model_name:
+            choices = cn_module_choices[t]
+            return gr.update(visible=True, choices=choices, value=choices[0])
+    return gr.update(visible=False, choices=["None"], value="None")
+
+
+def elem_id(item_id: str, n: int, is_img2img: bool) -> str:
+    tap = "img2img" if is_img2img else "txt2img"
+    suf = suffix(n, "_")
+    return f"script_{tap}_adetailer_{item_id}{suf}"
+
+
+def state_init(w: Widgets) -> dict[str, Any]:
+    return {attr: getattr(w, attr).value for attr in ALL_ARGS.attrs}
+
+
+def adui(
+    num_models: int,
+    is_img2img: bool,
+    webui_info: WebuiInfo,
+):
+    states = []
+    infotext_fields = []
+    eid = partial(elem_id, n=0, is_img2img=is_img2img)
+
+    with gr.Accordion(AFTER_DETAILER, open=False, elem_id=eid("ad_main_accordion")):
+        with gr.Row():
+            with gr.Column(scale=6):
+                ad_enable = gr.Checkbox(
+                    label="Enable ADetailer",
+                    value=False,
+                    visible=True,
+                    elem_id=eid("ad_enable"),
+                )
+
+            with gr.Column(scale=6):
+                ad_skip_img2img = gr.Checkbox(
+                    label="Skip img2img",
+                    value=False,
+                    visible=is_img2img,
+                    elem_id=eid("ad_skip_img2img"),
+                )
+
+            with gr.Column(scale=1, min_width=180):
+                gr.Markdown(
+                    f"v{__version__}",
+                    elem_id=eid("ad_version"),
+                )
+
+        infotext_fields.append((ad_enable, "ADetailer enable"))
+        infotext_fields.append((ad_skip_img2img, "ADetailer skip img2img"))
+
+        with gr.Group(), gr.Tabs():
+            for n in range(num_models):
+                with gr.Tab(ordinal(n + 1)):
+                    state, infofields = one_ui_group(
+                        n=n,
+                        is_img2img=is_img2img,
+                        webui_info=webui_info,
+                    )
+
+                states.append(state)
+                infotext_fields.extend(infofields)
+
+    # components: [bool, dict, dict, ...]
+    components = [ad_enable, ad_skip_img2img, *states]
+    return components, infotext_fields
+
+
+def one_ui_group(n: int, is_img2img: bool, webui_info: WebuiInfo):
+    w = Widgets()
+    eid = partial(elem_id, n=n, is_img2img=is_img2img)
+
+    with gr.Row():
+        model_choices = (
+            [*webui_info.ad_model_list, "None"]
+            if n == 0
+            else ["None", *webui_info.ad_model_list]
+        )
+
+        w.ad_model = gr.Dropdown(
+            label="ADetailer model" + suffix(n),
+            choices=model_choices,
+            value=model_choices[0],
+            visible=True,
+            type="value",
+            elem_id=eid("ad_model"),
+        )
+
+    with gr.Group():
+        with gr.Row(elem_id=eid("ad_toprow_prompt")):
+            w.ad_prompt = gr.Textbox(
+                label="ad_prompt" + suffix(n),
+                show_label=False,
+                lines=3,
+                placeholder="ADetailer prompt"
+                + suffix(n)
+                + "\nIf blank, the main prompt is used.",
+                elem_id=eid("ad_prompt"),
+            )
+
+        with gr.Row(elem_id=eid("ad_toprow_negative_prompt")):
+            w.ad_negative_prompt = gr.Textbox(
+                label="ad_negative_prompt" + suffix(n),
+                show_label=False,
+                lines=2,
+                placeholder="ADetailer negative prompt"
+                + suffix(n)
+                + "\nIf blank, the main negative prompt is used.",
+                elem_id=eid("ad_negative_prompt"),
+            )
+
+    with gr.Group():
+        with gr.Accordion(
+            "Detection", open=False, elem_id=eid("ad_detection_accordion")
+        ):
+            detection(w, n, is_img2img)
+
+        with gr.Accordion(
+            "Mask Preprocessing",
+            open=False,
+            elem_id=eid("ad_mask_preprocessing_accordion"),
+        ):
+            mask_preprocessing(w, n, is_img2img)
+
+        with gr.Accordion(
+            "Inpainting", open=False, elem_id=eid("ad_inpainting_accordion")
+        ):
+            inpainting(w, n, is_img2img, webui_info)
+
+    with gr.Group():
+        controlnet(w, n, is_img2img)
+
+    state = gr.State(lambda: state_init(w))
+
+    for attr in ALL_ARGS.attrs:
+        widget = getattr(w, attr)
+        on_change = partial(on_widget_change, attr=attr)
+        widget.change(fn=on_change, inputs=[state, widget], outputs=state, queue=False)
+
+    all_inputs = [state, *w.tolist()]
+    target_button = webui_info.i2i_button if is_img2img else webui_info.t2i_button
+    target_button.click(
+        fn=on_generate_click, inputs=all_inputs, outputs=state, queue=False
+    )
+
+    infotext_fields = [(getattr(w, attr), name + suffix(n)) for attr, name in ALL_ARGS]
+
+    return state, infotext_fields
+
+
+def detection(w: Widgets, n: int, is_img2img: bool):
+    eid = partial(elem_id, n=n, is_img2img=is_img2img)
+
+    with gr.Row():
+        with gr.Column(variant="compact"):
+            w.ad_confidence = gr.Slider(
+                label="Detection model confidence threshold" + suffix(n),
+                minimum=0.0,
+                maximum=1.0,
+                step=0.01,
+                value=0.3,
+                visible=True,
+                elem_id=eid("ad_confidence"),
+            )
+            w.ad_mask_k_largest = gr.Slider(
+                label="Mask only the top k largest (0 to disable)" + suffix(n),
+                minimum=0,
+                maximum=10,
+                step=1,
+                value=0,
+                visible=True,
+                elem_id=eid("ad_mask_k_largest"),
+            )
+
+        with gr.Column(variant="compact"):
+            w.ad_mask_min_ratio = gr.Slider(
+                label="Mask min area ratio" + suffix(n),
+                minimum=0.0,
+                maximum=1.0,
+                step=0.001,
+                value=0.0,
+                visible=True,
+                elem_id=eid("ad_mask_min_ratio"),
+            )
+            w.ad_mask_max_ratio = gr.Slider(
+                label="Mask max area ratio" + suffix(n),
+                minimum=0.0,
+                maximum=1.0,
+                step=0.001,
+                value=1.0,
+                visible=True,
+                elem_id=eid("ad_mask_max_ratio"),
+            )
+
+
+def mask_preprocessing(w: Widgets, n: int, is_img2img: bool):
+    eid = partial(elem_id, n=n, is_img2img=is_img2img)
+
+    with gr.Group():
+        with gr.Row():
+            with gr.Column(variant="compact"):
+                w.ad_x_offset = gr.Slider(
+                    label="Mask x(→) offset" + suffix(n),
+                    minimum=-200,
+                    maximum=200,
+                    step=1,
+                    value=0,
+                    visible=True,
+                    elem_id=eid("ad_x_offset"),
+                )
+                w.ad_y_offset = gr.Slider(
+                    label="Mask y(↑) offset" + suffix(n),
+                    minimum=-200,
+                    maximum=200,
+                    step=1,
+                    value=0,
+                    visible=True,
+                    elem_id=eid("ad_y_offset"),
+                )
+
+            with gr.Column(variant="compact"):
+                w.ad_dilate_erode = gr.Slider(
+                    label="Mask erosion (-) / dilation (+)" + suffix(n),
+                    minimum=-128,
+                    maximum=128,
+                    step=4,
+                    value=4,
+                    visible=True,
+                    elem_id=eid("ad_dilate_erode"),
+                )
+
+        with gr.Row():
+            w.ad_mask_merge_invert = gr.Radio(
+                label="Mask merge mode" + suffix(n),
+                choices=MASK_MERGE_INVERT,
+                value="None",
+                elem_id=eid("ad_mask_merge_invert"),
+            )
+
+
+def inpainting(w: Widgets, n: int, is_img2img: bool, webui_info: WebuiInfo):
+    eid = partial(elem_id, n=n, is_img2img=is_img2img)
+
+    with gr.Group():
+        with gr.Row():
+            w.ad_mask_blur = gr.Slider(
+                label="Inpaint mask blur" + suffix(n),
+                minimum=0,
+                maximum=64,
+                step=1,
+                value=4,
+                visible=True,
+                elem_id=eid("ad_mask_blur"),
+            )
+
+            w.ad_denoising_strength = gr.Slider(
+                label="Inpaint denoising strength" + suffix(n),
+                minimum=0.0,
+                maximum=1.0,
+                step=0.01,
+                value=0.4,
+                visible=True,
+                elem_id=eid("ad_denoising_strength"),
+            )
+
+        with gr.Row():
+            with gr.Column(variant="compact"):
+                w.ad_inpaint_only_masked = gr.Checkbox(
+                    label="Inpaint only masked" + suffix(n),
+                    value=True,
+                    visible=True,
+                    elem_id=eid("ad_inpaint_only_masked"),
+                )
+                w.ad_inpaint_only_masked_padding = gr.Slider(
+                    label="Inpaint only masked padding, pixels" + suffix(n),
+                    minimum=0,
+                    maximum=256,
+                    step=4,
+                    value=32,
+                    visible=True,
+                    elem_id=eid("ad_inpaint_only_masked_padding"),
+                )
+
+                w.ad_inpaint_only_masked.change(
+                    gr_interactive,
+                    inputs=w.ad_inpaint_only_masked,
+                    outputs=w.ad_inpaint_only_masked_padding,
+                    queue=False,
+                )
+
+            with gr.Column(variant="compact"):
+                w.ad_use_inpaint_width_height = gr.Checkbox(
+                    label="Use separate width/height" + suffix(n),
+                    value=False,
+                    visible=True,
+                    elem_id=eid("ad_use_inpaint_width_height"),
+                )
+
+                w.ad_inpaint_width = gr.Slider(
+                    label="inpaint width" + suffix(n),
+                    minimum=64,
+                    maximum=2048,
+                    step=4,
+                    value=512,
+                    visible=True,
+                    elem_id=eid("ad_inpaint_width"),
+                )
+
+                w.ad_inpaint_height = gr.Slider(
+                    label="inpaint height" + suffix(n),
+                    minimum=64,
+                    maximum=2048,
+                    step=4,
+                    value=512,
+                    visible=True,
+                    elem_id=eid("ad_inpaint_height"),
+                )
+
+                w.ad_use_inpaint_width_height.change(
+                    lambda value: (gr_interactive(value), gr_interactive(value)),
+                    inputs=w.ad_use_inpaint_width_height,
+                    outputs=[w.ad_inpaint_width, w.ad_inpaint_height],
+                    queue=False,
+                )
+
+        with gr.Row():
+            with gr.Column(variant="compact"):
+                w.ad_use_steps = gr.Checkbox(
+                    label="Use separate steps" + suffix(n),
+                    value=False,
+                    visible=True,
+                    elem_id=eid("ad_use_steps"),
+                )
+
+                w.ad_steps = gr.Slider(
+                    label="ADetailer steps" + suffix(n),
+                    minimum=1,
+                    maximum=150,
+                    step=1,
+                    value=28,
+                    visible=True,
+                    elem_id=eid("ad_steps"),
+                )
+
+                w.ad_use_steps.change(
+                    gr_interactive,
+                    inputs=w.ad_use_steps,
+                    outputs=w.ad_steps,
+                    queue=False,
+                )
+
+            with gr.Column(variant="compact"):
+                w.ad_use_cfg_scale = gr.Checkbox(
+                    label="Use separate CFG scale" + suffix(n),
+                    value=False,
+                    visible=True,
+                    elem_id=eid("ad_use_cfg_scale"),
+                )
+
+                w.ad_cfg_scale = gr.Slider(
+                    label="ADetailer CFG scale" + suffix(n),
+                    minimum=0.0,
+                    maximum=30.0,
+                    step=0.5,
+                    value=7.0,
+                    visible=True,
+                    elem_id=eid("ad_cfg_scale"),
+                )
+
+                w.ad_use_cfg_scale.change(
+                    gr_interactive,
+                    inputs=w.ad_use_cfg_scale,
+                    outputs=w.ad_cfg_scale,
+                    queue=False,
+                )
+
+        with gr.Row():
+            with gr.Column(variant="compact"):
+                w.ad_use_checkpoint = gr.Checkbox(
+                    label="Use separate checkpoint" + suffix(n),
+                    value=False,
+                    visible=True,
+                    elem_id=eid("ad_use_checkpoint"),
+                )
+
+                ckpts = ["Use same checkpoint", *webui_info.checkpoints_list]
+
+                w.ad_checkpoint = gr.Dropdown(
+                    label="ADetailer checkpoint" + suffix(n),
+                    choices=ckpts,
+                    value=ckpts[0],
+                    visible=True,
+                    elem_id=eid("ad_checkpoint"),
+                )
+
+            with gr.Column(variant="compact"):
+                w.ad_use_vae = gr.Checkbox(
+                    label="Use separate VAE" + suffix(n),
+                    value=False,
+                    visible=True,
+                    elem_id=eid("ad_use_vae"),
+                )
+
+                vaes = ["Use same VAE", *webui_info.vae_list]
+
+                w.ad_vae = gr.Dropdown(
+                    label="ADetailer VAE" + suffix(n),
+                    choices=vaes,
+                    value=vaes[0],
+                    visible=True,
+                    elem_id=eid("ad_vae"),
+                )
+
+        with gr.Row(), gr.Column(variant="compact"):
+            w.ad_use_sampler = gr.Checkbox(
+                label="Use separate sampler" + suffix(n),
+                value=False,
+                visible=True,
+                elem_id=eid("ad_use_sampler"),
+            )
+
+            w.ad_sampler = gr.Dropdown(
+                label="ADetailer sampler" + suffix(n),
+                choices=webui_info.sampler_names,
+                value=webui_info.sampler_names[0],
+                visible=True,
+                elem_id=eid("ad_sampler"),
+            )
+
+            w.ad_use_sampler.change(
+                gr_interactive,
+                inputs=w.ad_use_sampler,
+                outputs=w.ad_sampler,
+                queue=False,
+            )
+
+        with gr.Row():
+            with gr.Column(variant="compact"):
+                w.ad_use_noise_multiplier = gr.Checkbox(
+                    label="Use separate noise multiplier" + suffix(n),
+                    value=False,
+                    visible=True,
+                    elem_id=eid("ad_use_noise_multiplier"),
+                )
+
+                w.ad_noise_multiplier = gr.Slider(
+                    label="Noise multiplier for img2img" + suffix(n),
+                    minimum=0.5,
+                    maximum=1.5,
+                    step=0.01,
+                    value=1.0,
+                    visible=True,
+                    elem_id=eid("ad_noise_multiplier"),
+                )
+
+                w.ad_use_noise_multiplier.change(
+                    gr_interactive,
+                    inputs=w.ad_use_noise_multiplier,
+                    outputs=w.ad_noise_multiplier,
+                    queue=False,
+                )
+
+            with gr.Column(variant="compact"):
+                w.ad_use_clip_skip = gr.Checkbox(
+                    label="Use separate CLIP skip" + suffix(n),
+                    value=False,
+                    visible=True,
+                    elem_id=eid("ad_use_clip_skip"),
+                )
+
+                w.ad_clip_skip = gr.Slider(
+                    label="ADetailer CLIP skip" + suffix(n),
+                    minimum=1,
+                    maximum=12,
+                    step=1,
+                    value=1,
+                    visible=True,
+                    elem_id=eid("ad_clip_skip"),
+                )
+
+                w.ad_use_clip_skip.change(
+                    gr_interactive,
+                    inputs=w.ad_use_clip_skip,
+                    outputs=w.ad_clip_skip,
+                    queue=False,
+                )
+
+        with gr.Row(), gr.Column(variant="compact"):
+            w.ad_restore_face = gr.Checkbox(
+                label="Restore faces after ADetailer" + suffix(n),
+                value=False,
+                elem_id=eid("ad_restore_face"),
+            )
+
+
+def controlnet(w: Widgets, n: int, is_img2img: bool):
+    eid = partial(elem_id, n=n, is_img2img=is_img2img)
+    cn_models = ["None", "Passthrough", *get_cn_models()]
+
+    with gr.Row(variant="panel"):
+        with gr.Column(variant="compact"):
+            w.ad_controlnet_model = gr.Dropdown(
+                label="ControlNet model" + suffix(n),
+                choices=cn_models,
+                value="None",
+                visible=True,
+                type="value",
+                interactive=controlnet_exists,
+                elem_id=eid("ad_controlnet_model"),
+            )
+
+            w.ad_controlnet_module = gr.Dropdown(
+                label="ControlNet module" + suffix(n),
+                choices=["None"],
+                value="None",
+                visible=False,
+                type="value",
+                interactive=controlnet_exists,
+                elem_id=eid("ad_controlnet_module"),
+            )
+
+            w.ad_controlnet_weight = gr.Slider(
+                label="ControlNet weight" + suffix(n),
+                minimum=0.0,
+                maximum=1.0,
+                step=0.01,
+                value=1.0,
+                visible=True,
+                interactive=controlnet_exists,
+                elem_id=eid("ad_controlnet_weight"),
+            )
+
+            w.ad_controlnet_model.change(
+                on_cn_model_update,
+                inputs=w.ad_controlnet_model,
+                outputs=w.ad_controlnet_module,
+                queue=False,
+            )
+
+        with gr.Column(variant="compact"):
+            w.ad_controlnet_guidance_start = gr.Slider(
+                label="ControlNet guidance start" + suffix(n),
+                minimum=0.0,
+                maximum=1.0,
+                step=0.01,
+                value=0.0,
+                visible=True,
+                interactive=controlnet_exists,
+                elem_id=eid("ad_controlnet_guidance_start"),
+            )
+
+            w.ad_controlnet_guidance_end = gr.Slider(
+                label="ControlNet guidance end" + suffix(n),
+                minimum=0.0,
+                maximum=1.0,
+                step=0.01,
+                value=1.0,
+                visible=True,
+                interactive=controlnet_exists,
+                elem_id=eid("ad_controlnet_guidance_end"),
+            )

adetailer/adetailer/ultralytics.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import cv2
+from PIL import Image
+from torchvision.transforms.functional import to_pil_image
+
+from adetailer import PredictOutput
+from adetailer.common import create_mask_from_bbox
+
+
+def ultralytics_predict(
+    model_path: str | Path,
+    image: Image.Image,
+    confidence: float = 0.3,
+    device: str = "",
+) -> PredictOutput:
+    from ultralytics import YOLO
+
+    model = YOLO(model_path)
+    pred = model(image, conf=confidence, device=device)
+
+    bboxes = pred[0].boxes.xyxy.cpu().numpy()
+    if bboxes.size == 0:
+        return PredictOutput()
+    bboxes = bboxes.tolist()
+
+    if pred[0].masks is None:
+        masks = create_mask_from_bbox(bboxes, image.size)
+    else:
+        masks = mask_to_pil(pred[0].masks.data, image.size)
+    preview = pred[0].plot()
+    preview = cv2.cvtColor(preview, cv2.COLOR_BGR2RGB)
+    preview = Image.fromarray(preview)
+
+    return PredictOutput(bboxes=bboxes, masks=masks, preview=preview)
+
+
+def mask_to_pil(masks, shape: tuple[int, int]) -> list[Image.Image]:
+    """
+    Parameters
+    ----------
+    masks: torch.Tensor, dtype=torch.float32, shape=(N, H, W).
+        The device can be CUDA, but `to_pil_image` takes care of that.
+
+    shape: tuple[int, int]
+        (width, height) of the original image
+    """
+    n = masks.shape[0]
+    return [to_pil_image(masks[i], mode="L").resize(shape) for i in range(n)]

adetailer/controlnet_ext/__init__.py

@@ -0,0 +1,7 @@
+from .controlnet_ext import ControlNetExt, controlnet_exists, get_cn_models
+
+__all__ = [
+    "ControlNetExt",
+    "controlnet_exists",
+    "get_cn_models",
+]

adetailer/controlnet_ext/controlnet_ext.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import importlib
+import re
+import sys
+from functools import lru_cache
+from pathlib import Path
+from textwrap import dedent
+
+from modules import extensions, sd_models, shared
+
+try:
+    from modules.paths import extensions_builtin_dir, extensions_dir, models_path
+except ImportError as e:
+    msg = """
+    [-] ADetailer: `stable-diffusion-webui < 1.1.0` is no longer supported.
+        Please upgrade to stable-diffusion-webui >= 1.1.0.
+        or you can use ADetailer v23.10.1 (https://github.com/Bing-su/adetailer/archive/refs/tags/v23.10.1.zip)
+    """
+    raise RuntimeError(dedent(msg)) from e
+
+ext_path = Path(extensions_dir)
+ext_builtin_path = Path(extensions_builtin_dir)
+controlnet_exists = False
+controlnet_path = None
+cn_base_path = ""
+
+for extension in extensions.active():
+    if not extension.enabled:
+        continue
+    # For cases like sd-webui-controlnet-master
+    if "sd-webui-controlnet" in extension.name:
+        controlnet_exists = True
+        controlnet_path = Path(extension.path)
+        cn_base_path = ".".join(controlnet_path.parts[-2:])
+        break
+
+if controlnet_path is not None:
+    sd_webui_controlnet_path = controlnet_path.resolve().parent
+    if sd_webui_controlnet_path.stem in ("extensions", "extensions-builtin"):
+        target_path = str(sd_webui_controlnet_path.parent)
+        if target_path not in sys.path:
+            sys.path.append(target_path)
+
+cn_model_module = {
+    "inpaint": "inpaint_global_harmonious",
+    "scribble": "t2ia_sketch_pidi",
+    "lineart": "lineart_coarse",
+    "openpose": "openpose_full",
+    "tile": "tile_resample",
+    "depth": "depth_midas",
+}
+cn_model_regex = re.compile("|".join(cn_model_module.keys()))
+
+
+class ControlNetExt:
+    def __init__(self):
+        self.cn_models = ["None"]
+        self.cn_available = False
+        self.external_cn = None
+
+    def init_controlnet(self):
+        import_path = cn_base_path + ".scripts.external_code"
+
+        self.external_cn = importlib.import_module(import_path, "external_code")
+        self.cn_available = True
+        models = self.external_cn.get_models()
+        self.cn_models.extend(m for m in models if cn_model_regex.search(m))
+
+    def update_scripts_args(
+        self,
+        p,
+        model: str,
+        module: str | None,
+        weight: float,
+        guidance_start: float,
+        guidance_end: float,
+    ):
+        if (not self.cn_available) or model == "None":
+            return
+
+        if module is None or module == "None":
+            for m, v in cn_model_module.items():
+                if m in model:
+                    module = v
+                    break
+            else:
+                module = None
+
+        cn_units = [
+            self.external_cn.ControlNetUnit(
+                model=model,
+                weight=weight,
+                control_mode=self.external_cn.ControlMode.BALANCED,
+                module=module,
+                guidance_start=guidance_start,
+                guidance_end=guidance_end,
+                pixel_perfect=True,
+            )
+        ]
+
+        try:
+            self.external_cn.update_cn_script_in_processing(p, cn_units)
+        except AttributeError as e:
+            if "script_args_value" not in str(e):
+                raise
+            msg = "[-] Adetailer: ControlNet option not available in WEBUI version lower than 1.6.0 due to updates in ControlNet"
+            raise RuntimeError(msg) from e
+
+
+def get_cn_model_dirs() -> list[Path]:
+    cn_model_dir = Path(models_path, "ControlNet")
+    if controlnet_path is not None:
+        cn_model_dir_old = controlnet_path.joinpath("models")
+    else:
+        cn_model_dir_old = None
+    ext_dir1 = shared.opts.data.get("control_net_models_path", "")
+    ext_dir2 = getattr(shared.cmd_opts, "controlnet_dir", "")
+
+    dirs = [cn_model_dir]
+    dirs += [
+        Path(ext_dir) for ext_dir in [cn_model_dir_old, ext_dir1, ext_dir2] if ext_dir
+    ]
+
+    return dirs
+
+
+@lru_cache
+def _get_cn_models() -> list[str]:
+    """
+    Since we can't import ControlNet, we use a function that does something like
+    controlnet's `list(global_state.cn_models_names.values())`.
+    """
+    cn_model_exts = (".pt", ".pth", ".ckpt", ".safetensors")
+    dirs = get_cn_model_dirs()
+    name_filter = shared.opts.data.get("control_net_models_name_filter", "")
+    name_filter = name_filter.strip(" ").lower()
+
+    model_paths = []
+
+    for base in dirs:
+        if not base.exists():
+            continue
+
+        for p in base.rglob("*"):
+            if (
+                p.is_file()
+                and p.suffix in cn_model_exts
+                and cn_model_regex.search(p.name)
+            ):
+                if name_filter and name_filter not in p.name.lower():
+                    continue
+                model_paths.append(p)
+    model_paths.sort(key=lambda p: p.name)
+
+    models = []
+    for p in model_paths:
+        model_hash = sd_models.model_hash(p)
+        name = f"{p.stem} [{model_hash}]"
+        models.append(name)
+    return models
+
+
+def get_cn_models() -> list[str]:
+    if controlnet_exists:
+        return _get_cn_models()
+    return []

adetailer/controlnet_ext/restore.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+
+from modules import img2img, processing, shared
+
+
+class CNHijackRestore:
+    def __init__(self):
+        self.process = hasattr(processing, "__controlnet_original_process_images_inner")
+        self.img2img = hasattr(img2img, "__controlnet_original_process_batch")
+
+    def __enter__(self):
+        if self.process:
+            self.orig_process = processing.process_images_inner
+            processing.process_images_inner = getattr(
+                processing, "__controlnet_original_process_images_inner"
+            )
+        if self.img2img:
+            self.orig_img2img = img2img.process_batch
+            img2img.process_batch = getattr(
+                img2img, "__controlnet_original_process_batch"
+            )
+
+    def __exit__(self, *args, **kwargs):
+        if self.process:
+            processing.process_images_inner = self.orig_process
+        if self.img2img:
+            img2img.process_batch = self.orig_img2img
+
+
+@contextmanager
+def cn_allow_script_control():
+    orig = False
+    if "control_net_allow_script_control" in shared.opts.data:
+        try:
+            orig = shared.opts.data["control_net_allow_script_control"]
+            shared.opts.data["control_net_allow_script_control"] = True
+            yield
+        finally:
+            shared.opts.data["control_net_allow_script_control"] = orig
+    else:
+        yield

adetailer/install.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import importlib.util
+import subprocess
+import sys
+from importlib.metadata import version  # python >= 3.8
+
+from packaging.version import parse
+
+import_name = {"py-cpuinfo": "cpuinfo", "protobuf": "google.protobuf"}
+
+
+def is_installed(
+    package: str, min_version: str | None = None, max_version: str | None = None
+):
+    name = import_name.get(package, package)
+    try:
+        spec = importlib.util.find_spec(name)
+    except ModuleNotFoundError:
+        return False
+
+    if spec is None:
+        return False
+
+    if not min_version and not max_version:
+        return True
+
+    if not min_version:
+        min_version = "0.0.0"
+    if not max_version:
+        max_version = "99999999.99999999.99999999"
+
+    try:
+        pkg_version = version(package)
+        return parse(min_version) <= parse(pkg_version) <= parse(max_version)
+    except Exception:
+        return False
+
+
+def run_pip(*args):
+    subprocess.run([sys.executable, "-m", "pip", "install", *args])
+
+
+def install():
+    deps = [
+        # requirements
+        ("ultralytics", "8.1.0", None),
+        ("mediapipe", "0.10.9", None),
+        ("rich", "13.0.0", None),
+        # mediapipe
+        ("protobuf", "3.20", "3.9999"),
+    ]
+
+    for pkg, low, high in deps:
+        if not is_installed(pkg, low, high):
+            if low and high:
+                cmd = f"{pkg}>={low},<={high}"
+            elif low:
+                cmd = f"{pkg}>={low}"
+            elif high:
+                cmd = f"{pkg}<={high}"
+            else:
+                cmd = pkg
+
+            run_pip("-U", cmd)
+
+
+try:
+    import launch
+
+    skip_install = launch.args.skip_install
+except Exception:
+    skip_install = False
+
+if not skip_install:
+    install()

adetailer/preload.py

@@ -0,0 +1,9 @@
+import argparse
+
+
+def preload(parser: argparse.ArgumentParser):
+    parser.add_argument(
+        "--ad-no-huggingface",
+        action="store_true",
+        help="Don't use adetailer models from huggingface",
+    )

adetailer/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "adetailer"
+description = "An object detection and auto-mask extension for stable diffusion webui."
+authors = [{ name = "dowon", email = "[email protected]" }]
+requires-python = ">=3.8,<3.12"
+readme = "README.md"
+license = { text = "AGPL-3.0" }
+
+[project.urls]
+repository = "https://github.com/Bing-su/adetailer"
+
+[tool.isort]
+profile = "black"
+known_first_party = ["launch", "modules"]
+
+[tool.ruff]
+select = [
+    "A",
+    "B",
+    "C4",
+    "C90",
+    "E",
+    "EM",
+    "F",
+    "FA",
+    "I001",
+    "ISC",
+    "N",
+    "PERF",
+    "PIE",
+    "PT",
+    "PTH",
+    "RET",
+    "RUF",
+    "SIM",
+    "UP",
+    "W",
+]
+ignore = ["B008", "B905", "E501", "F401", "UP007"]
+
+[tool.ruff.isort]
+known-first-party = ["launch", "modules"]

adetailer/scripts/!adetailer.py

@@ -0,0 +1,1000 @@
+from __future__ import annotations
+
+import os
+import platform
+import re
+import sys
+import traceback
+from contextlib import contextmanager, suppress
+from copy import copy
+from functools import partial
+from pathlib import Path
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+import gradio as gr
+import torch
+from PIL import Image
+from rich import print
+from torchvision.transforms.functional import to_pil_image
+
+import modules
+from adetailer import (
+    AFTER_DETAILER,
+    __version__,
+    get_models,
+    mediapipe_predict,
+    ultralytics_predict,
+)
+from adetailer.args import ALL_ARGS, BBOX_SORTBY, ADetailerArgs, SkipImg2ImgOrig
+from adetailer.common import PredictOutput
+from adetailer.mask import (
+    filter_by_ratio,
+    filter_k_largest,
+    mask_preprocess,
+    sort_bboxes,
+)
+from adetailer.traceback import rich_traceback
+from adetailer.ui import WebuiInfo, adui, ordinal, suffix
+from controlnet_ext import ControlNetExt, controlnet_exists, get_cn_models
+from controlnet_ext.restore import (
+    CNHijackRestore,
+    cn_allow_script_control,
+)
+from modules import images, paths, safe, script_callbacks, scripts, shared
+from modules.devices import NansException
+from modules.processing import (
+    Processed,
+    StableDiffusionProcessingImg2Img,
+    create_infotext,
+    process_images,
+)
+from modules.sd_samplers import all_samplers
+from modules.shared import cmd_opts, opts, state
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+no_huggingface = getattr(cmd_opts, "ad_no_huggingface", False)
+adetailer_dir = Path(paths.models_path, "adetailer")
+extra_models_dir = shared.opts.data.get("ad_extra_models_dir", "")
+model_mapping = get_models(
+    adetailer_dir, extra_dir=extra_models_dir, huggingface=not no_huggingface
+)
+txt2img_submit_button = img2img_submit_button = None
+SCRIPT_DEFAULT = "dynamic_prompting,dynamic_thresholding,wildcard_recursive,wildcards,lora_block_weight,negpip"
+
+if (
+    not adetailer_dir.exists()
+    and adetailer_dir.parent.exists()
+    and os.access(adetailer_dir.parent, os.W_OK)
+):
+    adetailer_dir.mkdir()
+
+print(
+    f"[-] ADetailer initialized. version: {__version__}, num models: {len(model_mapping)}"
+)
+
+
+@contextmanager
+def change_torch_load():
+    orig = torch.load
+    try:
+        torch.load = safe.unsafe_torch_load
+        yield
+    finally:
+        torch.load = orig
+
+
+@contextmanager
+def pause_total_tqdm():
+    orig = opts.data.get("multiple_tqdm", True)
+    try:
+        opts.data["multiple_tqdm"] = False
+        yield
+    finally:
+        opts.data["multiple_tqdm"] = orig
+
+
+@contextmanager
+def preseve_prompts(p):
+    all_pt = copy(p.all_prompts)
+    all_ng = copy(p.all_negative_prompts)
+    try:
+        yield
+    finally:
+        p.all_prompts = all_pt
+        p.all_negative_prompts = all_ng
+
+
+class AfterDetailerScript(scripts.Script):
+    def __init__(self):
+        super().__init__()
+        self.ultralytics_device = self.get_ultralytics_device()
+
+        self.controlnet_ext = None
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(version={__version__})"
+
+    def title(self):
+        return AFTER_DETAILER
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        num_models = opts.data.get("ad_max_models", 2)
+        ad_model_list = list(model_mapping.keys())
+        sampler_names = [sampler.name for sampler in all_samplers]
+
+        try:
+            checkpoint_list = modules.sd_models.checkpoint_tiles(use_shorts=True)
+        except TypeError:
+            checkpoint_list = modules.sd_models.checkpoint_tiles()
+        vae_list = modules.shared_items.sd_vae_items()
+
+        webui_info = WebuiInfo(
+            ad_model_list=ad_model_list,
+            sampler_names=sampler_names,
+            t2i_button=txt2img_submit_button,
+            i2i_button=img2img_submit_button,
+            checkpoints_list=checkpoint_list,
+            vae_list=vae_list,
+        )
+
+        components, infotext_fields = adui(num_models, is_img2img, webui_info)
+
+        self.infotext_fields = infotext_fields
+        return components
+
+    def init_controlnet_ext(self) -> None:
+        if self.controlnet_ext is not None:
+            return
+        self.controlnet_ext = ControlNetExt()
+
+        if controlnet_exists:
+            try:
+                self.controlnet_ext.init_controlnet()
+            except ImportError:
+                error = traceback.format_exc()
+                print(
+                    f"[-] ADetailer: ControlNetExt init failed:\n{error}",
+                    file=sys.stderr,
+                )
+
+    def update_controlnet_args(self, p, args: ADetailerArgs) -> None:
+        if self.controlnet_ext is None:
+            self.init_controlnet_ext()
+
+        if (
+            self.controlnet_ext is not None
+            and self.controlnet_ext.cn_available
+            and args.ad_controlnet_model != "None"
+        ):
+            self.controlnet_ext.update_scripts_args(
+                p,
+                model=args.ad_controlnet_model,
+                module=args.ad_controlnet_module,
+                weight=args.ad_controlnet_weight,
+                guidance_start=args.ad_controlnet_guidance_start,
+                guidance_end=args.ad_controlnet_guidance_end,
+            )
+
+    def is_ad_enabled(self, *args_) -> bool:
+        arg_list = [arg for arg in args_ if isinstance(arg, dict)]
+        if not args_ or not arg_list:
+            message = f"""
+                       [-] ADetailer: Invalid arguments passed to ADetailer.
+                           input: {args_!r}
+                           ADetailer disabled.
+                       """
+            print(dedent(message), file=sys.stderr)
+            return False
+
+        ad_enabled = args_[0] if isinstance(args_[0], bool) else True
+        not_none = any(arg.get("ad_model", "None") != "None" for arg in arg_list)
+        return ad_enabled and not_none
+
+    def check_skip_img2img(self, p, *args_) -> None:
+        if (
+            hasattr(p, "_ad_skip_img2img")
+            or not hasattr(p, "init_images")
+            or not p.init_images
+        ):
+            return
+
+        if len(args_) >= 2 and isinstance(args_[1], bool):
+            p._ad_skip_img2img = args_[1]
+            if args_[1]:
+                p._ad_orig = SkipImg2ImgOrig(
+                    steps=p.steps,
+                    sampler_name=p.sampler_name,
+                    width=p.width,
+                    height=p.height,
+                )
+                p.steps = 1
+                p.sampler_name = "Euler"
+                p.width = 128
+                p.height = 128
+        else:
+            p._ad_skip_img2img = False
+
+    @staticmethod
+    def get_i(p) -> int:
+        it = p.iteration
+        bs = p.batch_size
+        i = p.batch_index
+        return it * bs + i
+
+    def get_args(self, p, *args_) -> list[ADetailerArgs]:
+        """
+        `args_` is at least 1 in length by `is_ad_enabled` immediately above
+        """
+        args = [arg for arg in args_ if isinstance(arg, dict)]
+
+        if not args:
+            message = f"[-] ADetailer: Invalid arguments passed to ADetailer: {args_!r}"
+            raise ValueError(message)
+
+        if hasattr(p, "_ad_xyz"):
+            args[0] = {**args[0], **p._ad_xyz}
+
+        all_inputs = []
+
+        for n, arg_dict in enumerate(args, 1):
+            try:
+                inp = ADetailerArgs(**arg_dict)
+            except ValueError as e:
+                msgs = [
+                    f"[-] ADetailer: ValidationError when validating {ordinal(n)} arguments: {e}\n"
+                ]
+                for attr in ALL_ARGS.attrs:
+                    arg = arg_dict.get(attr)
+                    dtype = type(arg)
+                    arg = "DEFAULT" if arg is None else repr(arg)
+                    msgs.append(f"    {attr}: {arg} ({dtype})")
+                raise ValueError("\n".join(msgs)) from e
+
+            all_inputs.append(inp)
+
+        return all_inputs
+
+    def extra_params(self, arg_list: list[ADetailerArgs]) -> dict:
+        params = {}
+        for n, args in enumerate(arg_list):
+            params.update(args.extra_params(suffix=suffix(n)))
+        params["ADetailer version"] = __version__
+        return params
+
+    @staticmethod
+    def get_ultralytics_device() -> str:
+        if "adetailer" in shared.cmd_opts.use_cpu:
+            return "cpu"
+
+        if platform.system() == "Darwin":
+            return ""
+
+        vram_args = ["lowvram", "medvram", "medvram_sdxl"]
+        if any(getattr(cmd_opts, vram, False) for vram in vram_args):
+            return "cpu"
+
+        return ""
+
+    def prompt_blank_replacement(
+        self, all_prompts: list[str], i: int, default: str
+    ) -> str:
+        if not all_prompts:
+            return default
+        if i < len(all_prompts):
+            return all_prompts[i]
+        j = i % len(all_prompts)
+        return all_prompts[j]
+
+    def _get_prompt(
+        self,
+        ad_prompt: str,
+        all_prompts: list[str],
+        i: int,
+        default: str,
+        replacements: list[PromptSR],
+    ) -> list[str]:
+        prompts = re.split(r"\s*\[SEP\]\s*", ad_prompt)
+        blank_replacement = self.prompt_blank_replacement(all_prompts, i, default)
+        for n in range(len(prompts)):
+            if not prompts[n]:
+                prompts[n] = blank_replacement
+            elif "[PROMPT]" in prompts[n]:
+                prompts[n] = prompts[n].replace("[PROMPT]", f" {blank_replacement} ")
+
+            for pair in replacements:
+                prompts[n] = prompts[n].replace(pair.s, pair.r)
+        return prompts
+
+    def get_prompt(self, p, args: ADetailerArgs) -> tuple[list[str], list[str]]:
+        i = self.get_i(p)
+        prompt_sr = p._ad_xyz_prompt_sr if hasattr(p, "_ad_xyz_prompt_sr") else []
+
+        prompt = self._get_prompt(args.ad_prompt, p.all_prompts, i, p.prompt, prompt_sr)
+        negative_prompt = self._get_prompt(
+            args.ad_negative_prompt,
+            p.all_negative_prompts,
+            i,
+            p.negative_prompt,
+            prompt_sr,
+        )
+
+        return prompt, negative_prompt
+
+    def get_seed(self, p) -> tuple[int, int]:
+        i = self.get_i(p)
+
+        if not p.all_seeds:
+            seed = p.seed
+        elif i < len(p.all_seeds):
+            seed = p.all_seeds[i]
+        else:
+            j = i % len(p.all_seeds)
+            seed = p.all_seeds[j]
+
+        if not p.all_subseeds:
+            subseed = p.subseed
+        elif i < len(p.all_subseeds):
+            subseed = p.all_subseeds[i]
+        else:
+            j = i % len(p.all_subseeds)
+            subseed = p.all_subseeds[j]
+
+        return seed, subseed
+
+    def get_width_height(self, p, args: ADetailerArgs) -> tuple[int, int]:
+        if args.ad_use_inpaint_width_height:
+            width = args.ad_inpaint_width
+            height = args.ad_inpaint_height
+        elif hasattr(p, "_ad_orig"):
+            width = p._ad_orig.width
+            height = p._ad_orig.height
+        else:
+            width = p.width
+            height = p.height
+
+        return width, height
+
+    def get_steps(self, p, args: ADetailerArgs) -> int:
+        if args.ad_use_steps:
+            return args.ad_steps
+        if hasattr(p, "_ad_orig"):
+            return p._ad_orig.steps
+        return p.steps
+
+    def get_cfg_scale(self, p, args: ADetailerArgs) -> float:
+        return args.ad_cfg_scale if args.ad_use_cfg_scale else p.cfg_scale
+
+    def get_sampler(self, p, args: ADetailerArgs) -> str:
+        if args.ad_use_sampler:
+            return args.ad_sampler
+        if hasattr(p, "_ad_orig"):
+            return p._ad_orig.sampler_name
+        return p.sampler_name
+
+    def get_override_settings(self, p, args: ADetailerArgs) -> dict[str, Any]:
+        d = {}
+
+        if args.ad_use_clip_skip:
+            d["CLIP_stop_at_last_layers"] = args.ad_clip_skip
+
+        if (
+            args.ad_use_checkpoint
+            and args.ad_checkpoint
+            and args.ad_checkpoint not in ("None", "Use same checkpoint")
+        ):
+            d["sd_model_checkpoint"] = args.ad_checkpoint
+
+        if (
+            args.ad_use_vae
+            and args.ad_vae
+            and args.ad_vae not in ("None", "Use same VAE")
+        ):
+            d["sd_vae"] = args.ad_vae
+        return d
+
+    def get_initial_noise_multiplier(self, p, args: ADetailerArgs) -> float | None:
+        return args.ad_noise_multiplier if args.ad_use_noise_multiplier else None
+
+    @staticmethod
+    def infotext(p) -> str:
+        return create_infotext(
+            p, p.all_prompts, p.all_seeds, p.all_subseeds, None, 0, 0
+        )
+
+    def write_params_txt(self, content: str) -> None:
+        params_txt = Path(paths.data_path, "params.txt")
+        with suppress(Exception):
+            params_txt.write_text(content, encoding="utf-8")
+
+    @staticmethod
+    def script_args_copy(script_args):
+        type_: type[list] | type[tuple] = type(script_args)
+        result = []
+        for arg in script_args:
+            try:
+                a = copy(arg)
+            except TypeError:
+                a = arg
+            result.append(a)
+        return type_(result)
+
+    def script_filter(self, p, args: ADetailerArgs):
+        script_runner = copy(p.scripts)
+        script_args = self.script_args_copy(p.script_args)
+
+        ad_only_seleted_scripts = opts.data.get("ad_only_seleted_scripts", True)
+        if not ad_only_seleted_scripts:
+            return script_runner, script_args
+
+        ad_script_names = opts.data.get("ad_script_names", SCRIPT_DEFAULT)
+        script_names_set = {
+            name
+            for script_name in ad_script_names.split(",")
+            for name in (script_name, script_name.strip())
+        }
+
+        if args.ad_controlnet_model != "None":
+            script_names_set.add("controlnet")
+
+        filtered_alwayson = []
+        for script_object in script_runner.alwayson_scripts:
+            filepath = script_object.filename
+            filename = Path(filepath).stem
+            if filename in script_names_set:
+                filtered_alwayson.append(script_object)
+
+        script_runner.alwayson_scripts = filtered_alwayson
+        return script_runner, script_args
+
+    def disable_controlnet_units(
+        self, script_args: list[Any] | tuple[Any, ...]
+    ) -> None:
+        for obj in script_args:
+            if "controlnet" in obj.__class__.__name__.lower():
+                if hasattr(obj, "enabled"):
+                    obj.enabled = False
+                if hasattr(obj, "input_mode"):
+                    obj.input_mode = getattr(obj.input_mode, "SIMPLE", "simple")
+
+            elif isinstance(obj, dict) and "module" in obj:
+                obj["enabled"] = False
+
+    def get_i2i_p(self, p, args: ADetailerArgs, image):
+        seed, subseed = self.get_seed(p)
+        width, height = self.get_width_height(p, args)
+        steps = self.get_steps(p, args)
+        cfg_scale = self.get_cfg_scale(p, args)
+        initial_noise_multiplier = self.get_initial_noise_multiplier(p, args)
+        sampler_name = self.get_sampler(p, args)
+        override_settings = self.get_override_settings(p, args)
+
+        i2i = StableDiffusionProcessingImg2Img(
+            init_images=[image],
+            resize_mode=0,
+            denoising_strength=args.ad_denoising_strength,
+            mask=None,
+            mask_blur=args.ad_mask_blur,
+            inpainting_fill=1,
+            inpaint_full_res=args.ad_inpaint_only_masked,
+            inpaint_full_res_padding=args.ad_inpaint_only_masked_padding,
+            inpainting_mask_invert=0,
+            initial_noise_multiplier=initial_noise_multiplier,
+            sd_model=p.sd_model,
+            outpath_samples=p.outpath_samples,
+            outpath_grids=p.outpath_grids,
+            prompt="",  # replace later
+            negative_prompt="",
+            styles=p.styles,
+            seed=seed,
+            subseed=subseed,
+            subseed_strength=p.subseed_strength,
+            seed_resize_from_h=p.seed_resize_from_h,
+            seed_resize_from_w=p.seed_resize_from_w,
+            sampler_name=sampler_name,
+            batch_size=1,
+            n_iter=1,
+            steps=steps,
+            cfg_scale=cfg_scale,
+            width=width,
+            height=height,
+            restore_faces=args.ad_restore_face,
+            tiling=p.tiling,
+            extra_generation_params=p.extra_generation_params,
+            do_not_save_samples=True,
+            do_not_save_grid=True,
+            override_settings=override_settings,
+        )
+
+        i2i.cached_c = [None, None]
+        i2i.cached_uc = [None, None]
+        i2i.scripts, i2i.script_args = self.script_filter(p, args)
+        i2i._ad_disabled = True
+        i2i._ad_inner = True
+
+        if args.ad_controlnet_model != "Passthrough":
+            self.disable_controlnet_units(i2i.script_args)
+
+        if args.ad_controlnet_model not in ["None", "Passthrough"]:
+            self.update_controlnet_args(i2i, args)
+        elif args.ad_controlnet_model == "None":
+            i2i.control_net_enabled = False
+
+        return i2i
+
+    def save_image(self, p, image, *, condition: str, suffix: str) -> None:
+        i = self.get_i(p)
+        if p.all_prompts:
+            i %= len(p.all_prompts)
+            save_prompt = p.all_prompts[i]
+        else:
+            save_prompt = p.prompt
+        seed, _ = self.get_seed(p)
+
+        if opts.data.get(condition, False):
+            images.save_image(
+                image=image,
+                path=p.outpath_samples,
+                basename="",
+                seed=seed,
+                prompt=save_prompt,
+                extension=opts.samples_format,
+                info=self.infotext(p),
+                p=p,
+                suffix=suffix,
+            )
+
+    def get_ad_model(self, name: str):
+        if name not in model_mapping:
+            msg = f"[-] ADetailer: Model {name!r} not found. Available models: {list(model_mapping.keys())}"
+            raise ValueError(msg)
+        return model_mapping[name]
+
+    def sort_bboxes(self, pred: PredictOutput) -> PredictOutput:
+        sortby = opts.data.get("ad_bbox_sortby", BBOX_SORTBY[0])
+        sortby_idx = BBOX_SORTBY.index(sortby)
+        return sort_bboxes(pred, sortby_idx)
+
+    def pred_preprocessing(self, pred: PredictOutput, args: ADetailerArgs):
+        pred = filter_by_ratio(
+            pred, low=args.ad_mask_min_ratio, high=args.ad_mask_max_ratio
+        )
+        pred = filter_k_largest(pred, k=args.ad_mask_k_largest)
+        pred = self.sort_bboxes(pred)
+        return mask_preprocess(
+            pred.masks,
+            kernel=args.ad_dilate_erode,
+            x_offset=args.ad_x_offset,
+            y_offset=args.ad_y_offset,
+            merge_invert=args.ad_mask_merge_invert,
+        )
+
+    @staticmethod
+    def ensure_rgb_image(image: Any):
+        if not isinstance(image, Image.Image):
+            image = to_pil_image(image)
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        return image
+
+    @staticmethod
+    def i2i_prompts_replace(
+        i2i, prompts: list[str], negative_prompts: list[str], j: int
+    ) -> None:
+        i1 = min(j, len(prompts) - 1)
+        i2 = min(j, len(negative_prompts) - 1)
+        prompt = prompts[i1]
+        negative_prompt = negative_prompts[i2]
+        i2i.prompt = prompt
+        i2i.negative_prompt = negative_prompt
+
+    @staticmethod
+    def compare_prompt(p, processed, n: int = 0):
+        if p.prompt != processed.all_prompts[0]:
+            print(
+                f"[-] ADetailer: applied {ordinal(n + 1)} ad_prompt: {processed.all_prompts[0]!r}"
+            )
+
+        if p.negative_prompt != processed.all_negative_prompts[0]:
+            print(
+                f"[-] ADetailer: applied {ordinal(n + 1)} ad_negative_prompt: {processed.all_negative_prompts[0]!r}"
+            )
+
+    @staticmethod
+    def need_call_process(p) -> bool:
+        if p.scripts is None:
+            return False
+        i = p.batch_index
+        bs = p.batch_size
+        return i == bs - 1
+
+    @staticmethod
+    def need_call_postprocess(p) -> bool:
+        if p.scripts is None:
+            return False
+        return p.batch_index == 0
+
+    @staticmethod
+    def get_i2i_init_image(p, pp):
+        if getattr(p, "_ad_skip_img2img", False):
+            return p.init_images[0]
+        return pp.image
+
+    @staticmethod
+    def get_each_tap_seed(seed: int, i: int):
+        use_same_seed = shared.opts.data.get("ad_same_seed_for_each_tap", False)
+        return seed if use_same_seed else seed + i
+
+    @staticmethod
+    def is_img2img_inpaint(p) -> bool:
+        return hasattr(p, "image_mask") and bool(p.image_mask)
+
+    @rich_traceback
+    def process(self, p, *args_):
+        if getattr(p, "_ad_disabled", False):
+            return
+
+        if self.is_img2img_inpaint(p):
+            p._ad_disabled = True
+            msg = "[-] ADetailer: img2img inpainting detected. adetailer disabled."
+            print(msg)
+            return
+
+        if self.is_ad_enabled(*args_):
+            arg_list = self.get_args(p, *args_)
+            self.check_skip_img2img(p, *args_)
+            extra_params = self.extra_params(arg_list)
+            p.extra_generation_params.update(extra_params)
+        else:
+            p._ad_disabled = True
+
+    def _postprocess_image_inner(
+        self, p, pp, args: ADetailerArgs, *, n: int = 0
+    ) -> bool:
+        """
+        Returns
+        -------
+            bool
+
+            `True` if image was processed, `False` otherwise.
+        """
+        if state.interrupted or state.skipped:
+            return False
+
+        i = self.get_i(p)
+
+        i2i = self.get_i2i_p(p, args, pp.image)
+        seed, subseed = self.get_seed(p)
+        ad_prompts, ad_negatives = self.get_prompt(p, args)
+
+        is_mediapipe = args.ad_model.lower().startswith("mediapipe")
+
+        kwargs = {}
+        if is_mediapipe:
+            predictor = mediapipe_predict
+            ad_model = args.ad_model
+        else:
+            predictor = ultralytics_predict
+            ad_model = self.get_ad_model(args.ad_model)
+            kwargs["device"] = self.ultralytics_device
+
+        with change_torch_load():
+            pred = predictor(ad_model, pp.image, args.ad_confidence, **kwargs)
+
+        masks = self.pred_preprocessing(pred, args)
+        shared.state.assign_current_image(pred.preview)
+
+        if not masks:
+            print(
+                f"[-] ADetailer: nothing detected on image {i + 1} with {ordinal(n + 1)} settings."
+            )
+            return False
+
+        self.save_image(
+            p,
+            pred.preview,
+            condition="ad_save_previews",
+            suffix="-ad-preview" + suffix(n, "-"),
+        )
+
+        steps = len(masks)
+        processed = None
+        state.job_count += steps
+
+        if is_mediapipe:
+            print(f"mediapipe: {steps} detected.")
+
+        p2 = copy(i2i)
+        for j in range(steps):
+            p2.image_mask = masks[j]
+            p2.init_images[0] = self.ensure_rgb_image(p2.init_images[0])
+            self.i2i_prompts_replace(p2, ad_prompts, ad_negatives, j)
+
+            if re.match(r"^\s*\[SKIP\]\s*$", p2.prompt):
+                continue
+
+            p2.seed = self.get_each_tap_seed(seed, j)
+            p2.subseed = self.get_each_tap_seed(subseed, j)
+
+            try:
+                processed = process_images(p2)
+            except NansException as e:
+                msg = f"[-] ADetailer: 'NansException' occurred with {ordinal(n + 1)} settings.\n{e}"
+                print(msg, file=sys.stderr)
+                continue
+            finally:
+                p2.close()
+
+            self.compare_prompt(p2, processed, n=n)
+            p2 = copy(i2i)
+            p2.init_images = [processed.images[0]]
+
+        if processed is not None:
+            pp.image = processed.images[0]
+            return True
+
+        return False
+
+    @rich_traceback
+    def postprocess_image(self, p, pp, *args_):
+        if getattr(p, "_ad_disabled", False) or not self.is_ad_enabled(*args_):
+            return
+
+        pp.image = self.get_i2i_init_image(p, pp)
+        pp.image = self.ensure_rgb_image(pp.image)
+        init_image = copy(pp.image)
+        arg_list = self.get_args(p, *args_)
+        params_txt_content = Path(paths.data_path, "params.txt").read_text("utf-8")
+
+        if self.need_call_postprocess(p):
+            dummy = Processed(p, [], p.seed, "")
+            with preseve_prompts(p):
+                p.scripts.postprocess(copy(p), dummy)
+
+        is_processed = False
+        with CNHijackRestore(), pause_total_tqdm(), cn_allow_script_control():
+            for n, args in enumerate(arg_list):
+                if args.ad_model == "None":
+                    continue
+                is_processed |= self._postprocess_image_inner(p, pp, args, n=n)
+
+        if is_processed and not getattr(p, "_ad_skip_img2img", False):
+            self.save_image(
+                p, init_image, condition="ad_save_images_before", suffix="-ad-before"
+            )
+
+        if self.need_call_process(p):
+            with preseve_prompts(p):
+                copy_p = copy(p)
+                if hasattr(p.scripts, "before_process"):
+                    p.scripts.before_process(copy_p)
+                p.scripts.process(copy_p)
+
+        self.write_params_txt(params_txt_content)
+
+
+def on_after_component(component, **_kwargs):
+    global txt2img_submit_button, img2img_submit_button
+    if getattr(component, "elem_id", None) == "txt2img_generate":
+        txt2img_submit_button = component
+        return
+
+    if getattr(component, "elem_id", None) == "img2img_generate":
+        img2img_submit_button = component
+
+
+def on_ui_settings():
+    section = ("ADetailer", AFTER_DETAILER)
+    shared.opts.add_option(
+        "ad_max_models",
+        shared.OptionInfo(
+            default=2,
+            label="Max models",
+            component=gr.Slider,
+            component_args={"minimum": 1, "maximum": 10, "step": 1},
+            section=section,
+        ),
+    )
+
+    shared.opts.add_option(
+        "ad_extra_models_dir",
+        shared.OptionInfo(
+            default="",
+            label="Extra path to scan adetailer models",
+            component=gr.Textbox,
+            section=section,
+        ),
+    )
+
+    shared.opts.add_option(
+        "ad_save_previews",
+        shared.OptionInfo(False, "Save mask previews", section=section),
+    )
+
+    shared.opts.add_option(
+        "ad_save_images_before",
+        shared.OptionInfo(False, "Save images before ADetailer", section=section),
+    )
+
+    shared.opts.add_option(
+        "ad_only_seleted_scripts",
+        shared.OptionInfo(
+            True, "Apply only selected scripts to ADetailer", section=section
+        ),
+    )
+
+    textbox_args = {
+        "placeholder": "comma-separated list of script names",
+        "interactive": True,
+    }
+
+    shared.opts.add_option(
+        "ad_script_names",
+        shared.OptionInfo(
+            default=SCRIPT_DEFAULT,
+            label="Script names to apply to ADetailer (separated by comma)",
+            component=gr.Textbox,
+            component_args=textbox_args,
+            section=section,
+        ),
+    )
+
+    shared.opts.add_option(
+        "ad_bbox_sortby",
+        shared.OptionInfo(
+            default="None",
+            label="Sort bounding boxes by",
+            component=gr.Radio,
+            component_args={"choices": BBOX_SORTBY},
+            section=section,
+        ),
+    )
+
+    shared.opts.add_option(
+        "ad_same_seed_for_each_tap",
+        shared.OptionInfo(
+            False, "Use same seed for each tab in adetailer", section=section
+        ),
+    )
+
+
+# xyz_grid
+
+
+class PromptSR(NamedTuple):
+    s: str
+    r: str
+
+
+def set_value(p, x: Any, xs: Any, *, field: str):
+    if not hasattr(p, "_ad_xyz"):
+        p._ad_xyz = {}
+    p._ad_xyz[field] = x
+
+
+def search_and_replace_prompt(p, x: Any, xs: Any, replace_in_main_prompt: bool):
+    if replace_in_main_prompt:
+        p.prompt = p.prompt.replace(xs[0], x)
+        p.negative_prompt = p.negative_prompt.replace(xs[0], x)
+
+    if not hasattr(p, "_ad_xyz_prompt_sr"):
+        p._ad_xyz_prompt_sr = []
+    p._ad_xyz_prompt_sr.append(PromptSR(s=xs[0], r=x))
+
+
+def make_axis_on_xyz_grid():
+    xyz_grid = None
+    for script in scripts.scripts_data:
+        if script.script_class.__module__ == "xyz_grid.py":
+            xyz_grid = script.module
+            break
+
+    if xyz_grid is None:
+        return
+
+    model_list = ["None", *model_mapping.keys()]
+    samplers = [sampler.name for sampler in all_samplers]
+
+    axis = [
+        xyz_grid.AxisOption(
+            "[ADetailer] ADetailer model 1st",
+            str,
+            partial(set_value, field="ad_model"),
+            choices=lambda: model_list,
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] ADetailer prompt 1st",
+            str,
+            partial(set_value, field="ad_prompt"),
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] ADetailer negative prompt 1st",
+            str,
+            partial(set_value, field="ad_negative_prompt"),
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] Prompt S/R (AD 1st)",
+            str,
+            partial(search_and_replace_prompt, replace_in_main_prompt=False),
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] Prompt S/R (AD 1st and main prompt)",
+            str,
+            partial(search_and_replace_prompt, replace_in_main_prompt=True),
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] Mask erosion / dilation 1st",
+            int,
+            partial(set_value, field="ad_dilate_erode"),
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] Inpaint denoising strength 1st",
+            float,
+            partial(set_value, field="ad_denoising_strength"),
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] Inpaint only masked 1st",
+            str,
+            partial(set_value, field="ad_inpaint_only_masked"),
+            choices=lambda: ["True", "False"],
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] Inpaint only masked padding 1st",
+            int,
+            partial(set_value, field="ad_inpaint_only_masked_padding"),
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] ADetailer sampler 1st",
+            str,
+            partial(set_value, field="ad_sampler"),
+            choices=lambda: samplers,
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] ControlNet model 1st",
+            str,
+            partial(set_value, field="ad_controlnet_model"),
+            choices=lambda: ["None", *get_cn_models()],
+        ),
+    ]
+
+    if not any(x.label.startswith("[ADetailer]") for x in xyz_grid.axis_options):
+        xyz_grid.axis_options.extend(axis)
+
+
+def on_before_ui():
+    try:
+        make_axis_on_xyz_grid()
+    except Exception:
+        error = traceback.format_exc()
+        print(
+            f"[-] ADetailer: xyz_grid error:\n{error}",
+            file=sys.stderr,
+        )
+
+
+# api
+
+
+def add_api_endpoints(_: gr.Blocks, app: FastAPI):
+    @app.get("/adetailer/v1/version")
+    def version():
+        return {"version": __version__}
+
+    @app.get("/adetailer/v1/schema")
+    def schema():
+        return ADetailerArgs.schema()
+
+    @app.get("/adetailer/v1/ad_model")
+    def ad_model():
+        return {"ad_model": list(model_mapping)}
+
+
+script_callbacks.on_ui_settings(on_ui_settings)
+script_callbacks.on_after_component(on_after_component)
+script_callbacks.on_app_started(add_api_endpoints)
+script_callbacks.on_before_ui(on_before_ui)

kohya-sd-scripts-webui/.gitignore

@@ -0,0 +1,9 @@
+__pycache__
+venv
+tmp
+
+kohya_ss
+wd14_tagger_model
+presets.json
+meta.json
+presets

kohya-sd-scripts-webui/README.md

@@ -0,0 +1,22 @@
+# kohya sd-scripts webui
+
+[![](https://img.shields.io/static/v1?message=Open%20in%20Colab&logo=googlecolab&labelColor=5c5c5c&color=0f80c1&label=%20&style=for-the-badge)](https://colab.research.google.com/github/ddPn08/kohya-sd-scripts-webui/blob/main/kohya-sd-scripts-webui-colab.ipynb)
+
+Gradio wrapper for [sd-scripts](https://github.com/kohya-ss/sd-scripts) by kohya
+
+It can be used as an extension of [stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) or can be launched standalone.
+
+![](/screenshots/webui-01.png)
+
+# Usage
+## As an extension of stable-diffusion-webui
+
+Go to `Extensions` > `Install from URL`, enter the following URL and press the install button.
+
+https://github.com/ddpn08/kohya-sd-scripts-webui.git
+
+![](/screenshots/installation-extension.png)
+
+## Start standalone
+
+Run `webui.bat` for Windows, `webui.sh` for Linux, MacOS

kohya-sd-scripts-webui/built-in-presets.json

@@ -0,0 +1,126 @@
+{
+    "train_network": {
+        "lora-x512": {
+            "v2": null,
+            "v_parameterization": null,
+            "pretrained_model_name_or_path": null,
+            "train_data_dir": null,
+            "shuffle_caption": true,
+            "caption_extension": ".caption",
+            "caption_extention": null,
+            "keep_tokens": null,
+            "color_aug": null,
+            "flip_aug": true,
+            "face_crop_aug_range": null,
+            "random_crop": null,
+            "debug_dataset": null,
+            "resolution": "512",
+            "cache_latents": null,
+            "enable_bucket": true,
+            "min_bucket_reso": 256,
+            "max_bucket_reso": 1024,
+            "reg_data_dir": null,
+            "in_json": null,
+            "dataset_repeats": 1,
+            "output_dir": null,
+            "output_name": null,
+            "save_precision": null,
+            "save_every_n_epochs": 5,
+            "save_n_epoch_ratio": null,
+            "save_last_n_epochs": null,
+            "save_last_n_epochs_state": null,
+            "save_state": null,
+            "resume": null,
+            "train_batch_size": 1,
+            "max_token_length": null,
+            "use_8bit_adam": true,
+            "mem_eff_attn": null,
+            "xformers": true,
+            "vae": null,
+            "learning_rate": 0.0001,
+            "max_train_steps": 1600,
+            "max_train_epochs": null,
+            "max_data_loader_n_workers": 8,
+            "seed": null,
+            "gradient_checkpointing": true,
+            "gradient_accumulation_steps": 1,
+            "mixed_precision": "no",
+            "full_fp16": null,
+            "clip_skip": 2,
+            "logging_dir": null,
+            "log_prefix": null,
+            "lr_scheduler": "constant",
+            "lr_warmup_steps": 0,
+            "prior_loss_weight": 1.0,
+            "no_metadata": null,
+            "save_model_as": "safetensors",
+            "unet_lr": null,
+            "text_encoder_lr": null,
+            "network_weights": null,
+            "network_module": "networks.lora",
+            "network_dim": 16,
+            "network_alpha": 1.0,
+            "network_args": null,
+            "network_train_unet_only": null,
+            "network_train_text_encoder_only": null,
+            "training_comment": null
+        }
+    },
+    "train_db": {
+        "db-x512": {
+            "v2": null,
+            "v_parameterization": null,
+            "pretrained_model_name_or_path": null,
+            "train_data_dir": null,
+            "shuffle_caption": true,
+            "caption_extension": ".caption",
+            "caption_extention": null,
+            "keep_tokens": null,
+            "color_aug": null,
+            "flip_aug": true,
+            "face_crop_aug_range": null,
+            "random_crop": null,
+            "debug_dataset": null,
+            "resolution": null,
+            "cache_latents": null,
+            "enable_bucket": true,
+            "min_bucket_reso": 256,
+            "max_bucket_reso": 1024,
+            "reg_data_dir": null,
+            "output_dir": null,
+            "output_name": null,
+            "save_precision": null,
+            "save_every_n_epochs": 5,
+            "save_n_epoch_ratio": null,
+            "save_last_n_epochs": null,
+            "save_last_n_epochs_state": null,
+            "save_state": null,
+            "resume": null,
+            "train_batch_size": 1,
+            "max_token_length": null,
+            "use_8bit_adam": true,
+            "mem_eff_attn": null,
+            "xformers": true,
+            "vae": null,
+            "learning_rate": 1e-06,
+            "max_train_steps": 1600,
+            "max_train_epochs": null,
+            "max_data_loader_n_workers": 8,
+            "seed": null,
+            "gradient_checkpointing": null,
+            "gradient_accumulation_steps": 1,
+            "mixed_precision": "no",
+            "full_fp16": null,
+            "clip_skip": 2,
+            "logging_dir": null,
+            "log_prefix": null,
+            "lr_scheduler": "constant",
+            "lr_warmup_steps": 0,
+            "prior_loss_weight": 1.0,
+            "save_model_as": "safetensors",
+            "use_safetensors": null,
+            "no_token_padding": null,
+            "stop_text_encoder_training": null
+        }
+    }
+}

kohya-sd-scripts-webui/install.py

@@ -0,0 +1,116 @@
+import sys
+import launch
+import platform
+import os
+import shutil
+import site
+import glob
+import re
+
+dirname = os.path.dirname(__file__)
+repo_dir = os.path.join(dirname, "kohya_ss")
+
+
+def prepare_environment():
+    torch_command = os.environ.get(
+        "TORCH_COMMAND",
+        "pip install torch==2.0.0+cu118 torchvision==0.15.1+cu118 --extra-index-url https://download.pytorch.org/whl/cu118",
+    )
+    sd_scripts_repo = os.environ.get("SD_SCRIPTS_REPO", "https://github.com/kohya-ss/sd-scripts.git")
+    sd_scripts_branch = os.environ.get("SD_SCRIPTS_BRANCH", "main")
+    requirements_file = os.environ.get("REQS_FILE", "requirements.txt")
+
+    sys.argv, skip_install = launch.extract_arg(sys.argv, "--skip-install")
+    sys.argv, disable_strict_version = launch.extract_arg(
+        sys.argv, "--disable-strict-version"
+    )
+    sys.argv, skip_torch_cuda_test = launch.extract_arg(
+        sys.argv, "--skip-torch-cuda-test"
+    )
+    sys.argv, skip_checkout_repo = launch.extract_arg(sys.argv, "--skip-checkout-repo")
+    sys.argv, update = launch.extract_arg(sys.argv, "--update")
+    sys.argv, reinstall_xformers = launch.extract_arg(sys.argv, "--reinstall-xformers")
+    sys.argv, reinstall_torch = launch.extract_arg(sys.argv, "--reinstall-torch")
+    xformers = "--xformers" in sys.argv
+    ngrok = "--ngrok" in sys.argv
+
+    if skip_install:
+        return
+
+
+    if (
+        reinstall_torch
+        or not launch.is_installed("torch")
+        or not launch.is_installed("torchvision")
+    ) and not disable_strict_version:
+        launch.run(
+            f'"{launch.python}" -m {torch_command}',
+            "Installing torch and torchvision",
+            "Couldn't install torch",
+        )
+
+    if not skip_torch_cuda_test:
+        launch.run_python(
+            "import torch; assert torch.cuda.is_available(), 'Torch is not able to use GPU; add --skip-torch-cuda-test to COMMANDLINE_ARGS variable to disable this check'"
+        )
+
+    if (not launch.is_installed("xformers") or reinstall_xformers) and xformers:
+        launch.run_pip("install xformers --pre", "xformers")
+
+    if update and os.path.exists(repo_dir):
+        launch.run(f'cd "{repo_dir}" && {launch.git} fetch --prune')
+        launch.run(f'cd "{repo_dir}" && {launch.git} reset --hard origin/main')
+    elif not os.path.exists(repo_dir):
+        launch.run(
+            f'{launch.git} clone {sd_scripts_repo} "{repo_dir}"'
+        )
+
+    if not skip_checkout_repo:
+        launch.run(f'cd "{repo_dir}" && {launch.git} checkout {sd_scripts_branch}')
+
+    if not launch.is_installed("gradio"):
+        launch.run_pip("install gradio==3.16.2", "gradio")
+
+    if not launch.is_installed("pyngrok") and ngrok:
+        launch.run_pip("install pyngrok", "ngrok")
+
+    if platform.system() == "Linux":
+        if not launch.is_installed("triton"):
+            launch.run_pip("install triton", "triton")
+
+    if disable_strict_version:
+        with open(os.path.join(repo_dir, requirements_file), "r") as f:
+            txt = f.read()
+            requirements = [
+                re.split("==|<|>", a)[0]
+                for a in txt.split("\n")
+                if (not a.startswith("#") and a != ".")
+            ]
+            requirements = " ".join(requirements)
+            launch.run_pip(
+                f'install "{requirements}" "{repo_dir}"',
+                "requirements for kohya sd-scripts",
+            )
+    else:
+        launch.run(
+            f'cd "{repo_dir}" && "{launch.python}" -m pip install -r requirements.txt',
+            desc=f"Installing requirements for kohya sd-scripts",
+            errdesc=f"Couldn't install requirements for kohya sd-scripts",
+        )
+
+    if platform.system() == "Windows":
+        for file in glob.glob(os.path.join(repo_dir, "bitsandbytes_windows", "*")):
+            filename = os.path.basename(file)
+            for dir in site.getsitepackages():
+                outfile = (
+                    os.path.join(dir, "bitsandbytes", "cuda_setup", filename)
+                    if filename == "main.py"
+                    else os.path.join(dir, "bitsandbytes", filename)
+                )
+                if not os.path.exists(os.path.dirname(outfile)):
+                    continue
+                shutil.copy(file, outfile)
+
+
+if __name__ == "__main__":
+    prepare_environment()

kohya-sd-scripts-webui/kohya-sd-scripts-webui-colab.ipynb

@@ -0,0 +1,157 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "colab_type": "text",
+        "id": "view-in-github"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/ddPn08/kohya-sd-scripts-webui/blob/main/kohya-sd-scripts-webui-colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zSM6HuYmkYCt"
+      },
+      "source": [
+        "# [kohya sd-scripts webui](https://github.com/ddPn08/kohya-sd-scripts-webui)\n",
+        "\n",
+        "This notebook is for running [sd-scripts](https://github.com/kohya-ss/sd-scripts) by [Kohya](https://github.com/kohya-ss).\n",
+        "\n",
+        "このノートブックは[Kohya](https://github.com/kohya-ss)さんによる[sd-scripts](https://github.com/kohya-ss/sd-scripts)を実行するためのものです。\n",
+        "\n",
+        "# Repository\n",
+        "[kohya_ss/sd-scripts](https://github.com/kohya-ss/sd-scripts)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "zXcznGdeyb2I"
+      },
+      "outputs": [],
+      "source": [
+        "! nvidia-smi\n",
+        "! nvcc -V\n",
+        "! free -h"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "id": "tj65Tb_oyxtP"
+      },
+      "outputs": [],
+      "source": [
+        "# @markdown # Mount Google Drive\n",
+        "mount_gdrive = True  # @param {type:\"boolean\"}\n",
+        "gdrive_preset_path = \"/content/drive/MyDrive/AI/kohya-sd-scripts-webui/presets\"  # @param {type:\"string\"}\n",
+        "\n",
+        "if mount_gdrive:\n",
+        "    from google.colab import drive\n",
+        "    drive.mount('/content/drive', force_remount=False)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "id": "FN7UJvSdzBFF"
+      },
+      "outputs": [],
+      "source": [
+        "# @markdown # Initialize environment\n",
+        "\n",
+        "! git clone https://github.com/ddPn08/kohya-sd-scripts-webui.git\n",
+        "\n",
+        "import os\n",
+        "\n",
+        "if not os.path.exists(gdrive_preset_path):\n",
+        "    os.makedirs(gdrive_preset_path, exist_ok=True)\n",
+        "\n",
+        "! rm -f ./kohya-sd-scripts-webui/presets.json\n",
+        "! ln -s {gdrive_preset_path} ./kohya-sd-scripts-webui/presets\n",
+        "\n",
+        "conda_dir = \"/opt/conda\"  # @param{type:\"string\"}\n",
+        "conda_bin = os.path.join(conda_dir, \"bin\", \"conda\")\n",
+        "\n",
+        "if not os.path.exists(conda_bin):\n",
+        "    ! curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh\n",
+        "    ! chmod +x Miniconda3-latest-Linux-x86_64.sh\n",
+        "    ! bash ./Miniconda3-latest-Linux-x86_64.sh -b -f -p {conda_dir}\n",
+        "    ! rm Miniconda3-latest-Linux-x86_64.sh\n",
+        "\n",
+        "def run_script(s):\n",
+        "    ! {s}\n",
+        "\n",
+        "def make_args(d):\n",
+        "    arguments = \"\"\n",
+        "    for k, v in d.items():\n",
+        "        if type(v) == bool:\n",
+        "            arguments += f\"--{k} \" if v else \"\"\n",
+        "        elif type(v) == str and v:\n",
+        "            arguments += f\"--{k} \\\"{v}\\\" \"\n",
+        "        elif v:\n",
+        "            arguments += f\"--{k}={v} \"\n",
+        "    return arguments"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "id": "uetu1lShs6aJ"
+      },
+      "outputs": [],
+      "source": [
+        "# @markdown # Run\n",
+        "\n",
+        "# @markdown <br>\n",
+        "\n",
+        "# @markdown ## Optional | Ngrok Tunnel\n",
+        "# @markdown Get token from [here](https://dashboard.ngrok.com/get-started/your-authtoken)\n",
+        "\n",
+        "ngrok_token = \"\"  # @param {type:\"string\"}\n",
+        "ngrok_region = \"us\"  # @param [\"us\", \"eu\", \"au\", \"ap\", \"sa\", \"jp\", \"in\"]\n",
+        "\n",
+        "arguments = {\n",
+        "    \"ngrok\": ngrok_token,\n",
+        "    \"ngrok-region\": ngrok_region,\n",
+        "    \"share\": ngrok_token is None,\n",
+        "    \"xformers\": True,\n",
+        "    \"enable-console-log\": True\n",
+        "}\n",
+        "\n",
+        "run_script(f\"\"\"\n",
+        "eval \"$({conda_bin} shell.bash hook)\"\n",
+        "cd kohya-sd-scripts-webui\n",
+        "python launch.py {make_args(arguments)}\n",
+        "\"\"\")"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "include_colab_link": true,
+      "provenance": []
+    },
+    "gpuClass": "standard",
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

kohya-sd-scripts-webui/launch.py

@@ -0,0 +1,79 @@
+import install
+import subprocess
+import os
+import sys
+import importlib.util
+
+python = sys.executable
+git = os.environ.get("GIT", "git")
+index_url = os.environ.get("INDEX_URL", "")
+skip_install = False
+
+
+def run(command, desc=None, errdesc=None, custom_env=None):
+    if desc is not None:
+        print(desc)
+
+    result = subprocess.run(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        shell=True,
+        env=os.environ if custom_env is None else custom_env,
+    )
+
+    if result.returncode != 0:
+
+        message = f"""{errdesc or 'Error running command'}.
+Command: {command}
+Error code: {result.returncode}
+stdout: {result.stdout.decode(encoding="utf8", errors="ignore") if len(result.stdout)>0 else '<empty>'}
+stderr: {result.stderr.decode(encoding="utf8", errors="ignore") if len(result.stderr)>0 else '<empty>'}
+"""
+        raise RuntimeError(message)
+
+    return result.stdout.decode(encoding="utf8", errors="ignore")
+
+
+def check_run(command):
+    result = subprocess.run(
+        command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
+    )
+    return result.returncode == 0
+
+
+def is_installed(package):
+    try:
+        spec = importlib.util.find_spec(package)
+    except ModuleNotFoundError:
+        return False
+
+    return spec is not None
+
+
+def run_pip(args, desc=None):
+    if skip_install:
+        return
+
+    index_url_line = f" --index-url {index_url}" if index_url != "" else ""
+    return run(
+        f'"{python}" -m pip {args} --prefer-binary{index_url_line}',
+        desc=f"Installing {desc}",
+        errdesc=f"Couldn't install {desc}",
+    )
+
+
+def run_python(code, desc=None, errdesc=None):
+    return run(f'"{python}" -c "{code}"', desc, errdesc)
+
+
+def extract_arg(args, name):
+    return [x for x in args if x != name], name in args
+
+
+if __name__ == "__main__":
+    install.prepare_environment()
+
+    from scripts import main
+
+    main.launch()

kohya-sd-scripts-webui/main.py

@@ -0,0 +1,14 @@
+import io
+import sys
+import subprocess
+
+ps = subprocess.Popen(
+    [sys.executable, "-u", "./sub.py"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+)
+
+reader = io.TextIOWrapper(ps.stdout, encoding='utf8')
+while ps.poll() is None:
+    char = reader.read(1)
+    if char == '\n':
+        print('break')
+    sys.stdout.write(char)

kohya-sd-scripts-webui/script.js

@@ -0,0 +1,87 @@
+function gradioApp() {
+    const elems = document.getElementsByTagName('gradio-app')
+    const gradioShadowRoot = elems.length == 0 ? null : elems[0].shadowRoot
+    return !!gradioShadowRoot ? gradioShadowRoot : document;
+}
+
+let executed = false
+
+/** @type {(() => void)[]} */
+
+/**
+ * @param {string} tab
+ * @param {boolean} show
+ */
+function kohya_sd_webui__toggle_runner_button(tab, show) {
+    gradioApp().getElementById(`kohya_sd_webui__${tab}_run_button`).style.display = show ? 'block' : 'none'
+    gradioApp().getElementById(`kohya_sd_webui__${tab}_stop_button`).style.display = show ? 'none' : 'block'
+}
+
+window.addEventListener('DOMContentLoaded', () => {
+    const observer = new MutationObserver((m) => {
+        if (!executed && gradioApp().querySelector('#kohya_sd_webui__root')) {
+            executed = true;
+
+            /** @type {Record<string, string>} */
+            const helps = kohya_sd_webui__help_map
+            /** @type {string[]} */
+            const all_tabs = kohya_sd_webui__all_tabs
+
+            const initializeTerminalObserver = () => {
+                const container = gradioApp().querySelector("#kohya_sd_webui__terminal_outputs")
+                const parentContainer = container.parentElement
+                const clearBtn = document.createElement('button')
+                clearBtn.innerText = 'Clear The Terminal'
+                clearBtn.style.color = 'yellow';
+                parentContainer.insertBefore(clearBtn, container)
+                let clearTerminal = false;
+                clearBtn.addEventListener('click', () => {
+                    container.innerHTML = ''
+                    clearTerminal = true
+                })
+                setInterval(async () => {
+                    const res = await fetch('./internal/extensions/kohya-sd-scripts-webui/terminal/outputs', {
+                        method: "POST",
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            output_index: container.children.length,
+                            clear_terminal: clearTerminal,
+                        }),
+                    })
+                    clearTerminal = false
+                    const obj = await res.json()
+                    const isBottom = container.scrollHeight - container.scrollTop === container.clientHeight
+                    for(const line of obj.outputs){
+                        const el = document.createElement('div')
+                        el.innerText = line
+                        container.appendChild(el)
+                    }
+                    if(isBottom) container.scrollTop = container.scrollHeight
+                }, 1000)
+            }
+
+            const checkProcessIsAlive = () => {
+                setInterval(async () => {
+                    const res = await fetch('./internal/extensions/kohya-sd-scripts-webui/process/alive')
+                    const obj = await res.json()
+                    for (const tab of all_tabs)
+                        kohya_sd_webui__toggle_runner_button(tab, !obj.alive)
+
+                }, 1000)
+            }
+
+            initializeTerminalObserver()
+            checkProcessIsAlive()
+
+            for (const tab of all_tabs)
+                gradioApp().querySelector(`#kohya_sd_webui__${tab}_run_button`).addEventListener('click', () => kohya_sd_webui__toggle_runner_button(tab, false))
+
+            for (const [k, v] of Object.entries(helps)) {
+                el = gradioApp().getElementById(k)
+                if (!el) continue
+                el.title = v
+            }
+        }
+    })
+    observer.observe(gradioApp(), { childList: true, subtree: true })
+})

kohya-sd-scripts-webui/scripts/main.py

@@ -0,0 +1,98 @@
+import json
+import os
+import time
+
+import gradio.routes
+
+import scripts.runner as runner
+import scripts.shared as shared
+from scripts.shared import ROOT_DIR, is_webui_extension
+from scripts.ui import create_ui
+
+
+def create_js():
+    jsfile = os.path.join(ROOT_DIR, "script.js")
+    with open(jsfile, mode="r") as f:
+        js = f.read()
+
+    js = js.replace("kohya_sd_webui__help_map", json.dumps(shared.help_title_map))
+    js = js.replace(
+        "kohya_sd_webui__all_tabs",
+        json.dumps(shared.loaded_tabs),
+    )
+    return js
+
+
+def create_head():
+    head = f'<script type="text/javascript">{create_js()}</script>'
+
+    def template_response_for_webui(*args, **kwargs):
+        res = shared.gradio_template_response_original(*args, **kwargs)
+        res.body = res.body.replace(b"</head>", f"{head}</head>".encode("utf8"))
+        return res
+
+    def template_response(*args, **kwargs):
+        res = template_response_for_webui(*args, **kwargs)
+        res.init_headers()
+        return res
+
+    if is_webui_extension():
+        import modules.shared
+
+        modules.shared.GradioTemplateResponseOriginal = template_response_for_webui
+    else:
+        gradio.routes.templates.TemplateResponse = template_response
+
+
+def wait_on_server():
+    while 1:
+        time.sleep(0.5)
+
+
+def on_ui_tabs():
+    cssfile = os.path.join(ROOT_DIR, "style.css")
+    with open(cssfile, mode="r") as f:
+        css = f.read()
+    sd_scripts = create_ui(css)
+    create_head()
+    return [(sd_scripts, "Kohya sd-scripts", "kohya_sd_scripts")]
+
+
+def launch():
+    block, _, _ = on_ui_tabs()[0]
+    if shared.cmd_opts.ngrok is not None:
+        import scripts.ngrok as ngrok
+
+        address = ngrok.connect(
+            shared.cmd_opts.ngrok,
+            shared.cmd_opts.port if shared.cmd_opts.port is not None else 7860,
+            shared.cmd_opts.ngrok_region,
+        )
+        print("Running on ngrok URL: " + address)
+
+    app, local_url, share_url = block.launch(
+        share=shared.cmd_opts.share,
+        server_port=shared.cmd_opts.port,
+        server_name=shared.cmd_opts.host,
+        prevent_thread_lock=True,
+    )
+
+    runner.initialize_api(app)
+
+    wait_on_server()
+
+
+if not hasattr(shared, "gradio_template_response_original"):
+    shared.gradio_template_response_original = gradio.routes.templates.TemplateResponse
+
+if is_webui_extension():
+    from modules import script_callbacks
+
+    def initialize_api(_, app):
+        runner.initialize_api(app)
+
+    script_callbacks.on_ui_tabs(on_ui_tabs)
+    script_callbacks.on_app_started(initialize_api)
+
+if __name__ == "__main__":
+    launch()

kohya-sd-scripts-webui/scripts/ngrok.py

@@ -0,0 +1,28 @@
+def connect(token, port, region):
+    from pyngrok import conf, exception, ngrok
+
+    account = None
+    if token is None:
+        token = "None"
+    else:
+        if ":" in token:
+            account = token.split(":")[1] + ":" + token.split(":")[-1]
+            token = token.split(":")[0]
+
+    config = conf.PyngrokConfig(auth_token=token, region=region)
+    try:
+        if account is None:
+            public_url = ngrok.connect(
+                port, pyngrok_config=config, bind_tls=True
+            ).public_url
+        else:
+            public_url = ngrok.connect(
+                port, pyngrok_config=config, bind_tls=True, auth=account
+            ).public_url
+    except exception.PyngrokNgrokError:
+        print(
+            f"Invalid ngrok authtoken, ngrok connection aborted.\n"
+            f"Your token: {token}, get the right one on https://dashboard.ngrok.com/get-started/your-authtoken"
+        )
+    else:
+        return public_url

kohya-sd-scripts-webui/scripts/presets.py

@@ -0,0 +1,179 @@
+import argparse
+import inspect
+import os
+from pathlib import Path
+import toml
+from kohya_ss.library import train_util, config_util
+
+import gradio as gr
+
+from scripts.shared import ROOT_DIR
+from scripts.utilities import gradio_to_args
+
+PRESET_DIR = os.path.join(ROOT_DIR, "presets")
+PRESET_PATH = os.path.join(ROOT_DIR, "presets.json")
+
+
+def get_arg_templates(fn):
+    parser = argparse.ArgumentParser()
+    args = [parser]
+    sig = inspect.signature(fn)
+    args.extend([True] * (len(sig.parameters) - 1))
+    fn(*args)
+    keys = [
+        x.replace("--", "") for x in parser.__dict__["_option_string_actions"].keys()
+    ]
+    keys = [x for x in keys if x not in ["help", "-h"]]
+    return keys, fn.__name__.replace("add_", "")
+
+
+arguments_functions = [
+    train_util.add_dataset_arguments,
+    train_util.add_optimizer_arguments,
+    train_util.add_sd_models_arguments,
+    train_util.add_sd_saving_arguments,
+    train_util.add_training_arguments,
+    config_util.add_config_arguments,
+]
+
+arg_templates = [get_arg_templates(x) for x in arguments_functions]
+
+
+def load_presets():
+    obj = {}
+    os.makedirs(PRESET_DIR, exist_ok=True)
+    preset_names = os.listdir(PRESET_DIR)
+    for preset_name in preset_names:
+        preset_path = os.path.join(PRESET_DIR, preset_name)
+        obj[preset_name] = {}
+        for key in os.listdir(preset_path):
+            key = key.replace(".toml", "")
+            obj[preset_name][key] = load_preset(preset_name, key)
+    return obj
+
+
+def load_preset(key, name):
+    filepath = os.path.join(PRESET_DIR, key, name + ".toml")
+    if not os.path.exists(filepath):
+        return {}
+    with open(filepath, mode="r") as f:
+        obj = toml.load(f)
+
+    flatten = {}
+    for k, v in obj.items():
+        if not isinstance(v, dict):
+            flatten[k] = v
+        else:
+            for k2, v2 in v.items():
+                flatten[k2] = v2
+    return flatten
+
+
+def save_preset(key, name, value):
+    obj = {}
+    for k, v in value.items():
+        if isinstance(v, Path):
+            v = str(v)
+        for (template, category) in arg_templates:
+            if k in template:
+                if category not in obj:
+                    obj[category] = {}
+                obj[category][k] = v
+                break
+        else:
+            obj[k] = v
+
+    filepath = os.path.join(PRESET_DIR, key, name + ".toml")
+    os.makedirs(os.path.dirname(filepath), exist_ok=True)
+    with open(filepath, mode="w") as f:
+        toml.dump(obj, f)
+
+
+def delete_preset(key, name):
+    filepath = os.path.join(PRESET_DIR, key, name + ".toml")
+    if os.path.exists(filepath):
+        os.remove(filepath)
+
+
+def create_ui(key, tmpls, opts):
+    get_templates = lambda: tmpls() if callable(tmpls) else tmpls
+    get_options = lambda: opts() if callable(opts) else opts
+
+    presets = load_presets()
+
+    if key not in presets:
+        presets[key] = {}
+
+    with gr.Box():
+        with gr.Row():
+            with gr.Column() as c:
+                load_preset_button = gr.Button("Load preset", variant="primary")
+                delete_preset_button = gr.Button("Delete preset")
+            with gr.Column() as c:
+                load_preset_name = gr.Dropdown(
+                    list(presets[key].keys()), show_label=False
+                ).style(container=False)
+                reload_presets_button = gr.Button("🔄️")
+            with gr.Column() as c:
+                c.scale = 0.5
+                save_preset_name = gr.Textbox(
+                    "", placeholder="Preset name", lines=1, show_label=False
+                ).style(container=False)
+                save_preset_button = gr.Button("Save preset", variant="primary")
+
+    def update_dropdown():
+        presets = load_presets()
+        if key not in presets:
+            presets[key] = {}
+        return gr.Dropdown.update(choices=list(presets[key].keys()))
+
+    def _save_preset(args):
+        name = args[save_preset_name]
+        if not name:
+            return update_dropdown()
+        args = gradio_to_args(get_templates(), get_options(), args)
+        save_preset(key, name, args)
+        return update_dropdown()
+
+    def _load_preset(args):
+        name = args[load_preset_name]
+        if not name:
+            return update_dropdown()
+        args = gradio_to_args(get_templates(), get_options(), args)
+        preset = load_preset(key, name)
+        result = []
+        for k, _ in args.items():
+            if k == load_preset_name:
+                continue
+            if k not in preset:
+                result.append(None)
+                continue
+            v = preset[k]
+            if type(v) == list:
+                v = " ".join(v)
+            result.append(v)
+        return result[0] if len(result) == 1 else result
+
+    def _delete_preset(name):
+        if not name:
+            return update_dropdown()
+        delete_preset(key, name)
+        return update_dropdown()
+
+    def init():
+        save_preset_button.click(
+            _save_preset,
+            set([save_preset_name, *get_options().values()]),
+            [load_preset_name],
+        )
+        load_preset_button.click(
+            _load_preset,
+            set([load_preset_name, *get_options().values()]),
+            [*get_options().values()],
+        )
+        delete_preset_button.click(_delete_preset, load_preset_name, [load_preset_name])
+        reload_presets_button.click(
+            update_dropdown, inputs=[], outputs=[load_preset_name]
+        )
+
+    return init

kohya-sd-scripts-webui/scripts/runner.py

@@ -0,0 +1,113 @@
+import io
+import sys
+
+import fastapi
+import gradio as gr
+from pydantic import BaseModel, Field
+
+import scripts.shared as shared
+from scripts.utilities import run_python
+
+proc = None
+outputs = []
+
+
+def alive():
+    return proc is not None
+
+
+def initialize_runner(script_file, tmpls, opts):
+    run_button = gr.Button(
+        "Run",
+        variant="primary",
+        elem_id=f"kohya_sd_webui__{shared.current_tab}_run_button",
+    )
+    stop_button = gr.Button(
+        "Stop",
+        variant="secondary",
+        elem_id=f"kohya_sd_webui__{shared.current_tab}_stop_button",
+    )
+    get_templates = lambda: tmpls() if callable(tmpls) else tmpls
+    get_options = lambda: opts() if callable(opts) else opts
+
+    def run(args):
+        global proc
+        global outputs
+        if alive():
+            return
+        proc = run_python(script_file, get_templates(), get_options(), args)
+        reader = io.TextIOWrapper(proc.stdout, encoding="utf-8-sig")
+        line = ""
+        while proc is not None and proc.poll() is None:
+            try:
+                char = reader.read(1)
+                if shared.cmd_opts.enable_console_log:
+                    sys.stdout.write(char)
+                if char == "\n":
+                    outputs.append(line)
+                    line = ""
+                    continue
+                line += char
+            except:
+                ()
+        proc = None
+
+    def stop():
+        global proc
+        print("killed the running process")
+        proc.kill()
+        proc = None
+
+    def init():
+        run_button.click(
+            run,
+            set(get_options().values()),
+        )
+        stop_button.click(stop)
+
+    return init
+
+
+class GetOutputRequest(BaseModel):
+    output_index: int = Field(
+        default=0, title="Index of the beginning of the log to retrieve"
+    )
+    clear_terminal: bool = Field(
+        default=False, title="Whether to clear the terminal"
+    )
+
+
+class GetOutputResponse(BaseModel):
+    outputs: list = Field(title="List of terminal output")
+
+
+class ProcessAliveResponse(BaseModel):
+    alive: bool = Field(title="Whether the process is running.")
+
+
+def api_get_outputs(req: GetOutputRequest):
+    i = req.output_index
+    if req.clear_terminal:
+        global outputs
+        outputs = []
+    out = outputs[i:] if len(outputs) > i else []
+    return GetOutputResponse(outputs=out)
+
+
+def api_get_isalive(req: fastapi.Request):
+    return ProcessAliveResponse(alive=alive())
+
+
+def initialize_api(app: fastapi.FastAPI):
+    app.add_api_route(
+        "/internal/extensions/kohya-sd-scripts-webui/terminal/outputs",
+        api_get_outputs,
+        methods=["POST"],
+        response_model=GetOutputResponse,
+    )
+    app.add_api_route(
+        "/internal/extensions/kohya-sd-scripts-webui/process/alive",
+        api_get_isalive,
+        methods=["GET"],
+        response_model=ProcessAliveResponse,
+    )

kohya-sd-scripts-webui/scripts/shared.py

@@ -0,0 +1,32 @@
+import argparse
+import importlib
+import os
+import sys
+
+
+def is_webui_extension():
+    try:
+        importlib.import_module("webui")
+        return True
+    except:
+        return False
+
+
+ROOT_DIR = (
+    importlib.import_module("modules.scripts").basedir()
+    if is_webui_extension()
+    else os.path.dirname(os.path.dirname(__file__))
+)
+
+current_tab = None
+loaded_tabs = []
+help_title_map = {}
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--share", action="store_true")
+parser.add_argument("--port", type=int, default=None)
+parser.add_argument("--host", type=str, default=None)
+parser.add_argument("--ngrok", type=str, default=None)
+parser.add_argument("--ngrok-region", type=str, default="us")
+parser.add_argument("--enable-console-log", action="store_true")
+cmd_opts, _ = parser.parse_known_args(sys.argv)

kohya-sd-scripts-webui/scripts/tabs/networks/check_lora_weights.py

@@ -0,0 +1,23 @@
+import gradio as gr
+
+from scripts import ui
+from scripts.runner import initialize_runner
+from scripts.utilities import load_args_template, options_to_gradio
+
+
+def title():
+    return "Check lora wights"
+
+
+def create_ui():
+    options = {}
+    templates, script_file = load_args_template("networks", "check_lora_weights.py")
+
+    with gr.Column():
+        init = initialize_runner(script_file, templates, options)
+        with gr.Box():
+            ui.title("Options")
+            with gr.Column():
+                options_to_gradio(templates, options)
+
+    init()

kohya-sd-scripts-webui/scripts/tabs/networks/extract_lora_from_models.py

@@ -0,0 +1,25 @@
+import gradio as gr
+
+from scripts import ui
+from scripts.runner import initialize_runner
+from scripts.utilities import load_args_template, options_to_gradio
+
+
+def title():
+    return "Extract lora from models"
+
+
+def create_ui():
+    options = {}
+    templates, script_file = load_args_template(
+        "networks", "extract_lora_from_models.py"
+    )
+
+    with gr.Column():
+        init = initialize_runner(script_file, templates, options)
+        with gr.Box():
+            ui.title("Options")
+            with gr.Column():
+                options_to_gradio(templates, options)
+
+    init()

kohya-sd-scripts-webui/scripts/tabs/networks/lora_interrogator.py

@@ -0,0 +1,23 @@
+import gradio as gr
+
+from scripts import ui
+from scripts.runner import initialize_runner
+from scripts.utilities import load_args_template, options_to_gradio
+
+
+def title():
+    return "Lora interrogator"
+
+
+def create_ui():
+    options = {}
+    templates, script_file = load_args_template("networks", "lora_interrogator.py")
+
+    with gr.Column():
+        init = initialize_runner(script_file, templates, options)
+        with gr.Box():
+            ui.title("Options")
+            with gr.Column():
+                options_to_gradio(templates, options)
+
+    init()

kohya-sd-scripts-webui/scripts/tabs/networks/merge_lora.py

@@ -0,0 +1,23 @@
+import gradio as gr
+
+from scripts import ui
+from scripts.runner import initialize_runner
+from scripts.utilities import load_args_template, options_to_gradio
+
+
+def title():
+    return "Merge lora"
+
+
+def create_ui():
+    options = {}
+    templates, script_file = load_args_template("networks", "merge_lora.py")
+
+    with gr.Column():
+        init = initialize_runner(script_file, templates, options)
+        with gr.Box():
+            ui.title("Options")
+            with gr.Column():
+                options_to_gradio(templates, options)
+
+    init()

kohya-sd-scripts-webui/scripts/tabs/networks/resize_lora.py

@@ -0,0 +1,23 @@
+import gradio as gr
+
+from scripts import ui
+from scripts.runner import initialize_runner
+from scripts.utilities import load_args_template, options_to_gradio
+
+
+def title():
+    return "Resize lora"
+
+
+def create_ui():
+    options = {}
+    templates, script_file = load_args_template("networks", "resize_lora.py")
+
+    with gr.Column():
+        init = initialize_runner(script_file, templates, options)
+        with gr.Box():
+            ui.title("Options")
+            with gr.Column():
+                options_to_gradio(templates, options)
+
+    init()

kohya-sd-scripts-webui/scripts/tabs/networks/svd_merge_lora.py

@@ -0,0 +1,23 @@
+import gradio as gr
+
+from scripts import ui
+from scripts.runner import initialize_runner
+from scripts.utilities import load_args_template, options_to_gradio
+
+
+def title():
+    return "Svd merge lora"
+
+
+def create_ui():
+    options = {}
+    templates, script_file = load_args_template("networks", "svd_merge_lora.py")
+
+    with gr.Column():
+        init = initialize_runner(script_file, templates, options)
+        with gr.Box():
+            ui.title("Options")
+            with gr.Column():
+                options_to_gradio(templates, options)
+
+    init()