Auto-sync from GitHub Actions

README.md

@@ -347,23 +347,20 @@ thumbnail: >-
 POST /api/search
 {
     "query": "白色水手服的女孩",
-    "search_mode": "full_scene",
-    "category": "all",
+    "top_k": 5,
+    "limit": 80,
+    "popularity_weight": 0.15,
     "show_nsfw": true,
-    "include_wiki": false
+    "use_segmentation": true,
+    "target_layers": ["英文", "中文扩展词", "释义", "中文核心词"],
+    "target_categories": ["General", "Character", "Copyright"],
+    "group_mode": "off",
+    "max_per_group": 2
 }
 ```
 
-`search_mode` 使用预设检索策略，不再直接暴露 `top_k`、`limit`、`popularity_weight`、`use_segmentation` 等底层参数：
-
-| 模式 | 适用场景 |
-|---|---|
-| `full_scene` | 默认模式。用于完整画面、多人/多元素描述，返回可直接使用的 prompt |
-| `concept_explore` | 开放式概念发散，例如“兔耳朵都有哪些” |
-| `subject_describe` | 单一角色、物品或视觉概念描述，例如“EVA中蓝发的驾驶员” |
-| `precise_lookup` | 精确查词或拼写纠错，例如 `selafuku` |
-
-`category` 可选：`all`、`general`、`character`、`copyright`。搜索响应包含 `prompt`、`keywords`、`results`，当 `include_wiki=true` 时，每条结果会附带 `wiki` 字段。
+搜索接口保留底层可调参数，适合需要精细控制召回数量、分层检索、分词策略、类别筛选和分组去重的工作流。
+响应包含 `tags_all`、`tags_sfw`、`keywords`、`results`；每条结果默认包含完整字段和 `wiki`。
 
 **关联推荐接口**
 ```
@@ -371,12 +368,11 @@ POST /api/related
 {
     "tags": ["white_serafuku", "sailor_collar"],
     "limit": 50,
-    "show_nsfw": true,
-    "include_wiki": false
+    "show_nsfw": true
 }
 ```
 
-响应为 `results` 列表；如果输入标签拼写错误但可被纠正，会额外返回 `correction_note` 和 `corrections`。
+响应为 `results` 列表，每条结果默认包含 `wiki`；如果输入标签拼写错误但可被纠正，会额外返回 `correction_note` 和 `corrections`。
 
 **推荐擅长画师接口**
 ```

api_fastapi.py

@@ -27,10 +27,10 @@ FastAPI 适配层（可选）。
 from __future__ import annotations
 
 import asyncio
-import re
 from typing import Any
+from typing import Literal
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from core.engine import DanbooruTagger
 from core.models import SearchRequest, SearchResponse
@@ -39,26 +39,64 @@ import core.counter as counter
 
 # ── Pydantic I/O 模型（API 层专用，与 core.models 解耦）──
 
+LayerName = Literal['英文', '中文扩展词', '释义', '中文核心词', 'artist']
+CategoryName = Literal['General', 'Artist', 'Copyright', 'Character', 'Meta']
+GroupMode = Literal['off', 'expand', 'diverse']
+
 
 class SearchIn(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "query": "白色水手服的女孩",
+                "top_k": 5,
+                "limit": 80,
+                "popularity_weight": 0.15,
+                "show_nsfw": True,
+                "use_segmentation": True,
+                "target_layers": ['英文', '中文扩展词', '释义', '中文核心词', 'artist'],
+                "target_categories": ['General', 'Character', 'Copyright'],
+                "group_mode": "off",
+                "max_per_group": 2,
+            }
+        }
+    )
+
     query: str
-    search_mode: str = "full_scene"
-    category: str = "all"
+    top_k: int = Field(5, ge=1, le=50)
+    limit: int = Field(80, ge=1, le=500)
+    popularity_weight: float = Field(0.15, ge=0.0, le=1.0)
     show_nsfw: bool = True
