mirror of
https://github.com/willmiao/ComfyUI-Lora-Manager.git
synced 2026-08-07 14:30:15 -03:00
56acefbd6c
Add /af and /noaf toggle commands (plus /activefilters aliases) to the
loras autocomplete widget. When enabled (default off), suggestions are
matched within the active filters (folder, base model, tags, auto-tags,
license, tag logic) persisted by the LoRA Manager page in localStorage,
keeping the match pool consistent with the list endpoint, including the
global show_only_sfw setting.
Backend: /lm/{prefix}/relative-paths accepts the filter query params and
pre-filters the scanner cache with ModelFilterSet. The presence of the
recursive param signals the filter pipeline to run even without concrete
filters so global settings stay in parity with the list endpoint.
382 lines
12 KiB
Python
382 lines
12 KiB
Python
import os
|
|
import pytest
|
|
|
|
from py.services.base_model_service import BaseModelService
|
|
from py.utils.models import BaseModelMetadata
|
|
|
|
|
|
class DummyService(BaseModelService):
|
|
async def format_response(self, model_data):
|
|
return model_data
|
|
|
|
|
|
class FakeCache:
|
|
def __init__(self, raw_data):
|
|
self.raw_data = list(raw_data)
|
|
|
|
|
|
class FakeScanner:
|
|
def __init__(self, raw_data, roots):
|
|
self._cache = FakeCache(raw_data)
|
|
self._roots = list(roots)
|
|
|
|
async def get_cached_data(self, *_args, **_kwargs):
|
|
return self._cache
|
|
|
|
def get_model_roots(self):
|
|
return list(self._roots)
|
|
|
|
|
|
class StubSettings:
|
|
"""Settings stub that returns defaults, avoiding the real settings singleton."""
|
|
|
|
def get(self, key, default=None):
|
|
return default
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_supports_multiple_tokens():
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/flux/detail-model.safetensors"},
|
|
{"file_path": "/models/flux/only-flux.safetensors"},
|
|
{"file_path": "/models/detail/flux-trained.safetensors"},
|
|
{"file_path": "/models/detail/standalone.safetensors"},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService("stub", scanner, BaseModelMetadata)
|
|
|
|
matching = await service.search_relative_paths("flux detail")
|
|
|
|
assert matching == [
|
|
f"flux{os.sep}detail-model.safetensors",
|
|
f"detail{os.sep}flux-trained.safetensors",
|
|
]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_excludes_tokens():
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/flux/detail-model.safetensors"},
|
|
{"file_path": "/models/flux/keep-me.safetensors"},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService("stub", scanner, BaseModelMetadata)
|
|
|
|
matching = await service.search_relative_paths("flux -detail")
|
|
|
|
assert matching == [f"flux{os.sep}keep-me.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_does_not_match_extension():
|
|
"""Searching for 's' or 'safe' should not match .safetensors extension."""
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/lora1.safetensors"},
|
|
{"file_path": "/models/lora2.safetensors"},
|
|
{"file_path": "/models/special-model.safetensors"}, # 's' in filename
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService("stub", scanner, BaseModelMetadata)
|
|
|
|
# Searching for 's' should only match 'special-model', not all .safetensors
|
|
matching = await service.search_relative_paths("s")
|
|
|
|
# Should only match 'special-model' because 's' is in the filename
|
|
assert len(matching) == 1
|
|
assert "special-model" in matching[0]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_safe_does_not_match_all_files():
|
|
"""Searching for 'safe' should not match .safetensors extension."""
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/flux.safetensors"},
|
|
{"file_path": "/models/detail.safetensors"},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService("stub", scanner, BaseModelMetadata)
|
|
|
|
# Searching for 'safe' should return nothing (no file has 'safe' in its name)
|
|
matching = await service.search_relative_paths("safe")
|
|
|
|
assert len(matching) == 0
|
|
|
|
|
|
class SfwStubSettings(StubSettings):
|
|
"""Settings stub with the global SFW filter enabled."""
|
|
|
|
def get(self, key, default=None):
|
|
if key == "show_only_sfw":
|
|
return True
|
|
return default
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_respects_global_sfw_setting():
|
|
"""Filtered search applies show_only_sfw like the list endpoint (parity)."""
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/sfw-model.safetensors", "preview_nsfw_level": 0},
|
|
{"file_path": "/models/nsfw-model.safetensors", "preview_nsfw_level": 4},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=SfwStubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths("model", apply_filters=True)
|
|
|
|
assert matching == ["sfw-model.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_sfw_only_applied_when_filter_mode_is_on():
|
|
"""Global settings (show_only_sfw) apply only when the filter pipeline runs."""
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/sfw-model.safetensors", "preview_nsfw_level": 0},
|
|
{"file_path": "/models/nsfw-model.safetensors", "preview_nsfw_level": 4},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=SfwStubSettings()
|
|
)
|
|
|
|
default_matching = await service.search_relative_paths("model")
|
|
|
|
assert default_matching == [
|
|
"sfw-model.safetensors",
|
|
"nsfw-model.safetensors",
|
|
]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_folder_filter_recursive():
|
|
"""folder filter with recursive=True (default) matches subfolders."""
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/anime/model-a.safetensors", "folder": "anime"},
|
|
{
|
|
"file_path": "/models/anime/nsfw/model-b.safetensors",
|
|
"folder": "anime/nsfw",
|
|
},
|
|
{"file_path": "/models/realistic/model-c.safetensors", "folder": "realistic"},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths("model", folder="anime")
|
|
|
|
assert matching == [
|
|
f"anime{os.sep}model-a.safetensors",
|
|
f"anime{os.sep}nsfw{os.sep}model-b.safetensors",
|
|
]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_folder_filter_exact():
|
|
"""folder filter with recursive=False matches only the exact folder."""
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/anime/model-a.safetensors", "folder": "anime"},
|
|
{
|
|
"file_path": "/models/anime/nsfw/model-b.safetensors",
|
|
"folder": "anime/nsfw",
|
|
},
|
|
{"file_path": "/models/realistic/model-c.safetensors", "folder": "realistic"},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths(
|
|
"model", folder="anime", recursive=False
|
|
)
|
|
|
|
assert matching == [f"anime{os.sep}model-a.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_base_model_filter():
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/model-a.safetensors", "base_model": "SD 1.5"},
|
|
{"file_path": "/models/model-b.safetensors", "base_model": "SDXL"},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths("model", base_models=["SD 1.5"])
|
|
|
|
assert matching == ["model-a.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_tag_include():
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/model-a.safetensors", "tags": ["anime"]},
|
|
{"file_path": "/models/model-b.safetensors", "tags": ["realistic"]},
|
|
{"file_path": "/models/model-c.safetensors", "tags": ["anime", "realistic"]},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths("model", tags={"anime": "include"})
|
|
|
|
assert set(matching) == {"model-a.safetensors", "model-c.safetensors"}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_tag_exclude():
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/model-a.safetensors", "tags": ["anime"]},
|
|
{"file_path": "/models/model-b.safetensors", "tags": ["realistic"]},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths("model", tags={"anime": "exclude"})
|
|
|
|
assert matching == ["model-b.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_auto_tag_include():
|
|
scanner = FakeScanner(
|
|
[
|
|
{
|
|
"file_path": "/models/model-i2v.safetensors",
|
|
"file_name": "model-i2v.safetensors",
|
|
},
|
|
{
|
|
"file_path": "/models/model-t2v.safetensors",
|
|
"file_name": "model-t2v.safetensors",
|
|
},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths(
|
|
"model", auto_tags={"I2V": "include"}
|
|
)
|
|
|
|
assert matching == ["model-i2v.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_tag_logic_all():
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/model-a.safetensors", "tags": ["anime", "style"]},
|
|
{"file_path": "/models/model-b.safetensors", "tags": ["anime"]},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths(
|
|
"model", tags={"anime": "include", "style": "include"}, tag_logic="all"
|
|
)
|
|
|
|
assert matching == ["model-a.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_credit_required_filter():
|
|
# license_flags bit0: 1 = no credit required, 0 = credit required
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/model-a.safetensors", "license_flags": 127},
|
|
{"file_path": "/models/model-b.safetensors", "license_flags": 0},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths("model", credit_required=True)
|
|
assert matching == ["model-b.safetensors"]
|
|
|
|
matching = await service.search_relative_paths("model", credit_required=False)
|
|
assert matching == ["model-a.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_allow_selling_filter():
|
|
# license_flags bit1: 1 = commercial image use allowed, 0 = not allowed
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/model-a.safetensors", "license_flags": 2},
|
|
{"file_path": "/models/model-b.safetensors", "license_flags": 1},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths(
|
|
"model", allow_selling_generated_content=True
|
|
)
|
|
assert matching == ["model-a.safetensors"]
|
|
|
|
matching = await service.search_relative_paths(
|
|
"model", allow_selling_generated_content=False
|
|
)
|
|
assert matching == ["model-b.safetensors"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_search_relative_paths_no_filters_regression():
|
|
"""No filter kwargs -> behavior is byte-identical to plain token matching."""
|
|
scanner = FakeScanner(
|
|
[
|
|
{"file_path": "/models/flux/detail-model.safetensors"},
|
|
{"file_path": "/models/flux/only-flux.safetensors"},
|
|
],
|
|
["/models"],
|
|
)
|
|
service = DummyService(
|
|
"stub", scanner, BaseModelMetadata, settings_provider=StubSettings()
|
|
)
|
|
|
|
matching = await service.search_relative_paths("flux")
|
|
|
|
assert matching == [
|
|
f"flux{os.sep}only-flux.safetensors",
|
|
f"flux{os.sep}detail-model.safetensors",
|
|
]
|
|
|