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

astrbot/core/provider/sources/azure_tts_source.py

@@ -0,0 +1,224 @@
+import asyncio
+import hashlib
+import json
+import re
+import secrets
+import time
+import uuid
+from pathlib import Path
+from xml.sax.saxutils import escape
+
+from httpx import AsyncClient, Timeout
+
+from astrbot.core.config.default import VERSION
+
+from ..entities import ProviderType
+from ..provider import TTSProvider
+from ..register import register_provider_adapter
+
+TEMP_DIR = Path("data/temp/azure_tts")
+TEMP_DIR.mkdir(parents=True, exist_ok=True)
+
+
+class OTTSProvider:
+    def __init__(self, config: dict):
+        self.skey = config["OTTS_SKEY"]
+        self.api_url = config["OTTS_URL"]
+        self.auth_time_url = config["OTTS_AUTH_TIME"]
+        self.time_offset = 0
+        self.last_sync_time = 0
+        self.timeout = Timeout(10.0)
+        self.retry_count = 3
+        self.client = None
+
+    async def __aenter__(self):
+        self.client = AsyncClient(timeout=self.timeout)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.client:
+            await self.client.aclose()
+
+    async def _sync_time(self):
+        try:
+            response = await self.client.get(self.auth_time_url)
+            response.raise_for_status()
+            server_time = int(response.json()["timestamp"])
+            local_time = int(time.time())
+            self.time_offset = server_time - local_time
+            self.last_sync_time = local_time
+        except Exception as e:
+            if time.time() - self.last_sync_time > 3600:
+                raise RuntimeError("时间同步失败") from e
+
+    async def _generate_signature(self) -> str:
+        await self._sync_time()
+        timestamp = int(time.time()) + self.time_offset
+        nonce = "".join(
+            secrets.choice("abcdefghijklmnopqrstuvwxyz0123456789") for _ in range(10)
+        )
+        path = re.sub(r"^https?://[^/]+", "", self.api_url) or "/"
+        return f"{timestamp}-{nonce}-0-{hashlib.md5(f'{path}-{timestamp}-{nonce}-0-{self.skey}'.encode()).hexdigest()}"
+
+    async def get_audio(self, text: str, voice_params: dict) -> str:
+        file_path = TEMP_DIR / f"otts-{uuid.uuid4()}.wav"
+        signature = await self._generate_signature()
+        for attempt in range(self.retry_count):
+            try:
+                response = await self.client.post(
+                    f"{self.api_url}?sign={signature}",
+                    data={
+                        "text": text,
+                        "voice": voice_params["voice"],
+                        "style": voice_params["style"],
+                        "role": voice_params["role"],
+                        "rate": voice_params["rate"],
+                        "volume": voice_params["volume"],
+                    },
+                    headers={
+                        "User-Agent": f"AstrBot/{VERSION}",
+                        "UAK": "AstrBot/AzureTTS",
+                    },
+                )
+                response.raise_for_status()
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                with file_path.open("wb") as f:
+                    async for chunk in response.aiter_bytes(4096):
+                        f.write(chunk)
+                return str(file_path.resolve())
+            except Exception as e:
+                if attempt == self.retry_count - 1:
+                    raise RuntimeError(f"OTTS请求失败: {e!s}") from e
+                await asyncio.sleep(0.5 * (attempt + 1))
+
+
+class AzureNativeProvider(TTSProvider):
+    def __init__(self, provider_config: dict, provider_settings: dict):
+        super().__init__(provider_config, provider_settings)
+        self.subscription_key = provider_config.get(
+            "azure_tts_subscription_key",
+            "",
+        ).strip()
+        if not re.fullmatch(r"^[a-zA-Z0-9]{32}$", self.subscription_key):
+            raise ValueError("无效的Azure订阅密钥")
+        self.region = provider_config.get("azure_tts_region", "eastus").strip()
+        self.endpoint = (
+            f"https://{self.region}.tts.speech.microsoft.com/cognitiveservices/v1"
+        )
+        self.client = None
+        self.token = None
+        self.token_expire = 0
+        self.voice_params = {
+            "voice": provider_config.get("azure_tts_voice", "zh-CN-YunxiaNeural"),
+            "style": provider_config.get("azure_tts_style", "cheerful"),
+            "role": provider_config.get("azure_tts_role", "Boy"),
+            "rate": provider_config.get("azure_tts_rate", "1"),
+            "volume": provider_config.get("azure_tts_volume", "100"),
+        }
+
+    async def __aenter__(self):
+        self.client = AsyncClient(
+            headers={
+                "User-Agent": f"AstrBot/{VERSION}",
+                "Content-Type": "application/ssml+xml",
+                "X-Microsoft-OutputFormat": "riff-48khz-16bit-mono-pcm",
+            },
+        )
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.client:
+            await self.client.aclose()
+
+    async def _refresh_token(self):
+        token_url = (
+            f"https://{self.region}.api.cognitive.microsoft.com/sts/v1.0/issuetoken"
+        )
+        response = await self.client.post(
+            token_url,
+            headers={"Ocp-Apim-Subscription-Key": self.subscription_key},
+        )
+        response.raise_for_status()
+        self.token = response.text
+        self.token_expire = time.time() + 540
+
+    async def get_audio(self, text: str) -> str:
+        if not self.token or time.time() > self.token_expire:
+            await self._refresh_token()
+        file_path = TEMP_DIR / f"azure-{uuid.uuid4()}.wav"
+        ssml = f"""<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis'
+            xmlns:mstts='http://www.w3.org/2001/mstts' xml:lang='zh-CN'>
+            <voice name='{escape(self.voice_params["voice"])}'>
+                <mstts:express-as style='{escape(self.voice_params["style"])}'
+                    role='{escape(self.voice_params["role"])}'>
+                    <prosody rate='{escape(self.voice_params["rate"])}'
+                        volume='{escape(self.voice_params["volume"])}'>
+                        {escape(text)}
+                    </prosody>
+                </mstts:express-as>
+            </voice>
+        </speak>"""
+        response = await self.client.post(
+            self.endpoint,
+            content=ssml,
+            headers={
+                "Authorization": f"Bearer {self.token}",
+                "User-Agent": f"AstrBot/{VERSION}",
+            },
+        )
+        response.raise_for_status()
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        with file_path.open("wb") as f:
+            for chunk in response.iter_bytes(4096):
+                f.write(chunk)
+        return str(file_path.resolve())
+
+
+@register_provider_adapter("azure_tts", "Azure TTS", ProviderType.TEXT_TO_SPEECH)
+class AzureTTSProvider(TTSProvider):
+    def __init__(self, provider_config: dict, provider_settings: dict):
+        super().__init__(provider_config, provider_settings)
+        key_value = provider_config.get("azure_tts_subscription_key", "")
+        self.provider = self._parse_provider(key_value, provider_config)
+
+    def _parse_provider(self, key_value: str, config: dict) -> TTSProvider:
+        if key_value.lower().startswith("other["):
+            try:
+                match = re.match(r"other\[(.*)\]", key_value, re.DOTALL)
+                if not match:
+                    raise ValueError("无效的other[...]格式，应形如 other[{...}]")
+                json_str = match.group(1).strip()
+                otts_config = json.loads(json_str)
+                required = {"OTTS_SKEY", "OTTS_URL", "OTTS_AUTH_TIME"}
+                if missing := required - otts_config.keys():
+                    raise ValueError(f"缺少OTTS参数: {', '.join(missing)}")
+                return OTTSProvider(otts_config)
+            except json.JSONDecodeError as e:
+                error_msg = (
+                    f"JSON解析失败，请检查格式（错误位置：行 {e.lineno} 列 {e.colno}）\n"
+                    f"错误详情: {e.msg}\n"
+                    f"错误上下文: {json_str[max(0, e.pos - 30) : e.pos + 30]}"
+                )
+                raise ValueError(error_msg) from e
+            except KeyError as e:
+                raise ValueError(f"配置错误: 缺少必要参数 {e}") from e
+        if re.fullmatch(r"^[a-zA-Z0-9]{32}$", key_value):
+            return AzureNativeProvider(config, self.provider_settings)
+        raise ValueError("订阅密钥格式无效，应为32位字母数字或other[...]格式")
+
+    async def get_audio(self, text: str) -> str:
+        if isinstance(self.provider, OTTSProvider):
+            async with self.provider as provider:
+                return await provider.get_audio(
+                    text,
+                    {
+                        "voice": self.provider_config.get("azure_tts_voice"),
+                        "style": self.provider_config.get("azure_tts_style"),
+                        "role": self.provider_config.get("azure_tts_role"),
+                        "rate": self.provider_config.get("azure_tts_rate"),
+                        "volume": self.provider_config.get("azure_tts_volume"),
+                    },
+                )
+        else:
+            async with self.provider as provider:
+                return await provider.get_audio(text)

