setup.py

"""
自动下载和安装VOSK模型的脚本
"""
import os
import sys
import urllib.request
import zipfile
import tarfile
import json
from pathlib import Path
import tkinter as tk
from tkinter import ttk, messagebox, simpledialog
import threading
import time

class ModelDownloader:
    """VOSK模型下载器"""
    
    def __init__(self):
        # 可用的VOSK模型列表
        self.models = {
            "zh-cn": {
                "small": {
                    "name": "vosk-model-small-cn-0.22",
                    "url": "https://alphacephei.com/vosk/models/vosk-model-small-cn-0.22.zip",
                    "size": "42 MB",
                    "description": "中文小模型 (推荐) - 快速响应，适合一般使用"
                },
                "large": {
                    "name": "vosk-model-cn-0.22", 
                    "url": "https://alphacephei.com/vosk/models/vosk-model-cn-0.22.zip",
                    "size": "1.2 GB",
                    "description": "中文大模型 - 更高精度，需要更多存储空间"
                }
            },
            "en-us": {
                "small": {
                    "name": "vosk-model-small-en-us-0.15",
                    "url": "https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip", 
                    "size": "40 MB",
                    "description": "英文小模型 - 快速响应，适合一般使用"
                },
                "large": {
                    "name": "vosk-model-en-us-0.22",
                    "url": "https://alphacephei.com/vosk/models/vosk-model-en-us-0.22.zip",
                    "size": "1.8 GB", 
                    "description": "英文大模型 - 更高精度，需要更多存储空间"
                }
            }
        }
        
        self.models_dir = Path("models")
        self.models_dir.mkdir(exist_ok=True)
        
    def get_installed_models(self):
        """获取已安装的模型列表"""
        installed = []
        if self.models_dir.exists():
            for item in self.models_dir.iterdir():
                if item.is_dir() and (item / "am" / "final.mdl").exists():
                    installed.append(item.name)
        return installed
    
    def download_with_progress(self, url, filename, progress_callback=None):
        """带进度条的下载"""
        def reporthook(block_num, block_size, total_size):
            if progress_callback and total_size > 0:
                downloaded = block_num * block_size
                percentage = min(100, (downloaded / total_size) * 100)
                progress_callback(percentage, downloaded, total_size)
        
        urllib.request.urlretrieve(url, filename, reporthook=reporthook)
    
    def extract_archive(self, archive_path, extract_path, progress_callback=None):
        """解压文件"""
        if archive_path.suffix.lower() == '.zip':
            with zipfile.ZipFile(archive_path, 'r') as zip_ref:
                members = zip_ref.infolist()
                total_files = len(members)
                
                for i, member in enumerate(members):
                    zip_ref.extract(member, extract_path)
                    if progress_callback:
                        progress_callback((i + 1) / total_files * 100)
        
        elif archive_path.suffix.lower() in ['.tar', '.gz', '.tgz']:
            with tarfile.open(archive_path, 'r:*') as tar_ref:
                members = tar_ref.getmembers()
                total_files = len(members)
                
                for i, member in enumerate(members):
                    tar_ref.extract(member, extract_path)
                    if progress_callback:
                        progress_callback((i + 1) / total_files * 100)
    
    def download_model(self, language, size, progress_callback=None, status_callback=None):
        """下载指定模型"""
        if language not in self.models or size not in self.models[language]:
            raise ValueError(f"不支持的模型: {language}-{size}")
        
        model_info = self.models[language][size]
        model_name = model_info["name"]
        model_url = model_info["url"]
        
        # 检查是否已安装
        if model_name in self.get_installed_models():
            if status_callback:
                status_callback(f"模型 {model_name} 已安装")
            return True
        
        try:
            # 创建临时下载目录
            temp_dir = Path("temp_download")
            temp_dir.mkdir(exist_ok=True)
            
            archive_name = Path(model_url).name
            archive_path = temp_dir / archive_name
            
            if status_callback:
                status_callback(f"正在下载 {model_name}...")
            
            # 下载模型
            def download_progress(percentage, downloaded, total):
                if progress_callback:
                    progress_callback(percentage * 0.8)  # 下载占80%进度
                if status_callback:
                    downloaded_mb = downloaded / 1024 / 1024
                    total_mb = total / 1024 / 1024
                    status_callback(f"下载中: {downloaded_mb:.1f}MB / {total_mb:.1f}MB ({percentage:.1f}%)")
            
            self.download_with_progress(model_url, archive_path, download_progress)
            
            if status_callback:
                status_callback("正在解压模型...")
            
            # 解压模型
            def extract_progress(percentage):
                if progress_callback:
                    progress_callback(80 + percentage * 0.2)  # 解压占20%进度
            
            self.extract_archive(archive_path, self.models_dir, extract_progress)
            
            # 清理临时文件
            archive_path.unlink()
            temp_dir.rmdir()
            
            if status_callback:
                status_callback(f"模型 {model_name} 安装完成！")
            
            return True
            
        except Exception as e:
            if status_callback:
                status_callback(f"下载失败: {str(e)}")
            return False

