Auto-sync from GitHub Actions

api_fastapi.py

@@ -104,8 +104,8 @@ async def search(body: SearchIn) -> SearchOut:
     # SearchIn → core.models.SearchRequest（两者字段一一对应，直接解包）
     request = SearchRequest(**body.model_dump())
 
-    # 在线程池中运行阻塞的 search()
-    response: SearchResponse = await asyncio.to_thread(tagger.search, request)
+    # 并发安全的异步 search（信号量串行化 + 线程池执行）
+    response: SearchResponse = await tagger.search_async(request)
 
     # 计数：每次 API 搜索调用均计入搜索、成功、复制；访问不变
     await counter.increment()

core/engine.py

@@ -37,6 +37,10 @@ from platform_utils import (
 )
 
 
+# 限制 PyTorch CPU 线程数，给 asyncio 事件循环留出至少一个核心。
+torch.set_num_threads(max(1, (os.cpu_count() or 2) - 1))
+
+
 # LRU 缓存
 class LRUCache:
     def __init__(self, maxsize: int):
@@ -158,6 +162,9 @@ class DanbooruTagger:
 
     _instance: Optional['DanbooruTagger'] = None
     _lock: Optional[asyncio.Lock] = None
+    # 进程级搜索并发信号量：串行化 search()，避免多个 model.encode()
+    # 并发抢占 CPU 而拖垮事件循环。
+    _search_sem: Optional[asyncio.Semaphore] = None
 
     @classmethod
     def is_ready(cls) -> bool:
@@ -536,6 +543,21 @@ class DanbooruTagger:
         self._search_cache.put(cache_key, response)
         return response
 
+    @classmethod
+    def _get_search_sem(cls) -> asyncio.Semaphore:
+        if cls._search_sem is None:
+            cls._search_sem = asyncio.Semaphore(1)
+        return cls._search_sem
+
+    async def search_async(self, request: SearchRequest) -> SearchResponse:
+        """search() 的并发安全异步封装：信号量串行化 + 线程池执行。
+
+        所有异步入口（MCP / API / UI）都应改用本方法，而非各自
+        asyncio.to_thread(self.search)，以共享同一个并发闸门。
+        """
+        async with self._get_search_sem():
+            return await asyncio.to_thread(self.search, request)
+
     def _apply_group_expand(self, final: dict[str, TagResult]) -> None:
         """expand 模式：提升同 group 标签的分数。"""
         BETA = 0.2
@@ -777,7 +799,11 @@ class DanbooruTagger:
     _EN_MAX_COMPOUND = 4  # 复合标签最大单词数
 
     def _tokenize_en_chunk(self, chunk: str) -> list[str]:
-        """对一段英文文本做分词：清洗 → 按空格切分 → 过滤停用词/纯数 → 合并已知复合标签。"""
+        """对一段英文文本做分词：清洗 → 按空格切分 → 过滤停用词/纯数 → 变体规范化 → 合并已知复合标签。
+
+        变体规范化指：未直接命中 tag_set 的 token 尝试 `连字符→下划线` /
+        复数还原（s/es/ies→y），仅在变体落在 tag_set 才采用。
+        """
         cleaned = re.sub(r'[,()\[\]{}:]', ' ', chunk)
         raw = [p for p in cleaned.split() if p]
         tag_set = getattr(self, '_tag_names_set', None)
@@ -790,6 +816,11 @@ class DanbooruTagger:
                 continue
             if low in STOP_WORDS:
                 continue
+            # 连字符/复数变体探测（仅当变体落在 tag_set 才采用）
+            variant = self._resolve_tag_variant(low)
+            if variant:
+                tokens.append(variant)
+                continue
             if part.isdigit():      # 仅过滤纯数字，保留 3d/2b 等含数字的词
                 continue
             tokens.append(low)
@@ -797,6 +828,44 @@ class DanbooruTagger:
             return []
         return self._merge_compound_english(tokens)
 
