GUI.py

import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
import json
import os
from pathlib import Path
from api_extract import LLMClient

class LLMAPIClientGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("多提供商LLM API客户端")
        self.root.geometry("800x650")
        self.root.resizable(True, True)
        
        # 设置中文字体支持
        self.style = ttk.Style()
        
        # 初始化LLM客户端
        self.llm_client = LLMClient()
        
        # API密钥变量
        self.api_key_var = tk.StringVar()
        
        # 自定义API相关变量
        self.custom_url_var = tk.StringVar()
        self.custom_headers_var = tk.StringVar()
        
        # 创建界面
        self.create_widgets()
    
    def create_widgets(self):
        # 创建主框架
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # API提供商选择区域
        provider_frame = ttk.LabelFrame(main_frame, text="API 提供商选择", padding="10")
        provider_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.provider_var = tk.StringVar(value="siliconflow")
        providers_frame = ttk.Frame(provider_frame)
        providers_frame.pack(anchor=tk.W)
        
        # 添加预定义提供商选项
        for provider in self.llm_client.API_PROVIDERS:
            provider_name = self.llm_client.API_PROVIDERS[provider]["name"]
            ttk.Radiobutton(providers_frame, text=provider_name, variable=self.provider_var, 
                           value=provider, command=self.on_provider_change).pack(side=tk.LEFT, padx=10, pady=5)
        
        # 自定义API选项
        ttk.Radiobutton(providers_frame, text="自定义API", variable=self.provider_var, 
                       value="custom", command=self.on_provider_change).pack(side=tk.LEFT, padx=10, pady=5)
        
        # API密钥区域
        api_frame = ttk.LabelFrame(main_frame, text="API 密钥配置", padding="10")
        api_frame.pack(fill=tk.X, pady=(0, 10))
        
        ttk.Label(api_frame, text="API Key:").grid(row=0, column=0, sticky=tk.W, pady=5)
        api_entry = ttk.Entry(api_frame, textvariable=self.api_key_var, width=60, show="*")
        api_entry.grid(row=0, column=1, sticky=tk.W, pady=5, padx=5)
        ttk.Button(api_frame, text="保存密钥", command=self.save_api_key).grid(row=0, column=2, padx=5)
        
        # 自定义API配置区域
        self.custom_api_frame = ttk.LabelFrame(main_frame, text="自定义API配置", padding="10")
        self.custom_api_frame.pack(fill=tk.X, pady=(0, 10))
        self.custom_api_frame.pack_forget()  # 默认隐藏
        
        ttk.Label(self.custom_api_frame, text="API地址:").grid(row=0, column=0, sticky=tk.W, pady=5)
        ttk.Entry(self.custom_api_frame, textvariable=self.custom_url_var, width=60).grid(row=0, column=1, sticky=tk.W, pady=5, padx=5)
        
        ttk.Label(self.custom_api_frame, text="请求头(可选):").grid(row=1, column=0, sticky=tk.NW, pady=5)
        self.custom_headers_text = scrolledtext.ScrolledText(self.custom_api_frame, width=60, height=3, wrap=tk.WORD)
        self.custom_headers_text.grid(row=1, column=1, sticky=tk.W, pady=5, padx=5)
        self.custom_headers_text.insert(tk.END, "Content-Type: application/json\nAuthorization: Bearer {api_key}")
        
        # 模型选择区域
        model_frame = ttk.LabelFrame(main_frame, text="模型选择", padding="10")
        model_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.model_var = tk.StringVar(value="")
        self.update_model_options()
        
        # 自定义模型输入框
        self.custom_model_var = tk.StringVar(value="")
        custom_model_frame = ttk.Frame(model_frame)
        custom_model_frame.pack(anchor=tk.W, pady=(5, 0))
        ttk.Label(custom_model_frame, text="自定义模型ID:").pack(side=tk.LEFT, padx=(20, 5))
        ttk.Entry(custom_model_frame, textvariable=self.custom_model_var, width=50).pack(side=tk.LEFT)
        
        # 提示词输入区域
        prompt_frame = ttk.LabelFrame(main_frame, text="提示词输入", padding="10")
        prompt_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.prompt_text = scrolledtext.ScrolledText(prompt_frame, width=80, height=6, wrap=tk.WORD)
        self.prompt_text.pack(fill=tk.X, expand=True)
        self.prompt_text.insert(tk.END, "你好，请简单介绍一下你自己")
        
        # 按钮区域
        button_frame = ttk.Frame(main_frame)
        button_frame.pack(fill=tk.X, pady=(0, 10))
        
        ttk.Button(button_frame, text="选择提供商", command=self.select_provider).pack(side=tk.LEFT, padx=5)
        ttk.Button(button_frame, text="发送请求", command=self.send_request).pack(side=tk.LEFT, padx=5)
        ttk.Button(button_frame, text="清空结果", command=self.clear_result).pack(side=tk.LEFT, padx=5)
        
        # 结果显示区域
        result_frame = ttk.LabelFrame(main_frame, text="API 返回结果", padding="10")
        result_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
        
        # 创建标签页
        self.tab_control = ttk.Notebook(result_frame)
        
        # 原始响应标签
        self.raw_tab = ttk.Frame(self.tab_control)
        self.tab_control.add(self.raw_tab, text="原始响应")
        
        self.raw_text = scrolledtext.ScrolledText(self.raw_tab, width=80, height=15, wrap=tk.WORD)
        self.raw_text.pack(fill=tk.BOTH, expand=True)
        
        # 解析结果标签
        self.parsed_tab = ttk.Frame(self.tab_control)
        self.tab_control.add(self.parsed_tab, text="回答")
        
        self.parsed_text = scrolledtext.ScrolledText(self.parsed_tab, width=80, height=15, wrap=tk.WORD)
        self.parsed_text.pack(fill=tk.BOTH, expand=True)
        
        self.tab_control.pack(fill=tk.BOTH, expand=True)
        
        # 状态标签
        self.status_var = tk.StringVar(value="就绪")
        status_bar = ttk.Label(self.root, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W)
        status_bar.pack(side=tk.BOTTOM, fill=tk.X)
        
        # 初始化时加载API密钥
        self.load_api_key()
    
    def on_provider_change(self):
        """当提供商改变时更新UI"""
        provider = self.provider_var.get()
        # 显示或隐藏自定义API配置区域
        if provider == "custom":
            self.custom_api_frame.pack(fill=tk.X, pady=(0, 10))
        else:
            self.custom_api_frame.pack_forget()
        
        # 更新模型选项
        self.update_model_options()
        # 加载对应提供商的API密钥
        self.load_api_key()
    
    def update_model_options(self):
        """更新模型选项"""
        provider = self.provider_var.get()
        if provider in self.llm_client.API_PROVIDERS:
            self.model_var.set(self.llm_client.API_PROVIDERS[provider]["default_model"])
        else:
            self.model_var.set("")
    
    def select_provider(self):
        """弹出提供商选择对话框"""
        # 使用LLMClient的选择提供商方法
        self.llm_client.provider = self.provider_var.get()
        
        # 如果是自定义API，配置相关参数
        if self.llm_client.provider == "custom":
            url = self.custom_url_var.get().strip()
            if not url:
                messagebox.showwarning("警告", "请输入自定义API地址")
                return
            
            self.llm_client.custom_url = url
            
            # 解析自定义请求头
            headers_text = self.custom_headers_text.get(1.0, tk.END).strip()
            if headers_text:
                headers = {}
                for line in headers_text.split('\n'):
                    if ':' in line:
                        key, value = line.split(':', 1)
                        # 替换API密钥占位符
                        if '{api_key}' in value:
                            value = value.replace('{api_key}', self.api_key_var.get())
                        headers[key.strip()] = value.strip()
                self.llm_client.custom_headers = headers
        
        # 设置API密钥
        self.llm_client.api_key = self.api_key_var.get()
        
        # 设置模型
        if self.model_var.get() == "custom":
            self.llm_client.model = self.custom_model_var.get()
        else:
            self.llm_client.model = self.model_var.get()
        
        self.status_var.set(f"✅ 已选择提供商: {self.get_provider_name()}")
    
    def get_provider_name(self):
        """获取当前提供商的名称"""
        provider = self.provider_var.get()
        if provider == "custom":
            return "自定义API"
        elif provider in self.llm_client.API_PROVIDERS:
            return self.llm_client.API_PROVIDERS[provider]["name"]
        return provider
    
    def load_api_key(self):
        """从配置文件加载API密钥"""
        provider = self.provider_var.get()
        api_key = self.llm_client.load_api_key_from_config(provider)
        if api_key:
            self.api_key_var.set(api_key)
            self.status_var.set(f"✅ 已加载{self.get_provider_name()}的API密钥")
        else:
            self.status_var.set(f"未找到{self.get_provider_name()}的API密钥")
    
    def save_api_key(self):
        """保存API密钥到配置文件"""
        api_key = self.api_key_var.get().strip()
        provider = self.provider_var.get()
        
        if not api_key:
            messagebox.showwarning("警告", "API密钥不能为空")
            self.status_var.set("⚠️ API密钥保存失败: 密钥不能为空")
            return
        
        # 简单验证API密钥格式
        if len(api_key) < 20:
            confirm = messagebox.askyesno("警告", "API密钥看起来太短，确定要保存吗？")
            if not confirm:
                return
        
        try:
            # 使用LLMClient的保存方法
            self.llm_client.save_api_key_to_config(api_key, provider)
            
            success_msg = f"✅ {self.get_provider_name()}的API密钥已成功保存"
            self.status_var.set(success_msg)
            messagebox.showinfo("成功", f"{self.get_provider_name()}的API密钥已成功保存到配置文件")
            
        except Exception as e:
            error_msg = f"保存API密钥失败: {str(e)}"
            self.status_var.set(f"❌ {error_msg}")
            messagebox.showerror("错误", error_msg)
    
    def send_request(self):
        """发送API请求"""
        # 确保已选择提供商
        if not self.llm_client.provider:
            self.select_provider()
        
        # 获取API密钥
        api_key = self.api_key_var.get().strip()
        if not api_key and self.llm_client.provider != "custom":
            messagebox.showwarning("警告", "请先输入API密钥")
            return
        
        # 获取模型
        if self.model_var.get() == "custom":
            custom_model = self.custom_model_var.get().strip()
            if not custom_model:
                messagebox.showwarning("警告", "请输入自定义模型ID")
                return
            self.llm_client.model = custom_model
        else:
            self.llm_client.model = self.model_var.get()
        
        # 获取提示词
        prompt = self.prompt_text.get(1.0, tk.END).strip()
        if not prompt:
            messagebox.showwarning("警告", "请输入提示词")
            return
        
        # 更新状态
        self.status_var.set("正在发送请求...")
        self.root.update()
        
        # 发送请求
        try:
            # 确保客户端配置正确
            self.llm_client.provider = self.provider_var.get()
            self.llm_client.api_key = api_key
            
            if self.llm_client.provider == "custom":
                self.llm_client.custom_url = self.custom_url_var.get().strip()
                
                # 解析自定义请求头
                headers_text = self.custom_headers_text.get(1.0, tk.END).strip()
                if headers_text:
                    headers = {}
                    for line in headers_text.split('\n'):
                        if ':' in line:
                            key, value = line.split(':', 1)
                            if '{api_key}' in value:
                                value = value.replace('{api_key}', api_key)
                            headers[key.strip()] = value.strip()
                    self.llm_client.custom_headers = headers
            
            # 使用LLMClient调用API
            result = self.llm_client.call_api(prompt)
            
            if result:
                # 显示原始响应
                self.raw_text.delete(1.0, tk.END)
                self.raw_text.insert(tk.END, json.dumps(result["full_response"], ensure_ascii=False, indent=2))
                
                # 显示解析结果
                self.parsed_text.delete(1.0, tk.END)
                self.parsed_text.insert(tk.END, result["content"])
                
                self.status_var.set("请求成功完成")
            else:
                # 如果result为None，错误信息已经在call_api中打印
                self.status_var.set("请求失败")
                
        except Exception as e:
            error_msg = f"发生未知错误: {str(e)}"
            self.raw_text.delete(1.0, tk.END)
            self.raw_text.insert(tk.END, error_msg)
            self.parsed_text.delete(1.0, tk.END)
            self.parsed_text.insert(tk.END, error_msg)
            self.status_var.set("发生未知错误")
    
    def clear_result(self):
        """清空结果显示"""
        self.raw_text.delete(1.0, tk.END)
        self.parsed_text.delete(1.0, tk.END)
        self.status_var.set("结果已清空")

# 主函数，支持命令行运行
def main():
    root = tk.Tk()
    app = LLMAPIClientGUI(root)
    root.mainloop()

# 允许作为模块导入或直接运行
if __name__ == "__main__":
    main()