Edge-TTS语音合成实战：构建稳定可靠的多语言语音应用

Edge-TTS语音合成实战：构建稳定可靠的多语言语音应用

【免费下载链接】edge-ttsUse Microsoft Edge's online text-to-speech service from Python WITHOUT needing Microsoft Edge or Windows or an API key项目地址: https://gitcode.com/GitHub_Trending/ed/edge-tts

在当今数字化时代，语音合成技术已成为智能助手、有声内容创作、无障碍服务等众多应用场景的核心组件。Edge-TTS作为一个基于微软Edge在线语音服务的Python库，为开发者提供了无需微软Edge浏览器、Windows系统或API密钥即可使用的便捷解决方案。然而，在实际应用中，许多开发者会遇到连接失败、音频中断、语音列表获取异常等问题，这些问题往往源于网络环境、配置参数或服务端策略的变化。

问题发现与背景

想象这样一个场景：你正在开发一个多语言播报系统，需要为不同语言的用户提供实时语音反馈。系统在本地测试时一切正常，但当部署到生产环境后，用户开始报告语音合成失败的问题。控制台出现WSServerHandshakeError: 403错误，语音列表查询返回空数据，或者音频文件生成到一半突然中断。这些问题不仅影响用户体验，还可能导致关键业务流程中断。

更令人困惑的是，同样的代码在不同时间、不同网络环境下表现不一。有时上午能正常工作，下午却频繁失败；在公司内网环境下稳定运行，但在客户现场却无法使用。这种不稳定性让开发者难以定位问题根源，往往只能通过反复尝试和猜测来寻找解决方案。

核心挑战剖析

Edge-TTS的核心挑战源于其作为客户端与服务端之间的复杂交互系统。与传统的本地语音合成不同，Edge-TTS依赖于微软的云端语音服务，这意味着整个流程涉及多个关键环节：

1. 身份验证机制：微软服务端会对客户端请求进行多重验证，包括User-Agent、请求头格式、协议版本等
2. 网络连接稳定性：WebSocket长连接对网络质量要求较高，任何中间环节的波动都可能导致连接中断
3. 服务端策略变化：微软可能随时调整服务策略，如限制特定地区的访问、更新验证机制等
4. 客户端兼容性：不同版本的Edge-TTS可能与服务端存在兼容性问题

这些挑战并非孤立存在，而是相互关联的。例如，网络不稳定可能导致连接超时，而服务端可能会将频繁的连接尝试视为恶意行为，进而加强验证要求，形成恶性循环。

创新解决方案

方案一：智能重试与降级策略（复杂度：★★☆）

对于临时性的网络波动和服务端响应异常，智能重试机制是最有效的解决方案。Edge-TTS内置的重试逻辑较为简单，我们可以扩展其能力：

import asyncio import random from typing import Optional from edge_tts import Communicate class EnhancedCommunicate: """增强版的语音合成客户端，包含智能重试机制""" def __init__(self, max_retries: int = 3, backoff_factor: float = 1.5): self.max_retries = max_retries self.backoff_factor = backoff_factor async def text_to_speech_with_retry( self, text: str, voice: str = "zh-CN-XiaoxiaoNeural", rate: str = "+0%", volume: str = "+0%", pitch: str = "+0Hz" ) -> Optional[bytes]: """带智能重试的文本转语音方法""" for attempt in range(self.max_retries): try: # 创建通信实例 communicate = Communicate(text, voice, rate=rate, volume=volume, pitch=pitch) # 收集音频数据 audio_chunks = [] async for chunk in communicate.stream(): if chunk["type"] == "audio": audio_chunks.append(chunk["data"]) # 合并所有音频片段 if audio_chunks: return b"".join(audio_chunks) else: raise Exception("未接收到音频数据") except Exception as e: if attempt == self.max_retries - 1: # 最后一次尝试也失败，抛出异常 raise # 计算退避时间（指数退避 + 随机抖动） wait_time = (self.backoff_factor ** attempt) + random.uniform(0, 1) print(f"第{attempt + 1}次尝试失败，{wait_time:.2f}秒后重试: {e}") # 等待后重试 await asyncio.sleep(wait_time) return None async def fallback_to_local_tts( self, text: str, voice: str = "zh-CN-XiaoxiaoNeural" ) -> bytes: """降级到本地TTS引擎（如果可用）""" try: # 尝试使用本地TTS引擎，如pyttsx3 import pyttsx3 engine = pyttsx3.init() # 设置语音属性 voices = engine.getProperty('voices') for v in voices: if voice.lower() in v.name.lower(): engine.setProperty('voice', v.id) break # 保存到临时文件 temp_file = f"temp_{int(time.time())}.mp3" engine.save_to_file(text, temp_file) engine.runAndWait() # 读取文件内容 with open(temp_file, 'rb') as f: audio_data = f.read() # 清理临时文件 os.remove(temp_file) return audio_data except ImportError: print("本地TTS引擎不可用，返回静音音频") # 返回静音音频作为降级方案 return self._generate_silence_audio()