-    include_wiki: bool = False
+    use_segmentation: bool = True
+    target_layers: list[LayerName] = Field(
+        default_factory=lambda: ['英文', '中文扩展词', '释义', '中文核心词'],
+        description="匹配层；可显式加入 'artist' 以返回编辑距离<=1的画师标签行。",
+    )
+    target_categories: list[CategoryName] = Field(
+        default_factory=lambda: ['General', 'Character', 'Copyright'],
+    )
+    group_mode: GroupMode = "off"
+    max_per_group: int = 2
 
 
 class TagOut(BaseModel):
     tag: str
     cn_name: str
+    category: str
+    nsfw: str
+    final_score: float
+    semantic_score: float
+    count: int
+    source: str
+    layer: str
     wiki: str = ""
+    artist_top_tags: list[str] = Field(default_factory=list)
 
 
 class RelatedIn(BaseModel):
     tags: list[str]
     limit: int = Field(50, ge=1, le=200)
     show_nsfw: bool = True
-    include_wiki: bool = False
 
 
 class RelatedTagOut(BaseModel):
@@ -69,10 +107,10 @@ class RelatedTagOut(BaseModel):
 
 
 class SearchOut(BaseModel):
-    prompt: str
+    tags_all: str
+    tags_sfw: str
     results: list[TagOut]
     keywords: list[str]
-    hint: str | None = None
 
 
 class ArtistIn(BaseModel):
@@ -90,21 +128,6 @@ class ArtistOut(BaseModel):
     top_tags: list[str]
 
 
-_SEARCH_MODE_PRESETS: dict[str, dict[str, Any]] = {
-    "precise_lookup": {"top_k": 10, "limit": 10, "popularity_weight": 0.15, "use_segmentation": False, "group_mode": "off", "max_per_group": 2},
-    "concept_explore": {"top_k": 80, "limit": 80, "popularity_weight": 0.15, "use_segmentation": True, "group_mode": "expand", "max_per_group": 2},
-    "subject_describe": {"top_k": 20, "limit": 20, "popularity_weight": 0.15, "use_segmentation": False, "group_mode": "off", "max_per_group": 2},
-    "full_scene": {"top_k": 5, "limit": 80, "popularity_weight": 0.15, "use_segmentation": True, "group_mode": "diverse", "max_per_group": 2},
-}
-
-_CATEGORY_MAP: dict[str, list[str]] = {
-    "all": ["General", "Character", "Copyright", "Artist", "Meta"],
-    "general": ["General"],
-    "character": ["Character"],
-    "copyright": ["Copyright"],
-}
-
-
 async def _correct_tags(tagger: DanbooruTagger, tags: list[str]) -> tuple[list[str], list[str], dict[str, str]]:
     valid_tags: list[str] = []
     invalid_tags: list[str] = []
@@ -163,24 +186,12 @@ app = FastAPI(
 
 # ── 端点 ──
 
-@app.post("/search")
-async def search(body: SearchIn) -> dict[str, Any]:
+@app.post("/search", response_model=SearchOut)
+async def search(body: SearchIn) -> SearchOut:
     tagger = await DanbooruTagger.get_instance()
 
     # SearchIn → core.models.SearchRequest（两者字段一一对应，直接解包）
-    preset = _SEARCH_MODE_PRESETS.get(body.search_mode, _SEARCH_MODE_PRESETS["full_scene"])
-    target_categories = _CATEGORY_MAP.get(body.category, _CATEGORY_MAP["all"])
-    request = SearchRequest(
-        query=body.query,
-        top_k=preset["top_k"],
-        limit=preset["limit"],
-        popularity_weight=preset["popularity_weight"],
-        show_nsfw=body.show_nsfw,
-        use_segmentation=preset["use_segmentation"],
-        target_categories=target_categories,
-        group_mode=preset["group_mode"],
-        max_per_group=preset["max_per_group"],
-    )
+    request = SearchRequest(**body.model_dump())
 
     # 并发安全的异步 search（信号量串行化 + 线程池执行）
     try:
@@ -193,27 +204,12 @@ async def search(body: SearchIn) -> dict[str, Any]:
     await counter.increment_success()
     await counter.increment_copy()
 
-    results: list[dict[str, Any]] = []
-    for result in response.results:
-        if result.nsfw == '1' and not body.show_nsfw:
-            continue
-        item = {
-            "tag": result.tag,
-            "cn_name": result.cn_name,
-        }
-        if body.include_wiki:
-            item["wiki"] = result.wiki
-        results.append(item)
-
-    payload: dict[str, Any] = {
-        "prompt": response.tags_sfw if not body.show_nsfw else response.tags_all,
-        "keywords": response.keywords,
-        "results": results,
-    }
-    han_chars = re.findall(r'[\u4e00-\u9fff]', body.query)
-    if body.query and len(han_chars) / len(body.query) < 0.5:
-        payload["hint"] = "检测到英文查询，该搜索引擎对中文查询优化更好，如果搜索结果不合预期，推荐用中文重试"
-    return payload
+    return SearchOut(
+        tags_all=response.tags_all,
+        tags_sfw=response.tags_sfw,
+        results=[TagOut(**vars(result)) for result in response.results],
+        keywords=response.keywords,
+    )
 
 
 @app.post("/related")
@@ -250,8 +246,7 @@ async def related(body: RelatedIn) -> dict[str, Any]:
             "cn_name": result.cn_name,
             "sources": result.sources,
         }