class ModelSetupGUI:
    """模型安装图形界面"""
    
    def __init__(self):
        self.downloader = ModelDownloader()
        self.setup_window()
        
    def setup_window(self):
        """设置主窗口"""
        self.root = tk.Tk()
        self.root.title("ezA2T 模型安装程序")
        self.root.geometry("650x600")
        self.root.resizable(True, True)
        self.root.minsize(600, 500)
        
        # 设置窗口图标（如果有的话）
        try:
            self.root.iconbitmap("icon.ico")
        except:
            pass
        
        # 创建主框架和滚动区域
        self.setup_scrollable_frame()
        
    def setup_scrollable_frame(self):
        """创建可滚动的主框架"""
        # 创建Canvas和Scrollbar
        canvas = tk.Canvas(self.root, highlightthickness=0)
        scrollbar = ttk.Scrollbar(self.root, orient="vertical", command=canvas.yview)
        self.scrollable_frame = ttk.Frame(canvas)
        
        # 配置滚动
        self.scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 布局Canvas和Scrollbar
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # 添加鼠标滚轮支持
        def _on_mousewheel(event):
            canvas.yview_scroll(int(-1*(event.delta/120)), "units")
        
        def _bind_to_mousewheel(event):
            canvas.bind_all("<MouseWheel>", _on_mousewheel)
        
        def _unbind_from_mousewheel(event):
            canvas.unbind_all("<MouseWheel>")
        
        canvas.bind('<Enter>', _bind_to_mousewheel)
        canvas.bind('<Leave>', _unbind_from_mousewheel)
        
        # 创建内容框架
        main_frame = ttk.Frame(self.scrollable_frame, padding="20")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        self.setup_content(main_frame)
    
    def setup_content(self, main_frame):
        """设置界面内容"""
        title_label = ttk.Label(main_frame, text="ezA2T 语音识别模型安装", 
                               font=("Microsoft YaHei", 16, "bold"))
        title_label.pack(pady=(0, 20))
        
        # 说明文本
        info_text = """欢迎使用 ezA2T 实时语音转字幕软件！

为了开始使用，您需要下载语音识别模型。
请选择适合您需要的语言和模型大小：

• 小模型：下载快，占用空间少，响应速度快，适合一般使用
• 大模型：识别精度更高，但下载时间长，占用空间大

推荐首次使用选择小模型进行体验。"""
        
        info_label = ttk.Label(main_frame, text=info_text, justify=tk.LEFT, wraplength=550)
        info_label.pack(anchor=tk.W, pady=(0, 20))
        
        # 模型选择框架
        selection_frame = ttk.LabelFrame(main_frame, text="选择模型", padding="15")
        selection_frame.pack(fill=tk.X, pady=(0, 20))
        
        # 语言选择
        lang_frame = ttk.Frame(selection_frame)
        lang_frame.pack(fill=tk.X, pady=(0, 15))
        
        ttk.Label(lang_frame, text="语言:", font=("Microsoft YaHei", 10, "bold")).pack(side=tk.LEFT)
        self.language_var = tk.StringVar(value="zh-cn")
        lang_combo = ttk.Combobox(lang_frame, textvariable=self.language_var, 
                                 values=["zh-cn", "en-us"], state="readonly", width=15)
        lang_combo.pack(side=tk.LEFT, padx=(10, 0))
        
        # 添加语言说明
        lang_labels = {"zh-cn": "中文", "en-us": "英文"}
        self.lang_desc = ttk.Label(lang_frame, text="(中文)", font=("Microsoft YaHei", 9))
        self.lang_desc.pack(side=tk.LEFT, padx=(10, 0))
        
        def on_language_change(*args):
            lang = self.language_var.get()
            self.lang_desc.config(text=f"({lang_labels.get(lang, lang)})")
            self.update_model_list()
        
        self.language_var.trace('w', on_language_change)
        
        # 模型大小选择
        size_frame = ttk.Frame(selection_frame)
        size_frame.pack(fill=tk.X, pady=(15, 0))
        
        ttk.Label(size_frame, text="模型大小:", font=("Microsoft YaHei", 10, "bold")).pack(anchor=tk.W, pady=(0, 10))
        
        self.size_var = tk.StringVar(value="small")
        
        # 小模型选项
        small_frame = ttk.Frame(size_frame)
        small_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.size_radio1 = ttk.Radiobutton(small_frame, text="小模型 (推荐)", 
                                          variable=self.size_var, value="small")
        self.size_radio1.pack(side=tk.LEFT)
        
        small_desc = ttk.Label(small_frame, text="约40MB，快速下载，适合一般使用", 
                              font=("Microsoft YaHei", 8), foreground="gray")
        small_desc.pack(side=tk.LEFT, padx=(10, 0))
        
        # 大模型选项
        large_frame = ttk.Frame(size_frame)
        large_frame.pack(fill=tk.X)
        
        self.size_radio2 = ttk.Radiobutton(large_frame, text="大模型 (高精度)", 
                                          variable=self.size_var, value="large")
        self.size_radio2.pack(side=tk.LEFT)
        
        large_desc = ttk.Label(large_frame, text="约1-2GB，下载较慢，识别精度更高", 
                              font=("Microsoft YaHei", 8), foreground="gray")
        large_desc.pack(side=tk.LEFT, padx=(10, 0))
        
        # 模型详情显示
        self.detail_frame = ttk.LabelFrame(main_frame, text="模型详情", padding="15")
        self.detail_frame.pack(fill=tk.X, pady=(0, 20))
        
        self.detail_label = ttk.Label(self.detail_frame, text="", justify=tk.LEFT, wraplength=550)
        self.detail_label.pack(anchor=tk.W)
        
        self.size_var.trace('w', lambda *args: self.update_model_list())
        
        # 已安装模型显示
        installed_frame = ttk.LabelFrame(main_frame, text="已安装模型", padding="15")
        installed_frame.pack(fill=tk.X, pady=(0, 20))
        
        self.installed_label = ttk.Label(installed_frame, text="正在检查已安装模型...", wraplength=550)
        self.installed_label.pack(anchor=tk.W)
        
        # 进度条区域
        progress_frame = ttk.LabelFrame(main_frame, text="下载进度", padding="15")
        progress_frame.pack(fill=tk.X, pady=(0, 20))
        
        self.progress_bar = ttk.Progressbar(progress_frame, mode='determinate', length=500)
        self.progress_bar.pack(fill=tk.X, pady=(0, 10))
        
        self.status_label = ttk.Label(progress_frame, text="就绪", wraplength=550)
        self.status_label.pack(anchor=tk.W)
        
        # 按钮框架
        button_frame = ttk.Frame(main_frame)
        button_frame.pack(fill=tk.X, pady=(20, 0))
        
        # 主要按钮
        main_buttons = ttk.Frame(button_frame)
        main_buttons.pack(fill=tk.X, pady=(0, 10))
        
        self.download_button = ttk.Button(main_buttons, text="开始下载", 
                                         command=self.start_download)
        self.download_button.pack(side=tk.LEFT, padx=(0, 10))
        
        self.refresh_button = ttk.Button(main_buttons, text="刷新状态", 
                                        command=self.refresh_installed)
        self.refresh_button.pack(side=tk.LEFT, padx=(0, 10))
        
        # 次要按钮
        secondary_buttons = ttk.Frame(button_frame)
        secondary_buttons.pack(fill=tk.X)
        
        ttk.Button(secondary_buttons, text="跳过安装 (演示模式)", 
                  command=self.skip_setup).pack(side=tk.LEFT, padx=(0, 10))
        
        ttk.Button(secondary_buttons, text="退出安装程序", 
                  command=self.root.quit).pack(side=tk.RIGHT)
        
        # 帮助信息
        help_frame = ttk.LabelFrame(main_frame, text="帮助信息", padding="15")
        help_frame.pack(fill=tk.X, pady=(20, 0))
        
        help_text = """提示：
• 如果下载失败，请检查网络连接或尝试使用VPN
• 模型文件较大，请耐心等待下载完成
• 可以随时关闭此窗口，稍后手动运行 python setup.py 重新安装
• 如有问题，请访问项目文档或提交issue"""
        
        help_label = ttk.Label(help_frame, text=help_text, justify=tk.LEFT, 
                              font=("Microsoft YaHei", 8), foreground="gray", wraplength=550)
        help_label.pack(anchor=tk.W)
        
        # 初始化显示
        self.update_model_list()
        self.refresh_installed()
        
    def update_model_list(self):
        """更新模型详情显示"""
        language = self.language_var.get()
        size = self.size_var.get()
        
        if language in self.downloader.models and size in self.downloader.models[language]:
            model_info = self.downloader.models[language][size]
            detail_text = f"""模型名称: {model_info['name']}
文件大小: {model_info['size']}
说明: {model_info['description']}
下载地址: {model_info['url']}"""
            self.detail_label.config(text=detail_text)
        
    def refresh_installed(self):
        """刷新已安装模型列表"""
        installed = self.downloader.get_installed_models()
        if installed:
            installed_text = "已安装模型: " + ", ".join(installed)
        else:
            installed_text = "尚未安装任何模型，请选择并下载模型"
        self.installed_label.config(text=installed_text)
        
        # 如果已有模型，更新按钮文本
        if installed:
            self.download_button.config(text="下载其他模型")
        else:
            self.download_button.config(text="开始下载")
            
    def start_download(self):
        """开始下载模型"""
        language = self.language_var.get()
        size = self.size_var.get()
        
        # 确认下载
        model_info = self.downloader.models[language][size]
        
        # 创建详细的确认对话框
        confirm_text = f"""确定要下载以下模型吗？

模型名称: {model_info['name']}
文件大小: {model_info['size']}
语言: {self.lang_desc.cget('text')}
类型: {'小模型 (推荐)' if size == 'small' else '大模型 (高精度)'}

说明: {model_info['description']}

下载可能需要几分钟到几十分钟，取决于您的网络速度。"""
        
        # 使用自定义对话框
        result = self.show_download_confirmation(confirm_text, model_info)
        
        if not result:
            return
            
        # 禁用按钮
        self.download_button.config(state='disabled', text="下载中...")
        self.refresh_button.config(state='disabled')
        
        # 重置进度条
        self.progress_bar['value'] = 0
        
        def progress_callback(percentage):
            self.progress_bar['value'] = percentage
            self.root.update_idletasks()
            
        def status_callback(message):
            self.status_label.config(text=message)
            self.root.update_idletasks()
            
        def download_thread():
            try:
                success = self.downloader.download_model(language, size, 
                                                       progress_callback, status_callback)
                
                # 在主线程中更新UI
                self.root.after(0, self.download_completed, success)
                
            except Exception as e:
                self.root.after(0, self.download_completed, False, str(e))
        
        # 在新线程中下载
        threading.Thread(target=download_thread, daemon=True).start()
    
    def show_download_confirmation(self, message, model_info):
        """显示下载确认对话框"""
        dialog = tk.Toplevel(self.root)
        dialog.title("确认下载")
        dialog.geometry("500x400")
        dialog.resizable(False, False)
        dialog.transient(self.root)
        dialog.grab_set()
        
        # 居中显示
        dialog.update_idletasks()
        x = self.root.winfo_x() + (self.root.winfo_width() // 2) - (dialog.winfo_width() // 2)
        y = self.root.winfo_y() + (self.root.winfo_height() // 2) - (dialog.winfo_height() // 2)
        dialog.geometry(f"+{x}+{y}")
        
        # 创建滚动文本区域
        text_frame = ttk.Frame(dialog, padding="20")
        text_frame.pack(fill=tk.BOTH, expand=True)
        
        # 滚动文本
        text_widget = tk.Text(text_frame, wrap=tk.WORD, width=50, height=15, 
                             font=("Microsoft YaHei", 10))
        scrollbar = ttk.Scrollbar(text_frame, orient="vertical", command=text_widget.yview)
        text_widget.configure(yscrollcommand=scrollbar.set)
        
        text_widget.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        text_widget.insert("1.0", message)
        text_widget.config(state="disabled")
        
        # 按钮框架
        button_frame = ttk.Frame(dialog, padding="20")
        button_frame.pack(fill=tk.X)
        
        result = {"value": False}
        
        def on_confirm():
            result["value"] = True
            dialog.destroy()
        
        def on_cancel():
            result["value"] = False
            dialog.destroy()
        
        ttk.Button(button_frame, text="确认下载", command=on_confirm).pack(side=tk.LEFT, padx=(0, 10))
        ttk.Button(button_frame, text="取消", command=on_cancel).pack(side=tk.LEFT)
        
        # 等待对话框关闭
        dialog.wait_window()
        return result["value"]
        
    def download_completed(self, success, error_msg=None):
        """下载完成回调"""
        # 恢复按钮
        self.download_button.config(state='normal', text="开始下载")
        self.refresh_button.config(state='normal')
        
        if success:
            self.progress_bar['value'] = 100
            self.status_label.config(text="模型安装完成！")
            self.refresh_installed()
            
            # 显示成功对话框
            success_dialog = tk.Toplevel(self.root)
            success_dialog.title("安装成功")
            success_dialog.geometry("400x300")
            success_dialog.resizable(False, False)
            success_dialog.transient(self.root)
            success_dialog.grab_set()
            
            # 居中显示
            success_dialog.update_idletasks()
            x = self.root.winfo_x() + (self.root.winfo_width() // 2) - (success_dialog.winfo_width() // 2)
            y = self.root.winfo_y() + (self.root.winfo_height() // 2) - (success_dialog.winfo_height() // 2)
            success_dialog.geometry(f"+{x}+{y}")
            
            # 成功信息
            success_frame = ttk.Frame(success_dialog, padding="20")
            success_frame.pack(fill=tk.BOTH, expand=True)
            
            ttk.Label(success_frame, text="🎉 模型安装成功！", 
                     font=("Microsoft YaHei", 14, "bold")).pack(pady=(0, 20))
            
            success_text = """模型已成功下载并安装到 models/ 目录。
现在您可以开始使用 ezA2T 进行实时语音转字幕了！

接下来您可以：
• 立即启动 ezA2T 体验语音转字幕功能
• 关闭安装程序，稍后手动启动
• 下载其他语言模型"""
            
            ttk.Label(success_frame, text=success_text, justify=tk.LEFT, wraplength=350).pack(pady=(0, 20))
            
            # 按钮
            button_frame = ttk.Frame(success_frame)
            button_frame.pack(fill=tk.X)
            
            def launch_now():
                success_dialog.destroy()
                self.launch_app()
            
            def close_only():
                success_dialog.destroy()
            
            ttk.Button(button_frame, text="立即启动 ezA2T", 
                      command=launch_now).pack(side=tk.LEFT, padx=(0, 10))
            ttk.Button(button_frame, text="稍后启动", 
                      command=close_only).pack(side=tk.LEFT)
            
        else:
            self.progress_bar['value'] = 0
            error_text = f"模型安装失败"
            if error_msg:
                error_text += f": {error_msg}"
            self.status_label.config(text=error_text)
            
            # 显示错误对话框
            error_dialog = tk.Toplevel(self.root)
            error_dialog.title("安装失败")
            error_dialog.geometry("450x350")
            error_dialog.resizable(False, False)
            error_dialog.transient(self.root)
            error_dialog.grab_set()
            
            # 居中显示
            error_dialog.update_idletasks()
            x = self.root.winfo_x() + (self.root.winfo_width() // 2) - (error_dialog.winfo_width() // 2)
            y = self.root.winfo_y() + (self.root.winfo_height() // 2) - (error_dialog.winfo_height() // 2)
            error_dialog.geometry(f"+{x}+{y}")
            
            # 错误信息
            error_frame = ttk.Frame(error_dialog, padding="20")
            error_frame.pack(fill=tk.BOTH, expand=True)
            
            ttk.Label(error_frame, text="❌ 模型安装失败", 
                     font=("Microsoft YaHei", 14, "bold")).pack(pady=(0, 20))
            
            error_detail = f"""安装过程中出现错误：{error_msg or '未知错误'}

可能的解决方案：
• 检查网络连接是否正常
• 尝试使用VPN或更换网络环境
• 手动下载模型文件：访问 https://alphacephei.com/vosk/models
• 稍后重试安装程序

您也可以先体验演示模式，稍后再安装模型。"""
            
            ttk.Label(error_frame, text=error_detail, justify=tk.LEFT, wraplength=400).pack(pady=(0, 20))
            
            # 按钮
            button_frame = ttk.Frame(error_frame)
            button_frame.pack(fill=tk.X)
            
            def retry_download():
                error_dialog.destroy()
                self.start_download()
            
            def demo_mode():
                error_dialog.destroy()
                self.skip_setup()
            
            def close_error():
                error_dialog.destroy()
            
            ttk.Button(button_frame, text="重试下载", 
                      command=retry_download).pack(side=tk.LEFT, padx=(0, 5))
            ttk.Button(button_frame, text="演示模式", 
                      command=demo_mode).pack(side=tk.LEFT, padx=(0, 5))
            ttk.Button(button_frame, text="关闭", 
                      command=close_error).pack(side=tk.LEFT)
    
    def skip_setup(self):
        """跳过安装"""
        # 创建确认对话框
        skip_dialog = tk.Toplevel(self.root)
        skip_dialog.title("跳过模型安装")
        skip_dialog.geometry("400x250")
        skip_dialog.resizable(False, False)
        skip_dialog.transient(self.root)
        skip_dialog.grab_set()
        
        # 居中显示
        skip_dialog.update_idletasks()
        x = self.root.winfo_x() + (self.root.winfo_width() // 2) - (skip_dialog.winfo_width() // 2)
        y = self.root.winfo_y() + (self.root.winfo_height() // 2) - (skip_dialog.winfo_height() // 2)
        skip_dialog.geometry(f"+{x}+{y}")
        
        # 确认信息
        skip_frame = ttk.Frame(skip_dialog, padding="20")
        skip_frame.pack(fill=tk.BOTH, expand=True)
        
        ttk.Label(skip_frame, text="确定要跳过模型安装吗？", 
                 font=("Microsoft YaHei", 12, "bold")).pack(pady=(0, 15))
        
        skip_text = """没有语音识别模型，程序将以演示模式运行：
• 界面功能正常，可以测试字幕显示效果
• 无法进行实际的语音识别
• 稍后可以重新运行安装程序下载模型

您可以随时运行 python setup.py 来安装模型。"""
        
        ttk.Label(skip_frame, text=skip_text, justify=tk.LEFT, wraplength=350).pack(pady=(0, 20))
        
        # 按钮
        button_frame = ttk.Frame(skip_frame)
        button_frame.pack(fill=tk.X)
        
        def confirm_skip():
            skip_dialog.destroy()
            self.launch_app()
        
        def cancel_skip():
            skip_dialog.destroy()
        
        ttk.Button(button_frame, text="确认跳过", 
                  command=confirm_skip).pack(side=tk.LEFT, padx=(0, 10))
        ttk.Button(button_frame, text="取消", 
                  command=cancel_skip).pack(side=tk.LEFT)
    
    def launch_app(self):
        """启动主程序"""
        self.root.destroy()
        
        # 启动主程序
        try:
            import subprocess
            subprocess.Popen([sys.executable, "main.py"])
        except Exception as e:
            # 如果无法启动，显示错误信息
            error_root = tk.Tk()
            error_root.withdraw()
            messagebox.showerror("启动失败", f"无法启动主程序: {e}\n\n请手动运行: python main.py")
            error_root.destroy()
    
    def run(self):
        """运行安装程序"""
        # 居中显示窗口
        self.root.update_idletasks()
        x = (self.root.winfo_screenwidth() // 2) - (self.root.winfo_width() // 2)
        y = (self.root.winfo_screenheight() // 2) - (self.root.winfo_height() // 2)
        self.root.geometry(f"+{x}+{y}")
        
        self.root.mainloop()

def main():
    """主函数"""
    print("ezA2T 模型安装程序")
    print("=" * 30)
    
    # 检查是否在正确的目录
    if not Path("main.py").exists():
        print("错误: 请在 ezA2T 项目根目录运行此脚本")
        input("按回车键退出...")
        return
    
    # 启动图形界面
    try:
        app = ModelSetupGUI()
        app.run()
    except Exception as e:
        print(f"启动安装程序失败: {e}")
        
        # 降级到命令行模式
        print("\\n尝试命令行模式...")
        downloader = ModelDownloader()
        
        print("\\n可用模型:")
        for lang, models in downloader.models.items():
            print(f"\\n{lang}:")
            for size, info in models.items():
                print(f"  {size}: {info['name']} ({info['size']})")
        
        print("\\n请手动下载模型到 models/ 目录")
        print("下载地址: https://alphacephei.com/vosk/models")
        
        input("按回车键退出...")

if __name__ == "__main__":
    main()