Upload 44 files

extensions/adetailer/.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -0,0 +1,61 @@
+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
+        Принимаются все языки
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      description: |
+        Description of how we can reproduce this issue.
+
+  - 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

extensions/adetailer/.github/ISSUE_TEMPLATE/feature_request.yaml

@@ -0,0 +1,26 @@
+name: Feature request
+description: Suggest an idea for this project
+title: "[Feature Request]: "
+labels:
+  - enhancement
+
+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.

extensions/adetailer/.github/workflows/pypi.yml

@@ -0,0 +1,26 @@
+name: Publish to PyPI
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  test:
+    name: test
+    uses: ./.github/workflows/test.yml
+
+  build:
+    name: build
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    needs: [test]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build wheel
+        run: pipx run build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

extensions/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@v9
+        with:
+          days-before-stale: 17
+          days-before-close: 3

extensions/adetailer/.github/workflows/test.yml

@@ -0,0 +1,30 @@
+name: Test
+
+on:
+  pull_request:
+    paths:
+      - "adetailer/**.py"
+  workflow_call:
+  schedule:
+    - cron: "0 0 * * 0"
+
+jobs:
+  test:
+    name: Test on python ${{ matrix.python-version }}
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.10"
+          - "3.11"
+          - "3.12"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Run tests
+        run: uv run --all-extras pytest -v

extensions/adetailer/.gitignore

@@ -0,0 +1,198 @@
+# 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
+node_modules
+modules

extensions/adetailer/.pre-commit-config.yaml

@@ -0,0 +1,31 @@
+ci:
+  autoupdate_branch: "dev"
+
+exclude: ^modules/
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: check-added-large-files
+        args: [--maxkb=100]
+      - id: check-merge-conflict
+      - id: check-case-conflict
+      - id: check-ast
+      - id: check-yaml
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+
+  - repo: https://github.com/rbubley/mirrors-prettier
+    rev: v3.5.3
+    hooks:
+      - id: prettier
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.9.9
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+      - id: ruff-format

extensions/adetailer/.vscode/extensions.json

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

extensions/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"
+  }
+}

extensions/adetailer/CHANGELOG.md