-        if body.include_wiki:
-            item["wiki"] = result.wiki
+        item["wiki"] = result.wiki
         output.append(item)
 
     return _with_corrections(output, corrections)

core/engine.py

@@ -396,6 +396,29 @@ class DanbooruTagger:
         if cached is not None:
             return cached
 
+        tag_results, keywords, extra_segments, cached_queries = self._search_tag_results(request)
+        artist_results = (
+            self.search_artist_rows(request.query, request.limit, show_nsfw=request.show_nsfw)
+            if "artist" in request.target_layers else []
+        )
+        if artist_results:
+            artist_tags = {r.tag for r in artist_results}
+            tag_results = [r for r in tag_results if r.tag not in artist_tags]
+        valid = artist_results + tag_results
+
+        tags_all = ', '.join(r.tag for r in valid)
+        tags_sfw = ', '.join(r.tag for r in valid if r.nsfw != '1')
+        response = SearchResponse(
+            tags_all=tags_all, tags_sfw=tags_sfw,
+            results=valid, keywords=keywords, segments=extra_segments,
+            cached_queries=cached_queries,
+        )
+        self._search_cache.put(cache_key, response)
+        return response
+
+    def _search_tag_results(
+        self, request: SearchRequest,
+    ) -> tuple[list[TagResult], list[str], list[str], list[str]]:
         if request.use_segmentation:
             raw_kw, raw_segments = self._smart_split(request.query)
             keywords = [w.strip() for w in raw_kw if w.strip() and w.strip() not in STOP_WORDS]
@@ -554,16 +577,8 @@ class DanbooruTagger:
                 if len(valid) < request.limit or r.tag in guaranteed_tags:
                     valid.append(r)
 
-        tags_all = ', '.join(r.tag for r in valid)
-        tags_sfw = ', '.join(r.tag for r in valid if r.nsfw != '1')
         cached_queries = [q for q, hit in zip(queries, hit_mask) if hit]
-        response = SearchResponse(
-            tags_all=tags_all, tags_sfw=tags_sfw,
-            results=valid, keywords=keywords, segments=extra_segments,
-            cached_queries=cached_queries,
-        )
-        self._search_cache.put(cache_key, response)
-        return response
+        return valid, keywords, extra_segments, cached_queries
 
     # ── CPU 并发闸门（类级信号量，所有 CPU 密集型操作共享）───────────────
 
@@ -1339,6 +1354,68 @@ class DanbooruTagger:
     def _compact_artist_key(name: str) -> str:
         return re.sub(r"[\W_]+", "", str(name or "").lower())
 
