feat: 全面重构GUI与日志系统

本次提交对项目进行了大规模的现代化改造，核心在于GUI的视觉革新和日志系统的完全重构，旨在提升用户体验和代码质量。

**主要改动:**

### 1. GUI 全面革新
- **新主题**: 废弃 `qdarkstyle`，引入名为 "Otaku-Sync Soft & Fresh Theme" 的自定义浅色主题，视觉上更柔和、现代化。
- **映射编辑器重构**: 彻底改造了映射文件编辑器，增加了搜索、左右分栏布局、未保存状态提示 (`*`) 及安全退出确认，显著提升了易用性。
- **国际化**: 为Qt标准对话框添加了中文翻译。

### 2. 日志系统重构
- **标准化**: 全面迁移到 Python 官方的 `logging` 模块，并引入 `rich` 库美化终端输出。
- **分级显示**:
  - **CLI**: 默认日志更简洁。通过设置 `LOG_LEVEL=DEBUG` 环境变量可开启“调试模式”，显示含文件路径和行号的详细信息。
  - **GUI**: 日志在界面上保持干净，只显示核心信息。
- **代码解耦**: 移除了旧的 `patch_logger` 猴子补丁机制，代码更健壮。

### 3. Bug 修复
- 修正了 `scripts/inspect_notion_fields.py` 脚本中因在同步函数里使用 `await` 导致的语法错误。

### 4. 文档更新
- 同步更新了 `GEMINI.md`, `utils/GEMINI.md`, `gui/GEMINI.md` 等文档，以准确反映新的架构和功能。

Author: baiheyyds

GEMINI.md

@@ -13,14 +13,14 @@ Otaku-Sync 是一款自动化工具，其核心目标是从多个在线数据源
 - **`core/`**: 包含了所有的核心业务逻辑，如数据抓取、信息处理和同步。此模块与具体的 UI 实现无关。
 - **`core/interaction.py`**: 定义了一个抽象接口，所有需要用户输入或交互的场景（例如，让用户从列表中选择、确认操作或输入文本）都必须通过此接口进行。
 - **UI 实现**:
-    - **GUI (`run_gui.py`, `gui/`, `utils/gui_bridge.py`)**: 通过一个基于 Qt (PySide6) 的现代化图形界面实现交互提供者接口。该界面采用了 `qdarkstyle` 库提供的暗色主题，并通过 `gui/style.qss` 进行自定义美化。主窗口使用标签页 (`QTabWidget`) 来组织不同的功能模块（如批处理工具、映射文件编辑器），布局则通过自定义的 `FlowLayout` 等组件实现，提供了用户友好的操作体验。
+    - **GUI (`run_gui.py`, `gui/`)**: 通过一个基于 Qt (PySide6) 的现代化图形界面实现交互提供者接口。该界面采用在 `gui/style.qss` 中定义的自定义浅色主题，取代了原有的 `qdarkstyle` 库，提供了更统一和现代化的视觉体验。主窗口使用标签页 (`QTabWidget`) 来组织不同的功能模块（如批处理工具、映射文件编辑器），布局则通过自定义的 `FlowLayout` 等组件实现，提供了用户友好的操作体验。
     - **CLI (`main.py`)**: 通过简单的命令行提示（如 `input()`）来实现交互提供者接口。
 
 这种架构保证了项目的高度可维护性和可扩展性。例如，未来可以在不改动任何核心逻辑的情况下，轻松地为项目添加一个新的 Web 前端。
 
 ## 3. 主要入口点
 
-- **`run_gui.py`**: **GUI 模式**的入口文件。它负责初始化 `QApplication`、应用 `qdarkstyle` 和自定义样式，并启动主窗口 `MainWindow`。这是为大多数用户推荐的运行方式。
+- **`run_gui.py`**: **GUI 模式**的入口文件。它负责初始化 `QApplication`、加载并应用在 `gui/style.qss` 中定义的自定义样式，并启动主窗口 `MainWindow`。这是为大多数用户推荐的运行方式。
 - **`main.py`**: **CLI 模式**的入口文件。它包含一个主异步循环，负责提示用户输入、处理单个游戏，然后重复此过程。
 
 ## 4. 关键模块与目录

