Update app.py

app.py

@@ -1,13 +1,13 @@
 import os
-import json
 import gradio as gr
 import huggingface_hub
 import numpy as np
 import onnxruntime as rt
 import pandas as pd
 from PIL import Image
-from huggingface_hub import whoami
+from huggingface_hub import login
 
+# 导入修改后的翻译函数
 from translator import translate_texts
 
 # ------------------------------------------------------------------
@@ -17,8 +17,14 @@ MODEL_REPO = "SmilingWolf/wd-eva02-large-tagger-v3"
 MODEL_FILENAME = "model.onnx"
 LABEL_FILENAME = "selected_tags.csv"
 
-HF_TOKEN = os.environ.get("HF_TOKEN")
-ACCESS_PASSWORD = os.environ.get("ACCESS_PASSWORD")
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+if HF_TOKEN:
+    try:
+        login(token=HF_TOKEN)
+    except Exception as e:
+        print(f"Hugging Face登录失败: {e}")
+else:
+    print("⚠️ 未检测到 HF_TOKEN，私有模型可能下载失败")
 
 # ------------------------------------------------------------------
 # Tagger 类 (全局实例化)
@@ -58,40 +64,53 @@ class Tagger:
 
     # ------------------------- preprocess -------------------------
     def _preprocess(self, img: Image.Image) -> np.ndarray:
