mirror of
https://github.com/willmiao/ComfyUI-Lora-Manager.git
synced 2026-10-12 12:32:11 -03:00
Will Miao
6d0d7cb15b
ComfyUI hands its model folders over in the host's own spelling -- `utils/extra_config.py` runs every configured path through `os.path.normpath()`, which is all backslashes on Windows, and `main.py` registers `<output>/loras` unconditionally for its save nodes. `Config` kept that spelling verbatim while `_prepare_*_paths()` normalized the live root lists to forward slashes, and the scanner compared the two as raw strings. On Windows every configured root therefore looked like a root that was not in the live list: the Refresh menu listed each directory twice (the twin showing "0 models"), the completion toast claimed reachable roots were "currently inaccessible" and kept their whole cache count as `kept_unreachable`, and the settings sync persisted host-registered directories that were never created. The duplication was not only cosmetic. `_UnreachablePaths.add()` normalizes the prefix it is given, so the configured twin of a live root registered exactly the live root's prefix as unreadable: in the prune phase every cached-but-missing entry under it matched and was "kept", so models deleted from disk were never removed from the cache again. * `py/utils/root_paths.py` holds the single `normalize_root_identity()` (separator style, redundant/trailing separators, and case where the filesystem folds it: whole paths on Windows, drive letters everywhere). `config.py` and `settings_manager.py` each carried a private copy and `model_scanner.py` compared raw strings. * `ModelScanner` compares root identities in `get_configured_model_roots()`, `describe_model_roots()` (dedupe + `available`), the reconcile's `configured_only` list and the `ReconcileScope.roots` membership test, so one directory is one root whatever the host called it. `_normalized_root_prefix()` is built on the same identity, and an empty prefix no longer matches every path. * A configured root that never made it into the live list is reported only while it still holds cached entries -- in the menu and in `skipped_roots` / `unavailable_paths` alike. A directory that neither exists nor was ever scanned has nothing to keep, so `<output>/loras` stops being an unavailable root. * The startup sync drops saved roots that neither exist nor hold cached entries (`PersistentModelCache.roots_with_cached_entries()`, one scan per model type, separator-agnostic and wildcard-escaped). A root named by the library's `default_*_root` is kept even when empty: dropping it would let the next boot "repair" the default onto another root. When the cache cannot be consulted, every root is kept. * `GET /scan?roots=` validates requested roots by identity too, so the browser extension or a script passing the spelling settings.json holds selects the root instead of answering 400 "Unknown model root(s)". Verified: 8 of the new tests fail against the pre-fix source (checked with the fix stashed); 3798 passed, 7 skipped, 11 deselected. The probe costs 71ms for a 100k-model library with seven missing roots (357ms when probing root by root).
37 lines
1.4 KiB
Python
37 lines
1.4 KiB
Python
"""Path identity helpers for model roots.
|
|
|
|
ComfyUI hands its model folders over in whatever spelling the host uses --
|
|
``os.path.normpath()`` output, which is all backslashes on Windows -- while LoRA
|
|
Manager's own root lists and cached model paths are forward-slashed. Comparing
|
|
the two spellings as raw strings makes one directory look like two roots, so every
|
|
root identity check goes through :func:`normalize_root_identity` (issue #1146).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import posixpath
|
|
|
|
|
|
def normalize_root_identity(path: str) -> str:
|
|
"""Return the comparable identity of a model root path.
|
|
|
|
Folds the separator style (``\\`` and ``/`` are both accepted as separators,
|
|
because the host may spell a Windows path either way), redundant and trailing
|
|
separators, and the case where the filesystem does not distinguish it: Windows
|
|
compares whole paths case-insensitively, and every platform folds a drive
|
|
letter (``E:`` == ``e:``). Symlinks are never resolved -- business paths stay
|
|
business paths, matching the rest of the codebase.
|
|
"""
|
|
|
|
if not isinstance(path, str):
|
|
return ""
|
|
candidate = path.strip()
|
|
if not candidate:
|
|
return ""
|
|
|
|
normalized = posixpath.normpath(candidate.replace("\\", "/"))
|
|
if os.name == "nt" or (len(normalized) >= 2 and normalized[1] == ":"):
|
|
return normalized.lower()
|
|
return normalized
|