+    def _resolve_tag_variant(self, low: str) -> str | None:
+        """对未直接命中 tag_set 的英文 token 探测常见变体。
+
+        覆盖：连字符→下划线（cat-ears → cat_ears）、复数→单数
+        （cats → cat / dresses → dress / bunnies → bunny）。
+        仅在变体落在 _tag_names_set 中才返回，避免 'glass'→'glas' 之类误伤。
+
+        Returns:
+            命中的 tag 名；都不命中返回 None。
+        """
+        tag_set = getattr(self, '_tag_names_set', None)
+        if not tag_set:
+            return None
+
+        # 连字符直接换成下划线若直接命中 tag 则优先返回
+        bases = [low]
+        if '-' in low:
+            hyphen_normalized = low.replace('-', '_')
+            if hyphen_normalized in tag_set:
+                return hyphen_normalized
+            bases.append(hyphen_normalized)
+
+        # 对每个基串尝试复数还原（按"剥离短→长"顺序，避免 houses→hous 误判）
+        for base in bases:
+            if base.endswith('s') and len(base) > 1:
+                v = base[:-1]
+                if v in tag_set:
+                    return v
+            if base.endswith('es') and len(base) > 2:
+                v = base[:-2]
+                if v in tag_set:
+                    return v
+            if base.endswith('ies') and len(base) > 3:
+                v = base[:-3] + 'y'
+                if v in tag_set:
+                    return v
+        return None
+
     def _merge_compound_english(self, tokens: list[str]) -> list[str]:
         """将相邻英文单词合并为已知的 Danbooru 下划线复合标签。
 

mcp_server.py

@@ -17,6 +17,8 @@ MCP 服务层
 
 import json
 import asyncio
+import logging
+from anyio import BrokenResourceError, ClosedResourceError
 from mcp.server.fastmcp import FastMCP
 from mcp.server.transport_security import TransportSecuritySettings
 from core.engine import DanbooruTagger
@@ -25,6 +27,20 @@ import core.counter as counter
 import re
 
 
+# ── 过滤客户端断连产生的无害报错噪音 ──────────────────────────────────
+class _SuppressClientDisconnect(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        exc = record.exc_info[1] if record.exc_info else None
+        if isinstance(exc, (BrokenResourceError, ClosedResourceError)):
+            return False  # 丢弃该日志记录
+        return True
+
+
+_disconnect_filter = _SuppressClientDisconnect()
+logging.getLogger("mcp.server.streamable_http").addFilter(_disconnect_filter)
+logging.getLogger("uvicorn.error").addFilter(_disconnect_filter)
+
+
 mcp = FastMCP(
     name="danbooru-searcher",
     transport_security=TransportSecuritySettings(enable_dns_rebinding_protection=False),
@@ -198,7 +214,7 @@ Each result: tag, cn_name, category, final_score, count[, wiki if include_wiki=T
         group_mode=group_mode,
         max_per_group=max_per_group,
     )
-    response = await asyncio.to_thread(tagger.search, request)
+    response = await tagger.search_async(request)
     # 计数：每次 MCP 搜索调用均计入搜索、成功、复制；访问不变
     await counter.increment()
     await counter.increment_success()
@@ -307,7 +323,7 @@ JSON array sorted by aggregated NPMI score (descending). Each result:
                     use_segmentation=False,
                     target_layers=['英文']
                 )
-                resp = await asyncio.to_thread(tagger.search, req)
+                resp = await tagger.search_async(req)
                 if resp.results:
                     corrections[bad_tag] = resp.results[0].tag
             except Exception:

ui_nicegui.py

@@ -1179,7 +1179,7 @@ class DanbooruSearchUI:
                 group_mode=self.input_group_mode.value if self.input_group_mode else 'off',
                 max_per_group=int(self.input_max_per_group.value) if self.input_max_per_group else 2,
             )
-            response = await run.io_bound(tagger.search, request)
+            response = await tagger.search_async(request)
 
             # 后台计数
             async def silent_counter_update():