AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/core/provider/sources/gemini_tts_source.py

@@ -0,0 +1,81 @@
+import os
+import uuid
+import wave
+
+from google import genai
+from google.genai import types
+
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
+from ..entities import ProviderType
+from ..provider import TTSProvider
+from ..register import register_provider_adapter
+
+
+@register_provider_adapter(
+    "gemini_tts",
+    "Gemini TTS API",
+    provider_type=ProviderType.TEXT_TO_SPEECH,
+)
+class ProviderGeminiTTSAPI(TTSProvider):
+    def __init__(
+        self,
+        provider_config: dict,
+        provider_settings: dict,
+    ) -> None:
+        super().__init__(provider_config, provider_settings)
+        api_key: str = provider_config.get("gemini_tts_api_key", "")
+        api_base: str | None = provider_config.get("gemini_tts_api_base")
+        timeout: int = int(provider_config.get("gemini_tts_timeout", 20))
+        http_options = types.HttpOptions(timeout=timeout * 1000)
+
+        if api_base:
+            api_base = api_base.removesuffix("/")
+            http_options.base_url = api_base
+
+        self.client = genai.Client(api_key=api_key, http_options=http_options).aio
+        self.model: str = provider_config.get(
+            "gemini_tts_model",
+            "gemini-2.5-flash-preview-tts",
+        )
+        self.prefix: str | None = provider_config.get(
+            "gemini_tts_prefix",
+        )
+        self.voice_name: str = provider_config.get("gemini_tts_voice_name", "Leda")
+
+    async def get_audio(self, text: str) -> str:
+        temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+        path = os.path.join(temp_dir, f"gemini_tts_{uuid.uuid4()}.wav")
+        prompt = f"{self.prefix}: {text}" if self.prefix else text
+        response = await self.client.models.generate_content(
+            model=self.model,
+            contents=prompt,
+            config=types.GenerateContentConfig(
+                response_modalities=["AUDIO"],
+                speech_config=types.SpeechConfig(
+                    voice_config=types.VoiceConfig(
+                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                            voice_name=self.voice_name,
+                        ),
+                    ),
+                ),
+            ),
+        )
+
+        # 不想看类型检查报错
+        if (
+            not response.candidates
+            or not response.candidates[0].content
+            or not response.candidates[0].content.parts
+            or not response.candidates[0].content.parts[0].inline_data
+            or not response.candidates[0].content.parts[0].inline_data.data
+        ):
+            raise Exception("No audio content returned from Gemini TTS API.")
+
+        with wave.open(path, "wb") as wf:
+            wf.setnchannels(1)
+            wf.setsampwidth(2)
+            wf.setframerate(24000)
+            wf.writeframes(response.candidates[0].content.parts[0].inline_data.data)
+
+        return path

astrbot/core/provider/sources/groq_source.py

@@ -0,0 +1,15 @@
+from ..register import register_provider_adapter
+from .openai_source import ProviderOpenAIOfficial
+
+
+@register_provider_adapter(
+    "groq_chat_completion", "Groq Chat Completion Provider Adapter"
+)
+class ProviderGroq(ProviderOpenAIOfficial):
+    def __init__(
+        self,
+        provider_config: dict,
+        provider_settings: dict,
+    ) -> None:
+        super().__init__(provider_config, provider_settings)
+        self.reasoning_key = "reasoning"

astrbot/core/provider/sources/gsv_selfhosted_source.py