+    @staticmethod
+    def _edit_distance_at_most_one(left: str, right: str) -> bool:
+        if left == right:
+            return True
+        if abs(len(left) - len(right)) > 1:
+            return False
+
+        if len(left) == len(right):
+            mismatches = 0
+            for a, b in zip(left, right):
+                if a != b:
+                    mismatches += 1
+                    if mismatches > 1:
+                        return False
+            return True
+
+        short, long = (left, right) if len(left) < len(right) else (right, left)
+        i = j = edits = 0
+        while i < len(short) and j < len(long):
+            if short[i] == long[j]:
+                i += 1
+                j += 1
+                continue
+            edits += 1
+            if edits > 1:
+                return False
+            j += 1
+        return True
+
+    def search_artist_rows(
+        self, query: str, limit: int = 20, show_nsfw: bool = True,
+    ) -> list[TagResult]:
+        """Return artist rows whose normalized name is within edit distance 1."""
+        normalized = self._normalize_artist_name(query)
+        compact_query = self._compact_artist_key(normalized)
+        if not compact_query:
+            return []
+
+        matches: list[TagResult] = []
+        for artist in sorted(self._artist_top_tags.keys()):
+            if not self._edit_distance_at_most_one(compact_query, self._compact_artist_key(artist)):
+                continue
+            top_tags = self.get_artist_top_tags(
+                [artist], top_n=10, show_nsfw=show_nsfw,
+            ).get(artist, [])
+            matches.append(TagResult(
+                tag=artist,
+                cn_name="画师标签",
+                category="Artist",
+                nsfw="0",
+                final_score=1.0,
+                semantic_score=1.0,
+                count=int(self._artist_post_count.get(artist, 0)),
+                source=query,
+                layer="artist",
+                wiki="",
+                artist_top_tags=top_tags,
+            ))
+
+        matches.sort(key=lambda r: (r.count, r.tag), reverse=True)
+        return matches[:limit]
+
     def resolve_artist_name(self, artist_name: str) -> dict[str, Any]:
         """Resolve a user-entered artist name to the artist co-occurrence index."""
         artists = set(self._artist_top_tags.keys())

core/models.py

@@ -18,6 +18,7 @@ class TagResult:
     source: str
     layer: str
     wiki: str = ""
+    artist_top_tags: list[str] = field(default_factory=list)
 
 
 @dataclass
@@ -72,4 +73,4 @@ class SearchResponse:
     results: list[TagResult]
     keywords: list[str]
     segments: list[str] = field(default_factory=list)  # 分隔符切分后的原始从句级片段
-    cached_queries: list[str] = field(default_factory=list)  # 命中 emb 缓存的查询文本
+    cached_queries: list[str] = field(default_factory=list)  # 命中 emb 缓存的查询文本

ui_nicegui.py

@@ -207,7 +207,7 @@ class DanbooruSearchUI:
         self.spinner = None
         self.search_btn = None
 
-        self.selected_layers = {'英文': True, '中文扩展词': True, '释义': True, '中文核心词': True}
+        self.selected_layers = {'英文': True, '中文扩展词': True, '释义': True, '中文核心词': True, 'artist': True}
         self.selected_cats = {'General': True, 'Copyright': True, 'Character': True}
 
         self.bad_case_btn = None
@@ -229,6 +229,8 @@ class DanbooruSearchUI:
         self._artist_rec_checkboxes: dict[str, ui.checkbox] = {}
         # 当前推荐画师的标签名集合（用于 Anima 模式复制时加 @ 前缀）
         self._current_artist_rec_tags: set[str] = set()
+        self._artist_result_tags: set[str] = set()
+        self._last_recommendation_seed_tags: list[str] = []
 
         # 高级选项中各层/类型的 checkbox 引用，用于 restore 时同步控件状态
         self._layer_checkboxes: dict[str, ui.checkbox] = {}
@@ -739,8 +741,9 @@ class DanbooruSearchUI:
                             display_map = {
                                 '英文': '英文标签', '中文扩展词': '中文扩展词',
                                 '释义': '维基释义', '中文核心词': '中文核心词',
+                                'artist': 'artist',
                             }