astrbot/core/provider/sources/bailian_rerank_source.py

@@ -0,0 +1,236 @@
+import os
+
+import aiohttp
+
+from astrbot import logger
+
+from ..entities import ProviderType, RerankResult
+from ..provider import RerankProvider
+from ..register import register_provider_adapter
+
+
+class BailianRerankError(Exception):
+    """百炼重排序服务异常基类"""
+
+    pass
+
+
+class BailianAPIError(BailianRerankError):
+    """百炼API返回错误"""
+
+    pass
+
+
+class BailianNetworkError(BailianRerankError):
+    """百炼网络请求错误"""
+
+    pass
+
+
+@register_provider_adapter(
+    "bailian_rerank", "阿里云百炼文本排序适配器", provider_type=ProviderType.RERANK
+)
+class BailianRerankProvider(RerankProvider):
+    """阿里云百炼文本重排序适配器."""
+
+    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
+
+        # API配置
+        self.api_key = provider_config.get("rerank_api_key") or os.getenv(
+            "DASHSCOPE_API_KEY", ""
+        )
+        if not self.api_key:
+            raise ValueError("阿里云百炼 API Key 不能为空。")
+
+        self.model = provider_config.get("rerank_model", "qwen3-rerank")
+        self.timeout = provider_config.get("timeout", 30)
+        self.return_documents = provider_config.get("return_documents", False)
+        self.instruct = provider_config.get("instruct", "")
+
+        self.base_url = provider_config.get(
+            "rerank_api_base",
+            "https://dashscope.aliyuncs.com/api/v1/services/rerank/text-rerank/text-rerank",
+        )
+
+        # 设置HTTP客户端
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        self.client = aiohttp.ClientSession(
+            headers=headers, timeout=aiohttp.ClientTimeout(total=self.timeout)
+        )
+
+        # 设置模型名称
+        self.set_model(self.model)
+
+        logger.info(f"AstrBot 百炼 Rerank 初始化完成。模型: {self.model}")
+
+    def _build_payload(
+        self, query: str, documents: list[str], top_n: int | None
+    ) -> dict:
+        """构建请求载荷
+
+        Args:
+            query: 查询文本
+            documents: 文档列表
+            top_n: 返回前N个结果，如果为None则返回所有结果
+
+        Returns:
+            请求载荷字典
+        """
+        base = {"model": self.model, "input": {"query": query, "documents": documents}}
+
+        params = {
+            k: v
+            for k, v in [
+                ("top_n", top_n if top_n is not None and top_n > 0 else None),
+                ("return_documents", True if self.return_documents else None),
+                (
+                    "instruct",
+                    self.instruct
+                    if self.instruct and self.model == "qwen3-rerank"
+                    else None,
+                ),
+            ]
+            if v is not None
+        }
+
+        if params:
+            base["parameters"] = params
+
+        return base
+
+    def _parse_results(self, data: dict) -> list[RerankResult]:
+        """解析API响应结果
+
+        Args:
+            data: API响应数据
+
+        Returns:
+            重排序结果列表
+
+        Raises:
+            BailianAPIError: API返回错误
+            KeyError: 结果缺少必要字段
+        """
+        # 检查响应状态
+        if data.get("code", "200") != "200":
+            raise BailianAPIError(
+                f"百炼 API 错误: {data.get('code')} – {data.get('message', '')}"
+            )
+
+        results = data.get("output", {}).get("results", [])
+        if not results:
+            logger.warning(f"百炼 Rerank 返回空结果: {data}")
+            return []
+
+        # 转换为RerankResult对象，使用.get()避免KeyError
+        rerank_results = []
+        for idx, result in enumerate(results):
+            try:
+                index = result.get("index", idx)
+                relevance_score = result.get("relevance_score", 0.0)
+
+                if relevance_score is None:
+                    logger.warning(f"结果 {idx} 缺少 relevance_score，使用默认值 0.0")
+                    relevance_score = 0.0
+
+                rerank_result = RerankResult(
+                    index=index, relevance_score=relevance_score
+                )
+                rerank_results.append(rerank_result)
+            except Exception as e:
+                logger.warning(f"解析结果 {idx} 时出错: {e}, result={result}")
+                continue
+
+        return rerank_results
+
+    def _log_usage(self, data: dict) -> None:
+        """记录使用量信息
+
+        Args:
+            data: API响应数据
+        """
+        tokens = data.get("usage", {}).get("total_tokens", 0)
+        if tokens > 0:
+            logger.debug(f"百炼 Rerank 消耗 Token: {tokens}")
+
+    async def rerank(
+        self,
+        query: str,
+        documents: list[str],
+        top_n: int | None = None,
+    ) -> list[RerankResult]:
+        """
+        对文档进行重排序
+
+        Args:
+            query: 查询文本
+            documents: 待排序的文档列表
+            top_n: 返回前N个结果，如果为None则使用配置中的默认值
+
+        Returns:
+            重排序结果列表
+        """
+        if not documents:
+            logger.warning("文档列表为空，返回空结果")
+            return []
+
+        if not query.strip():
+            logger.warning("查询文本为空，返回空结果")
+            return []
+
+        # 检查限制
+        if len(documents) > 500:
+            logger.warning(
+                f"文档数量({len(documents)})超过限制(500)，将截断前500个文档"
+            )
+            documents = documents[:500]
+
+        try:
+            # 构建请求载荷，如果top_n为None则返回所有重排序结果
+            payload = self._build_payload(query, documents, top_n)
+
+            logger.debug(
+                f"百炼 Rerank 请求: query='{query[:50]}...', 文档数量={len(documents)}"
+            )
+
+            # 发送请求
+            async with self.client.post(self.base_url, json=payload) as response:
+                response.raise_for_status()
+                response_data = await response.json()
+
+                # 解析结果并记录使用量
+                results = self._parse_results(response_data)
+                self._log_usage(response_data)
+
+                logger.debug(f"百炼 Rerank 成功返回 {len(results)} 个结果")
+
+                return results
+
+        except aiohttp.ClientError as e:
+            error_msg = f"网络请求失败: {e}"
+            logger.error(f"百炼 Rerank 网络请求失败: {e}")
+            raise BailianNetworkError(error_msg) from e
+        except BailianRerankError:
+            raise
+        except Exception as e:
+            error_msg = f"重排序失败: {e}"
+            logger.error(f"百炼 Rerank 处理失败: {e}")
+            raise BailianRerankError(error_msg) from e
+
+    async def terminate(self) -> None:
+        """关闭HTTP客户端会话."""
+        if self.client:
+            logger.info("关闭 百炼 Rerank 客户端会话")
+            try:
+                await self.client.close()
+            except Exception as e:
+                logger.error(f"关闭 百炼 Rerank 客户端时出错: {e}")
+            finally:
+                self.client = None