@@ -0,0 +1,151 @@
+import asyncio
+import os
+import uuid
+
+import aiohttp
+
+from astrbot import logger
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
+from ..entities import ProviderType
+from ..provider import TTSProvider
+from ..register import register_provider_adapter
+
+
+@register_provider_adapter(
+    provider_type_name="gsv_tts_selfhost",
+    desc="GPT-SoVITS TTS(本地加载)",
+    provider_type=ProviderType.TEXT_TO_SPEECH,
+)
+class ProviderGSVTTS(TTSProvider):
+    def __init__(
+        self,
+        provider_config: dict,
+        provider_settings: dict,
+    ) -> None:
+        super().__init__(provider_config, provider_settings)
+
+        self.api_base = provider_config.get("api_base", "http://127.0.0.1:9880").rstrip(
+            "/",
+        )
+        self.gpt_weights_path: str = provider_config.get("gpt_weights_path", "")
+        self.sovits_weights_path: str = provider_config.get("sovits_weights_path", "")
+
+        # TTS 请求的默认参数，移除前缀gsv_
+        self.default_params: dict = {
+            key.removeprefix("gsv_"): str(value).lower()
+            for key, value in provider_config.get("gsv_default_parms", {}).items()
+        }
+        self.timeout = provider_config.get("timeout", 60)
+        self._session: aiohttp.ClientSession | None = None
+
+    async def initialize(self):
+        """异步初始化：在 ProviderManager 中被调用"""
+        self._session = aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=self.timeout),
+        )
+        try:
+            await self._set_model_weights()
+            logger.info("[GSV TTS] 初始化完成")
+        except Exception as e:
+            logger.error(f"[GSV TTS] 初始化失败：{e}")
+            raise
+
+    def get_session(self) -> aiohttp.ClientSession:
+        if not self._session or self._session.closed:
+            raise RuntimeError(
+                "[GSV TTS] Provider HTTP session is not ready or closed.",
+            )
+        return self._session
+
+    async def _make_request(
+        self,
+        endpoint: str,
+        params=None,
+        retries: int = 3,
+    ) -> bytes | None:
+        """发起请求"""
+        for attempt in range(retries):
+            logger.debug(f"[GSV TTS] 请求地址：{endpoint}，参数：{params}")
+            try:
+                async with self.get_session().get(endpoint, params=params) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        raise Exception(
+                            f"[GSV TTS] Request to {endpoint} failed with status {response.status}: {error_text}",
+                        )
+                    return await response.read()
+            except Exception as e:
+                if attempt < retries - 1:
+                    logger.warning(
+                        f"[GSV TTS] 请求 {endpoint} 第 {attempt + 1} 次失败：{e}，重试中...",
+                    )
+                    await asyncio.sleep(1)
+                else:
+                    logger.error(f"[GSV TTS] 请求 {endpoint} 最终失败：{e}")
+                    raise
+
+    async def _set_model_weights(self):
+        """设置模型路径"""
+        try:
+            if self.gpt_weights_path:
+                await self._make_request(
+                    f"{self.api_base}/set_gpt_weights",
+                    {"weights_path": self.gpt_weights_path},
+                )
+                logger.info(f"[GSV TTS] 成功设置 GPT 模型路径：{self.gpt_weights_path}")
+            else:
+                logger.info("[GSV TTS] GPT 模型路径未配置，将使用内置 GPT 模型")
+
+            if self.sovits_weights_path:
+                await self._make_request(
+                    f"{self.api_base}/set_sovits_weights",
+                    {"weights_path": self.sovits_weights_path},
+                )
+                logger.info(
+                    f"[GSV TTS] 成功设置 SoVITS 模型路径：{self.sovits_weights_path}",
+                )
+            else:
+                logger.info("[GSV TTS] SoVITS 模型路径未配置，将使用内置 SoVITS 模型")
+        except aiohttp.ClientError as e:
+            logger.error(f"[GSV TTS] 设置模型路径时发生网络错误：{e}")
+        except Exception as e:
+            logger.error(f"[GSV TTS] 设置模型路径时发生未知错误：{e}")
+
+    async def get_audio(self, text: str) -> str:
+        """实现 TTS 核心方法，根据文本内容自动切换情绪"""
+        if not text.strip():
+            raise ValueError("[GSV TTS] TTS 文本不能为空")
+
+        endpoint = f"{self.api_base}/tts"
+
+        params = self.build_synthesis_params(text)
+
+        temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+        os.makedirs(temp_dir, exist_ok=True)
+        path = os.path.join(temp_dir, f"gsv_tts_{uuid.uuid4().hex}.wav")
+
+        logger.debug(f"[GSV TTS] 正在调用语音合成接口，参数：{params}")
+
+        result = await self._make_request(endpoint, params)
+        if isinstance(result, bytes):
+            with open(path, "wb") as f:
+                f.write(result)
+            return path
+        raise Exception(f"[GSV TTS] 合成失败，输入文本：{text}，错误信息：{result}")
+
+    def build_synthesis_params(self, text: str) -> dict:
+        """构建语音合成所需的参数字典。
+
+        当前仅包含默认参数 + 文本，未来可在此基础上动态添加如情绪、角色等语义控制字段。
+        """
+        params = self.default_params.copy()
+        params["text"] = text
+        # TODO: 在此处添加情绪分析，例如 params["emotion"] = detect_emotion(text)
+        return params
+
+    async def terminate(self):
+        """终止释放资源：在 ProviderManager 中被调用"""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            logger.info("[GSV TTS] Session 已关闭")

