mirror of
https://github.com/willmiao/ComfyUI-Lora-Manager.git
synced 2026-10-07 18:12:12 -03:00
Will Miao
f4d0228d6b
`Config._dedupe_existing_paths()` drops roots whose directory does not exist
when the root list is built, so a drive that is switched off while LM starts was
not "an offline root" — it was not a root at all. The Refresh ▾ menu had no row
for it in either state, a full refresh reported nothing (its cached entries
survived only because they fall outside every configured prefix), and plugging
the drive back in changed nothing until the next restart.
* `Config` now records the configured (existence-unfiltered) paths per model
type — from ComfyUI's list in plugin mode, from the active library snapshot in
standalone mode, where the host mock filters non-existent paths itself — and
exposes them through `configured_roots_for()`.
* `ModelScanner.describe_model_roots()` appends configured-but-unavailable roots
with a live `reachable`, an `available` flag and their cached entry count, so
`/roots` (and therefore the menu) offers a row in both states: greyed while the
directory is missing, normal and clickable once it is back.
* `_reconcile_cache()` reports them as `skipped_roots` / `unavailable_paths` with
reason `root_unavailable` and counts their cached entries in `kept_unreachable`,
which is what makes the "N models kept" toast appear in the startup-offline
case. Report-only: they stay outside the scan scope, so nothing about pruning
changes. A root-scoped scan stays quiet about roots it was not asked about, and
a folder-scoped scan only mentions a missing root that holds cached entries of
that folder.
* `Config.admit_configured_roots()` re-runs the per-type prepare helpers against
the configured paths and APPENDS what is readable now (plus the
checkpoint/unet/other side maps), then refreshes the preview allowlist, so a
drive plugged in mid-session can be scanned without restarting. Append-only and
order-preserving by design: removing a root mid-session would let a later
settings save persist the loss, and re-sorting would move `*_roots[0]`, which
derives the recipes directory and the usage-stats file location. `_roots[0]`
never moves.
* `/roots` and `/scan` admit first, so `describe_model_roots()` stays a pure read
and a caller that never opens the menu (the browser extension) still gets a
drive that came back.
Verified on the sandbox with drive-Z switched off before startup: `/roots`
reports `drive-Z reachable=false available=false models=60`, a full refresh
returns `skipped_roots=[drive-Z root_unavailable]`,
`unavailable_paths=[{... kept: 60}]`, `kept_unreachable=60`, and all 432 models
stay cached. Renaming the drive back while the server runs admits it
(`available=true`) and `GET /scan?roots=<drive-Z>` walks it with no restart.
3714 passed, 7 skipped; frontend 1495 passed (149 files); vue widgets 96 passed.
133 lines
4.7 KiB
Python
133 lines
4.7 KiB
Python
"""Wave 6: configured roots that are unavailable must be reportable and
|
|
re-admitted append-only, never dropped from the live lists."""
|
|
|
|
import os
|
|
|
|
import pytest
|
|
|
|
from py import config as config_module
|
|
|
|
|
|
def _make_config(**overrides) -> config_module.Config:
|
|
config = config_module.Config.__new__(config_module.Config)
|
|
config._path_mappings = {}
|
|
config._preview_root_paths = set()
|
|
config._cached_fingerprint = None
|
|
config.loras_roots = []
|
|
config.extra_loras_roots = []
|
|
config.base_models_roots = []
|
|
config.checkpoints_roots = []
|
|
config.unet_roots = []
|
|
config.embeddings_roots = []
|
|
config.extra_checkpoints_roots = []
|
|
config.extra_unet_roots = []
|
|
config.extra_embeddings_roots = []
|
|
config.other_roots = []
|
|
config.recipes_path = ""
|
|
config.other_root_subtypes = {}
|
|
config.other_folder_roots = {}
|
|
config._configured_root_paths = {}
|
|
for key, value in overrides.items():
|
|
setattr(config, key, value)
|
|
return config
|
|
|
|
|
|
def _normalize(path) -> str:
|
|
return os.path.normpath(str(path)).replace(os.sep, "/")
|
|
|
|
|
|
class TestAppendNewPaths:
|
|
def test_appends_without_reordering_or_duplicating(self):
|
|
merged = config_module._append_new_paths(
|
|
["/b/loras", "/a/loras"], ["/a/loras", "/c/loras", "", None]
|
|
)
|
|
# Existing order is preserved (it derives *_roots[0] consumers) and the
|
|
# new root lands at the end.
|
|
assert merged == ["/b/loras", "/a/loras", "/c/loras"]
|
|
|
|
def test_matches_case_insensitively(self):
|
|
merged = config_module._append_new_paths(["C:/Loras"], ["c:/loras"])
|
|
assert merged == ["C:/Loras"]
|
|
|
|
|
|
class TestAdmitConfiguredRoots:
|
|
def test_admits_a_root_that_became_readable(self, tmp_path):
|
|
primary = tmp_path / "primary"
|
|
primary.mkdir()
|
|
drive = tmp_path / "drive-Z" / "loras"
|
|
|
|
config = _make_config(
|
|
loras_roots=[str(primary)],
|
|
_configured_root_paths={"lora": [str(primary), str(drive)]},
|
|
)
|
|
assert config.configured_roots_for("lora") == [str(primary), str(drive)]
|
|
|
|
# Still switched off: nothing to admit.
|
|
assert config.admit_configured_roots() == []
|
|
assert config.loras_roots == [str(primary)]
|
|
|
|
drive.mkdir(parents=True)
|
|
admitted = config.admit_configured_roots()
|
|
|
|
assert admitted == [str(drive)]
|
|
assert config.loras_roots == [str(primary), str(drive)]
|
|
# Idempotent: a second call adds nothing.
|
|
assert config.admit_configured_roots() == []
|
|
|
|
def test_never_removes_a_root_that_disappeared(self, tmp_path):
|
|
primary = tmp_path / "primary"
|
|
primary.mkdir()
|
|
drive = tmp_path / "drive-Z" / "loras"
|
|
drive.mkdir(parents=True)
|
|
|
|
config = _make_config(
|
|
loras_roots=[str(primary), str(drive)],
|
|
_configured_root_paths={"lora": [str(drive), str(primary)]},
|
|
)
|
|
|
|
# The drive is switched off after the lists were built: the live list
|
|
# keeps it (reporting and pruning decide separately) and admission must
|
|
# not "clean it up" — a later settings save would persist the loss.
|
|
drive.rmdir()
|
|
config.admit_configured_roots()
|
|
|
|
assert config.loras_roots == [str(primary), str(drive)]
|
|
|
|
def test_admits_every_model_type_and_its_side_maps(self, tmp_path):
|
|
checkpoint_dir = tmp_path / "checkpoints"
|
|
unet_dir = tmp_path / "unet"
|
|
embedding_dir = tmp_path / "embeddings"
|
|
other_dir = tmp_path / "vae"
|
|
for directory in (checkpoint_dir, unet_dir, embedding_dir, other_dir):
|
|
directory.mkdir()
|
|
|
|
config = _make_config(
|
|
_configured_root_paths={
|
|
"checkpoint": [str(checkpoint_dir)],
|
|
"unet": [str(unet_dir)],
|
|
"embedding": [str(embedding_dir)],
|
|
"other": [str(other_dir)],
|
|
},
|
|
)
|
|
config._get_enabled_other_folder_keys = lambda: ["vae"]
|
|
config._configured_other_paths_for_key = lambda key: [str(other_dir)]
|
|
|
|
admitted = config.admit_configured_roots()
|
|
|
|
assert set(admitted) == {
|
|
_normalize(checkpoint_dir),
|
|
_normalize(unet_dir),
|
|
_normalize(embedding_dir),
|
|
_normalize(other_dir),
|
|
}
|
|
assert config.base_models_roots == [
|
|
_normalize(checkpoint_dir),
|
|
_normalize(unet_dir),
|
|
]
|
|
assert config.checkpoints_roots == [_normalize(checkpoint_dir)]
|
|
assert config.unet_roots == [_normalize(unet_dir)]
|
|
assert config.embeddings_roots == [_normalize(embedding_dir)]
|
|
assert config.other_roots == [_normalize(other_dir)]
|
|
assert config.other_root_subtypes[_normalize(other_dir)] == "vae"
|
|
assert config.other_folder_roots["vae"] == [_normalize(other_dir)]
|