batch_updater.py

@@ -1,11 +1,11 @@
 # batch_updater.py
 import asyncio
+import logging
 import re
 from tqdm import tqdm
 from typing import List, Dict, Any
 
 from core.init import init_context, close_context
-from utils import logger
 from config.config_token import GAME_DB_ID, BRAND_DB_ID, CHARACTER_DB_ID
 from config.config_fields import FIELDS
 
@@ -126,7 +126,7 @@ async def preprocess_item(context, page: Dict[str, Any], db_key: str) -> Dict[st
         }
     except Exception as e:
         page_title = context["notion"].get_page_title(page)
-        logger.warn(f"预处理 '{page_title}' 时失败: {e}")
+        logging.warning(f"⚠️ 预处理 '{page_title}' 时失败: {e}")
         return None
 
 
@@ -171,7 +171,7 @@ async def write_item_to_notion(context, item_data: Dict[str, Any], db_key: str):
             warned_keys = set()
             await context["bangumi"].create_or_update_character(bangumi_data, warned_keys)
     except Exception as e:
-        logger.error(f"写入页面 '{page_title}' ({page_id}) 时出错: {e}")
+        logging.error(f"❌ 写入页面 '{page_title}' ({page_id}) 时出错: {e}")
 
 
 async def batch_update(context, dbs_to_update: List[str]):
@@ -180,14 +180,14 @@ async def batch_update(context, dbs_to_update: List[str]):
 
     for db_key in dbs_to_update:
         config = DB_CONFIG[db_key]
-        logger.step(f"开始处理 {config['name']}...")
+        logging.info(f"🚀 开始处理 {config['name']}...")
 
         all_pages = await notion_client.get_all_pages_from_db(config["id"])
         if not all_pages:
-            logger.warn(f"{config['name']} 中没有找到任何页面。")
+            logging.warning(f"⚠️ {config['name']} 中没有找到任何页面。")
             continue
 