astrbot/core/provider/sources/gsvi_tts_source.py

@@ -1,13 +1,20 @@
+import os
+import urllib.parse
 import uuid
+
 import aiohttp
-import urllib.parse
-from ..provider import TTSProvider
+
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
 from ..entities import ProviderType
+from ..provider import TTSProvider
 from ..register import register_provider_adapter
 
 
 @register_provider_adapter(
-    "gsvi_tts_api", "GSVI TTS API", provider_type=ProviderType.TEXT_TO_SPEECH
+    "gsvi_tts_api",
+    "GSVI TTS API",
+    provider_type=ProviderType.TEXT_TO_SPEECH,
 )
 class ProviderGSVITTS(TTSProvider):
     def __init__(
@@ -17,13 +24,13 @@ class ProviderGSVITTS(TTSProvider):
     ) -> None:
         super().__init__(provider_config, provider_settings)
         self.api_base = provider_config.get("api_base", "http://127.0.0.1:5000")
-        if self.api_base.endswith("/"):
-            self.api_base = self.api_base[:-1]
+        self.api_base = self.api_base.removesuffix("/")
         self.character = provider_config.get("character")
         self.emotion = provider_config.get("emotion")
 
     async def get_audio(self, text: str) -> str:
-        path = f"data/temp/gsvi_tts_{uuid.uuid4()}.wav"
+        temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+        path = os.path.join(temp_dir, f"gsvi_tts_{uuid.uuid4()}.wav")
         params = {"text": text}
 
         if self.character:
@@ -46,7 +53,7 @@ class ProviderGSVITTS(TTSProvider):
                 else:
                     error_text = await response.text()
                     raise Exception(
-                        f"GSVI TTS API 请求失败，状态码: {response.status}，错误: {error_text}"
+                        f"GSVI TTS API 请求失败，状态码: {response.status}，错误: {error_text}",
                     )
 
         return path

astrbot/core/provider/sources/minimax_tts_api_source.py