@@ -0,0 +1,501 @@
+# Changelog
+
+## 2025-03-10
+
+- v25.3.0
+- unsafe pickling 방법 변경
+
+## 2024-11-13
+
+- v24.11.1
+- `mediapipe_face_mesh`, `mediapipe_face_mesh_eyes_only` 모델에 confidences가 없어 발생하는 에러 수정
+
+## 2024-11-10
+
+- v24.11.0
+- `disable_controlnet_units` 함수가 `script_args`의 상태를 변경된 상태로 저장하는 문제 수정
+- XYZ Grid에 CFG Scale, scheduler, noise multiplier 추가
+- Area 또는 Confidence를 기준으로 마스크 최대 갯수를 지정할 수 있도록 함 (PR #720)
+
+- `ADetailer detector classes`의 element id를 `ad_classes`에서 `ad_model_classes`로 변경
+- `mediapipe` 최대 버전을 0.10.15로 제한
+
+## 2024-09-02
+
+- v24.9.0
+- Dynamic Denoising, Inpaint bbox sizing 기능 (PR #678)
+- `ad_save_images_dir` 옵션 추가 - ad 이미지를 저장하는 장소 지정 (PR #689)
+
+- forge와 관련된 버그 몇 개 수정
+- pydantic validation에 실패해도 에러를 일으키지 않고 넘어가도록 수정
+
+## 2024-08-03
+
+- v24.8.0
+- 샘플러 선택칸에 Use same sampler 옵션 추가
+- 컨트롤넷 유니온 모델을 선택할 수 있게 함
+
+- webui 1.9.0이상에서 기본 스케줄러가 설정되지 않던 문제 수정
+- issus #656의 문제 해결을 위해 v24.4.0에 적용되었던 프롬프트 표시 기능을 되돌림
+- mediapipe에서 에러가 발생하면 추론이 실패한 것으로 처리하고 조용히 넘어감
+
+## 2024-06-16
+
+- v24.6.0
+- webui 1.6.0 미만 버전을 위한 기능들을 제거하고, 최소 버전을 1.6.0으로 올림
+- 허깅페이스 연결을 체크하는데 1초만 소요되도록 함
+  - 허깅페이스 미러 (hf-mirror.com)도 체크함 (합쳐서 2초)
+- InputAccordion을 적용함
+
+## 2024-05-20
+
+- v24.5.1
+- uv를 사용하지 않게 함
+- 모든 허깅페이스 모델을 동시에 다운로드 시도함
+- 기본 탭 수를 2에서 4로 변경
+
+## 2024-05-19
+
+- v24.5.0
+- 개별 탭 활성화/비활성화 체크박스 추가
+- ad_extra_model_dir 옵션에 |로 구분된 여러 디렉토리를 추가할 수 있게 함 (PR #596)
+- `hypertile` 빌트인 확장이 지원되도록 함
+- 항상 cond 캐시를 비움
+- 설치 스크립트에 uv를 사용함
+- mediapipe 최소 버전을 올려 protobuf 버전 4를 사용하게 함
+
+## 2024-04-17
+
+- v24.4.2
+- `params.txt` 파일이 없을 때 에러가 발생하지 않도록 수정
+- 파이썬 3.9 이하에서 유니온 타입 에러 방지
+
+## 2024-04-14
+
+- v24.4.1
+- webui 1.9.0에서 발생한 에러 수정
+  - extra generation params에 callable이 들어와서 생긴 문제
+  - assign_current_image에 None이 들어갈 수 있던 문제
+- webui 1.9.0에서 변경된 scheduler 지원
+- 컨트롤넷 모델을 찾을 때, 대소문자 구분을 하지 않음 (PR #577)
+- 몇몇 기능을 스크립트에서 분리하여 별도 파일로 빼냄
+
+## 2024-04-10
+
+- v24.4.0
+- txt2img에서 hires를 설정했을 때, 이미지의 exif에서 Denoising Strength가 adetailer의 denoisiog stregnth로 덮어 쓰이는 문제 수정
+- ad prompt, ad negative prompt에 프롬프트를 변경하는 기능을 적용했을 때(와일드카드 등), 적용된 프롬프트가 이미지의 exif에 제대로 표시됨
+
+## 2024-03-29
+
+- v24.3.5
+- 알 수 없는 이유로 인페인팅을 확인하는 과정에서 Txt2Img 인스턴스가 들어오는 문제에 대한 임시 해결
+
+## 2024-03-28
+
+- v24.3.4
+- 인페인트에서, 이미지 해상도가 16의 배수가 아닐 때 사이즈 불일치로 인한 opencv 에러 방지
+
+## 2024-03-25
+
+- v24.3.3
+- webui 1.6.0 미만 버전에서 create_binary_mask 함수에 대해 ImportError가 발생하는 것 수정
+
+## 2024-03-21
+
+- v24.3.2
+- UI를 거치지 않은 입력에 대해, image_mask를 입력했을 때 opencv 에러가 발생하는 것 수정
+- img2img inpaint에서 skip img2img 옵션을 활성화할 경우, adetailer를 비활성화함
+  - 마스크 크기에 대해 해결하기 힘든 문제가 있음
+
+## 2024-03-16
+
+- v24.3.1
+- YOLO World v2, YOLO9 지원가능한 버전으로 ultralytics 업데이트
+- inpaint full res인 경우 인페인트 모드에서 동작하게 변경
+- inpaint full res가 아닌 경우, 사용자가 입력한 마스크와 교차점이 있는 마스크만 선택하여 사용함
+
+## 2024-03-01
+
+- v24.3.0
+- YOLO World 모델 추가: 가장 큰 yolov8x-world.pt 모델만 기본적으로 선택할 수 있게 함.
+- lllyasviel/stable-diffusion-webui-forge에서 컨트롤넷을 사용가능하게 함 (PR #517)
+- 기본 스크립트 목록에 soft_inpainting 추가 (https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/14208)
+
+  - 기존에 설치한 사람에게 소급적용되지는 않음
+
+- 감지모델에 대한 간단한 pytest 추가함
+- xyz grid 컨트롤넷 모델 옵션에 `Passthrough` 추가함
+
+## 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.

extensions/adetailer/LICENSE.md

@@ -0,0 +1,661 @@
+                    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/>.

extensions/adetailer/README.md

@@ -0,0 +1,118 @@
+# ADetailer
+
+ADetailer is an extension for the stable diffusion webui that does automatic masking and inpainting. It is similar to the Detection Detailer.
+
+## Install
+
+You can install it directly from the Extensions tab.
+
+![image](https://i.imgur.com/qaXtoI6.png)
+
+Or
+
+(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.)
+
+## Options
+
+| Model, Prompts                    |                                                                                    |                                                                                                                                                        |
+| --------------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ADetailer model                   | Determine what to detect.                                                          | `None` = disable                                                                                                                                       |
+| ADetailer model classes           | Comma separated class names to detect. only available when using YOLO World models | If blank, use default values.<br/>default = [COCO 80 classes](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) |
+| 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, depth` controlnet models. Once you choose a model, the preprocessor is set automatically. It works separately from the model set by the Controlnet extension.
+
+If you select `Passthrough`, the controlnet settings you set outside of ADetailer will be used.
+
+## Advanced Options
+
+API request example: [wiki/REST-API](https://github.com/Bing-su/adetailer/wiki/REST-API)
+
+`[SEP], [SKIP], [PROMPT]` 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)
+
+- 📜 [ADetailer Installation and 5 Usage Methods](https://kindanai.com/en/manual-adetailer/)
+
+## 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).
+
+For a detailed description of the YOLO8 model, see: https://docs.ultralytics.com/models/yolov8/#overview
+
+YOLO World model: https://docs.ultralytics.com/models/yolo-world/
+
+### Additional Model
+
+Put your [ultralytics](https://github.com/ultralytics/ultralytics) yolo model in `models/adetailer`. The model name should end with `.pt`.
+
+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.
+
+## Development
+
+ADetailer is developed and tested using the stable-diffusion 1.5 model, for the latest version of [AUTOMATIC1111/stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) repository only.
+
+## License
+
+ADetailer is a derivative work that uses two AGPL-licensed works (stable-diffusion-webui, ultralytics) and is therefore distributed under the AGPL license.
+
+## See Also
+
+- https://github.com/ototadana/sd-face-editor
+- https://github.com/continue-revolution/sd-webui-segment-anything
+- https://github.com/portu-sim/sd-webui-bmab

extensions/adetailer/Taskfile.yml

@@ -0,0 +1,31 @@
+# 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 {{ .CLI_ARGS }}"
+    silent: true
+
+  lint:
+    cmds:
+      - pre-commit run -a
+
+  update:
+    cmds:
+      - "{{.PYTHON}} -m uv pip install -U ultralytics mediapipe ruff pre-commit-uv black devtools pytest hypothesis"
+
+  update-torch:
+    cmds:
+      - "{{.PYTHON}} -m uv pip install -U torch torchvision torchaudio xformers --extra-index-url https://download.pytorch.org/whl/cu126"

extensions/adetailer/aaaaaa/conditional.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+msg = "[-] ADetailer: WebUI versions below 1.6.0 are not supported."
+
+try:
+    from modules.processing import create_binary_mask  # noqa: F401
+except ImportError as e:
+    raise RuntimeError(msg) from e
+
+
+try:
+    from modules.ui_components import InputAccordion  # noqa: F401
+except ImportError as e:
+    raise RuntimeError(msg) from e
+
+
+try:
+    from modules.sd_schedulers import schedulers
+except ImportError:
+    # webui < 1.9.0
+    schedulers = []

extensions/adetailer/aaaaaa/helper.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import os
+from contextlib import contextmanager
+from copy import copy
+from typing import TYPE_CHECKING, Any, Union
+from unittest.mock import patch
+
+import torch
+from PIL import Image
+from typing_extensions import Protocol
+
+from modules import safe
+from modules.shared import cmd_opts, opts
+
+if TYPE_CHECKING:
+    # 타입 체커가 빨간 줄을 긋지 않게 하는 편법
+    from types import SimpleNamespace
+
+    StableDiffusionProcessingTxt2Img = SimpleNamespace
+    StableDiffusionProcessingImg2Img = SimpleNamespace
+else:
+    from modules.processing import (
+        StableDiffusionProcessingImg2Img,
+        StableDiffusionProcessingTxt2Img,
+    )
+
+PT = Union[StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img]
+
+
+@contextmanager
+def change_torch_load():
+    orig = torch.load
+    try:
+        torch.load = safe.unsafe_torch_load
+        yield
+    finally:
+        torch.load = orig
+
+
+@contextmanager
+def disable_safe_unpickle():
+    with (
+        patch.dict(os.environ, {"TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD": "1"}, clear=False),
+        patch.object(cmd_opts, "disable_safe_unpickle", True),
+    ):
+        yield
+
+
+@contextmanager
+def pause_total_tqdm():
+    with patch.dict(opts.data, {"multiple_tqdm": False}, clear=False):
+        yield
+
+
+@contextmanager
+def preserve_prompts(p: PT):
+    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
+
+
+def copy_extra_params(extra_params: dict[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in extra_params.items() if not callable(v)}
+
+
+class PPImage(Protocol):
+    image: Image.Image

extensions/adetailer/aaaaaa/p_method.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+
+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
+
+
+def need_call_postprocess(p) -> bool:
+    if p.scripts is None:
+        return False
+    return p.batch_index == 0
+
+
+def is_img2img_inpaint(p) -> bool:
+    return hasattr(p, "image_mask") and p.image_mask is not None
+
+
+def is_inpaint_only_masked(p) -> bool:
+    return hasattr(p, "inpaint_full_res") and p.inpaint_full_res
+
+
+def get_i(p) -> int:
+    it = p.iteration
+    bs = p.batch_size
+    i = p.batch_index
+    return it * bs + i
+
+
+def is_skip_img2img(p) -> bool:
+    return getattr(p, "_ad_skip_img2img", False)

extensions/adetailer/aaaaaa/traceback.py

@@ -0,0 +1,175 @@
+from __future__ import annotations  # noqa: A005
+
+import io
+import platform
+import sys
+from collections.abc import Callable
+from importlib.metadata import version
+from typing import Any, TypeVar
+
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.traceback import Traceback
+from typing_extensions import ParamSpec
+
+from adetailer.__version__ import __version__
+from adetailer.args import ADetailerArgs
+
+
+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 = []
+    for arg in args:
+        if not isinstance(arg, dict):
+            continue
+
+        try:
+            a = ADetailerArgs(**arg)
+        except ValueError:
+            continue
+
+        if not a.need_skip():
+            ad_args.append(a)
+
+    if not ad_args:
+        return {}
+
+    arg0 = ad_args[0]
+    return {
+        "version": __version__,
+        "ad_model": arg0.ad_model,
+        "ad_prompt": arg0.ad_prompt,
+        "ad_negative_prompt": arg0.ad_negative_prompt,
+        "ad_controlnet_model": arg0.ad_controlnet_model,
+        "is_api": arg0.is_api,
+    }
+
+
+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)  # noqa: PLW2901
+        table.add_row(key, value)
+
+    return table
+
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def rich_traceback(func: Callable[P, T]) -> Callable[P, T]:
+    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

extensions/adetailer/aaaaaa/ui.py

@@ -0,0 +1,720 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import partial
+from itertools import chain
+from types import SimpleNamespace
+from typing import Any
+
+import gradio as gr
+
+from aaaaaa.conditional import InputAccordion
+from adetailer import ADETAILER, __version__
+from adetailer.args import ALL_ARGS, MASK_MERGE_INVERT
+from controlnet_ext import controlnet_exists, controlnet_type, get_cn_models
+
+if controlnet_type == "forge":
+    from lib_controlnet import global_state
+
+    cn_module_choices = {
+        "inpaint": list(global_state.get_filtered_preprocessors("Inpaint")),
+        "lineart": list(global_state.get_filtered_preprocessors("Lineart")),
+        "openpose": list(global_state.get_filtered_preprocessors("OpenPose")),
+        "tile": list(global_state.get_filtered_preprocessors("Tile")),
+        "scribble": list(global_state.get_filtered_preprocessors("Scribble")),
+        "depth": list(global_state.get_filtered_preprocessors("Depth")),
+    }
+else:
+    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"],
+    }
+
+union = list(chain.from_iterable(cn_module_choices.values()))
+cn_module_choices["union"] = union
+
+
+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]
+    scheduler_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  # noqa: PERF403
+    state["is_api"] = ()
+    return state
+
+
+def on_ad_model_update(model: str):
+    if "-world" in model:
+        return gr.update(
+            visible=True,
+            placeholder="Comma separated class names to detect, ex: 'person,cat'. default: COCO 80 classes",
+        )
+    return gr.update(visible=False, placeholder="")
+
+
+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:
+    tab = "img2img" if is_img2img else "txt2img"
+    suf = suffix(n, "_")
+    return f"script_{tab}_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 InputAccordion(
+        value=False,
+        elem_id=eid("ad_main_accordion"),
+        label=ADETAILER,
+        visible=True,
+    ) as ad_enable:
+        with gr.Row():
+            with gr.Column(scale=8):
+                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, 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)
+
+    model_choices = (
+        [*webui_info.ad_model_list, "None"]
+        if n == 0
+        else ["None", *webui_info.ad_model_list]
+    )
+
+    with gr.Group():
+        with gr.Row(variant="compact"):
+            w.ad_tab_enable = gr.Checkbox(
+                label=f"Enable this tab ({ordinal(n + 1)})",
+                value=True,
+                visible=True,
+                elem_id=eid("ad_tab_enable"),
+            )
+
+        with gr.Row():
+            w.ad_model = gr.Dropdown(
+                label="ADetailer detector" + suffix(n),
+                choices=model_choices,
+                value=model_choices[0],
+                visible=True,
+                type="value",
+                elem_id=eid("ad_model"),
+                info="Select a model to use for detection.",
+            )
+
+        with gr.Row():
+            w.ad_model_classes = gr.Textbox(
+                label="ADetailer detector classes" + suffix(n),
+                value="",
+                visible=False,
+                elem_id=eid("ad_model_classes"),
+            )
+
+            w.ad_model.change(
+                on_ad_model_update,
+                inputs=w.ad_model,
+                outputs=w.ad_model_classes,
+                queue=False,
+            )
+
+    gr.HTML("<br>")
+
+    with gr.Group():
+        with gr.Row(elem_id=eid("ad_toprow_prompt")):
+            w.ad_prompt = gr.Textbox(
+                value="",
+                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(
+                value="",
+                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_filter_method = gr.Radio(
+                choices=["Area", "Confidence"],
+                value="Area",
+                label="Method to filter top k masks by (confidence or area)"
+                + suffix(n),
+                visible=True,
+                elem_id=eid("ad_mask_filter_method"),
+            )
+            w.ad_mask_k = gr.Slider(
+                label="Mask only the top k (0 to disable)" + suffix(n),
+                minimum=0,
+                maximum=10,
+                step=1,
+                value=0,
+                visible=True,
+                elem_id=eid("ad_mask_k"),
+            )
+
+        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"),
+                info="None: do nothing, Merge: merge masks, Merge and Invert: merge all masks and invert",
+            )
+
+
+def inpainting(w: Widgets, n: int, is_img2img: bool, webui_info: WebuiInfo):  # noqa: PLR0915
+    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"),
+            )
+
+            sampler_names = [
+                "Use same sampler",
+                *webui_info.sampler_names,
+            ]
+
+            with gr.Row():
+                w.ad_sampler = gr.Dropdown(
+                    label="ADetailer sampler" + suffix(n),
+                    choices=sampler_names,
+                    value=sampler_names[1],
+                    visible=True,
+                    elem_id=eid("ad_sampler"),
+                )
+
+                scheduler_names = [
+                    "Use same scheduler",
+                    *webui_info.scheduler_names,
+                ]
+                w.ad_scheduler = gr.Dropdown(
+                    label="ADetailer scheduler" + suffix(n),
+                    choices=scheduler_names,
+                    value=scheduler_names[0],
+                    visible=len(scheduler_names) > 1,
+                    elem_id=eid("ad_scheduler"),
+                )
+
+                w.ad_use_sampler.change(
+                    lambda value: (gr_interactive(value), gr_interactive(value)),
+                    inputs=w.ad_use_sampler,
+                    outputs=[w.ad_sampler, w.ad_scheduler],
+                    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"),
+            )

extensions/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
+
+ADETAILER = "ADetailer"
+
+__all__ = [
+    "ADETAILER",
+    "ALL_ARGS",
+    "ADetailerArgs",
+    "PredictOutput",
+    "__version__",
+    "get_models",
+    "mediapipe_predict",
+    "ultralytics_predict",
+]

extensions/adetailer/adetailer/__version__.py

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

extensions/adetailer/adetailer/args.py

@@ -0,0 +1,299 @@
+from __future__ import annotations
+
+from collections import UserList
+from dataclasses import dataclass
+from enum import Enum
+from functools import cached_property, partial
+from typing import Any, Literal, NamedTuple, Optional
+
+try:
+    from pydantic.v1 import (
+        BaseModel,
+        Extra,
+        NonNegativeFloat,
+        NonNegativeInt,
+        PositiveInt,
+        confloat,
+        conint,
+        validator,
+    )
+except ImportError:
+    from pydantic import (
+        BaseModel,
+        Extra,
+        NonNegativeFloat,
+        NonNegativeInt,
+        PositiveInt,
+        confloat,
+        conint,
+        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_model_classes: str = ""
+    ad_tab_enable: bool = True
+    ad_prompt: str = ""
+    ad_negative_prompt: str = ""
+    ad_confidence: confloat(ge=0.0, le=1.0) = 0.3
+    ad_mask_filter_method: Literal["Area", "Confidence"] = "Area"
+    ad_mask_k: 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_scheduler: str = "Use same scheduler"
+    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.need_skip():
+            return {}
+
+        p = {name: getattr(self, attr) for attr, name in ALL_ARGS}
+        ppop = partial(self.ppop, p)
+
+        ppop("ADetailer model classes")
+        ppop("ADetailer prompt")
+        ppop("ADetailer negative prompt")
+        p.pop("ADetailer tab enable", None)  # always pop
+        ppop(
+            "ADetailer mask only top k",
+            ["ADetailer mask only top k", "ADetailer method to decide top k masks"],
+            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",
+                "ADetailer scheduler",
+            ],
+        )
+        ppop("ADetailer scheduler", cond="Use same scheduler")
+        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
+
+    def is_mediapipe(self) -> bool:
+        return self.ad_model.lower().startswith("mediapipe")
+
+    def need_skip(self) -> bool:
+        return self.ad_model == "None" or self.ad_tab_enable is False
+
+
+_all_args = [
+    ("ad_model", "ADetailer model"),
+    ("ad_model_classes", "ADetailer model classes"),
+    ("ad_tab_enable", "ADetailer tab enable"),
+    ("ad_prompt", "ADetailer prompt"),
+    ("ad_negative_prompt", "ADetailer negative prompt"),
+    ("ad_confidence", "ADetailer confidence"),
+    ("ad_mask_filter_method", "ADetailer method to decide top k masks"),
+    ("ad_mask_k", "ADetailer mask only top k"),
+    ("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_scheduler", "ADetailer scheduler"),
+    ("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"]
+
+_script_default = (
+    "dynamic_prompting",
+    "dynamic_thresholding",
+    "wildcard_recursive",
+    "wildcards",
+    "lora_block_weight",
+    "negpip",
+)
+SCRIPT_DEFAULT = ",".join(sorted(_script_default))
+
+_builtin_script = ("soft_inpainting", "hypertile_script")
+BUILTIN_SCRIPT = ",".join(sorted(_builtin_script))
+
+
+class InpaintBBoxMatchMode(Enum):
+    OFF = "Off"
+    STRICT = "Strict (SDXL only)"
+    FREE = "Free"
+
+
+INPAINT_BBOX_MATCH_MODES = [
+    InpaintBBoxMatchMode.OFF.value,
+    InpaintBBoxMatchMode.STRICT.value,
+    InpaintBBoxMatchMode.FREE.value,
+]

extensions/adetailer/adetailer/common.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import os
+from collections import OrderedDict
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import suppress
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Generic, Optional, TypeVar
+
+from huggingface_hub import hf_hub_download
+from PIL import Image, ImageDraw
+from rich import print  # noqa: A004  Shadowing built-in 'print'
+from torchvision.transforms.functional import to_pil_image
+
+REPO_ID = "Bingsu/adetailer"
+
+T = TypeVar("T", int, float)
+
+
+@dataclass
+class PredictOutput(Generic[T]):
+    bboxes: list[list[T]] = field(default_factory=list)
+    masks: list[Image.Image] = field(default_factory=list)
+    confidences: list[float] = field(default_factory=list)
+    preview: Optional[Image.Image] = None
+
+
+def hf_download(file: str, repo_id: str = REPO_ID, check_remote: bool = True) -> str:
+    if check_remote:
+        with suppress(Exception):
+            return hf_hub_download(repo_id, file, etag_timeout=1)
+
+        with suppress(Exception):
+            return hf_hub_download(
+                repo_id, file, etag_timeout=1, endpoint="https://hf-mirror.com"
+            )
+
+    with suppress(Exception):
+        return hf_hub_download(repo_id, file, local_files_only=True)
+
+    if check_remote:
+        msg = f"[-] ADetailer: Failed to load model {file!r} from huggingface"
+        print(msg)
+    return "INVALID"
+
+
+def safe_mkdir(path: str | os.PathLike[str]) -> None:
+    path = Path(path)
+    if not path.exists() and path.parent.exists() and os.access(path.parent, os.W_OK):
+        path.mkdir()
+
+
+def scan_model_dir(path: Path) -> list[Path]:
+    if not path.is_dir():
+        return []
+    return [p for p in path.rglob("*") if p.is_file() and p.suffix == ".pt"]
+
+
+def download_models(*names: str, check_remote: bool = True) -> dict[str, str]:
+    models = OrderedDict()
+    with ThreadPoolExecutor() as executor:
+        for name in names:
+            if "-world" in name:
+                models[name] = executor.submit(
+                    hf_download,
+                    name,
+                    repo_id="Bingsu/yolo-world-mirror",
+                    check_remote=check_remote,
+                )
+            else:
+                models[name] = executor.submit(
+                    hf_download,
+                    name,
+                    check_remote=check_remote,
+                )
+    return {name: future.result() for name, future in models.items()}
+
+
+def get_models(
+    *dirs: str | os.PathLike[str], huggingface: bool = True
+) -> OrderedDict[str, str]:
+    model_paths = []
+
+    for dir_ in dirs:
+        if not dir_:
+            continue
+        model_paths.extend(scan_model_dir(Path(dir_)))
+
+    models = OrderedDict()
+    to_download = [
+        "face_yolov8n.pt",
+        "face_yolov8s.pt",
+        "hand_yolov8n.pt",
+        "person_yolov8n-seg.pt",
+        "person_yolov8s-seg.pt",
+        "yolov8x-worldv2.pt",
+    ]
+    models.update(download_models(*to_download, check_remote=huggingface))
+
+    models.update(
+        {
+            "mediapipe_face_full": "mediapipe_face_full",
+            "mediapipe_face_short": "mediapipe_face_short",
+            "mediapipe_face_mesh": "mediapipe_face_mesh",
+            "mediapipe_face_mesh_eyes_only": "mediapipe_face_mesh_eyes_only",
+        }
+    )
+
+    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)  # noqa: PLW2901
+        bbox = mask.getbbox()
+        if bbox is not None:
+            bboxes.append(list(bbox))
+    return bboxes
+
+
+def ensure_pil_image(image: Any, mode: str = "RGB") -> Image.Image:
+    if not isinstance(image, Image.Image):
+        image = to_pil_image(image)
+    if image.mode != mode:
+        image = image.convert(mode)
+    return image

extensions/adetailer/adetailer/mask.py

@@ -0,0 +1,292 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from functools import partial, reduce
+from math import dist
+from typing import Any, TypeVar
+
+import cv2
+import numpy as np
+from PIL import Image, ImageChops
+
+from adetailer.args import MASK_MERGE_INVERT
+from adetailer.common import PredictOutput, ensure_pil_image
+
+
+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
+
+
+T = TypeVar("T", int, float)
+
+
+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 | np.ndarray) -> bool:
+    if isinstance(img, Image.Image):
+        img = np.array(ensure_pil_image(img, "L"))
+    return cv2.countNonZero(img) == 0
+
+
+def has_intersection(im1: Any, im2: Any) -> bool:
+    arr1 = np.array(ensure_pil_image(im1, "L"))
+    arr2 = np.array(ensure_pil_image(im2, "L"))
+    return not is_all_black(cv2.bitwise_and(arr1, arr2))
+
+
+def bbox_area(bbox: list[T]) -> T:
+    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[T]) -> T:
+    """
+    Left to right
+
+    Parameters
+    ----------
+    bbox: list[int] | list[float]
+        list of [x1, y1, x2, y2]
+    """
+    return bbox[0]
+
+
+def _key_center_to_edge(bbox: list[T], *, center: tuple[float, float]) -> float:
+    """
+    Center to edge
+
+    Parameters
+    ----------
+    bbox: list[int] | 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[T]) -> T:
+    """
+    Large to small
+
+    Parameters
+    ----------
+    bbox: list[int] | list[float]
+        list of [x1, y1, x2, y2]
+    """
+    return -bbox_area(bbox)
+
+
+def sort_bboxes(
+    pred: PredictOutput[T], order: int | SortBy = SortBy.NONE
+) -> PredictOutput[T]:
+    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[T], low: float, high: float, orig_area: int) -> bool:
+    area = bbox_area(bbox)
+    return low <= area / orig_area <= high
+
+
+def filter_by_ratio(
+    pred: PredictOutput[T], low: float, high: float
+) -> PredictOutput[T]:
+    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]
+    pred.confidences = [pred.confidences[i] for i in idx]
+    return pred
+
+
+def filter_k_largest(pred: PredictOutput[T], k: int = 0) -> PredictOutput[T]:
+    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]
+    pred.confidences = [pred.confidences[i] for i in idx]
+    return pred
+
+
+def filter_k_most_confident(pred: PredictOutput[T], k: int = 0) -> PredictOutput[T]:
+    if not pred.bboxes or not pred.confidences or k == 0:
+        return pred
+    idx = np.argsort(pred.confidences)[-k:]
+    idx = idx[::-1]
+    pred.bboxes = [pred.bboxes[i] for i in idx]
+    pred.masks = [pred.masks[i] for i in idx]
+    pred.confidences = [pred.confidences[i] for i in idx]
+    return pred
+
+
+def filter_k_by(
+    pred: PredictOutput[T], k: int = 0, by: str = "Area"
+) -> PredictOutput[T]:
+    if by == "Area":
+        return filter_k_largest(pred, k)
+    if by == "Confidence":
+        return filter_k_most_confident(pred, k)
+    raise RuntimeError
+
+
+# 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

extensions/adetailer/adetailer/mediapipe.py

@@ -0,0 +1,189 @@
+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]
+        try:
+            return func(image, confidence)
+        except Exception:
+            return PredictOutput()
+    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[float]:
+    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 = []
+    confidences = []
+    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
+
+        confidences.append(detection.score)
+        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, confidences=confidences, preview=preview
+    )
+
+
+def mediapipe_face_mesh(
+    image: Image.Image, confidence: float = 0.3
+) -> PredictOutput[int]:
+    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 = []
+        confidences = []
+
+        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.array(
+                [[land.x * w, land.y * h] for land in landmarks.landmark], dtype=int
+            )
+            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)
+            confidences.append(1.0)  # Confidence is unknown
+
+        bboxes = create_bbox_from_mask(masks, image.size)
+        preview = Image.fromarray(preview)
+        return PredictOutput(
+            bboxes=bboxes, masks=masks, confidences=confidences, preview=preview
+        )
+
+
+def mediapipe_face_mesh_eyes_only(
+    image: Image.Image, confidence: float = 0.3
+) -> PredictOutput[int]:
+    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 = []
+        confidences = []
+
+        for landmarks in pred.multi_face_landmarks:
+            points = np.array(
+                [[land.x * w, land.y * h] for land in landmarks.landmark], dtype=int
+            )
+            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)
+            confidences.append(1.0)  # Confidence is unknown
+
+        bboxes = create_bbox_from_mask(masks, image.size)
+        preview = draw_preview(preview, bboxes, masks)
+        return PredictOutput(
+            bboxes=bboxes, masks=masks, confidences=confidences, 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

extensions/adetailer/adetailer/opts.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import ClassVar, TypeVar
+
+import numpy as np
+
+T = TypeVar("T", int, float)
+
+
+def dynamic_denoise_strength(
+    denoise_power: float,
+    denoise_strength: float,
+    bbox: Sequence[T],
+    image_size: tuple[int, int],
+) -> float:
+    if len(bbox) != 4:
+        msg = f"bbox length must be 4, got {len(bbox)}"
+        raise ValueError(msg)
+
+    if np.isclose(denoise_power, 0.0) or len(bbox) != 4:
+        return denoise_strength
+
+    width, height = image_size
+
+    image_pixels = width * height
+    bbox_pixels = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+
+    normalized_area = bbox_pixels / image_pixels
+    denoise_modifier = (1.0 - normalized_area) ** denoise_power
+
+    return denoise_strength * denoise_modifier
+
+
+class _OptimalCropSize:
+    sdxl_res: ClassVar[list[tuple[int, int]]] = [
+        (1024, 1024),
+        (1152, 896),
+        (896, 1152),
+        (1216, 832),
+        (832, 1216),
+        (1344, 768),
+        (768, 1344),
+        (1536, 640),
+        (640, 1536),
+    ]
+
+    def sdxl(
+        self, inpaint_width: int, inpaint_height: int, bbox: Sequence[T]
+    ) -> tuple[int, int]:
+        if len(bbox) != 4:
+            msg = f"bbox length must be 4, got {len(bbox)}"
+            raise ValueError(msg)
+
+        bbox_width = bbox[2] - bbox[0]
+        bbox_height = bbox[3] - bbox[1]
+        bbox_aspect_ratio = bbox_width / bbox_height
+
+        resolutions = [
+            res
+            for res in self.sdxl_res
+            if (res[0] >= bbox_width and res[1] >= bbox_height)
+            and (res[0] >= inpaint_width or res[1] >= inpaint_height)
+        ]
+
+        if not resolutions:
+            return inpaint_width, inpaint_height
+
+        return min(
+            resolutions,
+            key=lambda res: abs((res[0] / res[1]) - bbox_aspect_ratio),
+        )
+
+    def free(
+        self, inpaint_width: int, inpaint_height: int, bbox: Sequence[T]
+    ) -> tuple[int, int]:
+        if len(bbox) != 4:
+            msg = f"bbox length must be 4, got {len(bbox)}"
+            raise ValueError(msg)
+
+        bbox_width = bbox[2] - bbox[0]
+        bbox_height = bbox[3] - bbox[1]
+        bbox_aspect_ratio = bbox_width / bbox_height
+
+        scale_size = max(inpaint_width, inpaint_height)
+
+        if bbox_aspect_ratio > 1:
+            optimal_width = scale_size
+            optimal_height = scale_size / bbox_aspect_ratio
+        else:
+            optimal_width = scale_size * bbox_aspect_ratio
+            optimal_height = scale_size
+
+        # Round up to the nearest multiple of 8 to make the dimensions friendly for upscaling/diffusion.
+        optimal_width = ((optimal_width + 8 - 1) // 8) * 8
+        optimal_height = ((optimal_height + 8 - 1) // 8) * 8
+
+        return int(optimal_width), int(optimal_height)
+
+
+optimal_crop_size = _OptimalCropSize()

extensions/adetailer/adetailer/ultralytics.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+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
+
+if TYPE_CHECKING:
+    import torch
+    from ultralytics import YOLO, YOLOWorld
+
+
+def ultralytics_predict(
+    model_path: str | Path,
+    image: Image.Image,
+    confidence: float = 0.3,
+    device: str = "",
+    classes: str = "",
+) -> PredictOutput[float]:
+    from ultralytics import YOLO
+
+    model = YOLO(model_path)
+    apply_classes(model, model_path, classes)
+    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)
+
+    confidences = pred[0].boxes.conf.cpu().numpy().tolist()
+
+    preview = pred[0].plot()
+    preview = cv2.cvtColor(preview, cv2.COLOR_BGR2RGB)
+    preview = Image.fromarray(preview)
+
+    return PredictOutput(
+        bboxes=bboxes, masks=masks, confidences=confidences, preview=preview
+    )
+
+
+def apply_classes(model: YOLO | YOLOWorld, model_path: str | Path, classes: str):
+    if not classes or "-world" not in Path(model_path).stem:
+        return
+    parsed = [c.strip() for c in classes.split(",") if c.strip()]
+    if parsed:
+        model.set_classes(parsed)
+
+
+def mask_to_pil(masks: torch.Tensor, 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]
+        (W, H) of the original image
+    """
+    n = masks.shape[0]
+    return [to_pil_image(masks[i], mode="L").resize(shape) for i in range(n)]

extensions/adetailer/controlnet_ext/__init__.py

@@ -0,0 +1,25 @@
+try:
+    from .controlnet_ext_forge import (
+        ControlNetExt,
+        controlnet_exists,
+        controlnet_type,
+        get_cn_models,
+    )
+except ImportError:
+    from .controlnet_ext import (
+        ControlNetExt,
+        controlnet_exists,
+        controlnet_type,
+        get_cn_models,
+    )
+
+from .restore import CNHijackRestore, cn_allow_script_control
+
+__all__ = [
+    "CNHijackRestore",
+    "ControlNetExt",
+    "cn_allow_script_control",
+    "controlnet_exists",
+    "controlnet_type",
+    "get_cn_models",
+]

extensions/adetailer/controlnet_ext/common.py

@@ -0,0 +1,12 @@
+import re
+
+cn_model_module = {
+    "inpaint": "inpaint_global_harmonious",
+    "scribble": "t2ia_sketch_pidi",
+    "lineart": "lineart_coarse",
+    "openpose": "openpose_full",
+    "tile": "tile_resample",
+    "depth": "depth_midas",
+}
+_names = [*cn_model_module, "union"]
+cn_model_regex = re.compile("|".join(_names), flags=re.IGNORECASE)

extensions/adetailer/controlnet_ext/controlnet_ext.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import importlib
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+from modules import extensions, sd_models, shared
+from modules.paths import extensions_builtin_dir, extensions_dir, models_path
+
+from .common import cn_model_module, cn_model_regex
+
+ext_path = Path(extensions_dir)
+ext_builtin_path = Path(extensions_builtin_dir)
+controlnet_exists = False
+controlnet_type = "standard"
+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)
+
+
+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(  # noqa: PLR0913
+        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 == "None":
+            module = None
+        if module is None:
+            for m, v in cn_model_module.items():
+                if m in model:
+                    module = v
+                    break
+
+        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,
+                enabled=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 []

extensions/adetailer/controlnet_ext/controlnet_ext_forge.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import copy
+
+import numpy as np
+from lib_controlnet import external_code, global_state
+from lib_controlnet.external_code import ControlNetUnit
+
+from modules import scripts
+from modules.processing import StableDiffusionProcessing
+
+from .common import cn_model_regex
+
+controlnet_exists = True
+controlnet_type = "forge"
+
+
+def find_script(p: StableDiffusionProcessing, script_title: str) -> scripts.Script:
+    script = next((s for s in p.scripts.scripts if s.title() == script_title), None)
+    if not script:
+        msg = f"Script not found: {script_title!r}"
+        raise RuntimeError(msg)
+    return script
+
+
+def add_forge_script_to_adetailer_run(
+    p: StableDiffusionProcessing, script_title: str, script_args: list
+):
+    p.scripts = copy.copy(scripts.scripts_img2img)
+    p.scripts.alwayson_scripts = []
+    p.script_args_value = []
+
+    script = copy.copy(find_script(p, script_title))
+    script.args_from = len(p.script_args_value)
+    script.args_to = len(p.script_args_value) + len(script_args)
+    p.scripts.alwayson_scripts.append(script)
+    p.script_args_value.extend(script_args)
+
+
+class ControlNetExt:
+    def __init__(self):
+        self.cn_available = False
+        self.external_cn = external_code
+
+    def init_controlnet(self):
+        self.cn_available = True
+
+    def update_scripts_args(  # noqa: PLR0913
+        self,
+        p,
+        model: str,
+        module: str | None,
+        weight: float,
+        guidance_start: float,
+        guidance_end: float,
+    ):
+        if (not self.cn_available) or model == "None":
+            return
+
+        image = np.asarray(p.init_images[0])
+        mask = np.full_like(image, fill_value=255)
+
+        cnet_image = {"image": image, "mask": mask}
+
+        pres = external_code.pixel_perfect_resolution(
+            image,
+            target_H=p.height,
+            target_W=p.width,
+            resize_mode=external_code.resize_mode_from_value(p.resize_mode),
+        )
+
+        add_forge_script_to_adetailer_run(
+            p,
+            "ControlNet",
+            [
+                ControlNetUnit(
+                    enabled=True,
+                    image=cnet_image,
+                    model=model,
+                    module=module,
+                    weight=weight,
+                    guidance_start=guidance_start,
+                    guidance_end=guidance_end,
+                    processor_res=pres,
+                )
+            ],
+        )
+
+
+def get_cn_models() -> list[str]:
+    models = global_state.get_all_controlnet_names()
+    return [m for m in models if cn_model_regex.search(m)]

extensions/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

extensions/adetailer/install.py

@@ -0,0 +1,79 @@
+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], check=True)
+
+
+def install():
+    deps = [
+        # requirements
+        ("ultralytics", "8.3.75", None),
+        ("mediapipe", "0.10.13", "0.10.15"),
+        ("rich", "13.0.0", None),
+    ]
+
+    pkgs = []
+    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
+            pkgs.append(cmd)
+
+    if pkgs:
+        run_pip(*pkgs)
+
+
+try:
+    import launch
+
+    skip_install = launch.args.skip_install
+except Exception:
+    skip_install = False
+
+if not skip_install:
+    install()

extensions/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",
+    )

extensions/adetailer/pyproject.toml

@@ -0,0 +1,83 @@
+[project]
+name = "adetailer"
+description = "An object detection and auto-mask extension for stable diffusion webui."
+authors = [{ name = "dowon", email = "[email protected]" }]
+requires-python = ">=3.9"
+readme = "README.md"
+license = { text = "AGPL-3.0" }
+dependencies = [
+    "ultralytics>=8.2",
+    "mediapipe>=0.10.13",
+    "pydantic<3",
+    "rich>=13",
+    "huggingface_hub",
+]
+keywords = [
+    "stable-diffusion",
+    "stable-diffusion-webui",
+    "adetailer",
+    "ultralytics",
+]
+classifiers = [
+    "License :: OSI Approved :: GNU Affero General Public License v3",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+]
+dynamic = ["version"]
+
+[project.urls]
+repository = "https://github.com/Bing-su/adetailer"
+
+[project.optional-dependencies]
+dev = ["ruff", "pre-commit", "devtools"]
+test = ["pytest", "hypothesis"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "adetailer/__version__.py"
+
+[tool.isort]
+profile = "black"
+known_first_party = ["launch", "modules"]
+
+[tool.ruff]
+target-version = "py39"
+extend-exclude = ["modules"]
+
+[tool.ruff.lint]
+select = [
+    "A",
+    "B",
+    "C4",
+    "C90",
+    "E",
+    "EM",
+    "F",
+    "FA",
+    "I001",
+    "ISC",
+    "N",
+    "PD",
+    "PERF",
+    "PL",
+    "PIE",
+    "PT",
+    "PTH",
+    "RET",
+    "RUF",
+    "SIM",
+    "T20",
+    "TRY",
+    "UP",
+    "W",
+]
+ignore = ["B905", "E501", "PLR2004", "PLW0603"]
+unfixable = ["F401"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["launch", "modules"]
+
+[tool.ruff.lint.pyupgrade]
+keep-runtime-typing = true

extensions/adetailer/scripts/!adetailer.py

@@ -0,0 +1,1214 @@
+from __future__ import annotations
+
+import platform
+import re
+import sys
+import traceback
+from collections.abc import Sequence
+from copy import copy
+from functools import partial
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, NamedTuple, cast
+
+import gradio as gr
+from PIL import Image, ImageChops
+from rich import print  # noqa: A004  Shadowing built-in 'print'
+
+import modules
+from aaaaaa.conditional import create_binary_mask, schedulers
+from aaaaaa.helper import (
+    PPImage,
+    copy_extra_params,
+    disable_safe_unpickle,
+    pause_total_tqdm,
+    preserve_prompts,
+)
+from aaaaaa.p_method import (
+    get_i,
+    is_img2img_inpaint,
+    is_inpaint_only_masked,
+    is_skip_img2img,
+    need_call_postprocess,
+    need_call_process,
+)
+from aaaaaa.traceback import rich_traceback
+from aaaaaa.ui import WebuiInfo, adui, ordinal, suffix
+from adetailer import (
+    ADETAILER,
+    __version__,
+    get_models,
+    mediapipe_predict,
+    ultralytics_predict,
+)
+from adetailer.args import (
+    BBOX_SORTBY,
+    BUILTIN_SCRIPT,
+    INPAINT_BBOX_MATCH_MODES,
+    SCRIPT_DEFAULT,
+    ADetailerArgs,
+    InpaintBBoxMatchMode,
+    SkipImg2ImgOrig,
+)
+from adetailer.common import PredictOutput, ensure_pil_image, safe_mkdir
+from adetailer.mask import (
+    filter_by_ratio,
+    filter_k_by,
+    has_intersection,
+    is_all_black,
+    mask_preprocess,
+    sort_bboxes,
+)
+from adetailer.opts import dynamic_denoise_strength, optimal_crop_size
+from controlnet_ext import (
+    CNHijackRestore,
+    ControlNetExt,
+    cn_allow_script_control,
+    controlnet_exists,
+    controlnet_type,
+    get_cn_models,
+)
+from modules import images, paths, 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
+
+PARAMS_TXT = "params.txt"
+
+no_huggingface = getattr(cmd_opts, "ad_no_huggingface", False)
+adetailer_dir = Path(paths.models_path, "adetailer")
+safe_mkdir(adetailer_dir)
+
+extra_models_dirs = shared.opts.data.get("ad_extra_models_dir", "")
+model_mapping = get_models(
+    adetailer_dir,
+    *extra_models_dirs.split("|"),
+    huggingface=not no_huggingface,
+)
+
+txt2img_submit_button = img2img_submit_button = None
+txt2img_submit_button = cast(gr.Button, txt2img_submit_button)
+img2img_submit_button = cast(gr.Button, img2img_submit_button)
+
+print(
+    f"[-] ADetailer initialized. version: {__version__}, num models: {len(model_mapping)}"
+)
+
+
+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 ADETAILER
+
+    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]
+        scheduler_names = [x.label for x in schedulers]
+
+        checkpoint_list = modules.sd_models.checkpoint_tiles(use_short=True)
+        vae_list = modules.shared_items.sd_vae_items()
+
+        webui_info = WebuiInfo(
+            ad_model_list=ad_model_list,
+            sampler_names=sampler_names,
+            scheduler_names=scheduler_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 arg_list:
+            return False
+
+        ad_enabled = args[0] if isinstance(args[0], bool) else True
+
+        not_none = False
+        for arg in arg_list:
+            try:
+                adarg = ADetailerArgs(**arg)
+            except ValueError:  # noqa: PERF203
+                continue
+            else:
+                if not adarg.need_skip():
+                    not_none = True
+                    break
+        return ad_enabled and not_none
+
+    def set_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]
+        else:
+            p._ad_skip_img2img = False
+
+        if not p._ad_skip_img2img:
+            return
+
+        if is_img2img_inpaint(p):
+            p._ad_disabled = True
+            msg = "[-] ADetailer: img2img inpainting with skip img2img is not supported. (because it's buggy)"
+            print(msg)
+            return
+
+        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
+
+    def get_args(self, p, *args_) -> list[ADetailerArgs]:
+        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: list[ADetailerArgs] = []
+
+        for n, arg_dict in enumerate(args, 1):
+            try:
+                inp = ADetailerArgs(**arg_dict)
+            except ValueError:
+                msg = f"[-] ADetailer: ValidationError when validating {ordinal(n)} arguments:"
+                print(msg, arg_dict, file=sys.stderr)
+                continue
+
+            all_inputs.append(inp)
+
+        if not all_inputs:
+            msg = "[-] ADetailer: No valid arguments found."
+            raise ValueError(msg)
+        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]", 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 = get_i(p)
+        prompt_sr = p._ad_xyz_prompt_sr if hasattr(p, "_ad_xyz_prompt_sr") else []
+
+        prompt = self._get_prompt(
+            ad_prompt=args.ad_prompt,
+            all_prompts=p.all_prompts,
+            i=i,
+            default=p.prompt,
+            replacements=prompt_sr,
+        )
+        negative_prompt = self._get_prompt(
+            ad_prompt=args.ad_negative_prompt,
+            all_prompts=p.all_negative_prompts,
+            i=i,
+            default=p.negative_prompt,
+            replacements=prompt_sr,
+        )
+
+        return prompt, negative_prompt
+
+    def get_seed(self, p) -> tuple[int, int]:
+        i = 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:
+            if args.ad_sampler == "Use same sampler":
+                return p.sampler_name
+            return args.ad_sampler
+
+        if hasattr(p, "_ad_orig"):
+            return p._ad_orig.sampler_name
+        return p.sampler_name
+
+    def get_scheduler(self, p, args: ADetailerArgs) -> dict[str, str]:
+        "webui >= 1.9.0"
+        if not args.ad_use_sampler:
+            return {"scheduler": getattr(p, "scheduler", "Automatic")}
+
+        if args.ad_scheduler == "Use same scheduler":
+            value = getattr(p, "scheduler", "Automatic")
+        else:
+            value = args.ad_scheduler
+        return {"scheduler": value}
+
+    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 read_params_txt(self) -> str:
+        params_txt = Path(paths.data_path, PARAMS_TXT)
+        if params_txt.exists():
+            return params_txt.read_text(encoding="utf-8")
+        return ""
+
+    def write_params_txt(self, content: str) -> None:
+        params_txt = Path(paths.data_path, PARAMS_TXT)
+        if params_txt.exists() and content:
+            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_selected_scripts = opts.data.get("ad_only_selected_scripts", True)
+        if not ad_only_selected_scripts:
+            return script_runner, script_args
+
+        ad_script_names_string: str = opts.data.get("ad_script_names", SCRIPT_DEFAULT)
+        ad_script_names = ad_script_names_string.split(",") + BUILTIN_SCRIPT.split(",")
+        script_names_set = {
+            name
+            for script_name in ad_script_names
+            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: Sequence[Any]) -> list[Any]:
+        new_args = []
+        for arg in script_args:
+            if "controlnet" in arg.__class__.__name__.lower():
+                new = copy(arg)
+                if hasattr(new, "enabled"):
+                    new.enabled = False
+                if hasattr(new, "input_mode"):
+                    new.input_mode = getattr(new.input_mode, "SIMPLE", "simple")
+                new_args.append(new)
+
+            elif isinstance(arg, dict) and "module" in arg:
+                new = copy(arg)
+                new["enabled"] = False
+                new_args.append(new)
+
+            else:
+                new_args.append(arg)
+
+        return new_args
+
+    def get_i2i_p(
+        self, p, args: ADetailerArgs, image: Image.Image
+    ) -> StableDiffusionProcessingImg2Img:
+        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)
+
+        version_args = {}
+        if schedulers:
+            version_args.update(self.get_scheduler(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=copy_extra_params(p.extra_generation_params),
+            do_not_save_samples=True,
+            do_not_save_grid=True,
+            override_settings=override_settings,
+            **version_args,
+        )
+
+        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" and controlnet_type != "forge":
+            i2i.script_args = 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:
+        if not opts.data.get(condition, False):
+            return
+
+        i = 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)
+
+        ad_save_images_dir: str = opts.data.get("ad_save_images_dir", "")
+
+        if not ad_save_images_dir.strip():
+            ad_save_images_dir = p.outpath_samples
+
+        images.save_image(
+            image=image,
+            path=ad_save_images_dir,
+            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, p, pred: PredictOutput, args: ADetailerArgs):
+        pred = filter_by_ratio(
+            pred, low=args.ad_mask_min_ratio, high=args.ad_mask_max_ratio
+        )
+        pred = filter_k_by(pred, k=args.ad_mask_k, by=args.ad_mask_filter_method)
+        pred = self.sort_bboxes(pred)
+        masks = 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,
+        )
+
+        if is_img2img_inpaint(p) and not is_inpaint_only_masked(p):
+            image_mask = self.get_image_mask(p)
+            masks = self.inpaint_mask_filter(image_mask, masks)
+        return masks
+
+    @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(extra_params: dict[str, Any], processed, n: int = 0):
+        pt = "ADetailer prompt" + suffix(n)
+        if pt in extra_params and extra_params[pt] != processed.all_prompts[0]:
+            print(
+                f"[-] ADetailer: applied {ordinal(n + 1)} ad_prompt: {processed.all_prompts[0]!r}"
+            )
+
+        ng = "ADetailer negative prompt" + suffix(n)
+        if ng in extra_params and extra_params[ng] != processed.all_negative_prompts[0]:
+            print(
+                f"[-] ADetailer: applied {ordinal(n + 1)} ad_negative_prompt: {processed.all_negative_prompts[0]!r}"
+            )
+
+    @staticmethod
+    def get_i2i_init_image(p, pp: PPImage):
+        if is_skip_img2img(p):
+            return p.init_images[0]
+        return pp.image
+
+    @staticmethod
+    def get_each_tab_seed(seed: int, i: int):
+        use_same_seed = shared.opts.data.get("ad_same_seed_for_each_tab", False)
+        return seed if use_same_seed else seed + i
+
+    @staticmethod
+    def inpaint_mask_filter(
+        img2img_mask: Image.Image, ad_mask: list[Image.Image]
+    ) -> list[Image.Image]:
+        if ad_mask and img2img_mask.size != ad_mask[0].size:
+            img2img_mask = img2img_mask.resize(ad_mask[0].size, resample=Image.LANCZOS)
+        return [mask for mask in ad_mask if has_intersection(img2img_mask, mask)]
+
+    @staticmethod
+    def get_image_mask(p) -> Image.Image:
+        mask = p.image_mask
+        mask = ensure_pil_image(mask, "L")
+        if getattr(p, "inpainting_mask_invert", False):
+            mask = ImageChops.invert(mask)
+        mask = create_binary_mask(mask)
+
+        width, height = p.width, p.height
+        if is_skip_img2img(p) and hasattr(p, "init_images") and p.init_images:
+            width, height = p.init_images[0].size
+        return images.resize_image(p.resize_mode, mask, width, height)
+
+    @staticmethod
+    def get_dynamic_denoise_strength(
+        denoise_strength: float, bbox: Sequence[Any], image_size: tuple[int, int]
+    ):
+        denoise_power = opts.data.get("ad_dynamic_denoise_power", 0)
+        if denoise_power == 0:
+            return denoise_strength
+
+        modified_strength = dynamic_denoise_strength(
+            denoise_power=denoise_power,
+            denoise_strength=denoise_strength,
+            bbox=bbox,
+            image_size=image_size,
+        )
+
+        print(
+            f"[-] ADetailer: dynamic denoising -- {denoise_strength:.2f} -> {modified_strength:.2f}"
+        )
+
+        return modified_strength
+
+    @staticmethod
+    def get_optimal_crop_image_size(
+        inpaint_width: int, inpaint_height: int, bbox: Sequence[Any]
+    ) -> tuple[int, int]:
+        calculate_optimal_crop = opts.data.get(
+            "ad_match_inpaint_bbox_size", InpaintBBoxMatchMode.OFF.value
+        )
+
+        optimal_resolution: tuple[int, int] | None = None
+
+        # Off
+        if calculate_optimal_crop == InpaintBBoxMatchMode.OFF.value:
+            return (inpaint_width, inpaint_height)
+
+        # Strict (SDXL only)
+        if calculate_optimal_crop == InpaintBBoxMatchMode.STRICT.value:
+            if not shared.sd_model.is_sdxl:
+                msg = "[-] ADetailer: strict inpaint bounding box size matching is only available for SDXL. Use Free mode instead."
+                print(msg)
+                return (inpaint_width, inpaint_height)
+
+            optimal_resolution = optimal_crop_size.sdxl(
+                inpaint_width, inpaint_height, bbox
+            )
+
+        # Free
+        elif calculate_optimal_crop == InpaintBBoxMatchMode.FREE.value:
+            optimal_resolution = optimal_crop_size.free(
+                inpaint_width, inpaint_height, bbox
+            )
+
+        if optimal_resolution is None:
+            msg = "[-] ADetailer: unsupported inpaint bounding box match mode. Original inpainting dimensions will be used."
+            print(msg)
+            return (inpaint_width, inpaint_height)
+
+        # Only use optimal dimensions if they're different enough to current inpaint dimensions.
+        if (
+            abs(optimal_resolution[0] - inpaint_width) > inpaint_width * 0.1
+            or abs(optimal_resolution[1] - inpaint_height) > inpaint_height * 0.1
+        ):
+            print(
+                f"[-] ADetailer: inpaint dimensions optimized -- {inpaint_width}x{inpaint_height} -> {optimal_resolution[0]}x{optimal_resolution[1]}"
+            )
+
+        return optimal_resolution
+
+    def fix_p2(  # noqa: PLR0913
+        self, p, p2, pp: PPImage, args: ADetailerArgs, pred: PredictOutput, j: int
+    ):
+        seed, subseed = self.get_seed(p)
+        p2.seed = self.get_each_tab_seed(seed, j)
+        p2.subseed = self.get_each_tab_seed(subseed, j)
+        p2.denoising_strength = self.get_dynamic_denoise_strength(
+            p2.denoising_strength, pred.bboxes[j], pp.image.size
+        )
+
+        p2.cached_c = [None, None]
+        p2.cached_uc = [None, None]
+
+        # Don't override user-defined dimensions.
+        if not args.ad_use_inpaint_width_height:
+            p2.width, p2.height = self.get_optimal_crop_image_size(
+                p2.width, p2.height, pred.bboxes[j]
+            )
+
+    @rich_traceback
+    def process(self, p, *args_):
+        if getattr(p, "_ad_disabled", False):
+            return
+
+        if is_img2img_inpaint(p) and is_all_black(self.get_image_mask(p)):
+            p._ad_disabled = True
+            msg = (
+                "[-] ADetailer: img2img inpainting with no mask -- adetailer disabled."
+            )
+            print(msg)
+            return
+
+        if not self.is_ad_enabled(*args_):
+            p._ad_disabled = True
+            return
+
+        self.set_skip_img2img(p, *args_)
+        if getattr(p, "_ad_disabled", False):
+            # case when img2img inpainting with skip img2img
+            return
+
+        arg_list = self.get_args(p, *args_)
+
+        if hasattr(p, "_ad_xyz_prompt_sr"):
+            replaced_positive_prompt, replaced_negative_prompt = self.get_prompt(
+                p, arg_list[0]
+            )
+            arg_list[0].ad_prompt = replaced_positive_prompt[0]
+            arg_list[0].ad_negative_prompt = replaced_negative_prompt[0]
+
+        extra_params = self.extra_params(arg_list)
+        p.extra_generation_params.update(extra_params)
+
+    def _postprocess_image_inner(
+        self, p, pp: PPImage, args: ADetailerArgs, *, n: int = 0
+    ) -> bool:
+        """
+        Returns
+        -------
+            bool
+
+            `True` if image was processed, `False` otherwise.
+        """
+        if state.interrupted or state.skipped:
+            return False
+
+        i = get_i(p)
+
+        i2i = self.get_i2i_p(p, args, pp.image)
+        ad_prompts, ad_negatives = self.get_prompt(p, args)
+
+        is_mediapipe = args.is_mediapipe()
+
+        if is_mediapipe:
+            pred = mediapipe_predict(args.ad_model, pp.image, args.ad_confidence)
+
+        else:
+            ad_model = self.get_ad_model(args.ad_model)
+            with disable_safe_unpickle():
+                pred = ultralytics_predict(
+                    ad_model,
+                    image=pp.image,
+                    confidence=args.ad_confidence,
+                    device=self.ultralytics_device,
+                    classes=args.ad_model_classes,
+                )
+
+        if pred.preview is None:
+            print(
+                f"[-] ADetailer: nothing detected on image {i + 1} with {ordinal(n + 1)} settings."
+            )
+            return False
+
+        masks = self.pred_preprocessing(p, pred, args)
+        shared.state.assign_current_image(pred.preview)
+
+        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] = ensure_pil_image(p2.init_images[0], "RGB")
+            self.i2i_prompts_replace(p2, ad_prompts, ad_negatives, j)
+
+            if re.match(r"^\s*\[SKIP\]\s*$", p2.prompt):
+                continue
+
+            self.fix_p2(p, p2, pp, args, pred, 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()
+
+            if not processed.images:
+                processed = None
+                break
+
+            self.compare_prompt(p.extra_generation_params, 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: PPImage, *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 = ensure_pil_image(pp.image, "RGB")
+        init_image = copy(pp.image)
+        arg_list = self.get_args(p, *args_)
+        params_txt_content = self.read_params_txt()
+
+        if need_call_postprocess(p):
+            dummy = Processed(p, [], p.seed, "")
+            with preserve_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.need_skip():
+                    continue
+                is_processed |= self._postprocess_image_inner(p, pp, args, n=n)
+
+        if is_processed and not is_skip_img2img(p):
+            self.save_image(
+                p, init_image, condition="ad_save_images_before", suffix="-ad-before"
+            )
+
+        if need_call_process(p):
+            with preserve_prompts(p):
+                copy_p = copy(p)
+                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", ADETAILER)
+    shared.opts.add_option(
+        "ad_max_models",
+        shared.OptionInfo(
+            default=4,
+            label="Max tabs",
+            component=gr.Slider,
+            component_args={"minimum": 1, "maximum": 15, "step": 1},
+            section=section,
+        ).needs_reload_ui(),
+    )
+
+    shared.opts.add_option(
+        "ad_extra_models_dir",
+        shared.OptionInfo(
+            default="",
+            label="Extra paths to scan adetailer models separated by vertical bars(|)",
+            component=gr.Textbox,
+            section=section,
+        )
+        .info("eg. path\\to\\models|C:\\path\\to\\models|another/path/to/models")
+        .needs_reload_ui(),
+    )
+
+    shared.opts.add_option(
+        "ad_save_images_dir",
+        shared.OptionInfo(
+            default="",
+            label="Output directory for adetailer images",
+            component=gr.Textbox,
+            section=section,
+        ),
+    )
+
+    shared.opts.add_option(
+        "ad_save_previews",
+        shared.OptionInfo(default=False, label="Save mask previews", section=section),
+    )
+
+    shared.opts.add_option(
+        "ad_save_images_before",
+        shared.OptionInfo(
+            default=False, label="Save images before ADetailer", section=section
+        ),
+    )
+
+    shared.opts.add_option(
+        "ad_only_selected_scripts",
+        shared.OptionInfo(
+            default=True,
+            label="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_tab",
+        shared.OptionInfo(
+            default=False,
+            label="Use same seed for each tab in adetailer",
+            section=section,
+        ),
+    )
+
+    shared.opts.add_option(
+        "ad_dynamic_denoise_power",
+        shared.OptionInfo(
+            default=0,
+            label="Power scaling for dynamic denoise strength based on bounding box size",
+            component=gr.Slider,
+            component_args={"minimum": -10, "maximum": 10, "step": 0.01},
+            section=section,
+        ).info(
+            "Smaller areas get higher denoising, larger areas less. Maximum denoise strength is set by 'Inpaint denoising strength'. 0 = disabled; 1 = linear; 2-4 = recommended"
+        ),
+    )
+
+    shared.opts.add_option(
+        "ad_match_inpaint_bbox_size",
+        shared.OptionInfo(
+            default=InpaintBBoxMatchMode.OFF.value,  # Off
+            component=gr.Radio,
+            component_args={"choices": INPAINT_BBOX_MATCH_MODES},
+            label="Try to match inpainting size to bounding box size, if 'Use separate width/height' is not set",
+            section=section,
+        ).info(
+            "Strict is for SDXL only, and matches exactly to trained SDXL resolutions. Free works with any model, but will use potentially unsupported dimensions."
+        ),
+    )
+
+
+# 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()]
+    xyz_samplers = [sampler.name for sampler in all_samplers]
+    xyz_schedulers = [scheduler.label for scheduler in schedulers]
+
+    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] CFG scale 1st",
+            float,
+            partial(set_value, field="ad_cfg_scale"),
+        ),
+        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: xyz_samplers,
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] ADetailer scheduler 1st",
+            str,
+            partial(set_value, field="ad_scheduler"),
+            choices=lambda: xyz_schedulers,
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] noise multiplier 1st",
+            float,
+            partial(set_value, field="ad_noise_multiplier"),
+        ),
+        xyz_grid.AxisOption(
+            "[ADetailer] ControlNet model 1st",
+            str,
+            partial(set_value, field="ad_controlnet_model"),
+            choices=lambda: ["None", "Passthrough", *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")
+    async def version():
+        return {"version": __version__}
+
+    @app.get("/adetailer/v1/schema")
+    async def schema():
+        if hasattr(ADetailerArgs, "model_json_schema"):
+            return ADetailerArgs.model_json_schema()
+        return ADetailerArgs.schema()
+
+    @app.get("/adetailer/v1/ad_model")
+    async 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)

extensions/adetailer/tests/conftest.py

@@ -0,0 +1,18 @@
+import pytest
+import requests
+from PIL import Image
+
+
+def get_image(url: str) -> Image.Image:
+    resp = requests.get(url, stream=True, headers={"User-Agent": "Mozilla/5.0"})
+    return Image.open(resp.raw)
+
+
+@pytest.fixture(scope="session")
+def sample_image():
+    return get_image("https://i.imgur.com/E5OVXvn.png")
+
+
+@pytest.fixture(scope="session")
+def sample_image2():
+    return get_image("https://i.imgur.com/px5UT7T.png")

extensions/adetailer/tests/test_args.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import pytest
+
+from adetailer.args import ALL_ARGS, ADetailerArgs
+
+
+def test_all_args() -> None:
+    args = ADetailerArgs()
+    for attr, _ in ALL_ARGS:
+        assert hasattr(args, attr), attr
+
+    for attr, _ in args:
+        if attr == "is_api":
+            continue
+        assert attr in ALL_ARGS.attrs, attr
+
+
+@pytest.mark.parametrize(
+    ("ad_model", "expect"),
+    [("mediapipe_face_full", True), ("face_yolov8n.pt", False)],
+)
+def test_is_mediapipe(ad_model: str, expect: bool) -> None:
+    args = ADetailerArgs(ad_model=ad_model)
+    assert args.is_mediapipe() is expect
+
+
+@pytest.mark.parametrize(
+    ("ad_model", "expect"),
+    [("mediapipe_face_full", False), ("face_yolov8n.pt", False), ("None", True)],
+)
+def test_need_skip(ad_model: str, expect: bool) -> None:
+    args = ADetailerArgs(ad_model=ad_model)
+    assert args.need_skip() is expect
+
+
+@pytest.mark.parametrize(
+    ("ad_model", "ad_tab_enable", "expect"),
+    [
+        ("face_yolov8n.pt", False, True),
+        ("mediapipe_face_full", False, True),
+        ("None", True, True),
+        ("ace_yolov8s.pt", True, False),
+    ],
+)
+def test_need_skip_tab_enable(ad_model: str, ad_tab_enable: bool, expect: bool) -> None:
+    args = ADetailerArgs(ad_model=ad_model, ad_tab_enable=ad_tab_enable)
+    assert args.need_skip() is expect

extensions/adetailer/tests/test_common.py

@@ -0,0 +1,69 @@
+import numpy as np
+from PIL import Image, ImageDraw
+
+from adetailer.common import create_bbox_from_mask, create_mask_from_bbox
+
+
+def test_create_mask_from_bbox():
+    img = Image.new("L", (10, 10), color="black")
+    bbox = [[1.0, 1.0, 2.0, 2.0], [7.0, 7.0, 8.0, 8.0]]
+    masks = create_mask_from_bbox(bbox, img.size)
+    expect1 = np.array(
+        [
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 255, 255, 0, 0, 0, 0, 0, 0, 0],
+            [0, 255, 255, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    expect2 = np.array(
+        [
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 255, 255, 0],
+            [0, 0, 0, 0, 0, 0, 0, 255, 255, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    assert len(masks) == len(bbox)
+    arr1 = np.array(masks[0])
+    arr2 = np.array(masks[1])
+    assert arr1.shape == expect1.shape
+    assert arr2.shape == expect2.shape
+    assert arr1.shape == (10, 10)
+    assert arr1.dtype == expect1.dtype
+    assert arr2.dtype == expect2.dtype
+    assert np.array_equal(arr1, expect1)
+    assert np.array_equal(arr2, expect2)
+
+    # The function correctly receives a list of masks and the shape of the image.
+
+
+def test_create_bbox_from_mask():
+    mask = Image.new("L", (10, 10), color="black")
+    draw = ImageDraw.Draw(mask)
+    draw.rectangle((2, 2, 5, 5), fill="white")
+
+    result = create_bbox_from_mask([mask], (10, 10))
+
+    assert isinstance(result, list)
+    assert len(result) == 1
+    assert all(isinstance(bbox, list) for bbox in result)
+    assert all(len(bbox) == 4 for bbox in result)
+    assert result[0] == [2, 2, 6, 6]
+
+    result = create_bbox_from_mask([mask], (256, 256))
+    assert result[0] == [38, 38, 166, 166]

extensions/adetailer/tests/test_mask.py

@@ -0,0 +1,236 @@
+import cv2
+import numpy as np
+import pytest
+from PIL import Image, ImageDraw
+
+from adetailer.mask import (
+    bbox_area,
+    dilate_erode,
+    has_intersection,
+    is_all_black,
+    mask_invert,
+    mask_merge,
+    offset,
+)
+
+
+def test_dilate_positive_value():
+    img = Image.new("L", (10, 10), color="black")
+    draw = ImageDraw.Draw(img)
+    draw.rectangle((3, 3, 5, 5), fill="white")
+    value = 3
+
+    result = dilate_erode(img, value)
+
+    assert isinstance(result, Image.Image)
+    assert result.size == (10, 10)
+
+    expect = np.array(
+        [
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 255, 255, 255, 255, 255, 0, 0, 0],
+            [0, 0, 255, 255, 255, 255, 255, 0, 0, 0],
+            [0, 0, 255, 255, 255, 255, 255, 0, 0, 0],
+            [0, 0, 255, 255, 255, 255, 255, 0, 0, 0],
+            [0, 0, 255, 255, 255, 255, 255, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    assert np.array_equal(np.array(result), expect)
+
+
+def test_offset():
+    img = Image.new("L", (10, 10), color="black")
+    draw = ImageDraw.Draw(img)
+    draw.rectangle((4, 4, 5, 5), fill="white")
+
+    result = offset(img, x=1, y=2)
+
+    assert isinstance(result, Image.Image)
+    assert result.size == (10, 10)
+
+    expect = np.array(
+        [
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 255, 255, 0, 0, 0],
+            [0, 0, 0, 0, 0, 255, 255, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    assert np.array_equal(np.array(result), expect)
+
+
+class TestIsAllBlack:
+    def test_is_all_black_1(self):
+        img = Image.new("L", (10, 10), color="black")
+        assert is_all_black(img)
+
+        draw = ImageDraw.Draw(img)
+        draw.rectangle((4, 4, 5, 5), fill="white")
+        assert not is_all_black(img)
+
+    def test_is_all_black_2(self):
+        img = np.zeros((10, 10), dtype=np.uint8)
+        assert is_all_black(img)
+
+        img[4:6, 4:6] = 255
+        assert not is_all_black(img)
+
+    def test_is_all_black_rgb_image_pil(self):
+        img = Image.new("RGB", (10, 10), color="red")
+        assert not is_all_black(img)
+
+        img = Image.new("RGBA", (10, 10), color="red")
+        assert not is_all_black(img)
+
+    def test_is_all_black_rgb_image_numpy(self):
+        img = np.full((10, 10, 4), 127, dtype=np.uint8)
+        with pytest.raises(cv2.error):
+            is_all_black(img)
+
+        img = np.full((4, 10, 10), 0.5, dtype=np.float32)
+        with pytest.raises(cv2.error):
+            is_all_black(img)
+
+
+class TestHasIntersection:
+    def test_has_intersection_1(self):
+        arr1 = np.array(
+            [
+                [0, 0, 0, 0],
+                [0, 0, 0, 0],
+                [0, 0, 0, 0],
+                [0, 0, 0, 0],
+            ],
+            dtype=np.uint8,
+        )
+        arr2 = arr1.copy()
+        assert not has_intersection(arr1, arr2)
+
+    def test_has_intersection_2(self):
+        arr1 = np.array(
+            [
+                [0, 0, 0, 0],
+                [0, 255, 255, 0],
+                [0, 255, 255, 0],
+                [0, 0, 0, 0],
+            ],
+            dtype=np.uint8,
+        )
+        arr2 = np.array(
+            [
+                [0, 0, 0, 0],
+                [0, 0, 0, 0],
+                [0, 0, 255, 255],
+                [0, 0, 255, 255],
+            ],
+            dtype=np.uint8,
+        )
+        assert has_intersection(arr1, arr2)
+
+        arr3 = np.array(
+            [
+                [255, 0, 0, 0],
+                [0, 0, 0, 0],
+                [0, 0, 0, 255],
+                [0, 0, 255, 255],
+            ],
+            dtype=np.uint8,
+        )
+        assert not has_intersection(arr1, arr3)
+
+    def test_has_intersection_3(self):
+        img1 = Image.new("L", (10, 10), color="black")
+        draw1 = ImageDraw.Draw(img1)
+        draw1.rectangle((3, 3, 5, 5), fill="white")
+        img2 = Image.new("L", (10, 10), color="black")
+        draw2 = ImageDraw.Draw(img2)
+        draw2.rectangle((6, 6, 8, 8), fill="white")
+        assert not has_intersection(img1, img2)
+
+        img3 = Image.new("L", (10, 10), color="black")
+        draw3 = ImageDraw.Draw(img3)
+        draw3.rectangle((2, 2, 8, 8), fill="white")
+        assert has_intersection(img1, img3)
+
+    def test_has_intersection_4(self):
+        img1 = Image.new("RGB", (10, 10), color="black")
+        draw1 = ImageDraw.Draw(img1)
+        draw1.rectangle((3, 3, 5, 5), fill="white")
+        img2 = Image.new("RGBA", (10, 10), color="black")
+        draw2 = ImageDraw.Draw(img2)
+        draw2.rectangle((2, 2, 8, 8), fill="white")
+        assert has_intersection(img1, img2)
+
+    def test_has_intersection_5(self):
+        img1 = Image.new("RGB", (10, 10), color="black")
+        draw1 = ImageDraw.Draw(img1)
+        draw1.rectangle((4, 4, 5, 5), fill="white")
+        img2 = np.full((10, 10, 4), 255, dtype=np.uint8)
+        assert has_intersection(img1, img2)
+
+
+def test_bbox_area():
+    bbox = [0.0, 0.0, 10.0, 10.0]
+    assert bbox_area(bbox) == 100
+
+
+class TestMaskMerge:
+    def test_mask_merge(self):
+        img1 = Image.new("L", (10, 10), color="black")
+        draw1 = ImageDraw.Draw(img1)
+        draw1.rectangle((3, 3, 5, 5), fill="white")
+
+        img2 = Image.new("L", (10, 10), color="black")
+        draw2 = ImageDraw.Draw(img2)
+        draw2.rectangle((6, 6, 8, 8), fill="white")
+
+        merged = mask_merge([img1, img2])
+        assert len(merged) == 1
+
+        expect = Image.new("L", (10, 10), color="black")
+        draw3 = ImageDraw.Draw(expect)
+        draw3.rectangle((3, 3, 5, 5), fill="white")
+        draw3.rectangle((6, 6, 8, 8), fill="white")
+
+        assert np.array_equal(np.array(merged[0]), np.array(expect))
+
+    def test_merge_mask_different_size(self):
+        img1 = Image.new("L", (10, 10), color="black")
+        draw1 = ImageDraw.Draw(img1)
+        draw1.rectangle((3, 3, 5, 5), fill="white")
+
+        img2 = Image.new("L", (20, 20), color="black")
+        draw2 = ImageDraw.Draw(img2)
+        draw2.rectangle((6, 6, 8, 8), fill="white")
+
+        with pytest.raises(
+            cv2.error, match="-209:Sizes of input arguments do not match"
+        ):
+            mask_merge([img1, img2])
+
+
+def test_mask_invert():
+    img = Image.new("L", (10, 10), color="black")
+    draw = ImageDraw.Draw(img)
+    draw.rectangle((3, 3, 5, 5), fill="white")
+
+    inverted = mask_invert([img])
+    assert len(inverted) == 1
+
+    expect = Image.new("L", (10, 10), color="white")
+    draw = ImageDraw.Draw(expect)
+    draw.rectangle((3, 3, 5, 5), fill="black")
+
+    assert np.array_equal(np.array(inverted[0]), np.array(expect))

extensions/adetailer/tests/test_mediapipe.py

@@ -0,0 +1,22 @@
+import pytest
+from PIL import Image
+
+from adetailer.mediapipe import mediapipe_predict
+
+
+@pytest.mark.parametrize(
+    "model_name",
+    [
+        "mediapipe_face_short",
+        "mediapipe_face_full",
+        "mediapipe_face_mesh",
+        "mediapipe_face_mesh_eyes_only",
+    ],
+)
+def test_mediapipe(sample_image2: Image.Image, model_name: str):
+    result = mediapipe_predict(model_name, sample_image2)
+    if result.preview is not None:
+        assert len(result.bboxes) > 0
+        assert len(result.masks) > 0
+        assert len(result.confidences) > 0
+        assert len(result.bboxes) == len(result.masks) == len(result.confidences)

extensions/adetailer/tests/test_opts.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import numpy as np
+import pytest
+from hypothesis import assume, given
+from hypothesis import strategies as st
+
+from adetailer.opts import dynamic_denoise_strength, optimal_crop_size
+
+
+@pytest.mark.parametrize(
+    ("denoise_power", "denoise_strength", "bbox", "image_size", "expected_result"),
+    [
+        (0.001, 0.5, [0, 0, 100, 100], (200, 200), 0.4998561796520339),
+        (1.5, 0.3, [0, 0, 100, 100], (200, 200), 0.1948557158514987),
+        (-0.001, 0.7, [0, 0, 100, 100], (1000, 1000), 0.7000070352704507),
+        (-0.5, 0.5, [0, 0, 100, 100], (1000, 1000), 0.502518907629606),
+    ],
+)
+def test_dynamic_denoise_strength(
+    denoise_power: float,
+    denoise_strength: float,
+    bbox: list[int],
+    image_size: tuple[int, int],
+    expected_result: float,
+):
+    result = dynamic_denoise_strength(denoise_power, denoise_strength, bbox, image_size)
+    assert np.isclose(result, expected_result)
+
+
+@given(denoise_strength=st.floats(allow_nan=False))
+def test_dynamic_denoise_strength_no_bbox(denoise_strength: float):
+    with pytest.raises(ValueError, match="bbox length must be 4, got 0"):
+        dynamic_denoise_strength(0.5, denoise_strength, [], (1000, 1000))
+
+
+@given(denoise_strength=st.floats(allow_nan=False))
+def test_dynamic_denoise_strength_zero_power(denoise_strength: float):
+    result = dynamic_denoise_strength(
+        0.0, denoise_strength, [0, 0, 100, 100], (1000, 1000)
+    )
+    assert np.isclose(result, denoise_strength)
+
+
+@given(
+    inpaint_width=st.integers(1),
+    inpaint_height=st.integers(1),
+    bbox=st.tuples(
+        st.integers(0, 500),
+        st.integers(0, 500),
+        st.integers(501, 1000),
+        st.integers(501, 1000),
+    ),
+)
+def test_optimal_crop_size_sdxl(
+    inpaint_width: int, inpaint_height: int, bbox: tuple[int, int, int, int]
+):
+    bbox_width = bbox[2] - bbox[0]
+    bbox_height = bbox[3] - bbox[1]
+    assume(bbox_width > 0 and bbox_height > 0)
+
+    result = optimal_crop_size.sdxl(inpaint_width, inpaint_height, bbox)
+    assert (result in optimal_crop_size.sdxl_res) or result == (
+        inpaint_width,
+        inpaint_height,
+    )
+
+    if result != (inpaint_width, inpaint_height):
+        assert result[0] >= bbox_width
+        assert result[1] >= bbox_height
+        assert result[0] >= inpaint_width or result[1] >= inpaint_height
+
+
+@given(
+    inpaint_width=st.integers(1),
+    inpaint_height=st.integers(1),
+    bbox=st.tuples(
+        st.integers(0, 500),
+        st.integers(0, 500),
+        st.integers(501, 1000),
+        st.integers(501, 1000),
+    ),
+)
+def test_optimal_crop_size_free(
+    inpaint_width: int, inpaint_height: int, bbox: tuple[int, int, int, int]
+):
+    bbox_width = bbox[2] - bbox[0]
+    bbox_height = bbox[3] - bbox[1]
+    assume(bbox_width > 0 and bbox_height > 0)
+
+    result = optimal_crop_size.free(inpaint_width, inpaint_height, bbox)
+    assert result[0] % 8 == 0
+    assert result[1] % 8 == 0

extensions/adetailer/tests/test_ultralytics.py

@@ -0,0 +1,62 @@
+import pytest
+from huggingface_hub import hf_hub_download
+from PIL import Image
+
+from adetailer.ultralytics import ultralytics_predict
+
+
+@pytest.mark.parametrize(
+    "model_name",
+    [
+        "face_yolov8n.pt",
+        "face_yolov8n_v2.pt",
+        "face_yolov8s.pt",
+        "face_yolov9c.pt",
+        "hand_yolov8n.pt",
+        "hand_yolov8s.pt",
+        "hand_yolov9c.pt",
+        "person_yolov8n-seg.pt",
+        "person_yolov8s-seg.pt",
+        "person_yolov8m-seg.pt",
+        "deepfashion2_yolov8s-seg.pt",
+    ],
+)
+def test_ultralytics_hf_models(sample_image: Image.Image, model_name: str):
+    model_path = hf_hub_download("Bingsu/adetailer", model_name)
+    result = ultralytics_predict(model_path, sample_image)
+    assert result.preview is not None
+    assert len(result.bboxes) > 0
+    assert len(result.masks) > 0
+    assert len(result.confidences) > 0
+    assert len(result.bboxes) == len(result.masks) == len(result.confidences)
+
+
+def test_yolo_world_default(sample_image: Image.Image):
+    model_path = hf_hub_download("Bingsu/yolo-world-mirror", "yolov8x-worldv2.pt")
+    result = ultralytics_predict(model_path, sample_image)
+    assert result.preview is not None
+    assert len(result.bboxes) > 0
+    assert len(result.masks) > 0
+    assert len(result.confidences) > 0
+    assert len(result.bboxes) == len(result.masks) == len(result.confidences)
+
+
+@pytest.mark.parametrize(
+    "klass",
+    [
+        "person",
+        "bird",
+        "yellow bird",
+        "person,glasses,headphone",
+        "person,bird",
+        "glasses,yellow bird",
+    ],
+)
+def test_yolo_world(sample_image2: Image.Image, klass: str):
+    model_path = hf_hub_download("Bingsu/yolo-world-mirror", "yolov8x-worldv2.pt")
+    result = ultralytics_predict(model_path, sample_image2, classes=klass)
+    assert result.preview is not None
+    assert len(result.bboxes) > 0
+    assert len(result.masks) > 0
+    assert len(result.confidences) > 0
+    assert len(result.bboxes) == len(result.masks) == len(result.confidences)