-        logger.info(f"共找到 {len(all_pages)} 个条目，将以每批 {CONCURRENCY_LIMIT} 个并发处理...")
+        logging.info(f"✅ 共找到 {len(all_pages)} 个条目，将以每批 {CONCURRENCY_LIMIT} 个并发处理...")
 
         # 使用tqdm包装分块器，以批次为单位显示进度
         for page_chunk in tqdm(
@@ -215,13 +215,13 @@ async def batch_update(context, dbs_to_update: List[str]):
                     async with interaction_lock:
                         await write_item_to_notion(context, item, db_key)
 
-        logger.success(f"{config['name']} 处理完成！")
+        logging.info(f"✅ {config['name']} 处理完成！")
 
 
 async def main():
     dbs_to_update = get_user_choice()
     if not dbs_to_update:
-        logger.info("用户选择退出。")
+        logging.info("🔍 用户选择退出。")
         return
 
     context = await init_context()
@@ -243,26 +243,26 @@ async def new_handle_new_key_wrapper(
             target_db_id,
         )
         if result and result not in schema_manager.get_schema(target_db_id):
-            logger.system(f"检测到新属性 '{result}' 已创建，正在刷新数据库结构...")
+            logging.info(f"🔧 检测到新属性 '{result}' 已创建，正在刷新数据库结构...")
             db_key = DB_ID_TO_KEY_MAP.get(target_db_id)
             if db_key:
                 await schema_manager.initialize_schema(target_db_id, DB_CONFIG[db_key]["name"])
-                logger.success("数据库结构缓存已刷新！")
+                logging.info("✅ 数据库结构缓存已刷新！")
         return result
 
     BangumiMappingManager.handle_new_key = new_handle_new_key_wrapper
 
     try:
         await batch_update(context, dbs_to_update)
     except (KeyboardInterrupt, asyncio.CancelledError):
-        logger.warn("\n接收到中断信号，正在退出...")
+        logging.warning("\n⚠️ 接收到中断信号，正在退出...")
     except Exception as e:
-        logger.error(f"批量更新流程出现未捕获的严重错误: {e}")
+        logging.error(f"❌ 批量更新流程出现未捕获的严重错误: {e}")
     finally:
-        logger.system("正在清理资源...")
+        logging.info("🔧 正在清理资源...")
         await close_context(context)
         context["brand_cache"].save_cache(context["brand_extra_info_cache"])
-        logger.system("批量更新程序已安全退出。")
+        logging.info("✅ 批量更新程序已安全退出。")
 
 
 # get_user_choice() 和 __main__ 部分保持不变
@@ -291,4 +291,6 @@ def get_user_choice():
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    from utils.logger import setup_logging_for_cli
+    setup_logging_for_cli()
+    asyncio.run(main())

clients/bangumi_client.py

@@ -1,6 +1,7 @@
 # clients/bangumi_client.py
 # 该模块用于与 Bangumi API 交互，获取游戏和角色信息
 import asyncio
+import logging
 from rapidfuzz import fuzz
 
 import json
@@ -18,7 +19,6 @@
 from core.interaction import InteractionProvider
 from core.mapping_manager import BangumiMappingManager
 from core.schema_manager import NotionSchemaManager
-from utils import logger
 
 API_TOKEN = BANGUMI_TOKEN
 HEADERS_API = {
@@ -83,11 +83,11 @@ async def _search(self, keyword: str):
         try:
             resp = await self.client.post(url, headers=self.headers, json=payload, timeout=15)
             if resp.status_code != 200:
-                logger.warn(f"[Bangumi] API搜索失败: {resp.status_code}")
+                logging.warning(f"⚠️ [Bangumi] API搜索失败: {resp.status_code}")
                 return []
             return resp.json().get("data", [])
         except httpx.RequestError as e:
-            logger.error(f"[Bangumi] API请求异常: {e}")
+            logging.error(f"❌ [Bangumi] API请求异常: {e}")
             return []
 
     async def search_and_select_bangumi_id(self, keyword: str) -> str | None:
@@ -119,23 +119,23 @@ async def search_and_select_bangumi_id(self, keyword: str) -> str | None:
             if clean_title(item.get("name", "")) and (
                 clean_title(keyword) in clean_title(item.get("name", ""))
             ):
-                logger.info(f"[Bangumi] 子串匹配成功: {item['name']}，视为同一作品")
+                logging.info(f"🔍 [Bangumi] 子串匹配成功: {item['name']}，视为同一作品")
                 return str(item["id"])
         if candidates and candidates[0][0] >= self.similarity_threshold:
             best = candidates[0][1]
-            logger.info(f"[Bangumi] 自动匹配成功: {best['name']} (相似度 {candidates[0][0]:.2f})")
+            logging.info(f"🔍 [Bangumi] 自动匹配成功: {best['name']} (相似度 {candidates[0][0]:.2f})")
             return str(best["id"])
         if candidates and candidates[0][0] >= 0.7:
             best = candidates[0][1]
             if clean_title(best["name"]) in clean_title(keyword) or clean_title(
                 keyword
             ) in clean_title(best["name"]):
-                logger.info(
-                    f"[Bangumi] 模糊匹配成功（放宽判定）: {best['name']} (相似度 {candidates[0][0]:.2f})"
+                logging.info(
+                    f"🔍 [Bangumi] 模糊匹配成功（放宽判定）: {best['name']} (相似度 {candidates[0][0]:.2f})"
                 )
                 return str(best["id"])
 
-        logger.warn("Bangumi自动匹配相似度不足，请手动选择:")
+        logging.warning("⚠️ Bangumi自动匹配相似度不足，请手动选择:")
 
         # Format candidates for display in GUI
         gui_candidates = []
@@ -335,7 +335,7 @@ async def create_or_update_character(self, char: dict, warned_keys: Set[str]) ->
             prop_type = self.schema.get_property_type(CHARACTER_DB_ID, notion_prop_name)
             if not prop_type:
                 if notion_prop_name not in warned_keys:
-                    logger.warn(f"角色属性 '{notion_prop_name}' 在 Notion 角色库中不存在，已跳过。")
+                    logging.warning(f"⚠️ 角色属性 '{notion_prop_name}' 在 Notion 角色库中不存在，已跳过。")
                     warned_keys.add(notion_prop_name)
                 continue
             if prop_type == "title":
@@ -361,19 +361,19 @@ async def create_or_update_character(self, char: dict, warned_keys: Set[str]) ->
                 "PATCH", f"https://api.notion.com/v1/pages/{existing_id}", {"properties": props}
             )
             if resp:
-                logger.info(f"角色已存在，已更新：{char['name']}")
+                logging.info(f"🔍 角色已存在，已更新：{char['name']}")
             return existing_id if resp else None
         else:
             payload = {"parent": {"database_id": CHARACTER_DB_ID}, "properties": props}
             resp = await self.notion._request("POST", "https://api.notion.com/v1/pages", payload)
             if resp:
-                logger.success(f"新角色已创建：{char['name']}")
+                logging.info(f"✅ 新角色已创建：{char['name']}")
             return resp.get("id") if resp else None
 
     async def create_or_link_characters(self, game_page_id: str, subject_id: str):
         characters = await self.fetch_characters(subject_id)
         if not characters:
-            logger.info("未找到任何 Bangumi 角色信息，跳过角色关联。")
+            logging.info("🔍 未找到任何 Bangumi 角色信息，跳过角色关联。")
             patch = {
                 "properties": {
                     FIELDS["bangumi_url"]: {"url": f"https://bangumi.tv/subject/{subject_id}"}
@@ -391,7 +391,7 @@ async def create_or_link_characters(self, game_page_id: str, subject_id: str):
         character_relations = [{"id": cid} for cid in char_ids if cid]
         page_data = await self.notion.get_page(game_page_id)
         if not page_data:
-            logger.error(f"无法获取游戏页面 {game_page_id} 的当前状态，跳过声优补充。")
+            logging.error(f"❌ 无法获取游戏页面 {game_page_id} 的当前状态，跳过声优补充。")
             return
         patch_props = {
             FIELDS["bangumi_url"]: {"url": f"https://bangumi.tv/subject/{subject_id}"},
@@ -401,32 +401,32 @@ async def create_or_link_characters(self, game_page_id: str, subject_id: str):
             page_data.get("properties", {}).get(FIELDS["voice_actor"], {}).get("multi_select", [])
         )
         if not existing_vcs:
-            logger.info("游戏页面声优信息为空，尝试从 Bangumi 角色数据中补充...")
+            logging.info("🔍 游戏页面声优信息为空，尝试从 Bangumi 角色数据中补充...")
             all_cvs = {ch["声优"].strip() for ch in characters if ch.get("声优")}
             if all_cvs:
-                logger.success(f"已为【游戏页面】补充 {len(all_cvs)} 位声优。")
+                logging.info(f"✅ 已为【游戏页面】补充 {len(all_cvs)} 位声优。")
                 patch_props[FIELDS["voice_actor"]] = {
                     "multi_select": [{"name": name} for name in sorted(all_cvs)]
                 }
             else:
-                logger.info("Bangumi 角色数据中也未找到声优信息以供补充。")
+                logging.info("🔍 Bangumi 角色数据中也未找到声优信息以供补充。")
         else:
-            logger.info("游戏页面已存在声优信息，跳过补充。")
+            logging.info("🔍 游戏页面已存在声优信息，跳过补充。")
         await self.notion._request(
             "PATCH", f"https://api.notion.com/v1/pages/{game_page_id}", {"properties": patch_props}
         )
-        logger.success("Bangumi 角色信息同步与关联完成。")
+        logging.info("✅ Bangumi 角色信息同步与关联完成。")
 
     async def fetch_brand_info_from_bangumi(self, brand_name: str) -> dict | None:
         """[已重构] 搜索品牌，找到ID后调用 fetch_person_by_id 获取完整信息。"""
 
         async def search_brand(keyword: str):
-            logger.info(f"[Bangumi] 正在搜索品牌关键词: {keyword}")
+            logging.info(f"🔍 [Bangumi] 正在搜索品牌关键词: {keyword}")
             url = "https://api.bgm.tv/v0/search/persons"
             data = {"keyword": keyword, "filter": {"career": ["artist", "director", "producer"]}}
             resp = await self.client.post(url, headers=self.headers, json=data)
             if resp.status_code != 200:
-                logger.error(f"[Bangumi] 品牌搜索失败，状态码: {resp.status_code}")
+                logging.error(f"❌ [Bangumi] 品牌搜索失败，状态码: {resp.status_code}")
                 return []
             return resp.json().get("data", [])
 
@@ -458,28 +458,28 @@ async def search_brand(keyword: str):
         best_score, best_match = candidates[0] if candidates else (0, None)
 
         if not best_match or best_score < 0.7:
-            logger.warn(f"未找到相似度高于阈值的品牌（最高: {best_score:.2f})")
+            logging.warning(f"⚠️ 未找到相似度高于阈值的品牌（最高: {best_score:.2f})")
             return None
 
         person_id = best_match.get("id")
         if not person_id:
-            logger.warn("最佳匹配项缺少ID，无法获取详细信息。")
+            logging.warning("⚠️ 最佳匹配项缺少ID，无法获取详细信息。")
             return None
 
-        logger.success(
-            f"[Bangumi] 搜索匹配成功: {best_match.get('name')} (ID: {person_id}, 相似度: {best_score:.2f})"
+        logging.info(
+            f"✅ [Bangumi] 搜索匹配成功: {best_match.get('name')} (ID: {person_id}, 相似度: {best_score:.2f})"
         )
         return await self.fetch_person_by_id(str(person_id))
 
     async def fetch_person_by_id(self, person_id: str) -> dict | None:
         """[已重构] 通过 Person ID 直接获取并处理厂商/个人信息，作为唯一的数据处理源。"""
         url = f"https://api.bgm.tv/v0/persons/{person_id}"
-        logger.info(f"[Bangumi] 正在通过 ID 直接获取品牌信息: {person_id}")
+        logging.info(f"🔍 [Bangumi] 正在通过 ID 直接获取品牌信息: {person_id}")
         try:
             resp = await self.client.get(url, headers=self.headers)
             if resp.status_code != 200:
-                logger.error(
-                    f"[Bangumi] 品牌信息获取失败，ID: {person_id}, 状态码: {resp.status_code}"
+                logging.error(
+                    f"❌ [Bangumi] 品牌信息获取失败，ID: {person_id}, 状态码: {resp.status_code}"
                 )
                 return None
 
@@ -499,11 +499,11 @@ async def fetch_person_by_id(self, person_id: str) -> dict | None:
             }
             brand_info.update(infobox_data)
 
-            logger.success(f"[Bangumi] 已成功获取并处理品牌: {person_data.get('name')}")
+            logging.info(f"✅ [Bangumi] 已成功获取并处理品牌: {person_data.get('name')}")
             return brand_info
 
         except Exception as e:
-            logger.error(f"[Bangumi] 通过ID获取品牌信息时发生异常: {e}")
+            logging.error(f"❌ [Bangumi] 通过ID获取品牌信息时发生异常: {e}")
             return None
 
     async def fetch_and_prepare_character_data(self, character_id: str) -> dict | None:
@@ -512,7 +512,7 @@ async def fetch_and_prepare_character_data(self, character_id: str) -> dict | No
             char_detail_url = f"https://api.bgm.tv/v0/characters/{character_id}"
             resp = await self.client.get(char_detail_url, headers=self.headers)
             if resp.status_code != 200:
-                logger.error(f"获取角色 {character_id} 详情失败: 状态码 {resp.status_code}")
+                logging.error(f"❌ 获取角色 {character_id} 详情失败: 状态码 {resp.status_code}")
                 return None
 
             detail = resp.json()
@@ -536,5 +536,5 @@ async def fetch_and_prepare_character_data(self, character_id: str) -> dict | No
 
             return char_data_to_update
         except Exception as e:
-            logger.error(f"处理角色 {character_id} 数据时出错: {e}")
+            logging.error(f"❌ 处理角色 {character_id} 数据时出错: {e}")
             return None