@@ -0,0 +1,159 @@
+import json
+import os
+import uuid
+from collections.abc import AsyncIterator
+
+import aiohttp
+
+from astrbot.api import logger
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
+from ..entities import ProviderType
+from ..provider import TTSProvider
+from ..register import register_provider_adapter
+
+
+@register_provider_adapter(
+    "minimax_tts_api",
+    "MiniMax TTS API",
+    provider_type=ProviderType.TEXT_TO_SPEECH,
+)
+class ProviderMiniMaxTTSAPI(TTSProvider):
+    def __init__(
+        self,
+        provider_config: dict,
+        provider_settings: dict,
+    ) -> None:
+        super().__init__(provider_config, provider_settings)
+        self.chosen_api_key: str = provider_config.get("api_key", "")
+        self.api_base: str = provider_config.get(
+            "api_base",
+            "https://api.minimax.chat/v1/t2a_v2",
+        )
+        self.group_id: str = provider_config.get("minimax-group-id", "")
+        self.set_model(provider_config.get("model", ""))
+        self.lang_boost: str = provider_config.get("minimax-langboost", "auto")
+        self.is_timber_weight: bool = provider_config.get(
+            "minimax-is-timber-weight",
+            False,
+        )
+        self.timber_weight: list[dict[str, str | int]] = json.loads(
+            provider_config.get(
+                "minimax-timber-weight",
+                '[{"voice_id": "Chinese (Mandarin)_Warm_Girl", "weight": 1}]',
+            ),
+        )
+
+        self.voice_setting: dict = {
+            "speed": provider_config.get("minimax-voice-speed", 1.0),
+            "vol": provider_config.get("minimax-voice-vol", 1.0),
+            "pitch": provider_config.get("minimax-voice-pitch", 0),
+            "voice_id": ""
+            if self.is_timber_weight
+            else provider_config.get("minimax-voice-id", ""),
+            "emotion": provider_config.get("minimax-voice-emotion", "neutral"),
+            "latex_read": provider_config.get("minimax-voice-latex", False),
+            "english_normalization": provider_config.get(
+                "minimax-voice-english-normalization",
+                False,
+            ),
+        }
+
+        self.audio_setting: dict = {
+            "sample_rate": 32000,
+            "bitrate": 128000,
+            "format": "mp3",
+        }
+
+        self.concat_base_url: str = f"{self.api_base}?GroupId={self.group_id}"
+        self.headers = {
+            "Authorization": f"Bearer {self.chosen_api_key}",
+            "accept": "application/json, text/plain, */*",
+            "content-type": "application/json",
+        }
+
+    def _build_tts_stream_body(self, text: str):
+        """构建流式请求体"""
+        dict_body: dict[str, object] = {
+            "model": self.model_name,
+            "text": text,
+            "stream": True,
+            "language_boost": self.lang_boost,
+            "voice_setting": self.voice_setting,
+            "audio_setting": self.audio_setting,
+        }
+        if self.is_timber_weight:
+            dict_body["timber_weights"] = self.timber_weight
+
+        return json.dumps(dict_body)
+
+    async def _call_tts_stream(self, text: str) -> AsyncIterator[bytes]:
+        """进行流式请求"""
+        try:
+            async with (
+                aiohttp.ClientSession() as session,
+                session.post(
+                    self.concat_base_url,
+                    headers=self.headers,
+                    data=self._build_tts_stream_body(text),
+                    timeout=aiohttp.ClientTimeout(total=60),
+                ) as response,
+            ):
+                response.raise_for_status()
+
+                buffer = b""
+                while True:
+                    chunk = await response.content.read(8192)
+                    if not chunk:
+                        break
+
+                    buffer += chunk
+
+                    while b"\n\n" in buffer:
+                        try:
+                            message, buffer = buffer.split(b"\n\n", 1)
+                            if message.startswith(b"data: "):
+                                try:
+                                    data = json.loads(message[6:])
+                                    if "extra_info" in data:
+                                        continue
+                                    audio = data.get("data", {}).get("audio")
+                                    if audio is not None:
+                                        yield audio
+                                except json.JSONDecodeError:
+                                    logger.warning(
+                                        "Failed to parse JSON data from SSE message",
+                                    )
+                                    continue
+                        except ValueError:
+                            buffer = buffer[-1024:]
+
+        except aiohttp.ClientError as e:
+            raise Exception(f"MiniMax TTS API请求失败: {e!s}")
+
+    async def _audio_play(self, audio_stream: AsyncIterator[str]) -> bytes:
+        """解码数据流到 audio 比特流"""
+        chunks = []
+        async for chunk in audio_stream:
+            if chunk.strip():
+                chunks.append(bytes.fromhex(chunk.strip()))
+        return b"".join(chunks)
+
+    async def get_audio(self, text: str) -> str:
+        temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+        os.makedirs(temp_dir, exist_ok=True)
+        path = os.path.join(temp_dir, f"minimax_tts_api_{uuid.uuid4()}.mp3")
+
+        try:
+            # 直接将异步生成器传递给 _audio_play 方法
+            audio_stream = self._call_tts_stream(text)
+            audio = await self._audio_play(audio_stream)
+
+            # 结果保存至文件
+            with open(path, "wb") as file:
+                file.write(audio)
+
+            return path
+
+        except aiohttp.ClientError as e:
+            raise e

astrbot/core/provider/sources/openai_embedding_source.py

@@ -0,0 +1,40 @@
+from openai import AsyncOpenAI
+
+from ..entities import ProviderType
+from ..provider import EmbeddingProvider
+from ..register import register_provider_adapter
+
+
+@register_provider_adapter(
+    "openai_embedding",
+    "OpenAI API Embedding 提供商适配器",
+    provider_type=ProviderType.EMBEDDING,
+)
+class OpenAIEmbeddingProvider(EmbeddingProvider):
+    def __init__(self, provider_config: dict, provider_settings: dict) -> None:
+        super().__init__(provider_config, provider_settings)
+        self.provider_config = provider_config
+        self.provider_settings = provider_settings
+        self.client = AsyncOpenAI(
+            api_key=provider_config.get("embedding_api_key"),
+            base_url=provider_config.get(
+                "embedding_api_base",
+                "https://api.openai.com/v1",
+            ),
+            timeout=int(provider_config.get("timeout", 20)),
+        )
+        self.model = provider_config.get("embedding_model", "text-embedding-3-small")
+
+    async def get_embedding(self, text: str) -> list[float]:
+        """获取文本的嵌入"""
+        embedding = await self.client.embeddings.create(input=text, model=self.model)
+        return embedding.data[0].embedding
+
+    async def get_embeddings(self, texts: list[str]) -> list[list[float]]:
+        """批量获取文本的嵌入"""
+        embeddings = await self.client.embeddings.create(input=texts, model=self.model)
+        return [item.embedding for item in embeddings.data]
+
+    def get_dim(self) -> int:
+        """获取向量的维度"""
+        return self.provider_config.get("embedding_dimensions", 1024)