-        if img is None: raise ValueError("输入图像不能为空")
-        if img.mode != "RGB": img = img.convert("RGB")
+        if img is None:
+            raise ValueError("输入图像不能为空")
+        if img.mode != "RGB":
+            img = img.convert("RGB")
         size = max(img.size)
         canvas = Image.new("RGB", (size, size), (255, 255, 255))
         canvas.paste(img, ((size - img.width) // 2, (size - img.height) // 2))
         if size != self.input_size:
             canvas = canvas.resize((self.input_size, self.input_size), Image.BICUBIC)
-        return np.array(canvas)[:, :, ::-1].astype(np.float32)
+        return np.array(canvas)[:, :, ::-1].astype(np.float32)  # to BGR
 
     # --------------------------- predict --------------------------
     def predict(self, img: Image.Image, gen_th: float = 0.35, char_th: float = 0.85):
-        if self.model is None: raise RuntimeError("模型未成功加载，无法进行预测。")
+        if self.model is None:
+            raise RuntimeError("模型未成功加载，无法进行预测。")
         inp_name = self.model.get_inputs()[0].name
         outputs = self.model.run(None, {inp_name: self._preprocess(img)[None, ...]})[0][0]
 
         res = {"ratings": {}, "general": {}, "characters": {}}
         tag_categories_for_translation = {"ratings": [], "general": [], "characters": []}
 
-        for cat_key, cat_indices in self.categories.items():
-            sub_res = {}
-            if cat_key == "rating":
-                for idx in cat_indices:
-                    tag_name = self.tag_names[idx].replace("_", " ")
-                    sub_res[tag_name] = float(outputs[idx])
-            else:
-                threshold = char_th if cat_key == "character" else gen_th
-                for idx in cat_indices:
-                    if outputs[idx] > threshold:
-                        tag_name = self.tag_names[idx].replace("_", " ")
-                        sub_res[tag_name] = float(outputs[idx])
-
-            res_key = "characters" if cat_key == "character" else cat_key
-            res[res_key] = dict(sorted(sub_res.items(), key=lambda kv: kv[1], reverse=True))
-            tag_categories_for_translation[res_key] = list(res[res_key].keys())
+        for idx in self.categories["rating"]:
+            tag_name = self.tag_names[idx].replace("_", " ")
+            res["ratings"][tag_name] = float(outputs[idx])
+            tag_categories_for_translation["ratings"].append(tag_name)
+
+        for idx in self.categories["general"]:
+            if outputs[idx] > gen_th:
+                tag_name = self.tag_names[idx].replace("_", " ")
+                res["general"][tag_name] = float(outputs[idx])
+                tag_categories_for_translation["general"].append(tag_name)
+
+        for idx in self.categories["character"]:
+            if outputs[idx] > char_th:
+                tag_name = self.tag_names[idx].replace("_", " ")
+                res["characters"][tag_name] = float(outputs[idx])
+                tag_categories_for_translation["characters"].append(tag_name)
+
+
+        res["general"] = dict(sorted(res["general"].items(), key=lambda kv: kv[1], reverse=True))
+        res["characters"] = dict(sorted(res["characters"].items(), key=lambda kv: kv[1], reverse=True))
+        res["ratings"] = dict(sorted(res["ratings"].items(), key=lambda kv: kv[1], reverse=True))
+
+
+        tag_categories_for_translation["general"] = list(res["general"].keys())
+        tag_categories_for_translation["characters"] = list(res["characters"].keys())
+        tag_categories_for_translation["ratings"] = list(res["ratings"].keys())
 
         return res, tag_categories_for_translation
 
@@ -100,7 +119,7 @@ try:
     tagger_instance = Tagger()
 except RuntimeError as e:
     print(f"应用启动时Tagger初始化失败: {e}")
-    tagger_instance = None
+    tagger_instance = None # 允许应用启动，但在处理时会失���
 
 # ------------------------------------------------------------------
 # Gradio UI
@@ -123,7 +142,8 @@ function copyToClipboard(text) {
     }
     navigator.clipboard.writeText(text).then(() => {
         const feedback = document.createElement('div');
-        let displayText = String(text).substring(0, 30) + (String(text).length > 30 ? '...' : '');
+        let displayText = String(text);
+        displayText = displayText.substring(0, 30) + (displayText.length > 30 ? '...' : '');
         feedback.textContent = '已复制: ' + displayText;
         Object.assign(feedback.style, {
             position: 'fixed', bottom: '20px', left: '50%', transform: 'translateX(-50%)',
@@ -136,7 +156,7 @@ function copyToClipboard(text) {
             setTimeout(() => { if (document.body.contains(feedback)) document.body.removeChild(feedback); }, 500);
         }, 1500);
     }).catch(err => {
-        console.error('Failed to copy tag. Error:', err, 'Attempted to copy text:', text);
+        console.error('Failed to copy tag. Error:', err, 'Text:', text);
     });
 }
 """
@@ -144,203 +164,241 @@ function copyToClipboard(text) {
 with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=custom_css, js=_js_functions) as demo:
     gr.Markdown("# 🖼️ AI 图像标签分析器")
     gr.Markdown("上传图片自动识别标签，支持中英文显示和一键复制。[NovelAI在线绘画](https://nai.idlecloud.cc/)")
-    
-    # 统一的状态和登录/登出控制区域
-    with gr.Row():
-        user_status_html = gr.HTML("<p>ℹ️ 正在检查登录状态...</p>")
-    with gr.Row():
-        login_button = gr.LoginButton(value="🤗 通过 Hugging Face 登录", visible=True)
-        logout_button = gr.LogoutButton(value="退出登录", visible=False)
 
     state_res = gr.State({})
     state_translations_dict = gr.State({})
+    state_tag_categories_for_translation = gr.State({})
+
 
-    with gr.Row(visible=False) as main_interface:
+    with gr.Row():
         with gr.Column(scale=1):
             img_in = gr.Image(type="pil", label="上传图片", height=300)
+            
             btn = gr.Button("🚀 开始分析", variant="primary", elem_classes=["btn-analyze-container"])
             
             with gr.Accordion("⚙️ 高级设置", open=False):
-                gen_slider = gr.Slider(0, 1, value=0.35, step=0.01, label="通用标签阈值")
-                char_slider = gr.Slider(0, 1, value=0.85, step=0.01, label="角色标签阈值")
+                gen_slider = gr.Slider(0, 1, value=0.35, step=0.01, label="通用标签阈值", info="越高 → 标签更少更准")
+                char_slider = gr.Slider(0, 1, value=0.85, step=0.01, label="角色标签阈值", info="推荐保持较高阈值")
                 show_tag_scores = gr.Checkbox(True, label="在列表中显示标签置信度")
 
-            with gr.Accordion("🔑 翻译密钥设置", open=True):
-                gr.Markdown("输入访问密码可使用空间配置的密钥，否则请提供您自己的密钥。")
-                access_password_in = gr.Textbox(label="访问密码 (可选)", type="password", lines=1)
-                tencent_id_in = gr.Textbox(label="腾讯云 Secret ID", lines=1)
-                tencent_key_in = gr.Textbox(label="腾讯云 Secret Key", lines=1, type="password")
-                baidu_json_in = gr.Textbox(label="百度翻译凭证 (JSON 格式)", lines=3, placeholder='[{"app_id": "...", "secret_key": "..."}]')
+            with gr.Accordion("🔑 翻译服务配置", open=False):
+                enable_translation_cb = gr.Checkbox(label="启用翻译", value=True, info="取消勾选则不进行翻译")
+                gr.Markdown("提供 **系统访问密钥** 或 **自定义API密钥** 来启用翻译功能。如果两者均未提供或不正确，将不进行翻译。")
+
+                with gr.Tabs():
+                    with gr.TabItem("使用系统密钥"):
+                        system_key_input = gr.Textbox(label="系统访问密钥", type="password", placeholder="输入管理员提供的密钥")
+                    with gr.TabItem("使用自定义API"):
+                        gr.Markdown("在此处填入你自己的翻译API密钥。")
+                        tencent_id_input = gr.Textbox(label="腾讯云 SecretId", type="password")
+                        tencent_key_input = gr.Textbox(label="腾讯云 SecretKey", type="password")
+                        baidu_json_input = gr.Textbox(label="百度翻译凭证 (JSON格式)", type="password", placeholder='[{"app_id":"...", "secret_key":"..."}]')
 
             with gr.Accordion("📊 标签汇总设置", open=True):
-                sum_cats = gr.CheckboxGroup(["通用标签", "角色标签", "评分标签"], value=["通用标签", "角色标签"], label="汇总类别")
-                sum_sep = gr.Dropdown(["逗号", "换行", "空格"], value="逗号", label="标签分隔符")
+                gr.Markdown("选择要包含在下方汇总文本框中的标签类别：")
+                with gr.Row():
+                    sum_general = gr.Checkbox(True, label="通用标签", min_width=50)
+                    sum_char = gr.Checkbox(True, label="角色标签", min_width=50)
+                    sum_rating = gr.Checkbox(False, label="评分标签", min_width=50)
+                sum_sep = gr.Dropdown(["逗号", "换行", "空格"], value="逗号", label="标签之间的分隔符")
                 sum_show_zh = gr.Checkbox(False, label="在汇总中显示中文翻译")
 
             processing_info = gr.Markdown("", visible=False)
 
         with gr.Column(scale=2):
             with gr.Tabs():
-                with gr.TabItem("🏷️ 通用标签"): out_general = gr.HTML(label="General Tags")
-                with gr.TabItem("👤 角色标签"): out_char = gr.HTML(label="Character Tags")
-                with gr.TabItem("⭐ 评分标签"): out_rating = gr.HTML(label="Rating Tags")
-            gr.Markdown("### 标签汇总结果")
-            out_summary = gr.Textbox(label="标签汇总", lines=5, show_copy_button=True)
+                with gr.TabItem("🏷️ 通用标签"):
+                    out_general = gr.HTML(label="General Tags")
+                with gr.TabItem("👤 角色标签"):
+                    gr.Markdown("<p style='color:gray; font-size:small;'>提示：角色标签推测基于截至2024年2月的数据。</p>")
+                    out_char = gr.HTML(label="Character Tags")
+                with gr.TabItem("⭐ 评分标签"):
+                    out_rating = gr.HTML(label="Rating Tags")
             
-    # ----------------- 辅助函数 -----------------
-    def get_token_from_request(request: gr.Request) -> str | None:
-        auth_header = request.headers.get("authorization")
-        if auth_header and auth_header.startswith("Bearer "):
-            return auth_header.split(" ")[1]
-        return None
-
-    def check_user_status(request: gr.Request):
-        token = get_token_from_request(request)
-        if token:
-            try:
-                user_info = whoami(token=token)
-                welcome_msg = f"<p style='color:green;font-weight:bold;'>✅ 您好, {user_info.get('fullname', user_info.get('name'))}！欢迎使用。</p>"
-                # 已登录：显示欢迎信息，隐藏登录按钮，显示登出按钮，显示主界面
-                return (
-                    gr.update(value=welcome_msg),
-                    gr.update(visible=False),
-                    gr.update(visible=True),
-                    gr.update(visible=True)
-                )
-            except Exception as e:
-                print(f"Token 无效或已过期: {e}")
-                error_msg = "<p style='color:red;'>🚫 登录令牌无效或已过期，请重新登录。</p>"
-                # 令牌无效：显示错误，显示登录按钮，隐藏登出按钮，隐藏主界面
-                return (
-                    gr.update(value=error_msg),
-                    gr.update(visible=True),
-                    gr.update(visible=False),
-                    gr.update(visible=False)
-                )
-
-        # 未登录
-        info_msg = "<p style='color:#d46b08;'>🚫 您需要登录才能使用此应用。</p>"
-        return (
-            gr.update(value=info_msg),
-            gr.update(visible=True),
-            gr.update(visible=False),
-            gr.update(visible=False)
-        )
+            gr.Markdown("### 标签汇总结果")
+            out_summary = gr.Textbox(
+                label="标签汇总",
+                placeholder="分析完成后，此处将显示汇总的英文标签...",
+                lines=5,
+                show_copy_button=True
+            )
+
+    def format_tags_html(tags_dict, translations_list, show_scores=True, show_translation_in_list=True):
+        if not tags_dict:
+            return "<p>暂无标签</p>"
         
-    def format_tags_html(tags_dict, translations_list, show_scores):
-        if not tags_dict: return "<p>暂无标签</p>"
         html = '<div class="label-container">'
-        for i, (tag, score) in enumerate(tags_dict.items()):
+        tag_keys = list(tags_dict.keys())
+
+        for i, tag in enumerate(tag_keys):
+            score = tags_dict[tag]
             escaped_tag = tag.replace("'", "\\'")
+            
             html += '<div class="tag-item">'
             tag_display_html = f'<span class="tag-en" onclick="copyToClipboard(\'{escaped_tag}\')">{tag}</span>'
-            if i < len(translations_list) and translations_list[i]:
-                tag_display_html += f'<span class="tag-zh">({translations_list[i]})</span>'
+            
+            translation_text = translations_list[i] if i < len(translations_list) else None
+            # 仅当翻译文本存在且与原文不同时显示
+            if show_translation_in_list and translation_text and translation_text != tag:
+                tag_display_html += f'<span class="tag-zh">({translation_text})</span>'
+            
             html += f'<div>{tag_display_html}</div>'
-            if show_scores: html += f'<span class="tag-score">{score:.3f}</span>'
+            if show_scores:
+                html += f'<span class="tag-score">{score:.3f}</span>'
             html += '</div>'
-        return html + '</div>'
-
-    def generate_summary_text_content(current_res, translations, sum_cats, sep_type, show_zh):
-        if not current_res: return "请先分析图像。"
-        parts, sep = [], {"逗号": ", ", "换行": "\n", "空格": " "}.get(sep_type, ", ")
-        cat_map = {"通用标签": "general", "角色标签": "characters", "评分标签": "ratings"}
-        for cat_name in sum_cats:
-            cat_key = cat_map.get(cat_name)
-            if cat_key and current_res.get(cat_key):
-                tags_en, trans = list(current_res[cat_key].keys()), translations.get(cat_key, [])
-                tags_to_join = [f"{en}({zh})" if show_zh and i < len(trans) and trans[i] else en for i, en in enumerate(tags_en)]
-                if tags_to_join: parts.append(sep.join(tags_to_join))
-        return "\n".join(parts) if parts else "选定的类别中没有找到标签。"
-
-    # ----------------- 主要处理回调 -----------------
-    def process_image_and_generate_outputs(
-        img, g_th, c_th, s_scores,
-        access_pwd, user_tencent_id, user_tencent_key, user_baidu_json,
-        sum_cats, s_sep, s_zh_in_sum,
-        request: gr.Request
-    ):
-        if get_token_from_request(request) is None:
-            raise gr.Error("错误：您的登录会话已失效，请刷新页面后重试。")
-        if img is None:
-            raise gr.Error("请先上传图片。")
-        if tagger_instance is None:
-            raise gr.Error("分析器未成功初始化，请检查后台错误。")
+        html += '</div>'
+        return html
 
-        yield gr.update(interactive=False, value="🔄 处理中..."), gr.update(visible=True, value="🔄 正在分析..."), *["<p>分析中...</p>"]*3, "分析中...", {}, {}
+    def generate_summary_text_content(
+        current_res, current_translations_dict,
+        s_gen, s_char, s_rat, s_sep_type, s_show_zh
+    ):
+        if not current_res: return "请先分析图像或选择要汇总的标签类别。"
+
+        summary_parts = []
+        separator = {"逗号": ", ", "换行": "\n", "空格": " "}.get(s_sep_type, ", ")
+
+        categories_to_summarize = []
+        if s_gen: categories_to_summarize.append("general")
+        if s_char: categories_to_summarize.append("characters")
+        if s_rat: categories_to_summarize.append("ratings")
+
+        if not categories_to_summarize: return "请至少选择一个标签类别进行汇总。"
+
+        for cat_key in categories_to_summarize:
+            if current_res.get(cat_key):
+                tags_to_join = []
+                cat_tags_en = list(current_res[cat_key].keys())
+                cat_translations = current_translations_dict.get(cat_key, [])
+
+                for i, en_tag in enumerate(cat_tags_en):
+                    translation_text = cat_translations[i] if i < len(cat_translations) else None
+                    # 仅当勾选显示中文、翻译文本存在且与原文不同时，才加入翻译
+                    if s_show_zh and translation_text and translation_text != en_tag:
+                        tags_to_join.append(f"{en_tag}({translation_text})")
+                    else:
+                        tags_to_join.append(en_tag)
+                if tags_to_join:
+                     summary_parts.append(separator.join(tags_to_join))
+        
+        joiner = "\n\n" if separator != "\n" and len(summary_parts) > 1 else separator
+        final_summary = joiner.join(summary_parts)
+        return final_summary if final_summary else "选定的类别中没有找到标签。"
 
-        use_space_keys = bool(ACCESS_PASSWORD and access_pwd == ACCESS_PASSWORD)
+    def process_image_and_generate_outputs(
+        img, g_th, c_th, s_scores, # Main inputs
+        s_gen, s_char, s_rat, s_sep, s_zh_in_sum, # Summary controls
+        # New translation controls
+        enable_translation, sys_key, tc_id, tc_key, baidu_json 
+        ):
+        initial_yield_state = (
+            gr.update(interactive=True, value="🚀 开始分析"), # btn
+            "", "", "", "", # html outputs
+            gr.update(placeholder="分析失败..."), # summary
+            {}, {}, {} # states
+        )
+        if img is None:
+            yield (gr.update(visible=True, value="❌ 请先上传图片。"), *initial_yield_state)
+            return
         
-        final_tencent_id, final_tencent_key, baidu_json_str = (
-            (os.environ.get("TENCENT_SECRET_ID"), os.environ.get("TENCENT_SECRET_KEY"), os.environ.get("BAIDU_CREDENTIALS_JSON", "[]"))
-            if use_space_keys else (user_tencent_id, user_tencent_key, user_baidu_json)
+        if tagger_instance is None:
+            yield (gr.update(visible=True, value="❌ 分析器未成功初始化，请检查控制台错误。"), *initial_yield_state)
+            return
+
+        yield (
+            gr.update(interactive=False, value="🔄 处理中..."),
+            gr.update(visible=True, value="🔄 正在分析图像，请稍候..."),
+            gr.HTML(value="<p>分析中...</p>"), gr.HTML(value="<p>分析中...</p>"), gr.HTML(value="<p>分析中...</p>"),
+            gr.update(value="分析中，请稍候..."), {}, {}, {}
         )
         
-        final_baidu_creds_list = []
-        if baidu_json_str and baidu_json_str.strip():
-            try:
-                parsed_data = json.loads(baidu_json_str)
-                if isinstance(parsed_data, list): final_baidu_creds_list = parsed_data
-            except json.JSONDecodeError: print("提供的百度凭证JSON无效。")
-
         try:
-            res, tag_cats_original = tagger_instance.predict(img, g_th, c_th)
-            all_tags = [tag for cat in tag_cats_original.values() for tag in cat]
-            
-            translations_flat = translate_texts(
-                all_tags,
-                tencent_secret_id=final_tencent_id,
-                tencent_secret_key=final_tencent_key,
-                baidu_credentials_list=final_baidu_creds_list
-            ) if all_tags else []
+            res, tag_categories_original_order = tagger_instance.predict(img, g_th, c_th)
             
-            translations, offset = {}, 0
-            for cat_key, tags in tag_cats_original.items():
-                translations[cat_key] = translations_flat[offset : offset + len(tags)]
-                offset += len(tags)
+            current_translations_dict = {}
+            if enable_translation:
+                all_tags_to_translate = []
+                for cat_key in ["general", "characters", "ratings"]:
+                    all_tags_to_translate.extend(tag_categories_original_order.get(cat_key, []))
+                
+                all_translations_flat = []
+                if all_tags_to_translate:
+                    # 使用新的参数调用翻译函数
+                    all_translations_flat = translate_texts(
+                        texts=all_tags_to_translate,
+                        system_key_input=sys_key,
+                        tencent_id=tc_id,
+                        tencent_key=tc_key,
+                        baidu_creds_json_str=baidu_json
+                    )
+                
+                offset = 0
+                for cat_key in ["general", "characters", "ratings"]:
+                    num_tags_in_cat = len(tag_categories_original_order.get(cat_key, []))
+                    current_translations_dict[cat_key] = all_translations_flat[offset : offset + num_tags_in_cat] if num_tags_in_cat > 0 else []
+                    offset += num_tags_in_cat
+            else: # 如果未启用翻译，则用空列表填充
+                 for cat_key in ["general", "characters", "ratings"]:
+                     current_translations_dict[cat_key] = []
             
-            outputs_html = {k: format_tags_html(res.get(k, {}), translations.get(k, []), s_scores) for k in ["general", "characters", "ratings"]}
-            summary = generate_summary_text_content(res, translations, sum_cats, s_sep, s_zh_in_sum)
+            general_html = format_tags_html(res.get("general", {}), current_translations_dict.get("general", []), s_scores, enable_translation)
+            char_html = format_tags_html(res.get("characters", {}), current_translations_dict.get("characters", []), s_scores, enable_translation)
+            rating_html = format_tags_html(res.get("ratings", {}), current_translations_dict.get("ratings", []), s_scores, enable_translation)
+
+            summary_text = generate_summary_text_content(res, current_translations_dict, s_gen, s_char, s_rat, s_sep, s_zh_in_sum)
 
-            yield gr.update(interactive=True, value="🚀 开始分析"), gr.update(visible=True, value="✅ 分析完成! " + ("(使用空间密钥)" if use_space_keys else "(使用自定义密钥)")), outputs_html["general"], outputs_html["characters"], outputs_html["ratings"], summary, res, translations
+            yield (
+                gr.update(interactive=True, value="🚀 开始分析"), gr.update(visible=True, value="✅ 分析完成!"), 
+                general_html, char_html, rating_html,
+                gr.update(value=summary_text), res, current_translations_dict, tag_categories_original_order
+            )
             
         except Exception as e:
             import traceback
-            traceback.print_exc()
-            raise gr.Error(f"处理时发生错误: {e}")
-
-    # ----------------- 绑定事件 -----------------
-    demo.load(
-        fn=check_user_status, 
-        inputs=None, 
-        outputs=[user_status_html, login_button, logout_button, main_interface], 
-        queue=False
-    )
+            tb_str = traceback.format_exc()
+            print(f"处理时发生错误: {e}\n{tb_str}")
+            yield (
+                gr.update(visible=True, value=f"❌ 处理失败: {str(e)}"),
+                gr.update(interactive=True, value="🚀 开始分析"),
+                "<p>处理出错</p>", "<p>处理出错</p>", "<p>处理出错</p>",
+                gr.update(value=f"错误: {str(e)}", placeholder="分析失败..."),
+                {}, {}, {}
+            )
+
+    def update_summary_display(
+        s_gen, s_char, s_rat, s_sep, s_zh_in_sum,
+        current_res_from_state, current_translations_from_state
+    ):
+        if not current_res_from_state:
+            return gr.update(placeholder="请先完成一次图像分析以生成汇总。", value="")
+
+        new_summary_text = generate_summary_text_content(
+            current_res_from_state, current_translations_from_state,
+            s_gen, s_char, s_rat, s_sep, s_zh_in_sum
+        )
+        return gr.update(value=new_summary_text)
+
+
+    translation_inputs = [enable_translation_cb, system_key_input, tencent_id_input, tencent_key_input, baidu_json_input]
     
     btn.click(
         process_image_and_generate_outputs,
-        inputs=[
-            img_in, gen_slider, char_slider, show_tag_scores,
-            access_password_in, tencent_id_in, tencent_key_in, baidu_json_in,
-            sum_cats, sum_sep, sum_show_zh
-        ],
-        outputs=[
-            btn, processing_info,
-            out_general, out_char, out_rating,
-            out_summary,
-            state_res, state_translations_dict
-        ],
+        inputs=[img_in, gen_slider, char_slider, show_tag_scores,
+                sum_general, sum_char, sum_rating, sum_sep, sum_show_zh] + translation_inputs,
+        outputs=[btn, processing_info,
+                 out_general, out_char, out_rating, out_summary,
+                 state_res, state_translations_dict, state_tag_categories_for_translation]
     )
 
-    summary_controls = [sum_cats, sum_sep, sum_show_zh]
+    summary_controls = [sum_general, sum_char, sum_rating, sum_sep, sum_show_zh]
     for ctrl in summary_controls:
         ctrl.change(
-            fn=lambda r, t, c, s, z: generate_summary_text_content(r, t, c, s, z),
-            inputs=[state_res, state_translations_dict] + summary_controls,
-            outputs=[out_summary],
+            fn=update_summary_display,
+            inputs=summary_controls + [state_res, state_translations_dict],
+            outputs=[out_summary]
         )
-    
+
 if __name__ == "__main__":
     if tagger_instance is None:
-        print("CRITICAL: Tagger 未能初始化，应用功能将受限。")
+        print("CRITICAL: Tagger 未能初始化，应用功能将受限。请检查之前的错误信息。")
     demo.launch(server_name="0.0.0.0", server_port=7860)