astrbot/core/provider/sources/dashscope_tts.py

@@ -1,14 +1,31 @@
-import dashscope
-import uuid
 import asyncio
-from dashscope.audio.tts_v2 import *
-from ..provider import TTSProvider
+import base64
+import logging
+import os
+import uuid
+
+import aiohttp
+import dashscope
+from dashscope.audio.tts_v2 import AudioFormat, SpeechSynthesizer
+
+try:
+    from dashscope.aigc.multimodal_conversation import MultiModalConversation
+except (
+    ImportError
+):  # pragma: no cover - older dashscope versions without Qwen TTS support
+    MultiModalConversation = None
+
+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(
-    "dashscope_tts", "Dashscope TTS API", provider_type=ProviderType.TEXT_TO_SPEECH
+    "dashscope_tts",
+    "Dashscope TTS API",
+    provider_type=ProviderType.TEXT_TO_SPEECH,
 )
 class ProviderDashscopeTTSAPI(TTSProvider):
     def __init__(
@@ -19,20 +36,127 @@ class ProviderDashscopeTTSAPI(TTSProvider):
         super().__init__(provider_config, provider_settings)
         self.chosen_api_key: str = provider_config.get("api_key", "")
         self.voice: str = provider_config.get("dashscope_tts_voice", "loongstella")
-        self.set_model(provider_config.get("model", None))
+        self.set_model(provider_config.get("model"))
         self.timeout_ms = float(provider_config.get("timeout", 20)) * 1000
         dashscope.api_key = self.chosen_api_key
 
     async def get_audio(self, text: str) -> str:
-        path = f"data/temp/dashscope_tts_{uuid.uuid4()}.wav"
-        self.synthesizer = SpeechSynthesizer(
-            model=self.get_model(),
+        model = self.get_model()
+        if not model:
+            raise RuntimeError("Dashscope TTS model is not configured.")
+
+        temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+        os.makedirs(temp_dir, exist_ok=True)
+
+        if self._is_qwen_tts_model(model):
+            audio_bytes, ext = await self._synthesize_with_qwen_tts(model, text)
+        else:
+            audio_bytes, ext = await self._synthesize_with_cosyvoice(model, text)
+
+        if not audio_bytes:
+            raise RuntimeError(
+                "Audio synthesis failed, returned empty content. The model may not be supported or the service is unavailable.",
+            )
+
+        path = os.path.join(temp_dir, f"dashscope_tts_{uuid.uuid4()}{ext}")
+        with open(path, "wb") as f:
+            f.write(audio_bytes)
+        return path
+
+    def _call_qwen_tts(self, model: str, text: str):
+        if MultiModalConversation is None:
+            raise RuntimeError(
+                "dashscope SDK missing MultiModalConversation. Please upgrade the dashscope package to use Qwen TTS models.",
+            )
+
+        kwargs = {
+            "model": model,
+            "text": text,
+            "api_key": self.chosen_api_key,
+            "voice": self.voice or "Cherry",
+        }
+        if not self.voice:
+            logging.warning(
+                "No voice specified for Qwen TTS model, using default 'Cherry'.",
+            )
+        return MultiModalConversation.call(**kwargs)
+
+    async def _synthesize_with_qwen_tts(
+        self,
+        model: str,
+        text: str,
+    ) -> tuple[bytes | None, str]:
+        loop = asyncio.get_event_loop()
+        response = await loop.run_in_executor(None, self._call_qwen_tts, model, text)
+        audio_bytes = await self._extract_audio_from_response(response)
+        if not audio_bytes:
+            raise RuntimeError(
+                f"Audio synthesis failed for model '{model}'. {response}",
+            )
+        ext = ".wav"
+        return audio_bytes, ext
+
+    async def _extract_audio_from_response(self, response) -> bytes | None:
+        output = getattr(response, "output", None)
+        audio_obj = getattr(output, "audio", None) if output is not None else None
+        if not audio_obj:
+            return None
+
+        data_b64 = getattr(audio_obj, "data", None)
+        if data_b64:
+            try:
+                return base64.b64decode(data_b64)
+            except (ValueError, TypeError):
+                logging.exception("Failed to decode base64 audio data.")
+                return None
+
+        url = getattr(audio_obj, "url", None)
+        if url:
+            return await self._download_audio_from_url(url)
+        return None
+
+    async def _download_audio_from_url(self, url: str) -> bytes | None:
+        if not url:
+            return None
+        timeout = max(self.timeout_ms / 1000, 1) if self.timeout_ms else 20
+        try:
+            async with (
+                aiohttp.ClientSession() as session,
+                session.get(
+                    url,
+                    timeout=aiohttp.ClientTimeout(total=timeout),
+                ) as response,
+            ):
+                return await response.read()
+        except (aiohttp.ClientError, asyncio.TimeoutError, OSError) as e:
+            logging.exception(f"Failed to download audio from URL {url}: {e}")
+            return None
+
+    async def _synthesize_with_cosyvoice(
+        self,
+        model: str,
+        text: str,
+    ) -> tuple[bytes | None, str]:
+        synthesizer = SpeechSynthesizer(
+            model=model,
             voice=self.voice,
             format=AudioFormat.WAV_24000HZ_MONO_16BIT,
         )
-        audio = await asyncio.get_event_loop().run_in_executor(
-            None, self.synthesizer.call, text, self.timeout_ms
+        loop = asyncio.get_event_loop()
+        audio_bytes = await loop.run_in_executor(
+            None,
+            synthesizer.call,
+            text,
+            self.timeout_ms,
         )
-        with open(path, "wb") as f:
-            f.write(audio)
-        return path
+        if not audio_bytes:
+            resp = synthesizer.get_response()
+            if resp and isinstance(resp, dict):
+                raise RuntimeError(
+                    f"Audio synthesis failed for model '{model}'. {resp}".strip(),
+                )
+        return audio_bytes, ".wav"
+
+    def _is_qwen_tts_model(self, model: str) -> bool:
+        model_lower = model.lower()
+        return "tts" in model_lower and model_lower.startswith("qwen")