方案二：动态请求头优化（复杂度：★★★）

微软服务端对请求头的验证可能随时间变化，我们需要动态调整请求头以匹配服务端期望：

import aiohttp from datetime import datetime from edge_tts.constants import WSS_HEADERS, WSS_URL class DynamicHeaderManager: """动态请求头管理器，适应服务端验证策略变化""" def __init__(self): self.header_templates = [ # 标准Edge浏览器头 { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " "(KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0", "Accept": "*/*", "Accept-Language": "en-US,en;q=0.9", "Accept-Encoding": "gzip, deflate, br", "Origin": "chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold", "Connection": "Upgrade", "Upgrade": "websocket" }, # 移动端头 { "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) " "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 " "Mobile/15E148 Safari/604.1", "Accept": "*/*", "Accept-Language": "en-US,en;q=0.9", "Origin": "https://www.bing.com", "Connection": "Upgrade", "Upgrade": "websocket" }, # 精简头 { "User-Agent": "Edge-TTS/1.0", "Accept": "*/*", "Connection": "Upgrade", "Upgrade": "websocket" } ] self.current_template_index = 0 self.last_success_time = None self.success_count = {} def get_headers(self) -> dict: """获取当前最优的请求头""" # 如果有成功的记录，优先使用最成功的模板 if self.success_count: best_template = max(self.success_count.items(), key=lambda x: x[1])[0] return self.header_templates[best_template].copy() # 否则使用当前模板 return self.header_templates[self.current_template_index].copy() def rotate_template(self, success: bool): """根据请求结果旋转模板""" if success: # 记录成功次数 idx = self.current_template_index self.success_count[idx] = self.success_count.get(idx, 0) + 1 self.last_success_time = datetime.now() else: # 切换到下一个模板 self.current_template_index = (self.current_template_index + 1) % len(self.header_templates) print(f"切换到请求头模板 {self.current_template_index}") async def test_connection(self) -> bool: """测试当前请求头模板的连接性""" headers = self.get_headers() try: async with aiohttp.ClientSession() as session: # 尝试建立WebSocket连接 async with session.ws_connect( WSS_URL, headers=headers, ssl=False, timeout=aiohttp.ClientTimeout(total=10) ) as ws: # 发送测试消息 await ws.send_str(json.dumps({ "context": { "synthesis": { "audio": { "metadataoptions": { "sentenceBoundaryEnabled": "false", "wordBoundaryEnabled": "true" }, "outputFormat": "audio-24khz-48kbitrate-mono-mp3" } } } })) # 接收响应 response = await ws.receive(timeout=5) return response.type == aiohttp.WSMsgType.TEXT except Exception as e: print(f"连接测试失败: {e}") return False

方案三：语音缓存与预加载系统（复杂度：★★★★）

对于频繁使用的语音内容，建立缓存系统可以显著提升响应速度和稳定性：

import hashlib import json import os import sqlite3 from pathlib import Path from typing import Dict, List, Optional, Tuple class TTSCacheManager: """语音合成缓存管理器""" def __init__(self, cache_dir: str = ".edge_tts_cache", max_size_mb: int = 1024): self.cache_dir = Path(cache_dir) self.max_size_mb = max_size_mb self.db_path = self.cache_dir / "cache.db" # 初始化缓存目录和数据库 self.cache_dir.mkdir(parents=True, exist_ok=True) self._init_database() def _init_database(self): """初始化缓存数据库""" conn = sqlite3.connect(self.db_path) cursor = conn.cursor() # 创建缓存记录表 cursor.execute(""" CREATE TABLE IF NOT EXISTS tts_cache ( id TEXT PRIMARY KEY, text TEXT NOT NULL, voice TEXT NOT NULL, rate TEXT NOT NULL, volume TEXT NOT NULL, pitch TEXT NOT NULL, audio_file TEXT NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP, access_count INTEGER DEFAULT 1, file_size INTEGER NOT NULL ) """) # 创建索引 cursor.execute("CREATE INDEX IF NOT EXISTS idx_text_voice ON tts_cache(text, voice)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_last_accessed ON tts_cache(last_accessed)") conn.commit() conn.close() def _generate_cache_id(self, text: str, voice: str, rate: str, volume: str, pitch: str) -> str: """生成缓存ID""" content = f"{text}|{voice}|{rate}|{volume}|{pitch}" return hashlib.md5(content.encode('utf-8')).hexdigest() async def get_or_create( self, text: str, voice: str = "zh-CN-XiaoxiaoNeural", rate: str = "+0%", volume: str = "+0%", pitch: str = "+0Hz", tts_func=None ) -> Optional[bytes]: """获取缓存或创建新的语音""" cache_id = self._generate_cache_id(text, voice, rate, volume, pitch) # 检查缓存 cached_audio = self._get_from_cache(cache_id) if cached_audio: print(f"缓存命中: {cache_id[:8]}...") return cached_audio # 缓存未命中，调用TTS函数 if tts_func is None: return None print(f"缓存未命中，生成新语音: {cache_id[:8]}...") audio_data = await tts_func(text, voice, rate, volume, pitch) if audio_data: # 保存到缓存 self._save_to_cache(cache_id, text, voice, rate, volume, pitch, audio_data) # 清理过期缓存 self._cleanup_cache() return audio_data def _get_from_cache(self, cache_id: str) -> Optional[bytes]: """从缓存获取音频数据""" conn = sqlite3.connect(self.db_path) cursor = conn.cursor() cursor.execute(""" SELECT audio_file, file_size FROM tts_cache WHERE id = ? AND created_at > datetime('now', '-30 days') """, (cache_id,)) result = cursor.fetchone() if result: audio_file, file_size = result # 更新访问记录 cursor.execute(""" UPDATE tts_cache SET last_accessed = CURRENT_TIMESTAMP, access_count = access_count + 1 WHERE id = ? """, (cache_id,)) conn.commit() conn.close() # 读取音频文件 file_path = self.cache_dir / audio_file if file_path.exists(): with open(file_path, 'rb') as f: return f.read() conn.close() return None def _save_to_cache(self, cache_id: str, text: str, voice: str, rate: str, volume: str, pitch: str, audio_data: bytes): """保存音频数据到缓存""" # 生成文件名 audio_file = f"{cache_id}.mp3" file_path = self.cache_dir / audio_file # 保存音频文件 with open(file_path, 'wb') as f: f.write(audio_data) # 保存到数据库 conn = sqlite3.connect(self.db_path) cursor = conn.cursor() cursor.execute(""" INSERT OR REPLACE INTO tts_cache (id, text, voice, rate, volume, pitch, audio_file, file_size) VALUES (?, ?, ?, ?, ?, ?, ?, ?) """, (cache_id, text, voice, rate, volume, pitch, audio_file, len(audio_data))) conn.commit() conn.close() def _cleanup_cache(self): """清理过期和超限的缓存""" # 计算当前缓存大小 total_size = sum(f.stat().st_size for f in self.cache_dir.glob("*.mp3")) total_size_mb = total_size / (1024 * 1024) if total_size_mb <= self.max_size_mb: return # 需要清理的大小 need_to_free_mb = total_size_mb - self.max_size_mb * 0.8 # 清理到80%容量 conn = sqlite3.connect(self.db_path) cursor = conn.cursor() # 按最后访问时间排序，优先删除最久未访问的 cursor.execute(""" SELECT id, audio_file, file_size FROM tts_cache ORDER BY last_accessed ASC """) freed_size = 0 for cache_id, audio_file, file_size in cursor.fetchall(): # 删除文件 file_path = self.cache_dir / audio_file if file_path.exists(): file_path.unlink() # 删除数据库记录 cursor.execute("DELETE FROM tts_cache WHERE id = ?", (cache_id,)) freed_size += file_size if freed_size >= need_to_free_mb * 1024 * 1024: break conn.commit() conn.close() print(f"缓存清理完成，释放了{freed_size / (1024*1024):.2f}MB空间")

技术实现细节

连接池管理与优化

Edge-TTS的WebSocket连接管理是性能优化的关键。我们可以实现一个连接池来复用连接，减少握手开销：

import asyncio from collections import deque from typing import Deque, Optional import aiohttp class WebSocketConnectionPool: """WebSocket连接池""" def __init__(self, max_size: int = 10, idle_timeout: int = 300): self.max_size = max_size self.idle_timeout = idle_timeout self.pool: Deque[aiohttp.ClientWebSocketResponse] = deque() self.last_used = {} async def acquire(self) -> Optional[aiohttp.ClientWebSocketResponse]: """从连接池获取连接""" self._clean_idle_connections() if self.pool: ws = self.pool.popleft() self.last_used[id(ws)] = asyncio.get_event_loop().time() return ws return None async def release(self, ws: aiohttp.ClientWebSocketResponse): """释放连接回连接池""" if len(self.pool) < self.max_size and not ws.closed: self.pool.append(ws) self.last_used[id(ws)] = asyncio.get_event_loop().time() else: await ws.close() def _clean_idle_connections(self): """清理空闲连接""" current_time = asyncio.get_event_loop().time() # 移除空闲时间过长的连接 while self.pool: ws = self.pool[0] ws_id = id(ws) if current_time - self.last_used.get(ws_id, 0) > self.idle_timeout: self.pool.popleft() if not ws.closed: asyncio.create_task(ws.close()) del self.last_used[ws_id] else: break

音频流处理优化

处理大文本时，音频流的分块处理至关重要。以下是一个优化的音频流处理器：

import io import struct from typing import AsyncGenerator, List class AudioStreamProcessor: """音频流处理器，优化大文本合成""" def __init__(self, chunk_size: int = 4096): self.chunk_size = chunk_size async def process_large_text( self, text: str, voice: str, max_chars: int = 1000 ) -> AsyncGenerator[bytes, None]: """处理大文本，分块合成""" # 按句子分割文本 sentences = self._split_text_by_sentences(text, max_chars) for i, sentence in enumerate(sentences): print(f"处理第{i+1}/{len(sentences)}句: {sentence[:50]}...") try: # 合成当前句子 communicate = Communicate(sentence, voice) async for chunk in communicate.stream(): if chunk["type"] == "audio": # 分块输出音频数据 audio_data = chunk["data"] for j in range(0, len(audio_data), self.chunk_size): yield audio_data[j:j + self.chunk_size] # 句子间添加短暂静音 if i < len(sentences) - 1: yield self._generate_silence(500) # 500ms静音 except Exception as e: print(f"句子{i+1}合成失败: {e}") # 生成错误提示音频 yield self._generate_error_audio(f"第{i+1}句合成失败") def _split_text_by_sentences(self, text: str, max_chars: int) -> List[str]: """按句子分割文本，考虑最大字符限制""" sentences = [] current_sentence = "" # 简单的句子分割（实际应用中可以使用更复杂的分句算法） for char in text: current_sentence += char # 句子结束标志 if char in '。！？.!?': sentences.append(current_sentence.strip()) current_sentence = "" elif len(current_sentence) >= max_chars: # 超过最大长度，强制分割 sentences.append(current_sentence.strip()) current_sentence = "" if current_sentence: sentences.append(current_sentence.strip()) return sentences def _generate_silence(self, duration_ms: int) -> bytes: """生成指定时长的静音MP3帧""" # MP3静音帧（简化实现） # 实际应用中需要生成正确的MP3静音帧 silence_frame = b'\xFF\xFB\x90\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' frames_needed = int(duration_ms / 26) # 假设每帧26ms return silence_frame * frames_needed

最佳实践指南

1. 环境配置优化

网络配置建议：

• 确保防火墙允许到speech.platform.bing.com的WebSocket连接（端口443）
• 配置合理的DNS服务器，避免DNS解析问题
• 在网络不稳定的环境中，考虑使用HTTP/HTTPS代理，但需确保代理支持WebSocket协议

Python环境配置：

# requirements.txt 推荐版本 edge-tts>=6.1.0 aiohttp>=3.9.0 certifi>=2024.2.2 # 异步运行时配置 import asyncio import uvloop # 使用uvloop提升异步性能（Linux/macOS） try: asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) except ImportError: print("uvloop不可用，使用标准事件循环")

2. 错误处理策略

建立分级的错误处理机制，根据错误类型采取不同策略：

from edge_tts.exceptions import WebSocketError, NoAudioReceived, UnexpectedResponse class ErrorHandler: """分级错误处理器""" ERROR_STRATEGIES = { "network": { "retry_times": 3, "backoff_base": 2.0, "max_backoff": 30.0 }, "authentication": { "retry_times": 1, "backoff_base": 5.0, "max_backoff": 60.0, "action": "refresh_headers" }, "server_error": { "retry_times": 2, "backoff_base": 10.0, "max_backoff": 300.0, "action": "switch_endpoint" } } @classmethod def classify_error(cls, exception: Exception) -> str: """错误分类""" if isinstance(exception, (ConnectionError, TimeoutError)): return "network" elif isinstance(exception, WebSocketError) and "403" in str(exception): return "authentication" elif isinstance(exception, (UnexpectedResponse, NoAudioReceived)): return "server_error" else: return "unknown" @classmethod def get_strategy(cls, error_type: str) -> dict: """获取错误处理策略""" return cls.ERROR_STRATEGIES.get(error_type, { "retry_times": 1, "backoff_base": 1.0, "max_backoff": 10.0 })

3. 监控与日志

建立完善的监控体系，及时发现问题：

import logging from datetime import datetime from dataclasses import dataclass from typing import Dict, Any @dataclass class TTSEvent: """TTS事件记录""" timestamp: datetime event_type: str text_length: int voice: str success: bool duration_ms: float error_message: str = "" metadata: Dict[str, Any] = None class TTSMonitor: """TTS监控器""" def __init__(self): self.logger = logging.getLogger("edge_tts_monitor") self.events = [] def log_event(self, event: TTSEvent): """记录事件""" self.events.append(event) # 控制台日志 if event.success: self.logger.info( f"TTS合成成功: {event.text_length}字符, " f"耗时{event.duration_ms:.0f}ms, 语音: {event.voice}" ) else: self.logger.error( f"TTS合成失败: {event.error_message}, " f"文本长度: {event.text_length}, 语音: {event.voice}" ) # 定期清理旧事件 if len(self.events) > 1000: self.events = self.events[-500:] def get_stats(self, hours: int = 24) -> Dict[str, Any]: """获取统计信息""" cutoff_time = datetime.now() - timedelta(hours=hours) recent_events = [e for e in self.events if e.timestamp > cutoff_time] if not recent_events: return {} success_count = sum(1 for e in recent_events if e.success) total_count = len(recent_events) return { "total_requests": total_count, "success_rate": success_count / total_count * 100, "avg_duration_ms": sum(e.duration_ms for e in recent_events) / total_count, "by_voice": self._group_by_voice(recent_events), "error_types": self._group_by_error(recent_events) }

进阶思考

WebSocket协议深度优化

Edge-TTS使用的WebSocket协议在语音合成场景中有独特的优化空间。传统的WebSocket实现可能不适合长时间、大数据量的音频流传输。我们可以从以下几个角度进行优化：

1. 帧大小优化：调整WebSocket帧大小，平衡传输效率和延迟
2. 压缩策略：在传输层之上实现音频数据的增量压缩
3. 心跳机制：实现智能心跳，避免连接被服务端主动断开

多服务端负载均衡

单一服务端依赖是Edge-TTS的主要风险点。我们可以设计一个负载均衡器，在多个语音合成服务之间动态切换：

class TTSServiceBalancer: """TTS服务负载均衡器""" def __init__(self): self.services = [ {"name": "edge_tts", "weight": 10, "current_load": 0}, {"name": "google_tts", "weight": 5, "current_load": 0}, {"name": "azure_tts", "weight": 8, "current_load": 0} ] self.fallback_order = ["edge_tts", "azure_tts", "google_tts"] async def synthesize(self, text: str, **kwargs) -> bytes: """使用负载均衡策略合成语音""" for service_name in self._get_service_order(): try: if service_name == "edge_tts": return await self._synthesize_with_edge_tts(text, **kwargs) elif service_name == "azure_tts": return await self._synthesize_with_azure_tts(text, **kwargs) elif service_name == "google_tts": return await self._synthesize_with_google_tts(text, **kwargs) except Exception as e: print(f"{service_name} 服务失败: {e}") continue raise Exception("所有TTS服务均不可用") def _get_service_order(self) -> list: """获取服务调用顺序，基于权重和当前负载""" # 简单的加权轮询算法 services = sorted( self.services, key=lambda s: s["current_load"] / s["weight"] ) return [s["name"] for s in services]

语音质量评估与优化

对于语音合成应用，质量评估同样重要。我们可以实现一个简单的质量评估系统：

import numpy as np from scipy import signal import soundfile as sf class AudioQualityAnalyzer: """音频质量分析器""" def analyze_quality(self, audio_data: bytes) -> Dict[str, float]: """分析音频质量""" # 将音频数据转换为numpy数组（简化示例） # 实际应用中需要使用正确的解码器 try: # 这里使用一个简化的分析 audio_array = np.frombuffer(audio_data, dtype=np.int16) # 计算基本指标 metrics = { "duration_seconds": len(audio_array) / 16000, # 假设16kHz采样率 "max_amplitude": float(np.max(np.abs(audio_array))), "rms_energy": float(np.sqrt(np.mean(audio_array**2))), "signal_to_noise": self._estimate_snr(audio_array), "clipping_percentage": self._detect_clipping(audio_array) } # 频谱分析 if len(audio_array) > 100: frequencies, power = signal.welch(audio_array[:16000], fs=16000) metrics["dominant_frequency"] = float(frequencies[np.argmax(power)]) return metrics except Exception as e: print(f"音频质量分析失败: {e}") return {} def _estimate_snr(self, audio_array: np.ndarray) -> float: """估计信噪比（简化版）""" if len(audio_array) < 1000: return 0.0 # 假设静音段在前100个样本 noise_std = np.std(audio_array[:100]) signal_std = np.std(audio_array) if noise_std == 0: return float('inf') return 20 * np.log10(signal_std / noise_std) def _detect_clipping(self, audio_array: np.ndarray) -> float: """检测削波比例""" max_value = np.iinfo(audio_array.dtype).max clipping_samples = np.sum(np.abs(audio_array) >= max_value * 0.99) return clipping_samples / len(audio_array) * 100

结语

Edge-TTS作为一个强大的语音合成工具，在实际应用中面临的主要挑战来自于网络环境、服务端策略和客户端兼容性。通过本文介绍的智能重试、动态请求头优化、语音缓存等策略，我们可以显著提升系统的稳定性和可靠性。

关键要点回顾：

1. 不要过度依赖单一解决方案：结合多种策略应对不同场景
2. 建立完善的监控体系：及时发现并响应问题
3. 考虑降级方案：在主服务不可用时提供备选方案
4. 优化用户体验：通过缓存和预加载减少等待时间

在实际开发中，建议根据具体应用场景选择合适的策略组合。对于高可用性要求的应用，可以考虑实现多服务端负载均衡；对于资源受限的环境，可以优先使用缓存策略。

开放式思考：随着语音合成技术的不断发展，我们如何平衡服务端依赖与本地处理能力？在边缘计算日益普及的今天，是否有可能将部分语音合成任务下放到客户端，实现真正的边缘语音合成？欢迎分享你的见解和实践经验。

【免费下载链接】edge-ttsUse Microsoft Edge's online text-to-speech service from Python WITHOUT needing Microsoft Edge or Windows or an API key项目地址: https://gitcode.com/GitHub_Trending/ed/edge-tts