-                            for layer in ['英文', '中文扩展词', '释义', '中文核心词']:
+                            for layer in ['英文', '中文扩展词', '释义', '中文核心词', 'artist']:
                                 cb = ui.checkbox(
                                     display_map.get(layer, layer), value=True,
                                     on_change=lambda e, l=layer: self.selected_layers.__setitem__(l, e.value)
@@ -981,6 +984,8 @@ class DanbooruSearchUI:
             self.result_table.selected = []
         self._artist_rec_checkboxes.clear()
         self._current_artist_rec_tags.clear()
+        self._artist_result_tags.clear()
+        self._last_recommendation_seed_tags = []
         self._render_selected_chips()
         if self.selection_count_label is not None:
             self.selection_count_label.text = '0'
@@ -1025,6 +1030,7 @@ class DanbooruSearchUI:
                           :class="props.row._nsfw_blocked ? 'nsfw-row-blocked' : ''"
                           :style="{
                               'background-color':
+                                  props.row.layer === 'artist'       ? 'rgba(244,114,182,0.08)' :
                                   props.row.category === 'General'   ? 'rgba(59,130,246,0.06)' :
                                   props.row.category === 'Character' ? 'rgba(34,197,94,0.06)'  :
                                   props.row.category === 'Copyright' ? 'rgba(168,85,247,0.06)' : ''
@@ -1036,7 +1042,7 @@ class DanbooruSearchUI:
                         <q-td v-for="col in props.cols" :key="col.name" :props="props">
                             <template v-if="col.name === 'tag' || col.name === 'cn_name'">
                                 <div :class="props.row._nsfw_blocked ? 'nsfw-blur-cell' : ''">
-                                    <template v-if="col.name === 'cn_name' && col.value">
+                                    <template v-if="col.name === 'cn_name' && col.value && props.row.layer !== 'artist'">
                                         <span style="font-size:14px;display:inline-flex;align-items:center;gap:4px;">
                                             <span>{{ col.value.split(',')[0] }}</span>
                                             <q-btn icon="report_problem"
@@ -1073,7 +1079,17 @@ class DanbooruSearchUI:
                             </template>
                             <template v-else>{{ col.value }}</template>
                         </q-td>
-                        <q-tooltip v-if="(props.row.wiki || props.row.cn_name) && !props.row._nsfw_blocked"
+                        <q-tooltip v-if="props.row.layer === 'artist' && props.row.artist_top_tags && props.row.artist_top_tags.length && !props.row._nsfw_blocked"
+                            content-class="bg-black text-white shadow-4"
+                            max-width="400px" :offset="[10,10]">
+                            <div style="font-size:14px;line-height:1.5;max-width:380px;">
+                                <b>{{ props.row.tag }}</b><br>这位画师经常画:<br>
+                                <template v-for="tag in props.row.artist_top_tags.slice(0, 10)" :key="tag">
+                                    &nbsp;&nbsp;· {{ tag }}<br>
+                                </template>
+                            </div>
+                        </q-tooltip>
+                        <q-tooltip v-else-if="(props.row.wiki || props.row.cn_name) && !props.row._nsfw_blocked"
                             content-class="bg-black text-white shadow-4"
                             max-width="500px" :offset="[10,10]">
                             <div style="font-size:14px;line-height:1.5;">
@@ -1353,6 +1369,7 @@ class DanbooruSearchUI:
                 return
 
             table_data = [result_to_row(r, show_nsfw_val) for r in response.results]
+            self._artist_result_tags = {row['tag'] for row in table_data if row.get('layer') == 'artist'}
             self.full_table_data = table_data
             self.full_tags_str = response.tags_all
             self.full_tags_str_sfw = response.tags_sfw
@@ -1372,6 +1389,7 @@ class DanbooruSearchUI:
             self._save_staged_tags()
 
             self._refresh_related([], show_nsfw_val)
+            self._last_recommendation_seed_tags = []
 
             # 分词筛选 chips
             self.current_filter_keyword = 'ALL'
@@ -1436,6 +1454,26 @@ class DanbooruSearchUI:
         extra = [t for t in self.chip_extra_selected if t not in seen]
         return table_tags + extra
 
+    def _get_recommendation_seed_tags(self, selected_tags: list[str]) -> list[str]:
+        artist_tags = set(self._current_artist_rec_tags) | set(self._artist_result_tags)
+        if self.result_table is not None:
+            for row in self.result_table.rows:
+                if row.get('layer') != 'artist':
+                    continue
+                tag = row.get('tag')
+                if tag:
+                    artist_tags.add(tag)
+        return [tag for tag in selected_tags if tag not in artist_tags]
+
+    def _refresh_recommendations_if_seed_changed(self, selected_tags: list[str], show_nsfw: bool):
+        seed_tags = self._get_recommendation_seed_tags(selected_tags)
+        if seed_tags == self._last_recommendation_seed_tags:
+            return
+        self._last_recommendation_seed_tags = list(seed_tags)
+        self._refresh_related_from_selection(seed_tags, show_nsfw)
+        self._refresh_group_from_selection(seed_tags, show_nsfw)
+        self._refresh_artist_from_selection(seed_tags, show_nsfw)
+
     def _set_selected_tags(self, tags: list[str], skip_refresh: bool = False):
         tag_set = set(tags)
         table_tag_set = {row['tag'] for row in self.result_table.rows} if self.result_table else set()
@@ -1463,9 +1501,7 @@ class DanbooruSearchUI:
         # 从关联推荐/同类标签勾选时跳过，由各自动态刷新或手动按钮触发。
         if not skip_refresh:
             show_nsfw_val = self.input_nsfw.value
-            self._refresh_related_from_selection(all_tags, show_nsfw_val)
-            self._refresh_group_from_selection(all_tags, show_nsfw_val)
-            self._refresh_artist_from_selection(all_tags, show_nsfw_val)
+            self._refresh_recommendations_if_seed_changed(all_tags, show_nsfw_val)
             if not all_tags:
                 self.chip_extra_selected.clear()
 
@@ -1493,9 +1529,7 @@ class DanbooruSearchUI:
             cb.set_value(t in tag_set)
 
         show_nsfw_val = self.input_nsfw.value
-        self._refresh_related_from_selection(all_tags, show_nsfw_val)
-        self._refresh_group_from_selection(all_tags, show_nsfw_val)
-        self._refresh_artist_from_selection(all_tags, show_nsfw_val)
+        self._refresh_recommendations_if_seed_changed(all_tags, show_nsfw_val)
         if not all_tags:
             self.chip_extra_selected.clear()
         self._save_staged_tags()
@@ -1605,6 +1639,7 @@ class DanbooruSearchUI:
 
     def _refresh_related_from_selection(self, selected_tags: list[str], show_nsfw: bool):
         """仅刷新关联推荐列表（300ms 去抖，避免快速勾选产生 CPU 洪峰）。"""
+        selected_tags = self._get_recommendation_seed_tags(selected_tags)
         # 取消上次未执行的刷新
         if self._debounce_related_task and not self._debounce_related_task.done():
             self._debounce_related_task.cancel()
@@ -1625,6 +1660,7 @@ class DanbooruSearchUI:
 
     def _refresh_group_from_selection(self, selected_tags: list[str], show_nsfw: bool):
         """仅刷新同类扩展区域（300ms 去抖，避免快速勾选产生 CPU 洪峰）。"""
+        selected_tags = self._get_recommendation_seed_tags(selected_tags)
         if self._debounce_group_task and not self._debounce_group_task.done():
             self._debounce_group_task.cancel()
         async def _do():
@@ -1645,6 +1681,7 @@ class DanbooruSearchUI:
 
     def _refresh_artist_from_selection(self, selected_tags: list[str], show_nsfw: bool = True):
         """根据已选标签刷新画师推荐（300ms 去抖）。"""
+        selected_tags = self._get_recommendation_seed_tags(selected_tags)
         if self._debounce_artist_task and not self._debounce_artist_task.done():
             self._debounce_artist_task.cancel()
         async def _do():
@@ -1888,9 +1925,10 @@ class DanbooruSearchUI:
         self._mark_interaction()
         tags = self._get_selected_tags()
         parts = []
+        artist_tags = set(self._current_artist_rec_tags) | set(self._artist_result_tags)
         for t in tags:
             w = self.tag_weights.get(t, 1.0)
-            if self.prompt_format == 'anima' and t in self._current_artist_rec_tags:
+            if self.prompt_format == 'anima' and t in artist_tags:
                 parts.append(_format_tag_with_weight(f'@{t}', w, self.prompt_format))
             else:
                 parts.append(_format_tag_with_weight(t, w, self.prompt_format))