字段，将bbb映射为匿名占位符。
@@ -889,7 +933,7 @@ async def build_anonymous_messages(messages: List[DatabaseMessages]) -> str:
current_char += 1
return person_map[person_id]
- for msg in messages:
+ for i, msg in enumerate(messages):
try:
platform = msg.chat_info.platform
user_id = msg.user_info.user_id
@@ -910,7 +954,12 @@ async def build_anonymous_messages(messages: List[DatabaseMessages]) -> str:
content = replace_user_references(content, platform, anon_name_resolver, replace_bot_name=False)
- header = f"{anon_name}说 "
+ # 构建消息头，如果启用show_ids则添加序号
+ if show_ids:
+ header = f"[{i + 1}] {anon_name}说 "
+ else:
+ header = f"{anon_name}说 "
+
output_lines.append(header)
stripped_line = content.strip()
if stripped_line:
diff --git a/src/chat/utils/memory_forget_task.py b/src/chat/utils/memory_forget_task.py
index 15a912b4..cd9144a1 100644
--- a/src/chat/utils/memory_forget_task.py
+++ b/src/chat/utils/memory_forget_task.py
@@ -25,7 +25,7 @@ class MemoryForgetTask(AsyncTask):
"""执行遗忘检查"""
try:
current_time = time.time()
- logger.info("[记忆遗忘] 开始遗忘检查...")
+ # logger.info("[记忆遗忘] 开始遗忘检查...")
# 执行4个阶段的遗忘检查
await self._forget_stage_1(current_time)
@@ -33,7 +33,7 @@ class MemoryForgetTask(AsyncTask):
await self._forget_stage_3(current_time)
await self._forget_stage_4(current_time)
- logger.info("[记忆遗忘] 遗忘检查完成")
+ # logger.info("[记忆遗忘] 遗忘检查完成")
except Exception as e:
logger.error(f"[记忆遗忘] 执行遗忘检查时出错: {e}", exc_info=True)
diff --git a/src/chat/utils/statistic.py b/src/chat/utils/statistic.py
index 9b5497e9..fa865d48 100644
--- a/src/chat/utils/statistic.py
+++ b/src/chat/utils/statistic.py
@@ -227,6 +227,8 @@ class StatisticOutputTask(AsyncTask):
"",
self._format_model_classified_stat(stats["last_hour"]),
"",
+ self._format_module_classified_stat(stats["last_hour"]),
+ "",
self._format_chat_stat(stats["last_hour"]),
self.SEP_LINE,
"",
@@ -737,11 +739,13 @@ class StatisticOutputTask(AsyncTask):
"""
if stats[TOTAL_REQ_CNT] <= 0:
return ""
- data_fmt = "{:<32} {:>10} {:>12} {:>12} {:>12} {:>9.2f}¥ {:>10.1f} {:>10.1f}"
+ data_fmt = "{:<32} {:>10} {:>12} {:>12} {:>12} {:>9.2f}¥ {:>10.1f} {:>10.1f} {:>12} {:>12}"
+ total_replies = stats.get(TOTAL_REPLY_CNT, 0)
+
output = [
"按模型分类统计:",
- " 模型名称 调用次数 输入Token 输出Token Token总量 累计花费 平均耗时(秒) 标准差(秒)",
+ " 模型名称 调用次数 输入Token 输出Token Token总量 累计花费 平均耗时(秒) 标准差(秒) 每次回复平均调用次数 每次回复平均Token数",
]
for model_name, count in sorted(stats[REQ_CNT_BY_MODEL].items()):
name = f"{model_name[:29]}..." if len(model_name) > 32 else model_name
@@ -751,11 +755,19 @@ class StatisticOutputTask(AsyncTask):
cost = stats[COST_BY_MODEL][model_name]
avg_time_cost = stats[AVG_TIME_COST_BY_MODEL][model_name]
std_time_cost = stats[STD_TIME_COST_BY_MODEL][model_name]
+
+ # 计算每次回复平均值
+ avg_count_per_reply = count / total_replies if total_replies > 0 else 0.0
+ avg_tokens_per_reply = tokens / total_replies if total_replies > 0 else 0.0
+
# 格式化大数字
formatted_count = _format_large_number(count)
formatted_in_tokens = _format_large_number(in_tokens)
formatted_out_tokens = _format_large_number(out_tokens)
formatted_tokens = _format_large_number(tokens)
+ formatted_avg_count = _format_large_number(avg_count_per_reply) if total_replies > 0 else "N/A"
+ formatted_avg_tokens = _format_large_number(avg_tokens_per_reply) if total_replies > 0 else "N/A"
+
output.append(
data_fmt.format(
name,
@@ -766,6 +778,62 @@ class StatisticOutputTask(AsyncTask):
cost,
avg_time_cost,
std_time_cost,
+ formatted_avg_count,
+ formatted_avg_tokens,
+ )
+ )
+
+ output.append("")
+ return "\n".join(output)
+
+ @staticmethod
+ def _format_module_classified_stat(stats: Dict[str, Any]) -> str:
+ """
+ 格式化按模块分类的统计数据
+ """
+ if stats[TOTAL_REQ_CNT] <= 0:
+ return ""
+ data_fmt = "{:<32} {:>10} {:>12} {:>12} {:>12} {:>9.2f}¥ {:>10.1f} {:>10.1f} {:>12} {:>12}"
+
+ total_replies = stats.get(TOTAL_REPLY_CNT, 0)
+
+ output = [
+ "按模块分类统计:",
+ " 模块名称 调用次数 输入Token 输出Token Token总量 累计花费 平均耗时(秒) 标准差(秒) 每次回复平均调用次数 每次回复平均Token数",
+ ]
+ for module_name, count in sorted(stats[REQ_CNT_BY_MODULE].items()):
+ name = f"{module_name[:29]}..." if len(module_name) > 32 else module_name
+ in_tokens = stats[IN_TOK_BY_MODULE][module_name]
+ out_tokens = stats[OUT_TOK_BY_MODULE][module_name]
+ tokens = stats[TOTAL_TOK_BY_MODULE][module_name]
+ cost = stats[COST_BY_MODULE][module_name]
+ avg_time_cost = stats[AVG_TIME_COST_BY_MODULE][module_name]
+ std_time_cost = stats[STD_TIME_COST_BY_MODULE][module_name]
+
+ # 计算每次回复平均值
+ avg_count_per_reply = count / total_replies if total_replies > 0 else 0.0
+ avg_tokens_per_reply = tokens / total_replies if total_replies > 0 else 0.0
+
+ # 格式化大数字
+ formatted_count = _format_large_number(count)
+ formatted_in_tokens = _format_large_number(in_tokens)
+ formatted_out_tokens = _format_large_number(out_tokens)
+ formatted_tokens = _format_large_number(tokens)
+ formatted_avg_count = _format_large_number(avg_count_per_reply) if total_replies > 0 else "N/A"
+ formatted_avg_tokens = _format_large_number(avg_tokens_per_reply) if total_replies > 0 else "N/A"
+
+ output.append(
+ data_fmt.format(
+ name,
+ formatted_count,
+ formatted_in_tokens,
+ formatted_out_tokens,
+ formatted_tokens,
+ cost,
+ avg_time_cost,
+ std_time_cost,
+ formatted_avg_count,
+ formatted_avg_tokens,
)
)
@@ -849,6 +917,7 @@ class StatisticOutputTask(AsyncTask):
# format总在线时间
# 按模型分类统计
+ total_replies = stat_data.get(TOTAL_REPLY_CNT, 0)
model_rows = "\n".join(
[
f""
@@ -860,11 +929,13 @@ class StatisticOutputTask(AsyncTask):
f"| {stat_data[COST_BY_MODEL][model_name]:.2f} ¥ | "
f"{stat_data[AVG_TIME_COST_BY_MODEL][model_name]:.1f} 秒 | "
f"{stat_data[STD_TIME_COST_BY_MODEL][model_name]:.1f} 秒 | "
+ f"{_format_large_number(count / total_replies, html=True) if total_replies > 0 else 'N/A'} | "
+ f"{_format_large_number(stat_data[TOTAL_TOK_BY_MODEL][model_name] / total_replies, html=True) if total_replies > 0 else 'N/A'} | "
f"
"
for model_name, count in sorted(stat_data[REQ_CNT_BY_MODEL].items())
]
if stat_data[REQ_CNT_BY_MODEL]
- else ["| 暂无数据 |
"]
+ else ["| 暂无数据 |
"]
)
# 按请求类型分类统计
type_rows = "\n".join(
@@ -878,11 +949,13 @@ class StatisticOutputTask(AsyncTask):
f"{stat_data[COST_BY_TYPE][req_type]:.2f} ¥ | "
f"{stat_data[AVG_TIME_COST_BY_TYPE][req_type]:.1f} 秒 | "
f"{stat_data[STD_TIME_COST_BY_TYPE][req_type]:.1f} 秒 | "
+ f"{_format_large_number(count / total_replies, html=True) if total_replies > 0 else 'N/A'} | "
+ f"{_format_large_number(stat_data[TOTAL_TOK_BY_TYPE][req_type] / total_replies, html=True) if total_replies > 0 else 'N/A'} | "
f""
for req_type, count in sorted(stat_data[REQ_CNT_BY_TYPE].items())
]
if stat_data[REQ_CNT_BY_TYPE]
- else ["| 暂无数据 |
"]
+ else ["| 暂无数据 |
"]
)
# 按模块分类统计
module_rows = "\n".join(
@@ -896,11 +969,13 @@ class StatisticOutputTask(AsyncTask):
f"{stat_data[COST_BY_MODULE][module_name]:.2f} ¥ | "
f"{stat_data[AVG_TIME_COST_BY_MODULE][module_name]:.1f} 秒 | "
f"{stat_data[STD_TIME_COST_BY_MODULE][module_name]:.1f} 秒 | "
+ f"{_format_large_number(count / total_replies, html=True) if total_replies > 0 else 'N/A'} | "
+ f"{_format_large_number(stat_data[TOTAL_TOK_BY_MODULE][module_name] / total_replies, html=True) if total_replies > 0 else 'N/A'} | "
f""
for module_name, count in sorted(stat_data[REQ_CNT_BY_MODULE].items())
]
if stat_data[REQ_CNT_BY_MODULE]
- else ["| 暂无数据 |
"]
+ else ["| 暂无数据 |
"]
)
# 聊天消息统计
@@ -975,7 +1050,7 @@ class StatisticOutputTask(AsyncTask):
按模型分类统计
- | 模型名称 | 调用次数 | 输入Token | 输出Token | Token总量 | 累计花费 | 平均耗时(秒) | 标准差(秒) |
|---|
+ | 模型名称 | 调用次数 | 输入Token | 输出Token | Token总量 | 累计花费 | 平均耗时(秒) | 标准差(秒) | 每次回复平均调用次数 | 每次回复平均Token数 |
|---|
{model_rows}
@@ -986,7 +1061,7 @@ class StatisticOutputTask(AsyncTask):
- | 模块名称 | 调用次数 | 输入Token | 输出Token | Token总量 | 累计花费 | 平均耗时(秒) | 标准差(秒) |
|---|
+ | 模块名称 | 调用次数 | 输入Token | 输出Token | Token总量 | 累计花费 | 平均耗时(秒) | 标准差(秒) | 每次回复平均调用次数 | 每次回复平均Token数 |
|---|
{module_rows}
@@ -998,7 +1073,7 @@ class StatisticOutputTask(AsyncTask):
- | 请求类型 | 调用次数 | 输入Token | 输出Token | Token总量 | 累计花费 | 平均耗时(秒) | 标准差(秒) |
|---|
+ | 请求类型 | 调用次数 | 输入Token | 输出Token | Token总量 | 累计花费 | 平均耗时(秒) | 标准差(秒) | 每次回复平均调用次数 | 每次回复平均Token数 |
|---|
{type_rows}
diff --git a/src/chat/utils/utils_image.py b/src/chat/utils/utils_image.py
index f6012f09..56a3ae0f 100644
--- a/src/chat/utils/utils_image.py
+++ b/src/chat/utils/utils_image.py
@@ -12,7 +12,7 @@ from rich.traceback import install
from src.common.logger import get_logger
from src.common.database.database import db
-from src.common.database.database_model import Images, ImageDescriptions
+from src.common.database.database_model import Images, ImageDescriptions, EmojiDescriptionCache
from src.config.config import global_config, model_config
from src.llm_models.utils_model import LLMRequest
@@ -40,7 +40,7 @@ class ImageManager:
try:
db.connect(reuse_if_open=True)
- db.create_tables([Images, ImageDescriptions], safe=True)
+ db.create_tables([Images, ImageDescriptions, EmojiDescriptionCache], safe=True)
except Exception as e:
logger.error(f"数据库连接或表创建失败: {e}")
@@ -49,6 +49,11 @@ class ImageManager:
except Exception as e:
logger.warning(f"数据库清理失败: {e}")
+ try:
+ self._cleanup_emoji_from_image_descriptions()
+ except Exception as e:
+ logger.warning(f"清理ImageDescriptions中的emoji记录失败: {e}")
+
self._initialized = True
def _ensure_image_dir(self):
@@ -119,6 +124,31 @@ class ImageManager:
else:
logger.info("[清理完成] 未发现无效描述记录")
+ @staticmethod
+ def _cleanup_emoji_from_image_descriptions():
+ """清理Images和ImageDescriptions表中type为emoji的记录（已迁移到EmojiDescriptionCache）"""
+ try:
+ # 清理Images表中type为emoji的记录
+ deleted_images = Images.delete().where(Images.type == "emoji").execute()
+
+ # 清理ImageDescriptions表中type为emoji的记录
+ deleted_descriptions = (
+ ImageDescriptions.delete().where(ImageDescriptions.type == "emoji").execute()
+ )
+
+ total_deleted = deleted_images + deleted_descriptions
+ if total_deleted > 0:
+ logger.info(
+ f"[清理完成] 从Images表中删除 {deleted_images} 条emoji类型记录, "
+ f"从ImageDescriptions表中删除 {deleted_descriptions} 条emoji类型记录, "
+ f"共删除 {total_deleted} 条记录"
+ )
+ else:
+ logger.info("[清理完成] Images和ImageDescriptions表中未发现emoji类型记录")
+ except Exception as e:
+ logger.error(f"清理Images和ImageDescriptions中的emoji记录时出错: {str(e)}")
+ raise
+
async def get_emoji_tag(self, image_base64: str) -> str:
from src.chat.emoji_system.emoji_manager import get_emoji_manager
@@ -134,8 +164,49 @@ class ImageManager:
tag_str = ",".join(emotion_list)
return f"[表情包：{tag_str}]"
+ async def _save_emoji_file_if_needed(self, image_base64: str, image_hash: str, image_format: str) -> None:
+ """如果启用了steal_emoji且表情包未注册，保存文件到data/emoji目录
+
+ Args:
+ image_base64: 图片的base64编码
+ image_hash: 图片的MD5哈希值
+ image_format: 图片格式
+ """
+ if not global_config.emoji.steal_emoji:
+ return
+
+ try:
+ from src.chat.emoji_system.emoji_manager import EMOJI_DIR
+ from src.chat.emoji_system.emoji_manager import get_emoji_manager
+
+ # 确保目录存在
+ os.makedirs(EMOJI_DIR, exist_ok=True)
+
+ # 检查是否已存在该表情包（通过哈希值）
+ emoji_manager = get_emoji_manager()
+ existing_emoji = await emoji_manager.get_emoji_from_manager(image_hash)
+ if existing_emoji:
+ logger.debug(f"[自动保存] 表情包已注册，跳过保存: {image_hash[:8]}...")
+ return
+
+ # 生成文件名：使用哈希值前8位 + 格式
+ filename = f"{image_hash[:8]}.{image_format}"
+ file_path = os.path.join(EMOJI_DIR, filename)
+
+ # 检查文件是否已存在（可能之前保存过但未注册）
+ if not os.path.exists(file_path):
+ # 保存文件
+ if base64_to_image(image_base64, file_path):
+ logger.info(f"[自动保存] 表情包已保存到 {file_path} (Hash: {image_hash[:8]}...)")
+ else:
+ logger.warning(f"[自动保存] 保存表情包文件失败: {file_path}")
+ else:
+ logger.debug(f"[自动保存] 表情包文件已存在，跳过: {file_path}")
+ except Exception as save_error:
+ logger.warning(f"[自动保存] 保存表情包文件时出错: {save_error}")
+
async def get_emoji_description(self, image_base64: str) -> str:
- """获取表情包描述，优先使用Emoji表中的缓存数据"""
+ """获取表情包描述，优先使用EmojiDescriptionCache表中的缓存数据"""
try:
# 计算图片哈希
# 确保base64字符串只包含ASCII字符
@@ -158,10 +229,25 @@ class ImageManager:
except Exception as e:
logger.debug(f"查询EmojiManager时出错: {e}")
- # 查询ImageDescriptions表的缓存描述
- if cached_description := self._get_description_from_db(image_hash, "emoji"):
- logger.info(f"[缓存命中] 使用ImageDescriptions表中的描述: {cached_description[:50]}...")
- return f"[表情包：{cached_description}]"
+ # 查询EmojiDescriptionCache表的缓存（包含描述和情感标签）
+ try:
+ cache_record = EmojiDescriptionCache.get_or_none(EmojiDescriptionCache.emoji_hash == image_hash)
+ if cache_record:
+ # 优先使用情感标签，如果没有则使用详细描述
+ result_text = ""
+ if cache_record.emotion_tags:
+ logger.info(f"[缓存命中] 使用EmojiDescriptionCache表中的情感标签: {cache_record.emotion_tags[:50]}...")
+ result_text = f"[表情包：{cache_record.emotion_tags}]"
+ elif cache_record.description:
+ logger.info(f"[缓存命中] 使用EmojiDescriptionCache表中的描述: {cache_record.description[:50]}...")
+ result_text = f"[表情包：{cache_record.description}]"
+
+ # 即使缓存命中，如果启用了steal_emoji，也检查是否需要保存文件
+ if result_text:
+ await self._save_emoji_file_if_needed(image_base64, image_hash, image_format)
+ return result_text
+ except Exception as e:
+ logger.debug(f"查询EmojiDescriptionCache时出错: {e}")
# === 二步走识别流程 ===
@@ -221,45 +307,38 @@ class ImageManager:
logger.debug(f"[emoji识别] 详细描述: {detailed_description[:50]}... -> 情感标签: {final_emotion}")
- if cached_description := self._get_description_from_db(image_hash, "emoji"):
- logger.warning(f"虽然生成了描述，但是找到缓存表情包描述: {cached_description}")
- return f"[表情包：{cached_description}]"
-
- # 保存表情包文件和元数据（用于可能的后续分析）
- logger.debug(f"保存表情包: {image_hash}")
- current_timestamp = time.time()
- filename = f"{int(current_timestamp)}_{image_hash[:8]}.{image_format}"
- emoji_dir = os.path.join(self.IMAGE_DIR, "emoji")
- os.makedirs(emoji_dir, exist_ok=True)
- file_path = os.path.join(emoji_dir, filename)
-
+ # 再次检查缓存（防止并发情况下其他线程已经保存）
try:
- # 保存文件
- with open(file_path, "wb") as f:
- f.write(image_bytes)
-
- # 保存到数据库 (Images表) - 包含详细描述用于可能的注册流程
- try:
- img_obj = Images.get((Images.emoji_hash == image_hash) & (Images.type == "emoji"))
- img_obj.path = file_path
- img_obj.description = detailed_description # 保存详细描述
- img_obj.timestamp = current_timestamp
- img_obj.save()
- except Images.DoesNotExist: # type: ignore
- Images.create(
- image_id=str(uuid.uuid4()),
- emoji_hash=image_hash,
- path=file_path,
- type="emoji",
- description=detailed_description, # 保存详细描述
- timestamp=current_timestamp,
- vlm_processed=True,
- )
+ cache_record = EmojiDescriptionCache.get_or_none(EmojiDescriptionCache.emoji_hash == image_hash)
+ if cache_record and cache_record.emotion_tags:
+ logger.warning(f"虽然生成了描述，但是找到缓存表情包情感标签: {cache_record.emotion_tags}")
+ return f"[表情包：{cache_record.emotion_tags}]"
except Exception as e:
- logger.error(f"保存表情包文件或元数据失败: {str(e)}")
+ logger.debug(f"再次查询EmojiDescriptionCache时出错: {e}")
- # 保存最终的情感标签到缓存 (ImageDescriptions表)
- self._save_description_to_db(image_hash, final_emotion, "emoji")
+ # 保存识别出的详细描述和情感标签到 emoji_description_cache
+ try:
+ current_timestamp = time.time()
+ cache_record, created = EmojiDescriptionCache.get_or_create(
+ emoji_hash=image_hash,
+ defaults={
+ "description": detailed_description,
+ "emotion_tags": final_emotion,
+ "timestamp": current_timestamp,
+ },
+ )
+ if not created:
+ # 更新已有记录
+ cache_record.description = detailed_description
+ cache_record.emotion_tags = final_emotion
+ cache_record.timestamp = current_timestamp
+ cache_record.save()
+ logger.info(f"[缓存保存] 表情包描述和情感标签已保存到EmojiDescriptionCache: {image_hash[:8]}...")
+ except Exception as e:
+ logger.error(f"保存表情包描述和情感标签缓存失败: {str(e)}")
+
+ # 如果启用了steal_emoji，自动保存表情包文件到data/emoji目录
+ await self._save_emoji_file_if_needed(image_base64, image_hash, image_format)
return f"[表情包：{final_emotion}]"
diff --git a/src/common/data_models/database_data_model.py b/src/common/data_models/database_data_model.py
index b981bd33..9707add8 100644
--- a/src/common/data_models/database_data_model.py
+++ b/src/common/data_models/database_data_model.py
@@ -77,6 +77,7 @@ class DatabaseMessages(BaseDataModel):
is_emoji: bool = False,
is_picid: bool = False,
is_command: bool = False,
+ is_no_read_command: bool = False,
is_notify: bool = False,
selected_expressions: Optional[str] = None,
user_id: str = "",
@@ -119,6 +120,7 @@ class DatabaseMessages(BaseDataModel):
self.is_emoji = is_emoji
self.is_picid = is_picid
self.is_command = is_command
+ self.is_no_read_command = is_no_read_command
self.is_notify = is_notify
self.selected_expressions = selected_expressions
@@ -186,6 +188,7 @@ class DatabaseMessages(BaseDataModel):
"is_emoji": self.is_emoji,
"is_picid": self.is_picid,
"is_command": self.is_command,
+ "is_no_read_command": self.is_no_read_command,
"is_notify": self.is_notify,
"selected_expressions": self.selected_expressions,
"user_id": self.user_info.user_id,
diff --git a/src/common/data_models/message_data_model.py b/src/common/data_models/message_data_model.py
index a3d5751f..3c4c5505 100644
--- a/src/common/data_models/message_data_model.py
+++ b/src/common/data_models/message_data_model.py
@@ -21,6 +21,8 @@ class MessageAndActionModel(BaseDataModel):
chat_info_platform: str = field(default_factory=str)
is_action_record: bool = field(default=False)
action_name: Optional[str] = None
+ is_command: bool = field(default=False)
+ is_no_read_command: bool = field(default=False)
@classmethod
def from_DatabaseMessages(cls, message: "DatabaseMessages"):
@@ -34,6 +36,8 @@ class MessageAndActionModel(BaseDataModel):
processed_plain_text=message.processed_plain_text,
display_message=message.display_message,
chat_info_platform=message.chat_info.platform,
+ is_command=message.is_command,
+ is_no_read_command=getattr(message, "is_no_read_command", False),
)
diff --git a/src/common/database/database_model.py b/src/common/database/database_model.py
index c97c0b72..9b1f18df 100644
--- a/src/common/database/database_model.py
+++ b/src/common/database/database_model.py
@@ -170,6 +170,7 @@ class Messages(BaseModel):
is_emoji = BooleanField(default=False)
is_picid = BooleanField(default=False)
is_command = BooleanField(default=False)
+ is_no_read_command = BooleanField(default=False)
is_notify = BooleanField(default=False)
selected_expressions = TextField(null=True)
@@ -239,6 +240,20 @@ class ImageDescriptions(BaseModel):
table_name = "image_descriptions"
+class EmojiDescriptionCache(BaseModel):
+ """
+ 存储表情包的详细描述和情感标签缓存
+ """
+
+ emoji_hash = TextField(unique=True, index=True)
+ description = TextField() # 详细描述
+ emotion_tags = TextField(null=True) # 情感标签，逗号分隔
+ timestamp = FloatField()
+
+ class Meta:
+ table_name = "emoji_description_cache"
+
+
class OnlineTime(BaseModel):
"""
用于存储在线时长记录的模型。
@@ -316,6 +331,8 @@ class Expression(BaseModel):
last_active_time = FloatField()
chat_id = TextField(index=True)
create_date = FloatField(null=True) # 创建日期，允许为空以兼容老数据
+ checked = BooleanField(default=False) # 是否已检查
+ rejected = BooleanField(default=False) # 是否被拒绝但未更新
class Meta:
table_name = "expression"
@@ -328,8 +345,6 @@ class Jargon(BaseModel):
content = TextField()
raw_content = TextField(null=True)
- type = TextField(null=True)
- translation = TextField(null=True)
meaning = TextField(null=True)
chat_id = TextField(index=True)
is_global = BooleanField(default=False)
@@ -357,6 +372,7 @@ class ChatHistory(BaseModel):
theme = TextField() # 主题：这段对话的主要内容，一个简短的标题
keywords = TextField() # 关键词：这段对话的关键词，JSON格式存储
summary = TextField() # 概括：对这段话的平文本概括
+ key_point = TextField(null=True) # 关键信息：话题中的关键信息点，JSON格式存储
count = IntegerField(default=0) # 被检索次数
forget_times = IntegerField(default=0) # 被遗忘检查的次数
@@ -389,6 +405,7 @@ MODELS = [
Messages,
Images,
ImageDescriptions,
+ EmojiDescriptionCache,
OnlineTime,
PersonInfo,
Expression,
diff --git a/src/common/message_repository.py b/src/common/message_repository.py
index fb9120ac..4b9c6b35 100644
--- a/src/common/message_repository.py
+++ b/src/common/message_repository.py
@@ -25,6 +25,7 @@ def find_messages(
limit_mode: str = "latest",
filter_bot=False,
filter_command=False,
+ filter_no_read_command=False,
) -> List[DatabaseMessages]:
"""
根据提供的过滤器、排序和限制条件查找消息。
@@ -84,6 +85,9 @@ def find_messages(
# 使用按位取反构造 Peewee 的 NOT 条件，避免直接与 False 比较
query = query.where(~Messages.is_command)
+ if filter_no_read_command:
+ query = query.where(~Messages.is_no_read_command)
+
if limit > 0:
if limit_mode == "earliest":
# 获取时间最早的 limit 条记录，已经是正序
diff --git a/src/common/toml_utils.py b/src/common/toml_utils.py
new file mode 100644
index 00000000..0c34f6ab
--- /dev/null
+++ b/src/common/toml_utils.py
@@ -0,0 +1,67 @@
+"""
+TOML 工具函数
+
+提供 TOML 文件的格式化保存功能，确保数组等元素以美观的多行格式输出。
+"""
+
+from typing import Any
+import tomlkit
+from tomlkit.items import AoT, Table, Array
+
+
+def _format_toml_value(obj: Any, threshold: int, depth: int = 0) -> Any:
+ """递归格式化 TOML 值，将数组转换为多行格式"""
+ # 处理 AoT (Array of Tables) - 保持原样，递归处理内部
+ if isinstance(obj, AoT):
+ for item in obj:
+ _format_toml_value(item, threshold, depth)
+ return obj
+
+ # 处理字典类型 (dict 或 Table)
+ if isinstance(obj, (dict, Table)):
+ for k, v in obj.items():
+ obj[k] = _format_toml_value(v, threshold, depth)
+ return obj
+
+ # 处理列表类型 (list 或 Array)
+ if isinstance(obj, (list, Array)):
+ # 如果是纯 list (非 tomlkit Array) 且包含字典/表，视为 AoT 的列表形式
+ # 保持结构递归处理，避免转换为 Inline Table Array (因为 Inline Table 必须单行，复杂对象不友好)
+ if isinstance(obj, list) and not isinstance(obj, Array) and obj and isinstance(obj[0], (dict, Table)):
+ for i, item in enumerate(obj):
+ obj[i] = _format_toml_value(item, threshold, depth)
+ return obj
+
+ # 决定是否多行：仅在顶层且长度超过阈值时
+ should_multiline = (depth == 0 and len(obj) > threshold)
+
+ # 如果已经是 tomlkit Array，原地修改以保留注释
+ if isinstance(obj, Array):
+ obj.multiline(should_multiline)
+ for i, item in enumerate(obj):
+ obj[i] = _format_toml_value(item, threshold, depth + 1)
+ return obj
+
+ # 普通 list：转换为 tomlkit 数组
+ arr = tomlkit.array()
+ arr.multiline(should_multiline)
+
+ for item in obj:
+ arr.append(_format_toml_value(item, threshold, depth + 1))
+ return arr
+
+ # 其他基本类型直接返回
+ return obj
+
+
+def save_toml_with_format(data: Any, file_path: str, multiline_threshold: int = 1) -> None:
+ """格式化 TOML 数据并保存到文件"""
+ formatted = _format_toml_value(data, multiline_threshold) if multiline_threshold >= 0 else data
+ with open(file_path, "w", encoding="utf-8") as f:
+ tomlkit.dump(formatted, f)
+
+
+def format_toml_string(data: Any, multiline_threshold: int = 1) -> str:
+ """格式化 TOML 数据并返回字符串"""
+ formatted = _format_toml_value(data, multiline_threshold) if multiline_threshold >= 0 else data
+ return tomlkit.dumps(formatted)
\ No newline at end of file
diff --git a/src/config/api_ada_configs.py b/src/config/api_ada_configs.py
index 3fc9c878..897e1f87 100644
--- a/src/config/api_ada_configs.py
+++ b/src/config/api_ada_configs.py
@@ -88,6 +88,9 @@ class TaskConfig(ConfigBase):
temperature: float = 0.3
"""模型温度"""
+ slow_threshold: float = 15.0
+ """慢请求阈值（秒），超过此值会输出警告日志"""
+
@dataclass
class ModelTaskConfig(ConfigBase):
diff --git a/src/config/config.py b/src/config/config.py
index 01b9f6ca..9342cbb4 100644
--- a/src/config/config.py
+++ b/src/config/config.py
@@ -11,6 +11,7 @@ from rich.traceback import install
from typing import List, Optional
from src.common.logger import get_logger
+from src.common.toml_utils import format_toml_string
from src.config.config_base import ConfigBase
from src.config.official_configs import (
BotConfig,
@@ -56,7 +57,7 @@ TEMPLATE_DIR = os.path.join(PROJECT_ROOT, "template")
# 考虑到，实际上配置文件中的mai_version是不会自动更新的,所以采用硬编码
# 对该字段的更新，请严格参照语义化版本规范：https://semver.org/lang/zh-CN/
-MMC_VERSION = "0.11.5"
+MMC_VERSION = "0.11.6"
def get_key_comment(toml_table, key):
@@ -252,7 +253,7 @@ def _update_config_generic(config_name: str, template_name: str):
# 如果配置有更新，立即保存到文件
if config_updated:
with open(old_config_path, "w", encoding="utf-8") as f:
- f.write(tomlkit.dumps(old_config))
+ f.write(format_toml_string(old_config))
logger.info(f"已保存更新后的{config_name}配置文件")
else:
logger.info(f"未检测到{config_name}模板默认值变动")
@@ -313,9 +314,9 @@ def _update_config_generic(config_name: str, template_name: str):
logger.info(f"开始合并{config_name}新旧配置...")
_update_dict(new_config, old_config)
- # 保存更新后的配置（保留注释和格式）
+ # 保存更新后的配置（保留注释和格式，数组多行格式化）
with open(new_config_path, "w", encoding="utf-8") as f:
- f.write(tomlkit.dumps(new_config))
+ f.write(format_toml_string(new_config))
logger.info(f"{config_name}配置文件更新完成，建议检查新配置文件中的内容，以免丢失重要信息")
diff --git a/src/config/official_configs.py b/src/config/official_configs.py
index fc084ecb..5e88f8cd 100644
--- a/src/config/official_configs.py
+++ b/src/config/official_configs.py
@@ -244,6 +244,9 @@ class MemoryConfig(ConfigBase):
max_agent_iterations: int = 5
"""Agent最多迭代轮数（最低为1）"""
+ enable_jargon_detection: bool = True
+ """记忆检索过程中是否启用黑话识别"""
+
def __post_init__(self):
"""验证配置值"""
if self.max_agent_iterations < 1:
@@ -279,6 +282,20 @@ class ExpressionConfig(ConfigBase):
格式: [["qq:12345:group", "qq:67890:private"]]
"""
+ reflect: bool = False
+ """是否启用表达反思"""
+
+ reflect_operator_id: str = ""
+ """表达反思操作员ID"""
+
+ allow_reflect: list[str] = field(default_factory=list)
+ """
+ 允许进行表达反思的聊天流ID列表
+ 格式: ["qq:123456:private", "qq:654321:group", ...]
+ 只有在此列表中的聊天流才会提出问题并跟踪
+ 如果列表为空，则所有聊天流都可以进行表达反思（前提是 reflect = true）
+ """
+
def _parse_stream_config_to_chat_id(self, stream_config_str: str) -> Optional[str]:
"""
解析流配置字符串并生成对应的 chat_id
diff --git a/src/express/express_utils.py b/src/express/express_utils.py
index 20095561..b0702e30 100644
--- a/src/express/express_utils.py
+++ b/src/express/express_utils.py
@@ -63,13 +63,15 @@ def format_create_date(timestamp: float) -> str:
def _compute_weights(population: List[Dict]) -> List[float]:
"""
- 根据表达的count计算权重，范围限定在1~3之间。
- count越高，权重越高，但最多为基础权重的3倍。
+ 根据表达的count计算权重，范围限定在1~5之间。
+ count越高，权重越高，但最多为基础权重的5倍。
+ 如果表达已checked，权重会再乘以3倍。
"""
if not population:
return []
counts = []
+ checked_flags = []
for item in population:
count = item.get("count", 1)
try:
@@ -77,18 +79,29 @@ def _compute_weights(population: List[Dict]) -> List[float]:
except (TypeError, ValueError):
count_value = 1.0
counts.append(max(count_value, 0.0))
+ # 获取checked状态
+ checked = item.get("checked", False)
+ checked_flags.append(bool(checked))
min_count = min(counts)
max_count = max(counts)
if max_count == min_count:
- return [1.0 for _ in counts]
+ base_weights = [1.0 for _ in counts]
+ else:
+ base_weights = []
+ for count_value in counts:
+ # 线性映射到[1,5]区间
+ normalized = (count_value - min_count) / (max_count - min_count)
+ base_weights.append(1.0 + normalized * 4.0) # 1~3
+ # 如果checked，权重乘以3
weights = []
- for count_value in counts:
- # 线性映射到[1,3]区间
- normalized = (count_value - min_count) / (max_count - min_count)
- weights.append(1.0 + normalized * 2.0) # 1~3
+ for base_weight, checked in zip(base_weights, checked_flags, strict=False):
+ if checked:
+ weights.append(base_weight * 3.0)
+ else:
+ weights.append(base_weight)
return weights
diff --git a/src/express/expression_learner.py b/src/express/expression_learner.py
index 57c03e77..af69cad6 100644
--- a/src/express/expression_learner.py
+++ b/src/express/expression_learner.py
@@ -1,6 +1,8 @@
import time
import json
import os
+import re
+import asyncio
from typing import List, Optional, Tuple
import traceback
from src.common.logger import get_logger
@@ -90,6 +92,9 @@ class ExpressionLearner:
# 维护每个chat的上次学习时间
self.last_learning_time: float = time.time()
+ # 学习锁，防止并发执行学习任务
+ self._learning_lock = asyncio.Lock()
+
# 学习参数
_, self.enable_learning, self.learning_intensity = global_config.expression.get_expression_config_for_chat(
self.chat_id
@@ -138,32 +143,45 @@ class ExpressionLearner:
Returns:
bool: 是否成功触发学习
"""
- if not self.should_trigger_learning():
- return
+ # 使用异步锁防止并发执行
+ async with self._learning_lock:
+ # 在锁内检查，避免并发触发
+ # 如果锁被持有，其他协程会等待，但等待期间条件可能已变化，所以需要再次检查
+ if not self.should_trigger_learning():
+ return
- try:
- logger.info(f"在聊天流 {self.chat_name} 学习表达方式")
- # 学习语言风格
- learnt_style = await self.learn_and_store(num=25)
+ # 保存学习开始前的时间戳，用于获取消息范围
+ learning_start_timestamp = time.time()
+ previous_learning_time = self.last_learning_time
+
+ # 立即更新学习时间，防止并发触发
+ self.last_learning_time = learning_start_timestamp
- # 更新学习时间
- self.last_learning_time = time.time()
+ try:
+ logger.info(f"在聊天流 {self.chat_name} 学习表达方式")
+ # 学习语言风格，传递学习开始前的时间戳
+ learnt_style = await self.learn_and_store(num=25, timestamp_start=previous_learning_time)
- if learnt_style:
- logger.info(f"聊天流 {self.chat_name} 表达学习完成")
- else:
- logger.warning(f"聊天流 {self.chat_name} 表达学习未获得有效结果")
+ if learnt_style:
+ logger.info(f"聊天流 {self.chat_name} 表达学习完成")
+ else:
+ logger.warning(f"聊天流 {self.chat_name} 表达学习未获得有效结果")
- except Exception as e:
- logger.error(f"为聊天流 {self.chat_name} 触发学习失败: {e}")
- traceback.print_exc()
- return
+ except Exception as e:
+ logger.error(f"为聊天流 {self.chat_name} 触发学习失败: {e}")
+ traceback.print_exc()
+ # 即使失败也保持时间戳更新，避免频繁重试
+ return
- async def learn_and_store(self, num: int = 10) -> List[Tuple[str, str, str]]:
+ async def learn_and_store(self, num: int = 10, timestamp_start: Optional[float] = None) -> List[Tuple[str, str, str]]:
"""
学习并存储表达方式
+
+ Args:
+ num: 学习数量
+ timestamp_start: 学习开始的时间戳，如果为None则使用self.last_learning_time
"""
- learnt_expressions = await self.learn_expression(num)
+ learnt_expressions = await self.learn_expression(num, timestamp_start=timestamp_start)
if learnt_expressions is None:
logger.info("没有学习到表达风格")
@@ -225,6 +243,19 @@ class ExpressionLearner:
match_responses = []
try:
response = response.strip()
+
+ # 尝试提取JSON代码块（如果存在）
+ json_pattern = r"```json\s*(.*?)\s*```"
+ matches = re.findall(json_pattern, response, re.DOTALL)
+ if matches:
+ response = matches[0].strip()
+
+ # 移除可能的markdown代码块标记（如果没有找到```json，但可能有```）
+ if not matches:
+ response = re.sub(r"^```\s*", "", response, flags=re.MULTILINE)
+ response = re.sub(r"```\s*$", "", response, flags=re.MULTILINE)
+ response = response.strip()
+
# 检查是否已经是标准JSON数组格式
if response.startswith("[") and response.endswith("]"):
match_responses = json.loads(response)
@@ -280,15 +311,60 @@ class ExpressionLearner:
logger.error(f"match_responses 不是列表或字典类型: {type(match_responses)}, 内容: {match_responses}")
return []
+ # 清理和规范化 match_responses 中的元素
+ normalized_responses = []
+ for item in match_responses:
+ if isinstance(item, dict):
+ # 已经是字典，直接添加
+ normalized_responses.append(item)
+ elif isinstance(item, str):
+ # 如果是字符串，尝试解析为 JSON
+ try:
+ parsed = json.loads(item)
+ if isinstance(parsed, dict):
+ normalized_responses.append(parsed)
+ elif isinstance(parsed, list):
+ # 如果是列表，递归处理
+ for sub_item in parsed:
+ if isinstance(sub_item, dict):
+ normalized_responses.append(sub_item)
+ else:
+ logger.debug(f"跳过非字典类型的子元素: {type(sub_item)}, 内容: {sub_item}")
+ else:
+ logger.debug(f"跳过无法转换为字典的字符串元素: {item}")
+ except (json.JSONDecodeError, TypeError):
+ logger.debug(f"跳过无法解析为JSON的字符串元素: {item}")
+ elif isinstance(item, list):
+ # 如果是列表，展开并处理其中的字典
+ for sub_item in item:
+ if isinstance(sub_item, dict):
+ normalized_responses.append(sub_item)
+ elif isinstance(sub_item, str):
+ # 尝试解析字符串
+ try:
+ parsed = json.loads(sub_item)
+ if isinstance(parsed, dict):
+ normalized_responses.append(parsed)
+ else:
+ logger.debug(f"跳过非字典类型的解析结果: {type(parsed)}, 内容: {parsed}")
+ except (json.JSONDecodeError, TypeError):
+ logger.debug(f"跳过无法解析为JSON的字符串子元素: {sub_item}")
+ else:
+ logger.debug(f"跳过非字典类型的列表元素: {type(sub_item)}, 内容: {sub_item}")
+ else:
+ logger.debug(f"跳过无法处理的元素类型: {type(item)}, 内容: {item}")
+
+ match_responses = normalized_responses
+
matched_expressions = []
used_pair_indices = set() # 用于跟踪已经使用的expression_pair索引
- logger.debug(f"match_responses 类型: {type(match_responses)}, 长度: {len(match_responses)}")
- logger.debug(f"match_responses 内容: {match_responses}")
+ logger.debug(f"规范化后的 match_responses 类型: {type(match_responses)}, 长度: {len(match_responses)}")
+ logger.debug(f"规范化后的 match_responses 内容: {match_responses}")
for match_response in match_responses:
try:
- # 检查 match_response 的类型
+ # 检查 match_response 的类型（此时应该都是字典）
if not isinstance(match_response, dict):
logger.error(f"match_response 不是字典类型: {type(match_response)}, 内容: {match_response}")
continue
@@ -315,18 +391,22 @@ class ExpressionLearner:
return matched_expressions
- async def learn_expression(self, num: int = 10) -> Optional[List[Tuple[str, str, str, str]]]:
+ async def learn_expression(self, num: int = 10, timestamp_start: Optional[float] = None) -> Optional[List[Tuple[str, str, str, str]]]:
"""从指定聊天流学习表达方式
Args:
num: 学习数量
+ timestamp_start: 学习开始的时间戳，如果为None则使用self.last_learning_time
"""
current_time = time.time()
+
+ # 使用传入的时间戳，如果没有则使用self.last_learning_time
+ start_timestamp = timestamp_start if timestamp_start is not None else self.last_learning_time
# 获取上次学习之后的消息
random_msg = get_raw_msg_by_timestamp_with_chat_inclusive(
chat_id=self.chat_id,
- timestamp_start=self.last_learning_time,
+ timestamp_start=start_timestamp,
timestamp_end=current_time,
limit=num,
)
diff --git a/src/express/expression_reflector.py b/src/express/expression_reflector.py
new file mode 100644
index 00000000..dc651e55
--- /dev/null
+++ b/src/express/expression_reflector.py
@@ -0,0 +1,252 @@
+import random
+import time
+from typing import Optional, Dict
+
+from src.common.logger import get_logger
+from src.common.database.database_model import Expression
+from src.config.config import global_config
+from src.chat.message_receive.chat_stream import get_chat_manager
+from src.plugin_system.apis import send_api
+
+logger = get_logger("expression_reflector")
+
+
+class ExpressionReflector:
+ """表达反思器，管理单个聊天流的表达反思提问"""
+
+ def __init__(self, chat_id: str):
+ self.chat_id = chat_id
+ self.last_ask_time: float = 0.0
+
+ async def check_and_ask(self) -> bool:
+ """
+ 检查是否需要提问表达反思，如果需要则提问
+
+ Returns:
+ bool: 是否执行了提问
+ """
+ try:
+ logger.debug(f"[Expression Reflection] 开始检查是否需要提问 (stream_id: {self.chat_id})")
+
+ if not global_config.expression.reflect:
+ logger.debug("[Expression Reflection] 表达反思功能未启用，跳过")
+ return False
+
+ operator_config = global_config.expression.reflect_operator_id
+ if not operator_config:
+ logger.debug("[Expression Reflection] Operator ID 未配置，跳过")
+ return False
+
+ # 检查是否在允许列表中
+ allow_reflect = global_config.expression.allow_reflect
+ if allow_reflect:
+ # 将 allow_reflect 中的 platform:id:type 格式转换为 chat_id 列表
+ allow_reflect_chat_ids = []
+ for stream_config in allow_reflect:
+ parsed_chat_id = global_config.expression._parse_stream_config_to_chat_id(stream_config)
+ if parsed_chat_id:
+ allow_reflect_chat_ids.append(parsed_chat_id)
+ else:
+ logger.warning(f"[Expression Reflection] 无法解析 allow_reflect 配置项: {stream_config}")
+
+ if self.chat_id not in allow_reflect_chat_ids:
+ logger.info(f"[Expression Reflection] 当前聊天流 {self.chat_id} 不在允许列表中，跳过")
+ return False
+
+ # 检查上一次提问时间
+ current_time = time.time()
+ time_since_last_ask = current_time - self.last_ask_time
+
+ # 5-10分钟间隔，随机选择
+ min_interval = 10 * 60 # 5分钟
+ max_interval = 15 * 60 # 10分钟
+ interval = random.uniform(min_interval, max_interval)
+
+ logger.info(
+ f"[Expression Reflection] 上次提问时间: {self.last_ask_time:.2f}, 当前时间: {current_time:.2f}, 已过时间: {time_since_last_ask:.2f}秒 ({time_since_last_ask / 60:.2f}分钟), 需要间隔: {interval:.2f}秒 ({interval / 60:.2f}分钟)"
+ )
+
+ if time_since_last_ask < interval:
+ remaining_time = interval - time_since_last_ask
+ logger.info(
+ f"[Expression Reflection] 距离上次提问时间不足，还需等待 {remaining_time:.2f}秒 ({remaining_time / 60:.2f}分钟)，跳过"
+ )
+ return False
+
+ # 检查是否已经有针对该 Operator 的 Tracker 在运行
+ logger.info(f"[Expression Reflection] 检查 Operator {operator_config} 是否已有活跃的 Tracker")
+ if await _check_tracker_exists(operator_config):
+ logger.info(f"[Expression Reflection] Operator {operator_config} 已有活跃的 Tracker，跳过本次提问")
+ return False
+
+ # 获取未检查的表达
+ try:
+ logger.info("[Expression Reflection] 查询未检查且未拒绝的表达")
+ expressions = (
+ Expression.select().where((~Expression.checked) & (~Expression.rejected)).limit(50)
+ )
+
+ expr_list = list(expressions)
+ logger.info(f"[Expression Reflection] 找到 {len(expr_list)} 个候选表达")
+
+ if not expr_list:
+ logger.info("[Expression Reflection] 没有可用的表达，跳过")
+ return False
+
+ target_expr: Expression = random.choice(expr_list)
+ logger.info(
+ f"[Expression Reflection] 随机选择了表达 ID: {target_expr.id}, Situation: {target_expr.situation}, Style: {target_expr.style}"
+ )
+
+ # 生成询问文本
+ ask_text = _generate_ask_text(target_expr)
+ if not ask_text:
+ logger.warning("[Expression Reflection] 生成询问文本失败，跳过")
+ return False
+
+ logger.info(f"[Expression Reflection] 准备向 Operator {operator_config} 发送提问")
+ # 发送给 Operator
+ await _send_to_operator(operator_config, ask_text, target_expr)
+
+ # 更新上一次提问时间
+ self.last_ask_time = current_time
+ logger.info(f"[Expression Reflection] 提问成功，已更新上次提问时间为 {current_time:.2f}")
+
+ return True
+
+ except Exception as e:
+ logger.error(f"[Expression Reflection] 检查或提问过程中出错: {e}")
+ import traceback
+
+ logger.error(traceback.format_exc())
+ return False
+ except Exception as e:
+ logger.error(f"[Expression Reflection] 检查或提问过程中出错: {e}")
+ import traceback
+
+ logger.error(traceback.format_exc())
+ return False
+
+
+class ExpressionReflectorManager:
+ """表达反思管理器，管理多个聊天流的表达反思实例"""
+
+ def __init__(self):
+ self.reflectors: Dict[str, ExpressionReflector] = {}
+
+ def get_or_create_reflector(self, chat_id: str) -> ExpressionReflector:
+ """获取或创建指定聊天流的表达反思实例"""
+ if chat_id not in self.reflectors:
+ self.reflectors[chat_id] = ExpressionReflector(chat_id)
+ return self.reflectors[chat_id]
+
+
+# 创建全局实例
+expression_reflector_manager = ExpressionReflectorManager()
+
+
+async def _check_tracker_exists(operator_config: str) -> bool:
+ """检查指定 Operator 是否已有活跃的 Tracker"""
+ from src.express.reflect_tracker import reflect_tracker_manager
+
+ chat_manager = get_chat_manager()
+ chat_stream = None
+
+ # 尝试解析配置字符串 "platform:id:type"
+ parts = operator_config.split(":")
+ if len(parts) == 3:
+ platform = parts[0]
+ id_str = parts[1]
+ stream_type = parts[2]
+
+ user_info = None
+ group_info = None
+
+ from maim_message import UserInfo, GroupInfo
+
+ if stream_type == "group":
+ group_info = GroupInfo(group_id=id_str, platform=platform)
+ user_info = UserInfo(user_id="system", user_nickname="System", platform=platform)
+ elif stream_type == "private":
+ user_info = UserInfo(user_id=id_str, platform=platform, user_nickname="Operator")
+ else:
+ return False
+
+ if user_info:
+ try:
+ chat_stream = await chat_manager.get_or_create_stream(platform, user_info, group_info)
+ except Exception as e:
+ logger.error(f"Failed to get or create chat stream for checking tracker: {e}")
+ return False
+ else:
+ chat_stream = chat_manager.get_stream(operator_config)
+
+ if not chat_stream:
+ return False
+
+ return reflect_tracker_manager.get_tracker(chat_stream.stream_id) is not None
+
+
+def _generate_ask_text(expr: Expression) -> Optional[str]:
+ try:
+ ask_text = (
+ f"我正在学习新的表达方式，请帮我看看这个是否合适？\n\n"
+ f"**学习到的表达信息**\n"
+ f"- 情景 (Situation): {expr.situation}\n"
+ f"- 风格 (Style): {expr.style}\n"
+ )
+ return ask_text
+ except Exception as e:
+ logger.error(f"Failed to generate ask text: {e}")
+ return None
+
+
+async def _send_to_operator(operator_config: str, text: str, expr: Expression):
+ chat_manager = get_chat_manager()
+ chat_stream = None
+
+ # 尝试解析配置字符串 "platform:id:type"
+ parts = operator_config.split(":")
+ if len(parts) == 3:
+ platform = parts[0]
+ id_str = parts[1]
+ stream_type = parts[2]
+
+ user_info = None
+ group_info = None
+
+ from maim_message import UserInfo, GroupInfo
+
+ if stream_type == "group":
+ group_info = GroupInfo(group_id=id_str, platform=platform)
+ user_info = UserInfo(user_id="system", user_nickname="System", platform=platform)
+ elif stream_type == "private":
+ user_info = UserInfo(user_id=id_str, platform=platform, user_nickname="Operator")
+ else:
+ logger.warning(f"Unknown stream type in operator config: {stream_type}")
+ return
+
+ if user_info:
+ try:
+ chat_stream = await chat_manager.get_or_create_stream(platform, user_info, group_info)
+ except Exception as e:
+ logger.error(f"Failed to get or create chat stream for operator {operator_config}: {e}")
+ return
+ else:
+ chat_stream = chat_manager.get_stream(operator_config)
+
+ if not chat_stream:
+ logger.warning(f"Could not find or create chat stream for operator: {operator_config}")
+ return
+
+ stream_id = chat_stream.stream_id
+
+ # 注册 Tracker
+ from src.express.reflect_tracker import ReflectTracker, reflect_tracker_manager
+
+ tracker = ReflectTracker(chat_stream=chat_stream, expression=expr, created_time=time.time())
+ reflect_tracker_manager.add_tracker(stream_id, tracker)
+
+ # 发送消息
+ await send_api.text_to_stream(text=text, stream_id=stream_id, typing=True)
+ logger.info(f"Sent expression reflect query to operator {operator_config} for expr {expr.id}")
diff --git a/src/express/expression_selector.py b/src/express/expression_selector.py
index b4e25f36..8d586d5d 100644
--- a/src/express/expression_selector.py
+++ b/src/express/expression_selector.py
@@ -126,8 +126,10 @@ class ExpressionSelector:
# 支持多chat_id合并抽选
related_chat_ids = self.get_related_chat_ids(chat_id)
- # 优化：一次性查询所有相关chat_id的表达方式
- style_query = Expression.select().where((Expression.chat_id.in_(related_chat_ids)))
+ # 优化：一次性查询所有相关chat_id的表达方式，排除 rejected=1 的表达
+ style_query = Expression.select().where(
+ (Expression.chat_id.in_(related_chat_ids)) & (~Expression.rejected)
+ )
style_exprs = [
{
@@ -138,6 +140,7 @@ class ExpressionSelector:
"source_id": expr.chat_id,
"create_date": expr.create_date if expr.create_date is not None else expr.last_active_time,
"count": expr.count if getattr(expr, "count", None) is not None else 1,
+ "checked": expr.checked if getattr(expr, "checked", None) is not None else False,
}
for expr in style_query
]
@@ -148,7 +151,6 @@ class ExpressionSelector:
else:
selected_style = []
- logger.info(f"随机选择，为聊天室 {chat_id} 选择了 {len(selected_style)} 个表达方式")
return selected_style
except Exception as e:
@@ -291,7 +293,7 @@ class ExpressionSelector:
if valid_expressions:
self.update_expressions_last_active_time(valid_expressions)
- logger.info(f"classic模式从{len(all_expressions)}个情境中选择了{len(valid_expressions)}个")
+ logger.debug(f"从{len(all_expressions)}个情境中选择了{len(valid_expressions)}个")
return valid_expressions, selected_ids
except Exception as e:
diff --git a/src/express/reflect_tracker.py b/src/express/reflect_tracker.py
new file mode 100644
index 00000000..c792679d
--- /dev/null
+++ b/src/express/reflect_tracker.py
@@ -0,0 +1,199 @@
+import time
+from typing import Optional, Dict, TYPE_CHECKING
+from src.common.logger import get_logger
+from src.common.database.database_model import Expression
+from src.llm_models.utils_model import LLMRequest
+from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
+from src.config.config import model_config
+from src.chat.message_receive.chat_stream import ChatStream
+from src.chat.utils.chat_message_builder import (
+ get_raw_msg_by_timestamp_with_chat,
+ build_readable_messages,
+)
+
+if TYPE_CHECKING:
+ pass
+
+logger = get_logger("reflect_tracker")
+
+
+class ReflectTracker:
+ def __init__(self, chat_stream: ChatStream, expression: Expression, created_time: float):
+ self.chat_stream = chat_stream
+ self.expression = expression
+ self.created_time = created_time
+ # self.message_count = 0 # Replaced by checking message list length
+ self.last_check_msg_count = 0
+ self.max_message_count = 30
+ self.max_duration = 15 * 60 # 15 minutes
+
+ # LLM for judging response
+ self.judge_model = LLMRequest(model_set=model_config.model_task_config.utils, request_type="reflect.tracker")
+
+ self._init_prompts()
+
+ def _init_prompts(self):
+ judge_prompt = """
+你是一个表达反思助手。Bot之前询问了表达方式是否合适。
+你需要根据提供的上下文对话，判断是否对该表达方式做出了肯定或否定的评价。
+
+**询问内容**
+情景: {situation}
+风格: {style}
+
+**上下文对话**
+{context_block}
+
+**判断要求**
+1. 判断对话中是否包含对上述询问的回答。
+2. 如果是，判断是肯定（Approve）还是否定（Reject），或者是提供了修改意见。
+3. 如果不是回答，或者是无关内容，请返回 "Ignore"。
+4. 如果是否定并提供了修改意见，请提取修正后的情景和风格。
+
+请输出JSON格式：
+```json
+{{
+ "judgment": "Approve" | "Reject" | "Ignore",
+ "corrected_situation": "...", // 如果有修改意见，提取修正后的情景，否则留空
+ "corrected_style": "..." // 如果有修改意见，提取修正后的风格，否则留空
+}}
+```
+"""
+ Prompt(judge_prompt, "reflect_judge_prompt")
+
+ async def trigger_tracker(self) -> bool:
+ """
+ 触发追踪检查
+ Returns: True if resolved (should destroy tracker), False otherwise
+ """
+ # Check timeout
+ if time.time() - self.created_time > self.max_duration:
+ logger.info(f"ReflectTracker for expr {self.expression.id} timed out (duration).")
+ return True
+
+ # Fetch messages since creation
+ msg_list = get_raw_msg_by_timestamp_with_chat(
+ chat_id=self.chat_stream.stream_id,
+ timestamp_start=self.created_time,
+ timestamp_end=time.time(),
+ )
+
+ current_msg_count = len(msg_list)
+
+ # Check message limit
+ if current_msg_count > self.max_message_count:
+ logger.info(f"ReflectTracker for expr {self.expression.id} timed out (message count).")
+ return True
+
+ # If no new messages since last check, skip
+ if current_msg_count <= self.last_check_msg_count:
+ return False
+
+ self.last_check_msg_count = current_msg_count
+
+ # Build context block
+ # Use simple readable format
+ context_block = build_readable_messages(
+ msg_list,
+ replace_bot_name=True,
+ timestamp_mode="relative",
+ read_mark=0.0,
+ show_actions=False,
+ )
+
+ # LLM Judge
+ try:
+ prompt = await global_prompt_manager.format_prompt(
+ "reflect_judge_prompt",
+ situation=self.expression.situation,
+ style=self.expression.style,
+ context_block=context_block,
+ )
+
+ logger.info(f"ReflectTracker LLM Prompt: {prompt}")
+
+ response, _ = await self.judge_model.generate_response_async(prompt, temperature=0.1)
+
+ logger.info(f"ReflectTracker LLM Response: {response}")
+
+ # Parse JSON
+ import json
+ import re
+ from json_repair import repair_json
+
+ json_pattern = r"```json\s*(.*?)\s*```"
+ matches = re.findall(json_pattern, response, re.DOTALL)
+ if not matches:
+ # Try to parse raw response if no code block
+ matches = [response]
+
+ json_obj = json.loads(repair_json(matches[0]))
+
+ judgment = json_obj.get("judgment")
+
+ if judgment == "Approve":
+ self.expression.checked = True
+ self.expression.rejected = False
+ self.expression.save()
+ logger.info(f"Expression {self.expression.id} approved by operator.")
+ return True
+
+ elif judgment == "Reject":
+ self.expression.checked = True
+ corrected_situation = json_obj.get("corrected_situation")
+ corrected_style = json_obj.get("corrected_style")
+
+ # 检查是否有更新
+ has_update = bool(corrected_situation or corrected_style)
+
+ if corrected_situation:
+ self.expression.situation = corrected_situation
+ if corrected_style:
+ self.expression.style = corrected_style
+
+ # 如果拒绝但未更新，标记为 rejected=1
+ if not has_update:
+ self.expression.rejected = True
+ else:
+ self.expression.rejected = False
+
+ self.expression.save()
+
+ if has_update:
+ logger.info(
+ f"Expression {self.expression.id} rejected and updated by operator. New situation: {corrected_situation}, New style: {corrected_style}"
+ )
+ else:
+ logger.info(
+ f"Expression {self.expression.id} rejected but no correction provided, marked as rejected=1."
+ )
+ return True
+
+ elif judgment == "Ignore":
+ logger.info(f"ReflectTracker for expr {self.expression.id} judged as Ignore.")
+ return False
+
+ except Exception as e:
+ logger.error(f"Error in ReflectTracker check: {e}")
+ return False
+
+ return False
+
+
+# Global manager for trackers
+class ReflectTrackerManager:
+ def __init__(self):
+ self.trackers: Dict[str, ReflectTracker] = {} # chat_id -> tracker
+
+ def add_tracker(self, chat_id: str, tracker: ReflectTracker):
+ self.trackers[chat_id] = tracker
+
+ def get_tracker(self, chat_id: str) -> Optional[ReflectTracker]:
+ return self.trackers.get(chat_id)
+
+ def remove_tracker(self, chat_id: str):
+ if chat_id in self.trackers:
+ del self.trackers[chat_id]
+
+
+reflect_tracker_manager = ReflectTrackerManager()
diff --git a/src/hippo_memorizer/chat_history_summarizer.py b/src/hippo_memorizer/chat_history_summarizer.py
new file mode 100644
index 00000000..70847de0
--- /dev/null
+++ b/src/hippo_memorizer/chat_history_summarizer.py
@@ -0,0 +1,924 @@
+"""
+聊天内容概括器
+用于累积、打包和压缩聊天记录
+"""
+
+import asyncio
+import json
+import time
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+from dataclasses import dataclass, field
+from json_repair import repair_json
+
+from src.common.logger import get_logger
+from src.common.data_models.database_data_model import DatabaseMessages
+from src.config.config import global_config, model_config
+from src.llm_models.utils_model import LLMRequest
+from src.plugin_system.apis import message_api
+from src.chat.utils.chat_message_builder import build_readable_messages
+from src.person_info.person_info import Person
+from src.chat.message_receive.chat_stream import get_chat_manager
+from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
+
+logger = get_logger("chat_history_summarizer")
+
+HIPPO_CACHE_DIR = Path(__file__).resolve().parents[2] / "data" / "hippo_memorizer"
+
+
+def init_prompt():
+ """初始化提示词模板"""
+
+ topic_analysis_prompt = """
+【历史话题标题列表】（仅标题，不含具体内容）：
+{history_topics_block}
+
+【本次聊天记录】（每条消息前有编号，用于后续引用）：
+{messages_block}
+
+请完成以下任务：
+**识别话题**
+1. 识别【本次聊天记录】中正在进行的一个或多个话题；
+2. 判断【历史话题标题列表】中的话题是否在【本次聊天记录】中出现，如果出现，则直接使用该历史话题标题字符串；
+
+**选取消息**
+1. 对于每个话题（新话题或历史话题），从上述带编号的消息中选出与该话题强相关的消息编号列表；
+2. 每个话题用一句话清晰地描述正在发生的事件，必须包含时间（大致即可）、人物、主要事件和主题，保证精准且有区分度；
+
+请先输出一段简短思考，说明有什么话题，哪些是不包含在历史话题中的，哪些是包含在历史话题中的，并说明为什么；
+然后严格以 JSON 格式输出【本次聊天记录】中涉及的话题，格式如下：
+[
+ {{
+ "topic": "话题",
+ "message_indices": [1, 2, 5]
+ }},
+ ...
+]
+"""
+ Prompt(topic_analysis_prompt, "hippo_topic_analysis_prompt")
+
+ topic_summary_prompt = """
+请基于以下话题，对聊天记录片段进行概括，提取以下信息：
+
+**话题**：{topic}
+
+**要求**：
+1. 关键词：提取与话题相关的关键词，用列表形式返回（3-10个关键词）
+2. 概括：对这段话的平文本概括（50-200字），要求：
+ - 仔细地转述发生的事件和聊天内容；
+ - 可以适当摘取聊天记录中的原文；
+ - 重点突出事件的发展过程和结果；
+ - 围绕话题这个中心进行概括。
+3. 关键信息：提取话题中的关键信息点，用列表形式返回（3-8个关键信息点），每个关键信息点应该简洁明了。
+
+请以JSON格式返回，格式如下：
+{{
+ "keywords": ["关键词1", "关键词2", ...],
+ "summary": "概括内容",
+ "key_point": ["关键信息1", "关键信息2", ...]
+}}
+
+聊天记录：
+{original_text}
+
+请直接返回JSON，不要包含其他内容。
+"""
+ Prompt(topic_summary_prompt, "hippo_topic_summary_prompt")
+
+
+@dataclass
+class MessageBatch:
+ """消息批次（用于触发话题检查的原始消息累积）"""
+
+ messages: List[DatabaseMessages]
+ start_time: float
+ end_time: float
+
+
+@dataclass
+class TopicCacheItem:
+ """
+ 话题缓存项
+
+ Attributes:
+ topic: 话题标题（一句话描述时间、人物、事件和主题）
+ messages: 与该话题相关的消息字符串列表（已经通过 build 函数转成可读文本）
+ participants: 涉及到的发言人昵称集合
+ no_update_checks: 连续多少次“检查”没有新增内容
+ """
+
+ topic: str
+ messages: List[str] = field(default_factory=list)
+ participants: Set[str] = field(default_factory=set)
+ no_update_checks: int = 0
+
+
+class ChatHistorySummarizer:
+ """聊天内容概括器"""
+
+ def __init__(self, chat_id: str, check_interval: int = 60):
+ """
+ 初始化聊天内容概括器
+
+ Args:
+ chat_id: 聊天ID
+ check_interval: 定期检查间隔（秒），默认60秒
+ """
+ self.chat_id = chat_id
+ self._chat_display_name = self._get_chat_display_name()
+ self.log_prefix = f"[{self._chat_display_name}]"
+
+ # 记录时间点，用于计算新消息
+ self.last_check_time = time.time()
+
+ # 记录上一次话题检查的时间，用于判断是否需要触发检查
+ self.last_topic_check_time = time.time()
+
+ # 当前累积的消息批次
+ self.current_batch: Optional[MessageBatch] = None
+
+ # 话题缓存：topic_str -> TopicCacheItem
+ # 在内存中维护，并通过本地文件实时持久化
+ self.topic_cache: Dict[str, TopicCacheItem] = {}
+ self._safe_chat_id = self._sanitize_chat_id(self.chat_id)
+ self._topic_cache_file = HIPPO_CACHE_DIR / f"{self._safe_chat_id}.json"
+ # 注意：批次加载需要异步查询消息，所以在 start() 中调用
+
+ # LLM请求器，用于压缩聊天内容
+ self.summarizer_llm = LLMRequest(
+ model_set=model_config.model_task_config.utils, request_type="chat_history_summarizer"
+ )
+
+ # 后台循环相关
+ self.check_interval = check_interval # 检查间隔（秒）
+ self._periodic_task: Optional[asyncio.Task] = None
+ self._running = False
+
+ def _get_chat_display_name(self) -> str:
+ """获取聊天显示名称"""
+ try:
+ chat_name = get_chat_manager().get_stream_name(self.chat_id)
+ if chat_name:
+ return chat_name
+ # 如果获取失败，使用简化的chat_id显示
+ if len(self.chat_id) > 20:
+ return f"{self.chat_id[:8]}..."
+ return self.chat_id
+ except Exception:
+ # 如果获取失败，使用简化的chat_id显示
+ if len(self.chat_id) > 20:
+ return f"{self.chat_id[:8]}..."
+ return self.chat_id
+
+ def _sanitize_chat_id(self, chat_id: str) -> str:
+ """用于生成可作为文件名的 chat_id"""
+ return re.sub(r"[^a-zA-Z0-9_.-]", "_", chat_id)
+
+ def _load_topic_cache_from_disk(self):
+ """在启动时加载本地话题缓存（同步部分），支持重启后继续"""
+ try:
+ if not self._topic_cache_file.exists():
+ return
+
+ with self._topic_cache_file.open("r", encoding="utf-8") as f:
+ data = json.load(f)
+
+ self.last_topic_check_time = data.get("last_topic_check_time", self.last_topic_check_time)
+ topics_data = data.get("topics", {})
+ loaded_count = 0
+ for topic, payload in topics_data.items():
+ self.topic_cache[topic] = TopicCacheItem(
+ topic=topic,
+ messages=payload.get("messages", []),
+ participants=set(payload.get("participants", [])),
+ no_update_checks=payload.get("no_update_checks", 0),
+ )
+ loaded_count += 1
+
+ if loaded_count:
+ logger.info(f"{self.log_prefix} 已加载 {loaded_count} 个话题缓存，继续追踪")
+ except Exception as e:
+ logger.error(f"{self.log_prefix} 加载话题缓存失败: {e}")
+
+ async def _load_batch_from_disk(self):
+ """在启动时加载聊天批次，支持重启后继续"""
+ try:
+ if not self._topic_cache_file.exists():
+ return
+
+ with self._topic_cache_file.open("r", encoding="utf-8") as f:
+ data = json.load(f)
+
+ batch_data = data.get("current_batch")
+ if not batch_data:
+ return
+
+ start_time = batch_data.get("start_time")
+ end_time = batch_data.get("end_time")
+ if not start_time or not end_time:
+ return
+
+ # 根据时间范围重新查询消息
+ messages = message_api.get_messages_by_time_in_chat(
+ chat_id=self.chat_id,
+ start_time=start_time,
+ end_time=end_time,
+ limit=0,
+ limit_mode="latest",
+ filter_mai=False,
+ filter_command=False,
+ )
+
+ if messages:
+ self.current_batch = MessageBatch(
+ messages=messages,
+ start_time=start_time,
+ end_time=end_time,
+ )
+ logger.info(f"{self.log_prefix} 已恢复聊天批次，包含 {len(messages)} 条消息")
+ except Exception as e:
+ logger.error(f"{self.log_prefix} 加载聊天批次失败: {e}")
+
+ def _persist_topic_cache(self):
+ """实时持久化话题缓存和聊天批次，避免重启后丢失"""
+ try:
+ # 如果既没有话题缓存也没有批次，删除缓存文件
+ if not self.topic_cache and not self.current_batch:
+ if self._topic_cache_file.exists():
+ self._topic_cache_file.unlink()
+ return
+
+ HIPPO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+ data = {
+ "chat_id": self.chat_id,
+ "last_topic_check_time": self.last_topic_check_time,
+ "topics": {
+ topic: {
+ "messages": item.messages,
+ "participants": list(item.participants),
+ "no_update_checks": item.no_update_checks,
+ }
+ for topic, item in self.topic_cache.items()
+ },
+ }
+
+ # 保存当前批次的时间范围（如果有）
+ if self.current_batch:
+ data["current_batch"] = {
+ "start_time": self.current_batch.start_time,
+ "end_time": self.current_batch.end_time,
+ }
+
+ with self._topic_cache_file.open("w", encoding="utf-8") as f:
+ json.dump(data, f, ensure_ascii=False, indent=2)
+ except Exception as e:
+ logger.error(f"{self.log_prefix} 持久化话题缓存失败: {e}")
+
+ async def process(self, current_time: Optional[float] = None):
+ """
+ 处理聊天内容概括
+
+ Args:
+ current_time: 当前时间戳，如果为None则使用time.time()
+ """
+ if current_time is None:
+ current_time = time.time()
+
+ try:
+ # 获取从上次检查时间到当前时间的新消息
+ new_messages = message_api.get_messages_by_time_in_chat(
+ chat_id=self.chat_id,
+ start_time=self.last_check_time,
+ end_time=current_time,
+ limit=0,
+ limit_mode="latest",
+ filter_mai=False, # 不过滤bot消息，因为需要检查bot是否发言
+ filter_command=False,
+ )
+
+ if not new_messages:
+ # 没有新消息，检查是否需要进行“话题检查”
+ if self.current_batch and self.current_batch.messages:
+ await self._check_and_run_topic_check(current_time)
+ self.last_check_time = current_time
+ return
+
+ logger.debug(
+ f"{self.log_prefix} 开始处理聊天概括，时间窗口: {self.last_check_time:.2f} -> {current_time:.2f}"
+ )
+
+ # 有新消息，更新最后检查时间
+ self.last_check_time = current_time
+
+ # 如果有当前批次，添加新消息
+ if self.current_batch:
+ before_count = len(self.current_batch.messages)
+ self.current_batch.messages.extend(new_messages)
+ self.current_batch.end_time = current_time
+ logger.info(f"{self.log_prefix} 更新聊天检查批次: {before_count} -> {len(self.current_batch.messages)} 条消息")
+ # 更新批次后持久化
+ self._persist_topic_cache()
+ else:
+ # 创建新批次
+ self.current_batch = MessageBatch(
+ messages=new_messages,
+ start_time=new_messages[0].time if new_messages else current_time,
+ end_time=current_time,
+ )
+ logger.debug(f"{self.log_prefix} 新建聊天检查批次: {len(new_messages)} 条消息")
+ # 创建批次后持久化
+ self._persist_topic_cache()
+
+ # 检查是否需要触发“话题检查”
+ await self._check_and_run_topic_check(current_time)
+
+ except Exception as e:
+ logger.error(f"{self.log_prefix} 处理聊天内容概括时出错: {e}")
+ import traceback
+
+ traceback.print_exc()
+
+ async def _check_and_run_topic_check(self, current_time: float):
+ """
+ 检查是否需要进行一次“话题检查”
+
+ 触发条件：
+ - 当前批次消息数 >= 100，或者
+ - 距离上一次检查的时间 > 3600 秒（1小时）
+ """
+ if not self.current_batch or not self.current_batch.messages:
+ return
+
+ messages = self.current_batch.messages
+ message_count = len(messages)
+ time_since_last_check = current_time - self.last_topic_check_time
+
+ # 格式化时间差显示
+ if time_since_last_check < 60:
+ time_str = f"{time_since_last_check:.1f}秒"
+ elif time_since_last_check < 3600:
+ time_str = f"{time_since_last_check / 60:.1f}分钟"
+ else:
+ time_str = f"{time_since_last_check / 3600:.1f}小时"
+
+ logger.debug(
+ f"{self.log_prefix} 批次状态检查 | 消息数: {message_count} | 距上次检查: {time_str}"
+ )
+
+ # 检查“话题检查”触发条件
+ should_check = False
+
+ # 条件1: 消息数量 >= 100，触发一次检查
+ if message_count >= 80:
+ should_check = True
+ logger.info(f"{self.log_prefix} 触发检查条件: 消息数量达到 {message_count} 条（阈值: 100条）")
+
+ # 条件2: 距离上一次检查 > 3600 秒（1小时），触发一次检查
+ elif time_since_last_check > 2400:
+ should_check = True
+ logger.info(f"{self.log_prefix} 触发检查条件: 距上次检查 {time_str}（阈值: 1小时）")
+
+ if should_check:
+ await self._run_topic_check_and_update_cache(messages)
+ # 本批次已经被处理为话题信息，可以清空
+ self.current_batch = None
+ # 更新上一次检查时间，并持久化
+ self.last_topic_check_time = current_time
+ self._persist_topic_cache()
+
+ async def _run_topic_check_and_update_cache(self, messages: List[DatabaseMessages]):
+ """
+ 执行一次“话题检查”：
+ 1. 首先确认这段消息里是否有 Bot 发言，没有则直接丢弃本次批次；
+ 2. 将消息编号并转成字符串，构造 LLM Prompt；
+ 3. 把历史话题标题列表放入 Prompt，要求 LLM：
+ - 识别当前聊天中的话题（1 个或多个）；
+ - 为每个话题选出相关消息编号；
+ - 若话题属于历史话题，则沿用原话题标题；
+ 4. LLM 返回 JSON：多个 {topic, message_indices}；
+ 5. 更新本地话题缓存，并根据规则触发“话题打包存储”。
+ """
+ if not messages:
+ return
+
+ start_time = messages[0].time
+ end_time = messages[-1].time
+
+ logger.info(
+ f"{self.log_prefix} 开始话题检查 | 消息数: {len(messages)} | 时间范围: {start_time:.2f} - {end_time:.2f}"
+ )
+
+ # 1. 检查当前批次内是否有 bot 发言（只检查当前批次，不往前推）
+ # 原因：我们要记录的是 bot 参与过的对话片段，如果当前批次内 bot 没有发言，
+ # 说明 bot 没有参与这段对话，不应该记录
+ bot_user_id = str(global_config.bot.qq_account)
+ has_bot_message = False
+
+ for msg in messages:
+ if msg.user_info.user_id == bot_user_id:
+ has_bot_message = True
+ break
+
+ if not has_bot_message:
+ logger.info(
+ f"{self.log_prefix} 当前批次内无 Bot 发言，丢弃本次检查 | 时间范围: {start_time:.2f} - {end_time:.2f}"
+ )
+ return
+
+ # 2. 构造编号后的消息字符串和参与者信息
+ numbered_lines, index_to_msg_str, index_to_msg_text, index_to_participants = self._build_numbered_messages_for_llm(messages)
+
+ # 3. 调用 LLM 识别话题，并得到 topic -> indices
+ existing_topics = list(self.topic_cache.keys())
+ success, topic_to_indices = await self._analyze_topics_with_llm(
+ numbered_lines=numbered_lines,
+ existing_topics=existing_topics,
+ )
+
+ if not success or not topic_to_indices:
+ logger.warning(f"{self.log_prefix} 话题识别失败或无有效话题，本次检查忽略")
+ # 即使识别失败，也认为是一次“检查”，但不更新 no_update_checks（保持原状）
+ return
+
+ # 4. 统计哪些话题在本次检查中有新增内容
+ updated_topics: Set[str] = set()
+
+ for topic, indices in topic_to_indices.items():
+ if not indices:
+ continue
+
+ item = self.topic_cache.get(topic)
+ if not item:
+ # 新话题
+ item = TopicCacheItem(topic=topic)
+ self.topic_cache[topic] = item
+
+ # 收集属于该话题的消息文本（不带编号）
+ topic_msg_texts: List[str] = []
+ new_participants: Set[str] = set()
+ for idx in indices:
+ msg_text = index_to_msg_text.get(idx)
+ if not msg_text:
+ continue
+ topic_msg_texts.append(msg_text)
+ new_participants.update(index_to_participants.get(idx, set()))
+
+ if not topic_msg_texts:
+ continue
+
+ # 将本次检查中属于该话题的所有消息合并为一个字符串（不带编号）
+ merged_text = "\n".join(topic_msg_texts)
+ item.messages.append(merged_text)
+ item.participants.update(new_participants)
+ # 本次检查中该话题有更新，重置计数
+ item.no_update_checks = 0
+ updated_topics.add(topic)
+
+ # 5. 对于本次没有更新的历史话题，no_update_checks + 1
+ for topic, item in list(self.topic_cache.items()):
+ if topic not in updated_topics:
+ item.no_update_checks += 1
+
+ # 6. 检查是否有话题需要打包存储
+ topics_to_finalize: List[str] = []
+ for topic, item in self.topic_cache.items():
+ if item.no_update_checks >= 3:
+ logger.info(f"{self.log_prefix} 话题[{topic}] 连续 3 次检查无新增内容，触发打包存储")
+ topics_to_finalize.append(topic)
+ continue
+ if len(item.messages) > 5:
+ logger.info(f"{self.log_prefix} 话题[{topic}] 消息条数超过 4，触发打包存储")
+ topics_to_finalize.append(topic)
+
+ for topic in topics_to_finalize:
+ item = self.topic_cache.get(topic)
+ if not item:
+ continue
+ try:
+ await self._finalize_and_store_topic(
+ topic=topic,
+ item=item,
+ # 这里的时间范围尽量覆盖最近一次检查的区间
+ start_time=start_time,
+ end_time=end_time,
+ )
+ finally:
+ # 无论成功与否，都从缓存中删除，避免重复
+ self.topic_cache.pop(topic, None)
+
+ def _build_numbered_messages_for_llm(
+ self, messages: List[DatabaseMessages]
+ ) -> tuple[List[str], Dict[int, str], Dict[int, str], Dict[int, Set[str]]]:
+ """
+ 将消息转为带编号的字符串，供 LLM 选择使用。
+
+ 返回:
+ numbered_lines: ["1. xxx", "2. yyy", ...] # 带编号，用于 LLM 选择
+ index_to_msg_str: idx -> "idx. xxx" # 带编号，用于 LLM 选择
+ index_to_msg_text: idx -> "xxx" # 不带编号，用于最终存储
+ index_to_participants: idx -> {nickname1, nickname2, ...}
+ """
+ numbered_lines: List[str] = []
+ index_to_msg_str: Dict[int, str] = {}
+ index_to_msg_text: Dict[int, str] = {} # 不带编号的消息文本
+ index_to_participants: Dict[int, Set[str]] = {}
+
+ for idx, msg in enumerate(messages, start=1):
+ # 使用 build_readable_messages 生成可读文本
+ try:
+ text = build_readable_messages(
+ messages=[msg],
+ replace_bot_name=True,
+ timestamp_mode="normal_no_YMD",
+ read_mark=0.0,
+ truncate=False,
+ show_actions=False,
+ ).strip()
+ except Exception:
+ # 回退到简单文本
+ text = getattr(msg, "processed_plain_text", "") or ""
+
+ # 获取发言人昵称
+ participants: Set[str] = set()
+ try:
+ platform = (
+ getattr(msg, "user_platform", None)
+ or (msg.user_info.platform if msg.user_info else None)
+ or msg.chat_info.platform
+ )
+ user_id = msg.user_info.user_id if msg.user_info else None
+ if platform and user_id:
+ person = Person(platform=platform, user_id=user_id)
+ if person.person_name:
+ participants.add(person.person_name)
+ except Exception:
+ pass
+
+ # 带编号的字符串（用于 LLM 选择）
+ line = f"{idx}. {text}"
+ numbered_lines.append(line)
+ index_to_msg_str[idx] = line
+ # 不带编号的文本（用于最终存储）
+ index_to_msg_text[idx] = text
+ index_to_participants[idx] = participants
+
+ return numbered_lines, index_to_msg_str, index_to_msg_text, index_to_participants
+
+ async def _analyze_topics_with_llm(
+ self,
+ numbered_lines: List[str],
+ existing_topics: List[str],
+ ) -> tuple[bool, Dict[str, List[int]]]:
+ """
+ 使用 LLM 识别本次检查中的话题，并为每个话题选择相关消息编号。
+
+ 要求：
+ - 话题用一句话清晰描述正在发生的事件，包括时间、人物、主要事件和主题；
+ - 可以有 1 个或多个话题；
+ - 若某个话题与历史话题列表中的某个话题是同一件事，请直接使用历史话题的字符串；
+ - 输出 JSON，格式：
+ [
+ {
+ "topic": "话题标题字符串",
+ "message_indices": [1, 2, 5]
+ },
+ ...
+ ]
+ """
+ if not numbered_lines:
+ return False, {}
+
+ history_topics_block = (
+ "\n".join(f"- {t}" for t in existing_topics) if existing_topics else "（当前无历史话题）"
+ )
+ messages_block = "\n".join(numbered_lines)
+
+ prompt = await global_prompt_manager.format_prompt(
+ "hippo_topic_analysis_prompt",
+ history_topics_block=history_topics_block,
+ messages_block=messages_block,
+ )
+
+ try:
+ response, _ = await self.summarizer_llm.generate_response_async(
+ prompt=prompt,
+ temperature=0.2,
+ max_tokens=800,
+ )
+
+ logger.info(f"{self.log_prefix} 话题识别LLM Prompt: {prompt}")
+ logger.info(f"{self.log_prefix} 话题识别LLM Response: {response}")
+
+ # 尝试从响应中提取JSON代码块
+ json_str = None
+ json_pattern = r"```json\s*(.*?)\s*```"
+ matches = re.findall(json_pattern, response, re.DOTALL)
+
+ if matches:
+ # 找到JSON代码块，使用第一个匹配
+ json_str = matches[0].strip()
+ else:
+ # 如果没有找到代码块，尝试查找JSON数组的开始和结束位置
+ # 查找第一个 [ 和最后一个 ]
+ start_idx = response.find('[')
+ end_idx = response.rfind(']')
+ if start_idx != -1 and end_idx != -1 and end_idx > start_idx:
+ json_str = response[start_idx:end_idx + 1].strip()
+ else:
+ # 如果还是找不到，尝试直接使用整个响应（移除可能的markdown标记）
+ json_str = response.strip()
+ json_str = re.sub(r"^```json\s*", "", json_str, flags=re.MULTILINE)
+ json_str = re.sub(r"^```\s*", "", json_str, flags=re.MULTILINE)
+ json_str = json_str.strip()
+
+ # 使用json_repair修复可能的JSON错误
+ if json_str:
+ try:
+ repaired_json = repair_json(json_str)
+ result = json.loads(repaired_json) if isinstance(repaired_json, str) else repaired_json
+ except Exception as repair_error:
+ # 如果repair失败，尝试直接解析
+ logger.warning(f"{self.log_prefix} JSON修复失败，尝试直接解析: {repair_error}")
+ result = json.loads(json_str)
+ else:
+ raise ValueError("无法从响应中提取JSON内容")
+
+ if not isinstance(result, list):
+ logger.error(f"{self.log_prefix} 话题识别返回的 JSON 不是列表: {result}")
+ return False, {}
+
+ topic_to_indices: Dict[str, List[int]] = {}
+ for item in result:
+ if not isinstance(item, dict):
+ continue
+ topic = item.get("topic")
+ indices = item.get("message_indices") or item.get("messages") or []
+ if not topic or not isinstance(topic, str):
+ continue
+ if isinstance(indices, list):
+ valid_indices: List[int] = []
+ for v in indices:
+ try:
+ iv = int(v)
+ if iv > 0:
+ valid_indices.append(iv)
+ except (TypeError, ValueError):
+ continue
+ if valid_indices:
+ topic_to_indices[topic] = valid_indices
+
+ return True, topic_to_indices
+
+ except Exception as e:
+ logger.error(f"{self.log_prefix} 话题识别 LLM 调用或解析失败: {e}")
+ logger.error(f"{self.log_prefix} LLM响应: {response if 'response' in locals() else 'N/A'}")
+ return False, {}
+
+ async def _finalize_and_store_topic(
+ self,
+ topic: str,
+ item: TopicCacheItem,
+ start_time: float,
+ end_time: float,
+ ):
+ """
+ 对某个话题进行最终打包存储：
+ 1. 将 messages(list[str]) 拼接为 original_text；
+ 2. 使用 LLM 对 original_text 进行总结，得到 summary 和 keywords，theme 直接使用话题字符串；
+ 3. 写入数据库 ChatHistory；
+ 4. 完成后，调用方会从缓存中删除该话题。
+ """
+ if not item.messages:
+ logger.info(f"{self.log_prefix} 话题[{topic}] 无消息内容，跳过打包")
+ return
+
+ original_text = "\n".join(item.messages)
+
+ logger.info(
+ f"{self.log_prefix} 开始打包话题[{topic}] | 消息数: {len(item.messages)} | 时间范围: {start_time:.2f} - {end_time:.2f}"
+ )
+
+ # 使用 LLM 进行总结（基于话题名）
+ success, keywords, summary, key_point = await self._compress_with_llm(original_text, topic)
+ if not success:
+ logger.warning(f"{self.log_prefix} 话题[{topic}] LLM 概括失败，不写入数据库")
+ return
+
+ participants = list(item.participants)
+
+ await self._store_to_database(
+ start_time=start_time,
+ end_time=end_time,
+ original_text=original_text,
+ participants=participants,
+ theme=topic, # 主题直接使用话题名
+ keywords=keywords,
+ summary=summary,
+ key_point=key_point,
+ )
+
+ logger.info(
+ f"{self.log_prefix} 话题[{topic}] 成功打包并存储 | 消息数: {len(item.messages)} | 参与者数: {len(participants)}"
+ )
+
+ async def _compress_with_llm(self, original_text: str, topic: str) -> tuple[bool, List[str], str, List[str]]:
+ """
+ 使用LLM压缩聊天内容（用于单个话题的最终总结）
+
+ Args:
+ original_text: 聊天记录原文
+ topic: 话题名称
+
+ Returns:
+ tuple[bool, List[str], str, List[str]]: (是否成功, 关键词列表, 概括, 关键信息列表)
+ """
+ prompt = await global_prompt_manager.format_prompt(
+ "hippo_topic_summary_prompt",
+ topic=topic,
+ original_text=original_text,
+ )
+
+ try:
+ response, _ = await self.summarizer_llm.generate_response_async(
+ prompt=prompt,
+ temperature=0.3,
+ max_tokens=500,
+ )
+
+ # 解析JSON响应
+ json_str = response.strip()
+ json_str = re.sub(r"^```json\s*", "", json_str, flags=re.MULTILINE)
+ json_str = re.sub(r"^```\s*", "", json_str, flags=re.MULTILINE)
+ json_str = json_str.strip()
+
+ # 查找JSON对象的开始与结束
+ start_idx = json_str.find("{")
+ if start_idx == -1:
+ raise ValueError("未找到JSON对象开始标记")
+
+ end_idx = json_str.rfind("}")
+ if end_idx == -1 or end_idx <= start_idx:
+ logger.warning(f"{self.log_prefix} JSON缺少结束标记，尝试自动修复")
+ extracted_json = json_str[start_idx:]
+ else:
+ extracted_json = json_str[start_idx : end_idx + 1]
+
+ def _parse_with_quote_fix(payload: str) -> Dict[str, Any]:
+ fixed_chars: List[str] = []
+ in_string = False
+ escape_next = False
+ i = 0
+ while i < len(payload):
+ char = payload[i]
+ if escape_next:
+ fixed_chars.append(char)
+ escape_next = False
+ elif char == "\\":
+ fixed_chars.append(char)
+ escape_next = True
+ elif char == '"' and not escape_next:
+ fixed_chars.append(char)
+ in_string = not in_string
+ elif in_string and char in {"“", "”"}:
+ # 在字符串值内部，将中文引号替换为转义的英文引号
+ fixed_chars.append('\\"')
+ else:
+ fixed_chars.append(char)
+ i += 1
+
+ repaired = "".join(fixed_chars)
+ return json.loads(repaired)
+
+ try:
+ result = json.loads(extracted_json)
+ except json.JSONDecodeError:
+ try:
+ repaired_json = repair_json(extracted_json)
+ if isinstance(repaired_json, str):
+ result = json.loads(repaired_json)
+ else:
+ result = repaired_json
+ except Exception as repair_error:
+ logger.warning(f"{self.log_prefix} repair_json 失败，使用引号修复: {repair_error}")
+ result = _parse_with_quote_fix(extracted_json)
+
+ keywords = result.get("keywords", [])
+ summary = result.get("summary", "无概括")
+ key_point = result.get("key_point", [])
+
+ # 确保keywords和key_point是列表
+ if isinstance(keywords, str):
+ keywords = [keywords]
+ if isinstance(key_point, str):
+ key_point = [key_point]
+
+ return True, keywords, summary, key_point
+
+ except Exception as e:
+ logger.error(f"{self.log_prefix} LLM压缩聊天内容时出错: {e}")
+ logger.error(f"{self.log_prefix} LLM响应: {response if 'response' in locals() else 'N/A'}")
+ # 返回失败标志和默认值
+ return False, [], "压缩失败，无法生成概括", []
+
+ async def _store_to_database(
+ self,
+ start_time: float,
+ end_time: float,
+ original_text: str,
+ participants: List[str],
+ theme: str,
+ keywords: List[str],
+ summary: str,
+ key_point: Optional[List[str]] = None,
+ ):
+ """存储到数据库"""
+ try:
+ from src.common.database.database_model import ChatHistory
+ from src.plugin_system.apis import database_api
+
+ # 准备数据
+ data = {
+ "chat_id": self.chat_id,
+ "start_time": start_time,
+ "end_time": end_time,
+ "original_text": original_text,
+ "participants": json.dumps(participants, ensure_ascii=False),
+ "theme": theme,
+ "keywords": json.dumps(keywords, ensure_ascii=False),
+ "summary": summary,
+ "count": 0,
+ }
+
+ # 存储 key_point（如果存在）
+ if key_point is not None:
+ data["key_point"] = json.dumps(key_point, ensure_ascii=False)
+
+ # 使用db_save存储（使用start_time和chat_id作为唯一标识）
+ # 由于可能有多条记录，我们使用组合键，但peewee不支持，所以使用start_time作为唯一标识
+ # 但为了避免冲突，我们使用组合键：chat_id + start_time
+ # 由于peewee不支持组合键，我们直接创建新记录（不提供key_field和key_value）
+ saved_record = await database_api.db_save(
+ ChatHistory,
+ data=data,
+ )
+
+ if saved_record:
+ logger.debug(f"{self.log_prefix} 成功存储聊天历史记录到数据库")
+ else:
+ logger.warning(f"{self.log_prefix} 存储聊天历史记录到数据库失败")
+
+ except Exception as e:
+ logger.error(f"{self.log_prefix} 存储到数据库时出错: {e}")
+ import traceback
+
+ traceback.print_exc()
+ raise
+
+ async def start(self):
+ """启动后台定期检查循环"""
+ if self._running:
+ logger.warning(f"{self.log_prefix} 后台循环已在运行，无需重复启动")
+ return
+
+ # 加载聊天批次（如果有）
+ await self._load_batch_from_disk()
+
+ self._running = True
+ self._periodic_task = asyncio.create_task(self._periodic_check_loop())
+ logger.info(f"{self.log_prefix} 已启动后台定期检查循环 | 检查间隔: {self.check_interval}秒")
+
+ async def stop(self):
+ """停止后台定期检查循环"""
+ self._running = False
+ if self._periodic_task:
+ self._periodic_task.cancel()
+ try:
+ await self._periodic_task
+ except asyncio.CancelledError:
+ pass
+ self._periodic_task = None
+ logger.info(f"{self.log_prefix} 已停止后台定期检查循环")
+
+ async def _periodic_check_loop(self):
+ """后台定期检查循环"""
+ try:
+ while self._running:
+ # 执行一次检查
+ await self.process()
+
+ # 等待指定间隔后再次检查
+ await asyncio.sleep(self.check_interval)
+ except asyncio.CancelledError:
+ logger.info(f"{self.log_prefix} 后台检查循环被取消")
+ raise
+ except Exception as e:
+ logger.error(f"{self.log_prefix} 后台检查循环出错: {e}")
+ import traceback
+
+ traceback.print_exc()
+ self._running = False
+
+
+init_prompt()
+
diff --git a/src/jargon/jargon_explainer.py b/src/jargon/jargon_explainer.py
new file mode 100644
index 00000000..28122008
--- /dev/null
+++ b/src/jargon/jargon_explainer.py
@@ -0,0 +1,360 @@
+import re
+import time
+from typing import List, Dict, Optional, Any
+
+from src.common.logger import get_logger
+from src.common.database.database_model import Jargon
+from src.llm_models.utils_model import LLMRequest
+from src.config.config import model_config, global_config
+from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
+from src.jargon.jargon_miner import search_jargon
+from src.jargon.jargon_utils import is_bot_message, contains_bot_self_name, parse_chat_id_list, chat_id_list_contains
+
+logger = get_logger("jargon")
+
+
+def _init_explainer_prompts() -> None:
+ """初始化黑话解释器相关的prompt"""
+ # Prompt：概括黑话解释结果
+ summarize_prompt_str = """上下文聊天内容:
+{chat_context}
+
+在上下文中提取到的黑话及其含义:
+{jargon_explanations}
+
+请根据上述信息，对黑话解释进行概括和整理。
+- 如果上下文中有黑话出现，请简要说明这些黑话在上下文中的使用情况
+- 将所有黑话解释整理成简洁、易读的一段话
+- 输出格式要自然，适合作为回复参考信息
+请输出概括后的黑话解释（直接输出一段平文本，不要标题，无特殊格式或markdown格式，不要使用JSON格式）：
+"""
+ Prompt(summarize_prompt_str, "jargon_explainer_summarize_prompt")
+
+
+_init_explainer_prompts()
+
+
+class JargonExplainer:
+ """黑话解释器，用于在回复前识别和解释上下文中的黑话"""
+
+ def __init__(self, chat_id: str) -> None:
+ self.chat_id = chat_id
+ self.llm = LLMRequest(
+ model_set=model_config.model_task_config.utils,
+ request_type="jargon.explain",
+ )
+
+ def match_jargon_from_messages(self, messages: List[Any]) -> List[Dict[str, str]]:
+ """
+ 通过直接匹配数据库中的jargon字符串来提取黑话
+
+ Args:
+ messages: 消息列表
+
+ Returns:
+ List[Dict[str, str]]: 提取到的黑话列表，每个元素包含content
+ """
+ start_time = time.time()
+
+ if not messages:
+ return []
+
+ # 收集所有消息的文本内容
+ message_texts: List[str] = []
+ for msg in messages:
+ # 跳过机器人自己的消息
+ if is_bot_message(msg):
+ continue
+
+ msg_text = (
+ getattr(msg, "display_message", None) or getattr(msg, "processed_plain_text", None) or ""
+ ).strip()
+ if msg_text:
+ message_texts.append(msg_text)
+
+ if not message_texts:
+ return []
+
+ # 合并所有消息文本
+ combined_text = " ".join(message_texts)
+
+ # 查询所有有meaning的jargon记录
+ query = Jargon.select().where((Jargon.meaning.is_null(False)) & (Jargon.meaning != ""))
+
+ # 根据all_global配置决定查询逻辑
+ if global_config.jargon.all_global:
+ # 开启all_global：只查询is_global=True的记录
+ query = query.where(Jargon.is_global)
+ else:
+ # 关闭all_global：查询is_global=True或chat_id列表包含当前chat_id的记录
+ # 这里先查询所有，然后在Python层面过滤
+ pass
+
+ # 按count降序排序，优先匹配出现频率高的
+ query = query.order_by(Jargon.count.desc())
+
+ # 执行查询并匹配
+ matched_jargon: Dict[str, Dict[str, str]] = {}
+ query_time = time.time()
+
+ for jargon in query:
+ content = jargon.content or ""
+ if not content or not content.strip():
+ continue
+
+ # 跳过包含机器人昵称的词条
+ if contains_bot_self_name(content):
+ continue
+
+ # 检查chat_id（如果all_global=False）
+ if not global_config.jargon.all_global:
+ if jargon.is_global:
+ # 全局黑话，包含
+ pass
+ else:
+ # 检查chat_id列表是否包含当前chat_id
+ chat_id_list = parse_chat_id_list(jargon.chat_id)
+ if not chat_id_list_contains(chat_id_list, self.chat_id):
+ continue
+
+ # 在文本中查找匹配（大小写不敏感）
+ pattern = re.escape(content)
+ # 使用单词边界或中文字符边界来匹配，避免部分匹配
+ # 对于中文，使用Unicode字符类；对于英文，使用单词边界
+ if re.search(r"[\u4e00-\u9fff]", content):
+ # 包含中文，使用更宽松的匹配
+ search_pattern = pattern
+ else:
+ # 纯英文/数字，使用单词边界
+ search_pattern = r"\b" + pattern + r"\b"
+
+ if re.search(search_pattern, combined_text, re.IGNORECASE):
+ # 找到匹配，记录（去重）
+ if content not in matched_jargon:
+ matched_jargon[content] = {"content": content}
+
+ match_time = time.time()
+ total_time = match_time - start_time
+ query_duration = query_time - start_time
+ match_duration = match_time - query_time
+
+ logger.debug(
+ f"黑话匹配完成: 查询耗时 {query_duration:.3f}s, 匹配耗时 {match_duration:.3f}s, "
+ f"总耗时 {total_time:.3f}s, 匹配到 {len(matched_jargon)} 个黑话"
+ )
+
+ return list(matched_jargon.values())
+
+ async def explain_jargon(self, messages: List[Any], chat_context: str) -> Optional[str]:
+ """
+ 解释上下文中的黑话
+
+ Args:
+ messages: 消息列表
+ chat_context: 聊天上下文的文本表示
+
+ Returns:
+ Optional[str]: 黑话解释的概括文本，如果没有黑话则返回None
+ """
+ if not messages:
+ return None
+
+ # 直接匹配方式：从数据库中查询jargon并在消息中匹配
+ jargon_entries = self.match_jargon_from_messages(messages)
+
+ if not jargon_entries:
+ return None
+
+ # 去重（按content）
+ unique_jargon: Dict[str, Dict[str, str]] = {}
+ for entry in jargon_entries:
+ content = entry["content"]
+ if content not in unique_jargon:
+ unique_jargon[content] = entry
+
+ jargon_list = list(unique_jargon.values())
+ logger.info(f"从上下文中提取到 {len(jargon_list)} 个黑话: {[j['content'] for j in jargon_list]}")
+
+ # 查询每个黑话的含义
+ jargon_explanations: List[str] = []
+ for entry in jargon_list:
+ content = entry["content"]
+
+ # 根据是否开启全局黑话，决定查询方式
+ if global_config.jargon.all_global:
+ # 开启全局黑话：查询所有is_global=True的记录
+ results = search_jargon(
+ keyword=content,
+ chat_id=None, # 不指定chat_id，查询全局黑话
+ limit=1,
+ case_sensitive=False,
+ fuzzy=False, # 精确匹配
+ )
+ else:
+ # 关闭全局黑话：优先查询当前聊天或全局的黑话
+ results = search_jargon(
+ keyword=content,
+ chat_id=self.chat_id,
+ limit=1,
+ case_sensitive=False,
+ fuzzy=False, # 精确匹配
+ )
+
+ if results and len(results) > 0:
+ meaning = results[0].get("meaning", "").strip()
+ if meaning:
+ jargon_explanations.append(f"- {content}: {meaning}")
+ else:
+ logger.info(f"黑话 {content} 没有找到含义")
+ else:
+ logger.info(f"黑话 {content} 未在数据库中找到")
+
+ if not jargon_explanations:
+ logger.info("没有找到任何黑话的含义，跳过解释")
+ return None
+
+ # 拼接所有黑话解释
+ explanations_text = "\n".join(jargon_explanations)
+
+ # 使用LLM概括黑话解释
+ summarize_prompt = await global_prompt_manager.format_prompt(
+ "jargon_explainer_summarize_prompt",
+ chat_context=chat_context,
+ jargon_explanations=explanations_text,
+ )
+
+ summary, _ = await self.llm.generate_response_async(summarize_prompt, temperature=0.3)
+ if not summary:
+ # 如果LLM概括失败，直接返回原始解释
+ return f"上下文中的黑话解释：\n{explanations_text}"
+
+ summary = summary.strip()
+ if not summary:
+ return f"上下文中的黑话解释：\n{explanations_text}"
+
+ return summary
+
+
+async def explain_jargon_in_context(chat_id: str, messages: List[Any], chat_context: str) -> Optional[str]:
+ """
+ 解释上下文中的黑话（便捷函数）
+
+ Args:
+ chat_id: 聊天ID
+ messages: 消息列表
+ chat_context: 聊天上下文的文本表示
+
+ Returns:
+ Optional[str]: 黑话解释的概括文本，如果没有黑话则返回None
+ """
+ explainer = JargonExplainer(chat_id)
+ return await explainer.explain_jargon(messages, chat_context)
+
+
+def match_jargon_from_text(chat_text: str, chat_id: str) -> List[str]:
+ """直接在聊天文本中匹配已知的jargon，返回出现过的黑话列表
+
+ Args:
+ chat_text: 要匹配的聊天文本
+ chat_id: 聊天ID
+
+ Returns:
+ List[str]: 匹配到的黑话列表
+ """
+ if not chat_text or not chat_text.strip():
+ return []
+
+ query = Jargon.select().where((Jargon.meaning.is_null(False)) & (Jargon.meaning != ""))
+ if global_config.jargon.all_global:
+ query = query.where(Jargon.is_global)
+
+ query = query.order_by(Jargon.count.desc())
+
+ matched: Dict[str, None] = {}
+
+ for jargon in query:
+ content = (jargon.content or "").strip()
+ if not content:
+ continue
+
+ if not global_config.jargon.all_global and not jargon.is_global:
+ chat_id_list = parse_chat_id_list(jargon.chat_id)
+ if not chat_id_list_contains(chat_id_list, chat_id):
+ continue
+
+ pattern = re.escape(content)
+ if re.search(r"[\u4e00-\u9fff]", content):
+ search_pattern = pattern
+ else:
+ search_pattern = r"\b" + pattern + r"\b"
+
+ if re.search(search_pattern, chat_text, re.IGNORECASE):
+ matched[content] = None
+
+ logger.info(f"匹配到 {len(matched)} 个黑话")
+
+ return list(matched.keys())
+
+
+async def retrieve_concepts_with_jargon(concepts: List[str], chat_id: str) -> str:
+ """对概念列表进行jargon检索
+
+ Args:
+ concepts: 概念列表
+ chat_id: 聊天ID
+
+ Returns:
+ str: 检索结果字符串
+ """
+ if not concepts:
+ return ""
+
+ results = []
+ exact_matches = [] # 收集所有精确匹配的概念
+ for concept in concepts:
+ concept = concept.strip()
+ if not concept:
+ continue
+
+ # 先尝试精确匹配
+ jargon_results = search_jargon(keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=False)
+
+ is_fuzzy_match = False
+
+ # 如果精确匹配未找到，尝试模糊搜索
+ if not jargon_results:
+ jargon_results = search_jargon(keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=True)
+ is_fuzzy_match = True
+
+ if jargon_results:
+ # 找到结果
+ if is_fuzzy_match:
+ # 模糊匹配
+ output_parts = [f"未精确匹配到'{concept}'"]
+ for result in jargon_results:
+ found_content = result.get("content", "").strip()
+ meaning = result.get("meaning", "").strip()
+ if found_content and meaning:
+ output_parts.append(f"找到 '{found_content}' 的含义为：{meaning}")
+ results.append("，".join(output_parts))
+ logger.info(f"在jargon库中找到匹配（模糊搜索）: {concept}，找到{len(jargon_results)}条结果")
+ else:
+ # 精确匹配
+ output_parts = []
+ for result in jargon_results:
+ meaning = result.get("meaning", "").strip()
+ if meaning:
+ output_parts.append(f"'{concept}' 为黑话或者网络简写，含义为：{meaning}")
+ results.append("；".join(output_parts) if len(output_parts) > 1 else output_parts[0])
+ exact_matches.append(concept) # 收集精确匹配的概念，稍后统一打印
+ else:
+ # 未找到，不返回占位信息，只记录日志
+ logger.info(f"在jargon库中未找到匹配: {concept}")
+
+ # 合并所有精确匹配的日志
+ if exact_matches:
+ logger.info(f"找到黑话: {', '.join(exact_matches)}，共找到{len(exact_matches)}条结果")
+
+ if results:
+ return "【概念检索结果】\n" + "\n".join(results) + "\n"
+ return ""
\ No newline at end of file
diff --git a/src/jargon/jargon_miner.py b/src/jargon/jargon_miner.py
index 4319ad3d..b7f6c857 100644
--- a/src/jargon/jargon_miner.py
+++ b/src/jargon/jargon_miner.py
@@ -1,6 +1,7 @@
import time
import json
import asyncio
+from collections import OrderedDict
from typing import List, Dict, Optional, Any
from json_repair import repair_json
from peewee import fn
@@ -10,42 +11,27 @@ from src.common.database.database_model import Jargon
from src.llm_models.utils_model import LLMRequest
from src.config.config import model_config, global_config
from src.chat.message_receive.chat_stream import get_chat_manager
-from src.plugin_system.apis import llm_api
from src.chat.utils.chat_message_builder import (
- build_anonymous_messages,
+ build_readable_messages_with_id,
get_raw_msg_by_timestamp_with_chat_inclusive,
- get_raw_msg_before_timestamp_with_chat,
- build_readable_messages_with_list,
)
from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
+from src.jargon.jargon_utils import (
+ is_bot_message,
+ build_context_paragraph,
+ contains_bot_self_name,
+ parse_chat_id_list,
+ chat_id_list_contains,
+ update_chat_id_list,
+)
logger = get_logger("jargon")
-def _contains_bot_self_name(content: str) -> bool:
- """
- 判断词条是否包含机器人的昵称或别名
- """
- if not content:
- return False
-
- bot_config = getattr(global_config, "bot", None)
- if not bot_config:
- return False
-
- target = content.strip().lower()
- nickname = str(getattr(bot_config, "nickname", "") or "").strip().lower()
- alias_names = [str(alias or "").strip().lower() for alias in getattr(bot_config, "alias_names", []) or []]
-
- candidates = [name for name in [nickname, *alias_names] if name]
-
- return any(name in target for name in candidates if target)
-
-
def _init_prompt() -> None:
prompt_str = """
-**聊天内容，其中的SELF是你自己的发言**
+**聊天内容，其中的{bot_name}的发言内容是你自己的发言，[msg_id] 是消息ID**
{chat_str}
请从上面这段聊天内容中提取"可能是黑话"的候选项（黑话/俚语/网络缩写/口头禅）。
@@ -62,9 +48,10 @@ def _init_prompt() -> None:
- 中文词语的缩写，用几个汉字概括一个词汇或含义，例如：社死、内卷
以 JSON 数组输出，元素为对象（严格按以下结构）：
+请你提取出可能的黑话，最多10
[
- {{"content": "词条", "raw_content": "包含该词条的完整对话上下文原文"}},
- {{"content": "词条2", "raw_content": "包含该词条的完整对话上下文原文"}}
+ {{"content": "词条", "msg_id": "m12"}}, // msg_id 必须与上方聊天中展示的ID完全一致
+ {{"content": "词条2", "msg_id": "m15"}}
]
现在请输出：
@@ -78,12 +65,13 @@ def _init_inference_prompts() -> None:
prompt1_str = """
**词条内容**
{content}
-**词条出现的上下文（raw_content）其中的SELF是你自己的发言**
+**词条出现的上下文。其中的{bot_name}的发言内容是你自己的发言**
{raw_content_list}
-请根据以上词条内容和上下文，推断这个词条的含义。
+请根据上下文，推断"{content}"这个词条的含义。
- 如果这是一个黑话、俚语或网络用语，请推断其含义
- 如果含义明确（常规词汇），也请说明
+- {bot_name} 的发言内容可能包含错误，请不要参考其发言内容
- 如果上下文信息不足，无法推断含义，请设置 no_info 为 true
以 JSON 格式输出：
@@ -136,95 +124,6 @@ _init_prompt()
_init_inference_prompts()
-async def _enrich_raw_content_if_needed(
- content: str,
- raw_content_list: List[str],
- chat_id: str,
- messages: List[Any],
- extraction_start_time: float,
- extraction_end_time: float,
-) -> List[str]:
- """
- 检查raw_content是否只包含黑话本身，如果是，则获取该消息的前三条消息作为原始内容
-
- Args:
- content: 黑话内容
- raw_content_list: 原始raw_content列表
- chat_id: 聊天ID
- messages: 当前时间窗口内的消息列表
- extraction_start_time: 提取开始时间
- extraction_end_time: 提取结束时间
-
- Returns:
- 处理后的raw_content列表
- """
- enriched_list = []
-
- for raw_content in raw_content_list:
- # 检查raw_content是否只包含黑话本身（去除空白字符后比较）
- raw_content_clean = raw_content.strip()
- content_clean = content.strip()
-
- # 如果raw_content只包含黑话本身（可能有一些标点或空白），则尝试获取上下文
- # 去除所有空白字符后比较，确保只包含黑话本身
- raw_content_normalized = raw_content_clean.replace(" ", "").replace("\n", "").replace("\t", "")
- content_normalized = content_clean.replace(" ", "").replace("\n", "").replace("\t", "")
-
- if raw_content_normalized == content_normalized:
- # 在消息列表中查找只包含该黑话的消息（去除空白后比较）
- target_message = None
- for msg in messages:
- msg_content = (msg.processed_plain_text or msg.display_message or "").strip()
- msg_content_normalized = msg_content.replace(" ", "").replace("\n", "").replace("\t", "")
- # 检查消息内容是否只包含黑话本身（去除空白后完全匹配）
- if msg_content_normalized == content_normalized:
- target_message = msg
- break
-
- if target_message and target_message.time:
- # 获取该消息的前三条消息
- try:
- previous_messages = get_raw_msg_before_timestamp_with_chat(
- chat_id=chat_id, timestamp=target_message.time, limit=3
- )
-
- if previous_messages:
- # 将前三条消息和当前消息一起格式化
- context_messages = previous_messages + [target_message]
- # 按时间排序
- context_messages.sort(key=lambda x: x.time or 0)
-
- # 格式化为可读消息
- formatted_context, _ = await build_readable_messages_with_list(
- context_messages,
- replace_bot_name=True,
- timestamp_mode="relative",
- truncate=False,
- )
-
- if formatted_context.strip():
- enriched_list.append(formatted_context.strip())
- logger.warning(f"为黑话 {content} 补充了上下文消息")
- else:
- # 如果格式化失败，使用原始raw_content
- enriched_list.append(raw_content)
- else:
- # 没有找到前三条消息，使用原始raw_content
- enriched_list.append(raw_content)
- except Exception as e:
- logger.warning(f"获取黑话 {content} 的上下文消息失败: {e}")
- # 出错时使用原始raw_content
- enriched_list.append(raw_content)
- else:
- # 没有找到包含黑话的消息，使用原始raw_content
- enriched_list.append(raw_content)
- else:
- # raw_content包含更多内容，直接使用
- enriched_list.append(raw_content)
-
- return enriched_list
-
-
def _should_infer_meaning(jargon_obj: Jargon) -> bool:
"""
判断是否需要进行含义推断
@@ -240,7 +139,7 @@ def _should_infer_meaning(jargon_obj: Jargon) -> bool:
last_inference = jargon_obj.last_inference_count or 0
# 阈值列表：3,6, 10, 20, 40, 60, 100
- thresholds = [3, 6, 10, 20, 40, 60, 100]
+ thresholds = [2, 4, 8, 12, 24, 60, 100]
if count < thresholds[0]:
return False
@@ -281,6 +180,56 @@ class JargonMiner:
chat_manager = get_chat_manager()
stream_name = chat_manager.get_stream_name(self.chat_id)
self.stream_name = stream_name if stream_name else self.chat_id
+ self.cache_limit = 100
+ self.cache: OrderedDict[str, None] = OrderedDict()
+
+ # 黑话提取锁，防止并发执行
+ self._extraction_lock = asyncio.Lock()
+
+ def _add_to_cache(self, content: str) -> None:
+ """将提取到的黑话加入缓存，保持LRU语义"""
+ if not content:
+ return
+
+ key = content.strip()
+ if not key:
+ return
+
+ if key in self.cache:
+ self.cache.move_to_end(key)
+ else:
+ self.cache[key] = None
+ if len(self.cache) > self.cache_limit:
+ self.cache.popitem(last=False)
+
+ def _collect_cached_entries(self, messages: List[Any]) -> List[Dict[str, List[str]]]:
+ """检查缓存中的黑话是否出现在当前消息窗口，生成对应上下文"""
+ if not self.cache or not messages:
+ return []
+
+ cached_entries: List[Dict[str, List[str]]] = []
+ processed_pairs = set()
+
+ for idx, msg in enumerate(messages):
+ msg_text = (
+ getattr(msg, "display_message", None) or getattr(msg, "processed_plain_text", None) or ""
+ ).strip()
+ if not msg_text or is_bot_message(msg):
+ continue
+
+ for content in self.cache.keys():
+ if not content:
+ continue
+ if (content, idx) in processed_pairs:
+ continue
+ if content in msg_text:
+ paragraph = build_context_paragraph(messages, idx)
+ if not paragraph:
+ continue
+ cached_entries.append({"content": content, "raw_content": [paragraph]})
+ processed_pairs.add((content, idx))
+
+ return cached_entries
async def _infer_meaning_by_id(self, jargon_id: int) -> None:
"""通过ID加载对象并推断"""
@@ -323,6 +272,7 @@ class JargonMiner:
prompt1 = await global_prompt_manager.format_prompt(
"jargon_inference_with_context_prompt",
content=content,
+ bot_name=global_config.bot.nickname,
raw_content_list=raw_content_text,
)
@@ -441,8 +391,8 @@ class JargonMiner:
# 是黑话，使用推断1的结果（基于上下文，更准确）
jargon_obj.meaning = inference1.get("meaning", "")
else:
- # 不是黑话，也记录含义（使用推断2的结果，因为含义明确）
- jargon_obj.meaning = inference2.get("meaning", "")
+ # 不是黑话，清空含义，不再存储任何内容
+ jargon_obj.meaning = ""
# 更新最后一次判定的count值，避免重启后重复判定
jargon_obj.last_inference_count = jargon_obj.count or 0
@@ -489,204 +439,265 @@ class JargonMiner:
return bool(recent_messages and len(recent_messages) >= self.min_messages_for_learning)
async def run_once(self) -> None:
- try:
- if not self.should_trigger():
- return
-
- chat_stream = get_chat_manager().get_stream(self.chat_id)
- if not chat_stream:
- return
-
- # 记录本次提取的时间窗口，避免重复提取
- extraction_start_time = self.last_learning_time
- extraction_end_time = time.time()
-
- # 拉取学习窗口内的消息
- messages = get_raw_msg_by_timestamp_with_chat_inclusive(
- chat_id=self.chat_id,
- timestamp_start=extraction_start_time,
- timestamp_end=extraction_end_time,
- limit=20,
- )
- if not messages:
- return
-
- chat_str: str = await build_anonymous_messages(messages)
- if not chat_str.strip():
- return
-
- prompt: str = await global_prompt_manager.format_prompt(
- "extract_jargon_prompt",
- chat_str=chat_str,
- )
-
- response, _ = await self.llm.generate_response_async(prompt, temperature=0.2)
- if not response:
- return
-
- if global_config.debug.show_jargon_prompt:
- logger.info(f"jargon提取提示词: {prompt}")
- logger.info(f"jargon提取结果: {response}")
-
- # 解析为JSON
- entries: List[dict] = []
+ # 使用异步锁防止并发执行
+ async with self._extraction_lock:
try:
- resp = response.strip()
- parsed = None
- if resp.startswith("[") and resp.endswith("]"):
- parsed = json.loads(resp)
- else:
- repaired = repair_json(resp)
- if isinstance(repaired, str):
- parsed = json.loads(repaired)
- else:
- parsed = repaired
-
- if isinstance(parsed, dict):
- parsed = [parsed]
-
- if not isinstance(parsed, list):
+ # 在锁内检查，避免并发触发
+ if not self.should_trigger():
return
- for item in parsed:
- if not isinstance(item, dict):
- continue
- content = str(item.get("content", "")).strip()
- raw_content_value = item.get("raw_content", "")
+ chat_stream = get_chat_manager().get_stream(self.chat_id)
+ if not chat_stream:
+ return
- # 处理raw_content：可能是字符串或列表
- raw_content_list = []
- if isinstance(raw_content_value, list):
- raw_content_list = [str(rc).strip() for rc in raw_content_value if str(rc).strip()]
- # 去重
- raw_content_list = list(dict.fromkeys(raw_content_list))
- elif isinstance(raw_content_value, str):
- raw_content_str = raw_content_value.strip()
- if raw_content_str:
- raw_content_list = [raw_content_str]
-
- if content and raw_content_list:
- if _contains_bot_self_name(content):
- logger.debug(f"解析阶段跳过包含机器人昵称/别名的词条: {content}")
- continue
- entries.append({"content": content, "raw_content": raw_content_list})
- except Exception as e:
- logger.error(f"解析jargon JSON失败: {e}; 原始: {response}")
- return
-
- if not entries:
- return
-
- # 去重并写入DB（按 chat_id + content 去重）
- # 使用content作为去重键
- seen = set()
- uniq_entries = []
- for entry in entries:
- content_key = entry["content"]
- if content_key not in seen:
- seen.add(content_key)
- uniq_entries.append(entry)
-
- saved = 0
- updated = 0
- for entry in uniq_entries:
- content = entry["content"]
- raw_content_list = entry["raw_content"] # 已经是列表
-
- # 检查并补充raw_content：如果只包含黑话本身，则获取前三条消息作为上下文
- raw_content_list = await _enrich_raw_content_if_needed(
- content=content,
- raw_content_list=raw_content_list,
- chat_id=self.chat_id,
- messages=messages,
- extraction_start_time=extraction_start_time,
- extraction_end_time=extraction_end_time,
- )
-
- try:
- # 根据all_global配置决定查询逻辑
- if global_config.jargon.all_global:
- # 开启all_global：无视chat_id，查询所有content匹配的记录（所有记录都是全局的）
- query = Jargon.select().where(Jargon.content == content)
- else:
- # 关闭all_global：只查询chat_id匹配的记录（不考虑is_global）
- query = Jargon.select().where((Jargon.chat_id == self.chat_id) & (Jargon.content == content))
-
- if query.exists():
- obj = query.get()
- try:
- obj.count = (obj.count or 0) + 1
- except Exception:
- obj.count = 1
-
- # 合并raw_content列表：读取现有列表，追加新值，去重
- existing_raw_content = []
- if obj.raw_content:
- try:
- existing_raw_content = (
- json.loads(obj.raw_content) if isinstance(obj.raw_content, str) else obj.raw_content
- )
- if not isinstance(existing_raw_content, list):
- existing_raw_content = [existing_raw_content] if existing_raw_content else []
- except (json.JSONDecodeError, TypeError):
- existing_raw_content = [obj.raw_content] if obj.raw_content else []
-
- # 合并并去重
- merged_list = list(dict.fromkeys(existing_raw_content + raw_content_list))
- obj.raw_content = json.dumps(merged_list, ensure_ascii=False)
-
- # 开启all_global时，确保记录标记为is_global=True
- if global_config.jargon.all_global:
- obj.is_global = True
- # 关闭all_global时，保持原有is_global不变（不修改）
-
- obj.save()
-
- # 检查是否需要推断（达到阈值且超过上次判定值）
- if _should_infer_meaning(obj):
- # 异步触发推断，不阻塞主流程
- # 重新加载对象以确保数据最新
- jargon_id = obj.id
- asyncio.create_task(self._infer_meaning_by_id(jargon_id))
-
- updated += 1
- else:
- # 没找到匹配记录，创建新记录
- if global_config.jargon.all_global:
- # 开启all_global：新记录默认为is_global=True
- is_global_new = True
- else:
- # 关闭all_global：新记录is_global=False
- is_global_new = False
-
- Jargon.create(
- content=content,
- raw_content=json.dumps(raw_content_list, ensure_ascii=False),
- chat_id=self.chat_id,
- is_global=is_global_new,
- count=1,
- )
- saved += 1
- except Exception as e:
- logger.error(f"保存jargon失败: chat_id={self.chat_id}, content={content}, err={e}")
- continue
-
- # 固定输出提取的jargon结果，格式化为可读形式（只要有提取结果就输出）
- if uniq_entries:
- # 收集所有提取的jargon内容
- jargon_list = [entry["content"] for entry in uniq_entries]
- jargon_str = ",".join(jargon_list)
-
- # 输出格式化的结果（使用logger.info会自动应用jargon模块的颜色）
- logger.info(f"[{self.stream_name}]疑似黑话: {jargon_str}")
-
- # 更新为本次提取的结束时间，确保不会重复提取相同的消息窗口
+ # 记录本次提取的时间窗口，避免重复提取
+ extraction_start_time = self.last_learning_time
+ extraction_end_time = time.time()
+
+ # 立即更新学习时间，防止并发触发
self.last_learning_time = extraction_end_time
- if saved or updated:
- logger.info(f"jargon写入: 新增 {saved} 条，更新 {updated} 条，chat_id={self.chat_id}")
- except Exception as e:
- logger.error(f"JargonMiner 运行失败: {e}")
+ # 拉取学习窗口内的消息
+ messages = get_raw_msg_by_timestamp_with_chat_inclusive(
+ chat_id=self.chat_id,
+ timestamp_start=extraction_start_time,
+ timestamp_end=extraction_end_time,
+ limit=20,
+ )
+ if not messages:
+ return
+
+ # 按时间排序，确保编号与上下文一致
+ messages = sorted(messages, key=lambda msg: msg.time or 0)
+
+ chat_str, message_id_list = build_readable_messages_with_id(
+ messages=messages,
+ replace_bot_name=True,
+ timestamp_mode="relative",
+ truncate=False,
+ show_actions=False,
+ show_pic=True,
+ pic_single=True,
+ )
+ if not chat_str.strip():
+ return
+
+ msg_id_to_index: Dict[str, int] = {}
+ for idx, (msg_id, _msg) in enumerate(message_id_list or []):
+ if not msg_id:
+ continue
+ msg_id_to_index[msg_id] = idx
+ if not msg_id_to_index:
+ logger.warning("未能生成消息ID映射，跳过本次提取")
+ return
+
+ prompt: str = await global_prompt_manager.format_prompt(
+ "extract_jargon_prompt",
+ bot_name=global_config.bot.nickname,
+ chat_str=chat_str,
+ )
+
+ response, _ = await self.llm.generate_response_async(prompt, temperature=0.2)
+ if not response:
+ return
+
+ if global_config.debug.show_jargon_prompt:
+ logger.info(f"jargon提取提示词: {prompt}")
+ logger.info(f"jargon提取结果: {response}")
+
+ # 解析为JSON
+ entries: List[dict] = []
+ try:
+ resp = response.strip()
+ parsed = None
+ if resp.startswith("[") and resp.endswith("]"):
+ parsed = json.loads(resp)
+ else:
+ repaired = repair_json(resp)
+ if isinstance(repaired, str):
+ parsed = json.loads(repaired)
+ else:
+ parsed = repaired
+
+ if isinstance(parsed, dict):
+ parsed = [parsed]
+
+ if not isinstance(parsed, list):
+ return
+
+ for item in parsed:
+ if not isinstance(item, dict):
+ continue
+
+ content = str(item.get("content", "")).strip()
+ msg_id_value = item.get("msg_id")
+
+ if not content:
+ continue
+
+ if contains_bot_self_name(content):
+ logger.info(f"解析阶段跳过包含机器人昵称/别名的词条: {content}")
+ continue
+
+ msg_id_str = str(msg_id_value or "").strip()
+ if not msg_id_str:
+ logger.warning(f"解析jargon失败：msg_id缺失，content={content}")
+ continue
+
+ msg_index = msg_id_to_index.get(msg_id_str)
+ if msg_index is None:
+ logger.warning(f"解析jargon失败：msg_id未找到，content={content}, msg_id={msg_id_str}")
+ continue
+
+ target_msg = messages[msg_index]
+ if is_bot_message(target_msg):
+ logger.info(f"解析阶段跳过引用机器人自身消息的词条: content={content}, msg_id={msg_id_str}")
+ continue
+
+ context_paragraph = build_context_paragraph(messages, msg_index)
+ if not context_paragraph:
+ logger.warning(f"解析jargon失败：上下文为空，content={content}, msg_id={msg_id_str}")
+ continue
+
+ entries.append({"content": content, "raw_content": [context_paragraph]})
+ cached_entries = self._collect_cached_entries(messages)
+ if cached_entries:
+ entries.extend(cached_entries)
+ except Exception as e:
+ logger.error(f"解析jargon JSON失败: {e}; 原始: {response}")
+ return
+
+ if not entries:
+ return
+
+ # 去重并合并raw_content（按 content 聚合）
+ merged_entries: OrderedDict[str, Dict[str, List[str]]] = OrderedDict()
+ for entry in entries:
+ content_key = entry["content"]
+ raw_list = entry.get("raw_content", []) or []
+ if content_key in merged_entries:
+ merged_entries[content_key]["raw_content"].extend(raw_list)
+ else:
+ merged_entries[content_key] = {
+ "content": content_key,
+ "raw_content": list(raw_list),
+ }
+
+ uniq_entries = []
+ for merged_entry in merged_entries.values():
+ raw_content_list = merged_entry["raw_content"]
+ if raw_content_list:
+ merged_entry["raw_content"] = list(dict.fromkeys(raw_content_list))
+ uniq_entries.append(merged_entry)
+
+ saved = 0
+ updated = 0
+ for entry in uniq_entries:
+ content = entry["content"]
+ raw_content_list = entry["raw_content"] # 已经是列表
+
+ try:
+ # 查询所有content匹配的记录
+ query = Jargon.select().where(Jargon.content == content)
+
+ # 查找匹配的记录
+ matched_obj = None
+ for obj in query:
+ if global_config.jargon.all_global:
+ # 开启all_global：所有content匹配的记录都可以
+ matched_obj = obj
+ break
+ else:
+ # 关闭all_global：需要检查chat_id列表是否包含目标chat_id
+ chat_id_list = parse_chat_id_list(obj.chat_id)
+ if chat_id_list_contains(chat_id_list, self.chat_id):
+ matched_obj = obj
+ break
+
+ if matched_obj:
+ obj = matched_obj
+ try:
+ obj.count = (obj.count or 0) + 1
+ except Exception:
+ obj.count = 1
+
+ # 合并raw_content列表：读取现有列表，追加新值，去重
+ existing_raw_content = []
+ if obj.raw_content:
+ try:
+ existing_raw_content = (
+ json.loads(obj.raw_content) if isinstance(obj.raw_content, str) else obj.raw_content
+ )
+ if not isinstance(existing_raw_content, list):
+ existing_raw_content = [existing_raw_content] if existing_raw_content else []
+ except (json.JSONDecodeError, TypeError):
+ existing_raw_content = [obj.raw_content] if obj.raw_content else []
+
+ # 合并并去重
+ merged_list = list(dict.fromkeys(existing_raw_content + raw_content_list))
+ obj.raw_content = json.dumps(merged_list, ensure_ascii=False)
+
+ # 更新chat_id列表：增加当前chat_id的计数
+ chat_id_list = parse_chat_id_list(obj.chat_id)
+ updated_chat_id_list = update_chat_id_list(chat_id_list, self.chat_id, increment=1)
+ obj.chat_id = json.dumps(updated_chat_id_list, ensure_ascii=False)
+
+ # 开启all_global时，确保记录标记为is_global=True
+ if global_config.jargon.all_global:
+ obj.is_global = True
+ # 关闭all_global时，保持原有is_global不变（不修改）
+
+ obj.save()
+
+ # 检查是否需要推断（达到阈值且超过上次判定值）
+ if _should_infer_meaning(obj):
+ # 异步触发推断，不阻塞主流程
+ # 重新加载对象以确保数据最新
+ jargon_id = obj.id
+ asyncio.create_task(self._infer_meaning_by_id(jargon_id))
+
+ updated += 1
+ else:
+ # 没找到匹配记录，创建新记录
+ if global_config.jargon.all_global:
+ # 开启all_global：新记录默认为is_global=True
+ is_global_new = True
+ else:
+ # 关闭all_global：新记录is_global=False
+ is_global_new = False
+
+ # 使用新格式创建chat_id列表：[[chat_id, count]]
+ chat_id_list = [[self.chat_id, 1]]
+ chat_id_json = json.dumps(chat_id_list, ensure_ascii=False)
+
+ Jargon.create(
+ content=content,
+ raw_content=json.dumps(raw_content_list, ensure_ascii=False),
+ chat_id=chat_id_json,
+ is_global=is_global_new,
+ count=1,
+ )
+ saved += 1
+ except Exception as e:
+ logger.error(f"保存jargon失败: chat_id={self.chat_id}, content={content}, err={e}")
+ continue
+ finally:
+ self._add_to_cache(content)
+
+ # 固定输出提取的jargon结果，格式化为可读形式（只要有提取结果就输出）
+ if uniq_entries:
+ # 收集所有提取的jargon内容
+ jargon_list = [entry["content"] for entry in uniq_entries]
+ jargon_str = ",".join(jargon_list)
+
+ # 输出格式化的结果（使用logger.info会自动应用jargon模块的颜色）
+ logger.info(f"[{self.stream_name}]疑似黑话: {jargon_str}")
+
+ if saved or updated:
+ logger.info(f"jargon写入: 新增 {saved} 条，更新 {updated} 条，chat_id={self.chat_id}")
+ except Exception as e:
+ logger.error(f"JargonMiner 运行失败: {e}")
+ # 即使失败也保持时间戳更新，避免频繁重试
class JargonMinerManager:
@@ -730,8 +741,8 @@ def search_jargon(
keyword = keyword.strip()
- # 构建查询
- query = Jargon.select(Jargon.content, Jargon.meaning)
+ # 构建查询（选择所有需要的字段，以便后续过滤）
+ query = Jargon.select()
# 构建搜索条件
if case_sensitive:
@@ -757,102 +768,34 @@ def search_jargon(
if global_config.jargon.all_global:
# 开启all_global：所有记录都是全局的，查询所有is_global=True的记录（无视chat_id）
query = query.where(Jargon.is_global)
- else:
- # 关闭all_global：如果提供了chat_id，优先搜索该聊天或global的jargon
- if chat_id:
- query = query.where((Jargon.chat_id == chat_id) | Jargon.is_global)
+ # 注意：对于all_global=False的情况，chat_id过滤在Python层面进行，以便兼容新旧格式
- # 只返回有meaning的记录
- query = query.where((Jargon.meaning.is_null(False)) & (Jargon.meaning != ""))
+ # 注意：meaning的过滤移到Python层面，因为我们需要先过滤chat_id
# 按count降序排序，优先返回出现频率高的
query = query.order_by(Jargon.count.desc())
- # 限制结果数量
- query = query.limit(limit)
+ # 限制结果数量（先多取一些，因为后面可能过滤）
+ query = query.limit(limit * 2)
- # 执行查询并返回结果
+ # 执行查询并返回结果，过滤chat_id
results = []
for jargon in query:
+ # 如果提供了chat_id且all_global=False，需要检查chat_id列表是否包含目标chat_id
+ if chat_id and not global_config.jargon.all_global:
+ chat_id_list = parse_chat_id_list(jargon.chat_id)
+ # 如果记录是is_global=True，或者chat_id列表包含目标chat_id，则包含
+ if not jargon.is_global and not chat_id_list_contains(chat_id_list, chat_id):
+ continue
+
+ # 只返回有meaning的记录
+ if not jargon.meaning or jargon.meaning.strip() == "":
+ continue
+
results.append({"content": jargon.content or "", "meaning": jargon.meaning or ""})
+ # 达到限制数量后停止
+ if len(results) >= limit:
+ break
+
return results
-
-
-async def store_jargon_from_answer(jargon_keyword: str, answer: str, chat_id: str) -> None:
- """将黑话存入jargon系统
-
- Args:
- jargon_keyword: 黑话关键词
- answer: 答案内容（将概括为raw_content）
- chat_id: 聊天ID
- """
- try:
- # 概括答案为简短的raw_content
- summary_prompt = f"""请将以下答案概括为一句简短的话（不超过50字），作为黑话"{jargon_keyword}"的使用示例：
-
-答案：{answer}
-
-只输出概括后的内容，不要输出其他内容："""
-
- success, summary, _, _ = await llm_api.generate_with_model(
- summary_prompt,
- model_config=model_config.model_task_config.utils_small,
- request_type="memory.summarize_jargon",
- )
-
- logger.info(f"概括答案提示: {summary_prompt}")
- logger.info(f"概括答案: {summary}")
-
- if not success:
- logger.warning(f"概括答案失败，使用原始答案: {summary}")
- summary = answer[:100] # 截取前100字符作为备用
-
- raw_content = summary.strip()[:200] # 限制长度
-
- # 检查是否已存在
- if global_config.jargon.all_global:
- query = Jargon.select().where(Jargon.content == jargon_keyword)
- else:
- query = Jargon.select().where((Jargon.chat_id == chat_id) & (Jargon.content == jargon_keyword))
-
- if query.exists():
- # 更新现有记录
- obj = query.get()
- obj.count = (obj.count or 0) + 1
-
- # 合并raw_content列表
- existing_raw_content = []
- if obj.raw_content:
- try:
- existing_raw_content = (
- json.loads(obj.raw_content) if isinstance(obj.raw_content, str) else obj.raw_content
- )
- if not isinstance(existing_raw_content, list):
- existing_raw_content = [existing_raw_content] if existing_raw_content else []
- except (json.JSONDecodeError, TypeError):
- existing_raw_content = [obj.raw_content] if obj.raw_content else []
-
- # 合并并去重
- merged_list = list(dict.fromkeys(existing_raw_content + [raw_content]))
- obj.raw_content = json.dumps(merged_list, ensure_ascii=False)
-
- if global_config.jargon.all_global:
- obj.is_global = True
-
- obj.save()
- logger.info(f"更新jargon记录: {jargon_keyword}")
- else:
- # 创建新记录
- is_global_new = True if global_config.jargon.all_global else False
- Jargon.create(
- content=jargon_keyword,
- raw_content=json.dumps([raw_content], ensure_ascii=False),
- chat_id=chat_id,
- is_global=is_global_new,
- count=1,
- )
- logger.info(f"创建新jargon记录: {jargon_keyword}")
-
- except Exception as e:
- logger.error(f"存储jargon失败: {e}")
diff --git a/src/jargon/jargon_utils.py b/src/jargon/jargon_utils.py
new file mode 100644
index 00000000..f42d807b
--- /dev/null
+++ b/src/jargon/jargon_utils.py
@@ -0,0 +1,195 @@
+import json
+from typing import List, Dict, Optional, Any
+
+from src.common.logger import get_logger
+from src.config.config import global_config
+from src.chat.utils.chat_message_builder import (
+ build_readable_messages,
+)
+from src.chat.utils.utils import parse_platform_accounts
+
+
+logger = get_logger("jargon")
+
+
+def parse_chat_id_list(chat_id_value: Any) -> List[List[Any]]:
+ """
+ 解析chat_id字段，兼容旧格式（字符串）和新格式（JSON列表）
+
+ Args:
+ chat_id_value: 可能是字符串（旧格式）或JSON字符串（新格式）
+
+ Returns:
+ List[List[Any]]: 格式为 [[chat_id, count], ...] 的列表
+ """
+ if not chat_id_value:
+ return []
+
+ # 如果是字符串，尝试解析为JSON
+ if isinstance(chat_id_value, str):
+ # 尝试解析JSON
+ try:
+ parsed = json.loads(chat_id_value)
+ if isinstance(parsed, list):
+ # 新格式：已经是列表
+ return parsed
+ elif isinstance(parsed, str):
+ # 解析后还是字符串，说明是旧格式
+ return [[parsed, 1]]
+ else:
+ # 其他类型，当作旧格式处理
+ return [[str(chat_id_value), 1]]
+ except (json.JSONDecodeError, TypeError):
+ # 解析失败，当作旧格式（纯字符串）
+ return [[str(chat_id_value), 1]]
+ elif isinstance(chat_id_value, list):
+ # 已经是列表格式
+ return chat_id_value
+ else:
+ # 其他类型，转换为旧格式
+ return [[str(chat_id_value), 1]]
+
+
+def update_chat_id_list(chat_id_list: List[List[Any]], target_chat_id: str, increment: int = 1) -> List[List[Any]]:
+ """
+ 更新chat_id列表，如果target_chat_id已存在则增加计数，否则添加新条目
+
+ Args:
+ chat_id_list: 当前的chat_id列表，格式为 [[chat_id, count], ...]
+ target_chat_id: 要更新或添加的chat_id
+ increment: 增加的计数，默认为1
+
+ Returns:
+ List[List[Any]]: 更新后的chat_id列表
+ """
+ # 查找是否已存在该chat_id
+ found = False
+ for item in chat_id_list:
+ if isinstance(item, list) and len(item) >= 1 and str(item[0]) == str(target_chat_id):
+ # 找到匹配的chat_id，增加计数
+ if len(item) >= 2:
+ item[1] = (item[1] if isinstance(item[1], (int, float)) else 0) + increment
+ else:
+ item.append(increment)
+ found = True
+ break
+
+ if not found:
+ # 未找到，添加新条目
+ chat_id_list.append([target_chat_id, increment])
+
+ return chat_id_list
+
+
+def chat_id_list_contains(chat_id_list: List[List[Any]], target_chat_id: str) -> bool:
+ """
+ 检查chat_id列表中是否包含指定的chat_id
+
+ Args:
+ chat_id_list: chat_id列表，格式为 [[chat_id, count], ...]
+ target_chat_id: 要查找的chat_id
+
+ Returns:
+ bool: 如果包含则返回True
+ """
+ for item in chat_id_list:
+ if isinstance(item, list) and len(item) >= 1 and str(item[0]) == str(target_chat_id):
+ return True
+ return False
+
+
+def contains_bot_self_name(content: str) -> bool:
+ """
+ 判断词条是否包含机器人的昵称或别名
+ """
+ if not content:
+ return False
+
+ bot_config = getattr(global_config, "bot", None)
+ if not bot_config:
+ return False
+
+ target = content.strip().lower()
+ nickname = str(getattr(bot_config, "nickname", "") or "").strip().lower()
+ alias_names = [str(alias or "").strip().lower() for alias in getattr(bot_config, "alias_names", []) or []]
+
+ candidates = [name for name in [nickname, *alias_names] if name]
+
+ return any(name in target for name in candidates if target)
+
+
+def build_context_paragraph(messages: List[Any], center_index: int) -> Optional[str]:
+ """
+ 构建包含中心消息上下文的段落（前3条+后3条），使用标准的 readable builder 输出
+ """
+ if not messages or center_index < 0 or center_index >= len(messages):
+ return None
+
+ context_start = max(0, center_index - 3)
+ context_end = min(len(messages), center_index + 1 + 3)
+ context_messages = messages[context_start:context_end]
+
+ if not context_messages:
+ return None
+
+ try:
+ paragraph = build_readable_messages(
+ messages=context_messages,
+ replace_bot_name=True,
+ timestamp_mode="relative",
+ read_mark=0.0,
+ truncate=False,
+ show_actions=False,
+ show_pic=True,
+ message_id_list=None,
+ remove_emoji_stickers=False,
+ pic_single=True,
+ )
+ except Exception as e:
+ logger.warning(f"构建上下文段落失败: {e}")
+ return None
+
+ paragraph = paragraph.strip()
+ return paragraph or None
+
+
+def is_bot_message(msg: Any) -> bool:
+ """判断消息是否来自机器人自身"""
+ if msg is None:
+ return False
+
+ bot_config = getattr(global_config, "bot", None)
+ if not bot_config:
+ return False
+
+ platform = (
+ str(getattr(msg, "user_platform", "") or getattr(getattr(msg, "user_info", None), "platform", "") or "")
+ .strip()
+ .lower()
+ )
+ user_id = str(getattr(msg, "user_id", "") or getattr(getattr(msg, "user_info", None), "user_id", "") or "").strip()
+
+ if not platform or not user_id:
+ return False
+
+ platform_accounts = {}
+ try:
+ platform_accounts = parse_platform_accounts(getattr(bot_config, "platforms", []) or [])
+ except Exception:
+ platform_accounts = {}
+
+ bot_accounts: Dict[str, str] = {}
+ qq_account = str(getattr(bot_config, "qq_account", "") or "").strip()
+ if qq_account:
+ bot_accounts["qq"] = qq_account
+
+ telegram_account = str(getattr(bot_config, "telegram_account", "") or "").strip()
+ if telegram_account:
+ bot_accounts["telegram"] = telegram_account
+
+ for plat, account in platform_accounts.items():
+ if account and plat not in bot_accounts:
+ bot_accounts[plat] = account
+
+ bot_account = bot_accounts.get(platform)
+ return bool(bot_account and user_id == bot_account)
diff --git a/src/llm_models/exceptions.py b/src/llm_models/exceptions.py
index 65e49f74..25452e0b 100644
--- a/src/llm_models/exceptions.py
+++ b/src/llm_models/exceptions.py
@@ -18,11 +18,12 @@ error_code_mapping = {
class NetworkConnectionError(Exception):
"""连接异常，常见于网络问题或服务器不可用"""
- def __init__(self):
- super().__init__()
+ def __init__(self, message: str | None = None):
+ super().__init__(message)
+ self.message = message
def __str__(self):
- return "连接异常，请检查网络连接状态或URL是否正确"
+ return self.message or "连接异常，请检查网络连接状态或URL是否正确"
class ReqAbortException(Exception):
diff --git a/src/llm_models/utils_model.py b/src/llm_models/utils_model.py
index 1ed74e03..44ff2de3 100644
--- a/src/llm_models/utils_model.py
+++ b/src/llm_models/utils_model.py
@@ -47,6 +47,21 @@ class LLMRequest:
}
"""模型使用量记录，用于进行负载均衡，对应为(total_tokens, penalty, usage_penalty)，惩罚值是为了能在某个模型请求不给力或正在被使用的时候进行调整"""
+ def _check_slow_request(self, time_cost: float, model_name: str) -> None:
+ """检查请求是否过慢并输出警告日志
+
+ Args:
+ time_cost: 请求耗时（秒）
+ model_name: 使用的模型名称
+ """
+ threshold = self.model_for_task.slow_threshold
+ if time_cost > threshold:
+ request_type_display = self.request_type or "未知任务"
+ logger.warning(
+ f"LLM请求耗时过长: {request_type_display} 使用模型 {model_name} 耗时 {time_cost:.1f}s（阈值: {threshold}s），请考虑使用更快的模型\n"
+ f" 如果你认为该警告出现得过于频繁，请调整model_config.toml中对应任务的slow_threshold至符合你实际情况的合理值"
+ )
+
async def generate_response_for_image(
self,
prompt: str,
@@ -86,6 +101,8 @@ class LLMRequest:
if not reasoning_content and content:
content, extracted_reasoning = self._extract_reasoning(content)
reasoning_content = extracted_reasoning
+ time_cost = time.time() - start_time
+ self._check_slow_request(time_cost, model_info.name)
if usage := response.usage:
llm_usage_recorder.record_usage_to_database(
model_info=model_info,
@@ -93,7 +110,7 @@ class LLMRequest:
user_id="system",
request_type=self.request_type,
endpoint="/chat/completions",
- time_cost=time.time() - start_time,
+ time_cost=time_cost,
)
return content, (reasoning_content, model_info.name, tool_calls)
@@ -198,7 +215,8 @@ class LLMRequest:
tool_options=tool_built,
)
- logger.debug(f"LLM请求总耗时: {time.time() - start_time}")
+ time_cost = time.time() - start_time
+ logger.debug(f"LLM请求总耗时: {time_cost}")
logger.debug(f"LLM生成内容: {response}")
content = response.content
@@ -207,6 +225,7 @@ class LLMRequest:
if not reasoning_content and content:
content, extracted_reasoning = self._extract_reasoning(content)
reasoning_content = extracted_reasoning
+ self._check_slow_request(time_cost, model_info.name)
if usage := response.usage:
llm_usage_recorder.record_usage_to_database(
model_info=model_info,
@@ -214,7 +233,7 @@ class LLMRequest:
user_id="system",
request_type=self.request_type,
endpoint="/chat/completions",
- time_cost=time.time() - start_time,
+ time_cost=time_cost,
)
return content or "", (reasoning_content, model_info.name, tool_calls)
@@ -301,7 +320,7 @@ class LLMRequest:
message_list=(compressed_messages or message_list),
tool_options=tool_options,
max_tokens=self.model_for_task.max_tokens if max_tokens is None else max_tokens,
- temperature=self.model_for_task.temperature if temperature is None else temperature,
+ temperature=temperature if temperature is not None else (model_info.extra_params or {}).get("temperature", self.model_for_task.temperature),
response_format=response_format,
stream_response_handler=stream_response_handler,
async_response_parser=async_response_parser,
@@ -323,34 +342,45 @@ class LLMRequest:
)
except EmptyResponseException as e:
# 空回复：通常为临时问题，单独记录并重试
+ original_error_info = self._get_original_error_info(e)
retry_remain -= 1
if retry_remain <= 0:
- logger.error(f"模型 '{model_info.name}' 在多次出现空回复后仍然失败。")
+ logger.error(f"模型 '{model_info.name}' 在多次出现空回复后仍然失败。{original_error_info}")
raise ModelAttemptFailed(f"模型 '{model_info.name}' 重试耗尽", original_exception=e) from e
- logger.warning(f"模型 '{model_info.name}' 返回空回复(可重试)。剩余重试次数: {retry_remain}")
+ logger.warning(f"模型 '{model_info.name}' 返回空回复(可重试){original_error_info}。剩余重试次数: {retry_remain}")
await asyncio.sleep(api_provider.retry_interval)
except NetworkConnectionError as e:
# 网络错误：单独记录并重试
+ # 尝试从链式异常中获取原始错误信息以诊断具体原因
+ original_error_info = self._get_original_error_info(e)
+
retry_remain -= 1
if retry_remain <= 0:
- logger.error(f"模型 '{model_info.name}' 在网络错误重试用尽后仍然失败。")
+ logger.error(f"模型 '{model_info.name}' 在网络错误重试用尽后仍然失败。{original_error_info}")
raise ModelAttemptFailed(f"模型 '{model_info.name}' 重试耗尽", original_exception=e) from e
- logger.warning(f"模型 '{model_info.name}' 遇到网络错误(可重试): {str(e)}。剩余重试次数: {retry_remain}")
+ logger.warning(
+ f"模型 '{model_info.name}' 遇到网络错误(可重试): {str(e)}{original_error_info}\n"
+ f" 常见原因: 如请求的API正常但APITimeoutError类型错误过多，请尝试调整模型配置中对应API Provider的timeout值\n"
+ f" 其它可能原因: 网络波动、DNS 故障、连接超时、防火墙限制或代理问题\n"
+ f" 剩余重试次数: {retry_remain}"
+ )
await asyncio.sleep(api_provider.retry_interval)
except RespNotOkException as e:
+ original_error_info = self._get_original_error_info(e)
+
# 可重试的HTTP错误
if e.status_code == 429 or e.status_code >= 500:
retry_remain -= 1
if retry_remain <= 0:
- logger.error(f"模型 '{model_info.name}' 在遇到 {e.status_code} 错误并用尽重试次数后仍然失败。")
+ logger.error(f"模型 '{model_info.name}' 在遇到 {e.status_code} 错误并用尽重试次数后仍然失败。{original_error_info}")
raise ModelAttemptFailed(f"模型 '{model_info.name}' 重试耗尽", original_exception=e) from e
logger.warning(
- f"模型 '{model_info.name}' 遇到可重试的HTTP错误: {str(e)}。剩余重试次数: {retry_remain}"
+ f"模型 '{model_info.name}' 遇到可重试的HTTP错误: {str(e)}{original_error_info}。剩余重试次数: {retry_remain}"
)
await asyncio.sleep(api_provider.retry_interval)
continue
@@ -363,13 +393,15 @@ class LLMRequest:
continue
# 不可重试的HTTP错误
- logger.warning(f"模型 '{model_info.name}' 遇到不可重试的HTTP错误: {str(e)}")
+ logger.warning(f"模型 '{model_info.name}' 遇到不可重试的HTTP错误: {str(e)}{original_error_info}")
raise ModelAttemptFailed(f"模型 '{model_info.name}' 遇到硬错误", original_exception=e) from e
except Exception as e:
logger.error(traceback.format_exc())
- logger.warning(f"模型 '{model_info.name}' 遇到未知的不可重试错误: {str(e)}")
+ original_error_info = self._get_original_error_info(e)
+
+ logger.warning(f"模型 '{model_info.name}' 遇到未知的不可重试错误: {str(e)}{original_error_info}")
raise ModelAttemptFailed(f"模型 '{model_info.name}' 遇到硬错误", original_exception=e) from e
raise ModelAttemptFailed(f"模型 '{model_info.name}' 未被尝试，因为重试次数已配置为0或更少。")
@@ -483,3 +515,14 @@ class LLMRequest:
content = re.sub(r"(?:)?.*?", "", content, flags=re.DOTALL, count=1).strip()
reasoning = match[1].strip() if match else ""
return content, reasoning
+
+ @staticmethod
+ def _get_original_error_info(e: Exception) -> str:
+ """获取原始错误信息"""
+ if e.__cause__:
+ original_error_type = type(e.__cause__).__name__
+ original_error_msg = str(e.__cause__)
+ return (
+ f"\n 底层异常类型: {original_error_type}\n 底层异常信息: {original_error_msg}"
+ )
+ return ""
diff --git a/src/main.py b/src/main.py
index 09ead248..3bcc9695 100644
--- a/src/main.py
+++ b/src/main.py
@@ -56,7 +56,7 @@ class MainSystem:
from src.webui.webui_server import get_webui_server
self.webui_server = get_webui_server()
-
+
if webui_mode == "development":
logger.info("📝 WebUI 开发模式已启用")
logger.info("🌐 后端 API 将运行在 http://0.0.0.0:8001")
@@ -64,9 +64,9 @@ class MainSystem:
logger.info("💡 前端将运行在 http://localhost:7999")
else:
logger.info("✅ WebUI 生产模式已启用")
- logger.info(f"🌐 WebUI 将运行在 http://0.0.0.0:8001")
+ logger.info("🌐 WebUI 将运行在 http://0.0.0.0:8001")
logger.info("💡 请确保已构建前端: cd MaiBot-Dashboard && bun run build")
-
+
except Exception as e:
logger.error(f"❌ 初始化 WebUI 服务器失败: {e}")
@@ -156,7 +156,7 @@ class MainSystem:
async def schedule_tasks(self):
"""调度定时任务"""
- while True:
+ try:
tasks = [
get_emoji_manager().start_periodic_check_register(),
self.app.run(),
@@ -168,6 +168,9 @@ class MainSystem:
tasks.append(self.webui_server.start())
await asyncio.gather(*tasks)
+ except asyncio.CancelledError:
+ logger.info("调度任务已取消")
+ raise
# async def forget_memory_task(self):
# """记忆遗忘任务"""
diff --git a/src/memory_system/memory_retrieval.py b/src/memory_system/memory_retrieval.py
index 7d129bbc..2471c8fa 100644
--- a/src/memory_system/memory_retrieval.py
+++ b/src/memory_system/memory_retrieval.py
@@ -1,18 +1,16 @@
import time
import json
-import re
-import random
import asyncio
-from typing import List, Dict, Any, Optional, Tuple
+from typing import List, Dict, Any, Optional, Tuple, Set
from src.common.logger import get_logger
from src.config.config import global_config, model_config
from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
from src.plugin_system.apis import llm_api
from src.common.database.database_model import ThinkingBack
-from json_repair import repair_json
from src.memory_system.retrieval_tools import get_tool_registry, init_all_tools
-from src.memory_system.retrieval_tools.query_lpmm_knowledge import query_lpmm_knowledge
+from src.memory_system.memory_utils import parse_questions_json
from src.llm_models.payload_content.message import MessageBuilder, RoleType, Message
+from src.jargon.jargon_explainer import match_jargon_from_text, retrieve_concepts_with_jargon
logger = get_logger("memory_retrieval")
@@ -63,27 +61,25 @@ def init_memory_retrieval_prompt():
2. 是否有需要回忆的内容（比如"之前说过"、"上次"、"以前"等）
3. 是否有需要查找历史信息的问题
4. 是否有问题可以搜集信息帮助你聊天
-5. 对话中是否包含黑话、俚语、缩写等可能需要查询的概念
重要提示：
- **每次只能提出一个问题**，选择最需要查询的关键问题
- 如果"最近已查询的问题和结果"中已经包含了类似的问题并得到了答案，请避免重复生成相同或相似的问题，不需要重复查询
- 如果之前已经查询过某个问题但未找到答案，可以尝试用不同的方式提问或更具体的问题
-如果你认为需要从记忆中检索信息来回答，请：
-1. 识别对话中可能需要查询的概念（黑话/俚语/缩写/专有名词等关键词），放入"concepts"字段
-2. 根据上下文提出**一个**最关键的问题来帮助你回复目标消息，放入"questions"字段
+如果你认为需要从记忆中检索信息来回答，请根据上下文提出**一个**最关键的问题来帮助你回复目标消息，放入"questions"字段
问题格式示例：
- "xxx在前几天干了什么"
-- "xxx是什么"
+- "xxx是什么，在什么时候提到过?"
- "xxxx和xxx的关系是什么"
- "xxx在某个时间点发生了什么"
+问题要说明前因后果和上下文，使其全面且精准
+
输出格式示例（需要检索时）：
```json
{{
- "concepts": ["AAA", "BBB", "CCC"], #需要检索的概念列表（字符串数组），如果不需要检索概念则输出空数组[]
"questions": ["张三在前几天干了什么"] #问题数组（字符串数组），如果不需要检索记忆则输出空数组[]，如果需要检索则只输出包含一个问题的数组
}}
```
@@ -91,7 +87,6 @@ def init_memory_retrieval_prompt():
输出格式示例（不需要检索时）：
```json
{{
- "concepts": [],
"questions": []
}}
```
@@ -105,36 +100,21 @@ def init_memory_retrieval_prompt():
Prompt(
"""你的名字是{bot_name}。现在是{time_now}。
你正在参与聊天，你需要搜集信息来回答问题，帮助你参与聊天。
-
-**重要限制：**
-- 最大查询轮数：{max_iterations}轮（当前第{current_iteration}轮，剩余{remaining_iterations}轮）
-- 必须尽快得出答案，避免不必要的查询
-- 思考要简短，直接切入要点
-- 必须严格使用检索到的信息回答问题，不要编造信息
-
-当前问题：{question}
+当前需要解答的问题：{question}
已收集的信息：
{collected_info}
**执行步骤：**
-**第一步：思考（Think）**
-在思考中分析：
-- 当前信息是否足够回答问题？
-- **如果信息足够且能找到明确答案**，在思考中直接给出答案，格式为：found_answer(answer="你的答案内容")
-- **如果需要尝试搜集更多信息，进一步调用工具，进入第二步行动环节
-- **如果已有信息不足或无法找到答案**，在思考中给出：not_enough_info(reason="信息不足或无法找到答案的原因")
-
-**第二步：行动（Action）**
-- 如果涉及过往事件，可以使用聊天记录查询工具查询过往事件
-- 如果涉及概念，可以用jargon查询，或根据关键词检索聊天记录
+- 如果涉及过往事件，或者查询某个过去可能提到过的概念，或者某段时间发生的事件。可以使用聊天记录查询工具查询过往事件
- 如果涉及人物，可以使用人物信息查询工具查询人物信息
-- 如果不确定查询类别，也可以使用lpmm知识库查询
-- 如果信息不足且需要继续查询，说明最需要查询什么，并输出为纯文本说明，然后调用相应工具查询（可并行调用多个工具）
+- 如果没有可靠信息，且查询时间充足，或者不确定查询类别，也可以使用lpmm知识库查询，作为辅助信息
+- **如果信息不足需要使用tool，说明需要查询什么，并输出为纯文本说明，然后调用相应工具查询（可并行调用多个工具）**
+- **如果当前已收集的信息足够回答问题，且能找到明确答案，调用found_answer工具标记已找到答案**
-**重要规则：**
-- **只有在检索到明确、有关的信息并得出答案时，才使用found_answer**
-- **如果信息不足、无法确定、找不到相关信息，必须使用not_enough_info，不要使用found_answer**
-- 答案必须在思考中给出，格式为 found_answer(answer="...") 或 not_enough_info(reason="...")
+**思考**
+- 你可以对查询思路给出简短的思考：思考要简短，直接切入要点
+- 如果信息不足，你必须给出使用什么工具进行查询
+- 如果信息足够，你必须调用found_answer工具
""",
name="memory_retrieval_react_prompt_head",
)
@@ -166,122 +146,83 @@ def init_memory_retrieval_prompt():
)
-def _parse_react_response(response: str) -> Optional[Dict[str, Any]]:
- """解析ReAct Agent的响应
+
+
+def _log_conversation_messages(
+ conversation_messages: List[Message],
+ head_prompt: Optional[str] = None,
+ final_status: Optional[str] = None,
+) -> None:
+ """输出对话消息列表的日志
Args:
- response: LLM返回的响应
-
- Returns:
- Dict[str, Any]: 解析后的动作信息，如果解析失败返回None
- 格式: {"thought": str, "actions": List[Dict[str, Any]]}
- 每个action格式: {"action_type": str, "action_params": dict}
+ conversation_messages: 对话消息列表
+ head_prompt: 第一条系统消息（head_prompt）的内容，可选
+ final_status: 最终结果状态描述（例如：找到答案/未找到答案），可选
"""
- try:
- # 尝试提取JSON（可能包含在```json代码块中）
- json_pattern = r"```json\s*(.*?)\s*```"
- matches = re.findall(json_pattern, response, re.DOTALL)
+ if not global_config.debug.show_memory_prompt:
+ return
- if matches:
- json_str = matches[0]
+ log_lines: List[str] = []
+
+ # 如果有head_prompt，先添加为第一条消息
+ if head_prompt:
+ msg_info = "========================================\n[消息 1] 角色: System 内容类型: 文本\n-----------------------------"
+ msg_info += f"\n{head_prompt}"
+ log_lines.append(msg_info)
+ start_idx = 2
+ else:
+ start_idx = 1
+
+ if not conversation_messages and not head_prompt:
+ return
+
+ for idx, msg in enumerate(conversation_messages, start_idx):
+ role_name = msg.role.value if hasattr(msg.role, "value") else str(msg.role)
+
+ # 处理内容 - 显示完整内容，不截断
+ if isinstance(msg.content, str):
+ full_content = msg.content
+ content_type = "文本"
+ elif isinstance(msg.content, list):
+ text_parts = [item for item in msg.content if isinstance(item, str)]
+ image_count = len([item for item in msg.content if isinstance(item, tuple)])
+ full_content = "".join(text_parts) if text_parts else ""
+ content_type = f"混合({len(text_parts)}段文本, {image_count}张图片)"
else:
- # 尝试直接解析整个响应
- json_str = response.strip()
+ full_content = str(msg.content)
+ content_type = "未知"
- # 修复可能的JSON错误
- repaired_json = repair_json(json_str)
+ # 构建单条消息的日志信息
+ msg_info = f"\n========================================\n[消息 {idx}] 角色: {role_name} 内容类型: {content_type}\n-----------------------------"
- # 解析JSON
- action_info = json.loads(repaired_json)
+ if full_content:
+ msg_info += f"\n{full_content}"
- if not isinstance(action_info, dict):
- logger.warning(f"解析的JSON不是对象格式: {action_info}")
- return None
+ if msg.tool_calls:
+ msg_info += f"\n 工具调用: {len(msg.tool_calls)}个"
+ for tool_call in msg.tool_calls:
+ msg_info += f"\n - {tool_call}"
- # 确保actions字段存在且为列表
- if "actions" not in action_info:
- logger.warning(f"响应中缺少actions字段: {action_info}")
- return None
+ if msg.tool_call_id:
+ msg_info += f"\n 工具调用ID: {msg.tool_call_id}"
- if not isinstance(action_info["actions"], list):
- logger.warning(f"actions字段不是数组格式: {action_info['actions']}")
- return None
+ log_lines.append(msg_info)
- # 确保actions不为空
- if len(action_info["actions"]) == 0:
- logger.warning("actions数组为空")
- return None
-
- return action_info
-
- except Exception as e:
- logger.error(f"解析ReAct响应失败: {e}, 响应内容: {response[:200]}...")
- return None
-
-
-async def _retrieve_concepts_with_jargon(concepts: List[str], chat_id: str) -> str:
- """对概念列表进行jargon检索
-
- Args:
- concepts: 概念列表
- chat_id: 聊天ID
-
- Returns:
- str: 检索结果字符串
- """
- if not concepts:
- return ""
-
- from src.jargon.jargon_miner import search_jargon
-
- results = []
- for concept in concepts:
- concept = concept.strip()
- if not concept:
- continue
-
- # 先尝试精确匹配
- jargon_results = search_jargon(keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=False)
-
- is_fuzzy_match = False
-
- # 如果精确匹配未找到，尝试模糊搜索
- if not jargon_results:
- jargon_results = search_jargon(keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=True)
- is_fuzzy_match = True
-
- if jargon_results:
- # 找到结果
- if is_fuzzy_match:
- # 模糊匹配
- output_parts = [f"未精确匹配到'{concept}'"]
- for result in jargon_results:
- found_content = result.get("content", "").strip()
- meaning = result.get("meaning", "").strip()
- if found_content and meaning:
- output_parts.append(f"找到 '{found_content}' 的含义为：{meaning}")
- results.append("，".join(output_parts))
- logger.info(f"在jargon库中找到匹配（模糊搜索）: {concept}，找到{len(jargon_results)}条结果")
- else:
- # 精确匹配
- output_parts = []
- for result in jargon_results:
- meaning = result.get("meaning", "").strip()
- if meaning:
- output_parts.append(f"'{concept}' 为黑话或者网络简写，含义为：{meaning}")
- results.append("；".join(output_parts) if len(output_parts) > 1 else output_parts[0])
- logger.info(f"在jargon库中找到匹配（精确匹配）: {concept}，找到{len(jargon_results)}条结果")
- else:
- # 未找到，不返回占位信息，只记录日志
- logger.info(f"在jargon库中未找到匹配: {concept}")
-
- if results:
- return "【概念检索结果】\n" + "\n".join(results) + "\n"
- return ""
+ total_count = len(conversation_messages) + (1 if head_prompt else 0)
+ log_text = f"消息列表 (共{total_count}条):{''.join(log_lines)}"
+ if final_status:
+ log_text += f"\n\n[最终结果] {final_status}"
+ logger.info(log_text)
async def _react_agent_solve_question(
- question: str, chat_id: str, max_iterations: int = 5, timeout: float = 30.0, initial_info: str = ""
+ question: str,
+ chat_id: str,
+ max_iterations: int = 5,
+ timeout: float = 30.0,
+ initial_info: str = "",
+ initial_jargon_concepts: Optional[List[str]] = None,
) -> Tuple[bool, str, List[Dict[str, Any]], bool]:
"""使用ReAct架构的Agent来解决问题
@@ -291,15 +232,24 @@ async def _react_agent_solve_question(
max_iterations: 最大迭代次数
timeout: 超时时间（秒）
initial_info: 初始信息（如概念检索结果），将作为collected_info的初始值
+ initial_jargon_concepts: 预先已解析过的黑话列表，避免重复解释
Returns:
Tuple[bool, str, List[Dict[str, Any]], bool]: (是否找到答案, 答案内容, 思考步骤列表, 是否超时)
"""
start_time = time.time()
collected_info = initial_info if initial_info else ""
+ enable_jargon_detection = global_config.memory.enable_jargon_detection
+ seen_jargon_concepts: Set[str] = set()
+ if enable_jargon_detection and initial_jargon_concepts:
+ for concept in initial_jargon_concepts:
+ concept = (concept or "").strip()
+ if concept:
+ seen_jargon_concepts.add(concept)
thinking_steps = []
is_timeout = False
conversation_messages: List[Message] = []
+ first_head_prompt: Optional[str] = None # 保存第一次使用的head_prompt（用于日志显示）
for iteration in range(max_iterations):
# 检查超时
@@ -322,144 +272,7 @@ async def _react_agent_solve_question(
remaining_iterations = max_iterations - current_iteration
is_final_iteration = current_iteration >= max_iterations
- if is_final_iteration:
- # 最后一次迭代，使用最终prompt
- tool_definitions = []
- logger.info(
- f"ReAct Agent 第 {iteration + 1} 次迭代，问题: {question}|可用工具数量: 0（最后一次迭代，不提供工具调用）"
- )
-
- prompt = await global_prompt_manager.format_prompt(
- "memory_retrieval_react_final_prompt",
- bot_name=bot_name,
- time_now=time_now,
- question=question,
- collected_info=collected_info if collected_info else "暂无信息",
- current_iteration=current_iteration,
- remaining_iterations=remaining_iterations,
- max_iterations=max_iterations,
- )
-
- if global_config.debug.show_memory_prompt:
- logger.info(f"ReAct Agent 第 {iteration + 1} 次Prompt: {prompt}")
- success, response, reasoning_content, model_name, tool_calls = await llm_api.generate_with_model_with_tools(
- prompt,
- model_config=model_config.model_task_config.tool_use,
- tool_options=tool_definitions,
- request_type="memory.react",
- )
- else:
- # 非最终迭代，使用head_prompt
- tool_definitions = tool_registry.get_tool_definitions()
- logger.info(
- f"ReAct Agent 第 {iteration + 1} 次迭代，问题: {question}|可用工具数量: {len(tool_definitions)}"
- )
-
- head_prompt = await global_prompt_manager.format_prompt(
- "memory_retrieval_react_prompt_head",
- bot_name=bot_name,
- time_now=time_now,
- question=question,
- collected_info=collected_info if collected_info else "",
- current_iteration=current_iteration,
- remaining_iterations=remaining_iterations,
- max_iterations=max_iterations,
- )
-
- def message_factory(
- _client,
- *,
- _head_prompt: str = head_prompt,
- _conversation_messages: List[Message] = conversation_messages,
- ) -> List[Message]:
- messages: List[Message] = []
-
- system_builder = MessageBuilder()
- system_builder.set_role(RoleType.System)
- system_builder.add_text_content(_head_prompt)
- messages.append(system_builder.build())
-
- messages.extend(_conversation_messages)
-
- if global_config.debug.show_memory_prompt:
- # 优化日志展示 - 合并所有消息到一条日志
- log_lines = []
- for idx, msg in enumerate(messages, 1):
- role_name = msg.role.value if hasattr(msg.role, "value") else str(msg.role)
-
- # 处理内容 - 显示完整内容，不截断
- if isinstance(msg.content, str):
- full_content = msg.content
- content_type = "文本"
- elif isinstance(msg.content, list):
- text_parts = [item for item in msg.content if isinstance(item, str)]
- image_count = len([item for item in msg.content if isinstance(item, tuple)])
- full_content = "".join(text_parts) if text_parts else ""
- content_type = f"混合({len(text_parts)}段文本, {image_count}张图片)"
- else:
- full_content = str(msg.content)
- content_type = "未知"
-
- # 构建单条消息的日志信息
- msg_info = f"\n[消息 {idx}] 角色: {role_name} 内容类型: {content_type}\n========================================"
-
- if full_content:
- msg_info += f"\n{full_content}"
-
- if msg.tool_calls:
- msg_info += f"\n 工具调用: {len(msg.tool_calls)}个"
- for tool_call in msg.tool_calls:
- msg_info += f"\n - {tool_call}"
-
- if msg.tool_call_id:
- msg_info += f"\n 工具调用ID: {msg.tool_call_id}"
-
- log_lines.append(msg_info)
-
- # 合并所有消息为一条日志输出
- logger.info(f"消息列表 (共{len(messages)}条):{''.join(log_lines)}")
-
- return messages
-
- (
- success,
- response,
- reasoning_content,
- model_name,
- tool_calls,
- ) = await llm_api.generate_with_model_with_tools_by_message_factory(
- message_factory,
- model_config=model_config.model_task_config.tool_use,
- tool_options=tool_definitions,
- request_type="memory.react",
- )
-
- logger.info(
- f"ReAct Agent 第 {iteration + 1} 次迭代 模型: {model_name} ，调用工具数量: {len(tool_calls) if tool_calls else 0} ，调用工具响应: {response}"
- )
-
- if not success:
- logger.error(f"ReAct Agent LLM调用失败: {response}")
- break
-
- assistant_message: Optional[Message] = None
- if tool_calls:
- assistant_builder = MessageBuilder()
- assistant_builder.set_role(RoleType.Assistant)
- if response and response.strip():
- assistant_builder.add_text_content(response)
- assistant_builder.set_tool_calls(tool_calls)
- assistant_message = assistant_builder.build()
- elif response and response.strip():
- assistant_builder = MessageBuilder()
- assistant_builder.set_role(RoleType.Assistant)
- assistant_builder.add_text_content(response)
- assistant_message = assistant_builder.build()
-
- # 记录思考步骤
- step = {"iteration": iteration + 1, "thought": response, "actions": [], "observations": []}
-
- # 优先从思考内容中提取found_answer或not_enough_info
+ # 提取函数调用中参数的值，支持单引号和双引号
def extract_quoted_content(text, func_name, param_name):
"""从文本中提取函数调用中参数的值，支持单引号和双引号
@@ -517,45 +330,189 @@ async def _react_agent_solve_question(
return None
- # 从LLM的直接输出内容中提取found_answer或not_enough_info
- found_answer_content = None
- not_enough_info_reason = None
-
- # 只检查response（LLM的直接输出内容），不检查reasoning_content
- if response:
- found_answer_content = extract_quoted_content(response, "found_answer", "answer")
- if not found_answer_content:
- not_enough_info_reason = extract_quoted_content(response, "not_enough_info", "reason")
-
- # 如果从输出内容中找到了答案，直接返回
- if found_answer_content:
- step["actions"].append({"action_type": "found_answer", "action_params": {"answer": found_answer_content}})
- step["observations"] = ["从LLM输出内容中检测到found_answer"]
- thinking_steps.append(step)
- logger.info(
- f"ReAct Agent 第 {iteration + 1} 次迭代 从LLM输出内容中检测到found_answer: {found_answer_content[:100]}..."
- )
- return True, found_answer_content, thinking_steps, False
-
- if not_enough_info_reason:
- step["actions"].append(
- {"action_type": "not_enough_info", "action_params": {"reason": not_enough_info_reason}}
- )
- step["observations"] = ["从LLM输出内容中检测到not_enough_info"]
- thinking_steps.append(step)
- logger.info(
- f"ReAct Agent 第 {iteration + 1} 次迭代 从LLM输出内容中检测到not_enough_info: {not_enough_info_reason[:100]}..."
- )
- return False, not_enough_info_reason, thinking_steps, False
-
+ # 如果是最后一次迭代，使用final_prompt进行总结
if is_final_iteration:
- step["actions"].append(
- {"action_type": "not_enough_info", "action_params": {"reason": "已到达最后一次迭代，无法找到答案"}}
+ evaluation_prompt = await global_prompt_manager.format_prompt(
+ "memory_retrieval_react_final_prompt",
+ bot_name=bot_name,
+ time_now=time_now,
+ question=question,
+ collected_info=collected_info if collected_info else "暂无信息",
+ current_iteration=current_iteration,
+ remaining_iterations=remaining_iterations,
+ max_iterations=max_iterations,
)
- step["observations"] = ["已到达最后一次迭代，无法找到答案"]
- thinking_steps.append(step)
+
+ if global_config.debug.show_memory_prompt:
+ logger.info(f"ReAct Agent 最终评估Prompt: {evaluation_prompt}")
+
+ eval_success, eval_response, eval_reasoning_content, eval_model_name, eval_tool_calls = await llm_api.generate_with_model_with_tools(
+ evaluation_prompt,
+ model_config=model_config.model_task_config.tool_use,
+ tool_options=[], # 最终评估阶段不提供工具
+ request_type="memory.react.final",
+ )
+
+ if not eval_success:
+ logger.error(f"ReAct Agent 第 {iteration + 1} 次迭代 最终评估阶段 LLM调用失败: {eval_response}")
+ _log_conversation_messages(
+ conversation_messages,
+ head_prompt=first_head_prompt,
+ final_status="未找到答案：最终评估阶段LLM调用失败",
+ )
+ return False, "最终评估阶段LLM调用失败", thinking_steps, False
+
+ logger.info(
+ f"ReAct Agent 第 {iteration + 1} 次迭代 最终评估响应: {eval_response}"
+ )
+
+ # 从最终评估响应中提取found_answer或not_enough_info
+ found_answer_content = None
+ not_enough_info_reason = None
+
+ if eval_response:
+ found_answer_content = extract_quoted_content(eval_response, "found_answer", "answer")
+ if not found_answer_content:
+ not_enough_info_reason = extract_quoted_content(eval_response, "not_enough_info", "reason")
+
+ # 如果找到答案，返回
+ if found_answer_content:
+ eval_step = {
+ "iteration": iteration + 1,
+ "thought": f"[最终评估] {eval_response}",
+ "actions": [{"action_type": "found_answer", "action_params": {"answer": found_answer_content}}],
+ "observations": ["最终评估阶段检测到found_answer"]
+ }
+ thinking_steps.append(eval_step)
+ logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 最终评估阶段找到关于问题{question}的答案: {found_answer_content}")
+
+ _log_conversation_messages(
+ conversation_messages,
+ head_prompt=first_head_prompt,
+ final_status=f"找到答案：{found_answer_content}",
+ )
+
+ return True, found_answer_content, thinking_steps, False
+
+ # 如果评估为not_enough_info，返回空字符串（不返回任何信息）
+ if not_enough_info_reason:
+ eval_step = {
+ "iteration": iteration + 1,
+ "thought": f"[最终评估] {eval_response}",
+ "actions": [{"action_type": "not_enough_info", "action_params": {"reason": not_enough_info_reason}}],
+ "observations": ["最终评估阶段检测到not_enough_info"]
+ }
+ thinking_steps.append(eval_step)
+ logger.info(
+ f"ReAct Agent 第 {iteration + 1} 次迭代 最终评估阶段判断信息不足: {not_enough_info_reason}"
+ )
+
+ _log_conversation_messages(
+ conversation_messages,
+ head_prompt=first_head_prompt,
+ final_status=f"未找到答案：{not_enough_info_reason}",
+ )
+
+ return False, "", thinking_steps, False
+
+ # 如果没有明确判断，视为not_enough_info，返回空字符串（不返回任何信息）
+ eval_step = {
+ "iteration": iteration + 1,
+ "thought": f"[最终评估] {eval_response}",
+ "actions": [{"action_type": "not_enough_info", "action_params": {"reason": "已到达最后一次迭代，无法找到答案"}}],
+ "observations": ["已到达最后一次迭代，无法找到答案"]
+ }
+ thinking_steps.append(eval_step)
logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 已到达最后一次迭代，无法找到答案")
- return False, "已到达最后一次迭代，无法找到答案", thinking_steps, False
+
+ _log_conversation_messages(
+ conversation_messages,
+ head_prompt=first_head_prompt,
+ final_status="未找到答案：已到达最后一次迭代，无法找到答案",
+ )
+
+ return False, "", thinking_steps, False
+
+ # 前n-1次迭代，使用head_prompt决定调用哪些工具（包含found_answer工具）
+ tool_definitions = tool_registry.get_tool_definitions()
+ logger.info(
+ f"ReAct Agent 第 {iteration + 1} 次迭代，问题: {question}|可用工具数量: {len(tool_definitions)}"
+ )
+
+ # head_prompt应该只构建一次，使用初始的collected_info，后续迭代都复用同一个
+ if first_head_prompt is None:
+ # 第一次构建，使用初始的collected_info（即initial_info）
+ initial_collected_info = initial_info if initial_info else ""
+ first_head_prompt = await global_prompt_manager.format_prompt(
+ "memory_retrieval_react_prompt_head",
+ bot_name=bot_name,
+ time_now=time_now,
+ question=question,
+ collected_info=initial_collected_info,
+ current_iteration=current_iteration,
+ remaining_iterations=remaining_iterations,
+ max_iterations=max_iterations,
+ )
+
+ # 后续迭代都复用第一次构建的head_prompt
+ head_prompt = first_head_prompt
+
+ def message_factory(
+ _client,
+ *,
+ _head_prompt: str = head_prompt,
+ _conversation_messages: List[Message] = conversation_messages,
+ ) -> List[Message]:
+ messages: List[Message] = []
+
+ system_builder = MessageBuilder()
+ system_builder.set_role(RoleType.System)
+ system_builder.add_text_content(_head_prompt)
+ messages.append(system_builder.build())
+
+ messages.extend(_conversation_messages)
+
+ return messages
+
+ (
+ success,
+ response,
+ reasoning_content,
+ model_name,
+ tool_calls,
+ ) = await llm_api.generate_with_model_with_tools_by_message_factory(
+ message_factory,
+ model_config=model_config.model_task_config.tool_use,
+ tool_options=tool_definitions,
+ request_type="memory.react",
+ )
+
+ logger.debug(
+ f"ReAct Agent 第 {iteration + 1} 次迭代 模型: {model_name} ，调用工具数量: {len(tool_calls) if tool_calls else 0} ，调用工具响应: {response}"
+ )
+
+ if not success:
+ logger.error(f"ReAct Agent LLM调用失败: {response}")
+ break
+
+ # 注意：这里会检查found_answer工具调用，如果检测到found_answer工具，会直接返回答案
+
+ assistant_message: Optional[Message] = None
+ if tool_calls:
+ assistant_builder = MessageBuilder()
+ assistant_builder.set_role(RoleType.Assistant)
+ if response and response.strip():
+ assistant_builder.add_text_content(response)
+ assistant_builder.set_tool_calls(tool_calls)
+ assistant_message = assistant_builder.build()
+ elif response and response.strip():
+ assistant_builder = MessageBuilder()
+ assistant_builder.set_role(RoleType.Assistant)
+ assistant_builder.add_text_content(response)
+ assistant_message = assistant_builder.build()
+
+ # 记录思考步骤
+ step = {"iteration": iteration + 1, "thought": response, "actions": [], "observations": []}
if assistant_message:
conversation_messages.append(assistant_message)
@@ -568,43 +525,62 @@ async def _react_agent_solve_question(
# 处理工具调用
if not tool_calls:
- # 没有工具调用，说明LLM在思考中已经给出了答案（已在前面检查），或者需要继续查询
- # 如果思考中没有答案，说明需要继续查询或等待下一轮
+ # 如果没有工具调用，记录思考过程，继续下一轮迭代（下一轮会再次评估）
if response and response.strip():
- # 如果响应不为空，记录思考过程，继续下一轮迭代
step["observations"] = [f"思考完成，但未调用工具。响应: {response}"]
- logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 思考完成但未调用工具: {response[:100]}...")
- # 继续下一轮迭代，让LLM有机会在思考中给出found_answer或继续查询
+ logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 思考完成但未调用工具: {response}")
collected_info += f"思考: {response}"
- thinking_steps.append(step)
- continue
else:
logger.warning(f"ReAct Agent 第 {iteration + 1} 次迭代 无工具调用且无响应")
step["observations"] = ["无响应且无工具调用"]
- thinking_steps.append(step)
- break
+ thinking_steps.append(step)
+ continue
# 处理工具调用
+ # 首先检查是否有found_answer工具调用，如果有则立即返回，不再处理其他工具
+ found_answer_from_tool = None
+ for tool_call in tool_calls:
+ tool_name = tool_call.func_name
+ tool_args = tool_call.args or {}
+
+ if tool_name == "found_answer":
+ found_answer_from_tool = tool_args.get("answer", "")
+ if found_answer_from_tool:
+ step["actions"].append({"action_type": "found_answer", "action_params": {"answer": found_answer_from_tool}})
+ step["observations"] = ["检测到found_answer工具调用"]
+ thinking_steps.append(step)
+ logger.debug(f"ReAct Agent 第 {iteration + 1} 次迭代 通过found_answer工具找到关于问题{question}的答案: {found_answer_from_tool}")
+
+ _log_conversation_messages(
+ conversation_messages,
+ head_prompt=first_head_prompt,
+ final_status=f"找到答案：{found_answer_from_tool}",
+ )
+
+ return True, found_answer_from_tool, thinking_steps, False
+
+ # 如果没有found_answer工具调用，或者found_answer工具调用没有答案，继续处理其他工具
tool_tasks = []
-
for i, tool_call in enumerate(tool_calls):
tool_name = tool_call.func_name
tool_args = tool_call.args or {}
- logger.info(
+ logger.debug(
f"ReAct Agent 第 {iteration + 1} 次迭代 工具调用 {i + 1}/{len(tool_calls)}: {tool_name}({tool_args})"
)
+ # 跳过found_answer工具调用（已经在上面处理过了）
+ if tool_name == "found_answer":
+ continue
+
# 普通工具调用
tool = tool_registry.get_tool(tool_name)
if tool:
# 准备工具参数（需要添加chat_id如果工具需要）
- tool_params = tool_args.copy()
-
- # 如果工具函数签名需要chat_id，添加它
import inspect
sig = inspect.signature(tool.execute_func)
+ tool_params = tool_args.copy()
if "chat_id" in sig.parameters:
tool_params["chat_id"] = chat_id
@@ -637,15 +613,33 @@ async def _react_agent_solve_question(
logger.error(f"ReAct Agent 第 {iteration + 1} 次迭代 工具 {i + 1} 执行异常: {observation}")
observation_text = observation if isinstance(observation, str) else str(observation)
+ stripped_observation = observation_text.strip()
step["observations"].append(observation_text)
collected_info += f"\n{observation_text}\n"
- if observation_text.strip():
+ if stripped_observation:
+ # 检查工具输出中是否有新的jargon，如果有则追加到工具结果中
+ if enable_jargon_detection:
+ jargon_concepts = match_jargon_from_text(stripped_observation, chat_id)
+ if jargon_concepts:
+ new_concepts = []
+ for concept in jargon_concepts:
+ normalized_concept = concept.strip()
+ if normalized_concept and normalized_concept not in seen_jargon_concepts:
+ new_concepts.append(normalized_concept)
+ seen_jargon_concepts.add(normalized_concept)
+ if new_concepts:
+ jargon_info = await retrieve_concepts_with_jargon(new_concepts, chat_id)
+ if jargon_info:
+ # 将jargon查询结果追加到工具结果中
+ observation_text += f"\n\n{jargon_info}"
+ collected_info += f"\n{jargon_info}\n"
+ logger.info(f"工具输出触发黑话解析: {new_concepts}")
+
tool_builder = MessageBuilder()
tool_builder.set_role(RoleType.Tool)
tool_builder.add_text_content(observation_text)
tool_builder.add_tool_call(tool_call_item.call_id)
conversation_messages.append(tool_builder.build())
- # logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 工具 {i+1} 执行结果: {observation_text}")
thinking_steps.append(step)
@@ -660,11 +654,20 @@ async def _react_agent_solve_question(
logger.warning("ReAct Agent超时，直接视为not_enough_info")
else:
logger.warning("ReAct Agent达到最大迭代次数，直接视为not_enough_info")
- return False, "未找到相关信息", thinking_steps, is_timeout
+
+ # React完成时输出消息列表
+ timeout_reason = "超时" if is_timeout else "达到最大迭代次数"
+ _log_conversation_messages(
+ conversation_messages,
+ head_prompt=first_head_prompt,
+ final_status=f"未找到答案：{timeout_reason}",
+ )
+
+ return False, "", thinking_steps, is_timeout
-def _get_recent_query_history(chat_id: str, time_window_seconds: float = 300.0) -> str:
- """获取最近一段时间内的查询历史
+def _get_recent_query_history(chat_id: str, time_window_seconds: float = 600.0) -> str:
+ """获取最近一段时间内的查询历史（用于避免重复查询）
Args:
chat_id: 聊天ID
@@ -714,169 +717,49 @@ def _get_recent_query_history(chat_id: str, time_window_seconds: float = 300.0)
return ""
-def _get_cached_memories(chat_id: str, time_window_seconds: float = 300.0) -> List[str]:
- """获取最近一段时间内缓存的记忆（只返回找到答案的记录）
+def _get_recent_found_answers(chat_id: str, time_window_seconds: float = 600.0) -> List[str]:
+ """获取最近一段时间内已找到答案的查询记录（用于返回给 replyer）
Args:
chat_id: 聊天ID
- time_window_seconds: 时间窗口（秒），默认300秒（5分钟）
+ time_window_seconds: 时间窗口（秒），默认10分钟
Returns:
- List[str]: 格式化的记忆列表，每个元素格式为 "问题：xxx\n答案：xxx"
+ List[str]: 格式化的答案列表，每个元素格式为 "问题：xxx\n答案：xxx"
"""
try:
current_time = time.time()
start_time = current_time - time_window_seconds
- # 查询最近时间窗口内找到答案的记录，按更新时间倒序
+ # 查询最近时间窗口内已找到答案的记录，按更新时间倒序
records = (
ThinkingBack.select()
.where(
(ThinkingBack.chat_id == chat_id)
& (ThinkingBack.update_time >= start_time)
& (ThinkingBack.found_answer == 1)
+ & (ThinkingBack.answer.is_null(False))
+ & (ThinkingBack.answer != "")
)
.order_by(ThinkingBack.update_time.desc())
- .limit(5) # 最多返回5条最近的记录
+ .limit(3) # 最多返回5条最近的记录
)
if not records.exists():
return []
- cached_memories = []
+ found_answers = []
for record in records:
if record.answer:
- cached_memories.append(f"问题：{record.question}\n答案：{record.answer}")
+ found_answers.append(f"问题：{record.question}\n答案：{record.answer}")
- return cached_memories
+ return found_answers
except Exception as e:
- logger.error(f"获取缓存记忆失败: {e}")
+ logger.error(f"获取最近已找到答案的记录失败: {e}")
return []
-def _query_thinking_back(chat_id: str, question: str) -> Optional[Tuple[bool, str]]:
- """从thinking_back数据库中查询是否有现成的答案
-
- Args:
- chat_id: 聊天ID
- question: 问题
-
- Returns:
- Optional[Tuple[bool, str]]: 如果找到记录，返回(found_answer, answer)，否则返回None
- found_answer: 是否找到答案（True表示found_answer=1，False表示found_answer=0）
- answer: 答案内容
- """
- try:
- # 查询相同chat_id和问题的所有记录（包括found_answer为0和1的）
- # 按更新时间倒序，获取最新的记录
- records = (
- ThinkingBack.select()
- .where((ThinkingBack.chat_id == chat_id) & (ThinkingBack.question == question))
- .order_by(ThinkingBack.update_time.desc())
- .limit(1)
- )
-
- if records.exists():
- record = records.get()
- found_answer = bool(record.found_answer)
- answer = record.answer or ""
- logger.info(f"在thinking_back中找到记录，问题: {question[:50]}...，found_answer: {found_answer}")
- return found_answer, answer
-
- return None
-
- except Exception as e:
- logger.error(f"查询thinking_back失败: {e}")
- return None
-
-
-async def _analyze_question_answer(question: str, answer: str, chat_id: str) -> None:
- """异步分析问题和答案的类别，并存储到相应系统
-
- Args:
- question: 问题
- answer: 答案
- chat_id: 聊天ID
- """
- try:
- # 使用LLM分析类别
- analysis_prompt = f"""请分析以下问题和答案的类别：
-
-问题：{question}
-答案：{answer}
-
-类别说明：
-1. 人物信息：有关某个用户的个体信息（如某人的喜好、习惯、经历等）
-2. 黑话：对特定概念、缩写词、谐音词、自创词的解释（如"yyds"、"社死"等）
-3. 其他：除此之外的其他内容
-
-请输出JSON格式：
-{{
- "category": "人物信息" | "黑话" | "其他",
- "jargon_keyword": "如果是黑话，提取关键词（如'yyds'），否则为空字符串",
- "person_name": "如果是人物信息，提取人物名称，否则为空字符串",
- "memory_content": "如果是人物信息，提取要存储的记忆内容（简短概括），否则为空字符串"
-}}
-
-只输出JSON，不要输出其他内容："""
-
- success, response, _, _ = await llm_api.generate_with_model(
- analysis_prompt,
- model_config=model_config.model_task_config.utils,
- request_type="memory.analyze_qa",
- )
-
- if not success:
- logger.error(f"分析问题和答案失败: {response}")
- return
-
- # 解析JSON响应
- try:
- json_pattern = r"```json\s*(.*?)\s*```"
- matches = re.findall(json_pattern, response, re.DOTALL)
-
- if matches:
- json_str = matches[0]
- else:
- json_str = response.strip()
-
- repaired_json = repair_json(json_str)
- analysis_result = json.loads(repaired_json)
-
- category = analysis_result.get("category", "").strip()
-
- if category == "黑话":
- # 处理黑话
- jargon_keyword = analysis_result.get("jargon_keyword", "").strip()
- if jargon_keyword:
- from src.jargon.jargon_miner import store_jargon_from_answer
-
- await store_jargon_from_answer(jargon_keyword, answer, chat_id)
- else:
- logger.warning(f"分析为黑话但未提取到关键词，问题: {question[:50]}...")
-
- elif category == "人物信息":
- # 处理人物信息
- # person_name = analysis_result.get("person_name", "").strip()
- # memory_content = analysis_result.get("memory_content", "").strip()
- # if person_name and memory_content:
- # from src.person_info.person_info import store_person_memory_from_answer
- # await store_person_memory_from_answer(person_name, memory_content, chat_id)
- # else:
- # logger.warning(f"分析为人物信息但未提取到人物名称或记忆内容，问题: {question[:50]}...")
- pass # 功能暂时禁用
-
- else:
- logger.info(f"问题和答案类别为'其他'，不进行存储，问题: {question[:50]}...")
-
- except Exception as e:
- logger.error(f"解析分析结果失败: {e}, 响应: {response[:200]}...")
-
- except Exception as e:
- logger.error(f"分析问题和答案时发生异常: {e}")
-
-
def _store_thinking_back(
chat_id: str, question: str, context: str, found_answer: bool, answer: str, thinking_steps: List[Dict[str, Any]]
) -> None:
@@ -923,99 +806,65 @@ def _store_thinking_back(
create_time=now,
update_time=now,
)
- logger.info(f"已创建思考过程到数据库，问题: {question[:50]}...")
+ # logger.info(f"已创建思考过程到数据库，问题: {question[:50]}...")
except Exception as e:
logger.error(f"存储思考过程失败: {e}")
-async def _process_single_question(question: str, chat_id: str, context: str, initial_info: str = "") -> Optional[str]:
- """处理单个问题的查询（包含缓存检查逻辑）
+async def _process_single_question(
+ question: str,
+ chat_id: str,
+ context: str,
+ initial_info: str = "",
+ initial_jargon_concepts: Optional[List[str]] = None,
+) -> Optional[str]:
+ """处理单个问题的查询
Args:
question: 要查询的问题
chat_id: 聊天ID
context: 上下文信息
initial_info: 初始信息（如概念检索结果），将传递给ReAct Agent
+ initial_jargon_concepts: 已经处理过的黑话概念列表，用于ReAct阶段的去重
Returns:
Optional[str]: 如果找到答案，返回格式化的结果字符串，否则返回None
"""
- logger.info(f"开始处理问题: {question}")
+ # logger.info(f"开始处理问题: {question}")
_cleanup_stale_not_found_thinking_back()
question_initial_info = initial_info or ""
- # 预先进行一次LPMM知识库查询，作为后续ReAct Agent的辅助信息
- if global_config.lpmm_knowledge.enable:
- try:
- lpmm_result = await query_lpmm_knowledge(question, limit=2)
- if lpmm_result and lpmm_result.startswith("你从LPMM知识库中找到"):
- if question_initial_info:
- question_initial_info += "\n"
- question_initial_info += f"【LPMM知识库预查询】\n{lpmm_result}"
- logger.info(f"LPMM预查询命中，问题: {question[:50]}...")
- else:
- logger.info(f"LPMM预查询未命中或未找到信息，问题: {question[:50]}...")
- except Exception as e:
- logger.error(f"LPMM预查询失败，问题: {question[:50]}... 错误: {e}")
+ # 直接使用ReAct Agent查询（不再从thinking_back获取缓存）
+ # logger.info(f"使用ReAct Agent查询，问题: {question[:50]}...")
- # 先检查thinking_back数据库中是否有现成答案
- cached_result = _query_thinking_back(chat_id, question)
- should_requery = False
+ jargon_concepts_for_agent = initial_jargon_concepts if global_config.memory.enable_jargon_detection else None
- if cached_result:
- cached_found_answer, cached_answer = cached_result
+ found_answer, answer, thinking_steps, is_timeout = await _react_agent_solve_question(
+ question=question,
+ chat_id=chat_id,
+ max_iterations=global_config.memory.max_agent_iterations,
+ timeout=120.0,
+ initial_info=question_initial_info,
+ initial_jargon_concepts=jargon_concepts_for_agent,
+ )
- if cached_found_answer: # found_answer == 1 (True)
- # found_answer == 1：20%概率重新查询
- if random.random() < 0.5:
- should_requery = True
- logger.info(f"found_answer=1，触发20%概率重新查询，问题: {question[:50]}...")
-
- if not should_requery and cached_answer:
- logger.info(f"从thinking_back缓存中获取答案，问题: {question[:50]}...")
- return f"问题：{question}\n答案：{cached_answer}"
- elif not cached_answer:
- should_requery = True
- logger.info(f"found_answer=1 但缓存答案为空，重新查询，问题: {question[:50]}...")
- else:
- # found_answer == 0：不使用缓存，直接重新查询
- should_requery = True
- logger.info(f"thinking_back存在但未找到答案，忽略缓存重新查询，问题: {question[:50]}...")
-
- # 如果没有缓存答案或需要重新查询，使用ReAct Agent查询
- if not cached_result or should_requery:
- if should_requery:
- logger.info(f"概率触发重新查询，使用ReAct Agent查询，问题: {question[:50]}...")
- else:
- logger.info(f"未找到缓存答案，使用ReAct Agent查询，问题: {question[:50]}...")
-
- found_answer, answer, thinking_steps, is_timeout = await _react_agent_solve_question(
- question=question,
+ # 存储查询历史到数据库（超时时不存储）
+ if not is_timeout:
+ _store_thinking_back(
chat_id=chat_id,
- max_iterations=global_config.memory.max_agent_iterations,
- timeout=120.0,
- initial_info=question_initial_info,
+ question=question,
+ context=context,
+ found_answer=found_answer,
+ answer=answer,
+ thinking_steps=thinking_steps,
)
+ else:
+ logger.info(f"ReAct Agent超时，不存储到数据库，问题: {question[:50]}...")
- # 存储到数据库（超时时不存储）
- if not is_timeout:
- _store_thinking_back(
- chat_id=chat_id,
- question=question,
- context=context,
- found_answer=found_answer,
- answer=answer,
- thinking_steps=thinking_steps,
- )
- else:
- logger.info(f"ReAct Agent超时，不存储到数据库，问题: {question[:50]}...")
-
- if found_answer and answer:
- # 创建异步任务分析问题和答案
- asyncio.create_task(_analyze_question_answer(question, answer, chat_id))
- return f"问题：{question}\n答案：{answer}"
+ if found_answer and answer:
+ return f"问题：{question}\n答案：{answer}"
return None
@@ -1048,8 +897,8 @@ async def build_memory_retrieval_prompt(
bot_name = global_config.bot.nickname
chat_id = chat_stream.stream_id
- # 获取最近查询历史（最近1小时内的查询）
- recent_query_history = _get_recent_query_history(chat_id, time_window_seconds=300.0)
+ # 获取最近查询历史（最近10分钟内的查询，用于避免重复查询）
+ recent_query_history = _get_recent_query_history(chat_id, time_window_seconds=600.0)
if not recent_query_history:
recent_query_history = "最近没有查询记录。"
@@ -1072,57 +921,59 @@ async def build_memory_retrieval_prompt(
if global_config.debug.show_memory_prompt:
logger.info(f"记忆检索问题生成提示词: {question_prompt}")
- logger.info(f"记忆检索问题生成响应: {response}")
+ # logger.info(f"记忆检索问题生成响应: {response}")
if not success:
logger.error(f"LLM生成问题失败: {response}")
return ""
# 解析概念列表和问题列表
- concepts, questions = _parse_questions_json(response)
- logger.info(f"解析到 {len(concepts)} 个概念: {concepts}")
- logger.info(f"解析到 {len(questions)} 个问题: {questions}")
+ _, questions = parse_questions_json(response)
+ if questions:
+ logger.info(f"解析到 {len(questions)} 个问题: {questions}")
- # 对概念进行jargon检索，作为初始信息
+ enable_jargon_detection = global_config.memory.enable_jargon_detection
+ concepts: List[str] = []
+
+ if enable_jargon_detection:
+ # 使用匹配逻辑自动识别聊天中的黑话概念
+ concepts = match_jargon_from_text(message, chat_id)
+ if concepts:
+ logger.info(f"黑话匹配命中 {len(concepts)} 个概念: {concepts}")
+ else:
+ logger.debug("黑话匹配未命中任何概念")
+ else:
+ logger.debug("已禁用记忆检索中的黑话识别")
+
+ # 对匹配到的概念进行jargon检索，作为初始信息
initial_info = ""
- if concepts:
- logger.info(f"开始对 {len(concepts)} 个概念进行jargon检索")
- concept_info = await _retrieve_concepts_with_jargon(concepts, chat_id)
+ if enable_jargon_detection and concepts:
+ concept_info = await retrieve_concepts_with_jargon(concepts, chat_id)
if concept_info:
initial_info += concept_info
- logger.info(f"概念检索完成，结果: {concept_info[:200]}...")
+ logger.debug(f"概念检索完成，结果: {concept_info}")
else:
- logger.info("概念检索未找到任何结果")
-
- # 获取缓存的记忆（与question时使用相同的时间窗口和数量限制）
- cached_memories = _get_cached_memories(chat_id, time_window_seconds=300.0)
+ logger.debug("概念检索未找到任何结果")
if not questions:
- logger.debug("模型认为不需要检索记忆或解析失败")
- # 即使没有当次查询，也返回缓存的记忆和概念检索结果
- all_results = []
- if initial_info:
- all_results.append(initial_info.strip())
- if cached_memories:
- all_results.extend(cached_memories)
-
- if all_results:
- retrieved_memory = "\n\n".join(all_results)
- end_time = time.time()
- logger.info(f"无当次查询，返回缓存记忆和概念检索结果，耗时: {(end_time - start_time):.3f}秒")
- return f"你回忆起了以下信息：\n{retrieved_memory}\n如果与回复内容相关，可以参考这些回忆的信息。\n"
- else:
- return ""
-
- logger.info(f"解析到 {len(questions)} 个问题: {questions}")
+ logger.debug("模型认为不需要检索记忆或解析失败，不返回任何查询结果")
+ end_time = time.time()
+ logger.info(f"无当次查询，不返回任何结果，耗时: {(end_time - start_time):.3f}秒")
+ return ""
# 第二步：并行处理所有问题（使用配置的最大迭代次数/120秒超时）
max_iterations = global_config.memory.max_agent_iterations
- logger.info(f"问题数量: {len(questions)}，设置最大迭代次数: {max_iterations}，超时时间: 120秒")
+ logger.debug(f"问题数量: {len(questions)}，设置最大迭代次数: {max_iterations}，超时时间: 120秒")
# 并行处理所有问题，将概念检索结果作为初始信息传递
question_tasks = [
- _process_single_question(question=question, chat_id=chat_id, context=message, initial_info=initial_info)
+ _process_single_question(
+ question=question,
+ chat_id=chat_id,
+ context=message,
+ initial_info=initial_info,
+ initial_jargon_concepts=concepts if enable_jargon_detection else None,
+ )
for question in questions
]
@@ -1130,90 +981,54 @@ async def build_memory_retrieval_prompt(
results = await asyncio.gather(*question_tasks, return_exceptions=True)
# 收集所有有效结果
- all_results = []
- current_questions = set() # 用于去重，避免缓存和当次查询重复
+ question_results: List[str] = []
for i, result in enumerate(results):
if isinstance(result, Exception):
logger.error(f"处理问题 '{questions[i]}' 时发生异常: {result}")
elif result is not None:
- all_results.append(result)
- # 提取问题用于去重
- if result.startswith("问题："):
- question = result.split("\n")[0].replace("问题：", "").strip()
- current_questions.add(question)
+ question_results.append(result)
- # 将缓存的记忆添加到结果中（排除当次查询已包含的问题，避免重复）
- for cached_memory in cached_memories:
- if cached_memory.startswith("问题："):
- question = cached_memory.split("\n")[0].replace("问题：", "").strip()
- # 只有当次查询中没有相同问题时，才添加缓存记忆
- if question not in current_questions:
- all_results.append(cached_memory)
- logger.debug(f"添加缓存记忆: {question[:50]}...")
+ # 获取最近10分钟内已找到答案的缓存记录
+ cached_answers = _get_recent_found_answers(chat_id, time_window_seconds=600.0)
+
+ # 合并当前查询结果和缓存答案（去重：如果当前查询的问题在缓存中已存在，优先使用当前结果）
+ all_results = []
+
+ # 先添加当前查询的结果
+ current_questions = set()
+ for result in question_results:
+ # 提取问题（格式为 "问题：xxx\n答案：xxx"）
+ if result.startswith("问题："):
+ question_end = result.find("\n答案：")
+ if question_end != -1:
+ current_questions.add(result[4:question_end])
+ all_results.append(result)
+
+ # 添加缓存答案（排除当前查询中已存在的问题）
+ for cached_answer in cached_answers:
+ if cached_answer.startswith("问题："):
+ question_end = cached_answer.find("\n答案：")
+ if question_end != -1:
+ cached_question = cached_answer[4:question_end]
+ if cached_question not in current_questions:
+ all_results.append(cached_answer)
end_time = time.time()
if all_results:
retrieved_memory = "\n\n".join(all_results)
+ current_count = len(question_results)
+ cached_count = len(all_results) - current_count
logger.info(
- f"记忆检索成功，耗时: {(end_time - start_time):.3f}秒，包含 {len(all_results)} 条记忆（含缓存）"
+ f"记忆检索成功，耗时: {(end_time - start_time):.3f}秒，"
+ f"当前查询 {current_count} 条记忆，缓存 {cached_count} 条记忆，共 {len(all_results)} 条记忆"
)
return f"你回忆起了以下信息：\n{retrieved_memory}\n如果与回复内容相关，可以参考这些回忆的信息。\n"
else:
- logger.debug("所有问题均未找到答案，且无缓存记忆")
+ logger.debug("所有问题均未找到答案，且无缓存答案")
return ""
except Exception as e:
logger.error(f"记忆检索时发生异常: {str(e)}")
return ""
-
-def _parse_questions_json(response: str) -> Tuple[List[str], List[str]]:
- """解析问题JSON，返回概念列表和问题列表
-
- Args:
- response: LLM返回的响应
-
- Returns:
- Tuple[List[str], List[str]]: (概念列表, 问题列表)
- """
- try:
- # 尝试提取JSON（可能包含在```json代码块中）
- json_pattern = r"```json\s*(.*?)\s*```"
- matches = re.findall(json_pattern, response, re.DOTALL)
-
- if matches:
- json_str = matches[0]
- else:
- # 尝试直接解析整个响应
- json_str = response.strip()
-
- # 修复可能的JSON错误
- repaired_json = repair_json(json_str)
-
- # 解析JSON
- parsed = json.loads(repaired_json)
-
- # 只支持新格式：包含concepts和questions的对象
- if not isinstance(parsed, dict):
- logger.warning(f"解析的JSON不是对象格式: {parsed}")
- return [], []
-
- concepts_raw = parsed.get("concepts", [])
- questions_raw = parsed.get("questions", [])
-
- # 确保是列表
- if not isinstance(concepts_raw, list):
- concepts_raw = []
- if not isinstance(questions_raw, list):
- questions_raw = []
-
- # 确保所有元素都是字符串
- concepts = [c for c in concepts_raw if isinstance(c, str) and c.strip()]
- questions = [q for q in questions_raw if isinstance(q, str) and q.strip()]
-
- return concepts, questions
-
- except Exception as e:
- logger.error(f"解析问题JSON失败: {e}, 响应内容: {response[:200]}...")
- return [], []
diff --git a/src/memory_system/memory_utils.py b/src/memory_system/memory_utils.py
index bff39f95..7aa33a52 100644
--- a/src/memory_system/memory_utils.py
+++ b/src/memory_system/memory_utils.py
@@ -8,7 +8,8 @@ import json
import re
from datetime import datetime
from typing import Tuple
-from difflib import SequenceMatcher
+from typing import List
+from json_repair import repair_json
from src.common.logger import get_logger
@@ -16,101 +17,56 @@ from src.common.logger import get_logger
logger = get_logger("memory_utils")
-def parse_md_json(json_text: str) -> list[str]:
- """从Markdown格式的内容中提取JSON对象和推理内容"""
- json_objects = []
- reasoning_content = ""
- # 使用正则表达式查找```json包裹的JSON内容
- json_pattern = r"```json\s*(.*?)\s*```"
- matches = re.findall(json_pattern, json_text, re.DOTALL)
-
- # 提取JSON之前的内容作为推理文本
- if matches:
- # 找到第一个```json的位置
- first_json_pos = json_text.find("```json")
- if first_json_pos > 0:
- reasoning_content = json_text[:first_json_pos].strip()
- # 清理推理内容中的注释标记
- reasoning_content = re.sub(r"^//\s*", "", reasoning_content, flags=re.MULTILINE)
- reasoning_content = reasoning_content.strip()
-
- for match in matches:
- try:
- # 清理可能的注释和格式问题
- json_str = re.sub(r"//.*?\n", "\n", match) # 移除单行注释
- json_str = re.sub(r"/\*.*?\*/", "", json_str, flags=re.DOTALL) # 移除多行注释
- if json_str := json_str.strip():
- json_obj = json.loads(json_str)
- if isinstance(json_obj, dict):
- json_objects.append(json_obj)
- elif isinstance(json_obj, list):
- for item in json_obj:
- if isinstance(item, dict):
- json_objects.append(item)
- except Exception as e:
- logger.warning(f"解析JSON块失败: {e}, 块内容: {match[:100]}...")
- continue
-
- return json_objects, reasoning_content
-
-
-def calculate_similarity(text1: str, text2: str) -> float:
- """
- 计算两个文本的相似度
+def parse_questions_json(response: str) -> Tuple[List[str], List[str]]:
+ """解析问题JSON，返回概念列表和问题列表
Args:
- text1: 第一个文本
- text2: 第二个文本
+ response: LLM返回的响应
Returns:
- float: 相似度分数 (0-1)
+ Tuple[List[str], List[str]]: (概念列表, 问题列表)
"""
try:
- # 预处理文本
- text1 = preprocess_text(text1)
- text2 = preprocess_text(text2)
+ # 尝试提取JSON（可能包含在```json代码块中）
+ json_pattern = r"```json\s*(.*?)\s*```"
+ matches = re.findall(json_pattern, response, re.DOTALL)
- # 使用SequenceMatcher计算相似度
- similarity = SequenceMatcher(None, text1, text2).ratio()
+ if matches:
+ json_str = matches[0]
+ else:
+ # 尝试直接解析整个响应
+ json_str = response.strip()
- # 如果其中一个文本包含另一个，提高相似度
- if text1 in text2 or text2 in text1:
- similarity = max(similarity, 0.8)
+ # 修复可能的JSON错误
+ repaired_json = repair_json(json_str)
- return similarity
+ # 解析JSON
+ parsed = json.loads(repaired_json)
+
+ # 只支持新格式：包含concepts和questions的对象
+ if not isinstance(parsed, dict):
+ logger.warning(f"解析的JSON不是对象格式: {parsed}")
+ return [], []
+
+ concepts_raw = parsed.get("concepts", [])
+ questions_raw = parsed.get("questions", [])
+
+ # 确保是列表
+ if not isinstance(concepts_raw, list):
+ concepts_raw = []
+ if not isinstance(questions_raw, list):
+ questions_raw = []
+
+ # 确保所有元素都是字符串
+ concepts = [c for c in concepts_raw if isinstance(c, str) and c.strip()]
+ questions = [q for q in questions_raw if isinstance(q, str) and q.strip()]
+
+ return concepts, questions
except Exception as e:
- logger.error(f"计算相似度时出错: {e}")
- return 0.0
-
-
-def preprocess_text(text: str) -> str:
- """
- 预处理文本，提高匹配准确性
-
- Args:
- text: 原始文本
-
- Returns:
- str: 预处理后的文本
- """
- try:
- # 转换为小写
- text = text.lower()
-
- # 移除标点符号和特殊字符
- text = re.sub(r"[^\w\s]", "", text)
-
- # 移除多余空格
- text = re.sub(r"\s+", " ", text).strip()
-
- return text
-
- except Exception as e:
- logger.error(f"预处理文本时出错: {e}")
- return text
-
+ logger.error(f"解析问题JSON失败: {e}, 响应内容: {response[:200]}...")
+ return [], []
def parse_datetime_to_timestamp(value: str) -> float:
"""
@@ -140,29 +96,3 @@ def parse_datetime_to_timestamp(value: str) -> float:
except Exception as e:
last_err = e
raise ValueError(f"无法解析时间: {value} ({last_err})")
-
-
-def parse_time_range(time_range: str) -> Tuple[float, float]:
- """
- 解析时间范围字符串，返回开始和结束时间戳
-
- Args:
- time_range: 时间范围字符串，格式："YYYY-MM-DD HH:MM:SS - YYYY-MM-DD HH:MM:SS"
-
- Returns:
- Tuple[float, float]: (开始时间戳, 结束时间戳)
- """
- if " - " not in time_range:
- raise ValueError(f"时间范围格式错误，应为 '开始时间 - 结束时间': {time_range}")
-
- parts = time_range.split(" - ", 1)
- if len(parts) != 2:
- raise ValueError(f"时间范围格式错误: {time_range}")
-
- start_str = parts[0].strip()
- end_str = parts[1].strip()
-
- start_timestamp = parse_datetime_to_timestamp(start_str)
- end_timestamp = parse_datetime_to_timestamp(end_str)
-
- return start_timestamp, end_timestamp
diff --git a/src/memory_system/retrieval_tools/README.md b/src/memory_system/retrieval_tools/README.md
deleted file mode 100644
index 50c36dbe..00000000
--- a/src/memory_system/retrieval_tools/README.md
+++ /dev/null
@@ -1,161 +0,0 @@
-# 记忆检索工具模块
-
-这个模块提供了统一的工具注册和管理系统，用于记忆检索功能。
-
-## 目录结构
-
-```
-retrieval_tools/
-├── __init__.py # 模块导出
-├── tool_registry.py # 工具注册系统
-├── tool_utils.py # 工具函数库（共用函数）
-├── query_jargon.py # 查询jargon工具
-├── query_chat_history.py # 查询聊天历史工具
-├── query_lpmm_knowledge.py # 查询LPMM知识库工具
-└── README.md # 本文件
-```
-
-## 模块说明
-
-### `tool_registry.py`
-包含工具注册系统的核心类：
-- `MemoryRetrievalTool`: 工具基类
-- `MemoryRetrievalToolRegistry`: 工具注册器
-- `register_memory_retrieval_tool()`: 便捷注册函数
-- `get_tool_registry()`: 获取注册器实例
-
-### `tool_utils.py`
-包含所有工具共用的工具函数：
-- `parse_datetime_to_timestamp()`: 解析时间字符串为时间戳
-- `parse_time_range()`: 解析时间范围字符串
-
-### 工具文件
-每个工具都有独立的文件：
-- `query_jargon.py`: 根据关键词在jargon库中查询
-- `query_chat_history.py`: 根据时间或关键词在chat_history中查询（支持查询时间点事件、时间范围事件、关键词搜索）
-
-## 如何添加新工具
-
-1. 创建新的工具文件，例如 `query_new_tool.py`：
-
-```python
-"""
-新工具 - 工具实现
-"""
-
-from src.common.logger import get_logger
-from .tool_registry import register_memory_retrieval_tool
-from .tool_utils import parse_datetime_to_timestamp # 如果需要使用工具函数
-
-logger = get_logger("memory_retrieval_tools")
-
-
-async def query_new_tool(param1: str, param2: str, chat_id: str) -> str:
- """新工具的实现
-
- Args:
- param1: 参数1
- param2: 参数2
- chat_id: 聊天ID
-
- Returns:
- str: 查询结果
- """
- try:
- # 实现逻辑
- return "结果"
- except Exception as e:
- logger.error(f"新工具执行失败: {e}")
- return f"查询失败: {str(e)}"
-
-
-def register_tool():
- """注册工具"""
- register_memory_retrieval_tool(
- name="query_new_tool",
- description="新工具的描述",
- parameters=[
- {
- "name": "param1",
- "type": "string",
- "description": "参数1的描述",
- "required": True
- },
- {
- "name": "param2",
- "type": "string",
- "description": "参数2的描述",
- "required": True
- }
- ],
- execute_func=query_new_tool
- )
-```
-
-2. 在 `__init__.py` 中导入并注册新工具：
-
-```python
-from .query_new_tool import register_tool as register_query_new_tool
-
-def init_all_tools():
- """初始化并注册所有记忆检索工具"""
- register_query_jargon()
- register_query_chat_history()
- register_query_new_tool() # 添加新工具
-```
-
-3. 工具会自动：
- - 出现在 ReAct Agent 的 prompt 中
- - 在动作类型列表中可用
- - 被 ReAct Agent 自动调用
-
-## 使用示例
-
-```python
-from src.memory_system.retrieval_tools import init_all_tools, get_tool_registry
-
-# 初始化所有工具
-init_all_tools()
-
-# 获取工具注册器
-registry = get_tool_registry()
-
-# 获取特定工具
-tool = registry.get_tool("query_chat_history")
-
-# 执行工具（查询时间点事件）
-result = await tool.execute(time_point="2025-01-15 14:30:00", chat_id="chat123")
-
-# 或者查询关键词
-result = await tool.execute(keyword="小丑AI", chat_id="chat123")
-
-# 或者查询时间范围
-result = await tool.execute(time_range="2025-01-15 10:00:00 - 2025-01-15 20:00:00", chat_id="chat123")
-```
-
-## 现有工具说明
-
-### query_jargon
-根据关键词在jargon库中查询黑话/俚语/缩写的含义
-- 参数：`keyword` (必填) - 关键词
-
-### query_chat_history
-根据时间或关键词在chat_history中查询相关聊天记录。可以查询某个时间点发生了什么、某个时间范围内的事件，或根据关键词搜索消息
-- 参数：
- - `keyword` (可选) - 关键词，用于搜索消息内容
- - `time_point` (可选) - 时间点，格式：YYYY-MM-DD HH:MM:SS，用于查询某个时间点附近发生了什么（与time_range二选一）
- - `time_range` (可选) - 时间范围，格式：'YYYY-MM-DD HH:MM:SS - YYYY-MM-DD HH:MM:SS'（与time_point二选一）
-
-### query_lpmm_knowledge
-从LPMM知识库中检索与关键词相关的知识内容
-- 参数：
- - `query` (必填) - 查询的关键词或问题描述
-
-## 注意事项
-
-- 所有工具函数必须是异步函数（`async def`）
-- 如果工具函数签名需要 `chat_id` 参数，系统会自动添加（通过函数签名检测）
-- 工具参数定义中的 `required` 字段用于生成 prompt 描述
-- 工具执行失败时应返回错误信息字符串，而不是抛出异常
-- 共用函数放在 `tool_utils.py` 中，避免代码重复
-
diff --git a/src/memory_system/retrieval_tools/__init__.py b/src/memory_system/retrieval_tools/__init__.py
index 4b5c40c0..7832985f 100644
--- a/src/memory_system/retrieval_tools/__init__.py
+++ b/src/memory_system/retrieval_tools/__init__.py
@@ -11,18 +11,18 @@ from .tool_registry import (
)
# 导入所有工具的注册函数
-from .query_jargon import register_tool as register_query_jargon
from .query_chat_history import register_tool as register_query_chat_history
from .query_lpmm_knowledge import register_tool as register_lpmm_knowledge
from .query_person_info import register_tool as register_query_person_info
+from .found_answer import register_tool as register_found_answer
from src.config.config import global_config
def init_all_tools():
"""初始化并注册所有记忆检索工具"""
- register_query_jargon()
register_query_chat_history()
register_query_person_info()
+ register_found_answer() # 注册found_answer工具
if global_config.lpmm_knowledge.lpmm_mode == "agent":
register_lpmm_knowledge()
diff --git a/src/memory_system/retrieval_tools/found_answer.py b/src/memory_system/retrieval_tools/found_answer.py
new file mode 100644
index 00000000..0efd02be
--- /dev/null
+++ b/src/memory_system/retrieval_tools/found_answer.py
@@ -0,0 +1,40 @@
+"""
+found_answer工具 - 用于在记忆检索过程中标记找到答案
+"""
+
+from src.common.logger import get_logger
+from .tool_registry import register_memory_retrieval_tool
+
+logger = get_logger("memory_retrieval_tools")
+
+
+async def found_answer(answer: str) -> str:
+ """标记已找到问题的答案
+
+ Args:
+ answer: 找到的答案内容
+
+ Returns:
+ str: 确认信息
+ """
+ # 这个工具主要用于标记，实际答案会通过返回值传递
+ logger.info(f"找到答案: {answer}")
+ return f"已确认找到答案: {answer}"
+
+
+def register_tool():
+ """注册found_answer工具"""
+ register_memory_retrieval_tool(
+ name="found_answer",
+ description="当你在已收集的信息中找到了问题的明确答案时，调用此工具标记已找到答案。只有在检索到明确、具体的答案时才使用此工具，不要编造信息。",
+ parameters=[
+ {
+ "name": "answer",
+ "type": "string",
+ "description": "找到的答案内容，必须基于已收集的信息，不要编造",
+ "required": True,
+ },
+ ],
+ execute_func=found_answer,
+ )
+
diff --git a/src/memory_system/retrieval_tools/query_chat_history.py b/src/memory_system/retrieval_tools/query_chat_history.py
index 407bba05..097632c4 100644
--- a/src/memory_system/retrieval_tools/query_chat_history.py
+++ b/src/memory_system/retrieval_tools/query_chat_history.py
@@ -1,5 +1,5 @@
"""
-根据时间或关键词在chat_history中查询 - 工具实现
+根据关键词或参与人在chat_history中查询记忆 - 工具实现
从ChatHistory表的聊天记录概述库中查询
"""
@@ -9,103 +9,92 @@ from src.common.logger import get_logger
from src.common.database.database_model import ChatHistory
from src.chat.utils.utils import parse_keywords_string
from .tool_registry import register_memory_retrieval_tool
-from ..memory_utils import parse_datetime_to_timestamp, parse_time_range
+from datetime import datetime
logger = get_logger("memory_retrieval_tools")
-async def query_chat_history(
- chat_id: str, keyword: Optional[str] = None, time_range: Optional[str] = None, fuzzy: bool = True
+async def search_chat_history(
+ chat_id: str, keyword: Optional[str] = None, participant: Optional[str] = None
) -> str:
- """根据时间或关键词在chat_history表中查询聊天记录概述
+ """根据关键词或参与人查询记忆，返回匹配的记忆id、记忆标题theme和关键词keywords
Args:
chat_id: 聊天ID
- keyword: 关键词（可选，支持多个关键词，可用空格、逗号等分隔）
- time_range: 时间范围或时间点，格式：
- - 时间范围："YYYY-MM-DD HH:MM:SS - YYYY-MM-DD HH:MM:SS"
- - 时间点："YYYY-MM-DD HH:MM:SS"（查询包含该时间点的记录）
- fuzzy: 是否使用模糊匹配模式（默认True）
- - True: 模糊匹配，只要包含任意一个关键词即匹配（OR关系）
- - False: 全匹配，必须包含所有关键词才匹配（AND关系）
+ keyword: 关键词（可选，支持多个关键词，可用空格、逗号等分隔。匹配规则：如果关键词数量<=2，必须全部匹配；如果关键词数量>2，允许n-1个关键词匹配）
+ participant: 参与人昵称（可选）
Returns:
- str: 查询结果
+ str: 查询结果，包含记忆id、theme和keywords
"""
try:
# 检查参数
- if not keyword and not time_range:
- return "未指定查询参数（需要提供keyword或time_range之一）"
+ if not keyword and not participant:
+ return "未指定查询参数（需要提供keyword或participant之一）"
# 构建查询条件
query = ChatHistory.select().where(ChatHistory.chat_id == chat_id)
- # 时间过滤条件
- if time_range:
- # 判断是时间点还是时间范围
- if " - " in time_range:
- # 时间范围：查询与时间范围有交集的记录
- start_timestamp, end_timestamp = parse_time_range(time_range)
- # 交集条件：start_time < end_timestamp AND end_time > start_timestamp
- time_filter = (ChatHistory.start_time < end_timestamp) & (ChatHistory.end_time > start_timestamp)
- else:
- # 时间点：查询包含该时间点的记录（start_time <= time_point <= end_time）
- target_timestamp = parse_datetime_to_timestamp(time_range)
- time_filter = (ChatHistory.start_time <= target_timestamp) & (ChatHistory.end_time >= target_timestamp)
- query = query.where(time_filter)
-
# 执行查询
records = list(query.order_by(ChatHistory.start_time.desc()).limit(50))
- # 如果有关键词，进一步过滤
- if keyword:
- # 解析多个关键词（支持空格、逗号等分隔符）
- keywords_list = parse_keywords_string(keyword)
- if not keywords_list:
- keywords_list = [keyword.strip()] if keyword.strip() else []
+ filtered_records = []
- # 转换为小写以便匹配
- keywords_lower = [kw.lower() for kw in keywords_list if kw.strip()]
+ for record in records:
+ participant_matched = True # 如果没有participant条件，默认为True
+ keyword_matched = True # 如果没有keyword条件，默认为True
- if not keywords_lower:
- return "关键词为空"
-
- filtered_records = []
-
- for record in records:
- # 在theme、keywords、summary、original_text中搜索
- theme = (record.theme or "").lower()
- summary = (record.summary or "").lower()
- original_text = (record.original_text or "").lower()
-
- # 解析record中的keywords JSON
- record_keywords_list = []
- if record.keywords:
+ # 检查参与人匹配
+ if participant:
+ participant_matched = False
+ participants_list = []
+ if record.participants:
try:
- keywords_data = (
- json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords
+ participants_data = (
+ json.loads(record.participants)
+ if isinstance(record.participants, str)
+ else record.participants
)
- if isinstance(keywords_data, list):
- record_keywords_list = [str(k).lower() for k in keywords_data]
+ if isinstance(participants_data, list):
+ participants_list = [str(p).lower() for p in participants_data]
except (json.JSONDecodeError, TypeError, ValueError):
pass
- # 根据匹配模式检查关键词
- matched = False
- if fuzzy:
- # 模糊匹配：只要包含任意一个关键词即匹配（OR关系）
- for kw in keywords_lower:
- if (
- kw in theme
- or kw in summary
- or kw in original_text
- or any(kw in k for k in record_keywords_list)
- ):
- matched = True
- break
- else:
- # 全匹配：必须包含所有关键词才匹配（AND关系）
- matched = True
+ participant_lower = participant.lower().strip()
+ if participant_lower and any(participant_lower in p for p in participants_list):
+ participant_matched = True
+
+ # 检查关键词匹配
+ if keyword:
+ keyword_matched = False
+ # 解析多个关键词（支持空格、逗号等分隔符）
+ keywords_list = parse_keywords_string(keyword)
+ if not keywords_list:
+ keywords_list = [keyword.strip()] if keyword.strip() else []
+
+ # 转换为小写以便匹配
+ keywords_lower = [kw.lower() for kw in keywords_list if kw.strip()]
+
+ if keywords_lower:
+ # 在theme、keywords、summary、original_text中搜索
+ theme = (record.theme or "").lower()
+ summary = (record.summary or "").lower()
+ original_text = (record.original_text or "").lower()
+
+ # 解析record中的keywords JSON
+ record_keywords_list = []
+ if record.keywords:
+ try:
+ keywords_data = (
+ json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords
+ )
+ if isinstance(keywords_data, list):
+ record_keywords_list = [str(k).lower() for k in keywords_data]
+ except (json.JSONDecodeError, TypeError, ValueError):
+ pass
+
+ # 有容错的全匹配：如果关键词数量>2，允许n-1个关键词匹配；否则必须全部匹配
+ matched_count = 0
for kw in keywords_lower:
kw_matched = (
kw in theme
@@ -113,73 +102,80 @@ async def query_chat_history(
or kw in original_text
or any(kw in k for k in record_keywords_list)
)
- if not kw_matched:
- matched = False
- break
+ if kw_matched:
+ matched_count += 1
+
+ # 计算需要匹配的关键词数量
+ total_keywords = len(keywords_lower)
+ if total_keywords > 2:
+ # 关键词数量>2，允许n-1个关键词匹配
+ required_matches = total_keywords - 1
+ else:
+ # 关键词数量<=2，必须全部匹配
+ required_matches = total_keywords
+
+ keyword_matched = matched_count >= required_matches
- if matched:
- filtered_records.append(record)
+ # 两者都匹配（如果同时有participant和keyword，需要两者都匹配；如果只有一个条件，只需要该条件匹配）
+ matched = participant_matched and keyword_matched
- if not filtered_records:
- keywords_str = "、".join(keywords_list)
- match_mode = "包含任意一个关键词" if fuzzy else "包含所有关键词"
- if time_range:
- return f"未找到{match_mode}'{keywords_str}'且在指定时间范围内的聊天记录概述"
+ if matched:
+ filtered_records.append(record)
+
+ if not filtered_records:
+ if keyword and participant:
+ keywords_str = "、".join(parse_keywords_string(keyword) if keyword else [])
+ return f"未找到包含关键词'{keywords_str}'且参与人包含'{participant}'的聊天记录"
+ elif keyword:
+ keywords_str = "、".join(parse_keywords_string(keyword))
+ keywords_list = parse_keywords_string(keyword)
+ if len(keywords_list) > 2:
+ required_count = len(keywords_list) - 1
+ return f"未找到包含至少{required_count}个关键词（共{len(keywords_list)}个）'{keywords_str}'的聊天记录"
else:
- return f"未找到{match_mode}'{keywords_str}'的聊天记录概述"
-
- records = filtered_records
-
- # 如果没有记录（可能是时间范围查询但没有匹配的记录）
- if not records:
- if time_range:
- return "未找到指定时间范围内的聊天记录概述"
+ return f"未找到包含所有关键词'{keywords_str}'的聊天记录"
+ elif participant:
+ return f"未找到参与人包含'{participant}'的聊天记录"
else:
- return "未找到相关聊天记录概述"
+ return "未找到相关聊天记录"
- # 对即将返回的记录增加使用计数
- records_to_use = records[:3]
- for record in records_to_use:
- try:
- ChatHistory.update(count=ChatHistory.count + 1).where(ChatHistory.id == record.id).execute()
- record.count = (record.count or 0) + 1
- except Exception as update_error:
- logger.error(f"更新聊天记录概述计数失败: {update_error}")
-
- # 构建结果文本
+ # 构建结果文本，返回id、theme和keywords
results = []
- for record in records_to_use: # 最多返回3条记录
+ for record in filtered_records[:20]: # 最多返回20条记录
result_parts = []
+ # 添加记忆ID
+ result_parts.append(f"记忆ID：{record.id}")
+
# 添加主题
if record.theme:
result_parts.append(f"主题：{record.theme}")
+ else:
+ result_parts.append("主题：（无）")
- # 添加时间范围
- from datetime import datetime
-
- start_str = datetime.fromtimestamp(record.start_time).strftime("%Y-%m-%d %H:%M:%S")
- end_str = datetime.fromtimestamp(record.end_time).strftime("%Y-%m-%d %H:%M:%S")
- result_parts.append(f"时间：{start_str} - {end_str}")
-
- # 添加概括（优先使用summary，如果没有则使用original_text的前200字符）
- if record.summary:
- result_parts.append(f"概括：{record.summary}")
- elif record.original_text:
- text_preview = record.original_text[:200]
- if len(record.original_text) > 200:
- text_preview += "..."
- result_parts.append(f"内容：{text_preview}")
+ # 添加关键词
+ if record.keywords:
+ try:
+ keywords_data = json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords
+ if isinstance(keywords_data, list) and keywords_data:
+ keywords_str = "、".join([str(k) for k in keywords_data])
+ result_parts.append(f"关键词：{keywords_str}")
+ else:
+ result_parts.append("关键词：（无）")
+ except (json.JSONDecodeError, TypeError, ValueError):
+ result_parts.append("关键词：（无）")
+ else:
+ result_parts.append("关键词：（无）")
results.append("\n".join(result_parts))
if not results:
- return "未找到相关聊天记录概述"
+ return "未找到相关聊天记录"
response_text = "\n\n---\n\n".join(results)
- if len(records) > len(records_to_use):
- omitted_count = len(records) - len(records_to_use)
- response_text += f"\n\n(还有{omitted_count}条历史记录已省略)"
+ if len(filtered_records) > 20:
+ omitted_count = len(filtered_records) - 20
+ response_text += f"\n\n(还有{omitted_count}条记录已省略，可使用记忆ID查询详细信息)"
return response_text
except Exception as e:
@@ -187,30 +183,145 @@ async def query_chat_history(
return f"查询失败: {str(e)}"
+async def get_chat_history_detail(chat_id: str, memory_ids: str) -> str:
+ """根据记忆ID，展示某条或某几条记忆的具体内容
+
+ Args:
+ chat_id: 聊天ID
+ memory_ids: 记忆ID，可以是单个ID（如"123"）或多个ID（用逗号分隔，如"1,2,3"）
+
+ Returns:
+ str: 记忆的详细内容
+ """
+ try:
+ # 解析memory_ids
+ id_list = []
+ # 尝试解析为逗号分隔的ID列表
+ try:
+ id_list = [int(id_str.strip()) for id_str in memory_ids.split(",") if id_str.strip()]
+ except ValueError:
+ return f"无效的记忆ID格式: {memory_ids}，请使用数字ID，多个ID用逗号分隔（如：'123' 或 '123,456'）"
+
+ if not id_list:
+ return "未提供有效的记忆ID"
+
+ # 查询记录
+ query = ChatHistory.select().where((ChatHistory.chat_id == chat_id) & (ChatHistory.id.in_(id_list)))
+ records = list(query.order_by(ChatHistory.start_time.desc()))
+
+ if not records:
+ return f"未找到ID为{id_list}的记忆记录（可能ID不存在或不属于当前聊天）"
+
+ # 对即将返回的记录增加使用计数
+ for record in records:
+ try:
+ ChatHistory.update(count=ChatHistory.count + 1).where(ChatHistory.id == record.id).execute()
+ record.count = (record.count or 0) + 1
+ except Exception as update_error:
+ logger.error(f"更新聊天记录概述计数失败: {update_error}")
+
+ # 构建详细结果
+ results = []
+ for record in records:
+ result_parts = []
+
+ # 添加记忆ID
+ result_parts.append(f"记忆ID：{record.id}")
+
+ # 添加主题
+ if record.theme:
+ result_parts.append(f"主题：{record.theme}")
+
+ # 添加时间范围
+ start_str = datetime.fromtimestamp(record.start_time).strftime("%Y-%m-%d %H:%M:%S")
+ end_str = datetime.fromtimestamp(record.end_time).strftime("%Y-%m-%d %H:%M:%S")
+ result_parts.append(f"时间：{start_str} - {end_str}")
+
+ # 添加参与人
+ if record.participants:
+ try:
+ participants_data = (
+ json.loads(record.participants) if isinstance(record.participants, str) else record.participants
+ )
+ if isinstance(participants_data, list) and participants_data:
+ participants_str = "、".join([str(p) for p in participants_data])
+ result_parts.append(f"参与人：{participants_str}")
+ except (json.JSONDecodeError, TypeError, ValueError):
+ pass
+
+ # 添加关键词
+ if record.keywords:
+ try:
+ keywords_data = json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords
+ if isinstance(keywords_data, list) and keywords_data:
+ keywords_str = "、".join([str(k) for k in keywords_data])
+ result_parts.append(f"关键词：{keywords_str}")
+ except (json.JSONDecodeError, TypeError, ValueError):
+ pass
+
+ # 添加概括
+ if record.summary:
+ result_parts.append(f"概括：{record.summary}")
+
+ # 添加关键信息点
+ if record.key_point:
+ try:
+ key_point_data = (
+ json.loads(record.key_point) if isinstance(record.key_point, str) else record.key_point
+ )
+ if isinstance(key_point_data, list) and key_point_data:
+ key_point_str = "\n".join([f" - {str(kp)}" for kp in key_point_data])
+ result_parts.append(f"关键信息点：\n{key_point_str}")
+ except (json.JSONDecodeError, TypeError, ValueError):
+ pass
+
+ results.append("\n".join(result_parts))
+
+ if not results:
+ return "未找到相关记忆记录"
+
+ response_text = "\n\n" + "=" * 50 + "\n\n".join(results)
+ return response_text
+
+ except Exception as e:
+ logger.error(f"获取记忆详情失败: {e}")
+ return f"查询失败: {str(e)}"
+
+
def register_tool():
"""注册工具"""
+ # 注册工具1：搜索记忆
register_memory_retrieval_tool(
- name="query_chat_history",
- description="根据时间或关键词在聊天记录中查询。可以查询某个时间点发生了什么、某个时间范围内的事件，或根据关键词搜索消息概述。支持两种匹配模式：模糊匹配（默认，只要包含任意一个关键词即匹配）和全匹配（必须包含所有关键词才匹配）",
+ name="search_chat_history",
+ description="根据关键词或参与人查询记忆，返回匹配的记忆id、记忆标题theme和关键词keywords。用于快速搜索和定位相关记忆。匹配规则：如果关键词数量<=2，必须全部匹配；如果关键词数量>2，允许n-1个关键词匹配（容错匹配）。",
parameters=[
{
"name": "keyword",
"type": "string",
- "description": "关键词（可选，支持多个关键词，可用空格、逗号、斜杠等分隔，如：'麦麦 百度网盘' 或 '麦麦,百度网盘'。用于在主题、关键词、概括、原文中搜索）",
+ "description": "关键词（可选，支持多个关键词，可用空格、逗号、斜杠等分隔，如：'麦麦 百度网盘' 或 '麦麦,百度网盘'。用于在主题、关键词、概括、原文中搜索。匹配规则：如果关键词数量<=2，必须全部匹配；如果关键词数量>2，允许n-1个关键词匹配）",
"required": False,
},
{
- "name": "time_range",
+ "name": "participant",
"type": "string",
- "description": "时间范围或时间点（可选）。格式：'YYYY-MM-DD HH:MM:SS - YYYY-MM-DD HH:MM:SS'（时间范围，查询与时间范围有交集的记录）或 'YYYY-MM-DD HH:MM:SS'（时间点，查询包含该时间点的记录）",
- "required": False,
- },
- {
- "name": "fuzzy",
- "type": "boolean",
- "description": "是否使用模糊匹配模式（默认True）。True表示模糊匹配（只要包含任意一个关键词即匹配，OR关系），False表示全匹配（必须包含所有关键词才匹配，AND关系）",
+ "description": "参与人昵称（可选），用于查询包含该参与人的记忆",
"required": False,
},
],
- execute_func=query_chat_history,
+ execute_func=search_chat_history,
+ )
+
+ # 注册工具2：获取记忆详情
+ register_memory_retrieval_tool(
+ name="get_chat_history_detail",
+ description="根据记忆ID，展示某条或某几条记忆的具体内容。包括主题、时间、参与人、关键词、概括和关键信息点等详细信息。需要先使用search_chat_history工具获取记忆ID。",
+ parameters=[
+ {
+ "name": "memory_ids",
+ "type": "string",
+ "description": "记忆ID，可以是单个ID（如'123'）或多个ID（用逗号分隔，如'123,456,789'）",
+ "required": True,
+ },
+ ],
+ execute_func=get_chat_history_detail,
)
diff --git a/src/memory_system/retrieval_tools/query_jargon.py b/src/memory_system/retrieval_tools/query_jargon.py
deleted file mode 100644
index 65050b85..00000000
--- a/src/memory_system/retrieval_tools/query_jargon.py
+++ /dev/null
@@ -1,76 +0,0 @@
-"""
-根据关键词在jargon库中查询 - 工具实现
-"""
-
-from src.common.logger import get_logger
-from src.jargon.jargon_miner import search_jargon
-from .tool_registry import register_memory_retrieval_tool
-
-logger = get_logger("memory_retrieval_tools")
-
-
-async def query_jargon(keyword: str, chat_id: str) -> str:
- """根据关键词在jargon库中查询
-
- Args:
- keyword: 关键词（黑话/俚语/缩写）
- chat_id: 聊天ID
-
- Returns:
- str: 查询结果
- """
- try:
- content = str(keyword).strip()
- if not content:
- return "关键词为空"
-
- # 先尝试精确匹配
- results = search_jargon(keyword=content, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=False)
-
- is_fuzzy_match = False
-
- # 如果精确匹配未找到，尝试模糊搜索
- if not results:
- results = search_jargon(keyword=content, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=True)
- is_fuzzy_match = True
-
- if results:
- # 如果是模糊匹配，显示找到的实际jargon内容
- if is_fuzzy_match:
- # 处理多个结果
- output_parts = [f"未精确匹配到'{content}'"]
- for result in results:
- found_content = result.get("content", "").strip()
- meaning = result.get("meaning", "").strip()
- if found_content and meaning:
- output_parts.append(f"找到 '{found_content}' 的含义为：{meaning}")
- output = "，".join(output_parts)
- logger.info(f"在jargon库中找到匹配（当前会话或全局，模糊搜索）: {content}，找到{len(results)}条结果")
- else:
- # 精确匹配，可能有多条（相同content但不同chat_id的情况）
- output_parts = []
- for result in results:
- meaning = result.get("meaning", "").strip()
- if meaning:
- output_parts.append(f"'{content}' 为黑话或者网络简写，含义为：{meaning}")
- output = "；".join(output_parts) if len(output_parts) > 1 else output_parts[0]
- logger.info(f"在jargon库中找到匹配（当前会话或全局，精确匹配）: {content}，找到{len(results)}条结果")
- return output
-
- # 未命中
- logger.info(f"在jargon库中未找到匹配（当前会话或全局，精确匹配和模糊搜索都未找到）: {content}")
- return f"未在jargon库中找到'{content}'的解释"
-
- except Exception as e:
- logger.error(f"查询jargon失败: {e}")
- return f"查询失败: {str(e)}"
-
-
-def register_tool():
- """注册工具"""
- register_memory_retrieval_tool(
- name="query_jargon",
- description="根据关键词在jargon库中查询黑话/俚语/缩写的含义。支持大小写不敏感搜索，默认会先尝试精确匹配，如果找不到则自动使用模糊搜索。仅搜索当前会话或全局jargon。",
- parameters=[{"name": "keyword", "type": "string", "description": "关键词（黑话/俚语/缩写）", "required": True}],
- execute_func=query_jargon,
- )
diff --git a/src/memory_system/retrieval_tools/query_person_info.py b/src/memory_system/retrieval_tools/query_person_info.py
index bc192722..0f335cf1 100644
--- a/src/memory_system/retrieval_tools/query_person_info.py
+++ b/src/memory_system/retrieval_tools/query_person_info.py
@@ -12,6 +12,25 @@ from .tool_registry import register_memory_retrieval_tool
logger = get_logger("memory_retrieval_tools")
+def _calculate_similarity(query: str, target: str) -> float:
+ """计算查询词在目标字符串中的相似度比例
+
+ Args:
+ query: 查询词
+ target: 目标字符串
+
+ Returns:
+ float: 相似度比例（0.0-1.0），查询词长度 / 目标字符串长度
+ """
+ if not query or not target:
+ return 0.0
+ query_len = len(query)
+ target_len = len(target)
+ if target_len == 0:
+ return 0.0
+ return query_len / target_len
+
+
def _format_group_nick_names(group_nick_name_field) -> str:
"""格式化群昵称信息
@@ -81,11 +100,29 @@ async def query_person_info(person_name: str) -> str:
if not records:
return f"未找到模糊匹配'{person_name}'的用户信息"
+ # 根据相似度过滤结果：查询词在目标字符串中至少占50%
+ SIMILARITY_THRESHOLD = 0.5
+ filtered_records = []
+ for record in records:
+ if not record.person_name:
+ continue
+ # 精确匹配总是保留（相似度100%）
+ if record.person_name.strip() == person_name:
+ filtered_records.append(record)
+ else:
+ # 模糊匹配需要检查相似度
+ similarity = _calculate_similarity(person_name, record.person_name.strip())
+ if similarity >= SIMILARITY_THRESHOLD:
+ filtered_records.append(record)
+
+ if not filtered_records:
+ return f"未找到相似度≥50%的匹配'{person_name}'的用户信息"
+
# 区分精确匹配和模糊匹配的结果
exact_matches = []
fuzzy_matches = []
- for record in records:
+ for record in filtered_records:
# 检查是否是精确匹配
if record.person_name and record.person_name.strip() == person_name:
exact_matches.append(record)
@@ -248,7 +285,7 @@ async def query_person_info(person_name: str) -> str:
response_text = "\n\n---\n\n".join(results)
# 添加统计信息
- total_count = len(records)
+ total_count = len(filtered_records)
exact_count = len(exact_matches)
fuzzy_count = len(fuzzy_matches)
diff --git a/src/plugin_system/apis/emoji_api.py b/src/plugin_system/apis/emoji_api.py
index e1661887..e4d6fcd7 100644
--- a/src/plugin_system/apis/emoji_api.py
+++ b/src/plugin_system/apis/emoji_api.py
@@ -104,7 +104,7 @@ async def get_random(count: Optional[int] = 1) -> List[Tuple[str, str, str]]:
return []
if len(valid_emojis) < count:
- logger.warning(
+ logger.debug(
f"[EmojiAPI] 有效表情包数量 ({len(valid_emojis)}) 少于请求的数量 ({count})，将返回所有有效表情包"
)
count = len(valid_emojis)
diff --git a/src/plugin_system/apis/message_api.py b/src/plugin_system/apis/message_api.py
index cfacd558..6a4805b2 100644
--- a/src/plugin_system/apis/message_api.py
+++ b/src/plugin_system/apis/message_api.py
@@ -72,6 +72,7 @@ def get_messages_by_time_in_chat(
limit_mode: str = "latest",
filter_mai: bool = False,
filter_command: bool = False,
+ filter_no_read_command: bool = False,
) -> List[DatabaseMessages]:
"""
获取指定聊天中指定时间范围内的消息
@@ -110,6 +111,7 @@ def get_messages_by_time_in_chat(
limit_mode=limit_mode,
filter_bot=filter_mai,
filter_command=filter_command,
+ filter_no_read_command=filter_no_read_command,
)
@@ -121,6 +123,7 @@ def get_messages_by_time_in_chat_inclusive(
limit_mode: str = "latest",
filter_mai: bool = False,
filter_command: bool = False,
+ filter_no_read_command: bool = False,
) -> List[DatabaseMessages]:
"""
获取指定聊天中指定时间范围内的消息（包含边界）
@@ -147,15 +150,19 @@ def get_messages_by_time_in_chat_inclusive(
raise ValueError("chat_id 不能为空")
if not isinstance(chat_id, str):
raise ValueError("chat_id 必须是字符串类型")
- if filter_mai:
- return filter_mai_messages(
- get_raw_msg_by_timestamp_with_chat_inclusive(
- chat_id, start_time, end_time, limit, limit_mode, filter_command
- )
- )
- return get_raw_msg_by_timestamp_with_chat_inclusive(
- chat_id, start_time, end_time, limit, limit_mode, filter_command
+ messages = get_raw_msg_by_timestamp_with_chat_inclusive(
+ chat_id=chat_id,
+ timestamp_start=start_time,
+ timestamp_end=end_time,
+ limit=limit,
+ limit_mode=limit_mode,
+ filter_bot=filter_mai,
+ filter_command=filter_command,
+ filter_no_read_command=filter_no_read_command,
)
+ if filter_mai:
+ return filter_mai_messages(messages)
+ return messages
def get_messages_by_time_in_chat_for_users(
@@ -273,7 +280,11 @@ def get_messages_before_time(timestamp: float, limit: int = 0, filter_mai: bool
def get_messages_before_time_in_chat(
- chat_id: str, timestamp: float, limit: int = 0, filter_mai: bool = False
+ chat_id: str,
+ timestamp: float,
+ limit: int = 0,
+ filter_mai: bool = False,
+ filter_no_read_command: bool = False,
) -> List[DatabaseMessages]:
"""
获取指定聊天中指定时间戳之前的消息
@@ -298,9 +309,15 @@ def get_messages_before_time_in_chat(
raise ValueError("chat_id 不能为空")
if not isinstance(chat_id, str):
raise ValueError("chat_id 必须是字符串类型")
+ messages = get_raw_msg_before_timestamp_with_chat(
+ chat_id=chat_id,
+ timestamp=timestamp,
+ limit=limit,
+ filter_no_read_command=filter_no_read_command,
+ )
if filter_mai:
- return filter_mai_messages(get_raw_msg_before_timestamp_with_chat(chat_id, timestamp, limit))
- return get_raw_msg_before_timestamp_with_chat(chat_id, timestamp, limit)
+ return filter_mai_messages(messages)
+ return messages
def get_messages_before_time_for_users(
diff --git a/src/plugin_system/base/config_types.py b/src/plugin_system/base/config_types.py
index 752b3345..c8537ace 100644
--- a/src/plugin_system/base/config_types.py
+++ b/src/plugin_system/base/config_types.py
@@ -1,18 +1,263 @@
"""
插件系统配置类型定义
+
+提供插件配置的类型定义，支持 WebUI 可视化配置编辑。
"""
-from typing import Any, Optional, List
+from typing import Any, Optional, List, Dict, Union
from dataclasses import dataclass, field
@dataclass
class ConfigField:
- """配置字段定义"""
+ """
+ 配置字段定义
- type: type # 字段类型
+ 用于定义插件配置项的元数据，支持类型验证、UI 渲染等功能。
+
+ 基础示例:
+ ConfigField(type=str, default="", description="API密钥")
+
+ 完整示例:
+ ConfigField(
+ type=str,
+ default="",
+ description="API密钥",
+ input_type="password",
+ placeholder="请输入API密钥",
+ required=True,
+ hint="从服务商控制台获取",
+ order=1
+ )
+ """
+
+ # === 基础字段（必需） ===
+ type: type # 字段类型: str, int, float, bool, list, dict
default: Any # 默认值
- description: str # 字段描述
- example: Optional[str] = None # 示例值
+ description: str # 字段描述（也用作默认标签）
+
+ # === 验证相关 ===
+ example: Optional[str] = None # 示例值（用于生成配置文件注释）
required: bool = False # 是否必需
- choices: Optional[List[Any]] = field(default_factory=list) # 可选值列表
+ choices: Optional[List[Any]] = field(default_factory=list) # 可选值列表（用于下拉选择）
+ min: Optional[float] = None # 最小值（数字类型）
+ max: Optional[float] = None # 最大值（数字类型）
+ step: Optional[float] = None # 步进值（数字类型）
+ pattern: Optional[str] = None # 正则验证（字符串类型）
+ max_length: Optional[int] = None # 最大长度（字符串类型）
+
+ # === UI 显示控制 ===
+ label: Optional[str] = None # 显示标签（默认使用 description）
+ placeholder: Optional[str] = None # 输入框占位符
+ hint: Optional[str] = None # 字段下方的提示文字
+ icon: Optional[str] = None # 字段图标名称
+ hidden: bool = False # 是否在 UI 中隐藏
+ disabled: bool = False # 是否禁用编辑
+ order: int = 0 # 排序权重（数字越小越靠前）
+
+ # === 输入控件类型 ===
+ # 可选值: text, password, textarea, number, color, code, file, json
+ # 不指定时根据 type 和 choices 自动推断
+ input_type: Optional[str] = None
+
+ # === textarea 专用 ===
+ rows: int = 3 # 文本域行数
+
+ # === 分组与布局 ===
+ group: Optional[str] = None # 字段分组（在 section 内再细分）
+
+ # === 条件显示 ===
+ depends_on: Optional[str] = None # 依赖的字段路径，如 "section.field"
+ depends_value: Any = None # 依赖字段需要的值（当依赖字段等于此值时显示）
+
+ def get_ui_type(self) -> str:
+ """
+ 获取 UI 控件类型
+
+ 如果指定了 input_type 则直接返回，否则根据 type 和 choices 自动推断。
+
+ Returns:
+ 控件类型字符串
+ """
+ if self.input_type:
+ return self.input_type
+
+ # 根据 type 和 choices 自动推断
+ if self.type is bool:
+ return "switch"
+ elif self.type in (int, float):
+ if self.min is not None and self.max is not None:
+ return "slider"
+ return "number"
+ elif self.type is str:
+ if self.choices:
+ return "select"
+ return "text"
+ elif self.type is list:
+ return "list"
+ elif self.type is dict:
+ return "json"
+ else:
+ return "text"
+
+ def to_dict(self) -> Dict[str, Any]:
+ """
+ 转换为可序列化的字典（用于 API 传输）
+
+ Returns:
+ 包含所有配置信息的字典
+ """
+ return {
+ "type": self.type.__name__ if isinstance(self.type, type) else str(self.type),
+ "default": self.default,
+ "description": self.description,
+ "example": self.example,
+ "required": self.required,
+ "choices": self.choices if self.choices else None,
+ "min": self.min,
+ "max": self.max,
+ "step": self.step,
+ "pattern": self.pattern,
+ "max_length": self.max_length,
+ "label": self.label or self.description,
+ "placeholder": self.placeholder,
+ "hint": self.hint,
+ "icon": self.icon,
+ "hidden": self.hidden,
+ "disabled": self.disabled,
+ "order": self.order,
+ "input_type": self.input_type,
+ "ui_type": self.get_ui_type(),
+ "rows": self.rows,
+ "group": self.group,
+ "depends_on": self.depends_on,
+ "depends_value": self.depends_value,
+ }
+
+
+@dataclass
+class ConfigSection:
+ """
+ 配置节定义
+
+ 用于描述配置文件中一个 section 的元数据。
+
+ 示例:
+ ConfigSection(
+ title="API配置",
+ description="外部API连接参数",
+ icon="cloud",
+ order=1
+ )
+ """
+
+ title: str # 显示标题
+ description: Optional[str] = None # 详细描述
+ icon: Optional[str] = None # 图标名称
+ collapsed: bool = False # 默认是否折叠
+ order: int = 0 # 排序权重
+
+ def to_dict(self) -> Dict[str, Any]:
+ """转换为可序列化的字典"""
+ return {
+ "title": self.title,
+ "description": self.description,
+ "icon": self.icon,
+ "collapsed": self.collapsed,
+ "order": self.order,
+ }
+
+
+@dataclass
+class ConfigTab:
+ """
+ 配置标签页定义
+
+ 用于将多个 section 组织到一个标签页中。
+
+ 示例:
+ ConfigTab(
+ id="general",
+ title="通用设置",
+ icon="settings",
+ sections=["plugin", "api"]
+ )
+ """
+
+ id: str # 标签页 ID
+ title: str # 显示标题
+ sections: List[str] = field(default_factory=list) # 包含的 section 名称列表
+ icon: Optional[str] = None # 图标名称
+ order: int = 0 # 排序权重
+ badge: Optional[str] = None # 角标文字（如 "Beta", "New"）
+
+ def to_dict(self) -> Dict[str, Any]:
+ """转换为可序列化的字典"""
+ return {
+ "id": self.id,
+ "title": self.title,
+ "sections": self.sections,
+ "icon": self.icon,
+ "order": self.order,
+ "badge": self.badge,
+ }
+
+
+@dataclass
+class ConfigLayout:
+ """
+ 配置页面布局定义
+
+ 用于定义插件配置页面的整体布局结构。
+
+ 布局类型:
+ - "auto": 自动布局，sections 作为折叠面板显示
+ - "tabs": 标签页布局
+ - "pages": 分页布局（左侧导航 + 右侧内容）
+
+ 简单示例（标签页布局）:
+ ConfigLayout(
+ type="tabs",
+ tabs=[
+ ConfigTab(id="basic", title="基础", sections=["plugin", "api"]),
+ ConfigTab(id="advanced", title="高级", sections=["debug"]),
+ ]
+ )
+ """
+
+ type: str = "auto" # 布局类型: auto, tabs, pages
+ tabs: List[ConfigTab] = field(default_factory=list) # 标签页列表
+
+ def to_dict(self) -> Dict[str, Any]:
+ """转换为可序列化的字典"""
+ return {
+ "type": self.type,
+ "tabs": [tab.to_dict() for tab in self.tabs],
+ }
+
+
+def section_meta(
+ title: str, description: Optional[str] = None, icon: Optional[str] = None, collapsed: bool = False, order: int = 0
+) -> Union[str, ConfigSection]:
+ """
+ 便捷函数：创建 section 元数据
+
+ 可以在 config_section_descriptions 中使用，提供比纯字符串更丰富的信息。
+
+ Args:
+ title: 显示标题
+ description: 详细描述
+ icon: 图标名称
+ collapsed: 默认是否折叠
+ order: 排序权重
+
+ Returns:
+ ConfigSection 实例
+
+ 示例:
+ config_section_descriptions = {
+ "api": section_meta("API配置", icon="cloud", order=1),
+ "debug": section_meta("调试设置", collapsed=True, order=99),
+ }
+ """
+ return ConfigSection(title=title, description=description, icon=icon, collapsed=collapsed, order=order)
diff --git a/src/plugin_system/base/plugin_base.py b/src/plugin_system/base/plugin_base.py
index 0b7f15d1..f21c2a40 100644
--- a/src/plugin_system/base/plugin_base.py
+++ b/src/plugin_system/base/plugin_base.py
@@ -12,7 +12,11 @@ from src.plugin_system.base.component_types import (
PluginInfo,
PythonDependency,
)
-from src.plugin_system.base.config_types import ConfigField
+from src.plugin_system.base.config_types import (
+ ConfigField,
+ ConfigSection,
+ ConfigLayout,
+)
from src.plugin_system.utils.manifest_utils import ManifestValidator
logger = get_logger("plugin_base")
@@ -60,7 +64,10 @@ class PluginBase(ABC):
def config_schema(self) -> Dict[str, Union[Dict[str, ConfigField], str]]:
return {}
- config_section_descriptions: Dict[str, str] = {}
+ config_section_descriptions: Dict[str, Union[str, ConfigSection]] = {}
+
+ # 布局配置（可选，不定义则使用自动布局）
+ config_layout: ConfigLayout = None
def __init__(self, plugin_dir: str):
"""初始化插件
@@ -205,6 +212,22 @@ class PluginBase(ABC):
return value
+ def _format_toml_value(self, value: Any) -> str:
+ """将Python值格式化为合法的TOML字符串"""
+ if isinstance(value, str):
+ return json.dumps(value, ensure_ascii=False)
+ if isinstance(value, bool):
+ return str(value).lower()
+ if isinstance(value, (int, float)):
+ return str(value)
+ if isinstance(value, list):
+ inner = ", ".join(self._format_toml_value(item) for item in value)
+ return f"[{inner}]"
+ if isinstance(value, dict):
+ items = [f"{k} = {self._format_toml_value(v)}" for k, v in value.items()]
+ return "{ " + ", ".join(items) + " }"
+ return json.dumps(value, ensure_ascii=False)
+
def _generate_and_save_default_config(self, config_file_path: str):
"""根据插件的Schema生成并保存默认配置文件"""
if not self.config_schema:
@@ -244,12 +267,7 @@ class PluginBase(ABC):
# 添加字段值
value = field.default
- if isinstance(value, str):
- toml_str += f'{field_name} = "{value}"\n'
- elif isinstance(value, bool):
- toml_str += f"{field_name} = {str(value).lower()}\n"
- else:
- toml_str += f"{field_name} = {value}\n"
+ toml_str += f"{field_name} = {self._format_toml_value(value)}\n"
toml_str += "\n"
toml_str += "\n"
@@ -422,19 +440,7 @@ class PluginBase(ABC):
# 添加字段值（使用迁移后的值）
value = section_data.get(field_name, field.default)
- if isinstance(value, str):
- toml_str += f'{field_name} = "{value}"\n'
- elif isinstance(value, bool):
- toml_str += f"{field_name} = {str(value).lower()}\n"
- elif isinstance(value, list):
- # 格式化列表
- if all(isinstance(item, str) for item in value):
- formatted_list = "[" + ", ".join(f'"{item}"' for item in value) + "]"
- else:
- formatted_list = str(value)
- toml_str += f"{field_name} = {formatted_list}\n"
- else:
- toml_str += f"{field_name} = {value}\n"
+ toml_str += f"{field_name} = {self._format_toml_value(value)}\n"
toml_str += "\n"
toml_str += "\n"
@@ -564,6 +570,93 @@ class PluginBase(ABC):
return current
+ def get_webui_config_schema(self) -> Dict[str, Any]:
+ """
+ 获取 WebUI 配置 Schema
+
+ 返回完整的配置 schema，包含：
+ - 插件基本信息
+ - 所有 section 及其字段定义
+ - 布局配置
+
+ 用于 WebUI 动态生成配置表单。
+
+ Returns:
+ Dict: 完整的配置 schema
+ """
+ schema = {
+ "plugin_id": self.plugin_name,
+ "plugin_info": {
+ "name": self.display_name,
+ "version": self.plugin_version,
+ "description": self.plugin_description,
+ "author": self.plugin_author,
+ },
+ "sections": {},
+ "layout": None,
+ }
+
+ # 处理 sections
+ for section_name, fields in self.config_schema.items():
+ if not isinstance(fields, dict):
+ continue
+
+ section_data = {
+ "name": section_name,
+ "title": section_name,
+ "description": None,
+ "icon": None,
+ "collapsed": False,
+ "order": 0,
+ "fields": {},
+ }
+
+ # 获取 section 元数据
+ section_meta = self.config_section_descriptions.get(section_name)
+ if section_meta:
+ if isinstance(section_meta, str):
+ section_data["title"] = section_meta
+ elif isinstance(section_meta, ConfigSection):
+ section_data["title"] = section_meta.title
+ section_data["description"] = section_meta.description
+ section_data["icon"] = section_meta.icon
+ section_data["collapsed"] = section_meta.collapsed
+ section_data["order"] = section_meta.order
+ elif isinstance(section_meta, dict):
+ section_data.update(section_meta)
+
+ # 处理字段
+ for field_name, field_def in fields.items():
+ if isinstance(field_def, ConfigField):
+ field_data = field_def.to_dict()
+ field_data["name"] = field_name
+ section_data["fields"][field_name] = field_data
+
+ schema["sections"][section_name] = section_data
+
+ # 处理布局
+ if self.config_layout:
+ schema["layout"] = self.config_layout.to_dict()
+ else:
+ # 自动布局：按 section order 排序
+ schema["layout"] = {
+ "type": "auto",
+ "tabs": [],
+ }
+
+ return schema
+
+ def get_current_config_values(self) -> Dict[str, Any]:
+ """
+ 获取当前配置值
+
+ 返回插件当前的配置值（已从配置文件加载）。
+
+ Returns:
+ Dict: 当前配置值
+ """
+ return self.config.copy()
+
@abstractmethod
def register_plugin(self) -> bool:
"""
diff --git a/src/plugin_system/core/tool_use.py b/src/plugin_system/core/tool_use.py
index 915ed7aa..6d60ee77 100644
--- a/src/plugin_system/core/tool_use.py
+++ b/src/plugin_system/core/tool_use.py
@@ -95,7 +95,7 @@ class ToolExecutor:
# 如果没有可用工具，直接返回空内容
if not tools:
- logger.info(f"{self.log_prefix}没有可用工具，直接返回空内容")
+ logger.debug(f"{self.log_prefix}没有可用工具，直接返回空内容")
if return_details:
return [], [], ""
else:
diff --git a/src/plugins/built_in/knowledge/lpmm_get_knowledge.py b/src/plugins/built_in/knowledge/lpmm_get_knowledge.py
index 174bef1c..bb627e5e 100644
--- a/src/plugins/built_in/knowledge/lpmm_get_knowledge.py
+++ b/src/plugins/built_in/knowledge/lpmm_get_knowledge.py
@@ -15,7 +15,7 @@ class SearchKnowledgeFromLPMMTool(BaseTool):
description = "从知识库中搜索相关信息，如果你需要知识，就使用这个工具"
parameters = [
("query", ToolParamType.STRING, "搜索查询关键词", True, None),
- ("limit", ToolParamType.INTEGER, "希望返回的相关知识条数，默认5", False, 5),
+ ("limit", ToolParamType.INTEGER, "希望返回的相关知识条数，默认5", False, None),
]
available_for_llm = global_config.lpmm_knowledge.enable
diff --git a/src/webui/auth.py b/src/webui/auth.py
new file mode 100644
index 00000000..8d52a5e3
--- /dev/null
+++ b/src/webui/auth.py
@@ -0,0 +1,127 @@
+"""
+WebUI 认证模块
+提供统一的认证依赖，支持 Cookie 和 Header 两种方式
+"""
+
+from typing import Optional
+from fastapi import HTTPException, Cookie, Header, Response, Request
+from src.common.logger import get_logger
+from .token_manager import get_token_manager
+
+logger = get_logger("webui.auth")
+
+# Cookie 配置
+COOKIE_NAME = "maibot_session"
+COOKIE_MAX_AGE = 7 * 24 * 60 * 60 # 7天
+
+
+def get_current_token(
+ request: Request,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+) -> str:
+ """
+ 获取当前请求的 token，优先从 Cookie 获取，其次从 Header 获取
+
+ Args:
+ request: FastAPI Request 对象
+ maibot_session: Cookie 中的 token
+ authorization: Authorization Header (Bearer token)
+
+ Returns:
+ 验证通过的 token
+
+ Raises:
+ HTTPException: 认证失败时抛出 401 错误
+ """
+ token = None
+
+ # 优先从 Cookie 获取
+ if maibot_session:
+ token = maibot_session
+ # 其次从 Header 获取（兼容旧版本）
+ elif authorization and authorization.startswith("Bearer "):
+ token = authorization.replace("Bearer ", "")
+
+ if not token:
+ raise HTTPException(status_code=401, detail="未提供有效的认证信息")
+
+ # 验证 token
+ token_manager = get_token_manager()
+ if not token_manager.verify_token(token):
+ raise HTTPException(status_code=401, detail="Token 无效或已过期")
+
+ return token
+
+
+def set_auth_cookie(response: Response, token: str) -> None:
+ """
+ 设置认证 Cookie
+
+ Args:
+ response: FastAPI Response 对象
+ token: 要设置的 token
+ """
+ response.set_cookie(
+ key=COOKIE_NAME,
+ value=token,
+ max_age=COOKIE_MAX_AGE,
+ httponly=True, # 防止 JS 读取
+ samesite="lax", # 允许同站导航时发送 Cookie（兼容开发环境代理）
+ secure=False, # 本地开发不强制 HTTPS，生产环境建议设为 True
+ path="/", # 确保 Cookie 在所有路径下可用
+ )
+ logger.debug(f"已设置认证 Cookie: {token[:8]}...")
+
+
+def clear_auth_cookie(response: Response) -> None:
+ """
+ 清除认证 Cookie
+
+ Args:
+ response: FastAPI Response 对象
+ """
+ response.delete_cookie(
+ key=COOKIE_NAME,
+ httponly=True,
+ samesite="lax",
+ path="/",
+ )
+ logger.debug("已清除认证 Cookie")
+
+
+def verify_auth_token_from_cookie_or_header(
+ maibot_session: Optional[str] = None,
+ authorization: Optional[str] = None,
+) -> bool:
+ """
+ 验证认证 Token，支持从 Cookie 或 Header 获取
+
+ Args:
+ maibot_session: Cookie 中的 token
+ authorization: Authorization header (Bearer token)
+
+ Returns:
+ 验证成功返回 True
+
+ Raises:
+ HTTPException: 认证失败时抛出 401 错误
+ """
+ token = None
+
+ # 优先从 Cookie 获取
+ if maibot_session:
+ token = maibot_session
+ # 其次从 Header 获取（兼容旧版本）
+ elif authorization and authorization.startswith("Bearer "):
+ token = authorization.replace("Bearer ", "")
+
+ if not token:
+ raise HTTPException(status_code=401, detail="未提供有效的认证信息")
+
+ # 验证 token
+ token_manager = get_token_manager()
+ if not token_manager.verify_token(token):
+ raise HTTPException(status_code=401, detail="Token 无效或已过期")
+
+ return True
diff --git a/src/webui/chat_routes.py b/src/webui/chat_routes.py
new file mode 100644
index 00000000..14d8d9d2
--- /dev/null
+++ b/src/webui/chat_routes.py
@@ -0,0 +1,729 @@
+"""本地聊天室路由 - WebUI 与麦麦直接对话
+
+支持两种模式：
+1. WebUI 模式：使用 WebUI 平台独立身份聊天
+2. 虚拟身份模式：使用真实平台用户的身份，在虚拟群聊中与麦麦对话
+"""
+
+import time
+import uuid
+from typing import Dict, Any, Optional, List
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query
+from pydantic import BaseModel
+
+from src.common.logger import get_logger
+from src.common.database.database_model import Messages, PersonInfo
+from src.config.config import global_config
+from src.chat.message_receive.bot import chat_bot
+
+logger = get_logger("webui.chat")
+
+router = APIRouter(prefix="/api/chat", tags=["LocalChat"])
+
+# WebUI 聊天的虚拟群组 ID
+WEBUI_CHAT_GROUP_ID = "webui_local_chat"
+WEBUI_CHAT_PLATFORM = "webui"
+
+# 虚拟身份模式的群 ID 前缀
+VIRTUAL_GROUP_ID_PREFIX = "webui_virtual_group_"
+
+# 固定的 WebUI 用户 ID 前缀
+WEBUI_USER_ID_PREFIX = "webui_user_"
+
+
+class VirtualIdentityConfig(BaseModel):
+ """虚拟身份配置"""
+
+ enabled: bool = False # 是否启用虚拟身份模式
+ platform: Optional[str] = None # 目标平台（如 qq, discord 等）
+ person_id: Optional[str] = None # PersonInfo 的 person_id
+ user_id: Optional[str] = None # 原始平台用户 ID
+ user_nickname: Optional[str] = None # 用户昵称
+ group_id: Optional[str] = None # 虚拟群 ID（自动生成或用户指定）
+ group_name: Optional[str] = None # 虚拟群名（用户自定义）
+
+
+class ChatHistoryMessage(BaseModel):
+ """聊天历史消息"""
+
+ id: str
+ type: str # 'user' | 'bot' | 'system'
+ content: str
+ timestamp: float
+ sender_name: str
+ sender_id: Optional[str] = None
+ is_bot: bool = False
+
+
+class ChatHistoryManager:
+ """聊天历史管理器 - 使用 SQLite 数据库存储"""
+
+ def __init__(self, max_messages: int = 200):
+ self.max_messages = max_messages
+
+ def _message_to_dict(self, msg: Messages, group_id: Optional[str] = None) -> Dict[str, Any]:
+ """将数据库消息转换为前端格式
+
+ Args:
+ msg: 数据库消息对象
+ group_id: 群 ID，用于判断是否是虚拟群
+ """
+ # 判断是否是机器人消息
+ user_id = msg.user_id or ""
+
+ # 对于虚拟群，通过比较机器人 QQ 账号来判断
+ # 对于普通 WebUI 群，检查 user_id 是否以 webui_ 开头
+ if group_id and group_id.startswith(VIRTUAL_GROUP_ID_PREFIX):
+ # 虚拟群：user_id 等于机器人 QQ 账号的是机器人消息
+ bot_qq = str(global_config.bot.qq_account)
+ is_bot = user_id == bot_qq
+ else:
+ # 普通 WebUI 群：不以 webui_ 开头的是机器人消息
+ is_bot = not user_id.startswith("webui_") and not user_id.startswith(WEBUI_USER_ID_PREFIX)
+
+ return {
+ "id": msg.message_id,
+ "type": "bot" if is_bot else "user",
+ "content": msg.processed_plain_text or msg.display_message or "",
+ "timestamp": msg.time,
+ "sender_name": msg.user_nickname or (global_config.bot.nickname if is_bot else "未知用户"),
+ "sender_id": "bot" if is_bot else user_id,
+ "is_bot": is_bot,
+ }
+
+ def get_history(self, limit: int = 50, group_id: Optional[str] = None) -> List[Dict[str, Any]]:
+ """从数据库获取最近的历史记录
+
+ Args:
+ limit: 获取的消息数量
+ group_id: 群 ID，默认为 WEBUI_CHAT_GROUP_ID
+ """
+ target_group_id = group_id if group_id else WEBUI_CHAT_GROUP_ID
+ try:
+ # 查询指定群的消息，按时间排序
+ messages = (
+ Messages.select()
+ .where(Messages.chat_info_group_id == target_group_id)
+ .order_by(Messages.time.desc())
+ .limit(limit)
+ )
+
+ # 转换为列表并反转（使最旧的消息在前）
+ # 传递 group_id 以便正确判断虚拟群中的机器人消息
+ result = [self._message_to_dict(msg, target_group_id) for msg in messages]
+ result.reverse()
+
+ logger.debug(f"从数据库加载了 {len(result)} 条聊天记录 (group_id={target_group_id})")
+ return result
+ except Exception as e:
+ logger.error(f"从数据库加载聊天记录失败: {e}")
+ return []
+
+ def clear_history(self, group_id: Optional[str] = None) -> int:
+ """清空聊天历史记录
+
+ Args:
+ group_id: 群 ID，默认清空 WebUI 默认聊天室
+ """
+ target_group_id = group_id if group_id else WEBUI_CHAT_GROUP_ID
+ try:
+ deleted = Messages.delete().where(Messages.chat_info_group_id == target_group_id).execute()
+ logger.info(f"已清空 {deleted} 条聊天记录 (group_id={target_group_id})")
+ return deleted
+ except Exception as e:
+ logger.error(f"清空聊天记录失败: {e}")
+ return 0
+
+
+# 全局聊天历史管理器
+chat_history = ChatHistoryManager()
+
+
+# 存储 WebSocket 连接
+class ChatConnectionManager:
+ """聊天连接管理器"""
+
+ def __init__(self):
+ self.active_connections: Dict[str, WebSocket] = {}
+ self.user_sessions: Dict[str, str] = {} # user_id -> session_id 映射
+
+ async def connect(self, websocket: WebSocket, session_id: str, user_id: str):
+ await websocket.accept()
+ self.active_connections[session_id] = websocket
+ self.user_sessions[user_id] = session_id
+ logger.info(f"WebUI 聊天会话已连接: session={session_id}, user={user_id}")
+
+ def disconnect(self, session_id: str, user_id: str):
+ if session_id in self.active_connections:
+ del self.active_connections[session_id]
+ if user_id in self.user_sessions and self.user_sessions[user_id] == session_id:
+ del self.user_sessions[user_id]
+ logger.info(f"WebUI 聊天会话已断开: session={session_id}")
+
+ async def send_message(self, session_id: str, message: dict):
+ if session_id in self.active_connections:
+ try:
+ await self.active_connections[session_id].send_json(message)
+ except Exception as e:
+ logger.error(f"发送消息失败: {e}")
+
+ async def broadcast(self, message: dict):
+ """广播消息给所有连接"""
+ for session_id in list(self.active_connections.keys()):
+ await self.send_message(session_id, message)
+
+
+chat_manager = ChatConnectionManager()
+
+
+def create_message_data(
+ content: str,
+ user_id: str,
+ user_name: str,
+ message_id: Optional[str] = None,
+ is_at_bot: bool = True,
+ virtual_config: Optional[VirtualIdentityConfig] = None,
+) -> Dict[str, Any]:
+ """创建符合麦麦消息格式的消息数据
+
+ Args:
+ content: 消息内容
+ user_id: 用户 ID
+ user_name: 用户昵称
+ message_id: 消息 ID（可选，自动生成）
+ is_at_bot: 是否 @ 机器人
+ virtual_config: 虚拟身份配置（可选，启用后使用真实平台身份）
+ """
+ if message_id is None:
+ message_id = str(uuid.uuid4())
+
+ # 确定使用的平台、群信息和用户信息
+ if virtual_config and virtual_config.enabled:
+ # 虚拟身份模式：使用真实平台身份
+ platform = virtual_config.platform or WEBUI_CHAT_PLATFORM
+ group_id = virtual_config.group_id or f"{VIRTUAL_GROUP_ID_PREFIX}{uuid.uuid4().hex[:8]}"
+ group_name = virtual_config.group_name or "WebUI虚拟群聊"
+ actual_user_id = virtual_config.user_id or user_id
+ actual_user_name = virtual_config.user_nickname or user_name
+ else:
+ # 标准 WebUI 模式
+ platform = WEBUI_CHAT_PLATFORM
+ group_id = WEBUI_CHAT_GROUP_ID
+ group_name = "WebUI本地聊天室"
+ actual_user_id = user_id
+ actual_user_name = user_name
+
+ return {
+ "message_info": {
+ "platform": platform,
+ "message_id": message_id,
+ "time": time.time(),
+ "group_info": {
+ "group_id": group_id,
+ "group_name": group_name,
+ "platform": platform,
+ },
+ "user_info": {
+ "user_id": actual_user_id,
+ "user_nickname": actual_user_name,
+ "user_cardname": actual_user_name,
+ "platform": platform,
+ },
+ "additional_config": {
+ "at_bot": is_at_bot,
+ },
+ },
+ "message_segment": {
+ "type": "seglist",
+ "data": [
+ {
+ "type": "text",
+ "data": content,
+ },
+ {
+ "type": "mention_bot",
+ "data": "1.0",
+ },
+ ],
+ },
+ "raw_message": content,
+ "processed_plain_text": content,
+ }
+
+
+@router.get("/history")
+async def get_chat_history(
+ limit: int = Query(default=50, ge=1, le=200),
+ user_id: Optional[str] = Query(default=None), # 保留参数兼容性，但不用于过滤
+ group_id: Optional[str] = Query(default=None), # 可选：指定群 ID 获取历史
+):
+ """获取聊天历史记录
+
+ 所有 WebUI 用户共享同一个聊天室，因此返回所有历史记录
+ 如果指定了 group_id，则获取该虚拟群的历史记录
+ """
+ target_group_id = group_id if group_id else WEBUI_CHAT_GROUP_ID
+ history = chat_history.get_history(limit, target_group_id)
+ return {
+ "success": True,
+ "messages": history,
+ "total": len(history),
+ }
+
+
+@router.get("/platforms")
+async def get_available_platforms():
+ """获取可用平台列表
+
+ 从 PersonInfo 表中获取所有已知的平台
+ """
+ try:
+ from peewee import fn
+
+ # 查询所有不同的平台
+ platforms = (
+ PersonInfo.select(PersonInfo.platform, fn.COUNT(PersonInfo.id).alias("count"))
+ .group_by(PersonInfo.platform)
+ .order_by(fn.COUNT(PersonInfo.id).desc())
+ )
+
+ result = []
+ for p in platforms:
+ if p.platform: # 排除空平台
+ result.append({"platform": p.platform, "count": p.count})
+
+ return {"success": True, "platforms": result}
+ except Exception as e:
+ logger.error(f"获取平台列表失败: {e}")
+ return {"success": False, "error": str(e), "platforms": []}
+
+
+@router.get("/persons")
+async def get_persons_by_platform(
+ platform: str = Query(..., description="平台名称"),
+ search: Optional[str] = Query(default=None, description="搜索关键词"),
+ limit: int = Query(default=50, ge=1, le=200),
+):
+ """获取指定平台的用户列表
+
+ Args:
+ platform: 平台名称（如 qq, discord 等）
+ search: 搜索关键词（匹配昵称、用户名、user_id）
+ limit: 返回数量限制
+ """
+ try:
+ # 构建查询
+ query = PersonInfo.select().where(PersonInfo.platform == platform)
+
+ # 搜索过滤
+ if search:
+ query = query.where(
+ (PersonInfo.person_name.contains(search))
+ | (PersonInfo.nickname.contains(search))
+ | (PersonInfo.user_id.contains(search))
+ )
+
+ # 按最后交互时间排序，优先显示活跃用户
+ from peewee import Case
+
+ query = query.order_by(Case(None, [(PersonInfo.last_know.is_null(), 1)], 0), PersonInfo.last_know.desc())
+ query = query.limit(limit)
+
+ result = []
+ for person in query:
+ result.append(
+ {
+ "person_id": person.person_id,
+ "user_id": person.user_id,
+ "person_name": person.person_name,
+ "nickname": person.nickname,
+ "is_known": person.is_known,
+ "platform": person.platform,
+ "display_name": person.person_name or person.nickname or person.user_id,
+ }
+ )
+
+ return {"success": True, "persons": result, "total": len(result)}
+ except Exception as e:
+ logger.error(f"获取用户列表失败: {e}")
+ return {"success": False, "error": str(e), "persons": []}
+
+
+@router.delete("/history")
+async def clear_chat_history(group_id: Optional[str] = Query(default=None)):
+ """清空聊天历史记录
+
+ Args:
+ group_id: 可选，指定要清空的群 ID，默认清空 WebUI 默认聊天室
+ """
+ deleted = chat_history.clear_history(group_id)
+ return {
+ "success": True,
+ "message": f"已清空 {deleted} 条聊天记录",
+ }
+
+
+@router.websocket("/ws")
+async def websocket_chat(
+ websocket: WebSocket,
+ user_id: Optional[str] = Query(default=None),
+ user_name: Optional[str] = Query(default="WebUI用户"),
+ platform: Optional[str] = Query(default=None),
+ person_id: Optional[str] = Query(default=None),
+ group_name: Optional[str] = Query(default=None),
+ group_id: Optional[str] = Query(default=None), # 前端传递的稳定 group_id
+):
+ """WebSocket 聊天端点
+
+ Args:
+ user_id: 用户唯一标识（由前端生成并持久化）
+ user_name: 用户显示昵称（可修改）
+ platform: 虚拟身份模式的平台（可选）
+ person_id: 虚拟身份模式的用户 person_id（可选）
+ group_name: 虚拟身份模式的群名（可选）
+ group_id: 虚拟身份模式的群 ID（可选，由前端生成并持久化）
+
+ 虚拟身份模式可通过 URL 参数直接配置，或通过消息中的 set_virtual_identity 配置
+ """
+ # 生成会话 ID（每次连接都是新的）
+ session_id = str(uuid.uuid4())
+
+ # 如果没有提供 user_id，生成一个新的
+ if not user_id:
+ user_id = f"{WEBUI_USER_ID_PREFIX}{uuid.uuid4().hex[:16]}"
+ elif not user_id.startswith(WEBUI_USER_ID_PREFIX):
+ # 确保 user_id 有正确的前缀
+ user_id = f"{WEBUI_USER_ID_PREFIX}{user_id}"
+
+ # 当前会话的虚拟身份配置（可通过消息动态更新）
+ current_virtual_config: Optional[VirtualIdentityConfig] = None
+
+ # 如果 URL 参数中提供了虚拟身份信息，自动配置
+ if platform and person_id:
+ try:
+ person = PersonInfo.get_or_none(PersonInfo.person_id == person_id)
+ if person:
+ # 使用前端传递的 group_id，如果没有则生成一个稳定的
+ virtual_group_id = group_id or f"{VIRTUAL_GROUP_ID_PREFIX}{platform}_{person.user_id}"
+ current_virtual_config = VirtualIdentityConfig(
+ enabled=True,
+ platform=person.platform,
+ person_id=person.person_id,
+ user_id=person.user_id,
+ user_nickname=person.person_name or person.nickname or person.user_id,
+ group_id=virtual_group_id,
+ group_name=group_name or "WebUI虚拟群聊",
+ )
+ logger.info(f"虚拟身份模式已通过 URL 参数激活: {current_virtual_config.user_nickname} @ {current_virtual_config.platform}, group_id={virtual_group_id}")
+ except Exception as e:
+ logger.warning(f"通过 URL 参数配置虚拟身份失败: {e}")
+
+ await chat_manager.connect(websocket, session_id, user_id)
+
+ try:
+ # 构建会话信息
+ session_info_data = {
+ "type": "session_info",
+ "session_id": session_id,
+ "user_id": user_id,
+ "user_name": user_name,
+ "bot_name": global_config.bot.nickname,
+ }
+
+ # 如果有虚拟身份配置，添加到会话信息中
+ if current_virtual_config and current_virtual_config.enabled:
+ session_info_data["virtual_mode"] = True
+ session_info_data["group_id"] = current_virtual_config.group_id
+ session_info_data["virtual_identity"] = {
+ "platform": current_virtual_config.platform,
+ "user_id": current_virtual_config.user_id,
+ "user_nickname": current_virtual_config.user_nickname,
+ "group_name": current_virtual_config.group_name,
+ }
+
+ # 发送会话信息（包含用户 ID，前端需要保存）
+ await chat_manager.send_message(session_id, session_info_data)
+
+ # 发送历史记录（根据模式选择不同的群）
+ if current_virtual_config and current_virtual_config.enabled:
+ history = chat_history.get_history(50, current_virtual_config.group_id)
+ else:
+ history = chat_history.get_history(50)
+ if history:
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "history",
+ "messages": history,
+ },
+ )
+
+ # 发送欢迎消息（不保存到历史）
+ if current_virtual_config and current_virtual_config.enabled:
+ welcome_msg = f"已以 {current_virtual_config.user_nickname} 的身份连接到「{current_virtual_config.group_name}」，开始与 {global_config.bot.nickname} 对话吧！"
+ else:
+ welcome_msg = f"已连接到本地聊天室，可以开始与 {global_config.bot.nickname} 对话了！"
+
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "system",
+ "content": welcome_msg,
+ "timestamp": time.time(),
+ },
+ )
+
+ while True:
+ data = await websocket.receive_json()
+
+ if data.get("type") == "message":
+ content = data.get("content", "").strip()
+ if not content:
+ continue
+
+ # 用户可以更新昵称
+ current_user_name = data.get("user_name", user_name)
+
+ message_id = str(uuid.uuid4())
+ timestamp = time.time()
+
+ # 确定发送者信息（根据是否使用虚拟身份）
+ if current_virtual_config and current_virtual_config.enabled:
+ sender_name = current_virtual_config.user_nickname or current_user_name
+ sender_user_id = current_virtual_config.user_id or user_id
+ else:
+ sender_name = current_user_name
+ sender_user_id = user_id
+
+ # 广播用户消息给所有连接（包括发送者）
+ # 注意：用户消息会在 chat_bot.message_process 中自动保存到数据库
+ await chat_manager.broadcast(
+ {
+ "type": "user_message",
+ "content": content,
+ "message_id": message_id,
+ "timestamp": timestamp,
+ "sender": {
+ "name": sender_name,
+ "user_id": sender_user_id,
+ "is_bot": False,
+ },
+ "virtual_mode": current_virtual_config.enabled if current_virtual_config else False,
+ }
+ )
+
+ # 创建麦麦消息格式
+ message_data = create_message_data(
+ content=content,
+ user_id=user_id,
+ user_name=current_user_name,
+ message_id=message_id,
+ is_at_bot=True,
+ virtual_config=current_virtual_config,
+ )
+
+ try:
+ # 显示正在输入状态
+ await chat_manager.broadcast(
+ {
+ "type": "typing",
+ "is_typing": True,
+ }
+ )
+
+ # 调用麦麦的消息处理
+ await chat_bot.message_process(message_data)
+
+ except Exception as e:
+ logger.error(f"处理消息时出错: {e}")
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "error",
+ "content": f"处理消息时出错: {str(e)}",
+ "timestamp": time.time(),
+ },
+ )
+ finally:
+ await chat_manager.broadcast(
+ {
+ "type": "typing",
+ "is_typing": False,
+ }
+ )
+
+ elif data.get("type") == "ping":
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "pong",
+ "timestamp": time.time(),
+ },
+ )
+
+ elif data.get("type") == "update_nickname":
+ # 允许用户更新昵称
+ if new_name := data.get("user_name", "").strip():
+ current_user_name = new_name
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "nickname_updated",
+ "user_name": current_user_name,
+ "timestamp": time.time(),
+ },
+ )
+
+ elif data.get("type") == "set_virtual_identity":
+ # 设置或更新虚拟身份配置
+ virtual_data = data.get("config", {})
+ if virtual_data.get("enabled"):
+ # 验证必要字段
+ if not virtual_data.get("platform") or not virtual_data.get("person_id"):
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "error",
+ "content": "虚拟身份配置缺少必要字段: platform 和 person_id",
+ "timestamp": time.time(),
+ },
+ )
+ continue
+
+ # 获取用户信息
+ try:
+ person = PersonInfo.get_or_none(PersonInfo.person_id == virtual_data.get("person_id"))
+ if not person:
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "error",
+ "content": f"找不到用户: {virtual_data.get('person_id')}",
+ "timestamp": time.time(),
+ },
+ )
+ continue
+
+ # 生成虚拟群 ID
+ custom_group_id = virtual_data.get("group_id")
+ if custom_group_id:
+ group_id = f"{VIRTUAL_GROUP_ID_PREFIX}{custom_group_id}"
+ else:
+ group_id = f"{VIRTUAL_GROUP_ID_PREFIX}{session_id[:8]}"
+
+ current_virtual_config = VirtualIdentityConfig(
+ enabled=True,
+ platform=person.platform,
+ person_id=person.person_id,
+ user_id=person.user_id,
+ user_nickname=person.person_name or person.nickname or person.user_id,
+ group_id=group_id,
+ group_name=virtual_data.get("group_name", "WebUI虚拟群聊"),
+ )
+
+ # 发送虚拟身份已激活的消息
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "virtual_identity_set",
+ "config": {
+ "enabled": True,
+ "platform": current_virtual_config.platform,
+ "user_id": current_virtual_config.user_id,
+ "user_nickname": current_virtual_config.user_nickname,
+ "group_id": current_virtual_config.group_id,
+ "group_name": current_virtual_config.group_name,
+ },
+ "timestamp": time.time(),
+ },
+ )
+
+ # 加载虚拟群的历史记录
+ virtual_history = chat_history.get_history(50, current_virtual_config.group_id)
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "history",
+ "messages": virtual_history,
+ "group_id": current_virtual_config.group_id,
+ },
+ )
+
+ # 发送系统消息
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "system",
+ "content": f"已切换到虚拟身份模式：以 {current_virtual_config.user_nickname} 的身份在「{current_virtual_config.group_name}」与 {global_config.bot.nickname} 对话",
+ "timestamp": time.time(),
+ },
+ )
+
+ except Exception as e:
+ logger.error(f"设置虚拟身份失败: {e}")
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "error",
+ "content": f"设置虚拟身份失败: {str(e)}",
+ "timestamp": time.time(),
+ },
+ )
+ else:
+ # 禁用虚拟身份模式
+ current_virtual_config = None
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "virtual_identity_set",
+ "config": {"enabled": False},
+ "timestamp": time.time(),
+ },
+ )
+
+ # 重新加载默认聊天室历史
+ default_history = chat_history.get_history(50, WEBUI_CHAT_GROUP_ID)
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "history",
+ "messages": default_history,
+ "group_id": WEBUI_CHAT_GROUP_ID,
+ },
+ )
+
+ await chat_manager.send_message(
+ session_id,
+ {
+ "type": "system",
+ "content": "已切换回 WebUI 独立用户模式",
+ "timestamp": time.time(),
+ },
+ )
+
+ except WebSocketDisconnect:
+ logger.info(f"WebSocket 断开: session={session_id}, user={user_id}")
+ except Exception as e:
+ logger.error(f"WebSocket 错误: {e}")
+ finally:
+ chat_manager.disconnect(session_id, user_id)
+
+
+@router.get("/info")
+async def get_chat_info():
+ """获取聊天室信息"""
+ return {
+ "bot_name": global_config.bot.nickname,
+ "platform": WEBUI_CHAT_PLATFORM,
+ "group_id": WEBUI_CHAT_GROUP_ID,
+ "active_sessions": len(chat_manager.active_connections),
+ }
+
+
+def get_webui_chat_broadcaster() -> tuple:
+ """获取 WebUI 聊天广播器，供外部模块使用
+
+ Returns:
+ (chat_manager, WEBUI_CHAT_PLATFORM) 元组
+ """
+ return (chat_manager, WEBUI_CHAT_PLATFORM)
diff --git a/src/webui/config_routes.py b/src/webui/config_routes.py
index 84c660ae..5e54c8f7 100644
--- a/src/webui/config_routes.py
+++ b/src/webui/config_routes.py
@@ -5,10 +5,11 @@
import os
import tomlkit
from fastapi import APIRouter, HTTPException, Body
-from typing import Any
+from typing import Any, Annotated
from src.common.logger import get_logger
-from src.config.config import Config, APIAdapterConfig, CONFIG_DIR
+from src.common.toml_utils import save_toml_with_format
+from src.config.config import Config, APIAdapterConfig, CONFIG_DIR, PROJECT_ROOT
from src.config.official_configs import (
BotConfig,
PersonalityConfig,
@@ -41,6 +42,12 @@ from src.webui.config_schema import ConfigSchemaGenerator
logger = get_logger("webui")
+# 模块级别的类型别名（解决 B008 ruff 错误）
+ConfigBody = Annotated[dict[str, Any], Body()]
+SectionBody = Annotated[Any, Body()]
+RawContentBody = Annotated[str, Body(embed=True)]
+PathBody = Annotated[dict[str, str], Body()]
+
router = APIRouter(prefix="/config", tags=["config"])
@@ -90,7 +97,7 @@ async def get_bot_config_schema():
return {"success": True, "schema": schema}
except Exception as e:
logger.error(f"获取配置架构失败: {e}")
- raise HTTPException(status_code=500, detail=f"获取配置架构失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"获取配置架构失败: {str(e)}") from e
@router.get("/schema/model")
@@ -101,7 +108,7 @@ async def get_model_config_schema():
return {"success": True, "schema": schema}
except Exception as e:
logger.error(f"获取模型配置架构失败: {e}")
- raise HTTPException(status_code=500, detail=f"获取模型配置架构失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"获取模型配置架构失败: {str(e)}") from e
# ===== 子配置架构获取接口 =====
@@ -174,7 +181,7 @@ async def get_config_section_schema(section_name: str):
return {"success": True, "schema": schema}
except Exception as e:
logger.error(f"获取配置节架构失败: {e}")
- raise HTTPException(status_code=500, detail=f"获取配置节架构失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"获取配置节架构失败: {str(e)}") from e
# ===== 配置读取接口 =====
@@ -196,7 +203,7 @@ async def get_bot_config():
raise
except Exception as e:
logger.error(f"读取配置文件失败: {e}")
- raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") from e
@router.get("/model")
@@ -215,26 +222,25 @@ async def get_model_config():
raise
except Exception as e:
logger.error(f"读取配置文件失败: {e}")
- raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") from e
# ===== 配置更新接口 =====
@router.post("/bot")
-async def update_bot_config(config_data: dict[str, Any] = Body(...)):
+async def update_bot_config(config_data: ConfigBody):
"""更新麦麦主程序配置"""
try:
# 验证配置数据
try:
Config.from_dict(config_data)
except Exception as e:
- raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}")
+ raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e
- # 保存配置文件
+ # 保存配置文件（格式化数组为多行）
config_path = os.path.join(CONFIG_DIR, "bot_config.toml")
- with open(config_path, "w", encoding="utf-8") as f:
- tomlkit.dump(config_data, f)
+ save_toml_with_format(config_data, config_path)
logger.info("麦麦主程序配置已更新")
return {"success": True, "message": "配置已保存"}
@@ -242,23 +248,22 @@ async def update_bot_config(config_data: dict[str, Any] = Body(...)):
raise
except Exception as e:
logger.error(f"保存配置文件失败: {e}")
- raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") from e
@router.post("/model")
-async def update_model_config(config_data: dict[str, Any] = Body(...)):
+async def update_model_config(config_data: ConfigBody):
"""更新模型配置"""
try:
# 验证配置数据
try:
APIAdapterConfig.from_dict(config_data)
except Exception as e:
- raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}")
+ raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e
- # 保存配置文件
+ # 保存配置文件（格式化数组为多行）
config_path = os.path.join(CONFIG_DIR, "model_config.toml")
- with open(config_path, "w", encoding="utf-8") as f:
- tomlkit.dump(config_data, f)
+ save_toml_with_format(config_data, config_path)
logger.info("模型配置已更新")
return {"success": True, "message": "配置已保存"}
@@ -266,14 +271,14 @@ async def update_model_config(config_data: dict[str, Any] = Body(...)):
raise
except Exception as e:
logger.error(f"保存配置文件失败: {e}")
- raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") from e
# ===== 配置节更新接口 =====
@router.post("/bot/section/{section_name}")
-async def update_bot_config_section(section_name: str, section_data: Any = Body(...)):
+async def update_bot_config_section(section_name: str, section_data: SectionBody):
"""更新麦麦主程序配置的指定节（保留注释和格式）"""
try:
# 读取现有配置
@@ -304,11 +309,10 @@ async def update_bot_config_section(section_name: str, section_data: Any = Body(
try:
Config.from_dict(config_data)
except Exception as e:
- raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}")
+ raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e
- # 保存配置（tomlkit.dump 会保留注释）
- with open(config_path, "w", encoding="utf-8") as f:
- tomlkit.dump(config_data, f)
+ # 保存配置（格式化数组为多行，保留注释）
+ save_toml_with_format(config_data, config_path)
logger.info(f"配置节 '{section_name}' 已更新（保留注释）")
return {"success": True, "message": f"配置节 '{section_name}' 已保存"}
@@ -316,7 +320,7 @@ async def update_bot_config_section(section_name: str, section_data: Any = Body(
raise
except Exception as e:
logger.error(f"更新配置节失败: {e}")
- raise HTTPException(status_code=500, detail=f"更新配置节失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"更新配置节失败: {str(e)}") from e
# ===== 原始 TOML 文件操作接口 =====
@@ -338,24 +342,24 @@ async def get_bot_config_raw():
raise
except Exception as e:
logger.error(f"读取配置文件失败: {e}")
- raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") from e
@router.post("/bot/raw")
-async def update_bot_config_raw(raw_content: str = Body(..., embed=True)):
+async def update_bot_config_raw(raw_content: RawContentBody):
"""更新麦麦主程序配置（直接保存原始 TOML 内容，会先验证格式）"""
try:
# 验证 TOML 格式
try:
config_data = tomlkit.loads(raw_content)
except Exception as e:
- raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}")
+ raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}") from e
# 验证配置数据结构
try:
Config.from_dict(config_data)
except Exception as e:
- raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}")
+ raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e
# 保存配置文件
config_path = os.path.join(CONFIG_DIR, "bot_config.toml")
@@ -368,11 +372,11 @@ async def update_bot_config_raw(raw_content: str = Body(..., embed=True)):
raise
except Exception as e:
logger.error(f"保存配置文件失败: {e}")
- raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") from e
@router.post("/model/section/{section_name}")
-async def update_model_config_section(section_name: str, section_data: Any = Body(...)):
+async def update_model_config_section(section_name: str, section_data: SectionBody):
"""更新模型配置的指定节（保留注释和格式）"""
try:
# 读取现有配置
@@ -403,11 +407,10 @@ async def update_model_config_section(section_name: str, section_data: Any = Bod
try:
APIAdapterConfig.from_dict(config_data)
except Exception as e:
- raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}")
+ raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e
- # 保存配置（tomlkit.dump 会保留注释）
- with open(config_path, "w", encoding="utf-8") as f:
- tomlkit.dump(config_data, f)
+ # 保存配置（格式化数组为多行，保留注释）
+ save_toml_with_format(config_data, config_path)
logger.info(f"配置节 '{section_name}' 已更新（保留注释）")
return {"success": True, "message": f"配置节 '{section_name}' 已保存"}
@@ -415,12 +418,44 @@ async def update_model_config_section(section_name: str, section_data: Any = Bod
raise
except Exception as e:
logger.error(f"更新配置节失败: {e}")
- raise HTTPException(status_code=500, detail=f"更新配置节失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"更新配置节失败: {str(e)}") from e
# ===== 适配器配置管理接口 =====
+def _normalize_adapter_path(path: str) -> str:
+ """将路径转换为绝对路径（如果是相对路径，则相对于项目根目录）"""
+ if not path:
+ return path
+
+ # 如果已经是绝对路径，直接返回
+ if os.path.isabs(path):
+ return path
+
+ # 相对路径，转换为相对于项目根目录的绝对路径
+ return os.path.normpath(os.path.join(PROJECT_ROOT, path))
+
+
+def _to_relative_path(path: str) -> str:
+ """尝试将绝对路径转换为相对于项目根目录的相对路径，如果无法转换则返回原路径"""
+ if not path or not os.path.isabs(path):
+ return path
+
+ try:
+ # 尝试获取相对路径
+ rel_path = os.path.relpath(path, PROJECT_ROOT)
+ # 如果相对路径不是以 .. 开头（说明文件在项目目录内），则返回相对路径
+ if not rel_path.startswith(".."):
+ return rel_path
+ except (ValueError, TypeError):
+ # 在 Windows 上，如果路径在不同驱动器，relpath 会抛出 ValueError
+ pass
+
+ # 无法转换为相对路径，返回绝对路径
+ return path
+
+
@router.get("/adapter-config/path")
async def get_adapter_config_path():
"""获取保存的适配器配置文件路径"""
@@ -431,6 +466,7 @@ async def get_adapter_config_path():
return {"success": True, "path": None}
import json
+
with open(webui_data_path, "r", encoding="utf-8") as f:
webui_data = json.load(f)
@@ -438,22 +474,29 @@ async def get_adapter_config_path():
if not adapter_config_path:
return {"success": True, "path": None}
+ # 将路径规范化为绝对路径
+ abs_path = _normalize_adapter_path(adapter_config_path)
+
# 检查文件是否存在并返回最后修改时间
- if os.path.exists(adapter_config_path):
+ if os.path.exists(abs_path):
import datetime
- mtime = os.path.getmtime(adapter_config_path)
+
+ mtime = os.path.getmtime(abs_path)
last_modified = datetime.datetime.fromtimestamp(mtime).isoformat()
- return {"success": True, "path": adapter_config_path, "lastModified": last_modified}
+ # 返回相对路径（如果可能）
+ display_path = _to_relative_path(abs_path)
+ return {"success": True, "path": display_path, "lastModified": last_modified}
else:
+ # 文件不存在，返回原路径
return {"success": True, "path": adapter_config_path, "lastModified": None}
except Exception as e:
logger.error(f"获取适配器配置路径失败: {e}")
- raise HTTPException(status_code=500, detail=f"获取配置路径失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"获取配置路径失败: {str(e)}") from e
@router.post("/adapter-config/path")
-async def save_adapter_config_path(data: dict[str, str] = Body(...)):
+async def save_adapter_config_path(data: PathBody):
"""保存适配器配置文件路径偏好"""
try:
path = data.get("path")
@@ -471,22 +514,28 @@ async def save_adapter_config_path(data: dict[str, str] = Body(...)):
else:
webui_data = {}
+ # 将路径规范化为绝对路径
+ abs_path = _normalize_adapter_path(path)
+
+ # 尝试转换为相对路径保存（如果文件在项目目录内）
+ save_path = _to_relative_path(abs_path)
+
# 更新路径
- webui_data["adapter_config_path"] = path
+ webui_data["adapter_config_path"] = save_path
# 保存
os.makedirs("data", exist_ok=True)
with open(webui_data_path, "w", encoding="utf-8") as f:
json.dump(webui_data, f, ensure_ascii=False, indent=2)
- logger.info(f"适配器配置路径已保存: {path}")
+ logger.info(f"适配器配置路径已保存: {save_path}（绝对路径: {abs_path}）")
return {"success": True, "message": "路径已保存"}
except HTTPException:
raise
except Exception as e:
logger.error(f"保存适配器配置路径失败: {e}")
- raise HTTPException(status_code=500, detail=f"保存路径失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"保存路径失败: {str(e)}") from e
@router.get("/adapter-config")
@@ -496,30 +545,33 @@ async def get_adapter_config(path: str):
if not path:
raise HTTPException(status_code=400, detail="路径参数不能为空")
+ # 将路径规范化为绝对路径
+ abs_path = _normalize_adapter_path(path)
+
# 检查文件是否存在
- if not os.path.exists(path):
+ if not os.path.exists(abs_path):
raise HTTPException(status_code=404, detail=f"配置文件不存在: {path}")
# 检查文件扩展名
- if not path.endswith(".toml"):
+ if not abs_path.endswith(".toml"):
raise HTTPException(status_code=400, detail="只支持 .toml 格式的配置文件")
# 读取文件内容
- with open(path, "r", encoding="utf-8") as f:
+ with open(abs_path, "r", encoding="utf-8") as f:
content = f.read()
- logger.info(f"已读取适配器配置: {path}")
+ logger.info(f"已读取适配器配置: {path} (绝对路径: {abs_path})")
return {"success": True, "content": content}
except HTTPException:
raise
except Exception as e:
logger.error(f"读取适配器配置失败: {e}")
- raise HTTPException(status_code=500, detail=f"读取配置失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"读取配置失败: {str(e)}") from e
@router.post("/adapter-config")
-async def save_adapter_config(data: dict[str, str] = Body(...)):
+async def save_adapter_config(data: PathBody):
"""保存适配器配置到指定路径"""
try:
path = data.get("path")
@@ -530,30 +582,33 @@ async def save_adapter_config(data: dict[str, str] = Body(...)):
if content is None:
raise HTTPException(status_code=400, detail="配置内容不能为空")
+ # 将路径规范化为绝对路径
+ abs_path = _normalize_adapter_path(path)
+
# 检查文件扩展名
- if not path.endswith(".toml"):
+ if not abs_path.endswith(".toml"):
raise HTTPException(status_code=400, detail="只支持 .toml 格式的配置文件")
# 验证 TOML 格式
try:
- import toml
- toml.loads(content)
+ tomlkit.loads(content)
except Exception as e:
- raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}")
+ raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}") from e
# 确保目录存在
- os.makedirs(os.path.dirname(path) if os.path.dirname(path) else ".", exist_ok=True)
+ dir_path = os.path.dirname(abs_path)
+ if dir_path:
+ os.makedirs(dir_path, exist_ok=True)
# 保存文件
- with open(path, "w", encoding="utf-8") as f:
+ with open(abs_path, "w", encoding="utf-8") as f:
f.write(content)
- logger.info(f"适配器配置已保存: {path}")
+ logger.info(f"适配器配置已保存: {path} (绝对路径: {abs_path})")
return {"success": True, "message": "配置已保存"}
except HTTPException:
raise
except Exception as e:
logger.error(f"保存适配器配置失败: {e}")
- raise HTTPException(status_code=500, detail=f"保存配置失败: {str(e)}")
-
+ raise HTTPException(status_code=500, detail=f"保存配置失败: {str(e)}") from e
diff --git a/src/webui/config_schema.py b/src/webui/config_schema.py
index c1608bc4..d160000a 100644
--- a/src/webui/config_schema.py
+++ b/src/webui/config_schema.py
@@ -117,7 +117,7 @@ class ConfigSchemaGenerator:
if next_line.startswith('"""') or next_line.startswith("'''"):
# 单行文档字符串
if next_line.count('"""') == 2 or next_line.count("'''") == 2:
- description_lines.append(next_line.strip('"""').strip("'''").strip())
+ description_lines.append(next_line.replace('"""', "").replace("'''", "").strip())
else:
# 多行文档字符串
quote = '"""' if next_line.startswith('"""') else "'''"
@@ -135,7 +135,7 @@ class ConfigSchemaGenerator:
next_line = lines[i + 1].strip()
if next_line.startswith('"""') or next_line.startswith("'''"):
if next_line.count('"""') == 2 or next_line.count("'''") == 2:
- description_lines.append(next_line.strip('"""').strip("'''").strip())
+ description_lines.append(next_line.replace('"""', "").replace("'''", "").strip())
else:
quote = '"""' if next_line.startswith('"""') else "'''"
description_lines.append(next_line.strip(quote).strip())
@@ -199,13 +199,13 @@ class ConfigSchemaGenerator:
return FieldType.ARRAY, None, items
# 处理基本类型
- if field_type is bool or field_type == bool:
+ if field_type is bool:
return FieldType.BOOLEAN, None, None
- elif field_type is int or field_type == int:
+ elif field_type is int:
return FieldType.INTEGER, None, None
- elif field_type is float or field_type == float:
+ elif field_type is float:
return FieldType.NUMBER, None, None
- elif field_type is str or field_type == str:
+ elif field_type is str:
return FieldType.STRING, None, None
elif field_type is dict or origin is dict:
return FieldType.OBJECT, None, None
diff --git a/src/webui/emoji_routes.py b/src/webui/emoji_routes.py
index 471eb6d7..0784a26a 100644
--- a/src/webui/emoji_routes.py
+++ b/src/webui/emoji_routes.py
@@ -1,18 +1,175 @@
-"""表情包管理 API 路由"""
+""" 表情包管理 API 路由"""
-from fastapi import APIRouter, HTTPException, Header, Query
-from fastapi.responses import FileResponse
+from fastapi import APIRouter, HTTPException, Header, Query, UploadFile, File, Form, Cookie
+from fastapi.responses import FileResponse, JSONResponse
from pydantic import BaseModel
-from typing import Optional, List
+from typing import Optional, List, Annotated
from src.common.logger import get_logger
from src.common.database.database_model import Emoji
from .token_manager import get_token_manager
-import json
+from .auth import verify_auth_token_from_cookie_or_header
import time
import os
+import hashlib
+from PIL import Image
+import io
+from pathlib import Path
+import threading
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
logger = get_logger("webui.emoji")
+# ==================== 缩略图缓存配置 ====================
+# 缩略图缓存目录
+THUMBNAIL_CACHE_DIR = Path("data/emoji_thumbnails")
+# 缩略图尺寸 (宽, 高)
+THUMBNAIL_SIZE = (200, 200)
+# 缩略图质量 (WebP 格式, 1-100)
+THUMBNAIL_QUALITY = 80
+# 缓存锁，防止并发生成同一缩略图
+_thumbnail_locks: dict[str, threading.Lock] = {}
+_locks_lock = threading.Lock()
+# 缩略图生成专用线程池（避免阻塞事件循环）
+_thumbnail_executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="thumbnail")
+# 正在生成中的缩略图哈希集合（防止重复提交任务）
+_generating_thumbnails: set[str] = set()
+_generating_lock = threading.Lock()
+
+
+def _get_thumbnail_lock(file_hash: str) -> threading.Lock:
+ """获取指定文件哈希的锁，用于防止并发生成同一缩略图"""
+ with _locks_lock:
+ if file_hash not in _thumbnail_locks:
+ _thumbnail_locks[file_hash] = threading.Lock()
+ return _thumbnail_locks[file_hash]
+
+
+def _background_generate_thumbnail(source_path: str, file_hash: str) -> None:
+ """
+ 后台生成缩略图（在线程池中执行）
+
+ 生成完成后自动从 generating 集合中移除
+ """
+ try:
+ _generate_thumbnail(source_path, file_hash)
+ except Exception as e:
+ logger.warning(f"后台生成缩略图失败 {file_hash}: {e}")
+ finally:
+ with _generating_lock:
+ _generating_thumbnails.discard(file_hash)
+
+
+def _ensure_thumbnail_cache_dir() -> Path:
+ """确保缩略图缓存目录存在"""
+ THUMBNAIL_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+ return THUMBNAIL_CACHE_DIR
+
+
+def _get_thumbnail_cache_path(file_hash: str) -> Path:
+ """获取缩略图缓存路径"""
+ return THUMBNAIL_CACHE_DIR / f"{file_hash}.webp"
+
+
+def _generate_thumbnail(source_path: str, file_hash: str) -> Path:
+ """
+ 生成缩略图并保存到缓存目录
+
+ Args:
+ source_path: 原图路径
+ file_hash: 文件哈希值，用作缓存文件名
+
+ Returns:
+ 缩略图路径
+
+ Features:
+ - GIF: 提取第一帧作为缩略图
+ - 所有格式统一转为 WebP
+ - 保持宽高比缩放
+ """
+ _ensure_thumbnail_cache_dir()
+ cache_path = _get_thumbnail_cache_path(file_hash)
+
+ # 使用锁防止并发生成同一缩略图
+ lock = _get_thumbnail_lock(file_hash)
+ with lock:
+ # 双重检查，可能在等待锁时已被其他线程生成
+ if cache_path.exists():
+ return cache_path
+
+ try:
+ with Image.open(source_path) as img:
+ # GIF 处理：提取第一帧
+ if hasattr(img, 'n_frames') and img.n_frames > 1:
+ img.seek(0) # 确保在第一帧
+
+ # 转换为 RGB/RGBA（WebP 支持透明度）
+ if img.mode in ('P', 'PA'):
+ # 调色板模式转换为 RGBA 以保留透明度
+ img = img.convert('RGBA')
+ elif img.mode == 'LA':
+ img = img.convert('RGBA')
+ elif img.mode not in ('RGB', 'RGBA'):
+ img = img.convert('RGB')
+
+ # 创建缩略图（保持宽高比）
+ img.thumbnail(THUMBNAIL_SIZE, Image.Resampling.LANCZOS)
+
+ # 保存为 WebP 格式
+ img.save(cache_path, 'WEBP', quality=THUMBNAIL_QUALITY, method=6)
+
+ logger.debug(f"生成缩略图: {file_hash} -> {cache_path}")
+
+ except Exception as e:
+ logger.warning(f"生成缩略图失败 {file_hash}: {e}，将返回原图")
+ # 生成失败时不创建缓存文件，下次会重试
+ raise
+
+ return cache_path
+
+
+def cleanup_orphaned_thumbnails() -> tuple[int, int]:
+ """
+ 清理孤立的缩略图缓存（原图已不存在的缩略图）
+
+ Returns:
+ (清理数量, 保留数量)
+ """
+ if not THUMBNAIL_CACHE_DIR.exists():
+ return 0, 0
+
+ # 获取所有表情包的哈希值
+ valid_hashes = set()
+ for emoji in Emoji.select(Emoji.emoji_hash):
+ valid_hashes.add(emoji.emoji_hash)
+
+ cleaned = 0
+ kept = 0
+
+ for cache_file in THUMBNAIL_CACHE_DIR.glob("*.webp"):
+ file_hash = cache_file.stem
+ if file_hash not in valid_hashes:
+ try:
+ cache_file.unlink()
+ cleaned += 1
+ logger.debug(f"清理孤立缩略图: {cache_file.name}")
+ except Exception as e:
+ logger.warning(f"清理缩略图失败 {cache_file.name}: {e}")
+ else:
+ kept += 1
+
+ if cleaned > 0:
+ logger.info(f"清理孤立缩略图: 删除 {cleaned} 个，保留 {kept} 个")
+
+ return cleaned, kept
+
+# 模块级别的类型别名（解决 B008 ruff 错误）
+EmojiFile = Annotated[UploadFile, File(description="表情包图片文件")]
+EmojiFiles = Annotated[List[UploadFile], File(description="多个表情包图片文件")]
+DescriptionForm = Annotated[str, Form(description="表情包描述")]
+EmotionForm = Annotated[str, Form(description="情感标签，多个用逗号分隔")]
+IsRegisteredForm = Annotated[bool, Form(description="是否直接注册")]
+
# 创建路由器
router = APIRouter(prefix="/emoji", tags=["Emoji"])
@@ -92,18 +249,12 @@ class BatchDeleteResponse(BaseModel):
failed_ids: List[int] = []
-def verify_auth_token(authorization: Optional[str]) -> bool:
- """验证认证 Token"""
- if not authorization or not authorization.startswith("Bearer "):
- raise HTTPException(status_code=401, detail="未提供有效的认证信息")
-
- token = authorization.replace("Bearer ", "")
- token_manager = get_token_manager()
-
- if not token_manager.verify_token(token):
- raise HTTPException(status_code=401, detail="Token 无效或已过期")
-
- return True
+def verify_auth_token(
+ maibot_session: Optional[str] = None,
+ authorization: Optional[str] = None,
+) -> bool:
+ """验证认证 Token，支持 Cookie 和 Header"""
+ return verify_auth_token_from_cookie_or_header(maibot_session, authorization)
def emoji_to_response(emoji: Emoji) -> EmojiResponse:
@@ -133,6 +284,9 @@ async def get_emoji_list(
is_registered: Optional[bool] = Query(None, description="是否已注册筛选"),
is_banned: Optional[bool] = Query(None, description="是否被禁用筛选"),
format: Optional[str] = Query(None, description="格式筛选"),
+ sort_by: Optional[str] = Query("usage_count", description="排序字段"),
+ sort_order: Optional[str] = Query("desc", description="排序方向"),
+ maibot_session: Optional[str] = Cookie(None),
authorization: Optional[str] = Header(None),
):
"""
@@ -145,13 +299,15 @@ async def get_emoji_list(
is_registered: 是否已注册筛选
is_banned: 是否被禁用筛选
format: 格式筛选
+ sort_by: 排序字段 (usage_count, register_time, record_time, last_used_time)
+ sort_order: 排序方向 (asc, desc)
authorization: Authorization header
Returns:
表情包列表
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
# 构建查询
query = Emoji.select()
@@ -172,12 +328,22 @@ async def get_emoji_list(
if format:
query = query.where(Emoji.format == format)
- # 排序：使用次数倒序，然后按记录时间倒序
- from peewee import Case
+ # 排序字段映射
+ sort_field_map = {
+ "usage_count": Emoji.usage_count,
+ "register_time": Emoji.register_time,
+ "record_time": Emoji.record_time,
+ "last_used_time": Emoji.last_used_time,
+ }
- query = query.order_by(
- Emoji.usage_count.desc(), Case(None, [(Emoji.record_time.is_null(), 1)], 0), Emoji.record_time.desc()
- )
+ # 获取排序字段，默认使用 usage_count
+ sort_field = sort_field_map.get(sort_by, Emoji.usage_count)
+
+ # 应用排序
+ if sort_order == "asc":
+ query = query.order_by(sort_field.asc())
+ else:
+ query = query.order_by(sort_field.desc())
# 获取总数
total = query.count()
@@ -199,7 +365,7 @@ async def get_emoji_list(
@router.get("/{emoji_id}", response_model=EmojiDetailResponse)
-async def get_emoji_detail(emoji_id: int, authorization: Optional[str] = Header(None)):
+async def get_emoji_detail(emoji_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
获取表情包详细信息
@@ -211,7 +377,7 @@ async def get_emoji_detail(emoji_id: int, authorization: Optional[str] = Header(
表情包详细信息
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
emoji = Emoji.get_or_none(Emoji.id == emoji_id)
@@ -228,7 +394,7 @@ async def get_emoji_detail(emoji_id: int, authorization: Optional[str] = Header(
@router.patch("/{emoji_id}", response_model=EmojiUpdateResponse)
-async def update_emoji(emoji_id: int, request: EmojiUpdateRequest, authorization: Optional[str] = Header(None)):
+async def update_emoji(emoji_id: int, request: EmojiUpdateRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
增量更新表情包（只更新提供的字段）
@@ -241,7 +407,7 @@ async def update_emoji(emoji_id: int, request: EmojiUpdateRequest, authorization
更新结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
emoji = Emoji.get_or_none(Emoji.id == emoji_id)
@@ -280,7 +446,7 @@ async def update_emoji(emoji_id: int, request: EmojiUpdateRequest, authorization
@router.delete("/{emoji_id}", response_model=EmojiDeleteResponse)
-async def delete_emoji(emoji_id: int, authorization: Optional[str] = Header(None)):
+async def delete_emoji(emoji_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
删除表情包
@@ -292,7 +458,7 @@ async def delete_emoji(emoji_id: int, authorization: Optional[str] = Header(None
删除结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
emoji = Emoji.get_or_none(Emoji.id == emoji_id)
@@ -317,7 +483,7 @@ async def delete_emoji(emoji_id: int, authorization: Optional[str] = Header(None
@router.get("/stats/summary")
-async def get_emoji_stats(authorization: Optional[str] = Header(None)):
+async def get_emoji_stats(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
获取表情包统计数据
@@ -328,7 +494,7 @@ async def get_emoji_stats(authorization: Optional[str] = Header(None)):
统计数据
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
total = Emoji.select().count()
registered = Emoji.select().where(Emoji.is_registered).count()
@@ -372,7 +538,7 @@ async def get_emoji_stats(authorization: Optional[str] = Header(None)):
@router.post("/{emoji_id}/register", response_model=EmojiUpdateResponse)
-async def register_emoji(emoji_id: int, authorization: Optional[str] = Header(None)):
+async def register_emoji(emoji_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
注册表情包（快捷操作）
@@ -384,7 +550,7 @@ async def register_emoji(emoji_id: int, authorization: Optional[str] = Header(No
更新结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
emoji = Emoji.get_or_none(Emoji.id == emoji_id)
@@ -394,11 +560,9 @@ async def register_emoji(emoji_id: int, authorization: Optional[str] = Header(No
if emoji.is_registered:
raise HTTPException(status_code=400, detail="该表情包已经注册")
- if emoji.is_banned:
- raise HTTPException(status_code=400, detail="该表情包已被禁用，无法注册")
-
- # 注册表情包
+ # 注册表情包（如果已封禁，自动解除封禁）
emoji.is_registered = True
+ emoji.is_banned = False # 注册时自动解除封禁
emoji.register_time = time.time()
emoji.save()
@@ -414,7 +578,7 @@ async def register_emoji(emoji_id: int, authorization: Optional[str] = Header(No
@router.post("/{emoji_id}/ban", response_model=EmojiUpdateResponse)
-async def ban_emoji(emoji_id: int, authorization: Optional[str] = Header(None)):
+async def ban_emoji(emoji_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
禁用表情包（快捷操作）
@@ -426,7 +590,7 @@ async def ban_emoji(emoji_id: int, authorization: Optional[str] = Header(None)):
更新结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
emoji = Emoji.get_or_none(Emoji.id == emoji_id)
@@ -453,28 +617,47 @@ async def ban_emoji(emoji_id: int, authorization: Optional[str] = Header(None)):
async def get_emoji_thumbnail(
emoji_id: int,
token: Optional[str] = Query(None, description="访问令牌"),
+ maibot_session: Optional[str] = Cookie(None),
authorization: Optional[str] = Header(None),
+ original: bool = Query(False, description="是否返回原图"),
):
"""
- 获取表情包缩略图
+ 获取表情包缩略图（懒加载生成 + 缓存）
Args:
emoji_id: 表情包ID
- token: 访问令牌（通过 query parameter）
+ token: 访问令牌（通过 query parameter，用于向后兼容）
+ maibot_session: Cookie 中的 token
authorization: Authorization header
+ original: 是否返回原图（用于详情页查看原图）
Returns:
- 表情包图片文件
+ 表情包缩略图（WebP 格式）或原图
+
+ Features:
+ - 懒加载：首次请求时生成缩略图
+ - 缓存：后续请求直接返回缓存
+ - GIF 支持：提取第一帧作为缩略图
+ - 格式统一：所有缩略图统一为 WebP 格式
"""
try:
- # 优先使用 query parameter 中的 token（用于 img 标签）
- if token:
- token_manager = get_token_manager()
- if not token_manager.verify_token(token):
- raise HTTPException(status_code=401, detail="Token 无效或已过期")
- else:
- # 如果没有 query token，则验证 Authorization header
- verify_auth_token(authorization)
+ token_manager = get_token_manager()
+ is_valid = False
+
+ # 1. 优先使用 Cookie
+ if maibot_session and token_manager.verify_token(maibot_session):
+ is_valid = True
+ # 2. 其次使用 query parameter（用于向后兼容 img 标签）
+ elif token and token_manager.verify_token(token):
+ is_valid = True
+ # 3. 最后使用 Authorization header
+ elif authorization and authorization.startswith("Bearer "):
+ auth_token = authorization.replace("Bearer ", "")
+ if token_manager.verify_token(auth_token):
+ is_valid = True
+
+ if not is_valid:
+ raise HTTPException(status_code=401, detail="Token 无效或已过期")
emoji = Emoji.get_or_none(Emoji.id == emoji_id)
@@ -485,19 +668,59 @@ async def get_emoji_thumbnail(
if not os.path.exists(emoji.full_path):
raise HTTPException(status_code=404, detail="表情包文件不存在")
- # 根据格式设置 MIME 类型
- mime_types = {
- "png": "image/png",
- "jpg": "image/jpeg",
- "jpeg": "image/jpeg",
- "gif": "image/gif",
- "webp": "image/webp",
- "bmp": "image/bmp",
- }
+ # 如果请求原图，直接返回原文件
+ if original:
+ mime_types = {
+ "png": "image/png",
+ "jpg": "image/jpeg",
+ "jpeg": "image/jpeg",
+ "gif": "image/gif",
+ "webp": "image/webp",
+ "bmp": "image/bmp",
+ }
+ media_type = mime_types.get(emoji.format.lower(), "application/octet-stream")
+ return FileResponse(
+ path=emoji.full_path,
+ media_type=media_type,
+ filename=f"{emoji.emoji_hash}.{emoji.format}"
+ )
- media_type = mime_types.get(emoji.format.lower(), "application/octet-stream")
-
- return FileResponse(path=emoji.full_path, media_type=media_type, filename=f"{emoji.emoji_hash}.{emoji.format}")
+ # 尝试获取或生成缩略图
+ cache_path = _get_thumbnail_cache_path(emoji.emoji_hash)
+
+ # 检查缓存是否存在
+ if cache_path.exists():
+ # 缓存命中，直接返回
+ return FileResponse(
+ path=str(cache_path),
+ media_type="image/webp",
+ filename=f"{emoji.emoji_hash}_thumb.webp"
+ )
+
+ # 缓存未命中，触发后台生成并返回 202
+ with _generating_lock:
+ if emoji.emoji_hash not in _generating_thumbnails:
+ # 标记为正在生成
+ _generating_thumbnails.add(emoji.emoji_hash)
+ # 提交到线程池后台生成
+ _thumbnail_executor.submit(
+ _background_generate_thumbnail,
+ emoji.full_path,
+ emoji.emoji_hash
+ )
+
+ # 返回 202 Accepted，告诉前端缩略图正在生成中
+ return JSONResponse(
+ status_code=202,
+ content={
+ "status": "generating",
+ "message": "缩略图正在生成中，请稍后重试",
+ "emoji_id": emoji_id,
+ },
+ headers={
+ "Retry-After": "1", # 建议 1 秒后重试
+ }
+ )
except HTTPException:
raise
@@ -507,7 +730,7 @@ async def get_emoji_thumbnail(
@router.post("/batch/delete", response_model=BatchDeleteResponse)
-async def batch_delete_emojis(request: BatchDeleteRequest, authorization: Optional[str] = Header(None)):
+async def batch_delete_emojis(request: BatchDeleteRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
批量删除表情包
@@ -519,7 +742,7 @@ async def batch_delete_emojis(request: BatchDeleteRequest, authorization: Option
批量删除结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
if not request.emoji_ids:
raise HTTPException(status_code=400, detail="未提供要删除的表情包ID")
@@ -560,3 +783,524 @@ async def batch_delete_emojis(request: BatchDeleteRequest, authorization: Option
except Exception as e:
logger.exception(f"批量删除表情包失败: {e}")
raise HTTPException(status_code=500, detail=f"批量删除失败: {str(e)}") from e
+
+
+# 表情包存储目录
+EMOJI_REGISTERED_DIR = os.path.join("data", "emoji_registed")
+
+
+class EmojiUploadResponse(BaseModel):
+ """表情包上传响应"""
+
+ success: bool
+ message: str
+ data: Optional[EmojiResponse] = None
+
+
+@router.post("/upload", response_model=EmojiUploadResponse)
+async def upload_emoji(
+ file: EmojiFile,
+ description: DescriptionForm = "",
+ emotion: EmotionForm = "",
+ is_registered: IsRegisteredForm = True,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
+ """
+ 上传并注册表情包
+
+ Args:
+ file: 表情包图片文件 (支持 jpg, jpeg, png, gif, webp)
+ description: 表情包描述
+ emotion: 情感标签，多个用逗号分隔
+ is_registered: 是否直接注册，默认为 True
+ authorization: Authorization header
+
+ Returns:
+ 上传结果和表情包信息
+ """
+ try:
+ verify_auth_token(maibot_session, authorization)
+
+ # 验证文件类型
+ if not file.content_type:
+ raise HTTPException(status_code=400, detail="无法识别文件类型")
+
+ allowed_types = ["image/jpeg", "image/png", "image/gif", "image/webp"]
+ if file.content_type not in allowed_types:
+ raise HTTPException(
+ status_code=400,
+ detail=f"不支持的文件类型: {file.content_type}，支持: {', '.join(allowed_types)}",
+ )
+
+ # 读取文件内容
+ file_content = await file.read()
+
+ if not file_content:
+ raise HTTPException(status_code=400, detail="文件内容为空")
+
+ # 验证图片并获取格式
+ try:
+ with Image.open(io.BytesIO(file_content)) as img:
+ img_format = img.format.lower() if img.format else "png"
+ # 验证图片可以正常打开
+ img.verify()
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=f"无效的图片文件: {str(e)}") from e
+
+ # 重新打开图片（verify后需要重新打开）
+ with Image.open(io.BytesIO(file_content)) as img:
+ img_format = img.format.lower() if img.format else "png"
+
+ # 计算文件哈希
+ emoji_hash = hashlib.md5(file_content).hexdigest()
+
+ # 检查是否已存在相同哈希的表情包
+ existing_emoji = Emoji.get_or_none(Emoji.emoji_hash == emoji_hash)
+ if existing_emoji:
+ raise HTTPException(
+ status_code=409,
+ detail=f"已存在相同的表情包 (ID: {existing_emoji.id})",
+ )
+
+ # 确保目录存在
+ os.makedirs(EMOJI_REGISTERED_DIR, exist_ok=True)
+
+ # 生成文件名
+ timestamp = int(time.time())
+ filename = f"emoji_{timestamp}_{emoji_hash[:8]}.{img_format}"
+ full_path = os.path.join(EMOJI_REGISTERED_DIR, filename)
+
+ # 如果文件已存在，添加随机后缀
+ counter = 1
+ while os.path.exists(full_path):
+ filename = f"emoji_{timestamp}_{emoji_hash[:8]}_{counter}.{img_format}"
+ full_path = os.path.join(EMOJI_REGISTERED_DIR, filename)
+ counter += 1
+
+ # 保存文件
+ with open(full_path, "wb") as f:
+ f.write(file_content)
+
+ logger.info(f"表情包文件已保存: {full_path}")
+
+ # 处理情感标签
+ emotion_str = ",".join(e.strip() for e in emotion.split(",") if e.strip()) if emotion else ""
+
+ # 创建数据库记录
+ current_time = time.time()
+ emoji = Emoji.create(
+ full_path=full_path,
+ format=img_format,
+ emoji_hash=emoji_hash,
+ description=description,
+ emotion=emotion_str,
+ query_count=0,
+ is_registered=is_registered,
+ is_banned=False,
+ record_time=current_time,
+ register_time=current_time if is_registered else None,
+ usage_count=0,
+ last_used_time=None,
+ )
+
+ logger.info(f"表情包已上传并注册: ID={emoji.id}, hash={emoji_hash}")
+
+ return EmojiUploadResponse(
+ success=True,
+ message="表情包上传成功" + ("并已注册" if is_registered else ""),
+ data=emoji_to_response(emoji),
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.exception(f"上传表情包失败: {e}")
+ raise HTTPException(status_code=500, detail=f"上传失败: {str(e)}") from e
+
+
+@router.post("/batch/upload")
+async def batch_upload_emoji(
+ files: EmojiFiles,
+ emotion: EmotionForm = "",
+ is_registered: IsRegisteredForm = True,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
+ """
+ 批量上传表情包
+
+ Args:
+ files: 多个表情包图片文件
+ emotion: 共用的情感标签
+ is_registered: 是否直接注册
+ authorization: Authorization header
+
+ Returns:
+ 批量上传结果
+ """
+ try:
+ verify_auth_token(maibot_session, authorization)
+
+ results = {
+ "success": True,
+ "total": len(files),
+ "uploaded": 0,
+ "failed": 0,
+ "details": [],
+ }
+
+ allowed_types = ["image/jpeg", "image/png", "image/gif", "image/webp"]
+ os.makedirs(EMOJI_REGISTERED_DIR, exist_ok=True)
+
+ for file in files:
+ try:
+ # 验证文件类型
+ if file.content_type not in allowed_types:
+ results["failed"] += 1
+ results["details"].append(
+ {
+ "filename": file.filename,
+ "success": False,
+ "error": f"不支持的文件类型: {file.content_type}",
+ }
+ )
+ continue
+
+ # 读取文件内容
+ file_content = await file.read()
+
+ if not file_content:
+ results["failed"] += 1
+ results["details"].append(
+ {
+ "filename": file.filename,
+ "success": False,
+ "error": "文件内容为空",
+ }
+ )
+ continue
+
+ # 验证图片
+ try:
+ with Image.open(io.BytesIO(file_content)) as img:
+ img_format = img.format.lower() if img.format else "png"
+ except Exception as e:
+ results["failed"] += 1
+ results["details"].append(
+ {
+ "filename": file.filename,
+ "success": False,
+ "error": f"无效的图片: {str(e)}",
+ }
+ )
+ continue
+
+ # 计算哈希
+ emoji_hash = hashlib.md5(file_content).hexdigest()
+
+ # 检查重复
+ if Emoji.get_or_none(Emoji.emoji_hash == emoji_hash):
+ results["failed"] += 1
+ results["details"].append(
+ {
+ "filename": file.filename,
+ "success": False,
+ "error": "已存在相同的表情包",
+ }
+ )
+ continue
+
+ # 生成文件名并保存
+ timestamp = int(time.time())
+ filename = f"emoji_{timestamp}_{emoji_hash[:8]}.{img_format}"
+ full_path = os.path.join(EMOJI_REGISTERED_DIR, filename)
+
+ counter = 1
+ while os.path.exists(full_path):
+ filename = f"emoji_{timestamp}_{emoji_hash[:8]}_{counter}.{img_format}"
+ full_path = os.path.join(EMOJI_REGISTERED_DIR, filename)
+ counter += 1
+
+ with open(full_path, "wb") as f:
+ f.write(file_content)
+
+ # 处理情感标签
+ emotion_str = ",".join(e.strip() for e in emotion.split(",") if e.strip()) if emotion else ""
+
+ # 创建数据库记录
+ current_time = time.time()
+ emoji = Emoji.create(
+ full_path=full_path,
+ format=img_format,
+ emoji_hash=emoji_hash,
+ description="", # 批量上传暂不设置描述
+ emotion=emotion_str,
+ query_count=0,
+ is_registered=is_registered,
+ is_banned=False,
+ record_time=current_time,
+ register_time=current_time if is_registered else None,
+ usage_count=0,
+ last_used_time=None,
+ )
+
+ results["uploaded"] += 1
+ results["details"].append(
+ {
+ "filename": file.filename,
+ "success": True,
+ "id": emoji.id,
+ }
+ )
+
+ except Exception as e:
+ results["failed"] += 1
+ results["details"].append(
+ {
+ "filename": file.filename,
+ "success": False,
+ "error": str(e),
+ }
+ )
+
+ results["message"] = f"成功上传 {results['uploaded']} 个，失败 {results['failed']} 个"
+ return results
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.exception(f"批量上传表情包失败: {e}")
+ raise HTTPException(status_code=500, detail=f"批量上传失败: {str(e)}") from e
+
+
+# ==================== 缩略图缓存管理 API ====================
+
+
+class ThumbnailCacheStatsResponse(BaseModel):
+ """缩略图缓存统计响应"""
+
+ success: bool
+ cache_dir: str
+ total_count: int
+ total_size_mb: float
+ emoji_count: int
+ coverage_percent: float
+
+
+class ThumbnailCleanupResponse(BaseModel):
+ """缩略图清理响应"""
+
+ success: bool
+ message: str
+ cleaned_count: int
+ kept_count: int
+
+
+class ThumbnailPreheatResponse(BaseModel):
+ """缩略图预热响应"""
+
+ success: bool
+ message: str
+ generated_count: int
+ skipped_count: int
+ failed_count: int
+
+
+@router.get("/thumbnail-cache/stats", response_model=ThumbnailCacheStatsResponse)
+async def get_thumbnail_cache_stats(
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
+ """
+ 获取缩略图缓存统计信息
+
+ Returns:
+ 缓存目录、缓存数量、总大小、覆盖率等统计信息
+ """
+ try:
+ verify_auth_token(maibot_session, authorization)
+
+ _ensure_thumbnail_cache_dir()
+
+ # 统计缓存文件
+ cache_files = list(THUMBNAIL_CACHE_DIR.glob("*.webp"))
+ total_count = len(cache_files)
+ total_size = sum(f.stat().st_size for f in cache_files)
+ total_size_mb = round(total_size / (1024 * 1024), 2)
+
+ # 统计表情包总数
+ emoji_count = Emoji.select().count()
+
+ # 计算覆盖率
+ coverage_percent = round((total_count / emoji_count * 100) if emoji_count > 0 else 0, 1)
+
+ return ThumbnailCacheStatsResponse(
+ success=True,
+ cache_dir=str(THUMBNAIL_CACHE_DIR.absolute()),
+ total_count=total_count,
+ total_size_mb=total_size_mb,
+ emoji_count=emoji_count,
+ coverage_percent=coverage_percent,
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.exception(f"获取缩略图缓存统计失败: {e}")
+ raise HTTPException(status_code=500, detail=f"获取统计失败: {str(e)}") from e
+
+
+@router.post("/thumbnail-cache/cleanup", response_model=ThumbnailCleanupResponse)
+async def cleanup_thumbnail_cache(
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
+ """
+ 清理孤立的缩略图缓存（原图已删除的表情包对应的缩略图）
+
+ Returns:
+ 清理结果
+ """
+ try:
+ verify_auth_token(maibot_session, authorization)
+
+ cleaned, kept = cleanup_orphaned_thumbnails()
+
+ return ThumbnailCleanupResponse(
+ success=True,
+ message=f"清理完成：删除 {cleaned} 个孤立缓存，保留 {kept} 个有效缓存",
+ cleaned_count=cleaned,
+ kept_count=kept,
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.exception(f"清理缩略图缓存失败: {e}")
+ raise HTTPException(status_code=500, detail=f"清理失败: {str(e)}") from e
+
+
+@router.post("/thumbnail-cache/preheat", response_model=ThumbnailPreheatResponse)
+async def preheat_thumbnail_cache(
+ limit: int = Query(100, ge=1, le=1000, description="最多预热数量"),
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
+ """
+ 预热缩略图缓存（提前生成未缓存的缩略图）
+
+ 优先处理使用次数高的表情包
+
+ Args:
+ limit: 最多预热数量 (1-1000)
+
+ Returns:
+ 预热结果
+ """
+ try:
+ verify_auth_token(maibot_session, authorization)
+
+ _ensure_thumbnail_cache_dir()
+
+ # 获取使用次数最高的表情包（未缓存的优先）
+ emojis = (
+ Emoji.select()
+ .where(Emoji.is_banned == False) # noqa: E712 Peewee ORM requires == for boolean comparison
+ .order_by(Emoji.usage_count.desc())
+ .limit(limit * 2) # 多查一些，因为有些可能已缓存
+ )
+
+ generated = 0
+ skipped = 0
+ failed = 0
+
+ for emoji in emojis:
+ if generated >= limit:
+ break
+
+ cache_path = _get_thumbnail_cache_path(emoji.emoji_hash)
+
+ # 已缓存，跳过
+ if cache_path.exists():
+ skipped += 1
+ continue
+
+ # 原文件不存在，跳过
+ if not os.path.exists(emoji.full_path):
+ failed += 1
+ continue
+
+ try:
+ # 使用线程池异步生成缩略图，避免阻塞事件循环
+ loop = asyncio.get_event_loop()
+ await loop.run_in_executor(
+ _thumbnail_executor,
+ _generate_thumbnail,
+ emoji.full_path,
+ emoji.emoji_hash
+ )
+ generated += 1
+ except Exception as e:
+ logger.warning(f"预热缩略图失败 {emoji.emoji_hash}: {e}")
+ failed += 1
+
+ return ThumbnailPreheatResponse(
+ success=True,
+ message=f"预热完成：生成 {generated} 个，跳过 {skipped} 个已缓存，失败 {failed} 个",
+ generated_count=generated,
+ skipped_count=skipped,
+ failed_count=failed,
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.exception(f"预热缩略图缓存失败: {e}")
+ raise HTTPException(status_code=500, detail=f"预热失败: {str(e)}") from e
+
+
+@router.delete("/thumbnail-cache/clear", response_model=ThumbnailCleanupResponse)
+async def clear_all_thumbnail_cache(
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
+ """
+ 清空所有缩略图缓存（下次访问时会重新生成）
+
+ Returns:
+ 清理结果
+ """
+ try:
+ verify_auth_token(maibot_session, authorization)
+
+ if not THUMBNAIL_CACHE_DIR.exists():
+ return ThumbnailCleanupResponse(
+ success=True,
+ message="缓存目录不存在，无需清理",
+ cleaned_count=0,
+ kept_count=0,
+ )
+
+ cleaned = 0
+ for cache_file in THUMBNAIL_CACHE_DIR.glob("*.webp"):
+ try:
+ cache_file.unlink()
+ cleaned += 1
+ except Exception as e:
+ logger.warning(f"删除缓存文件失败 {cache_file.name}: {e}")
+
+ logger.info(f"已清空缩略图缓存: 删除 {cleaned} 个文件")
+
+ return ThumbnailCleanupResponse(
+ success=True,
+ message=f"已清空所有缩略图缓存：删除 {cleaned} 个文件",
+ cleaned_count=cleaned,
+ kept_count=0,
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.exception(f"清空缩略图缓存失败: {e}")
+ raise HTTPException(status_code=500, detail=f"清空失败: {str(e)}") from e
diff --git a/src/webui/expression_routes.py b/src/webui/expression_routes.py
index 983918cf..bef93b30 100644
--- a/src/webui/expression_routes.py
+++ b/src/webui/expression_routes.py
@@ -1,11 +1,11 @@
"""表达方式管理 API 路由"""
-from fastapi import APIRouter, HTTPException, Header, Query
+from fastapi import APIRouter, HTTPException, Header, Query, Cookie
from pydantic import BaseModel
-from typing import Optional, List
+from typing import Optional, List, Dict
from src.common.logger import get_logger
-from src.common.database.database_model import Expression
-from .token_manager import get_token_manager
+from src.common.database.database_model import Expression, ChatStreams
+from .auth import verify_auth_token_from_cookie_or_header
import time
logger = get_logger("webui.expression")
@@ -87,18 +87,12 @@ class ExpressionCreateResponse(BaseModel):
data: ExpressionResponse
-def verify_auth_token(authorization: Optional[str]) -> bool:
- """验证认证 Token"""
- if not authorization or not authorization.startswith("Bearer "):
- raise HTTPException(status_code=401, detail="未提供有效的认证信息")
-
- token = authorization.replace("Bearer ", "")
- token_manager = get_token_manager()
-
- if not token_manager.verify_token(token):
- raise HTTPException(status_code=401, detail="Token 无效或已过期")
-
- return True
+def verify_auth_token(
+ maibot_session: Optional[str] = None,
+ authorization: Optional[str] = None,
+) -> bool:
+ """验证认证 Token，支持 Cookie 和 Header"""
+ return verify_auth_token_from_cookie_or_header(maibot_session, authorization)
def expression_to_response(expression: Expression) -> ExpressionResponse:
@@ -115,12 +109,97 @@ def expression_to_response(expression: Expression) -> ExpressionResponse:
)
+def get_chat_name(chat_id: str) -> str:
+ """根据 chat_id 获取聊天名称"""
+ try:
+ chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == chat_id)
+ if chat_stream:
+ # 优先使用群聊名称，否则使用用户昵称
+ if chat_stream.group_name:
+ return chat_stream.group_name
+ elif chat_stream.user_nickname:
+ return chat_stream.user_nickname
+ return chat_id # 找不到时返回原始ID
+ except Exception:
+ return chat_id
+
+
+def get_chat_names_batch(chat_ids: List[str]) -> Dict[str, str]:
+ """批量获取聊天名称"""
+ result = {cid: cid for cid in chat_ids} # 默认值为原始ID
+ try:
+ chat_streams = ChatStreams.select().where(ChatStreams.stream_id.in_(chat_ids))
+ for cs in chat_streams:
+ if cs.group_name:
+ result[cs.stream_id] = cs.group_name
+ elif cs.user_nickname:
+ result[cs.stream_id] = cs.user_nickname
+ except Exception as e:
+ logger.warning(f"批量获取聊天名称失败: {e}")
+ return result
+
+
+class ChatInfo(BaseModel):
+ """聊天信息"""
+
+ chat_id: str
+ chat_name: str
+ platform: Optional[str] = None
+ is_group: bool = False
+
+
+class ChatListResponse(BaseModel):
+ """聊天列表响应"""
+
+ success: bool
+ data: List[ChatInfo]
+
+
+@router.get("/chats", response_model=ChatListResponse)
+async def get_chat_list(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
+ """
+ 获取所有聊天列表（用于下拉选择）
+
+ Args:
+ authorization: Authorization header
+
+ Returns:
+ 聊天列表
+ """
+ try:
+ verify_auth_token(maibot_session, authorization)
+
+ chat_list = []
+ for cs in ChatStreams.select():
+ chat_name = cs.group_name if cs.group_name else (cs.user_nickname if cs.user_nickname else cs.stream_id)
+ chat_list.append(
+ ChatInfo(
+ chat_id=cs.stream_id,
+ chat_name=chat_name,
+ platform=cs.platform,
+ is_group=bool(cs.group_id),
+ )
+ )
+
+ # 按名称排序
+ chat_list.sort(key=lambda x: x.chat_name)
+
+ return ChatListResponse(success=True, data=chat_list)
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.exception(f"获取聊天列表失败: {e}")
+ raise HTTPException(status_code=500, detail=f"获取聊天列表失败: {str(e)}") from e
+
+
@router.get("/list", response_model=ExpressionListResponse)
async def get_expression_list(
page: int = Query(1, ge=1, description="页码"),
page_size: int = Query(20, ge=1, le=100, description="每页数量"),
search: Optional[str] = Query(None, description="搜索关键词"),
chat_id: Optional[str] = Query(None, description="聊天ID筛选"),
+ maibot_session: Optional[str] = Cookie(None),
authorization: Optional[str] = Header(None),
):
"""
@@ -137,7 +216,7 @@ async def get_expression_list(
表达方式列表
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
# 构建查询
query = Expression.select()
@@ -181,7 +260,7 @@ async def get_expression_list(
@router.get("/{expression_id}", response_model=ExpressionDetailResponse)
-async def get_expression_detail(expression_id: int, authorization: Optional[str] = Header(None)):
+async def get_expression_detail(expression_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
获取表达方式详细信息
@@ -193,7 +272,7 @@ async def get_expression_detail(expression_id: int, authorization: Optional[str]
表达方式详细信息
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
expression = Expression.get_or_none(Expression.id == expression_id)
@@ -210,7 +289,7 @@ async def get_expression_detail(expression_id: int, authorization: Optional[str]
@router.post("/", response_model=ExpressionCreateResponse)
-async def create_expression(request: ExpressionCreateRequest, authorization: Optional[str] = Header(None)):
+async def create_expression(request: ExpressionCreateRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
创建新的表达方式
@@ -222,7 +301,7 @@ async def create_expression(request: ExpressionCreateRequest, authorization: Opt
创建结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
current_time = time.time()
@@ -252,7 +331,7 @@ async def create_expression(request: ExpressionCreateRequest, authorization: Opt
@router.patch("/{expression_id}", response_model=ExpressionUpdateResponse)
async def update_expression(
- expression_id: int, request: ExpressionUpdateRequest, authorization: Optional[str] = Header(None)
+ expression_id: int, request: ExpressionUpdateRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)
):
"""
增量更新表达方式（只更新提供的字段）
@@ -266,7 +345,7 @@ async def update_expression(
更新结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
expression = Expression.get_or_none(Expression.id == expression_id)
@@ -302,7 +381,7 @@ async def update_expression(
@router.delete("/{expression_id}", response_model=ExpressionDeleteResponse)
-async def delete_expression(expression_id: int, authorization: Optional[str] = Header(None)):
+async def delete_expression(expression_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
删除表达方式
@@ -314,7 +393,7 @@ async def delete_expression(expression_id: int, authorization: Optional[str] = H
删除结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
expression = Expression.get_or_none(Expression.id == expression_id)
@@ -345,7 +424,7 @@ class BatchDeleteRequest(BaseModel):
@router.post("/batch/delete", response_model=ExpressionDeleteResponse)
-async def batch_delete_expressions(request: BatchDeleteRequest, authorization: Optional[str] = Header(None)):
+async def batch_delete_expressions(request: BatchDeleteRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
批量删除表达方式
@@ -357,7 +436,7 @@ async def batch_delete_expressions(request: BatchDeleteRequest, authorization: O
删除结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
if not request.ids:
raise HTTPException(status_code=400, detail="未提供要删除的表达方式ID")
@@ -386,7 +465,7 @@ async def batch_delete_expressions(request: BatchDeleteRequest, authorization: O
@router.get("/stats/summary")
-async def get_expression_stats(authorization: Optional[str] = Header(None)):
+async def get_expression_stats(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
获取表达方式统计数据
@@ -397,7 +476,7 @@ async def get_expression_stats(authorization: Optional[str] = Header(None)):
统计数据
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
total = Expression.select().count()
diff --git a/src/webui/git_mirror_service.py b/src/webui/git_mirror_service.py
index df00cde9..a6a9b1bc 100644
--- a/src/webui/git_mirror_service.py
+++ b/src/webui/git_mirror_service.py
@@ -602,9 +602,9 @@ class GitMirrorService:
# 执行 git clone（在线程池中运行以避免阻塞）
loop = asyncio.get_event_loop()
- def run_git_clone():
+ def run_git_clone(clone_cmd=cmd):
return subprocess.run(
- cmd,
+ clone_cmd,
capture_output=True,
text=True,
timeout=300, # 5分钟超时
diff --git a/src/webui/jargon_routes.py b/src/webui/jargon_routes.py
new file mode 100644
index 00000000..318912e8
--- /dev/null
+++ b/src/webui/jargon_routes.py
@@ -0,0 +1,547 @@
+"""黑话（俚语）管理路由"""
+
+import json
+from typing import Optional, List, Annotated
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel, Field
+from peewee import fn
+
+from src.common.logger import get_logger
+from src.common.database.database_model import Jargon, ChatStreams
+
+logger = get_logger("webui.jargon")
+
+router = APIRouter(prefix="/jargon", tags=["Jargon"])
+
+
+# ==================== 辅助函数 ====================
+
+
+def parse_chat_id_to_stream_ids(chat_id_str: str) -> List[str]:
+ """
+ 解析 chat_id 字段，提取所有 stream_id
+ chat_id 格式: [["stream_id", user_id], ...] 或直接是 stream_id 字符串
+ """
+ if not chat_id_str:
+ return []
+
+ try:
+ # 尝试解析为 JSON
+ parsed = json.loads(chat_id_str)
+ if isinstance(parsed, list):
+ # 格式: [["stream_id", user_id], ...]
+ stream_ids = []
+ for item in parsed:
+ if isinstance(item, list) and len(item) >= 1:
+ stream_ids.append(str(item[0]))
+ return stream_ids
+ else:
+ # 其他格式，返回原始字符串
+ return [chat_id_str]
+ except (json.JSONDecodeError, TypeError):
+ # 不是有效的 JSON，可能是直接的 stream_id
+ return [chat_id_str]
+
+
+def get_display_name_for_chat_id(chat_id_str: str) -> str:
+ """
+ 获取 chat_id 的显示名称
+ 尝试解析 JSON 并查询 ChatStreams 表获取群聊名称
+ """
+ stream_ids = parse_chat_id_to_stream_ids(chat_id_str)
+
+ if not stream_ids:
+ return chat_id_str
+
+ # 查询所有 stream_id 对应的名称
+ names = []
+ for stream_id in stream_ids:
+ chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == stream_id)
+ if chat_stream and chat_stream.group_name:
+ names.append(chat_stream.group_name)
+ else:
+ # 如果没找到，显示截断的 stream_id
+ names.append(stream_id[:8] + "..." if len(stream_id) > 8 else stream_id)
+
+ return ", ".join(names) if names else chat_id_str
+
+
+# ==================== 请求/响应模型 ====================
+
+
+class JargonResponse(BaseModel):
+ """黑话信息响应"""
+
+ id: int
+ content: str
+ raw_content: Optional[str] = None
+ meaning: Optional[str] = None
+ chat_id: str
+ stream_id: Optional[str] = None # 解析后的 stream_id，用于前端编辑时匹配
+ chat_name: Optional[str] = None # 解析后的聊天名称，用于前端显示
+ is_global: bool = False
+ count: int = 0
+ is_jargon: Optional[bool] = None
+ is_complete: bool = False
+ inference_with_context: Optional[str] = None
+ inference_content_only: Optional[str] = None
+
+
+class JargonListResponse(BaseModel):
+ """黑话列表响应"""
+
+ success: bool = True
+ total: int
+ page: int
+ page_size: int
+ data: List[JargonResponse]
+
+
+class JargonDetailResponse(BaseModel):
+ """黑话详情响应"""
+
+ success: bool = True
+ data: JargonResponse
+
+
+class JargonCreateRequest(BaseModel):
+ """黑话创建请求"""
+
+ content: str = Field(..., description="黑话内容")
+ raw_content: Optional[str] = Field(None, description="原始内容")
+ meaning: Optional[str] = Field(None, description="含义")
+ chat_id: str = Field(..., description="聊天ID")
+ is_global: bool = Field(False, description="是否全局")
+
+
+class JargonUpdateRequest(BaseModel):
+ """黑话更新请求"""
+
+ content: Optional[str] = None
+ raw_content: Optional[str] = None
+ meaning: Optional[str] = None
+ chat_id: Optional[str] = None
+ is_global: Optional[bool] = None
+ is_jargon: Optional[bool] = None
+
+
+class JargonCreateResponse(BaseModel):
+ """黑话创建响应"""
+
+ success: bool = True
+ message: str
+ data: JargonResponse
+
+
+class JargonUpdateResponse(BaseModel):
+ """黑话更新响应"""
+
+ success: bool = True
+ message: str
+ data: Optional[JargonResponse] = None
+
+
+class JargonDeleteResponse(BaseModel):
+ """黑话删除响应"""
+
+ success: bool = True
+ message: str
+ deleted_count: int = 0
+
+
+class BatchDeleteRequest(BaseModel):
+ """批量删除请求"""
+
+ ids: List[int] = Field(..., description="要删除的黑话ID列表")
+
+
+class JargonStatsResponse(BaseModel):
+ """黑话统计响应"""
+
+ success: bool = True
+ data: dict
+
+
+class ChatInfoResponse(BaseModel):
+ """聊天信息响应"""
+
+ chat_id: str
+ chat_name: str
+ platform: Optional[str] = None
+ is_group: bool = False
+
+
+class ChatListResponse(BaseModel):
+ """聊天列表响应"""
+
+ success: bool = True
+ data: List[ChatInfoResponse]
+
+
+# ==================== 工具函数 ====================
+
+
+def jargon_to_dict(jargon: Jargon) -> dict:
+ """将 Jargon ORM 对象转换为字典"""
+ # 解析 chat_id 获取显示名称和 stream_id
+ chat_name = get_display_name_for_chat_id(jargon.chat_id) if jargon.chat_id else None
+ stream_ids = parse_chat_id_to_stream_ids(jargon.chat_id) if jargon.chat_id else []
+ stream_id = stream_ids[0] if stream_ids else None
+
+ return {
+ "id": jargon.id,
+ "content": jargon.content,
+ "raw_content": jargon.raw_content,
+ "meaning": jargon.meaning,
+ "chat_id": jargon.chat_id,
+ "stream_id": stream_id,
+ "chat_name": chat_name,
+ "is_global": jargon.is_global,
+ "count": jargon.count,
+ "is_jargon": jargon.is_jargon,
+ "is_complete": jargon.is_complete,
+ "inference_with_context": jargon.inference_with_context,
+ "inference_content_only": jargon.inference_content_only,
+ }
+
+
+# ==================== API 端点 ====================
+
+
+@router.get("/list", response_model=JargonListResponse)
+async def get_jargon_list(
+ page: int = Query(1, ge=1, description="页码"),
+ page_size: int = Query(20, ge=1, le=100, description="每页数量"),
+ search: Optional[str] = Query(None, description="搜索关键词"),
+ chat_id: Optional[str] = Query(None, description="按聊天ID筛选"),
+ is_jargon: Optional[bool] = Query(None, description="按是否是黑话筛选"),
+ is_global: Optional[bool] = Query(None, description="按是否全局筛选"),
+):
+ """获取黑话列表"""
+ try:
+ # 构建查询
+ query = Jargon.select()
+
+ # 搜索过滤
+ if search:
+ query = query.where(
+ (Jargon.content.contains(search))
+ | (Jargon.meaning.contains(search))
+ | (Jargon.raw_content.contains(search))
+ )
+
+ # 按聊天ID筛选（使用 contains 匹配，因为 chat_id 是 JSON 格式）
+ if chat_id:
+ # 从传入的 chat_id 中解析出 stream_id
+ stream_ids = parse_chat_id_to_stream_ids(chat_id)
+ if stream_ids:
+ # 使用第一个 stream_id 进行模糊匹配
+ query = query.where(Jargon.chat_id.contains(stream_ids[0]))
+ else:
+ # 如果无法解析，使用精确匹配
+ query = query.where(Jargon.chat_id == chat_id)
+
+ # 按是否是黑话筛选
+ if is_jargon is not None:
+ query = query.where(Jargon.is_jargon == is_jargon)
+
+ # 按是否全局筛选
+ if is_global is not None:
+ query = query.where(Jargon.is_global == is_global)
+
+ # 获取总数
+ total = query.count()
+
+ # 分页和排序（按使用次数降序）
+ query = query.order_by(Jargon.count.desc(), Jargon.id.desc())
+ query = query.paginate(page, page_size)
+
+ # 转换为响应格式
+ data = [jargon_to_dict(j) for j in query]
+
+ return JargonListResponse(
+ success=True,
+ total=total,
+ page=page,
+ page_size=page_size,
+ data=data,
+ )
+
+ except Exception as e:
+ logger.error(f"获取黑话列表失败: {e}")
+ raise HTTPException(status_code=500, detail=f"获取黑话列表失败: {str(e)}") from e
+
+
+@router.get("/chats", response_model=ChatListResponse)
+async def get_chat_list():
+ """获取所有有黑话记录的聊天列表"""
+ try:
+ # 获取所有不同的 chat_id
+ chat_ids = (
+ Jargon.select(Jargon.chat_id)
+ .distinct()
+ .where(Jargon.chat_id.is_null(False))
+ )
+
+ chat_id_list = [j.chat_id for j in chat_ids if j.chat_id]
+
+ # 用于按 stream_id 去重
+ seen_stream_ids: set[str] = set()
+
+ for chat_id in chat_id_list:
+ stream_ids = parse_chat_id_to_stream_ids(chat_id)
+ if stream_ids:
+ seen_stream_ids.add(stream_ids[0])
+
+ result = []
+ for stream_id in seen_stream_ids:
+ # 尝试从 ChatStreams 表获取聊天名称
+ chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == stream_id)
+ if chat_stream:
+ result.append(
+ ChatInfoResponse(
+ chat_id=stream_id, # 使用 stream_id，方便筛选匹配
+ chat_name=chat_stream.group_name or stream_id,
+ platform=chat_stream.platform,
+ is_group=True,
+ )
+ )
+ else:
+ result.append(
+ ChatInfoResponse(
+ chat_id=stream_id, # 使用 stream_id
+ chat_name=stream_id[:8] + "..." if len(stream_id) > 8 else stream_id,
+ platform=None,
+ is_group=False,
+ )
+ )
+
+ return ChatListResponse(success=True, data=result)
+
+ except Exception as e:
+ logger.error(f"获取聊天列表失败: {e}")
+ raise HTTPException(status_code=500, detail=f"获取聊天列表失败: {str(e)}") from e
+
+
+@router.get("/stats/summary", response_model=JargonStatsResponse)
+async def get_jargon_stats():
+ """获取黑话统计数据"""
+ try:
+ # 总数量
+ total = Jargon.select().count()
+
+ # 已确认是黑话的数量
+ confirmed_jargon = Jargon.select().where(Jargon.is_jargon).count()
+
+ # 已确认不是黑话的数量
+ confirmed_not_jargon = Jargon.select().where(~Jargon.is_jargon).count()
+
+ # 未判定的数量
+ pending = Jargon.select().where(Jargon.is_jargon.is_null()).count()
+
+ # 全局黑话数量
+ global_count = Jargon.select().where(Jargon.is_global).count()
+
+ # 已完成推断的数量
+ complete_count = Jargon.select().where(Jargon.is_complete).count()
+
+ # 关联的聊天数量
+ chat_count = (
+ Jargon.select(Jargon.chat_id)
+ .distinct()
+ .where(Jargon.chat_id.is_null(False))
+ .count()
+ )
+
+ # 按聊天统计 TOP 5
+ top_chats = (
+ Jargon.select(Jargon.chat_id, fn.COUNT(Jargon.id).alias("count"))
+ .group_by(Jargon.chat_id)
+ .order_by(fn.COUNT(Jargon.id).desc())
+ .limit(5)
+ )
+ top_chats_dict = {j.chat_id: j.count for j in top_chats if j.chat_id}
+
+ return JargonStatsResponse(
+ success=True,
+ data={
+ "total": total,
+ "confirmed_jargon": confirmed_jargon,
+ "confirmed_not_jargon": confirmed_not_jargon,
+ "pending": pending,
+ "global_count": global_count,
+ "complete_count": complete_count,
+ "chat_count": chat_count,
+ "top_chats": top_chats_dict,
+ },
+ )
+
+ except Exception as e:
+ logger.error(f"获取黑话统计失败: {e}")
+ raise HTTPException(status_code=500, detail=f"获取黑话统计失败: {str(e)}") from e
+
+
+@router.get("/{jargon_id}", response_model=JargonDetailResponse)
+async def get_jargon_detail(jargon_id: int):
+ """获取黑话详情"""
+ try:
+ jargon = Jargon.get_or_none(Jargon.id == jargon_id)
+ if not jargon:
+ raise HTTPException(status_code=404, detail="黑话不存在")
+
+ return JargonDetailResponse(success=True, data=jargon_to_dict(jargon))
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"获取黑话详情失败: {e}")
+ raise HTTPException(status_code=500, detail=f"获取黑话详情失败: {str(e)}") from e
+
+
+@router.post("/", response_model=JargonCreateResponse)
+async def create_jargon(request: JargonCreateRequest):
+ """创建黑话"""
+ try:
+ # 检查是否已存在相同内容的黑话
+ existing = Jargon.get_or_none(
+ (Jargon.content == request.content) & (Jargon.chat_id == request.chat_id)
+ )
+ if existing:
+ raise HTTPException(status_code=400, detail="该聊天中已存在相同内容的黑话")
+
+ # 创建黑话
+ jargon = Jargon.create(
+ content=request.content,
+ raw_content=request.raw_content,
+ meaning=request.meaning,
+ chat_id=request.chat_id,
+ is_global=request.is_global,
+ count=0,
+ is_jargon=None,
+ is_complete=False,
+ )
+
+ logger.info(f"创建黑话成功: id={jargon.id}, content={request.content}")
+
+ return JargonCreateResponse(
+ success=True,
+ message="创建成功",
+ data=jargon_to_dict(jargon),
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"创建黑话失败: {e}")
+ raise HTTPException(status_code=500, detail=f"创建黑话失败: {str(e)}") from e
+
+
+@router.patch("/{jargon_id}", response_model=JargonUpdateResponse)
+async def update_jargon(jargon_id: int, request: JargonUpdateRequest):
+ """更新黑话（增量更新）"""
+ try:
+ jargon = Jargon.get_or_none(Jargon.id == jargon_id)
+ if not jargon:
+ raise HTTPException(status_code=404, detail="黑话不存在")
+
+ # 增量更新字段
+ update_data = request.model_dump(exclude_unset=True)
+ if update_data:
+ for field, value in update_data.items():
+ if value is not None or field in ["meaning", "raw_content", "is_jargon"]:
+ setattr(jargon, field, value)
+ jargon.save()
+
+ logger.info(f"更新黑话成功: id={jargon_id}")
+
+ return JargonUpdateResponse(
+ success=True,
+ message="更新成功",
+ data=jargon_to_dict(jargon),
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"更新黑话失败: {e}")
+ raise HTTPException(status_code=500, detail=f"更新黑话失败: {str(e)}") from e
+
+
+@router.delete("/{jargon_id}", response_model=JargonDeleteResponse)
+async def delete_jargon(jargon_id: int):
+ """删除黑话"""
+ try:
+ jargon = Jargon.get_or_none(Jargon.id == jargon_id)
+ if not jargon:
+ raise HTTPException(status_code=404, detail="黑话不存在")
+
+ content = jargon.content
+ jargon.delete_instance()
+
+ logger.info(f"删除黑话成功: id={jargon_id}, content={content}")
+
+ return JargonDeleteResponse(
+ success=True,
+ message="删除成功",
+ deleted_count=1,
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"删除黑话失败: {e}")
+ raise HTTPException(status_code=500, detail=f"删除黑话失败: {str(e)}") from e
+
+
+@router.post("/batch/delete", response_model=JargonDeleteResponse)
+async def batch_delete_jargons(request: BatchDeleteRequest):
+ """批量删除黑话"""
+ try:
+ if not request.ids:
+ raise HTTPException(status_code=400, detail="ID列表不能为空")
+
+ deleted_count = Jargon.delete().where(Jargon.id.in_(request.ids)).execute()
+
+ logger.info(f"批量删除黑话成功: 删除了 {deleted_count} 条记录")
+
+ return JargonDeleteResponse(
+ success=True,
+ message=f"成功删除 {deleted_count} 条黑话",
+ deleted_count=deleted_count,
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"批量删除黑话失败: {e}")
+ raise HTTPException(status_code=500, detail=f"批量删除黑话失败: {str(e)}") from e
+
+
+@router.post("/batch/set-jargon", response_model=JargonUpdateResponse)
+async def batch_set_jargon_status(
+ ids: Annotated[List[int], Query(description="黑话ID列表")],
+ is_jargon: Annotated[bool, Query(description="是否是黑话")],
+):
+ """批量设置黑话状态"""
+ try:
+ if not ids:
+ raise HTTPException(status_code=400, detail="ID列表不能为空")
+
+ updated_count = (
+ Jargon.update(is_jargon=is_jargon)
+ .where(Jargon.id.in_(ids))
+ .execute()
+ )
+
+ logger.info(f"批量更新黑话状态成功: 更新了 {updated_count} 条记录，is_jargon={is_jargon}")
+
+ return JargonUpdateResponse(
+ success=True,
+ message=f"成功更新 {updated_count} 条黑话状态",
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"批量更新黑话状态失败: {e}")
+ raise HTTPException(status_code=500, detail=f"批量更新黑话状态失败: {str(e)}") from e
diff --git a/src/webui/knowledge_routes.py b/src/webui/knowledge_routes.py
new file mode 100644
index 00000000..af4594b6
--- /dev/null
+++ b/src/webui/knowledge_routes.py
@@ -0,0 +1,288 @@
+"""知识库图谱可视化 API 路由"""
+
+from typing import List, Optional
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/webui/knowledge", tags=["knowledge"])
+
+
+class KnowledgeNode(BaseModel):
+ """知识节点"""
+
+ id: str
+ type: str # 'entity' or 'paragraph'
+ content: str
+ create_time: Optional[float] = None
+
+
+class KnowledgeEdge(BaseModel):
+ """知识边"""
+
+ source: str
+ target: str
+ weight: float
+ create_time: Optional[float] = None
+ update_time: Optional[float] = None
+
+
+class KnowledgeGraph(BaseModel):
+ """知识图谱"""
+
+ nodes: List[KnowledgeNode]
+ edges: List[KnowledgeEdge]
+
+
+class KnowledgeStats(BaseModel):
+ """知识库统计信息"""
+
+ total_nodes: int
+ total_edges: int
+ entity_nodes: int
+ paragraph_nodes: int
+ avg_connections: float
+
+
+def _load_kg_manager():
+ """延迟加载 KGManager"""
+ try:
+ from src.chat.knowledge.kg_manager import KGManager
+
+ kg_manager = KGManager()
+ kg_manager.load_from_file()
+ return kg_manager
+ except Exception as e:
+ logger.error(f"加载 KGManager 失败: {e}")
+ return None
+
+
+def _convert_graph_to_json(kg_manager) -> KnowledgeGraph:
+ """将 DiGraph 转换为 JSON 格式"""
+ if kg_manager is None or kg_manager.graph is None:
+ return KnowledgeGraph(nodes=[], edges=[])
+
+ graph = kg_manager.graph
+ nodes = []
+ edges = []
+
+ # 转换节点
+ node_list = graph.get_node_list()
+ for node_id in node_list:
+ try:
+ node_data = graph[node_id]
+ # 节点类型: "ent" -> "entity", "pg" -> "paragraph"
+ node_type = "entity" if ("type" in node_data and node_data["type"] == "ent") else "paragraph"
+ content = node_data["content"] if "content" in node_data else node_id
+ create_time = node_data["create_time"] if "create_time" in node_data else None
+
+ nodes.append(KnowledgeNode(id=node_id, type=node_type, content=content, create_time=create_time))
+ except Exception as e:
+ logger.warning(f"跳过节点 {node_id}: {e}")
+ continue
+
+ # 转换边
+ edge_list = graph.get_edge_list()
+ for edge_tuple in edge_list:
+ try:
+ # edge_tuple 是 (source, target) 元组
+ source, target = edge_tuple[0], edge_tuple[1]
+ # 通过 graph[source, target] 获取边的属性数据
+ edge_data = graph[source, target]
+
+ # edge_data 支持 [] 操作符但不支持 .get()
+ weight = edge_data["weight"] if "weight" in edge_data else 1.0
+ create_time = edge_data["create_time"] if "create_time" in edge_data else None
+ update_time = edge_data["update_time"] if "update_time" in edge_data else None
+
+ edges.append(
+ KnowledgeEdge(
+ source=source, target=target, weight=weight, create_time=create_time, update_time=update_time
+ )
+ )
+ except Exception as e:
+ logger.warning(f"跳过边 {edge_tuple}: {e}")
+ continue
+
+ return KnowledgeGraph(nodes=nodes, edges=edges)
+
+
+@router.get("/graph", response_model=KnowledgeGraph)
+async def get_knowledge_graph(
+ limit: int = Query(100, ge=1, le=10000, description="返回的最大节点数"),
+ node_type: str = Query("all", description="节点类型过滤: all, entity, paragraph"),
+):
+ """获取知识图谱(限制节点数量)
+
+ Args:
+ limit: 返回的最大节点数,默认 100,最大 10000
+ node_type: 节点类型过滤 - all(全部), entity(实体), paragraph(段落)
+
+ Returns:
+ KnowledgeGraph: 包含指定数量节点和相关边的知识图谱
+ """
+ try:
+ kg_manager = _load_kg_manager()
+ if kg_manager is None:
+ logger.warning("KGManager 未初始化，返回空图谱")
+ return KnowledgeGraph(nodes=[], edges=[])
+
+ graph = kg_manager.graph
+ all_node_list = graph.get_node_list()
+
+ # 按类型过滤节点
+ if node_type == "entity":
+ all_node_list = [
+ n for n in all_node_list if n in graph and "type" in graph[n] and graph[n]["type"] == "ent"
+ ]
+ elif node_type == "paragraph":
+ all_node_list = [n for n in all_node_list if n in graph and "type" in graph[n] and graph[n]["type"] == "pg"]
+
+ # 限制节点数量
+ total_nodes = len(all_node_list)
+ if len(all_node_list) > limit:
+ node_list = all_node_list[:limit]
+ else:
+ node_list = all_node_list
+
+ logger.info(f"总节点数: {total_nodes}, 返回节点: {len(node_list)} (limit={limit}, type={node_type})")
+
+ # 转换节点
+ nodes = []
+ node_ids = set()
+ for node_id in node_list:
+ try:
+ node_data = graph[node_id]
+ node_type_val = "entity" if ("type" in node_data and node_data["type"] == "ent") else "paragraph"
+ content = node_data["content"] if "content" in node_data else node_id
+ create_time = node_data["create_time"] if "create_time" in node_data else None
+
+ nodes.append(KnowledgeNode(id=node_id, type=node_type_val, content=content, create_time=create_time))
+ node_ids.add(node_id)
+ except Exception as e:
+ logger.warning(f"跳过节点 {node_id}: {e}")
+ continue
+
+ # 只获取涉及当前节点集的边(保证图的完整性)
+ edges = []
+ edge_list = graph.get_edge_list()
+ for edge_tuple in edge_list:
+ try:
+ source, target = edge_tuple[0], edge_tuple[1]
+ # 只包含两端都在当前节点集中的边
+ if source not in node_ids or target not in node_ids:
+ continue
+
+ edge_data = graph[source, target]
+ weight = edge_data["weight"] if "weight" in edge_data else 1.0
+ create_time = edge_data["create_time"] if "create_time" in edge_data else None
+ update_time = edge_data["update_time"] if "update_time" in edge_data else None
+
+ edges.append(
+ KnowledgeEdge(
+ source=source, target=target, weight=weight, create_time=create_time, update_time=update_time
+ )
+ )
+ except Exception as e:
+ logger.warning(f"跳过边 {edge_tuple}: {e}")
+ continue
+
+ graph_data = KnowledgeGraph(nodes=nodes, edges=edges)
+ logger.info(f"返回知识图谱: {len(nodes)} 个节点, {len(edges)} 条边")
+ return graph_data
+
+ except Exception as e:
+ logger.error(f"获取知识图谱失败: {e}", exc_info=True)
+ return KnowledgeGraph(nodes=[], edges=[])
+
+
+@router.get("/stats", response_model=KnowledgeStats)
+async def get_knowledge_stats():
+ """获取知识库统计信息
+
+ Returns:
+ KnowledgeStats: 统计信息
+ """
+ try:
+ kg_manager = _load_kg_manager()
+ if kg_manager is None or kg_manager.graph is None:
+ return KnowledgeStats(total_nodes=0, total_edges=0, entity_nodes=0, paragraph_nodes=0, avg_connections=0.0)
+
+ graph = kg_manager.graph
+ node_list = graph.get_node_list()
+ edge_list = graph.get_edge_list()
+
+ total_nodes = len(node_list)
+ total_edges = len(edge_list)
+
+ # 统计节点类型
+ entity_nodes = 0
+ paragraph_nodes = 0
+ for node_id in node_list:
+ try:
+ node_data = graph[node_id]
+ node_type = node_data["type"] if "type" in node_data else "ent"
+ if node_type == "ent":
+ entity_nodes += 1
+ elif node_type == "pg":
+ paragraph_nodes += 1
+ except Exception:
+ continue
+
+ # 计算平均连接数
+ avg_connections = (total_edges * 2) / total_nodes if total_nodes > 0 else 0.0
+
+ return KnowledgeStats(
+ total_nodes=total_nodes,
+ total_edges=total_edges,
+ entity_nodes=entity_nodes,
+ paragraph_nodes=paragraph_nodes,
+ avg_connections=round(avg_connections, 2),
+ )
+
+ except Exception as e:
+ logger.error(f"获取统计信息失败: {e}", exc_info=True)
+ return KnowledgeStats(total_nodes=0, total_edges=0, entity_nodes=0, paragraph_nodes=0, avg_connections=0.0)
+
+
+@router.get("/search", response_model=List[KnowledgeNode])
+async def search_knowledge_node(query: str = Query(..., min_length=1)):
+ """搜索知识节点
+
+ Args:
+ query: 搜索关键词
+
+ Returns:
+ List[KnowledgeNode]: 匹配的节点列表
+ """
+ try:
+ kg_manager = _load_kg_manager()
+ if kg_manager is None or kg_manager.graph is None:
+ return []
+
+ graph = kg_manager.graph
+ node_list = graph.get_node_list()
+ results = []
+ query_lower = query.lower()
+
+ # 在节点内容中搜索
+ for node_id in node_list:
+ try:
+ node_data = graph[node_id]
+ content = node_data["content"] if "content" in node_data else node_id
+ node_type = "entity" if ("type" in node_data and node_data["type"] == "ent") else "paragraph"
+
+ if query_lower in content.lower() or query_lower in node_id.lower():
+ create_time = node_data["create_time"] if "create_time" in node_data else None
+ results.append(KnowledgeNode(id=node_id, type=node_type, content=content, create_time=create_time))
+ except Exception:
+ continue
+
+ logger.info(f"搜索 '{query}' 找到 {len(results)} 个节点")
+ return results[:50] # 限制返回数量
+
+ except Exception as e:
+ logger.error(f"搜索节点失败: {e}", exc_info=True)
+ return []
diff --git a/src/webui/model_routes.py b/src/webui/model_routes.py
new file mode 100644
index 00000000..7d8310ee
--- /dev/null
+++ b/src/webui/model_routes.py
@@ -0,0 +1,370 @@
+"""
+模型列表获取API路由
+
+提供从各个 AI 厂商 API 获取可用模型列表的代理接口
+"""
+
+import os
+import httpx
+from fastapi import APIRouter, HTTPException, Query
+from typing import Optional
+import tomlkit
+
+from src.common.logger import get_logger
+from src.config.config import CONFIG_DIR
+
+logger = get_logger("webui")
+
+router = APIRouter(prefix="/models", tags=["models"])
+
+
+# 模型获取器配置
+MODEL_FETCHER_CONFIG = {
+ # OpenAI 兼容格式的提供商
+ "openai": {
+ "endpoint": "/models",
+ "parser": "openai",
+ },
+ # Gemini 格式
+ "gemini": {
+ "endpoint": "/models",
+ "parser": "gemini",
+ },
+}
+
+
+def _normalize_url(url: str) -> str:
+ """规范化 URL（去掉尾部斜杠）"""
+ if not url:
+ return ""
+ return url.rstrip("/")
+
+
+def _parse_openai_response(data: dict) -> list[dict]:
+ """
+ 解析 OpenAI 格式的模型列表响应
+
+ 格式: { "data": [{ "id": "gpt-4", "object": "model", ... }] }
+ """
+ models = []
+ if "data" in data and isinstance(data["data"], list):
+ for model in data["data"]:
+ if isinstance(model, dict) and "id" in model:
+ models.append(
+ {
+ "id": model["id"],
+ "name": model.get("name") or model["id"],
+ "owned_by": model.get("owned_by", ""),
+ }
+ )
+ return models
+
+
+def _parse_gemini_response(data: dict) -> list[dict]:
+ """
+ 解析 Gemini 格式的模型列表响应
+
+ 格式: { "models": [{ "name": "models/gemini-pro", "displayName": "Gemini Pro", ... }] }
+ """
+ models = []
+ if "models" in data and isinstance(data["models"], list):
+ for model in data["models"]:
+ if isinstance(model, dict) and "name" in model:
+ # Gemini 的 name 格式是 "models/gemini-pro"，我们只取后面部分
+ model_id = model["name"]
+ if model_id.startswith("models/"):
+ model_id = model_id[7:] # 去掉 "models/" 前缀
+ models.append(
+ {
+ "id": model_id,
+ "name": model.get("displayName") or model_id,
+ "owned_by": "google",
+ }
+ )
+ return models
+
+
+async def _fetch_models_from_provider(
+ base_url: str,
+ api_key: str,
+ endpoint: str,
+ parser: str,
+ client_type: str = "openai",
+) -> list[dict]:
+ """
+ 从提供商 API 获取模型列表
+
+ Args:
+ base_url: 提供商的基础 URL
+ api_key: API 密钥
+ endpoint: 获取模型列表的端点
+ parser: 响应解析器类型 ('openai' | 'gemini')
+ client_type: 客户端类型 ('openai' | 'gemini')
+
+ Returns:
+ 模型列表
+ """
+ url = f"{_normalize_url(base_url)}{endpoint}"
+
+ # 根据客户端类型设置请求头
+ headers = {}
+ params = {}
+
+ if client_type == "gemini":
+ # Gemini 使用 URL 参数传递 API Key
+ params["key"] = api_key
+ else:
+ # OpenAI 兼容格式使用 Authorization 头
+ headers["Authorization"] = f"Bearer {api_key}"
+
+ try:
+ async with httpx.AsyncClient(timeout=30.0) as client:
+ response = await client.get(url, headers=headers, params=params)
+ response.raise_for_status()
+ data = response.json()
+ except httpx.TimeoutException as e:
+ raise HTTPException(status_code=504, detail="请求超时，请稍后重试") from e
+ except httpx.HTTPStatusError as e:
+ # 注意：使用 502 Bad Gateway 而不是原始的 401/403，
+ # 因为前端的 fetchWithAuth 会把 401 当作 WebUI 认证失败处理
+ if e.response.status_code == 401:
+ raise HTTPException(status_code=502, detail="API Key 无效或已过期") from e
+ elif e.response.status_code == 403:
+ raise HTTPException(status_code=502, detail="没有权限访问模型列表，请检查 API Key 权限") from e
+ elif e.response.status_code == 404:
+ raise HTTPException(status_code=502, detail="该提供商不支持获取模型列表") from e
+ else:
+ raise HTTPException(
+ status_code=502, detail=f"上游服务请求失败 ({e.response.status_code}): {e.response.text[:200]}"
+ ) from e
+ except Exception as e:
+ logger.error(f"获取模型列表失败: {e}")
+ raise HTTPException(status_code=500, detail=f"获取模型列表失败: {str(e)}") from e
+
+ # 根据解析器类型解析响应
+ if parser == "openai":
+ return _parse_openai_response(data)
+ elif parser == "gemini":
+ return _parse_gemini_response(data)
+ else:
+ raise HTTPException(status_code=400, detail=f"不支持的解析器类型: {parser}")
+
+
+def _get_provider_config(provider_name: str) -> Optional[dict]:
+ """
+ 从 model_config.toml 获取指定提供商的配置
+
+ Args:
+ provider_name: 提供商名称
+
+ Returns:
+ 提供商配置，如果未找到则返回 None
+ """
+ config_path = os.path.join(CONFIG_DIR, "model_config.toml")
+ if not os.path.exists(config_path):
+ return None
+
+ try:
+ with open(config_path, "r", encoding="utf-8") as f:
+ config_data = tomlkit.load(f)
+
+ providers = config_data.get("api_providers", [])
+ for provider in providers:
+ if provider.get("name") == provider_name:
+ return dict(provider)
+
+ return None
+ except Exception as e:
+ logger.error(f"读取提供商配置失败: {e}")
+ return None
+
+
+@router.get("/list")
+async def get_provider_models(
+ provider_name: str = Query(..., description="提供商名称"),
+ parser: str = Query("openai", description="响应解析器类型 (openai | gemini)"),
+ endpoint: str = Query("/models", description="获取模型列表的端点"),
+):
+ """
+ 获取指定提供商的可用模型列表
+
+ 通过提供商名称查找配置，然后请求对应的模型列表端点
+ """
+ # 获取提供商配置
+ provider_config = _get_provider_config(provider_name)
+ if not provider_config:
+ raise HTTPException(status_code=404, detail=f"未找到提供商: {provider_name}")
+
+ base_url = provider_config.get("base_url")
+ api_key = provider_config.get("api_key")
+ client_type = provider_config.get("client_type", "openai")
+
+ if not base_url:
+ raise HTTPException(status_code=400, detail="提供商配置缺少 base_url")
+ if not api_key:
+ raise HTTPException(status_code=400, detail="提供商配置缺少 api_key")
+
+ # 获取模型列表
+ models = await _fetch_models_from_provider(
+ base_url=base_url,
+ api_key=api_key,
+ endpoint=endpoint,
+ parser=parser,
+ client_type=client_type,
+ )
+
+ return {
+ "success": True,
+ "models": models,
+ "provider": provider_name,
+ "count": len(models),
+ }
+
+
+@router.get("/list-by-url")
+async def get_models_by_url(
+ base_url: str = Query(..., description="提供商的基础 URL"),
+ api_key: str = Query(..., description="API Key"),
+ parser: str = Query("openai", description="响应解析器类型 (openai | gemini)"),
+ endpoint: str = Query("/models", description="获取模型列表的端点"),
+ client_type: str = Query("openai", description="客户端类型 (openai | gemini)"),
+):
+ """
+ 通过 URL 直接获取模型列表（用于自定义提供商）
+ """
+ models = await _fetch_models_from_provider(
+ base_url=base_url,
+ api_key=api_key,
+ endpoint=endpoint,
+ parser=parser,
+ client_type=client_type,
+ )
+
+ return {
+ "success": True,
+ "models": models,
+ "count": len(models),
+ }
+
+
+@router.get("/test-connection")
+async def test_provider_connection(
+ base_url: str = Query(..., description="提供商的基础 URL"),
+ api_key: Optional[str] = Query(None, description="API Key（可选，用于验证 Key 有效性）"),
+):
+ """
+ 测试提供商连接状态
+
+ 分两步测试：
+ 1. 网络连通性测试：向 base_url 发送请求，检查是否能连接
+ 2. API Key 验证（可选）：如果提供了 api_key，尝试获取模型列表验证 Key 是否有效
+
+ 返回：
+ - network_ok: 网络是否连通
+ - api_key_valid: API Key 是否有效（仅在提供 api_key 时返回）
+ - latency_ms: 响应延迟（毫秒）
+ - error: 错误信息（如果有）
+ """
+ import time
+
+ base_url = _normalize_url(base_url)
+ if not base_url:
+ raise HTTPException(status_code=400, detail="base_url 不能为空")
+
+ result = {
+ "network_ok": False,
+ "api_key_valid": None,
+ "latency_ms": None,
+ "error": None,
+ "http_status": None,
+ }
+
+ # 第一步：测试网络连通性
+ try:
+ start_time = time.time()
+ async with httpx.AsyncClient(timeout=10.0, follow_redirects=True) as client:
+ # 尝试 GET 请求 base_url（不需要 API Key）
+ response = await client.get(base_url)
+ latency = (time.time() - start_time) * 1000
+
+ result["network_ok"] = True
+ result["latency_ms"] = round(latency, 2)
+ result["http_status"] = response.status_code
+
+ except httpx.ConnectError as e:
+ result["error"] = f"连接失败：无法连接到服务器 ({str(e)})"
+ return result
+ except httpx.TimeoutException:
+ result["error"] = "连接超时：服务器响应时间过长"
+ return result
+ except httpx.RequestError as e:
+ result["error"] = f"请求错误：{str(e)}"
+ return result
+ except Exception as e:
+ result["error"] = f"未知错误：{str(e)}"
+ return result
+
+ # 第二步：如果提供了 API Key，验证其有效性
+ if api_key:
+ try:
+ start_time = time.time()
+ async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
+ headers = {
+ "Authorization": f"Bearer {api_key}",
+ "Content-Type": "application/json",
+ }
+ # 尝试获取模型列表
+ models_url = f"{base_url}/models"
+ response = await client.get(models_url, headers=headers)
+
+ if response.status_code == 200:
+ result["api_key_valid"] = True
+ elif response.status_code in (401, 403):
+ result["api_key_valid"] = False
+ result["error"] = "API Key 无效或已过期"
+ else:
+ # 其他状态码，可能是端点不支持，但 Key 可能是有效的
+ result["api_key_valid"] = None
+
+ except Exception as e:
+ # API Key 验证失败不影响网络连通性结果
+ logger.warning(f"API Key 验证失败: {e}")
+ result["api_key_valid"] = None
+
+ return result
+
+
+@router.post("/test-connection-by-name")
+async def test_provider_connection_by_name(
+ provider_name: str = Query(..., description="提供商名称"),
+):
+ """
+ 通过提供商名称测试连接（从配置文件读取信息）
+ """
+ # 读取配置文件
+ model_config_path = os.path.join(CONFIG_DIR, "model_config.toml")
+ if not os.path.exists(model_config_path):
+ raise HTTPException(status_code=404, detail="配置文件不存在")
+
+ with open(model_config_path, "r", encoding="utf-8") as f:
+ config = tomlkit.load(f)
+
+ # 查找提供商
+ providers = config.get("api_providers", [])
+ provider = None
+ for p in providers:
+ if p.get("name") == provider_name:
+ provider = p
+ break
+
+ if not provider:
+ raise HTTPException(status_code=404, detail=f"未找到提供商: {provider_name}")
+
+ base_url = provider.get("base_url", "")
+ api_key = provider.get("api_key", "")
+
+ if not base_url:
+ raise HTTPException(status_code=400, detail="提供商配置缺少 base_url")
+
+ # 调用测试接口
+ return await test_provider_connection(base_url=base_url, api_key=api_key if api_key else None)
diff --git a/src/webui/person_routes.py b/src/webui/person_routes.py
index 5935a2fa..5c039371 100644
--- a/src/webui/person_routes.py
+++ b/src/webui/person_routes.py
@@ -1,11 +1,11 @@
"""人物信息管理 API 路由"""
-from fastapi import APIRouter, HTTPException, Header, Query
+from fastapi import APIRouter, HTTPException, Header, Query, Cookie
from pydantic import BaseModel
from typing import Optional, List, Dict
from src.common.logger import get_logger
from src.common.database.database_model import PersonInfo
-from .token_manager import get_token_manager
+from .auth import verify_auth_token_from_cookie_or_header
import json
import time
@@ -91,18 +91,12 @@ class BatchDeleteResponse(BaseModel):
failed_ids: List[str] = []
-def verify_auth_token(authorization: Optional[str]) -> bool:
- """验证认证 Token"""
- if not authorization or not authorization.startswith("Bearer "):
- raise HTTPException(status_code=401, detail="未提供有效的认证信息")
-
- token = authorization.replace("Bearer ", "")
- token_manager = get_token_manager()
-
- if not token_manager.verify_token(token):
- raise HTTPException(status_code=401, detail="Token 无效或已过期")
-
- return True
+def verify_auth_token(
+ maibot_session: Optional[str] = None,
+ authorization: Optional[str] = None,
+) -> bool:
+ """验证认证 Token，支持 Cookie 和 Header"""
+ return verify_auth_token_from_cookie_or_header(maibot_session, authorization)
def parse_group_nick_name(group_nick_name_str: Optional[str]) -> Optional[List[Dict[str, str]]]:
@@ -141,6 +135,7 @@ async def get_person_list(
search: Optional[str] = Query(None, description="搜索关键词"),
is_known: Optional[bool] = Query(None, description="是否已认识筛选"),
platform: Optional[str] = Query(None, description="平台筛选"),
+ maibot_session: Optional[str] = Cookie(None),
authorization: Optional[str] = Header(None),
):
"""
@@ -158,7 +153,7 @@ async def get_person_list(
人物信息列表
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
# 构建查询
query = PersonInfo.select()
@@ -205,7 +200,7 @@ async def get_person_list(
@router.get("/{person_id}", response_model=PersonDetailResponse)
-async def get_person_detail(person_id: str, authorization: Optional[str] = Header(None)):
+async def get_person_detail(person_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
获取人物详细信息
@@ -217,7 +212,7 @@ async def get_person_detail(person_id: str, authorization: Optional[str] = Heade
人物详细信息
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
person = PersonInfo.get_or_none(PersonInfo.person_id == person_id)
@@ -234,7 +229,7 @@ async def get_person_detail(person_id: str, authorization: Optional[str] = Heade
@router.patch("/{person_id}", response_model=PersonUpdateResponse)
-async def update_person(person_id: str, request: PersonUpdateRequest, authorization: Optional[str] = Header(None)):
+async def update_person(person_id: str, request: PersonUpdateRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
增量更新人物信息（只更新提供的字段）
@@ -247,7 +242,7 @@ async def update_person(person_id: str, request: PersonUpdateRequest, authorizat
更新结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
person = PersonInfo.get_or_none(PersonInfo.person_id == person_id)
@@ -283,7 +278,7 @@ async def update_person(person_id: str, request: PersonUpdateRequest, authorizat
@router.delete("/{person_id}", response_model=PersonDeleteResponse)
-async def delete_person(person_id: str, authorization: Optional[str] = Header(None)):
+async def delete_person(person_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
删除人物信息
@@ -295,7 +290,7 @@ async def delete_person(person_id: str, authorization: Optional[str] = Header(No
删除结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
person = PersonInfo.get_or_none(PersonInfo.person_id == person_id)
@@ -320,7 +315,7 @@ async def delete_person(person_id: str, authorization: Optional[str] = Header(No
@router.get("/stats/summary")
-async def get_person_stats(authorization: Optional[str] = Header(None)):
+async def get_person_stats(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
获取人物信息统计数据
@@ -331,7 +326,7 @@ async def get_person_stats(authorization: Optional[str] = Header(None)):
统计数据
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
total = PersonInfo.select().count()
known = PersonInfo.select().where(PersonInfo.is_known).count()
@@ -353,7 +348,7 @@ async def get_person_stats(authorization: Optional[str] = Header(None)):
@router.post("/batch/delete", response_model=BatchDeleteResponse)
-async def batch_delete_persons(request: BatchDeleteRequest, authorization: Optional[str] = Header(None)):
+async def batch_delete_persons(request: BatchDeleteRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)):
"""
批量删除人物信息
@@ -365,7 +360,7 @@ async def batch_delete_persons(request: BatchDeleteRequest, authorization: Optio
批量删除结果
"""
try:
- verify_auth_token(authorization)
+ verify_auth_token(maibot_session, authorization)
if not request.person_ids:
raise HTTPException(status_code=400, detail="未提供要删除的人物ID")
diff --git a/src/webui/plugin_routes.py b/src/webui/plugin_routes.py
index cb559fb7..1f2d85da 100644
--- a/src/webui/plugin_routes.py
+++ b/src/webui/plugin_routes.py
@@ -1,9 +1,10 @@
-from fastapi import APIRouter, HTTPException, Header
+from fastapi import APIRouter, HTTPException, Header, Cookie
from pydantic import BaseModel, Field
from typing import Optional, List, Dict, Any
from pathlib import Path
import json
from src.common.logger import get_logger
+from src.common.toml_utils import save_toml_with_format
from src.config.config import MMC_VERSION
from .git_mirror_service import get_git_mirror_service, set_update_progress_callback
from .token_manager import get_token_manager
@@ -18,6 +19,20 @@ router = APIRouter(prefix="/plugins", tags=["插件管理"])
set_update_progress_callback(update_progress)
+def get_token_from_cookie_or_header(
+ maibot_session: Optional[str] = None,
+ authorization: Optional[str] = None,
+) -> Optional[str]:
+ """从 Cookie 或 Header 获取 token"""
+ # 优先从 Cookie 获取
+ if maibot_session:
+ return maibot_session
+ # 其次从 Header 获取
+ if authorization and authorization.startswith("Bearer "):
+ return authorization.replace("Bearer ", "")
+ return None
+
+
def parse_version(version_str: str) -> tuple[int, int, int]:
"""
解析版本号字符串
@@ -29,8 +44,11 @@ def parse_version(version_str: str) -> tuple[int, int, int]:
Returns:
(major, minor, patch) 三元组
"""
- # 移除 snapshot 等后缀
- base_version = version_str.split(".snapshot")[0].split(".dev")[0].split(".alpha")[0].split(".beta")[0]
+ # 移除 snapshot、dev、alpha、beta 等后缀（支持 - 和 . 分隔符）
+ import re
+
+ # 匹配 -snapshot.X, .snapshot, -dev, .dev, -alpha, .alpha, -beta, .beta 等后缀
+ base_version = re.split(r"[-.](?:snapshot|dev|alpha|beta|rc)", version_str, flags=re.IGNORECASE)[0]
parts = base_version.split(".")
if len(parts) < 3:
@@ -206,12 +224,12 @@ async def check_git_status() -> GitStatusResponse:
@router.get("/mirrors", response_model=AvailableMirrorsResponse)
-async def get_available_mirrors(authorization: Optional[str] = Header(None)) -> AvailableMirrorsResponse:
+async def get_available_mirrors(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> AvailableMirrorsResponse:
"""
获取所有可用的镜像源配置
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -236,12 +254,12 @@ async def get_available_mirrors(authorization: Optional[str] = Header(None)) ->
@router.post("/mirrors", response_model=MirrorConfigResponse)
-async def add_mirror(request: AddMirrorRequest, authorization: Optional[str] = Header(None)) -> MirrorConfigResponse:
+async def add_mirror(request: AddMirrorRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> MirrorConfigResponse:
"""
添加新的镜像源
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -276,13 +294,13 @@ async def add_mirror(request: AddMirrorRequest, authorization: Optional[str] = H
@router.put("/mirrors/{mirror_id}", response_model=MirrorConfigResponse)
async def update_mirror(
- mirror_id: str, request: UpdateMirrorRequest, authorization: Optional[str] = Header(None)
+ mirror_id: str, request: UpdateMirrorRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)
) -> MirrorConfigResponse:
"""
更新镜像源配置
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -319,12 +337,12 @@ async def update_mirror(
@router.delete("/mirrors/{mirror_id}")
-async def delete_mirror(mirror_id: str, authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+async def delete_mirror(mirror_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
"""
删除镜像源
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -342,7 +360,7 @@ async def delete_mirror(mirror_id: str, authorization: Optional[str] = Header(No
@router.post("/fetch-raw", response_model=FetchRawFileResponse)
async def fetch_raw_file(
- request: FetchRawFileRequest, authorization: Optional[str] = Header(None)
+ request: FetchRawFileRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)
) -> FetchRawFileResponse:
"""
获取 GitHub 仓库的 Raw 文件内容
@@ -352,7 +370,7 @@ async def fetch_raw_file(
注意：此接口可公开访问，用于获取插件仓库等公开资源
"""
# Token 验证（可选，用于日志记录）
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
is_authenticated = token and token_manager.verify_token(token)
@@ -427,7 +445,7 @@ async def fetch_raw_file(
@router.post("/clone", response_model=CloneRepositoryResponse)
async def clone_repository(
- request: CloneRepositoryRequest, authorization: Optional[str] = Header(None)
+ request: CloneRepositoryRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)
) -> CloneRepositoryResponse:
"""
克隆 GitHub 仓库到本地
@@ -435,7 +453,7 @@ async def clone_repository(
支持多镜像源自动切换和错误重试
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -467,14 +485,14 @@ async def clone_repository(
@router.post("/install")
-async def install_plugin(request: InstallPluginRequest, authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+async def install_plugin(request: InstallPluginRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
"""
安装插件
从 Git 仓库克隆插件到本地插件目录
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -516,10 +534,14 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[
plugins_dir = Path("plugins")
plugins_dir.mkdir(exist_ok=True)
- target_path = plugins_dir / request.plugin_id
+ # 将插件 ID 中的点替换为下划线作为文件夹名称（避免文件系统问题）
+ # 例如: SengokuCola.Mute-Plugin -> SengokuCola_Mute-Plugin
+ folder_name = request.plugin_id.replace(".", "_")
+ target_path = plugins_dir / folder_name
- # 检查插件是否已安装
- if target_path.exists():
+ # 检查插件是否已安装（需要检查两种格式：新格式下划线和旧格式点）
+ old_format_path = plugins_dir / request.plugin_id
+ if target_path.exists() or old_format_path.exists():
await update_progress(
stage="error",
progress=0,
@@ -608,6 +630,12 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[
if field not in manifest:
raise ValueError(f"缺少必需字段: {field}")
+ # 将插件 ID 写入 manifest（用于后续准确识别）
+ # 这样即使文件夹名称改变，也能通过 manifest 准确识别插件
+ manifest["id"] = request.plugin_id
+ with open(manifest_path, "w", encoding="utf-8") as f:
+ json_module.dump(manifest, f, ensure_ascii=False, indent=2)
+
except Exception as e:
# 清理失败的安装
import shutil
@@ -661,7 +689,7 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[
@router.post("/uninstall")
async def uninstall_plugin(
- request: UninstallPluginRequest, authorization: Optional[str] = Header(None)
+ request: UninstallPluginRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)
) -> Dict[str, Any]:
"""
卸载插件
@@ -669,7 +697,7 @@ async def uninstall_plugin(
删除插件目录及其所有文件
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -686,20 +714,28 @@ async def uninstall_plugin(
plugin_id=request.plugin_id,
)
- # 1. 检查插件是否存在
+ # 1. 检查插件是否存在（支持新旧两种格式）
plugins_dir = Path("plugins")
- plugin_path = plugins_dir / request.plugin_id
+ # 新格式：下划线
+ folder_name = request.plugin_id.replace(".", "_")
+ plugin_path = plugins_dir / folder_name
+ # 旧格式：点
+ old_format_path = plugins_dir / request.plugin_id
+ # 优先使用新格式，如果不存在则尝试旧格式
if not plugin_path.exists():
- await update_progress(
- stage="error",
- progress=0,
- message="插件不存在",
- operation="uninstall",
- plugin_id=request.plugin_id,
- error="插件未安装或已被删除",
- )
- raise HTTPException(status_code=404, detail="插件未安装")
+ if old_format_path.exists():
+ plugin_path = old_format_path
+ else:
+ await update_progress(
+ stage="error",
+ progress=0,
+ message="插件不存在",
+ operation="uninstall",
+ plugin_id=request.plugin_id,
+ error="插件未安装或已被删除",
+ )
+ raise HTTPException(status_code=404, detail="插件未安装")
await update_progress(
stage="loading",
@@ -788,14 +824,14 @@ async def uninstall_plugin(
@router.post("/update")
-async def update_plugin(request: UpdatePluginRequest, authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+async def update_plugin(request: UpdatePluginRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
"""
更新插件
删除旧版本，重新克隆新版本
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -812,25 +848,32 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st
plugin_id=request.plugin_id,
)
- # 1. 检查插件是否已安装
+ # 1. 检查插件是否已安装（支持新旧两种格式）
plugins_dir = Path("plugins")
- plugin_path = plugins_dir / request.plugin_id
+ # 新格式：下划线
+ folder_name = request.plugin_id.replace(".", "_")
+ plugin_path = plugins_dir / folder_name
+ # 旧格式：点
+ old_format_path = plugins_dir / request.plugin_id
+ # 优先使用新格式，如果不存在则尝试旧格式
if not plugin_path.exists():
- await update_progress(
- stage="error",
- progress=0,
- message="插件不存在",
- operation="update",
- plugin_id=request.plugin_id,
- error="插件未安装，请先安装",
- )
- raise HTTPException(status_code=404, detail="插件未安装")
+ if old_format_path.exists():
+ plugin_path = old_format_path
+ else:
+ await update_progress(
+ stage="error",
+ progress=0,
+ message="插件不存在",
+ operation="update",
+ plugin_id=request.plugin_id,
+ error="插件未安装，请先安装",
+ )
+ raise HTTPException(status_code=404, detail="插件未安装")
# 2. 读取旧版本信息
manifest_path = plugin_path / "_manifest.json"
old_version = "unknown"
- plugin_name = request.plugin_id
if manifest_path.exists():
try:
@@ -839,7 +882,6 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st
with open(manifest_path, "r", encoding="utf-8") as f:
manifest = json_module.load(f)
old_version = manifest.get("version", "unknown")
- _plugin_name = manifest.get("name", request.plugin_id)
except Exception:
pass
@@ -1001,14 +1043,14 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st
@router.get("/installed")
-async def get_installed_plugins(authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+async def get_installed_plugins(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
"""
获取已安装的插件列表
扫描 plugins 目录，返回所有已安装插件的 ID 和基本信息
"""
# Token 验证
- token = authorization.replace("Bearer ", "") if authorization else None
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
token_manager = get_token_manager()
if not token or not token_manager.verify_token(token):
raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
@@ -1032,18 +1074,18 @@ async def get_installed_plugins(authorization: Optional[str] = Header(None)) ->
if not plugin_path.is_dir():
continue
- # 目录名即为插件 ID
- plugin_id = plugin_path.name
+ # 目录名（可能是下划线格式、点格式或其他格式）
+ folder_name = plugin_path.name
# 跳过隐藏目录和特殊目录
- if plugin_id.startswith(".") or plugin_id.startswith("__"):
+ if folder_name.startswith(".") or folder_name.startswith("__"):
continue
# 读取 _manifest.json
manifest_path = plugin_path / "_manifest.json"
if not manifest_path.exists():
- logger.warning(f"插件 {plugin_id} 缺少 _manifest.json，跳过")
+ logger.warning(f"插件文件夹 {folder_name} 缺少 _manifest.json，跳过")
continue
try:
@@ -1054,9 +1096,58 @@ async def get_installed_plugins(authorization: Optional[str] = Header(None)) ->
# 基本验证
if "name" not in manifest or "version" not in manifest:
- logger.warning(f"插件 {plugin_id} 的 _manifest.json 格式无效，跳过")
+ logger.warning(f"插件文件夹 {folder_name} 的 _manifest.json 格式无效，跳过")
continue
+ # 获取插件 ID（优先从 manifest，否则从文件夹名推断）
+ if "id" in manifest:
+ # 优先使用 manifest 中的 id（最准确）
+ plugin_id = manifest["id"]
+ else:
+ # 从 manifest 信息构建 ID
+ # 尝试从 author.name 和 repository_url 构建标准 ID
+ author_name = None
+ repo_name = None
+
+ # 获取作者名
+ if "author" in manifest:
+ if isinstance(manifest["author"], dict) and "name" in manifest["author"]:
+ author_name = manifest["author"]["name"]
+ elif isinstance(manifest["author"], str):
+ author_name = manifest["author"]
+
+ # 从 repository_url 获取仓库名
+ if "repository_url" in manifest:
+ repo_url = manifest["repository_url"].rstrip("/")
+ if repo_url.endswith(".git"):
+ repo_url = repo_url[:-4]
+ repo_name = repo_url.split("/")[-1]
+
+ # 构建 ID
+ if author_name and repo_name:
+ # 标准格式: Author.RepoName
+ plugin_id = f"{author_name}.{repo_name}"
+ elif author_name:
+ # 如果只有作者，使用 Author.FolderName
+ plugin_id = f"{author_name}.{folder_name}"
+ else:
+ # 从文件夹名推断
+ if "_" in folder_name and "." not in folder_name:
+ # 假设格式为 Author_PluginName，转换为 Author.PluginName
+ plugin_id = folder_name.replace("_", ".", 1)
+ else:
+ # 直接使用文件夹名
+ plugin_id = folder_name
+
+ # 将推断的 ID 写入 manifest（方便下次识别）
+ logger.info(f"为插件 {folder_name} 自动生成 ID: {plugin_id}")
+ manifest["id"] = plugin_id
+ try:
+ with open(manifest_path, "w", encoding="utf-8") as f:
+ json_module.dump(manifest, f, ensure_ascii=False, indent=2)
+ except Exception as write_error:
+ logger.warning(f"无法写入 ID 到 manifest: {write_error}")
+
# 添加到已安装列表（返回完整的 manifest 信息）
installed_plugins.append(
{
@@ -1080,3 +1171,408 @@ async def get_installed_plugins(authorization: Optional[str] = Header(None)) ->
except Exception as e:
logger.error(f"获取已安装插件列表失败: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e
+
+
+# ============ 插件配置管理 API ============
+
+
+class UpdatePluginConfigRequest(BaseModel):
+ """更新插件配置请求"""
+
+ config: Dict[str, Any] = Field(..., description="配置数据")
+
+
+@router.get("/config/{plugin_id}/schema")
+async def get_plugin_config_schema(plugin_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+ """
+ 获取插件配置 Schema
+
+ 返回插件的完整配置 schema，包含所有 section、字段定义和布局信息。
+ 用于前端动态生成配置表单。
+ """
+ # Token 验证
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
+ token_manager = get_token_manager()
+ if not token or not token_manager.verify_token(token):
+ raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
+
+ logger.info(f"获取插件配置 Schema: {plugin_id}")
+
+ try:
+ # 尝试从已加载的插件中获取
+ from src.plugin_system.core.plugin_manager import plugin_manager
+
+ # 查找插件实例
+ plugin_instance = None
+
+ # 遍历所有已加载的插件
+ for loaded_plugin_name in plugin_manager.list_loaded_plugins():
+ instance = plugin_manager.get_plugin_instance(loaded_plugin_name)
+ if instance:
+ # 匹配 plugin_name 或 manifest 中的 id
+ if instance.plugin_name == plugin_id:
+ plugin_instance = instance
+ break
+ # 也尝试匹配 manifest 中的 id
+ manifest_id = instance.get_manifest_info("id", "")
+ if manifest_id == plugin_id:
+ plugin_instance = instance
+ break
+
+ if plugin_instance and hasattr(plugin_instance, "get_webui_config_schema"):
+ # 从插件实例获取 schema
+ schema = plugin_instance.get_webui_config_schema()
+ return {"success": True, "schema": schema}
+
+ # 如果插件未加载，尝试从文件系统读取
+ # 查找插件目录
+ plugins_dir = Path("plugins")
+ plugin_path = None
+
+ for p in plugins_dir.iterdir():
+ if p.is_dir():
+ manifest_path = p / "_manifest.json"
+ if manifest_path.exists():
+ try:
+ with open(manifest_path, "r", encoding="utf-8") as f:
+ manifest = json.load(f)
+ if manifest.get("id") == plugin_id or p.name == plugin_id:
+ plugin_path = p
+ break
+ except Exception:
+ continue
+
+ if not plugin_path:
+ raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}")
+
+ # 读取配置文件获取当前配置
+ config_path = plugin_path / "config.toml"
+ current_config = {}
+ if config_path.exists():
+ import tomlkit
+
+ with open(config_path, "r", encoding="utf-8") as f:
+ current_config = tomlkit.load(f)
+
+ # 构建基础 schema（无法获取完整的 ConfigField 信息）
+ schema = {
+ "plugin_id": plugin_id,
+ "plugin_info": {
+ "name": plugin_id,
+ "version": "",
+ "description": "",
+ "author": "",
+ },
+ "sections": {},
+ "layout": {"type": "auto", "tabs": []},
+ "_note": "插件未加载，仅返回当前配置结构",
+ }
+
+ # 从当前配置推断 schema
+ for section_name, section_data in current_config.items():
+ if isinstance(section_data, dict):
+ schema["sections"][section_name] = {
+ "name": section_name,
+ "title": section_name,
+ "description": None,
+ "icon": None,
+ "collapsed": False,
+ "order": 0,
+ "fields": {},
+ }
+ for field_name, field_value in section_data.items():
+ # 推断字段类型
+ field_type = type(field_value).__name__
+ ui_type = "text"
+ if isinstance(field_value, bool):
+ ui_type = "switch"
+ elif isinstance(field_value, (int, float)):
+ ui_type = "number"
+ elif isinstance(field_value, list):
+ ui_type = "list"
+ elif isinstance(field_value, dict):
+ ui_type = "json"
+
+ schema["sections"][section_name]["fields"][field_name] = {
+ "name": field_name,
+ "type": field_type,
+ "default": field_value,
+ "description": field_name,
+ "label": field_name,
+ "ui_type": ui_type,
+ "required": False,
+ "hidden": False,
+ "disabled": False,
+ "order": 0,
+ }
+
+ return {"success": True, "schema": schema}
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"获取插件配置 Schema 失败: {e}", exc_info=True)
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e
+
+
+@router.get("/config/{plugin_id}")
+async def get_plugin_config(plugin_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+ """
+ 获取插件当前配置值
+
+ 返回插件的当前配置值。
+ """
+ # Token 验证
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
+ token_manager = get_token_manager()
+ if not token or not token_manager.verify_token(token):
+ raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
+
+ logger.info(f"获取插件配置: {plugin_id}")
+
+ try:
+ # 查找插件目录
+ plugins_dir = Path("plugins")
+ plugin_path = None
+
+ for p in plugins_dir.iterdir():
+ if p.is_dir():
+ manifest_path = p / "_manifest.json"
+ if manifest_path.exists():
+ try:
+ with open(manifest_path, "r", encoding="utf-8") as f:
+ manifest = json.load(f)
+ if manifest.get("id") == plugin_id or p.name == plugin_id:
+ plugin_path = p
+ break
+ except Exception:
+ continue
+
+ if not plugin_path:
+ raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}")
+
+ # 读取配置文件
+ config_path = plugin_path / "config.toml"
+ if not config_path.exists():
+ return {"success": True, "config": {}, "message": "配置文件不存在"}
+
+ import tomlkit
+
+ with open(config_path, "r", encoding="utf-8") as f:
+ config = tomlkit.load(f)
+
+ return {"success": True, "config": dict(config)}
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"获取插件配置失败: {e}", exc_info=True)
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e
+
+
+@router.put("/config/{plugin_id}")
+async def update_plugin_config(
+ plugin_id: str, request: UpdatePluginConfigRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)
+) -> Dict[str, Any]:
+ """
+ 更新插件配置
+
+ 保存新的配置值到插件的配置文件。
+ """
+ # Token 验证
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
+ token_manager = get_token_manager()
+ if not token or not token_manager.verify_token(token):
+ raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
+
+ logger.info(f"更新插件配置: {plugin_id}")
+
+ try:
+ # 查找插件目录
+ plugins_dir = Path("plugins")
+ plugin_path = None
+
+ for p in plugins_dir.iterdir():
+ if p.is_dir():
+ manifest_path = p / "_manifest.json"
+ if manifest_path.exists():
+ try:
+ with open(manifest_path, "r", encoding="utf-8") as f:
+ manifest = json.load(f)
+ if manifest.get("id") == plugin_id or p.name == plugin_id:
+ plugin_path = p
+ break
+ except Exception:
+ continue
+
+ if not plugin_path:
+ raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}")
+
+ config_path = plugin_path / "config.toml"
+
+ # 备份旧配置
+ import shutil
+ import datetime
+
+ if config_path.exists():
+ backup_name = f"config.toml.backup.{datetime.datetime.now().strftime('%Y%m%d%H%M%S')}"
+ backup_path = plugin_path / backup_name
+ shutil.copy(config_path, backup_path)
+ logger.info(f"已备份配置文件: {backup_path}")
+
+ # 写入新配置（使用 tomlkit 保留注释）
+ import tomlkit
+
+ # 先读取原配置以保留注释和格式
+ existing_doc = tomlkit.document()
+ if config_path.exists():
+ with open(config_path, "r", encoding="utf-8") as f:
+ existing_doc = tomlkit.load(f)
+ # 更新值
+ for key, value in request.config.items():
+ existing_doc[key] = value
+ save_toml_with_format(existing_doc, str(config_path))
+
+ logger.info(f"已更新插件配置: {plugin_id}")
+
+ return {"success": True, "message": "配置已保存", "note": "配置更改将在插件重新加载后生效"}
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"更新插件配置失败: {e}", exc_info=True)
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e
+
+
+@router.post("/config/{plugin_id}/reset")
+async def reset_plugin_config(plugin_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+ """
+ 重置插件配置为默认值
+
+ 删除当前配置文件，下次加载插件时将使用默认配置。
+ """
+ # Token 验证
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
+ token_manager = get_token_manager()
+ if not token or not token_manager.verify_token(token):
+ raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
+
+ logger.info(f"重置插件配置: {plugin_id}")
+
+ try:
+ # 查找插件目录
+ plugins_dir = Path("plugins")
+ plugin_path = None
+
+ for p in plugins_dir.iterdir():
+ if p.is_dir():
+ manifest_path = p / "_manifest.json"
+ if manifest_path.exists():
+ try:
+ with open(manifest_path, "r", encoding="utf-8") as f:
+ manifest = json.load(f)
+ if manifest.get("id") == plugin_id or p.name == plugin_id:
+ plugin_path = p
+ break
+ except Exception:
+ continue
+
+ if not plugin_path:
+ raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}")
+
+ config_path = plugin_path / "config.toml"
+
+ if not config_path.exists():
+ return {"success": True, "message": "配置文件不存在，无需重置"}
+
+ # 备份并删除
+ import shutil
+ import datetime
+
+ backup_name = f"config.toml.reset.{datetime.datetime.now().strftime('%Y%m%d%H%M%S')}"
+ backup_path = plugin_path / backup_name
+ shutil.move(config_path, backup_path)
+
+ logger.info(f"已重置插件配置: {plugin_id}，备份: {backup_path}")
+
+ return {"success": True, "message": "配置已重置，下次加载插件时将使用默认配置", "backup": str(backup_path)}
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"重置插件配置失败: {e}", exc_info=True)
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e
+
+
+@router.post("/config/{plugin_id}/toggle")
+async def toggle_plugin(plugin_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+ """
+ 切换插件启用状态
+
+ 切换插件配置中的 enabled 字段。
+ """
+ # Token 验证
+ token = get_token_from_cookie_or_header(maibot_session, authorization)
+ token_manager = get_token_manager()
+ if not token or not token_manager.verify_token(token):
+ raise HTTPException(status_code=401, detail="未授权：无效的访问令牌")
+
+ logger.info(f"切换插件状态: {plugin_id}")
+
+ try:
+ # 查找插件目录
+ plugins_dir = Path("plugins")
+ plugin_path = None
+
+ for p in plugins_dir.iterdir():
+ if p.is_dir():
+ manifest_path = p / "_manifest.json"
+ if manifest_path.exists():
+ try:
+ with open(manifest_path, "r", encoding="utf-8") as f:
+ manifest = json.load(f)
+ if manifest.get("id") == plugin_id or p.name == plugin_id:
+ plugin_path = p
+ break
+ except Exception:
+ continue
+
+ if not plugin_path:
+ raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}")
+
+ config_path = plugin_path / "config.toml"
+
+ import tomlkit
+
+ # 读取当前配置（保留注释和格式）
+ config = tomlkit.document()
+ if config_path.exists():
+ with open(config_path, "r", encoding="utf-8") as f:
+ config = tomlkit.load(f)
+
+ # 切换 enabled 状态
+ if "plugin" not in config:
+ config["plugin"] = tomlkit.table()
+
+ current_enabled = config["plugin"].get("enabled", True)
+ new_enabled = not current_enabled
+ config["plugin"]["enabled"] = new_enabled
+
+ # 写入配置（保留注释，格式化数组）
+ save_toml_with_format(config, str(config_path))
+
+ status = "启用" if new_enabled else "禁用"
+ logger.info(f"已{status}插件: {plugin_id}")
+
+ return {
+ "success": True,
+ "enabled": new_enabled,
+ "message": f"插件已{status}",
+ "note": "状态更改将在下次加载插件时生效",
+ }
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"切换插件状态失败: {e}", exc_info=True)
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e
diff --git a/src/webui/routers/system.py b/src/webui/routers/system.py
index fb203f79..d6932896 100644
--- a/src/webui/routers/system.py
+++ b/src/webui/routers/system.py
@@ -5,14 +5,15 @@
"""
import os
-import sys
import time
from datetime import datetime
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from src.config.config import MMC_VERSION
+from src.common.logger import get_logger
router = APIRouter(prefix="/system", tags=["system"])
+logger = get_logger("webui_system")
# 记录启动时间
_start_time = time.time()
@@ -39,22 +40,27 @@ async def restart_maibot():
"""
重启麦麦主程序
- 使用 os.execv 重启当前进程，配置更改将在重启后生效。
+ 请求重启当前进程，配置更改将在重启后生效。
注意：此操作会使麦麦暂时离线。
"""
+ import asyncio
+
try:
# 记录重启操作
- print(f"[{datetime.now()}] WebUI 触发重启操作")
+ logger.info("WebUI 触发重启操作")
- # 使用 os.execv 重启当前进程
- # 这会替换当前进程，保持相同的 PID
- python = sys.executable
- args = [python] + sys.argv
+ # 定义延迟重启的异步任务
+ async def delayed_restart():
+ await asyncio.sleep(0.5) # 延迟0.5秒，确保响应已发送
+ # 使用 os._exit(42) 退出当前进程，配合外部 runner 脚本进行重启
+ # 42 是约定的重启状态码
+ logger.info("WebUI 请求重启，退出代码 42")
+ os._exit(42)
- # 返回成功响应（实际上这个响应可能不会发送，因为进程会立即重启）
- # 但我们仍然返回它以保持 API 一致性
- os.execv(python, args)
+ # 创建后台任务执行重启
+ asyncio.create_task(delayed_restart())
+ # 立即返回成功响应
return RestartResponse(success=True, message="麦麦正在重启中...")
except Exception as e:
raise HTTPException(status_code=500, detail=f"重启失败: {str(e)}") from e
diff --git a/src/webui/routes.py b/src/webui/routes.py
index 3eb7e673..2c0fc9f7 100644
--- a/src/webui/routes.py
+++ b/src/webui/routes.py
@@ -1,18 +1,21 @@
"""WebUI API 路由"""
-from fastapi import APIRouter, HTTPException, Header
+from fastapi import APIRouter, HTTPException, Header, Response, Request, Cookie
from pydantic import BaseModel, Field
from typing import Optional
from src.common.logger import get_logger
from .token_manager import get_token_manager
+from .auth import set_auth_cookie, clear_auth_cookie
from .config_routes import router as config_router
from .statistics_routes import router as statistics_router
from .person_routes import router as person_router
from .expression_routes import router as expression_router
+from .jargon_routes import router as jargon_router
from .emoji_routes import router as emoji_router
from .plugin_routes import router as plugin_router
from .plugin_progress_ws import get_progress_router
from .routers.system import router as system_router
+from .model_routes import router as model_router
logger = get_logger("webui.api")
@@ -27,6 +30,8 @@ router.include_router(statistics_router)
router.include_router(person_router)
# 注册表达方式管理路由
router.include_router(expression_router)
+# 注册黑话管理路由
+router.include_router(jargon_router)
# 注册表情包管理路由
router.include_router(emoji_router)
# 注册插件管理路由
@@ -35,6 +40,8 @@ router.include_router(plugin_router)
router.include_router(get_progress_router())
# 注册系统控制路由
router.include_router(system_router)
+# 注册模型列表获取路由
+router.include_router(model_router)
class TokenVerifyRequest(BaseModel):
@@ -48,6 +55,7 @@ class TokenVerifyResponse(BaseModel):
valid: bool = Field(..., description="Token 是否有效")
message: str = Field(..., description="验证结果消息")
+ is_first_setup: bool = Field(False, description="是否为首次设置")
class TokenUpdateRequest(BaseModel):
@@ -99,22 +107,27 @@ async def health_check():
@router.post("/auth/verify", response_model=TokenVerifyResponse)
-async def verify_token(request: TokenVerifyRequest):
+async def verify_token(request: TokenVerifyRequest, response: Response):
"""
- 验证访问令牌
+ 验证访问令牌，验证成功后设置 HttpOnly Cookie
Args:
request: 包含 token 的验证请求
+ response: FastAPI Response 对象
Returns:
- 验证结果
+ 验证结果（包含首次配置状态）
"""
try:
token_manager = get_token_manager()
is_valid = token_manager.verify_token(request.token)
if is_valid:
- return TokenVerifyResponse(valid=True, message="Token 验证成功")
+ # 设置 HttpOnly Cookie
+ set_auth_cookie(response, request.token)
+ # 同时返回首次配置状态，避免额外请求
+ is_first_setup = token_manager.is_first_setup()
+ return TokenVerifyResponse(valid=True, message="Token 验证成功", is_first_setup=is_first_setup)
else:
return TokenVerifyResponse(valid=False, message="Token 无效或已过期")
except Exception as e:
@@ -122,24 +135,86 @@ async def verify_token(request: TokenVerifyRequest):
raise HTTPException(status_code=500, detail="Token 验证失败") from e
+@router.post("/auth/logout")
+async def logout(response: Response):
+ """
+ 登出并清除认证 Cookie
+
+ Args:
+ response: FastAPI Response 对象
+
+ Returns:
+ 登出结果
+ """
+ clear_auth_cookie(response)
+ return {"success": True, "message": "已成功登出"}
+
+
+@router.get("/auth/check")
+async def check_auth_status(
+ request: Request,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
+ """
+ 检查当前认证状态（用于前端判断是否已登录）
+
+ Returns:
+ 认证状态
+ """
+ try:
+ token = None
+
+ # 优先从 Cookie 获取
+ if maibot_session:
+ token = maibot_session
+ # 其次从 Header 获取
+ elif authorization and authorization.startswith("Bearer "):
+ token = authorization.replace("Bearer ", "")
+
+ if not token:
+ return {"authenticated": False}
+
+ token_manager = get_token_manager()
+ if token_manager.verify_token(token):
+ return {"authenticated": True}
+ else:
+ return {"authenticated": False}
+ except Exception:
+ return {"authenticated": False}
+
+
@router.post("/auth/update", response_model=TokenUpdateResponse)
-async def update_token(request: TokenUpdateRequest, authorization: Optional[str] = Header(None)):
+async def update_token(
+ request: TokenUpdateRequest,
+ response: Response,
+ req: Request,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
"""
更新访问令牌（需要当前有效的 token）
Args:
request: 包含新 token 的更新请求
+ response: FastAPI Response 对象
+ maibot_session: Cookie 中的 token
authorization: Authorization header (Bearer token)
Returns:
更新结果
"""
try:
- # 验证当前 token
- if not authorization or not authorization.startswith("Bearer "):
+ # 验证当前 token（优先 Cookie，其次 Header）
+ current_token = None
+ if maibot_session:
+ current_token = maibot_session
+ elif authorization and authorization.startswith("Bearer "):
+ current_token = authorization.replace("Bearer ", "")
+
+ if not current_token:
raise HTTPException(status_code=401, detail="未提供有效的认证信息")
- current_token = authorization.replace("Bearer ", "")
token_manager = get_token_manager()
if not token_manager.verify_token(current_token):
@@ -147,6 +222,10 @@ async def update_token(request: TokenUpdateRequest, authorization: Optional[str]
# 更新 token
success, message = token_manager.update_token(request.new_token)
+
+ # 如果更新成功，更新 Cookie
+ if success:
+ set_auth_cookie(response, request.new_token)
return TokenUpdateResponse(success=success, message=message)
except HTTPException:
@@ -157,22 +236,34 @@ async def update_token(request: TokenUpdateRequest, authorization: Optional[str]
@router.post("/auth/regenerate", response_model=TokenRegenerateResponse)
-async def regenerate_token(authorization: Optional[str] = Header(None)):
+async def regenerate_token(
+ response: Response,
+ request: Request,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
"""
重新生成访问令牌（需要当前有效的 token）
Args:
+ response: FastAPI Response 对象
+ maibot_session: Cookie 中的 token
authorization: Authorization header (Bearer token)
Returns:
新生成的 token
"""
try:
- # 验证当前 token
- if not authorization or not authorization.startswith("Bearer "):
- raise HTTPException(status_code=401, detail="未提供有效的认证信息")
+ # 验证当前 token（优先 Cookie，其次 Header）
+ current_token = None
+ if maibot_session:
+ current_token = maibot_session
+ elif authorization and authorization.startswith("Bearer "):
+ current_token = authorization.replace("Bearer ", "")
- current_token = authorization.replace("Bearer ", "")
+ if not current_token:
+ raise HTTPException(status_code=401, detail="未提供有效的认证信息")
+
token_manager = get_token_manager()
if not token_manager.verify_token(current_token):
@@ -180,6 +271,9 @@ async def regenerate_token(authorization: Optional[str] = Header(None)):
# 重新生成 token
new_token = token_manager.regenerate_token()
+
+ # 更新 Cookie
+ set_auth_cookie(response, new_token)
return TokenRegenerateResponse(success=True, token=new_token, message="Token 已重新生成")
except HTTPException:
@@ -190,22 +284,32 @@ async def regenerate_token(authorization: Optional[str] = Header(None)):
@router.get("/setup/status", response_model=FirstSetupStatusResponse)
-async def get_setup_status(authorization: Optional[str] = Header(None)):
+async def get_setup_status(
+ request: Request,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
"""
获取首次配置状态
Args:
+ maibot_session: Cookie 中的 token
authorization: Authorization header (Bearer token)
Returns:
首次配置状态
"""
try:
- # 验证 token
- if not authorization or not authorization.startswith("Bearer "):
+ # 验证 token（优先 Cookie，其次 Header）
+ current_token = None
+ if maibot_session:
+ current_token = maibot_session
+ elif authorization and authorization.startswith("Bearer "):
+ current_token = authorization.replace("Bearer ", "")
+
+ if not current_token:
raise HTTPException(status_code=401, detail="未提供有效的认证信息")
- current_token = authorization.replace("Bearer ", "")
token_manager = get_token_manager()
if not token_manager.verify_token(current_token):
@@ -223,22 +327,32 @@ async def get_setup_status(authorization: Optional[str] = Header(None)):
@router.post("/setup/complete", response_model=CompleteSetupResponse)
-async def complete_setup(authorization: Optional[str] = Header(None)):
+async def complete_setup(
+ request: Request,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
"""
标记首次配置完成
Args:
+ maibot_session: Cookie 中的 token
authorization: Authorization header (Bearer token)
Returns:
完成结果
"""
try:
- # 验证 token
- if not authorization or not authorization.startswith("Bearer "):
+ # 验证 token（优先 Cookie，其次 Header）
+ current_token = None
+ if maibot_session:
+ current_token = maibot_session
+ elif authorization and authorization.startswith("Bearer "):
+ current_token = authorization.replace("Bearer ", "")
+
+ if not current_token:
raise HTTPException(status_code=401, detail="未提供有效的认证信息")
- current_token = authorization.replace("Bearer ", "")
token_manager = get_token_manager()
if not token_manager.verify_token(current_token):
@@ -256,22 +370,32 @@ async def complete_setup(authorization: Optional[str] = Header(None)):
@router.post("/setup/reset", response_model=ResetSetupResponse)
-async def reset_setup(authorization: Optional[str] = Header(None)):
+async def reset_setup(
+ request: Request,
+ maibot_session: Optional[str] = Cookie(None),
+ authorization: Optional[str] = Header(None),
+):
"""
重置首次配置状态，允许重新进入配置向导
Args:
+ maibot_session: Cookie 中的 token
authorization: Authorization header (Bearer token)
Returns:
重置结果
"""
try:
- # 验证 token
- if not authorization or not authorization.startswith("Bearer "):
+ # 验证 token（优先 Cookie，其次 Header）
+ current_token = None
+ if maibot_session:
+ current_token = maibot_session
+ elif authorization and authorization.startswith("Bearer "):
+ current_token = authorization.replace("Bearer ", "")
+
+ if not current_token:
raise HTTPException(status_code=401, detail="未提供有效的认证信息")
- current_token = authorization.replace("Bearer ", "")
token_manager = get_token_manager()
if not token_manager.verify_token(current_token):
diff --git a/src/webui/webui_server.py b/src/webui/webui_server.py
index 61d279e2..ba6b7480 100644
--- a/src/webui/webui_server.py
+++ b/src/webui/webui_server.py
@@ -5,6 +5,7 @@ import asyncio
import mimetypes
from pathlib import Path
from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse
from uvicorn import Config, Server as UvicornServer
from src.common.logger import get_logger
@@ -20,19 +21,39 @@ class WebUIServer:
self.port = port
self.app = FastAPI(title="MaiBot WebUI")
self._server = None
-
+
+ # 配置 CORS（支持开发环境跨域请求）
+ self._setup_cors()
+
# 显示 Access Token
self._show_access_token()
-
+
# 重要：先注册 API 路由，再设置静态文件
self._register_api_routes()
self._setup_static_files()
+ def _setup_cors(self):
+ """配置 CORS 中间件"""
+ # 开发环境需要允许前端开发服务器的跨域请求
+ self.app.add_middleware(
+ CORSMiddleware,
+ allow_origins=[
+ "http://localhost:5173", # Vite 开发服务器
+ "http://127.0.0.1:5173",
+ "http://localhost:8001", # 生产环境
+ "http://127.0.0.1:8001",
+ ],
+ allow_credentials=True, # 允许携带 Cookie
+ allow_methods=["*"],
+ allow_headers=["*"],
+ )
+ logger.debug("✅ CORS 中间件已配置")
+
def _show_access_token(self):
"""显示 WebUI Access Token"""
try:
from src.webui.token_manager import get_token_manager
-
+
token_manager = get_token_manager()
current_token = token_manager.get_token()
logger.info(f"🔑 WebUI Access Token: {current_token}")
@@ -69,7 +90,7 @@ class WebUIServer:
# 如果是根路径，直接返回 index.html
if not full_path or full_path == "/":
return FileResponse(static_path / "index.html", media_type="text/html")
-
+
# 检查是否是静态文件
file_path = static_path / full_path
if file_path.is_file() and file_path.exists():
@@ -89,13 +110,26 @@ class WebUIServer:
from src.webui.routes import router as webui_router
from src.webui.logs_ws import router as logs_router
+ logger.info("开始导入 knowledge_routes...")
+ from src.webui.knowledge_routes import router as knowledge_router
+
+ logger.info("knowledge_routes 导入成功")
+
+ # 导入本地聊天室路由
+ from src.webui.chat_routes import router as chat_router
+
+ logger.info("chat_routes 导入成功")
+
# 注册路由
self.app.include_router(webui_router)
self.app.include_router(logs_router)
+ self.app.include_router(knowledge_router)
+ self.app.include_router(chat_router)
+ logger.info(f"knowledge_router 路由前缀: {knowledge_router.prefix}")
logger.info("✅ WebUI API 路由已注册")
except Exception as e:
- logger.error(f"❌ 注册 WebUI API 路由失败: {e}")
+ logger.error(f"❌ 注册 WebUI API 路由失败: {e}", exc_info=True)
async def start(self):
"""启动服务器"""
@@ -110,6 +144,8 @@ class WebUIServer:
logger.info("🌐 WebUI 服务器启动中...")
logger.info(f"🌐 访问地址: http://{self.host}:{self.port}")
+ if self.host == "0.0.0.0":
+ logger.info(f"本机访问请使用 http://localhost:{self.port}")
try:
await self._server.serve()
diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml
index 2c1da1be..9daf8739 100644
--- a/template/bot_config_template.toml
+++ b/template/bot_config_template.toml
@@ -1,9 +1,9 @@
[inner]
-version = "6.21.8"
+version = "6.23.5"
#----以下是给开发人员阅读的，如果你只是部署了麦麦，不需要阅读----
-#如果你想要修改配置文件，请递增version的值
-#如果新增项目，请阅读src/config/official_configs.py中的说明
+# 如果你想要修改配置文件，请递增version的值
+# 如果新增项目，请阅读src/config/official_configs.py中的说明
#
# 版本格式：主版本号.次版本号.修订号，版本号递增规则如下：
# 主版本号：MMC版本更新
@@ -23,7 +23,7 @@ alias_names = ["麦叠", "牢麦"] # 麦麦的别名
[personality]
# 建议120字以内，描述人格特质 和 身份特征
personality = "是一个女大学生，现在在读大二，会刷贴吧。"
-#アイデンティティがない 生まれないらららら
+# アイデンティティがない 生まれないらららら
# 描述麦麦说话的表达风格，表达习惯，如要修改，可以酌情新增内容
reply_style = "请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景。可以参考贴吧，知乎和微博的回复风格。"
@@ -80,12 +80,16 @@ expression_groups = [
# 注意：如果为群聊，则需要设置为group，如果设置为私聊，则需要设置为private
]
+reflect = false # 是否启用表达反思（Bot主动向管理员询问表达方式是否合适）
+reflect_operator_id = "" # 表达反思操作员ID，格式：platform:id:type (例如 "qq:123456:private" 或 "qq:654321:group")
+allow_reflect = [] # 允许进行表达反思的聊天流ID列表，格式：["qq:123456:private", "qq:654321:group", ...]，只有在此列表中的聊天流才会提出问题并跟踪。如果列表为空，则所有聊天流都可以进行表达反思（前提是 reflect = true）
-[chat] #麦麦的聊天设置
-talk_value = 1 #聊天频率，越小越沉默，范围0-1
+
+[chat] # 麦麦的聊天设置
+talk_value = 1 # 聊天频率，越小越沉默，范围0-1
mentioned_bot_reply = true # 是否启用提及必回复
max_context_size = 30 # 上下文长度
-planner_smooth = 2 #规划器平滑，增大数值会减小planner负荷，略微降低反应速度，推荐1-5，0为关闭，必须大于等于0
+planner_smooth = 2 # 规划器平滑，增大数值会减小planner负荷，略微降低反应速度，推荐1-5，0为关闭，必须大于等于0
enable_talk_value_rules = true # 是否启用动态发言频率规则
@@ -105,6 +109,7 @@ include_planner_reasoning = false # 是否将planner推理加入replyer，默认
[memory]
max_agent_iterations = 3 # 记忆思考深度（最低为1（不深入思考））
+enable_jargon_detection = true # 记忆检索过程中是否启用黑话识别
[jargon]
all_global = true # 是否开启全局黑话模式，注意，此功能关闭后，已经记录的全局黑话不会改变，需要手动删除
@@ -138,8 +143,8 @@ ban_words = [
ban_msgs_regex = [
# 需要过滤的消息（原始消息）匹配的正则表达式，匹配到的消息将被过滤，若不了解正则表达式请勿修改
- #"https?://[^\\s]+", # 匹配https链接
- #"\\d{4}-\\d{2}-\\d{2}", # 匹配日期
+ # "https?://[^\\s]+", # 匹配https链接
+ # "\\d{4}-\\d{2}-\\d{2}", # 匹配日期
]
@@ -168,7 +173,7 @@ embedding_dimension = 1024 # 嵌入向量维度,应该与模型的输出维度
keyword_rules = [
{ keywords = ["人机", "bot", "机器", "入机", "robot", "机器人", "ai", "AI"], reaction = "有人说你是人机或者机器人，否定这一事实，攻击或反问他。注意，只有认为你是机器人才回复，否则不要否认" },
{ keywords = ["测试关键词回复", "test"], reaction = "回答测试成功" },
- #{ keywords = ["你好", "hello"], reaction = "你好，有什么可以帮你？" }
+ # { keywords = ["你好", "hello"], reaction = "你好，有什么可以帮你？" }
# 在此处添加更多规则，格式同上
]
@@ -241,7 +246,7 @@ enable = true
chat_prompts = []
-#此系统暂时移除，无效配置
+# 此系统暂时移除，无效配置
[relationship]
enable_relationship = true # 是否启用关系系统
diff --git a/template/model_config_template.toml b/template/model_config_template.toml
index e7c93352..1e072d13 100644
--- a/template/model_config_template.toml
+++ b/template/model_config_template.toml
@@ -1,5 +1,5 @@
[inner]
-version = "1.8.1"
+version = "1.8.2"
# 配置文件版本号迭代规则同bot_config.toml
@@ -46,7 +46,7 @@ name = "deepseek-v3" # 模型名称（可随意命名，在后面
api_provider = "DeepSeek" # API服务商名称（对应在api_providers中配置的服务商名称）
price_in = 2.0 # 输入价格（用于API调用统计，单位：元/ M token）（可选，若无该字段，默认值为0）
price_out = 8.0 # 输出价格（用于API调用统计，单位：元/ M token）（可选，若无该字段，默认值为0）
-#force_stream_mode = true # 强制流式输出模式（若模型不支持非流式输出，请取消该注释，启用强制流式输出，若无该字段，默认值为false）
+# force_stream_mode = true # 强制流式输出模式（若模型不支持非流式输出，请取消该注释，启用强制流式输出，若无该字段，默认值为false）
[[models]]
model_identifier = "deepseek-ai/DeepSeek-V3.2-Exp"
@@ -56,6 +56,7 @@ price_in = 2.0
price_out = 3.0
[models.extra_params] # 可选的额外参数配置
enable_thinking = false # 不启用思考
+# temperature = 0.5 # 可选：为该模型单独指定温度，会覆盖任务配置中的温度
[[models]]
model_identifier = "deepseek-ai/DeepSeek-V3.2-Exp"
@@ -64,7 +65,8 @@ api_provider = "SiliconFlow"
price_in = 2.0
price_out = 3.0
[models.extra_params] # 可选的额外参数配置
-enable_thinking = true # 不启用思考
+enable_thinking = true # 启用思考
+# temperature = 0.7 # 可选：为该模型单独指定温度，会覆盖任务配置中的温度
[[models]]
model_identifier = "Qwen/Qwen3-Next-80B-A3B-Instruct"
@@ -89,8 +91,7 @@ api_provider = "SiliconFlow"
price_in = 3.5
price_out = 14.0
[models.extra_params] # 可选的额外参数配置
-enable_thinking = true # 不启用思考
-
+enable_thinking = true # 启用思考
[[models]]
model_identifier = "deepseek-ai/DeepSeek-R1"
@@ -134,51 +135,62 @@ price_out = 0
model_list = ["siliconflow-deepseek-v3.2"] # 使用的模型列表，每个子项对应上面的模型名称(name)
temperature = 0.2 # 模型温度，新V3建议0.1-0.3
max_tokens = 2048 # 最大输出token数
+slow_threshold = 15.0 # 慢请求阈值（秒），模型等待回复时间超过此值会输出警告日志
[model_task_config.utils_small] # 在麦麦的一些组件中使用的小模型，消耗量较大，建议使用速度较快的小模型
model_list = ["qwen3-30b","qwen3-next-80b"]
temperature = 0.7
max_tokens = 2048
+slow_threshold = 10.0
[model_task_config.tool_use] #工具调用模型，需要使用支持工具调用的模型
model_list = ["qwen3-30b","qwen3-next-80b"]
temperature = 0.7
max_tokens = 800
+slow_threshold = 10.0
[model_task_config.replyer] # 首要回复模型，还用于表达器和表达方式学习
model_list = ["siliconflow-deepseek-v3.2","siliconflow-deepseek-v3.2-think","siliconflow-glm-4.6","siliconflow-glm-4.6-think"]
temperature = 0.3 # 模型温度，新V3建议0.1-0.3
max_tokens = 2048
+slow_threshold = 25.0
[model_task_config.planner] #决策：负责决定麦麦该什么时候回复的模型
model_list = ["siliconflow-deepseek-v3.2"]
temperature = 0.3
max_tokens = 800
+slow_threshold = 12.0
[model_task_config.vlm] # 图像识别模型
model_list = ["qwen3-vl-30"]
max_tokens = 256
+slow_threshold = 15.0
[model_task_config.voice] # 语音识别模型
model_list = ["sensevoice-small"]
+slow_threshold = 12.0
-#嵌入模型
+# 嵌入模型
[model_task_config.embedding]
model_list = ["bge-m3"]
+slow_threshold = 5.0
-#------------LPMM知识库模型------------
+# ------------LPMM知识库模型------------
[model_task_config.lpmm_entity_extract] # 实体提取模型
model_list = ["siliconflow-deepseek-v3.2"]
temperature = 0.2
max_tokens = 800
+slow_threshold = 20.0
[model_task_config.lpmm_rdf_build] # RDF构建模型
model_list = ["siliconflow-deepseek-v3.2"]
temperature = 0.2
max_tokens = 800
+slow_threshold = 20.0
[model_task_config.lpmm_qa] # 问答模型
model_list = ["siliconflow-deepseek-v3.2"]
temperature = 0.7
max_tokens = 800
+slow_threshold = 20.0
diff --git a/test_edge.py b/test_edge.py
new file mode 100644
index 00000000..7981bb30
--- /dev/null
+++ b/test_edge.py
@@ -0,0 +1,30 @@
+from src.chat.knowledge.kg_manager import KGManager
+
+kg = KGManager()
+kg.load_from_file()
+
+edges = kg.graph.get_edge_list()
+if edges:
+ e = edges[0]
+ print(f"Edge tuple: {e}")
+ print(f"Edge tuple type: {type(e)}")
+
+ edge_data = kg.graph[e[0], e[1]]
+ print(f"\nEdge data type: {type(edge_data)}")
+ print(f"Edge data: {edge_data}")
+ print(f"Has 'get' method: {hasattr(edge_data, 'get')}")
+ print(f"Is dict: {isinstance(edge_data, dict)}")
+
+ # 尝试不同的访问方式
+ try:
+ print(f"\nUsing []: {edge_data['weight']}")
+ except Exception as e:
+ print(f"Using [] failed: {e}")
+
+ try:
+ print(f"Using .get(): {edge_data.get('weight')}")
+ except Exception as e:
+ print(f"Using .get() failed: {e}")
+
+ # 查看所有属性
+ print(f"\nDir: {[x for x in dir(edge_data) if not x.startswith('_')]}")
diff --git a/webui/dist/assets/charts-B1JvyJzO.js b/webui/dist/assets/charts-B1JvyJzO.js
deleted file mode 100644
index 7d2ae929..00000000
--- a/webui/dist/assets/charts-B1JvyJzO.js
+++ /dev/null
@@ -1,65 +0,0 @@
-import{r as N,R as S,i as Qt}from"./router-BWgTyY51.js";import{c as vi,g as oe}from"./react-vendor-Dtc2IqVY.js";function Ub(e){var t,r,n="";if(typeof e=="string"||typeof e=="number")n+=e;else if(typeof e=="object")if(Array.isArray(e)){var i=e.length;for(t=0;t-1}return Ho=t,Ho}var Ko,Op;function TO(){if(Op)return Ko;Op=1;var e=ja();function t(r,n){var i=this.__data__,a=e(i,r);return a<0?(++this.size,i.push([r,n])):i[a][1]=n,this}return Ko=t,Ko}var Go,_p;function Ma(){if(_p)return Go;_p=1;var e=_O(),t=AO(),r=SO(),n=PO(),i=TO();function a(o){var u=-1,c=o==null?0:o.length;for(this.clear();++u0?1:-1},Gt=function(t){return er(t)&&t.indexOf("%")===t.length-1},q=function(t){return YO(t)&&!oi(t)},ZO=function(t){return Y(t)},Ae=function(t){return q(t)||er(t)},JO=0,Zr=function(t){var r=++JO;return"".concat(t||"").concat(r)},Ie=function(t,r){var n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,i=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(!q(t)&&!er(t))return n;var a;if(Gt(t)){var o=t.indexOf("%");a=r*parseFloat(t.slice(0,o))/100}else a=+t;return oi(a)&&(a=n),i&&a>r&&(a=r),a},Mt=function(t){if(!t)return null;var r=Object.keys(t);return r&&r.length?t[r[0]]:null},QO=function(t){if(!Array.isArray(t))return!1;for(var r=t.length,n={},i=0;i=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function o_(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function ml(e){"@babel/helpers - typeof";return ml=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},ml(e)}var Zp={click:"onClick",mousedown:"onMouseDown",mouseup:"onMouseUp",mouseover:"onMouseOver",mousemove:"onMouseMove",mouseout:"onMouseOut",mouseenter:"onMouseEnter",mouseleave:"onMouseLeave",touchcancel:"onTouchCancel",touchend:"onTouchEnd",touchmove:"onTouchMove",touchstart:"onTouchStart",contextmenu:"onContextMenu",dblclick:"onDoubleClick"},bt=function(t){return typeof t=="string"?t:t?t.displayName||t.name||"Component":""},Jp=null,bu=null,Kf=function e(t){if(t===Jp&&Array.isArray(bu))return bu;var r=[];return N.Children.forEach(t,function(n){Y(n)||(KO.isFragment(n)?r=r.concat(e(n.props.children)):r.push(n))}),bu=r,Jp=t,r};function Ke(e,t){var r=[],n=[];return Array.isArray(t)?n=t.map(function(i){return bt(i)}):n=[bt(t)],Kf(e).forEach(function(i){var a=He(i,"type.displayName")||He(i,"type.name");n.indexOf(a)!==-1&&r.push(i)}),r}function We(e,t){var r=Ke(e,t);return r&&r[0]}var Qp=function(t){if(!t||!t.props)return!1;var r=t.props,n=r.width,i=r.height;return!(!q(n)||n<=0||!q(i)||i<=0)},u_=["a","altGlyph","altGlyphDef","altGlyphItem","animate","animateColor","animateMotion","animateTransform","circle","clipPath","color-profile","cursor","defs","desc","ellipse","feBlend","feColormatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDistantLight","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feImage","feMerge","feMergeNode","feMorphology","feOffset","fePointLight","feSpecularLighting","feSpotLight","feTile","feTurbulence","filter","font","font-face","font-face-format","font-face-name","font-face-url","foreignObject","g","glyph","glyphRef","hkern","image","line","lineGradient","marker","mask","metadata","missing-glyph","mpath","path","pattern","polygon","polyline","radialGradient","rect","script","set","stop","style","svg","switch","symbol","text","textPath","title","tref","tspan","use","view","vkern"],c_=function(t){return t&&t.type&&er(t.type)&&u_.indexOf(t.type)>=0},s_=function(t){return t&&ml(t)==="object"&&"clipDot"in t},l_=function(t,r,n,i){var a,o=(a=gu?.[i])!==null&&a!==void 0?a:[];return r.startsWith("data-")||!X(t)&&(i&&o.includes(r)||r_.includes(r))||n&&Hf.includes(r)},H=function(t,r,n){if(!t||typeof t=="function"||typeof t=="boolean")return null;var i=t;if(N.isValidElement(t)&&(i=t.props),!Yr(i))return null;var a={};return Object.keys(i).forEach(function(o){var u;l_((u=i)===null||u===void 0?void 0:u[o],o,r,n)&&(a[o]=i[o])}),a},gl=function e(t,r){if(t===r)return!0;var n=N.Children.count(t);if(n!==N.Children.count(r))return!1;if(n===0)return!0;if(n===1)return ed(Array.isArray(t)?t[0]:t,Array.isArray(r)?r[0]:r);for(var i=0;i=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function v_(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function xl(e){var t=e.children,r=e.width,n=e.height,i=e.viewBox,a=e.className,o=e.style,u=e.title,c=e.desc,s=d_(e,p_),f=i||{width:r,height:n,x:0,y:0},l=J("recharts-surface",a);return S.createElement("svg",bl({},H(s,!0,"svg"),{className:l,width:r,height:n,style:o,viewBox:"".concat(f.x," ").concat(f.y," ").concat(f.width," ").concat(f.height)}),S.createElement("title",null,u),S.createElement("desc",null,c),t)}var y_=["children","className"];function wl(){return wl=Object.assign?Object.assign.bind():function(e){for(var t=1;t=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function g_(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}var te=S.forwardRef(function(e,t){var r=e.children,n=e.className,i=m_(e,y_),a=J("recharts-layer",n);return S.createElement("g",wl({className:a},H(i,!0),{ref:t}),r)}),it=function(t,r){for(var n=arguments.length,i=new Array(n>2?n-2:0),a=2;aa?0:a+r),n=n>a?a:n,n<0&&(n+=a),a=r>n?0:n-r>>>0,r>>>=0;for(var o=Array(a);++i=a?r:e(r,n,i)}return wu=t,wu}var Ou,id;function Jb(){if(id)return Ou;id=1;var e="\\ud800-\\udfff",t="\\u0300-\\u036f",r="\\ufe20-\\ufe2f",n="\\u20d0-\\u20ff",i=t+r+n,a="\\ufe0e\\ufe0f",o="\\u200d",u=RegExp("["+o+e+i+a+"]");function c(s){return u.test(s)}return Ou=c,Ou}var _u,ad;function w_(){if(ad)return _u;ad=1;function e(t){return t.split("")}return _u=e,_u}var Au,od;function O_(){if(od)return Au;od=1;var e="\\ud800-\\udfff",t="\\u0300-\\u036f",r="\\ufe20-\\ufe2f",n="\\u20d0-\\u20ff",i=t+r+n,a="\\ufe0e\\ufe0f",o="["+e+"]",u="["+i+"]",c="\\ud83c[\\udffb-\\udfff]",s="(?:"+u+"|"+c+")",f="[^"+e+"]",l="(?:\\ud83c[\\udde6-\\uddff]){2}",h="[\\ud800-\\udbff][\\udc00-\\udfff]",d="\\u200d",y=s+"?",v="["+a+"]?",p="(?:"+d+"(?:"+[f,l,h].join("|")+")"+v+y+")*",g=v+y+p,x="(?:"+[f+u+"?",u,l,h,o].join("|")+")",w=RegExp(c+"(?="+c+")|"+x+g,"g");function O(m){return m.match(w)||[]}return Au=O,Au}var Su,ud;function __(){if(ud)return Su;ud=1;var e=w_(),t=Jb(),r=O_();function n(i){return t(i)?r(i):e(i)}return Su=n,Su}var Pu,cd;function A_(){if(cd)return Pu;cd=1;var e=x_(),t=Jb(),r=__(),n=Vb();function i(a){return function(o){o=n(o);var u=t(o)?r(o):void 0,c=u?u[0]:o.charAt(0),s=u?e(u,1).join(""):o.slice(1);return c[a]()+s}}return Pu=i,Pu}var Tu,sd;function S_(){if(sd)return Tu;sd=1;var e=A_(),t=e("toUpperCase");return Tu=t,Tu}var P_=S_();const Ia=oe(P_);function se(e){return function(){return e}}const Qb=Math.cos,Ci=Math.sin,at=Math.sqrt,Ii=Math.PI,ka=2*Ii,Ol=Math.PI,_l=2*Ol,Ut=1e-6,T_=_l-Ut;function e0(e){this._+=e[0];for(let t=1,r=e.length;t=0))throw new Error(`invalid digits: ${e}`);if(t>15)return e0;const r=10**t;return function(n){this._+=n[0];for(let i=1,a=n.length;iUt)if(!(Math.abs(l*c-s*f)>Ut)||!a)this._append`L${this._x1=t},${this._y1=r}`;else{let d=n-o,y=i-u,v=c*c+s*s,p=d*d+y*y,g=Math.sqrt(v),x=Math.sqrt(h),w=a*Math.tan((Ol-Math.acos((v+h-p)/(2*g*x)))/2),O=w/x,m=w/g;Math.abs(O-1)>Ut&&this._append`L${t+O*f},${r+O*l}`,this._append`A${a},${a},0,0,${+(l*d>f*y)},${this._x1=t+m*c},${this._y1=r+m*s}`}}arc(t,r,n,i,a,o){if(t=+t,r=+r,n=+n,o=!!o,n<0)throw new Error(`negative radius: ${n}`);let u=n*Math.cos(i),c=n*Math.sin(i),s=t+u,f=r+c,l=1^o,h=o?i-a:a-i;this._x1===null?this._append`M${s},${f}`:(Math.abs(this._x1-s)>Ut||Math.abs(this._y1-f)>Ut)&&this._append`L${s},${f}`,n&&(h<0&&(h=h%_l+_l),h>T_?this._append`A${n},${n},0,1,${l},${t-u},${r-c}A${n},${n},0,1,${l},${this._x1=s},${this._y1=f}`:h>Ut&&this._append`A${n},${n},0,${+(h>=Ol)},${l},${this._x1=t+n*Math.cos(a)},${this._y1=r+n*Math.sin(a)}`)}rect(t,r,n,i){this._append`M${this._x0=this._x1=+t},${this._y0=this._y1=+r}h${n=+n}v${+i}h${-n}Z`}toString(){return this._}}function Gf(e){let t=3;return e.digits=function(r){if(!arguments.length)return t;if(r==null)t=null;else{const n=Math.floor(r);if(!(n>=0))throw new RangeError(`invalid digits: ${r}`);t=n}return e},()=>new j_(t)}function Vf(e){return typeof e=="object"&&"length"in e?e:Array.from(e)}function t0(e){this._context=e}t0.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}};function Ra(e){return new t0(e)}function r0(e){return e[0]}function n0(e){return e[1]}function i0(e,t){var r=se(!0),n=null,i=Ra,a=null,o=Gf(u);e=typeof e=="function"?e:e===void 0?r0:se(e),t=typeof t=="function"?t:t===void 0?n0:se(t);function u(c){var s,f=(c=Vf(c)).length,l,h=!1,d;for(n==null&&(a=i(d=o())),s=0;s<=f;++s)!(s=d;--y)u.point(w[y],O[y]);u.lineEnd(),u.areaEnd()}g&&(w[h]=+e(p,h,l),O[h]=+t(p,h,l),u.point(n?+n(p,h,l):w[h],r?+r(p,h,l):O[h]))}if(x)return u=null,x+""||null}function f(){return i0().defined(i).curve(o).context(a)}return s.x=function(l){return arguments.length?(e=typeof l=="function"?l:se(+l),n=null,s):e},s.x0=function(l){return arguments.length?(e=typeof l=="function"?l:se(+l),s):e},s.x1=function(l){return arguments.length?(n=l==null?null:typeof l=="function"?l:se(+l),s):n},s.y=function(l){return arguments.length?(t=typeof l=="function"?l:se(+l),r=null,s):t},s.y0=function(l){return arguments.length?(t=typeof l=="function"?l:se(+l),s):t},s.y1=function(l){return arguments.length?(r=l==null?null:typeof l=="function"?l:se(+l),s):r},s.lineX0=s.lineY0=function(){return f().x(e).y(t)},s.lineY1=function(){return f().x(e).y(r)},s.lineX1=function(){return f().x(n).y(t)},s.defined=function(l){return arguments.length?(i=typeof l=="function"?l:se(!!l),s):i},s.curve=function(l){return arguments.length?(o=l,a!=null&&(u=o(a)),s):o},s.context=function(l){return arguments.length?(l==null?a=u=null:u=o(a=l),s):a},s}class a0{constructor(t,r){this._context=t,this._x=r}areaStart(){this._line=0}areaEnd(){this._line=NaN}lineStart(){this._point=0}lineEnd(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line}point(t,r){switch(t=+t,r=+r,this._point){case 0:{this._point=1,this._line?this._context.lineTo(t,r):this._context.moveTo(t,r);break}case 1:this._point=2;default:{this._x?this._context.bezierCurveTo(this._x0=(this._x0+t)/2,this._y0,this._x0,r,t,r):this._context.bezierCurveTo(this._x0,this._y0=(this._y0+r)/2,t,this._y0,t,r);break}}this._x0=t,this._y0=r}}function M_(e){return new a0(e,!0)}function $_(e){return new a0(e,!1)}const Xf={draw(e,t){const r=at(t/Ii);e.moveTo(r,0),e.arc(0,0,r,0,ka)}},C_={draw(e,t){const r=at(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}},o0=at(1/3),I_=o0*2,k_={draw(e,t){const r=at(t/I_),n=r*o0;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}},R_={draw(e,t){const r=at(t),n=-r/2;e.rect(n,n,r,r)}},D_=.8908130915292852,u0=Ci(Ii/10)/Ci(7*Ii/10),N_=Ci(ka/10)*u0,q_=-Qb(ka/10)*u0,L_={draw(e,t){const r=at(t*D_),n=N_*r,i=q_*r;e.moveTo(0,-r),e.lineTo(n,i);for(let a=1;a<5;++a){const o=ka*a/5,u=Qb(o),c=Ci(o);e.lineTo(c*r,-u*r),e.lineTo(u*n-c*i,c*n+u*i)}e.closePath()}},Eu=at(3),B_={draw(e,t){const r=-at(t/(Eu*3));e.moveTo(0,r*2),e.lineTo(-Eu*r,-r),e.lineTo(Eu*r,-r),e.closePath()}},Ge=-.5,Ve=at(3)/2,Al=1/at(12),F_=(Al/2+1)*3,W_={draw(e,t){const r=at(t/F_),n=r/2,i=r*Al,a=n,o=r*Al+r,u=-a,c=o;e.moveTo(n,i),e.lineTo(a,o),e.lineTo(u,c),e.lineTo(Ge*n-Ve*i,Ve*n+Ge*i),e.lineTo(Ge*a-Ve*o,Ve*a+Ge*o),e.lineTo(Ge*u-Ve*c,Ve*u+Ge*c),e.lineTo(Ge*n+Ve*i,Ge*i-Ve*n),e.lineTo(Ge*a+Ve*o,Ge*o-Ve*a),e.lineTo(Ge*u+Ve*c,Ge*c-Ve*u),e.closePath()}};function z_(e,t){let r=null,n=Gf(i);e=typeof e=="function"?e:se(e||Xf),t=typeof t=="function"?t:se(t===void 0?64:+t);function i(){let a;if(r||(r=a=n()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),a)return r=null,a+""||null}return i.type=function(a){return arguments.length?(e=typeof a=="function"?a:se(a),i):e},i.size=function(a){return arguments.length?(t=typeof a=="function"?a:se(+a),i):t},i.context=function(a){return arguments.length?(r=a??null,i):r},i}function ki(){}function Ri(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function c0(e){this._context=e}c0.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Ri(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Ri(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function U_(e){return new c0(e)}function s0(e){this._context=e}s0.prototype={areaStart:ki,areaEnd:ki,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Ri(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function H_(e){return new s0(e)}function l0(e){this._context=e}l0.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Ri(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function K_(e){return new l0(e)}function f0(e){this._context=e}f0.prototype={areaStart:ki,areaEnd:ki,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}};function G_(e){return new f0(e)}function ld(e){return e<0?-1:1}function fd(e,t,r){var n=e._x1-e._x0,i=t-e._x1,a=(e._y1-e._y0)/(n||i<0&&-0),o=(r-e._y1)/(i||n<0&&-0),u=(a*i+o*n)/(n+i);return(ld(a)+ld(o))*Math.min(Math.abs(a),Math.abs(o),.5*Math.abs(u))||0}function hd(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function ju(e,t,r){var n=e._x0,i=e._y0,a=e._x1,o=e._y1,u=(a-n)/3;e._context.bezierCurveTo(n+u,i+u*t,a-u,o-u*r,a,o)}function Di(e){this._context=e}Di.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:ju(this,this._t0,hd(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,ju(this,hd(this,r=fd(this,e,t)),r);break;default:ju(this,this._t0,r=fd(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};function h0(e){this._context=new p0(e)}(h0.prototype=Object.create(Di.prototype)).point=function(e,t){Di.prototype.point.call(this,t,e)};function p0(e){this._context=e}p0.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,a){this._context.bezierCurveTo(t,e,n,r,a,i)}};function V_(e){return new Di(e)}function X_(e){return new h0(e)}function d0(e){this._context=e}d0.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=pd(e),i=pd(t),a=0,o=1;o=0;--t)i[t]=(o[t]-i[t+1])/a[t];for(a[r-1]=(e[r]+i[r-1])/2,t=0;t=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}};function Z_(e){return new Da(e,.5)}function J_(e){return new Da(e,0)}function Q_(e){return new Da(e,1)}function Ar(e,t){if((o=e.length)>1)for(var r=1,n,i,a=e[t[0]],o,u=a.length;r=0;)r[t]=t;return r}function e1(e,t){return e[t]}function t1(e){const t=[];return t.key=e,t}function r1(){var e=se([]),t=Sl,r=Ar,n=e1;function i(a){var o=Array.from(e.apply(this,arguments),t1),u,c=o.length,s=-1,f;for(const l of a)for(u=0,++s;u0){for(var r,n,i=0,a=e[0].length,o;i0){for(var r=0,n=e[t[0]],i,a=n.length;r0)||!((a=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,a,o;n=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function f1(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}var v0={symbolCircle:Xf,symbolCross:C_,symbolDiamond:k_,symbolSquare:R_,symbolStar:L_,symbolTriangle:B_,symbolWye:W_},h1=Math.PI/180,p1=function(t){var r="symbol".concat(Ia(t));return v0[r]||Xf},d1=function(t,r,n){if(r==="area")return t;switch(n){case"cross":return 5*t*t/9;case"diamond":return .5*t*t/Math.sqrt(3);case"square":return t*t;case"star":{var i=18*h1;return 1.25*t*t*(Math.tan(i)-Math.tan(i*2)*Math.pow(Math.tan(i),2))}case"triangle":return Math.sqrt(3)*t*t/4;case"wye":return(21-10*Math.sqrt(3))*t*t/8;default:return Math.PI*t*t/4}},v1=function(t,r){v0["symbol".concat(Ia(t))]=r},Yf=function(t){var r=t.type,n=r===void 0?"circle":r,i=t.size,a=i===void 0?64:i,o=t.sizeType,u=o===void 0?"area":o,c=l1(t,o1),s=vd(vd({},c),{},{type:n,size:a,sizeType:u}),f=function(){var p=p1(n),g=z_().type(p).size(d1(a,u,n));return g()},l=s.className,h=s.cx,d=s.cy,y=H(s,!0);return h===+h&&d===+d&&a===+a?S.createElement("path",Pl({},y,{className:J("recharts-symbols",l),transform:"translate(".concat(h,", ").concat(d,")"),d:f()})):null};Yf.registerSymbol=v1;function Sr(e){"@babel/helpers - typeof";return Sr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Sr(e)}function Tl(){return Tl=Object.assign?Object.assign.bind():function(e){for(var t=1;t`);var x=d.inactive?s:d.color;return S.createElement("li",Tl({className:p,style:l,key:"legend-item-".concat(y)},tr(n.props,d,y)),S.createElement(xl,{width:o,height:o,viewBox:f,style:h},n.renderIcon(d)),S.createElement("span",{className:"recharts-legend-item-text",style:{color:x}},v?v(g,d,y):g))})}},{key:"render",value:function(){var n=this.props,i=n.payload,a=n.layout,o=n.align;if(!i||!i.length)return null;var u={padding:0,margin:0,textAlign:a==="horizontal"?o:"left"};return S.createElement("ul",{className:"recharts-default-legend",style:u},this.renderItems())}}])})(N.PureComponent);Sn(Zf,"displayName","Legend");Sn(Zf,"defaultProps",{iconSize:14,layout:"horizontal",align:"center",verticalAlign:"middle",inactiveColor:"#ccc"});var Mu,md;function S1(){if(md)return Mu;md=1;var e=Ma();function t(){this.__data__=new e,this.size=0}return Mu=t,Mu}var $u,gd;function P1(){if(gd)return $u;gd=1;function e(t){var r=this.__data__,n=r.delete(t);return this.size=r.size,n}return $u=e,$u}var Cu,bd;function T1(){if(bd)return Cu;bd=1;function e(t){return this.__data__.get(t)}return Cu=e,Cu}var Iu,xd;function E1(){if(xd)return Iu;xd=1;function e(t){return this.__data__.has(t)}return Iu=e,Iu}var ku,wd;function j1(){if(wd)return ku;wd=1;var e=Ma(),t=Ff(),r=Wf(),n=200;function i(a,o){var u=this.__data__;if(u instanceof e){var c=u.__data__;if(!t||c.lengthd))return!1;var v=l.get(o),p=l.get(u);if(v&&p)return v==u&&p==o;var g=-1,x=!0,w=c&i?new e:void 0;for(l.set(o,u),l.set(u,o);++g-1&&n%1==0&&n-1&&r%1==0&&r<=e}return rc=t,rc}var nc,Hd;function W1(){if(Hd)return nc;Hd=1;var e=St(),t=th(),r=Pt(),n="[object Arguments]",i="[object Array]",a="[object Boolean]",o="[object Date]",u="[object Error]",c="[object Function]",s="[object Map]",f="[object Number]",l="[object Object]",h="[object RegExp]",d="[object Set]",y="[object String]",v="[object WeakMap]",p="[object ArrayBuffer]",g="[object DataView]",x="[object Float32Array]",w="[object Float64Array]",O="[object Int8Array]",m="[object Int16Array]",b="[object Int32Array]",_="[object Uint8Array]",A="[object Uint8ClampedArray]",T="[object Uint16Array]",M="[object Uint32Array]",P={};P[x]=P[w]=P[O]=P[m]=P[b]=P[_]=P[A]=P[T]=P[M]=!0,P[n]=P[i]=P[p]=P[a]=P[g]=P[o]=P[u]=P[c]=P[s]=P[f]=P[l]=P[h]=P[d]=P[y]=P[v]=!1;function E(j){return r(j)&&t(j.length)&&!!P[e(j)]}return nc=E,nc}var ic,Kd;function S0(){if(Kd)return ic;Kd=1;function e(t){return function(r){return t(r)}}return ic=e,ic}var vn={exports:{}};vn.exports;var Gd;function z1(){return Gd||(Gd=1,(function(e,t){var r=Hb(),n=t&&!t.nodeType&&t,i=n&&!0&&e&&!e.nodeType&&e,a=i&&i.exports===n,o=a&&r.process,u=(function(){try{var c=i&&i.require&&i.require("util").types;return c||o&&o.binding&&o.binding("util")}catch{}})();e.exports=u})(vn,vn.exports)),vn.exports}var ac,Vd;function P0(){if(Vd)return ac;Vd=1;var e=W1(),t=S0(),r=z1(),n=r&&r.isTypedArray,i=n?t(n):e;return ac=i,ac}var oc,Xd;function U1(){if(Xd)return oc;Xd=1;var e=L1(),t=Qf(),r=qe(),n=A0(),i=eh(),a=P0(),o=Object.prototype,u=o.hasOwnProperty;function c(s,f){var l=r(s),h=!l&&t(s),d=!l&&!h&&n(s),y=!l&&!h&&!d&&a(s),v=l||h||d||y,p=v?e(s.length,String):[],g=p.length;for(var x in s)(f||u.call(s,x))&&!(v&&(x=="length"||d&&(x=="offset"||x=="parent")||y&&(x=="buffer"||x=="byteLength"||x=="byteOffset")||i(x,g)))&&p.push(x);return p}return oc=c,oc}var uc,Yd;function H1(){if(Yd)return uc;Yd=1;var e=Object.prototype;function t(r){var n=r&&r.constructor,i=typeof n=="function"&&n.prototype||e;return r===i}return uc=t,uc}var cc,Zd;function T0(){if(Zd)return cc;Zd=1;function e(t,r){return function(n){return t(r(n))}}return cc=e,cc}var sc,Jd;function K1(){if(Jd)return sc;Jd=1;var e=T0(),t=e(Object.keys,Object);return sc=t,sc}var lc,Qd;function G1(){if(Qd)return lc;Qd=1;var e=H1(),t=K1(),r=Object.prototype,n=r.hasOwnProperty;function i(a){if(!e(a))return t(a);var o=[];for(var u in Object(a))n.call(a,u)&&u!="constructor"&&o.push(u);return o}return lc=i,lc}var fc,ev;function ui(){if(ev)return fc;ev=1;var e=Lf(),t=th();function r(n){return n!=null&&t(n.length)&&!e(n)}return fc=r,fc}var hc,tv;function Na(){if(tv)return hc;tv=1;var e=U1(),t=G1(),r=ui();function n(i){return r(i)?e(i):t(i)}return hc=n,hc}var pc,rv;function V1(){if(rv)return pc;rv=1;var e=R1(),t=q1(),r=Na();function n(i){return e(i,r,t)}return pc=n,pc}var dc,nv;function X1(){if(nv)return dc;nv=1;var e=V1(),t=1,r=Object.prototype,n=r.hasOwnProperty;function i(a,o,u,c,s,f){var l=u&t,h=e(a),d=h.length,y=e(o),v=y.length;if(d!=v&&!l)return!1;for(var p=d;p--;){var g=h[p];if(!(l?g in o:n.call(o,g)))return!1}var x=f.get(a),w=f.get(o);if(x&&w)return x==o&&w==a;var O=!0;f.set(a,o),f.set(o,a);for(var m=l;++p-1}return Bc=t,Bc}var Fc,Mv;function vA(){if(Mv)return Fc;Mv=1;function e(t,r,n){for(var i=-1,a=t==null?0:t.length;++i=o){var g=s?null:i(c);if(g)return a(g);y=!1,h=n,p=new e}else p=s?[]:v;e:for(;++l=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function MA(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function $A(e){return e.value}function CA(e,t){if(S.isValidElement(e))return S.cloneElement(e,t);if(typeof e=="function")return S.createElement(e,t);t.ref;var r=jA(t,wA);return S.createElement(Zf,r)}var qv=1,wr=(function(e){function t(){var r;OA(this,t);for(var n=arguments.length,i=new Array(n),a=0;aqv||Math.abs(i.height-this.lastBoundingBox.height)>qv)&&(this.lastBoundingBox.width=i.width,this.lastBoundingBox.height=i.height,n&&n(i)):(this.lastBoundingBox.width!==-1||this.lastBoundingBox.height!==-1)&&(this.lastBoundingBox.width=-1,this.lastBoundingBox.height=-1,n&&n(null))}},{key:"getBBoxSnapshot",value:function(){return this.lastBoundingBox.width>=0&&this.lastBoundingBox.height>=0?pt({},this.lastBoundingBox):{width:0,height:0}}},{key:"getDefaultPosition",value:function(n){var i=this.props,a=i.layout,o=i.align,u=i.verticalAlign,c=i.margin,s=i.chartWidth,f=i.chartHeight,l,h;if(!n||(n.left===void 0||n.left===null)&&(n.right===void 0||n.right===null))if(o==="center"&&a==="vertical"){var d=this.getBBoxSnapshot();l={left:((s||0)-d.width)/2}}else l=o==="right"?{right:c&&c.right||0}:{left:c&&c.left||0};if(!n||(n.top===void 0||n.top===null)&&(n.bottom===void 0||n.bottom===null))if(u==="middle"){var y=this.getBBoxSnapshot();h={top:((f||0)-y.height)/2}}else h=u==="bottom"?{bottom:c&&c.bottom||0}:{top:c&&c.top||0};return pt(pt({},l),h)}},{key:"render",value:function(){var n=this,i=this.props,a=i.content,o=i.width,u=i.height,c=i.wrapperStyle,s=i.payloadUniqBy,f=i.payload,l=pt(pt({position:"absolute",width:o||"auto",height:u||"auto"},this.getDefaultPosition(c)),c);return S.createElement("div",{className:"recharts-legend-wrapper",style:l,ref:function(d){n.wrapperNode=d}},CA(a,pt(pt({},this.props),{},{payload:C0(f,s,$A)})))}}],[{key:"getWithHeight",value:function(n,i){var a=pt(pt({},this.defaultProps),n.props),o=a.layout;return o==="vertical"&&q(n.props.height)?{height:n.props.height}:o==="horizontal"?{width:n.props.width||i}:null}}])})(N.PureComponent);qa(wr,"displayName","Legend");qa(wr,"defaultProps",{iconSize:14,layout:"horizontal",align:"center",verticalAlign:"bottom"});var Kc,Lv;function IA(){if(Lv)return Kc;Lv=1;var e=ai(),t=Qf(),r=qe(),n=e?e.isConcatSpreadable:void 0;function i(a){return r(a)||t(a)||!!(n&&a&&a[n])}return Kc=i,Kc}var Gc,Bv;function R0(){if(Bv)return Gc;Bv=1;var e=_0(),t=IA();function r(n,i,a,o,u){var c=-1,s=n.length;for(a||(a=t),u||(u=[]);++c0&&a(f)?i>1?r(f,i-1,a,o,u):e(u,f):o||(u[u.length]=f)}return u}return Gc=r,Gc}var Vc,Fv;function kA(){if(Fv)return Vc;Fv=1;function e(t){return function(r,n,i){for(var a=-1,o=Object(r),u=i(r),c=u.length;c--;){var s=u[t?c:++a];if(n(o[s],s,o)===!1)break}return r}}return Vc=e,Vc}var Xc,Wv;function RA(){if(Wv)return Xc;Wv=1;var e=kA(),t=e();return Xc=t,Xc}var Yc,zv;function D0(){if(zv)return Yc;zv=1;var e=RA(),t=Na();function r(n,i){return n&&e(n,i,t)}return Yc=r,Yc}var Zc,Uv;function DA(){if(Uv)return Zc;Uv=1;var e=ui();function t(r,n){return function(i,a){if(i==null)return i;if(!e(i))return r(i,a);for(var o=i.length,u=n?o:-1,c=Object(i);(n?u--:++un||u&&c&&f&&!s&&!l||a&&c&&f||!i&&f||!o)return 1;if(!a&&!u&&!l&&r=s)return f;var l=i[a];return f*(l=="desc"?-1:1)}}return r.index-n.index}return rs=t,rs}var ns,Yv;function BA(){if(Yv)return ns;Yv=1;var e=zf(),t=Uf(),r=ht(),n=N0(),i=NA(),a=S0(),o=LA(),u=Jr(),c=qe();function s(f,l,h){l.length?l=e(l,function(v){return c(v)?function(p){return t(p,v.length===1?v[0]:v)}:v}):l=[u];var d=-1;l=e(l,a(r));var y=n(f,function(v,p,g){var x=e(l,function(w){return w(v)});return{criteria:x,index:++d,value:v}});return i(y,function(v,p){return o(v,p,h)})}return ns=s,ns}var is,Zv;function FA(){if(Zv)return is;Zv=1;function e(t,r,n){switch(n.length){case 0:return t.call(r);case 1:return t.call(r,n[0]);case 2:return t.call(r,n[0],n[1]);case 3:return t.call(r,n[0],n[1],n[2])}return t.apply(r,n)}return is=e,is}var as,Jv;function WA(){if(Jv)return as;Jv=1;var e=FA(),t=Math.max;function r(n,i,a){return i=t(i===void 0?n.length-1:i,0),function(){for(var o=arguments,u=-1,c=t(o.length-i,0),s=Array(c);++u0){if(++a>=e)return arguments[0]}else a=0;return i.apply(void 0,arguments)}}return ss=n,ss}var ls,ny;function KA(){if(ny)return ls;ny=1;var e=UA(),t=HA(),r=t(e);return ls=r,ls}var fs,iy;function GA(){if(iy)return fs;iy=1;var e=Jr(),t=WA(),r=KA();function n(i,a){return r(t(i,a,e),i+"")}return fs=n,fs}var hs,ay;function La(){if(ay)return hs;ay=1;var e=Bf(),t=ui(),r=eh(),n=It();function i(a,o,u){if(!n(u))return!1;var c=typeof o;return(c=="number"?t(u)&&r(o,u.length):c=="string"&&o in u)?e(u[o],a):!1}return hs=i,hs}var ps,oy;function VA(){if(oy)return ps;oy=1;var e=R0(),t=BA(),r=GA(),n=La(),i=r(function(a,o){if(a==null)return[];var u=o.length;return u>1&&n(a,o[0],o[1])?o=[]:u>2&&n(o[0],o[1],o[2])&&(o=[o[0]]),t(a,e(o,1),[])});return ps=i,ps}var XA=VA();const ih=oe(XA);function Pn(e){"@babel/helpers - typeof";return Pn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Pn(e)}function Ml(){return Ml=Object.assign?Object.assign.bind():function(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,n=new Array(t);r=t.x),"".concat(an,"-left"),q(r)&&t&&q(t.x)&&r=t.y),"".concat(an,"-top"),q(n)&&t&&q(t.y)&&nv?Math.max(f,c[n]):Math.max(l,c[n])}function lS(e){var t=e.translateX,r=e.translateY,n=e.useTranslate3d;return{transform:n?"translate3d(".concat(t,"px, ").concat(r,"px, 0)"):"translate(".concat(t,"px, ").concat(r,"px)")}}function fS(e){var t=e.allowEscapeViewBox,r=e.coordinate,n=e.offsetTopLeft,i=e.position,a=e.reverseDirection,o=e.tooltipBox,u=e.useTranslate3d,c=e.viewBox,s,f,l;return o.height>0&&o.width>0&&r?(f=sy({allowEscapeViewBox:t,coordinate:r,key:"x",offsetTopLeft:n,position:i,reverseDirection:a,tooltipDimension:o.width,viewBox:c,viewBoxDimension:c.width}),l=sy({allowEscapeViewBox:t,coordinate:r,key:"y",offsetTopLeft:n,position:i,reverseDirection:a,tooltipDimension:o.height,viewBox:c,viewBoxDimension:c.height}),s=lS({translateX:f,translateY:l,useTranslate3d:u})):s=cS,{cssProperties:s,cssClasses:sS({translateX:f,translateY:l,coordinate:r})}}function Tr(e){"@babel/helpers - typeof";return Tr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Tr(e)}function ly(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function fy(e){for(var t=1;thy||Math.abs(n.height-this.state.lastBoundingBox.height)>hy)&&this.setState({lastBoundingBox:{width:n.width,height:n.height}})}else(this.state.lastBoundingBox.width!==-1||this.state.lastBoundingBox.height!==-1)&&this.setState({lastBoundingBox:{width:-1,height:-1}})}},{key:"componentDidMount",value:function(){document.addEventListener("keydown",this.handleKeyDown),this.updateBBox()}},{key:"componentWillUnmount",value:function(){document.removeEventListener("keydown",this.handleKeyDown)}},{key:"componentDidUpdate",value:function(){var n,i;this.props.active&&this.updateBBox(),this.state.dismissed&&(((n=this.props.coordinate)===null||n===void 0?void 0:n.x)!==this.state.dismissedAtCoordinate.x||((i=this.props.coordinate)===null||i===void 0?void 0:i.y)!==this.state.dismissedAtCoordinate.y)&&(this.state.dismissed=!1)}},{key:"render",value:function(){var n=this,i=this.props,a=i.active,o=i.allowEscapeViewBox,u=i.animationDuration,c=i.animationEasing,s=i.children,f=i.coordinate,l=i.hasPayload,h=i.isAnimationActive,d=i.offset,y=i.position,v=i.reverseDirection,p=i.useTranslate3d,g=i.viewBox,x=i.wrapperStyle,w=fS({allowEscapeViewBox:o,coordinate:f,offsetTopLeft:d,position:y,reverseDirection:v,tooltipBox:this.state.lastBoundingBox,useTranslate3d:p,viewBox:g}),O=w.cssClasses,m=w.cssProperties,b=fy(fy({transition:h&&a?"transform ".concat(u,"ms ").concat(c):void 0},m),{},{pointerEvents:"none",visibility:!this.state.dismissed&&a&&l?"visible":"hidden",position:"absolute",top:0,left:0},x);return S.createElement("div",{tabIndex:-1,className:O,style:b,ref:function(A){n.wrapperNode=A}},s)}}])})(N.PureComponent),wS=function(){return!(typeof window<"u"&&window.document&&window.document.createElement&&window.setTimeout)},or={isSsr:wS()};function Er(e){"@babel/helpers - typeof";return Er=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Er(e)}function py(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function dy(e){for(var t=1;t0;return S.createElement(xS,{allowEscapeViewBox:o,animationDuration:u,animationEasing:c,isAnimationActive:h,active:a,coordinate:f,hasPayload:b,offset:d,position:p,reverseDirection:g,useTranslate3d:x,viewBox:w,wrapperStyle:O},$S(s,dy(dy({},this.props),{},{payload:m})))}}])})(N.PureComponent);ah(dt,"displayName","Tooltip");ah(dt,"defaultProps",{accessibilityLayer:!1,allowEscapeViewBox:{x:!1,y:!1},animationDuration:400,animationEasing:"ease",contentStyle:{},coordinate:{x:0,y:0},cursor:!0,cursorStyle:{},filterNull:!0,isAnimationActive:!or.isSsr,itemStyle:{},labelStyle:{},offset:10,reverseDirection:{x:!1,y:!1},separator:" : ",trigger:"hover",useTranslate3d:!1,viewBox:{x:0,y:0,height:0,width:0},wrapperStyle:{}});var vs,vy;function CS(){if(vy)return vs;vy=1;var e=ft(),t=function(){return e.Date.now()};return vs=t,vs}var ys,yy;function IS(){if(yy)return ys;yy=1;var e=/\s/;function t(r){for(var n=r.length;n--&&e.test(r.charAt(n)););return n}return ys=t,ys}var ms,my;function kS(){if(my)return ms;my=1;var e=IS(),t=/^\s+/;function r(n){return n&&n.slice(0,e(n)+1).replace(t,"")}return ms=r,ms}var gs,gy;function z0(){if(gy)return gs;gy=1;var e=kS(),t=It(),r=Xr(),n=NaN,i=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,o=/^0o[0-7]+$/i,u=parseInt;function c(s){if(typeof s=="number")return s;if(r(s))return n;if(t(s)){var f=typeof s.valueOf=="function"?s.valueOf():s;s=t(f)?f+"":f}if(typeof s!="string")return s===0?s:+s;s=e(s);var l=a.test(s);return l||o.test(s)?u(s.slice(2),l?2:8):i.test(s)?n:+s}return gs=c,gs}var bs,by;function RS(){if(by)return bs;by=1;var e=It(),t=CS(),r=z0(),n="Expected a function",i=Math.max,a=Math.min;function o(u,c,s){var f,l,h,d,y,v,p=0,g=!1,x=!1,w=!0;if(typeof u!="function")throw new TypeError(n);c=r(c)||0,e(s)&&(g=!!s.leading,x="maxWait"in s,h=x?i(r(s.maxWait)||0,c):h,w="trailing"in s?!!s.trailing:w);function O(j){var C=f,$=l;return f=l=void 0,p=j,d=u.apply($,C),d}function m(j){return p=j,y=setTimeout(A,c),g?O(j):d}function b(j){var C=j-v,$=j-p,k=c-C;return x?a(k,h-$):k}function _(j){var C=j-v,$=j-p;return v===void 0||C>=c||C<0||x&&$>=h}function A(){var j=t();if(_(j))return T(j);y=setTimeout(A,b(j))}function T(j){return y=void 0,w&&f?O(j):(f=l=void 0,d)}function M(){y!==void 0&&clearTimeout(y),p=0,f=v=l=y=void 0}function P(){return y===void 0?d:T(t())}function E(){var j=t(),C=_(j);if(f=arguments,l=this,v=j,C){if(y===void 0)return m(v);if(x)return clearTimeout(y),y=setTimeout(A,c),O(v)}return y===void 0&&(y=setTimeout(A,c)),d}return E.cancel=M,E.flush=P,E}return bs=o,bs}var xs,xy;function DS(){if(xy)return xs;xy=1;var e=RS(),t=It(),r="Expected a function";function n(i,a,o){var u=!0,c=!0;if(typeof i!="function")throw new TypeError(r);return t(o)&&(u="leading"in o?!!o.leading:u,c="trailing"in o?!!o.trailing:c),e(i,a,{leading:u,maxWait:a,trailing:c})}return xs=n,xs}var NS=DS();const U0=oe(NS);function En(e){"@babel/helpers - typeof";return En=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},En(e)}function wy(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function gi(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,n=new Array(t);r0&&(j=U0(j,v,{trailing:!0,leading:!1}));var C=new ResizeObserver(j),$=m.current.getBoundingClientRect(),k=$.width,R=$.height;return P(k,R),C.observe(m.current),function(){C.disconnect()}},[P,v]);var E=N.useMemo(function(){var j=T.containerWidth,C=T.containerHeight;if(j<0||C<0)return null;it(Gt(o)||Gt(c),`The width(%s) and height(%s) are both fixed numbers,
- maybe you don't need to use a ResponsiveContainer.`,o,c),it(!r||r>0,"The aspect(%s) must be greater than zero.",r);var $=Gt(o)?j:o,k=Gt(c)?C:c;r&&r>0&&($?k=$/r:k&&($=k*r),h&&k>h&&(k=h)),it($>0||k>0,`The width(%s) and height(%s) of chart should be greater than 0,
- please check the style of container, or the props width(%s) and height(%s),
- or add a minWidth(%s) or minHeight(%s) or use aspect(%s) to control the
- height and width.`,$,k,o,c,f,l,r);var R=!Array.isArray(d)&&bt(d.type).endsWith("Chart");return S.Children.map(d,function(L){return S.isValidElement(L)?N.cloneElement(L,gi({width:$,height:k},R?{style:gi({height:"100%",width:"100%",maxHeight:k,maxWidth:$},L.props.style)}:{})):L})},[r,d,c,h,l,f,T,o]);return S.createElement("div",{id:p?"".concat(p):void 0,className:J("recharts-responsive-container",g),style:gi(gi({},O),{},{width:o,height:c,minWidth:f,minHeight:l,maxHeight:h}),ref:m},E)}),oh=function(t){return null};oh.displayName="Cell";function jn(e){"@babel/helpers - typeof";return jn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},jn(e)}function _y(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function kl(e){for(var t=1;t1&&arguments[1]!==void 0?arguments[1]:{};if(t==null||or.isSsr)return{width:0,height:0};var n=ZS(r),i=JSON.stringify({text:t,copyStyle:n});if(fr.widthCache[i])return fr.widthCache[i];try{var a=document.getElementById(Ay);a||(a=document.createElement("span"),a.setAttribute("id",Ay),a.setAttribute("aria-hidden","true"),document.body.appendChild(a));var o=kl(kl({},YS),n);Object.assign(a.style,o),a.textContent="".concat(t);var u=a.getBoundingClientRect(),c={width:u.width,height:u.height};return fr.widthCache[i]=c,++fr.cacheCount>XS&&(fr.cacheCount=0,fr.widthCache={}),c}catch{return{width:0,height:0}}},JS=function(t){return{top:t.top+window.scrollY-document.documentElement.clientTop,left:t.left+window.scrollX-document.documentElement.clientLeft}};function Mn(e){"@babel/helpers - typeof";return Mn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Mn(e)}function Fi(e,t){return rP(e)||tP(e,t)||eP(e,t)||QS()}function QS(){throw new TypeError(`Invalid attempt to destructure non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function eP(e,t){if(e){if(typeof e=="string")return Sy(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return Sy(e,t)}}function Sy(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function yP(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function $y(e,t){return xP(e)||bP(e,t)||gP(e,t)||mP()}function mP(){throw new TypeError(`Invalid attempt to destructure non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function gP(e,t){if(e){if(typeof e=="string")return Cy(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return Cy(e,t)}}function Cy(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r0&&arguments[0]!==void 0?arguments[0]:[];return $.reduce(function(k,R){var L=R.word,B=R.width,U=k[k.length-1];if(U&&(i==null||a||U.width+B+nR.width?k:R})};if(!f)return d;for(var v="…",p=function($){var k=l.slice(0,$),R=V0({breakAll:s,style:c,children:k+v}).wordsWithComputedWidth,L=h(R),B=L.length>o||y(L).width>Number(i);return[B,L]},g=0,x=l.length-1,w=0,O;g<=x&&w<=l.length-1;){var m=Math.floor((g+x)/2),b=m-1,_=p(b),A=$y(_,2),T=A[0],M=A[1],P=p(m),E=$y(P,1),j=E[0];if(!T&&!j&&(g=m+1),T&&j&&(x=m-1),!T&&j){O=M;break}w++}return O||d},Iy=function(t){var r=Y(t)?[]:t.toString().split(G0);return[{words:r}]},OP=function(t){var r=t.width,n=t.scaleToFit,i=t.children,a=t.style,o=t.breakAll,u=t.maxLines;if((r||n)&&!or.isSsr){var c,s,f=V0({breakAll:o,children:i,style:a});if(f){var l=f.wordsWithComputedWidth,h=f.spaceWidth;c=l,s=h}else return Iy(i);return wP({breakAll:o,children:i,maxLines:u,style:a},c,s,r,n)}return Iy(i)},ky="#808080",rr=function(t){var r=t.x,n=r===void 0?0:r,i=t.y,a=i===void 0?0:i,o=t.lineHeight,u=o===void 0?"1em":o,c=t.capHeight,s=c===void 0?"0.71em":c,f=t.scaleToFit,l=f===void 0?!1:f,h=t.textAnchor,d=h===void 0?"start":h,y=t.verticalAnchor,v=y===void 0?"end":y,p=t.fill,g=p===void 0?ky:p,x=My(t,dP),w=N.useMemo(function(){return OP({breakAll:x.breakAll,children:x.children,maxLines:x.maxLines,scaleToFit:l,style:x.style,width:x.width})},[x.breakAll,x.children,x.maxLines,l,x.style,x.width]),O=x.dx,m=x.dy,b=x.angle,_=x.className,A=x.breakAll,T=My(x,vP);if(!Ae(n)||!Ae(a))return null;var M=n+(q(O)?O:0),P=a+(q(m)?m:0),E;switch(v){case"start":E=ws("calc(".concat(s,")"));break;case"middle":E=ws("calc(".concat((w.length-1)/2," * -").concat(u," + (").concat(s," / 2))"));break;default:E=ws("calc(".concat(w.length-1," * -").concat(u,")"));break}var j=[];if(l){var C=w[0].width,$=x.width;j.push("scale(".concat((q($)?$/C:1)/C,")"))}return b&&j.push("rotate(".concat(b,", ").concat(M,", ").concat(P,")")),j.length&&(T.transform=j.join(" ")),S.createElement("text",Rl({},H(T,!0),{x:M,y:P,className:J("recharts-text",_),textAnchor:d,fill:g.includes("url")?ky:g}),w.map(function(k,R){var L=k.words.join(A?"":" ");return S.createElement("tspan",{x:M,dy:R===0?E:u,key:"".concat(L,"-").concat(R)},L)}))};function Ct(e,t){return e==null||t==null?NaN:et?1:e>=t?0:NaN}function _P(e,t){return e==null||t==null?NaN:te?1:t>=e?0:NaN}function uh(e){let t,r,n;e.length!==2?(t=Ct,r=(u,c)=>Ct(e(u),c),n=(u,c)=>e(u)-c):(t=e===Ct||e===_P?e:AP,r=e,n=e);function i(u,c,s=0,f=u.length){if(s>>1;r(u[l],c)<0?s=l+1:f=l}while(s>>1;r(u[l],c)<=0?s=l+1:f=l}while(ss&&n(u[l-1],c)>-n(u[l],c)?l-1:l}return{left:i,center:o,right:a}}function AP(){return 0}function X0(e){return e===null?NaN:+e}function*SP(e,t){for(let r of e)r!=null&&(r=+r)>=r&&(yield r)}const PP=uh(Ct),ci=PP.right;uh(X0).center;class Ry extends Map{constructor(t,r=jP){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:r}}),t!=null)for(const[n,i]of t)this.set(n,i)}get(t){return super.get(Dy(this,t))}has(t){return super.has(Dy(this,t))}set(t,r){return super.set(TP(this,t),r)}delete(t){return super.delete(EP(this,t))}}function Dy({_intern:e,_key:t},r){const n=t(r);return e.has(n)?e.get(n):r}function TP({_intern:e,_key:t},r){const n=t(r);return e.has(n)?e.get(n):(e.set(n,r),r)}function EP({_intern:e,_key:t},r){const n=t(r);return e.has(n)&&(r=e.get(n),e.delete(n)),r}function jP(e){return e!==null&&typeof e=="object"?e.valueOf():e}function MP(e=Ct){if(e===Ct)return Y0;if(typeof e!="function")throw new TypeError("compare is not a function");return(t,r)=>{const n=e(t,r);return n||n===0?n:(e(r,r)===0)-(e(t,t)===0)}}function Y0(e,t){return(e==null||!(e>=e))-(t==null||!(t>=t))||(et?1:0)}const $P=Math.sqrt(50),CP=Math.sqrt(10),IP=Math.sqrt(2);function Wi(e,t,r){const n=(t-e)/Math.max(0,r),i=Math.floor(Math.log10(n)),a=n/Math.pow(10,i),o=a>=$P?10:a>=CP?5:a>=IP?2:1;let u,c,s;return i<0?(s=Math.pow(10,-i)/o,u=Math.round(e*s),c=Math.round(t*s),u/st&&--c,s=-s):(s=Math.pow(10,i)*o,u=Math.round(e/s),c=Math.round(t/s),u*st&&--c),c0))return[];if(e===t)return[e];const n=t=i))return[];const u=a-i+1,c=new Array(u);if(n)if(o<0)for(let s=0;s=n)&&(r=n);return r}function qy(e,t){let r;for(const n of e)n!=null&&(r>n||r===void 0&&n>=n)&&(r=n);return r}function Z0(e,t,r=0,n=1/0,i){if(t=Math.floor(t),r=Math.floor(Math.max(0,r)),n=Math.floor(Math.min(e.length-1,n)),!(r<=t&&t<=n))return e;for(i=i===void 0?Y0:MP(i);n>r;){if(n-r>600){const c=n-r+1,s=t-r+1,f=Math.log(c),l=.5*Math.exp(2*f/3),h=.5*Math.sqrt(f*l*(c-l)/c)*(s-c/2<0?-1:1),d=Math.max(r,Math.floor(t-s*l/c+h)),y=Math.min(n,Math.floor(t+(c-s)*l/c+h));Z0(e,t,d,y,i)}const a=e[t];let o=r,u=n;for(on(e,r,t),i(e[n],a)>0&&on(e,r,n);o0;)--u}i(e[r],a)===0?on(e,r,u):(++u,on(e,u,n)),u<=t&&(r=u+1),t<=u&&(n=u-1)}return e}function on(e,t,r){const n=e[t];e[t]=e[r],e[r]=n}function kP(e,t,r){if(e=Float64Array.from(SP(e)),!(!(n=e.length)||isNaN(t=+t))){if(t<=0||n<2)return qy(e);if(t>=1)return Ny(e);var n,i=(n-1)*t,a=Math.floor(i),o=Ny(Z0(e,a).subarray(0,a+1)),u=qy(e.subarray(a+1));return o+(u-o)*(i-a)}}function RP(e,t,r=X0){if(!(!(n=e.length)||isNaN(t=+t))){if(t<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,a=Math.floor(i),o=+r(e[a],a,e),u=+r(e[a+1],a+1,e);return o+(u-o)*(i-a)}}function DP(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,a=new Array(i);++n>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?xi(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?xi(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=qP.exec(e))?new Ne(t[1],t[2],t[3],1):(t=LP.exec(e))?new Ne(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=BP.exec(e))?xi(t[1],t[2],t[3],t[4]):(t=FP.exec(e))?xi(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=WP.exec(e))?Hy(t[1],t[2]/100,t[3]/100,1):(t=zP.exec(e))?Hy(t[1],t[2]/100,t[3]/100,t[4]):Ly.hasOwnProperty(e)?Wy(Ly[e]):e==="transparent"?new Ne(NaN,NaN,NaN,0):null}function Wy(e){return new Ne(e>>16&255,e>>8&255,e&255,1)}function xi(e,t,r,n){return n<=0&&(e=t=r=NaN),new Ne(e,t,r,n)}function KP(e){return e instanceof si||(e=kn(e)),e?(e=e.rgb(),new Ne(e.r,e.g,e.b,e.opacity)):new Ne}function Bl(e,t,r,n){return arguments.length===1?KP(e):new Ne(e,t,r,n??1)}function Ne(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}sh(Ne,Bl,Q0(si,{brighter(e){return e=e==null?zi:Math.pow(zi,e),new Ne(this.r*e,this.g*e,this.b*e,this.opacity)},darker(e){return e=e==null?Cn:Math.pow(Cn,e),new Ne(this.r*e,this.g*e,this.b*e,this.opacity)},rgb(){return this},clamp(){return new Ne(Zt(this.r),Zt(this.g),Zt(this.b),Ui(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:zy,formatHex:zy,formatHex8:GP,formatRgb:Uy,toString:Uy}));function zy(){return`#${Vt(this.r)}${Vt(this.g)}${Vt(this.b)}`}function GP(){return`#${Vt(this.r)}${Vt(this.g)}${Vt(this.b)}${Vt((isNaN(this.opacity)?1:this.opacity)*255)}`}function Uy(){const e=Ui(this.opacity);return`${e===1?"rgb(":"rgba("}${Zt(this.r)}, ${Zt(this.g)}, ${Zt(this.b)}${e===1?")":`, ${e})`}`}function Ui(e){return isNaN(e)?1:Math.max(0,Math.min(1,e))}function Zt(e){return Math.max(0,Math.min(255,Math.round(e)||0))}function Vt(e){return e=Zt(e),(e<16?"0":"")+e.toString(16)}function Hy(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new nt(e,t,r,n)}function ex(e){if(e instanceof nt)return new nt(e.h,e.s,e.l,e.opacity);if(e instanceof si||(e=kn(e)),!e)return new nt;if(e instanceof nt)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),a=Math.max(t,r,n),o=NaN,u=a-i,c=(a+i)/2;return u?(t===a?o=(r-n)/u+(r0&&c<1?0:o,new nt(o,u,c,e.opacity)}function VP(e,t,r,n){return arguments.length===1?ex(e):new nt(e,t,r,n??1)}function nt(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}sh(nt,VP,Q0(si,{brighter(e){return e=e==null?zi:Math.pow(zi,e),new nt(this.h,this.s,this.l*e,this.opacity)},darker(e){return e=e==null?Cn:Math.pow(Cn,e),new nt(this.h,this.s,this.l*e,this.opacity)},rgb(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new Ne(Os(e>=240?e-240:e+120,i,n),Os(e,i,n),Os(e<120?e+240:e-120,i,n),this.opacity)},clamp(){return new nt(Ky(this.h),wi(this.s),wi(this.l),Ui(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const e=Ui(this.opacity);return`${e===1?"hsl(":"hsla("}${Ky(this.h)}, ${wi(this.s)*100}%, ${wi(this.l)*100}%${e===1?")":`, ${e})`}`}}));function Ky(e){return e=(e||0)%360,e<0?e+360:e}function wi(e){return Math.max(0,Math.min(1,e||0))}function Os(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}const lh=e=>()=>e;function XP(e,t){return function(r){return e+r*t}}function YP(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function ZP(e){return(e=+e)==1?tx:function(t,r){return r-t?YP(t,r,e):lh(isNaN(t)?r:t)}}function tx(e,t){var r=t-e;return r?XP(e,r):lh(isNaN(e)?t:e)}const Gy=(function e(t){var r=ZP(t);function n(i,a){var o=r((i=Bl(i)).r,(a=Bl(a)).r),u=r(i.g,a.g),c=r(i.b,a.b),s=tx(i.opacity,a.opacity);return function(f){return i.r=o(f),i.g=u(f),i.b=c(f),i.opacity=s(f),i+""}}return n.gamma=e,n})(1);function JP(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(a){for(i=0;ir&&(a=t.slice(r,a),u[o]?u[o]+=a:u[++o]=a),(n=n[0])===(i=i[0])?u[o]?u[o]+=i:u[++o]=i:(u[++o]=null,c.push({i:o,x:Hi(n,i)})),r=_s.lastIndex;return rt&&(r=e,e=t,t=r),function(n){return Math.max(e,Math.min(t,n))}}function sT(e,t,r){var n=e[0],i=e[1],a=t[0],o=t[1];return i2?lT:sT,c=s=null,l}function l(h){return h==null||isNaN(h=+h)?a:(c||(c=u(e.map(n),t,r)))(n(o(h)))}return l.invert=function(h){return o(i((s||(s=u(t,e.map(n),Hi)))(h)))},l.domain=function(h){return arguments.length?(e=Array.from(h,Ki),f()):e.slice()},l.range=function(h){return arguments.length?(t=Array.from(h),f()):t.slice()},l.rangeRound=function(h){return t=Array.from(h),r=fh,f()},l.clamp=function(h){return arguments.length?(o=h?!0:ke,f()):o!==ke},l.interpolate=function(h){return arguments.length?(r=h,f()):r},l.unknown=function(h){return arguments.length?(a=h,l):a},function(h,d){return n=h,i=d,f()}}function hh(){return Ba()(ke,ke)}function fT(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function Gi(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}function jr(e){return e=Gi(Math.abs(e)),e?e[1]:NaN}function hT(e,t){return function(r,n){for(var i=r.length,a=[],o=0,u=e[0],c=0;i>0&&u>0&&(c+u+1>n&&(u=Math.max(1,n-c)),a.push(r.substring(i-=u,i+u)),!((c+=u+1)>n));)u=e[o=(o+1)%e.length];return a.reverse().join(t)}}function pT(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var dT=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Rn(e){if(!(t=dT.exec(e)))throw new Error("invalid format: "+e);var t;return new ph({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Rn.prototype=ph.prototype;function ph(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}ph.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function vT(e){e:for(var t=e.length,r=1,n=-1,i;r0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var rx;function yT(e,t){var r=Gi(e,t);if(!r)return e+"";var n=r[0],i=r[1],a=i-(rx=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,o=n.length;return a===o?n:a>o?n+new Array(a-o+1).join("0"):a>0?n.slice(0,a)+"."+n.slice(a):"0."+new Array(1-a).join("0")+Gi(e,Math.max(0,t+a-1))[0]}function Xy(e,t){var r=Gi(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}const Yy={"%":(e,t)=>(e*100).toFixed(t),b:e=>Math.round(e).toString(2),c:e=>e+"",d:fT,e:(e,t)=>e.toExponential(t),f:(e,t)=>e.toFixed(t),g:(e,t)=>e.toPrecision(t),o:e=>Math.round(e).toString(8),p:(e,t)=>Xy(e*100,t),r:Xy,s:yT,X:e=>Math.round(e).toString(16).toUpperCase(),x:e=>Math.round(e).toString(16)};function Zy(e){return e}var Jy=Array.prototype.map,Qy=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function mT(e){var t=e.grouping===void 0||e.thousands===void 0?Zy:hT(Jy.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",a=e.numerals===void 0?Zy:pT(Jy.call(e.numerals,String)),o=e.percent===void 0?"%":e.percent+"",u=e.minus===void 0?"−":e.minus+"",c=e.nan===void 0?"NaN":e.nan+"";function s(l){l=Rn(l);var h=l.fill,d=l.align,y=l.sign,v=l.symbol,p=l.zero,g=l.width,x=l.comma,w=l.precision,O=l.trim,m=l.type;m==="n"?(x=!0,m="g"):Yy[m]||(w===void 0&&(w=12),O=!0,m="g"),(p||h==="0"&&d==="=")&&(p=!0,h="0",d="=");var b=v==="$"?r:v==="#"&&/[boxX]/.test(m)?"0"+m.toLowerCase():"",_=v==="$"?n:/[%p]/.test(m)?o:"",A=Yy[m],T=/[defgprs%]/.test(m);w=w===void 0?6:/[gprs]/.test(m)?Math.max(1,Math.min(21,w)):Math.max(0,Math.min(20,w));function M(P){var E=b,j=_,C,$,k;if(m==="c")j=A(P)+j,P="";else{P=+P;var R=P<0||1/P<0;if(P=isNaN(P)?c:A(Math.abs(P),w),O&&(P=vT(P)),R&&+P==0&&y!=="+"&&(R=!1),E=(R?y==="("?y:u:y==="-"||y==="("?"":y)+E,j=(m==="s"?Qy[8+rx/3]:"")+j+(R&&y==="("?")":""),T){for(C=-1,$=P.length;++C<$;)if(k=P.charCodeAt(C),48>k||k>57){j=(k===46?i+P.slice(C+1):P.slice(C))+j,P=P.slice(0,C);break}}}x&&!p&&(P=t(P,1/0));var L=E.length+P.length+j.length,B=L>1)+E+P+j+B.slice(L);break;default:P=B+E+P+j;break}return a(P)}return M.toString=function(){return l+""},M}function f(l,h){var d=s((l=Rn(l),l.type="f",l)),y=Math.max(-8,Math.min(8,Math.floor(jr(h)/3)))*3,v=Math.pow(10,-y),p=Qy[8+y/3];return function(g){return d(v*g)+p}}return{format:s,formatPrefix:f}}var Oi,dh,nx;gT({thousands:",",grouping:[3],currency:["$",""]});function gT(e){return Oi=mT(e),dh=Oi.format,nx=Oi.formatPrefix,Oi}function bT(e){return Math.max(0,-jr(Math.abs(e)))}function xT(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(jr(t)/3)))*3-jr(Math.abs(e)))}function wT(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,jr(t)-jr(e))+1}function ix(e,t,r,n){var i=ql(e,t,r),a;switch(n=Rn(n??",f"),n.type){case"s":{var o=Math.max(Math.abs(e),Math.abs(t));return n.precision==null&&!isNaN(a=xT(i,o))&&(n.precision=a),nx(n,o)}case"":case"e":case"g":case"p":case"r":{n.precision==null&&!isNaN(a=wT(i,Math.max(Math.abs(e),Math.abs(t))))&&(n.precision=a-(n.type==="e"));break}case"f":case"%":{n.precision==null&&!isNaN(a=bT(i))&&(n.precision=a-(n.type==="%")*2);break}}return dh(n)}function kt(e){var t=e.domain;return e.ticks=function(r){var n=t();return Dl(n[0],n[n.length-1],r??10)},e.tickFormat=function(r,n){var i=t();return ix(i[0],i[i.length-1],r??10,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,a=n.length-1,o=n[i],u=n[a],c,s,f=10;for(u0;){if(s=Nl(o,u,r),s===c)return n[i]=o,n[a]=u,t(n);if(s>0)o=Math.floor(o/s)*s,u=Math.ceil(u/s)*s;else if(s<0)o=Math.ceil(o*s)/s,u=Math.floor(u*s)/s;else break;c=s}return e},e}function Vi(){var e=hh();return e.copy=function(){return li(e,Vi())},Qe.apply(e,arguments),kt(e)}function ax(e){var t;function r(n){return n==null||isNaN(n=+n)?t:n}return r.invert=r,r.domain=r.range=function(n){return arguments.length?(e=Array.from(n,Ki),r):e.slice()},r.unknown=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return ax(e).unknown(t)},e=arguments.length?Array.from(e,Ki):[0,1],kt(r)}function ox(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],a=e[n],o;return aMath.pow(e,t)}function PT(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),t=>Math.log(t)/e)}function rm(e){return(t,r)=>-e(-t,r)}function vh(e){const t=e(em,tm),r=t.domain;let n=10,i,a;function o(){return i=PT(n),a=ST(n),r()[0]<0?(i=rm(i),a=rm(a),e(OT,_T)):e(em,tm),t}return t.base=function(u){return arguments.length?(n=+u,o()):n},t.domain=function(u){return arguments.length?(r(u),o()):r()},t.ticks=u=>{const c=r();let s=c[0],f=c[c.length-1];const l=f0){for(;h<=d;++h)for(y=1;yf)break;g.push(v)}}else for(;h<=d;++h)for(y=n-1;y>=1;--y)if(v=h>0?y/a(-h):y*a(h),!(vf)break;g.push(v)}g.length*2{if(u==null&&(u=10),c==null&&(c=n===10?"s":","),typeof c!="function"&&(!(n%1)&&(c=Rn(c)).precision==null&&(c.trim=!0),c=dh(c)),u===1/0)return c;const s=Math.max(1,n*u/t.ticks().length);return f=>{let l=f/a(Math.round(i(f)));return l*nr(ox(r(),{floor:u=>a(Math.floor(i(u))),ceil:u=>a(Math.ceil(i(u)))})),t}function ux(){const e=vh(Ba()).domain([1,10]);return e.copy=()=>li(e,ux()).base(e.base()),Qe.apply(e,arguments),e}function nm(e){return function(t){return Math.sign(t)*Math.log1p(Math.abs(t/e))}}function im(e){return function(t){return Math.sign(t)*Math.expm1(Math.abs(t))*e}}function yh(e){var t=1,r=e(nm(t),im(t));return r.constant=function(n){return arguments.length?e(nm(t=+n),im(t)):t},kt(r)}function cx(){var e=yh(Ba());return e.copy=function(){return li(e,cx()).constant(e.constant())},Qe.apply(e,arguments)}function am(e){return function(t){return t<0?-Math.pow(-t,e):Math.pow(t,e)}}function TT(e){return e<0?-Math.sqrt(-e):Math.sqrt(e)}function ET(e){return e<0?-e*e:e*e}function mh(e){var t=e(ke,ke),r=1;function n(){return r===1?e(ke,ke):r===.5?e(TT,ET):e(am(r),am(1/r))}return t.exponent=function(i){return arguments.length?(r=+i,n()):r},kt(t)}function gh(){var e=mh(Ba());return e.copy=function(){return li(e,gh()).exponent(e.exponent())},Qe.apply(e,arguments),e}function jT(){return gh.apply(null,arguments).exponent(.5)}function om(e){return Math.sign(e)*e*e}function MT(e){return Math.sign(e)*Math.sqrt(Math.abs(e))}function sx(){var e=hh(),t=[0,1],r=!1,n;function i(a){var o=MT(e(a));return isNaN(o)?n:r?Math.round(o):o}return i.invert=function(a){return e.invert(om(a))},i.domain=function(a){return arguments.length?(e.domain(a),i):e.domain()},i.range=function(a){return arguments.length?(e.range((t=Array.from(a,Ki)).map(om)),i):t.slice()},i.rangeRound=function(a){return i.range(a).round(!0)},i.round=function(a){return arguments.length?(r=!!a,i):r},i.clamp=function(a){return arguments.length?(e.clamp(a),i):e.clamp()},i.unknown=function(a){return arguments.length?(n=a,i):n},i.copy=function(){return sx(e.domain(),t).round(r).clamp(e.clamp()).unknown(n)},Qe.apply(i,arguments),kt(i)}function lx(){var e=[],t=[],r=[],n;function i(){var o=0,u=Math.max(1,t.length);for(r=new Array(u-1);++o0?r[u-1]:e[0],u=r?[n[r-1],t]:[n[s-1],n[s]]},o.unknown=function(c){return arguments.length&&(a=c),o},o.thresholds=function(){return n.slice()},o.copy=function(){return fx().domain([e,t]).range(i).unknown(a)},Qe.apply(kt(o),arguments)}function hx(){var e=[.5],t=[0,1],r,n=1;function i(a){return a!=null&&a<=a?t[ci(e,a,0,n)]:r}return i.domain=function(a){return arguments.length?(e=Array.from(a),n=Math.min(e.length,t.length-1),i):e.slice()},i.range=function(a){return arguments.length?(t=Array.from(a),n=Math.min(e.length,t.length-1),i):t.slice()},i.invertExtent=function(a){var o=t.indexOf(a);return[e[o-1],e[o]]},i.unknown=function(a){return arguments.length?(r=a,i):r},i.copy=function(){return hx().domain(e).range(t).unknown(r)},Qe.apply(i,arguments)}const As=new Date,Ss=new Date;function Se(e,t,r,n){function i(a){return e(a=arguments.length===0?new Date:new Date(+a)),a}return i.floor=a=>(e(a=new Date(+a)),a),i.ceil=a=>(e(a=new Date(a-1)),t(a,1),e(a),a),i.round=a=>{const o=i(a),u=i.ceil(a);return a-o(t(a=new Date(+a),o==null?1:Math.floor(o)),a),i.range=(a,o,u)=>{const c=[];if(a=i.ceil(a),u=u==null?1:Math.floor(u),!(a0))return c;let s;do c.push(s=new Date(+a)),t(a,u),e(a);while(sSe(o=>{if(o>=o)for(;e(o),!a(o);)o.setTime(o-1)},(o,u)=>{if(o>=o)if(u<0)for(;++u<=0;)for(;t(o,-1),!a(o););else for(;--u>=0;)for(;t(o,1),!a(o););}),r&&(i.count=(a,o)=>(As.setTime(+a),Ss.setTime(+o),e(As),e(Ss),Math.floor(r(As,Ss))),i.every=a=>(a=Math.floor(a),!isFinite(a)||!(a>0)?null:a>1?i.filter(n?o=>n(o)%a===0:o=>i.count(0,o)%a===0):i)),i}const Xi=Se(()=>{},(e,t)=>{e.setTime(+e+t)},(e,t)=>t-e);Xi.every=e=>(e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Se(t=>{t.setTime(Math.floor(t/e)*e)},(t,r)=>{t.setTime(+t+r*e)},(t,r)=>(r-t)/e):Xi);Xi.range;const yt=1e3,Ze=yt*60,mt=Ze*60,Ot=mt*24,bh=Ot*7,um=Ot*30,Ps=Ot*365,Xt=Se(e=>{e.setTime(e-e.getMilliseconds())},(e,t)=>{e.setTime(+e+t*yt)},(e,t)=>(t-e)/yt,e=>e.getUTCSeconds());Xt.range;const xh=Se(e=>{e.setTime(e-e.getMilliseconds()-e.getSeconds()*yt)},(e,t)=>{e.setTime(+e+t*Ze)},(e,t)=>(t-e)/Ze,e=>e.getMinutes());xh.range;const wh=Se(e=>{e.setUTCSeconds(0,0)},(e,t)=>{e.setTime(+e+t*Ze)},(e,t)=>(t-e)/Ze,e=>e.getUTCMinutes());wh.range;const Oh=Se(e=>{e.setTime(e-e.getMilliseconds()-e.getSeconds()*yt-e.getMinutes()*Ze)},(e,t)=>{e.setTime(+e+t*mt)},(e,t)=>(t-e)/mt,e=>e.getHours());Oh.range;const _h=Se(e=>{e.setUTCMinutes(0,0,0)},(e,t)=>{e.setTime(+e+t*mt)},(e,t)=>(t-e)/mt,e=>e.getUTCHours());_h.range;const fi=Se(e=>e.setHours(0,0,0,0),(e,t)=>e.setDate(e.getDate()+t),(e,t)=>(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*Ze)/Ot,e=>e.getDate()-1);fi.range;const Fa=Se(e=>{e.setUTCHours(0,0,0,0)},(e,t)=>{e.setUTCDate(e.getUTCDate()+t)},(e,t)=>(t-e)/Ot,e=>e.getUTCDate()-1);Fa.range;const px=Se(e=>{e.setUTCHours(0,0,0,0)},(e,t)=>{e.setUTCDate(e.getUTCDate()+t)},(e,t)=>(t-e)/Ot,e=>Math.floor(e/Ot));px.range;function ur(e){return Se(t=>{t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},(t,r)=>{t.setDate(t.getDate()+r*7)},(t,r)=>(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*Ze)/bh)}const Wa=ur(0),Yi=ur(1),$T=ur(2),CT=ur(3),Mr=ur(4),IT=ur(5),kT=ur(6);Wa.range;Yi.range;$T.range;CT.range;Mr.range;IT.range;kT.range;function cr(e){return Se(t=>{t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},(t,r)=>{t.setUTCDate(t.getUTCDate()+r*7)},(t,r)=>(r-t)/bh)}const za=cr(0),Zi=cr(1),RT=cr(2),DT=cr(3),$r=cr(4),NT=cr(5),qT=cr(6);za.range;Zi.range;RT.range;DT.range;$r.range;NT.range;qT.range;const Ah=Se(e=>{e.setDate(1),e.setHours(0,0,0,0)},(e,t)=>{e.setMonth(e.getMonth()+t)},(e,t)=>t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12,e=>e.getMonth());Ah.range;const Sh=Se(e=>{e.setUTCDate(1),e.setUTCHours(0,0,0,0)},(e,t)=>{e.setUTCMonth(e.getUTCMonth()+t)},(e,t)=>t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12,e=>e.getUTCMonth());Sh.range;const _t=Se(e=>{e.setMonth(0,1),e.setHours(0,0,0,0)},(e,t)=>{e.setFullYear(e.getFullYear()+t)},(e,t)=>t.getFullYear()-e.getFullYear(),e=>e.getFullYear());_t.every=e=>!isFinite(e=Math.floor(e))||!(e>0)?null:Se(t=>{t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},(t,r)=>{t.setFullYear(t.getFullYear()+r*e)});_t.range;const At=Se(e=>{e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},(e,t)=>{e.setUTCFullYear(e.getUTCFullYear()+t)},(e,t)=>t.getUTCFullYear()-e.getUTCFullYear(),e=>e.getUTCFullYear());At.every=e=>!isFinite(e=Math.floor(e))||!(e>0)?null:Se(t=>{t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},(t,r)=>{t.setUTCFullYear(t.getUTCFullYear()+r*e)});At.range;function dx(e,t,r,n,i,a){const o=[[Xt,1,yt],[Xt,5,5*yt],[Xt,15,15*yt],[Xt,30,30*yt],[a,1,Ze],[a,5,5*Ze],[a,15,15*Ze],[a,30,30*Ze],[i,1,mt],[i,3,3*mt],[i,6,6*mt],[i,12,12*mt],[n,1,Ot],[n,2,2*Ot],[r,1,bh],[t,1,um],[t,3,3*um],[e,1,Ps]];function u(s,f,l){const h=fp).right(o,h);if(d===o.length)return e.every(ql(s/Ps,f/Ps,l));if(d===0)return Xi.every(Math.max(ql(s,f,l),1));const[y,v]=o[h/o[d-1][2]53)return null;"w"in D||(D.w=1),"Z"in D?(ee=Es(un(D.y,0,1)),be=ee.getUTCDay(),ee=be>4||be===0?Zi.ceil(ee):Zi(ee),ee=Fa.offset(ee,(D.V-1)*7),D.y=ee.getUTCFullYear(),D.m=ee.getUTCMonth(),D.d=ee.getUTCDate()+(D.w+6)%7):(ee=Ts(un(D.y,0,1)),be=ee.getDay(),ee=be>4||be===0?Yi.ceil(ee):Yi(ee),ee=fi.offset(ee,(D.V-1)*7),D.y=ee.getFullYear(),D.m=ee.getMonth(),D.d=ee.getDate()+(D.w+6)%7)}else("W"in D||"U"in D)&&("w"in D||(D.w="u"in D?D.u%7:"W"in D?1:0),be="Z"in D?Es(un(D.y,0,1)).getUTCDay():Ts(un(D.y,0,1)).getDay(),D.m=0,D.d="W"in D?(D.w+6)%7+D.W*7-(be+5)%7:D.w+D.U*7-(be+6)%7);return"Z"in D?(D.H+=D.Z/100|0,D.M+=D.Z%100,Es(D)):Ts(D)}}function A(F,Z,Q,D){for(var de=0,ee=Z.length,be=Q.length,xe,De;de=be)return-1;if(xe=Z.charCodeAt(de++),xe===37){if(xe=Z.charAt(de++),De=m[xe in cm?Z.charAt(de++):xe],!De||(D=De(F,Q,D))<0)return-1}else if(xe!=Q.charCodeAt(D++))return-1}return D}function T(F,Z,Q){var D=s.exec(Z.slice(Q));return D?(F.p=f.get(D[0].toLowerCase()),Q+D[0].length):-1}function M(F,Z,Q){var D=d.exec(Z.slice(Q));return D?(F.w=y.get(D[0].toLowerCase()),Q+D[0].length):-1}function P(F,Z,Q){var D=l.exec(Z.slice(Q));return D?(F.w=h.get(D[0].toLowerCase()),Q+D[0].length):-1}function E(F,Z,Q){var D=g.exec(Z.slice(Q));return D?(F.m=x.get(D[0].toLowerCase()),Q+D[0].length):-1}function j(F,Z,Q){var D=v.exec(Z.slice(Q));return D?(F.m=p.get(D[0].toLowerCase()),Q+D[0].length):-1}function C(F,Z,Q){return A(F,t,Z,Q)}function $(F,Z,Q){return A(F,r,Z,Q)}function k(F,Z,Q){return A(F,n,Z,Q)}function R(F){return o[F.getDay()]}function L(F){return a[F.getDay()]}function B(F){return c[F.getMonth()]}function U(F){return u[F.getMonth()]}function G(F){return i[+(F.getHours()>=12)]}function W(F){return 1+~~(F.getMonth()/3)}function V(F){return o[F.getUTCDay()]}function fe(F){return a[F.getUTCDay()]}function ye(F){return c[F.getUTCMonth()]}function Le(F){return u[F.getUTCMonth()]}function qt(F){return i[+(F.getUTCHours()>=12)]}function Re(F){return 1+~~(F.getUTCMonth()/3)}return{format:function(F){var Z=b(F+="",w);return Z.toString=function(){return F},Z},parse:function(F){var Z=_(F+="",!1);return Z.toString=function(){return F},Z},utcFormat:function(F){var Z=b(F+="",O);return Z.toString=function(){return F},Z},utcParse:function(F){var Z=_(F+="",!0);return Z.toString=function(){return F},Z}}}var cm={"-":"",_:" ",0:"0"},Ee=/^\s*\d+/,UT=/^%/,HT=/[\\^$*+?|[\]().{}]/g;function re(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",a=i.length;return n+(a[t.toLowerCase(),r]))}function GT(e,t,r){var n=Ee.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function VT(e,t,r){var n=Ee.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function XT(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function YT(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function ZT(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function sm(e,t,r){var n=Ee.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function lm(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function JT(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function QT(e,t,r){var n=Ee.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function eE(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function fm(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function tE(e,t,r){var n=Ee.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function hm(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function rE(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function nE(e,t,r){var n=Ee.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function iE(e,t,r){var n=Ee.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function aE(e,t,r){var n=Ee.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function oE(e,t,r){var n=UT.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function uE(e,t,r){var n=Ee.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function cE(e,t,r){var n=Ee.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function pm(e,t){return re(e.getDate(),t,2)}function sE(e,t){return re(e.getHours(),t,2)}function lE(e,t){return re(e.getHours()%12||12,t,2)}function fE(e,t){return re(1+fi.count(_t(e),e),t,3)}function vx(e,t){return re(e.getMilliseconds(),t,3)}function hE(e,t){return vx(e,t)+"000"}function pE(e,t){return re(e.getMonth()+1,t,2)}function dE(e,t){return re(e.getMinutes(),t,2)}function vE(e,t){return re(e.getSeconds(),t,2)}function yE(e){var t=e.getDay();return t===0?7:t}function mE(e,t){return re(Wa.count(_t(e)-1,e),t,2)}function yx(e){var t=e.getDay();return t>=4||t===0?Mr(e):Mr.ceil(e)}function gE(e,t){return e=yx(e),re(Mr.count(_t(e),e)+(_t(e).getDay()===4),t,2)}function bE(e){return e.getDay()}function xE(e,t){return re(Yi.count(_t(e)-1,e),t,2)}function wE(e,t){return re(e.getFullYear()%100,t,2)}function OE(e,t){return e=yx(e),re(e.getFullYear()%100,t,2)}function _E(e,t){return re(e.getFullYear()%1e4,t,4)}function AE(e,t){var r=e.getDay();return e=r>=4||r===0?Mr(e):Mr.ceil(e),re(e.getFullYear()%1e4,t,4)}function SE(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+re(t/60|0,"0",2)+re(t%60,"0",2)}function dm(e,t){return re(e.getUTCDate(),t,2)}function PE(e,t){return re(e.getUTCHours(),t,2)}function TE(e,t){return re(e.getUTCHours()%12||12,t,2)}function EE(e,t){return re(1+Fa.count(At(e),e),t,3)}function mx(e,t){return re(e.getUTCMilliseconds(),t,3)}function jE(e,t){return mx(e,t)+"000"}function ME(e,t){return re(e.getUTCMonth()+1,t,2)}function $E(e,t){return re(e.getUTCMinutes(),t,2)}function CE(e,t){return re(e.getUTCSeconds(),t,2)}function IE(e){var t=e.getUTCDay();return t===0?7:t}function kE(e,t){return re(za.count(At(e)-1,e),t,2)}function gx(e){var t=e.getUTCDay();return t>=4||t===0?$r(e):$r.ceil(e)}function RE(e,t){return e=gx(e),re($r.count(At(e),e)+(At(e).getUTCDay()===4),t,2)}function DE(e){return e.getUTCDay()}function NE(e,t){return re(Zi.count(At(e)-1,e),t,2)}function qE(e,t){return re(e.getUTCFullYear()%100,t,2)}function LE(e,t){return e=gx(e),re(e.getUTCFullYear()%100,t,2)}function BE(e,t){return re(e.getUTCFullYear()%1e4,t,4)}function FE(e,t){var r=e.getUTCDay();return e=r>=4||r===0?$r(e):$r.ceil(e),re(e.getUTCFullYear()%1e4,t,4)}function WE(){return"+0000"}function vm(){return"%"}function ym(e){return+e}function mm(e){return Math.floor(+e/1e3)}var hr,bx,xx;zE({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function zE(e){return hr=zT(e),bx=hr.format,hr.parse,xx=hr.utcFormat,hr.utcParse,hr}function UE(e){return new Date(e)}function HE(e){return e instanceof Date?+e:+new Date(+e)}function Ph(e,t,r,n,i,a,o,u,c,s){var f=hh(),l=f.invert,h=f.domain,d=s(".%L"),y=s(":%S"),v=s("%I:%M"),p=s("%I %p"),g=s("%a %d"),x=s("%b %d"),w=s("%B"),O=s("%Y");function m(b){return(c(b)t(i/(e.length-1)))},r.quantiles=function(n){return Array.from({length:n+1},(i,a)=>kP(e,a/n))},r.copy=function(){return Ax(t).domain(e)},Tt.apply(r,arguments)}function Ha(){var e=0,t=.5,r=1,n=1,i,a,o,u,c,s=ke,f,l=!1,h;function d(v){return isNaN(v=+v)?h:(v=.5+((v=+f(v))-a)*(n*vr}return Ms=e,Ms}var $s,wm;function YE(){if(wm)return $s;wm=1;var e=Ka(),t=Ex(),r=Jr();function n(i){return i&&i.length?e(i,r,t):void 0}return $s=n,$s}var ZE=YE();const Ga=oe(ZE);var Cs,Om;function jx(){if(Om)return Cs;Om=1;function e(t,r){return te.e^a.s<0?1:-1;for(n=a.d.length,i=e.d.length,t=0,r=ne.d[t]^a.s<0?1:-1;return n===i?0:n>i^a.s<0?1:-1};z.decimalPlaces=z.dp=function(){var e=this,t=e.d.length-1,r=(t-e.e)*he;if(t=e.d[t],t)for(;t%10==0;t/=10)r--;return r<0?0:r};z.dividedBy=z.div=function(e){return xt(this,new this.constructor(e))};z.dividedToIntegerBy=z.idiv=function(e){var t=this,r=t.constructor;return ue(xt(t,new r(e),0,1),r.precision)};z.equals=z.eq=function(e){return!this.cmp(e)};z.exponent=function(){return ge(this)};z.greaterThan=z.gt=function(e){return this.cmp(e)>0};z.greaterThanOrEqualTo=z.gte=function(e){return this.cmp(e)>=0};z.isInteger=z.isint=function(){return this.e>this.d.length-2};z.isNegative=z.isneg=function(){return this.s<0};z.isPositive=z.ispos=function(){return this.s>0};z.isZero=function(){return this.s===0};z.lessThan=z.lt=function(e){return this.cmp(e)<0};z.lessThanOrEqualTo=z.lte=function(e){return this.cmp(e)<1};z.logarithm=z.log=function(e){var t,r=this,n=r.constructor,i=n.precision,a=i+5;if(e===void 0)e=new n(10);else if(e=new n(e),e.s<1||e.eq(Ue))throw Error(Je+"NaN");if(r.s<1)throw Error(Je+(r.s?"NaN":"-Infinity"));return r.eq(Ue)?new n(0):(pe=!1,t=xt(Dn(r,a),Dn(e,a),a),pe=!0,ue(t,i))};z.minus=z.sub=function(e){var t=this;return e=new t.constructor(e),t.s==e.s?Ix(t,e):$x(t,(e.s=-e.s,e))};z.modulo=z.mod=function(e){var t,r=this,n=r.constructor,i=n.precision;if(e=new n(e),!e.s)throw Error(Je+"NaN");return r.s?(pe=!1,t=xt(r,e,0,1).times(e),pe=!0,r.minus(t)):ue(new n(r),i)};z.naturalExponential=z.exp=function(){return Cx(this)};z.naturalLogarithm=z.ln=function(){return Dn(this)};z.negated=z.neg=function(){var e=new this.constructor(this);return e.s=-e.s||0,e};z.plus=z.add=function(e){var t=this;return e=new t.constructor(e),t.s==e.s?$x(t,e):Ix(t,(e.s=-e.s,e))};z.precision=z.sd=function(e){var t,r,n,i=this;if(e!==void 0&&e!==!!e&&e!==1&&e!==0)throw Error(Jt+e);if(t=ge(i)+1,n=i.d.length-1,r=n*he+1,n=i.d[n],n){for(;n%10==0;n/=10)r--;for(n=i.d[0];n>=10;n/=10)r++}return e&&t>r?t:r};z.squareRoot=z.sqrt=function(){var e,t,r,n,i,a,o,u=this,c=u.constructor;if(u.s<1){if(!u.s)return new c(0);throw Error(Je+"NaN")}for(e=ge(u),pe=!1,i=Math.sqrt(+u),i==0||i==1/0?(t=ot(u.d),(t.length+e)%2==0&&(t+="0"),i=Math.sqrt(t),e=tn((e+1)/2)-(e<0||e%2),i==1/0?t="5e"+e:(t=i.toExponential(),t=t.slice(0,t.indexOf("e")+1)+e),n=new c(t)):n=new c(i.toString()),r=c.precision,i=o=r+3;;)if(a=n,n=a.plus(xt(u,a,o+2)).times(.5),ot(a.d).slice(0,o)===(t=ot(n.d)).slice(0,o)){if(t=t.slice(o-3,o+1),i==o&&t=="4999"){if(ue(a,r+1,0),a.times(a).eq(u)){n=a;break}}else if(t!="9999")break;o+=4}return pe=!0,ue(n,r)};z.times=z.mul=function(e){var t,r,n,i,a,o,u,c,s,f=this,l=f.constructor,h=f.d,d=(e=new l(e)).d;if(!f.s||!e.s)return new l(0);for(e.s*=f.s,r=f.e+e.e,c=h.length,s=d.length,c=0;){for(t=0,i=c+n;i>n;)u=a[i]+d[n]*h[i-n-1]+t,a[i--]=u%Pe|0,t=u/Pe|0;a[i]=(a[i]+t)%Pe|0}for(;!a[--o];)a.pop();return t?++r:a.shift(),e.d=a,e.e=r,pe?ue(e,l.precision):e};z.toDecimalPlaces=z.todp=function(e,t){var r=this,n=r.constructor;return r=new n(r),e===void 0?r:(st(e,0,en),t===void 0?t=n.rounding:st(t,0,8),ue(r,e+ge(r)+1,t))};z.toExponential=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=nr(n,!0):(st(e,0,en),t===void 0?t=i.rounding:st(t,0,8),n=ue(new i(n),e+1,t),r=nr(n,!0,e+1)),r};z.toFixed=function(e,t){var r,n,i=this,a=i.constructor;return e===void 0?nr(i):(st(e,0,en),t===void 0?t=a.rounding:st(t,0,8),n=ue(new a(i),e+ge(i)+1,t),r=nr(n.abs(),!1,e+ge(n)+1),i.isneg()&&!i.isZero()?"-"+r:r)};z.toInteger=z.toint=function(){var e=this,t=e.constructor;return ue(new t(e),ge(e)+1,t.rounding)};z.toNumber=function(){return+this};z.toPower=z.pow=function(e){var t,r,n,i,a,o,u=this,c=u.constructor,s=12,f=+(e=new c(e));if(!e.s)return new c(Ue);if(u=new c(u),!u.s){if(e.s<1)throw Error(Je+"Infinity");return u}if(u.eq(Ue))return u;if(n=c.precision,e.eq(Ue))return ue(u,n);if(t=e.e,r=e.d.length-1,o=t>=r,a=u.s,o){if((r=f<0?-f:f)<=Mx){for(i=new c(Ue),t=Math.ceil(n/he+4),pe=!1;r%2&&(i=i.times(u),Em(i.d,t)),r=tn(r/2),r!==0;)u=u.times(u),Em(u.d,t);return pe=!0,e.s<0?new c(Ue).div(i):ue(i,n)}}else if(a<0)throw Error(Je+"NaN");return a=a<0&&e.d[Math.max(t,r)]&1?-1:1,u.s=1,pe=!1,i=e.times(Dn(u,n+s)),pe=!0,i=Cx(i),i.s=a,i};z.toPrecision=function(e,t){var r,n,i=this,a=i.constructor;return e===void 0?(r=ge(i),n=nr(i,r<=a.toExpNeg||r>=a.toExpPos)):(st(e,1,en),t===void 0?t=a.rounding:st(t,0,8),i=ue(new a(i),e,t),r=ge(i),n=nr(i,e<=r||r<=a.toExpNeg,e)),n};z.toSignificantDigits=z.tosd=function(e,t){var r=this,n=r.constructor;return e===void 0?(e=n.precision,t=n.rounding):(st(e,1,en),t===void 0?t=n.rounding:st(t,0,8)),ue(new n(r),e,t)};z.toString=z.valueOf=z.val=z.toJSON=z[Symbol.for("nodejs.util.inspect.custom")]=function(){var e=this,t=ge(e),r=e.constructor;return nr(e,t<=r.toExpNeg||t>=r.toExpPos)};function $x(e,t){var r,n,i,a,o,u,c,s,f=e.constructor,l=f.precision;if(!e.s||!t.s)return t.s||(t=new f(e)),pe?ue(t,l):t;if(c=e.d,s=t.d,o=e.e,i=t.e,c=c.slice(),a=o-i,a){for(a<0?(n=c,a=-a,u=s.length):(n=s,i=o,u=c.length),o=Math.ceil(l/he),u=o>u?o+1:u+1,a>u&&(a=u,n.length=1),n.reverse();a--;)n.push(0);n.reverse()}for(u=c.length,a=s.length,u-a<0&&(a=u,n=s,s=c,c=n),r=0;a;)r=(c[--a]=c[a]+s[a]+r)/Pe|0,c[a]%=Pe;for(r&&(c.unshift(r),++i),u=c.length;c[--u]==0;)c.pop();return t.d=c,t.e=i,pe?ue(t,l):t}function st(e,t,r){if(e!==~~e||er)throw Error(Jt+e)}function ot(e){var t,r,n,i=e.length-1,a="",o=e[0];if(i>0){for(a+=o,t=1;to?1:-1;else for(u=c=0;ui[u]?1:-1;break}return c}function r(n,i,a){for(var o=0;a--;)n[a]-=o,o=n[a]1;)n.shift()}return function(n,i,a,o){var u,c,s,f,l,h,d,y,v,p,g,x,w,O,m,b,_,A,T=n.constructor,M=n.s==i.s?1:-1,P=n.d,E=i.d;if(!n.s)return new T(n);if(!i.s)throw Error(Je+"Division by zero");for(c=n.e-i.e,_=E.length,m=P.length,d=new T(M),y=d.d=[],s=0;E[s]==(P[s]||0);)++s;if(E[s]>(P[s]||0)&&--c,a==null?x=a=T.precision:o?x=a+(ge(n)-ge(i))+1:x=a,x<0)return new T(0);if(x=x/he+2|0,s=0,_==1)for(f=0,E=E[0],x++;(s1&&(E=e(E,f),P=e(P,f),_=E.length,m=P.length),O=_,v=P.slice(0,_),p=v.length;p<_;)v[p++]=0;A=E.slice(),A.unshift(0),b=E[0],E[1]>=Pe/2&&++b;do f=0,u=t(E,v,_,p),u<0?(g=v[0],_!=p&&(g=g*Pe+(v[1]||0)),f=g/b|0,f>1?(f>=Pe&&(f=Pe-1),l=e(E,f),h=l.length,p=v.length,u=t(l,v,h,p),u==1&&(f--,r(l,_16)throw Error(jh+ge(e));if(!e.s)return new f(Ue);for(pe=!1,u=l,o=new f(.03125);e.abs().gte(.1);)e=e.times(o),s+=5;for(n=Math.log(Ht(2,s))/Math.LN10*2+5|0,u+=n,r=i=a=new f(Ue),f.precision=u;;){if(i=ue(i.times(e),u),r=r.times(++c),o=a.plus(xt(i,r,u)),ot(o.d).slice(0,u)===ot(a.d).slice(0,u)){for(;s--;)a=ue(a.times(a),u);return f.precision=l,t==null?(pe=!0,ue(a,l)):a}a=o}}function ge(e){for(var t=e.e*he,r=e.d[0];r>=10;r/=10)t++;return t}function Ns(e,t,r){if(t>e.LN10.sd())throw pe=!0,r&&(e.precision=r),Error(Je+"LN10 precision limit exceeded");return ue(new e(e.LN10),t)}function jt(e){for(var t="";e--;)t+="0";return t}function Dn(e,t){var r,n,i,a,o,u,c,s,f,l=1,h=10,d=e,y=d.d,v=d.constructor,p=v.precision;if(d.s<1)throw Error(Je+(d.s?"NaN":"-Infinity"));if(d.eq(Ue))return new v(0);if(t==null?(pe=!1,s=p):s=t,d.eq(10))return t==null&&(pe=!0),Ns(v,s);if(s+=h,v.precision=s,r=ot(y),n=r.charAt(0),a=ge(d),Math.abs(a)<15e14){for(;n<7&&n!=1||n==1&&r.charAt(1)>3;)d=d.times(e),r=ot(d.d),n=r.charAt(0),l++;a=ge(d),n>1?(d=new v("0."+r),a++):d=new v(n+"."+r.slice(1))}else return c=Ns(v,s+2,p).times(a+""),d=Dn(new v(n+"."+r.slice(1)),s-h).plus(c),v.precision=p,t==null?(pe=!0,ue(d,p)):d;for(u=o=d=xt(d.minus(Ue),d.plus(Ue),s),f=ue(d.times(d),s),i=3;;){if(o=ue(o.times(f),s),c=u.plus(xt(o,new v(i),s)),ot(c.d).slice(0,s)===ot(u.d).slice(0,s))return u=u.times(2),a!==0&&(u=u.plus(Ns(v,s+2,p).times(a+""))),u=xt(u,new v(l),s),v.precision=p,t==null?(pe=!0,ue(u,p)):u;u=c,i+=2}}function Tm(e,t){var r,n,i;for((r=t.indexOf("."))>-1&&(t=t.replace(".","")),(n=t.search(/e/i))>0?(r<0&&(r=n),r+=+t.slice(n+1),t=t.substring(0,n)):r<0&&(r=t.length),n=0;t.charCodeAt(n)===48;)++n;for(i=t.length;t.charCodeAt(i-1)===48;)--i;if(t=t.slice(n,i),t){if(i-=n,r=r-n-1,e.e=tn(r/he),e.d=[],n=(r+1)%he,r<0&&(n+=he),nJi||e.e<-Ji))throw Error(jh+r)}else e.s=0,e.e=0,e.d=[0];return e}function ue(e,t,r){var n,i,a,o,u,c,s,f,l=e.d;for(o=1,a=l[0];a>=10;a/=10)o++;if(n=t-o,n<0)n+=he,i=t,s=l[f=0];else{if(f=Math.ceil((n+1)/he),a=l.length,f>=a)return e;for(s=a=l[f],o=1;a>=10;a/=10)o++;n%=he,i=n-he+o}if(r!==void 0&&(a=Ht(10,o-i-1),u=s/a%10|0,c=t<0||l[f+1]!==void 0||s%a,c=r<4?(u||c)&&(r==0||r==(e.s<0?3:2)):u>5||u==5&&(r==4||c||r==6&&(n>0?i>0?s/Ht(10,o-i):0:l[f-1])%10&1||r==(e.s<0?8:7))),t<1||!l[0])return c?(a=ge(e),l.length=1,t=t-a-1,l[0]=Ht(10,(he-t%he)%he),e.e=tn(-t/he)||0):(l.length=1,l[0]=e.e=e.s=0),e;if(n==0?(l.length=f,a=1,f--):(l.length=f+1,a=Ht(10,he-n),l[f]=i>0?(s/Ht(10,o-i)%Ht(10,i)|0)*a:0),c)for(;;)if(f==0){(l[0]+=a)==Pe&&(l[0]=1,++e.e);break}else{if(l[f]+=a,l[f]!=Pe)break;l[f--]=0,a=1}for(n=l.length;l[--n]===0;)l.pop();if(pe&&(e.e>Ji||e.e<-Ji))throw Error(jh+ge(e));return e}function Ix(e,t){var r,n,i,a,o,u,c,s,f,l,h=e.constructor,d=h.precision;if(!e.s||!t.s)return t.s?t.s=-t.s:t=new h(e),pe?ue(t,d):t;if(c=e.d,l=t.d,n=t.e,s=e.e,c=c.slice(),o=s-n,o){for(f=o<0,f?(r=c,o=-o,u=l.length):(r=l,n=s,u=c.length),i=Math.max(Math.ceil(d/he),u)+2,o>i&&(o=i,r.length=1),r.reverse(),i=o;i--;)r.push(0);r.reverse()}else{for(i=c.length,u=l.length,f=i0;--i)c[u++]=0;for(i=l.length;i>o;){if(c[--i]0?a=a.charAt(0)+"."+a.slice(1)+jt(n):o>1&&(a=a.charAt(0)+"."+a.slice(1)),a=a+(i<0?"e":"e+")+i):i<0?(a="0."+jt(-i-1)+a,r&&(n=r-o)>0&&(a+=jt(n))):i>=o?(a+=jt(i+1-o),r&&(n=r-i-1)>0&&(a=a+"."+jt(n))):((n=i+1)0&&(i+1===o&&(a+="."),a+=jt(n))),e.s<0?"-"+a:a}function Em(e,t){if(e.length>t)return e.length=t,!0}function kx(e){var t,r,n;function i(a){var o=this;if(!(o instanceof i))return new i(a);if(o.constructor=i,a instanceof i){o.s=a.s,o.e=a.e,o.d=(a=a.d)?a.slice():a;return}if(typeof a=="number"){if(a*0!==0)throw Error(Jt+a);if(a>0)o.s=1;else if(a<0)a=-a,o.s=-1;else{o.s=0,o.e=0,o.d=[0];return}if(a===~~a&&a<1e7){o.e=0,o.d=[a];return}return Tm(o,a.toString())}else if(typeof a!="string")throw Error(Jt+a);if(a.charCodeAt(0)===45?(a=a.slice(1),o.s=-1):o.s=1,uj.test(a))Tm(o,a);else throw Error(Jt+a)}if(i.prototype=z,i.ROUND_UP=0,i.ROUND_DOWN=1,i.ROUND_CEIL=2,i.ROUND_FLOOR=3,i.ROUND_HALF_UP=4,i.ROUND_HALF_DOWN=5,i.ROUND_HALF_EVEN=6,i.ROUND_HALF_CEIL=7,i.ROUND_HALF_FLOOR=8,i.clone=kx,i.config=i.set=cj,e===void 0&&(e={}),e)for(n=["precision","rounding","toExpNeg","toExpPos","LN10"],t=0;t=i[t+1]&&n<=i[t+2])this[r]=n;else throw Error(Jt+r+": "+n);if((n=e[r="LN10"])!==void 0)if(n==Math.LN10)this[r]=new this(n);else throw Error(Jt+r+": "+n);return this}var Mh=kx(oj);Ue=new Mh(1);const ae=Mh;function sj(e){return pj(e)||hj(e)||fj(e)||lj()}function lj(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function fj(e,t){if(e){if(typeof e=="string")return zl(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return zl(e,t)}}function hj(e){if(typeof Symbol<"u"&&Symbol.iterator in Object(e))return Array.from(e)}function pj(e){if(Array.isArray(e))return zl(e)}function zl(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r=t?r.apply(void 0,i):e(t-o,jm(function(){for(var u=arguments.length,c=new Array(u),s=0;se.length)&&(t=e.length);for(var r=0,n=new Array(t);r"u"||!(Symbol.iterator in Object(e)))){var r=[],n=!0,i=!1,a=void 0;try{for(var o=e[Symbol.iterator](),u;!(n=(u=o.next()).done)&&(r.push(u.value),!(t&&r.length===t));n=!0);}catch(c){i=!0,a=c}finally{try{!n&&o.return!=null&&o.return()}finally{if(i)throw a}}return r}}function Ej(e){if(Array.isArray(e))return e}function Lx(e){var t=Nn(e,2),r=t[0],n=t[1],i=r,a=n;return r>n&&(i=n,a=r),[i,a]}function Bx(e,t,r){if(e.lte(0))return new ae(0);var n=Ya.getDigitCount(e.toNumber()),i=new ae(10).pow(n),a=e.div(i),o=n!==1?.05:.1,u=new ae(Math.ceil(a.div(o).toNumber())).add(r).mul(o),c=u.mul(i);return t?c:new ae(Math.ceil(c))}function jj(e,t,r){var n=1,i=new ae(e);if(!i.isint()&&r){var a=Math.abs(e);a<1?(n=new ae(10).pow(Ya.getDigitCount(e)-1),i=new ae(Math.floor(i.div(n).toNumber())).mul(n)):a>1&&(i=new ae(Math.floor(e)))}else e===0?i=new ae(Math.floor((t-1)/2)):r||(i=new ae(Math.floor(e)));var o=Math.floor((t-1)/2),u=mj(yj(function(c){return i.add(new ae(c-o).mul(n)).toNumber()}),Ul);return u(0,t)}function Fx(e,t,r,n){var i=arguments.length>4&&arguments[4]!==void 0?arguments[4]:0;if(!Number.isFinite((t-e)/(r-1)))return{step:new ae(0),tickMin:new ae(0),tickMax:new ae(0)};var a=Bx(new ae(t).sub(e).div(r-1),n,i),o;e<=0&&t>=0?o=new ae(0):(o=new ae(e).add(t).div(2),o=o.sub(new ae(o).mod(a)));var u=Math.ceil(o.sub(e).div(a).toNumber()),c=Math.ceil(new ae(t).sub(o).div(a).toNumber()),s=u+c+1;return s>r?Fx(e,t,r,n,i+1):(s0?c+(r-s):c,u=t>0?u:u+(r-s)),{step:a,tickMin:o.sub(new ae(u).mul(a)),tickMax:o.add(new ae(c).mul(a))})}function Mj(e){var t=Nn(e,2),r=t[0],n=t[1],i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:6,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0,o=Math.max(i,2),u=Lx([r,n]),c=Nn(u,2),s=c[0],f=c[1];if(s===-1/0||f===1/0){var l=f===1/0?[s].concat(Kl(Ul(0,i-1).map(function(){return 1/0}))):[].concat(Kl(Ul(0,i-1).map(function(){return-1/0})),[f]);return r>n?Hl(l):l}if(s===f)return jj(s,i,a);var h=Fx(s,f,o,a),d=h.step,y=h.tickMin,v=h.tickMax,p=Ya.rangeStep(y,v.add(new ae(.1).mul(d)),d);return r>n?Hl(p):p}function $j(e,t){var r=Nn(e,2),n=r[0],i=r[1],a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0,o=Lx([n,i]),u=Nn(o,2),c=u[0],s=u[1];if(c===-1/0||s===1/0)return[n,i];if(c===s)return[c];var f=Math.max(t,2),l=Bx(new ae(s).sub(c).div(f-1),a,0),h=[].concat(Kl(Ya.rangeStep(new ae(c),new ae(s).sub(new ae(.99).mul(l)),l)),[s]);return n>i?Hl(h):h}var Cj=Nx(Mj),Ij=Nx($j),kj=["offset","layout","width","dataKey","data","dataPointFormatter","xAxis","yAxis"];function Cr(e){"@babel/helpers - typeof";return Cr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Cr(e)}function Qi(){return Qi=Object.assign?Object.assign.bind():function(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,n=new Array(t);r=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function Fj(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function Wj(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function zj(e,t){for(var r=0;re.length)&&(t=e.length);for(var r=0,n=new Array(t);r1&&arguments[1]!==void 0?arguments[1]:[],i=arguments.length>2?arguments[2]:void 0,a=arguments.length>3?arguments[3]:void 0,o=-1,u=(r=n?.length)!==null&&r!==void 0?r:0;if(u<=1)return 0;if(a&&a.axisType==="angleAxis"&&Math.abs(Math.abs(a.range[1]-a.range[0])-360)<=1e-6)for(var c=a.range,s=0;s0?i[s-1].coordinate:i[u-1].coordinate,l=i[s].coordinate,h=s>=u-1?i[0].coordinate:i[s+1].coordinate,d=void 0;if(Ce(l-f)!==Ce(h-l)){var y=[];if(Ce(h-l)===Ce(c[1]-c[0])){d=h;var v=l+c[1]-c[0];y[0]=Math.min(v,(v+f)/2),y[1]=Math.max(v,(v+f)/2)}else{d=f;var p=h+c[1]-c[0];y[0]=Math.min(l,(p+l)/2),y[1]=Math.max(l,(p+l)/2)}var g=[Math.min(l,(d+l)/2),Math.max(l,(d+l)/2)];if(t>g[0]&&t<=g[1]||t>=y[0]&&t<=y[1]){o=i[s].index;break}}else{var x=Math.min(f,h),w=Math.max(f,h);if(t>(x+l)/2&&t<=(w+l)/2){o=i[s].index;break}}}else for(var O=0;O0&&O(n[O].coordinate+n[O-1].coordinate)/2&&t<=(n[O].coordinate+n[O+1].coordinate)/2||O===u-1&&t>(n[O].coordinate+n[O-1].coordinate)/2){o=n[O].index;break}return o},$h=function(t){var r,n=t,i=n.type.displayName,a=(r=t.type)!==null&&r!==void 0&&r.defaultProps?ve(ve({},t.type.defaultProps),t.props):t.props,o=a.stroke,u=a.fill,c;switch(i){case"Line":c=o;break;case"Area":case"Radar":c=o&&o!=="none"?o:u;break;default:c=u;break}return c},oM=function(t){var r=t.barSize,n=t.totalSize,i=t.stackGroups,a=i===void 0?{}:i;if(!a)return{};for(var o={},u=Object.keys(a),c=0,s=u.length;c=0});if(g&&g.length){var x=g[0].type.defaultProps,w=x!==void 0?ve(ve({},x),g[0].props):g[0].props,O=w.barSize,m=w[p];o[m]||(o[m]=[]);var b=Y(O)?r:O;o[m].push({item:g[0],stackList:g.slice(1),barSize:Y(b)?void 0:Ie(b,n,0)})}}return o},uM=function(t){var r=t.barGap,n=t.barCategoryGap,i=t.bandSize,a=t.sizeList,o=a===void 0?[]:a,u=t.maxBarSize,c=o.length;if(c<1)return null;var s=Ie(r,i,0,!0),f,l=[];if(o[0].barSize===+o[0].barSize){var h=!1,d=i/c,y=o.reduce(function(O,m){return O+m.barSize||0},0);y+=(c-1)*s,y>=i&&(y-=(c-1)*s,s=0),y>=i&&d>0&&(h=!0,d*=.9,y=c*d);var v=(i-y)/2>>0,p={offset:v-s,size:0};f=o.reduce(function(O,m){var b={item:m.item,position:{offset:p.offset+p.size+s,size:h?d:m.barSize}},_=[].concat(Cm(O),[b]);return p=_[_.length-1].position,m.stackList&&m.stackList.length&&m.stackList.forEach(function(A){_.push({item:A,position:p})}),_},l)}else{var g=Ie(n,i,0,!0);i-2*g-(c-1)*s<=0&&(s=0);var x=(i-2*g-(c-1)*s)/c;x>1&&(x>>=0);var w=u===+u?Math.min(x,u):x;f=o.reduce(function(O,m,b){var _=[].concat(Cm(O),[{item:m.item,position:{offset:g+(x+s)*b+(x-w)/2,size:w}}]);return m.stackList&&m.stackList.length&&m.stackList.forEach(function(A){_.push({item:A,position:_[_.length-1].position})}),_},l)}return f},cM=function(t,r,n,i){var a=n.children,o=n.width,u=n.margin,c=o-(u.left||0)-(u.right||0),s=Hx({children:a,legendWidth:c});if(s){var f=i||{},l=f.width,h=f.height,d=s.align,y=s.verticalAlign,v=s.layout;if((v==="vertical"||v==="horizontal"&&y==="middle")&&d!=="center"&&q(t[d]))return ve(ve({},t),{},_r({},d,t[d]+(l||0)));if((v==="horizontal"||v==="vertical"&&d==="center")&&y!=="middle"&&q(t[y]))return ve(ve({},t),{},_r({},y,t[y]+(h||0)))}return t},sM=function(t,r,n){return Y(r)?!0:t==="horizontal"?r==="yAxis":t==="vertical"||n==="x"?r==="xAxis":n==="y"?r==="yAxis":!0},Kx=function(t,r,n,i,a){var o=r.props.children,u=Ke(o,pi).filter(function(s){return sM(i,a,s.props.direction)});if(u&&u.length){var c=u.map(function(s){return s.props.dataKey});return t.reduce(function(s,f){var l=_e(f,n);if(Y(l))return s;var h=Array.isArray(l)?[Va(l),Ga(l)]:[l,l],d=c.reduce(function(y,v){var p=_e(f,v,0),g=h[0]-Math.abs(Array.isArray(p)?p[0]:p),x=h[1]+Math.abs(Array.isArray(p)?p[1]:p);return[Math.min(g,y[0]),Math.max(x,y[1])]},[1/0,-1/0]);return[Math.min(d[0],s[0]),Math.max(d[1],s[1])]},[1/0,-1/0])}return null},lM=function(t,r,n,i,a){var o=r.map(function(u){return Kx(t,u,n,a,i)}).filter(function(u){return!Y(u)});return o&&o.length?o.reduce(function(u,c){return[Math.min(u[0],c[0]),Math.max(u[1],c[1])]},[1/0,-1/0]):null},Gx=function(t,r,n,i,a){var o=r.map(function(c){var s=c.props.dataKey;return n==="number"&&s&&Kx(t,c,s,i)||bn(t,s,n,a)});if(n==="number")return o.reduce(function(c,s){return[Math.min(c[0],s[0]),Math.max(c[1],s[1])]},[1/0,-1/0]);var u={};return o.reduce(function(c,s){for(var f=0,l=s.length;f=2?Ce(u[0]-u[1])*2*s:s,r&&(t.ticks||t.niceTicks)){var f=(t.ticks||t.niceTicks).map(function(l){var h=a?a.indexOf(l):l;return{coordinate:i(h)+s,value:l,offset:s}});return f.filter(function(l){return!oi(l.coordinate)})}return t.isCategorical&&t.categoricalDomain?t.categoricalDomain.map(function(l,h){return{coordinate:i(l)+s,value:l,index:h,offset:s}}):i.ticks&&!n?i.ticks(t.tickCount).map(function(l){return{coordinate:i(l)+s,value:l,offset:s}}):i.domain().map(function(l,h){return{coordinate:i(l)+s,value:a?a[l]:l,index:h,offset:s}})},qs=new WeakMap,_i=function(t,r){if(typeof r!="function")return t;qs.has(t)||qs.set(t,new WeakMap);var n=qs.get(t);if(n.has(r))return n.get(r);var i=function(){t.apply(void 0,arguments),r.apply(void 0,arguments)};return n.set(r,i),i},Yx=function(t,r,n){var i=t.scale,a=t.type,o=t.layout,u=t.axisType;if(i==="auto")return o==="radial"&&u==="radiusAxis"?{scale:$n(),realScaleType:"band"}:o==="radial"&&u==="angleAxis"?{scale:Vi(),realScaleType:"linear"}:a==="category"&&r&&(r.indexOf("LineChart")>=0||r.indexOf("AreaChart")>=0||r.indexOf("ComposedChart")>=0&&!n)?{scale:gn(),realScaleType:"point"}:a==="category"?{scale:$n(),realScaleType:"band"}:{scale:Vi(),realScaleType:"linear"};if(er(i)){var c="scale".concat(Ia(i));return{scale:(gm[c]||gn)(),realScaleType:gm[c]?c:"point"}}return X(i)?{scale:i}:{scale:gn(),realScaleType:"point"}},km=1e-4,Zx=function(t){var r=t.domain();if(!(!r||r.length<=2)){var n=r.length,i=t.range(),a=Math.min(i[0],i[1])-km,o=Math.max(i[0],i[1])+km,u=t(r[0]),c=t(r[n-1]);(uo||co)&&t.domain([r[0],r[n-1]])}},fM=function(t,r){if(!t)return null;for(var n=0,i=t.length;ni)&&(a[1]=i),a[0]>i&&(a[0]=i),a[1]=0?(t[u][n][0]=a,t[u][n][1]=a+c,a=t[u][n][1]):(t[u][n][0]=o,t[u][n][1]=o+c,o=t[u][n][1])}},dM=function(t){var r=t.length;if(!(r<=0))for(var n=0,i=t[0].length;n=0?(t[o][n][0]=a,t[o][n][1]=a+u,a=t[o][n][1]):(t[o][n][0]=0,t[o][n][1]=0)}},vM={sign:pM,expand:n1,none:Ar,silhouette:i1,wiggle:a1,positive:dM},yM=function(t,r,n){var i=r.map(function(u){return u.props.dataKey}),a=vM[n],o=r1().keys(i).value(function(u,c){return+_e(u,c,0)}).order(Sl).offset(a);return o(t)},mM=function(t,r,n,i,a,o){if(!t)return null;var u=o?r.reverse():r,c={},s=u.reduce(function(l,h){var d,y=(d=h.type)!==null&&d!==void 0&&d.defaultProps?ve(ve({},h.type.defaultProps),h.props):h.props,v=y.stackId,p=y.hide;if(p)return l;var g=y[n],x=l[g]||{hasStack:!1,stackGroups:{}};if(Ae(v)){var w=x.stackGroups[v]||{numericAxisId:n,cateAxisId:i,items:[]};w.items.push(h),x.hasStack=!0,x.stackGroups[v]=w}else x.stackGroups[Zr("_stackId_")]={numericAxisId:n,cateAxisId:i,items:[h]};return ve(ve({},l),{},_r({},g,x))},c),f={};return Object.keys(s).reduce(function(l,h){var d=s[h];if(d.hasStack){var y={};d.stackGroups=Object.keys(d.stackGroups).reduce(function(v,p){var g=d.stackGroups[p];return ve(ve({},v),{},_r({},p,{numericAxisId:n,cateAxisId:i,items:g.items,stackedData:yM(t,g.items,a)}))},y)}return ve(ve({},l),{},_r({},h,d))},f)},Jx=function(t,r){var n=r.realScaleType,i=r.type,a=r.tickCount,o=r.originalDomain,u=r.allowDecimals,c=n||r.scale;if(c!=="auto"&&c!=="linear")return null;if(a&&i==="number"&&o&&(o[0]==="auto"||o[1]==="auto")){var s=t.domain();if(!s.length)return null;var f=Cj(s,a,u);return t.domain([Va(f),Ga(f)]),{niceTicks:f}}if(a&&i==="number"){var l=t.domain(),h=Ij(l,a,u);return{niceTicks:h}}return null};function Rm(e){var t=e.axis,r=e.ticks,n=e.bandSize,i=e.entry,a=e.index,o=e.dataKey;if(t.type==="category"){if(!t.allowDuplicatedCategory&&t.dataKey&&!Y(i[t.dataKey])){var u=Mi(r,"value",i[t.dataKey]);if(u)return u.coordinate+n/2}return r[a]?r[a].coordinate+n/2:null}var c=_e(i,Y(o)?t.dataKey:o);return Y(c)?null:t.scale(c)}var Dm=function(t){var r=t.axis,n=t.ticks,i=t.offset,a=t.bandSize,o=t.entry,u=t.index;if(r.type==="category")return n[u]?n[u].coordinate+i:null;var c=_e(o,r.dataKey,r.domain[u]);return Y(c)?null:r.scale(c)-a/2+i},gM=function(t){var r=t.numericAxis,n=r.scale.domain();if(r.type==="number"){var i=Math.min(n[0],n[1]),a=Math.max(n[0],n[1]);return i<=0&&a>=0?0:a<0?a:i}return n[0]},bM=function(t,r){var n,i=(n=t.type)!==null&&n!==void 0&&n.defaultProps?ve(ve({},t.type.defaultProps),t.props):t.props,a=i.stackId;if(Ae(a)){var o=r[a];if(o){var u=o.items.indexOf(t);return u>=0?o.stackedData[u]:null}}return null},xM=function(t){return t.reduce(function(r,n){return[Va(n.concat([r[0]]).filter(q)),Ga(n.concat([r[1]]).filter(q))]},[1/0,-1/0])},Qx=function(t,r,n){return Object.keys(t).reduce(function(i,a){var o=t[a],u=o.stackedData,c=u.reduce(function(s,f){var l=xM(f.slice(r,n+1));return[Math.min(s[0],l[0]),Math.max(s[1],l[1])]},[1/0,-1/0]);return[Math.min(c[0],i[0]),Math.max(c[1],i[1])]},[1/0,-1/0]).map(function(i){return i===1/0||i===-1/0?0:i})},Nm=/^dataMin[\s]*-[\s]*([0-9]+([.]{1}[0-9]+){0,1})$/,qm=/^dataMax[\s]*\+[\s]*([0-9]+([.]{1}[0-9]+){0,1})$/,Yl=function(t,r,n){if(X(t))return t(r,n);if(!Array.isArray(t))return r;var i=[];if(q(t[0]))i[0]=n?t[0]:Math.min(t[0],r[0]);else if(Nm.test(t[0])){var a=+Nm.exec(t[0])[1];i[0]=r[0]-a}else X(t[0])?i[0]=t[0](r[0]):i[0]=r[0];if(q(t[1]))i[1]=n?t[1]:Math.max(t[1],r[1]);else if(qm.test(t[1])){var o=+qm.exec(t[1])[1];i[1]=r[1]+o}else X(t[1])?i[1]=t[1](r[1]):i[1]=r[1];return i},ta=function(t,r,n){if(t&&t.scale&&t.scale.bandwidth){var i=t.scale.bandwidth();if(!n||i>0)return i}if(t&&r&&r.length>=2){for(var a=ih(r,function(l){return l.coordinate}),o=1/0,u=1,c=a.length;ue.length)&&(t=e.length);for(var r=0,n=new Array(t);r2&&arguments[2]!==void 0?arguments[2]:{top:0,right:0,bottom:0,left:0};return Math.min(Math.abs(t-(n.left||0)-(n.right||0)),Math.abs(r-(n.top||0)-(n.bottom||0)))/2},jM=function(t,r,n,i,a){var o=t.width,u=t.height,c=t.startAngle,s=t.endAngle,f=Ie(t.cx,o,o/2),l=Ie(t.cy,u,u/2),h=rw(o,u,n),d=Ie(t.innerRadius,h,0),y=Ie(t.outerRadius,h,h*.8),v=Object.keys(r);return v.reduce(function(p,g){var x=r[g],w=x.domain,O=x.reversed,m;if(Y(x.range))i==="angleAxis"?m=[c,s]:i==="radiusAxis"&&(m=[d,y]),O&&(m=[m[1],m[0]]);else{m=x.range;var b=m,_=_M(b,2);c=_[0],s=_[1]}var A=Yx(x,a),T=A.realScaleType,M=A.scale;M.domain(w).range(m),Zx(M);var P=Jx(M,vt(vt({},x),{},{realScaleType:T})),E=vt(vt(vt({},x),P),{},{range:m,radius:y,realScaleType:T,scale:M,cx:f,cy:l,innerRadius:d,outerRadius:y,startAngle:c,endAngle:s});return vt(vt({},p),{},tw({},g,E))},{})},MM=function(t,r){var n=t.x,i=t.y,a=r.x,o=r.y;return Math.sqrt(Math.pow(n-a,2)+Math.pow(i-o,2))},$M=function(t,r){var n=t.x,i=t.y,a=r.cx,o=r.cy,u=MM({x:n,y:i},{x:a,y:o});if(u<=0)return{radius:u};var c=(n-a)/u,s=Math.acos(c);return i>o&&(s=2*Math.PI-s),{radius:u,angle:EM(s),angleInRadian:s}},CM=function(t){var r=t.startAngle,n=t.endAngle,i=Math.floor(r/360),a=Math.floor(n/360),o=Math.min(i,a);return{startAngle:r-o*360,endAngle:n-o*360}},IM=function(t,r){var n=r.startAngle,i=r.endAngle,a=Math.floor(n/360),o=Math.floor(i/360),u=Math.min(a,o);return t+u*360},Wm=function(t,r){var n=t.x,i=t.y,a=$M({x:n,y:i},r),o=a.radius,u=a.angle,c=r.innerRadius,s=r.outerRadius;if(os)return!1;if(o===0)return!0;var f=CM(r),l=f.startAngle,h=f.endAngle,d=u,y;if(l<=h){for(;d>h;)d-=360;for(;d=l&&d<=h}else{for(;d>l;)d-=360;for(;d=h&&d<=l}return y?vt(vt({},r),{},{radius:o,angle:IM(d,r)}):null},nw=function(t){return!N.isValidElement(t)&&!X(t)&&typeof t!="boolean"?t.className:""};function Fn(e){"@babel/helpers - typeof";return Fn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Fn(e)}var kM=["offset"];function RM(e){return LM(e)||qM(e)||NM(e)||DM()}function DM(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function NM(e,t){if(e){if(typeof e=="string")return Zl(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return Zl(e,t)}}function qM(e){if(typeof Symbol<"u"&&e[Symbol.iterator]!=null||e["@@iterator"]!=null)return Array.from(e)}function LM(e){if(Array.isArray(e))return Zl(e)}function Zl(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function FM(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function zm(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function Oe(e){for(var t=1;t=0?1:-1,w,O;i==="insideStart"?(w=d+x*o,O=v):i==="insideEnd"?(w=y-x*o,O=!v):i==="end"&&(w=y+x*o,O=v),O=g<=0?O:!O;var m=le(s,f,p,w),b=le(s,f,p,w+(O?1:-1)*359),_="M".concat(m.x,",").concat(m.y,`
- A`).concat(p,",").concat(p,",0,1,").concat(O?0:1,`,
- `).concat(b.x,",").concat(b.y),A=Y(t.id)?Zr("recharts-radial-line-"):t.id;return S.createElement("text",Wn({},n,{dominantBaseline:"central",className:J("recharts-radial-bar-label",u)}),S.createElement("defs",null,S.createElement("path",{id:A,d:_})),S.createElement("textPath",{xlinkHref:"#".concat(A)},r))},VM=function(t){var r=t.viewBox,n=t.offset,i=t.position,a=r,o=a.cx,u=a.cy,c=a.innerRadius,s=a.outerRadius,f=a.startAngle,l=a.endAngle,h=(f+l)/2;if(i==="outside"){var d=le(o,u,s+n,h),y=d.x,v=d.y;return{x:y,y:v,textAnchor:y>=o?"start":"end",verticalAnchor:"middle"}}if(i==="center")return{x:o,y:u,textAnchor:"middle",verticalAnchor:"middle"};if(i==="centerTop")return{x:o,y:u,textAnchor:"middle",verticalAnchor:"start"};if(i==="centerBottom")return{x:o,y:u,textAnchor:"middle",verticalAnchor:"end"};var p=(c+s)/2,g=le(o,u,p,h),x=g.x,w=g.y;return{x,y:w,textAnchor:"middle",verticalAnchor:"middle"}},XM=function(t){var r=t.viewBox,n=t.parentViewBox,i=t.offset,a=t.position,o=r,u=o.x,c=o.y,s=o.width,f=o.height,l=f>=0?1:-1,h=l*i,d=l>0?"end":"start",y=l>0?"start":"end",v=s>=0?1:-1,p=v*i,g=v>0?"end":"start",x=v>0?"start":"end";if(a==="top"){var w={x:u+s/2,y:c-l*i,textAnchor:"middle",verticalAnchor:d};return Oe(Oe({},w),n?{height:Math.max(c-n.y,0),width:s}:{})}if(a==="bottom"){var O={x:u+s/2,y:c+f+h,textAnchor:"middle",verticalAnchor:y};return Oe(Oe({},O),n?{height:Math.max(n.y+n.height-(c+f),0),width:s}:{})}if(a==="left"){var m={x:u-p,y:c+f/2,textAnchor:g,verticalAnchor:"middle"};return Oe(Oe({},m),n?{width:Math.max(m.x-n.x,0),height:f}:{})}if(a==="right"){var b={x:u+s+p,y:c+f/2,textAnchor:x,verticalAnchor:"middle"};return Oe(Oe({},b),n?{width:Math.max(n.x+n.width-b.x,0),height:f}:{})}var _=n?{width:s,height:f}:{};return a==="insideLeft"?Oe({x:u+p,y:c+f/2,textAnchor:x,verticalAnchor:"middle"},_):a==="insideRight"?Oe({x:u+s-p,y:c+f/2,textAnchor:g,verticalAnchor:"middle"},_):a==="insideTop"?Oe({x:u+s/2,y:c+h,textAnchor:"middle",verticalAnchor:y},_):a==="insideBottom"?Oe({x:u+s/2,y:c+f-h,textAnchor:"middle",verticalAnchor:d},_):a==="insideTopLeft"?Oe({x:u+p,y:c+h,textAnchor:x,verticalAnchor:y},_):a==="insideTopRight"?Oe({x:u+s-p,y:c+h,textAnchor:g,verticalAnchor:y},_):a==="insideBottomLeft"?Oe({x:u+p,y:c+f-h,textAnchor:x,verticalAnchor:d},_):a==="insideBottomRight"?Oe({x:u+s-p,y:c+f-h,textAnchor:g,verticalAnchor:d},_):Yr(a)&&(q(a.x)||Gt(a.x))&&(q(a.y)||Gt(a.y))?Oe({x:u+Ie(a.x,s),y:c+Ie(a.y,f),textAnchor:"end",verticalAnchor:"end"},_):Oe({x:u+s/2,y:c+f/2,textAnchor:"middle",verticalAnchor:"middle"},_)},YM=function(t){return"cx"in t&&q(t.cx)};function Te(e){var t=e.offset,r=t===void 0?5:t,n=BM(e,kM),i=Oe({offset:r},n),a=i.viewBox,o=i.position,u=i.value,c=i.children,s=i.content,f=i.className,l=f===void 0?"":f,h=i.textBreakAll;if(!a||Y(u)&&Y(c)&&!N.isValidElement(s)&&!X(s))return null;if(N.isValidElement(s))return N.cloneElement(s,i);var d;if(X(s)){if(d=N.createElement(s,i),N.isValidElement(d))return d}else d=HM(i);var y=YM(a),v=H(i,!0);if(y&&(o==="insideStart"||o==="insideEnd"||o==="end"))return GM(i,d,v);var p=y?VM(i):XM(i);return S.createElement(rr,Wn({className:J("recharts-label",l)},v,p,{breakAll:h}),d)}Te.displayName="Label";var iw=function(t){var r=t.cx,n=t.cy,i=t.angle,a=t.startAngle,o=t.endAngle,u=t.r,c=t.radius,s=t.innerRadius,f=t.outerRadius,l=t.x,h=t.y,d=t.top,y=t.left,v=t.width,p=t.height,g=t.clockWise,x=t.labelViewBox;if(x)return x;if(q(v)&&q(p)){if(q(l)&&q(h))return{x:l,y:h,width:v,height:p};if(q(d)&&q(y))return{x:d,y,width:v,height:p}}return q(l)&&q(h)?{x:l,y:h,width:0,height:0}:q(r)&&q(n)?{cx:r,cy:n,startAngle:a||i||0,endAngle:o||i||0,innerRadius:s||0,outerRadius:f||c||u||0,clockWise:g}:t.viewBox?t.viewBox:{}},ZM=function(t,r){return t?t===!0?S.createElement(Te,{key:"label-implicit",viewBox:r}):Ae(t)?S.createElement(Te,{key:"label-implicit",viewBox:r,value:t}):N.isValidElement(t)?t.type===Te?N.cloneElement(t,{key:"label-implicit",viewBox:r}):S.createElement(Te,{key:"label-implicit",content:t,viewBox:r}):X(t)?S.createElement(Te,{key:"label-implicit",content:t,viewBox:r}):Yr(t)?S.createElement(Te,Wn({viewBox:r},t,{key:"label-implicit"})):null:null},JM=function(t,r){var n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0;if(!t||!t.children&&n&&!t.label)return null;var i=t.children,a=iw(t),o=Ke(i,Te).map(function(c,s){return N.cloneElement(c,{viewBox:r||a,key:"label-".concat(s)})});if(!n)return o;var u=ZM(t.label,r||a);return[u].concat(RM(o))};Te.parseViewBox=iw;Te.renderCallByParent=JM;var Ls,Um;function QM(){if(Um)return Ls;Um=1;function e(t){var r=t==null?0:t.length;return r?t[r-1]:void 0}return Ls=e,Ls}var e$=QM();const t$=oe(e$);function zn(e){"@babel/helpers - typeof";return zn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},zn(e)}var r$=["valueAccessor"],n$=["data","dataKey","clockWise","id","textBreakAll"];function i$(e){return c$(e)||u$(e)||o$(e)||a$()}function a$(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function o$(e,t){if(e){if(typeof e=="string")return Jl(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return Jl(e,t)}}function u$(e){if(typeof Symbol<"u"&&e[Symbol.iterator]!=null||e["@@iterator"]!=null)return Array.from(e)}function c$(e){if(Array.isArray(e))return Jl(e)}function Jl(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function h$(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}var p$=function(t){return Array.isArray(t.value)?t$(t.value):t.value};function wt(e){var t=e.valueAccessor,r=t===void 0?p$:t,n=Gm(e,r$),i=n.data,a=n.dataKey,o=n.clockWise,u=n.id,c=n.textBreakAll,s=Gm(n,n$);return!i||!i.length?null:S.createElement(te,{className:"recharts-label-list"},i.map(function(f,l){var h=Y(a)?r(f,l):_e(f&&f.payload,a),d=Y(u)?{}:{id:"".concat(u,"-").concat(l)};return S.createElement(Te,na({},H(f,!0),s,d,{parentViewBox:f.parentViewBox,value:h,textBreakAll:c,viewBox:Te.parseViewBox(Y(o)?f:Km(Km({},f),{},{clockWise:o})),key:"label-".concat(l),index:l}))}))}wt.displayName="LabelList";function d$(e,t){return e?e===!0?S.createElement(wt,{key:"labelList-implicit",data:t}):S.isValidElement(e)||X(e)?S.createElement(wt,{key:"labelList-implicit",data:t,content:e}):Yr(e)?S.createElement(wt,na({data:t},e,{key:"labelList-implicit"})):null:null}function v$(e,t){var r=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0;if(!e||!e.children&&r&&!e.label)return null;var n=e.children,i=Ke(n,wt).map(function(o,u){return N.cloneElement(o,{data:t,key:"labelList-".concat(u)})});if(!r)return i;var a=d$(e.label,t);return[a].concat(i$(i))}wt.renderCallByParent=v$;function Un(e){"@babel/helpers - typeof";return Un=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Un(e)}function Ql(){return Ql=Object.assign?Object.assign.bind():function(e){for(var t=1;t180),",").concat(+(o>s),`,
- `).concat(l.x,",").concat(l.y,`
- `);if(i>0){var d=le(r,n,i,o),y=le(r,n,i,s);h+="L ".concat(y.x,",").concat(y.y,`
- A `).concat(i,",").concat(i,`,0,
- `).concat(+(Math.abs(c)>180),",").concat(+(o<=s),`,
- `).concat(d.x,",").concat(d.y," Z")}else h+="L ".concat(r,",").concat(n," Z");return h},x$=function(t){var r=t.cx,n=t.cy,i=t.innerRadius,a=t.outerRadius,o=t.cornerRadius,u=t.forceCornerRadius,c=t.cornerIsExternal,s=t.startAngle,f=t.endAngle,l=Ce(f-s),h=Ai({cx:r,cy:n,radius:a,angle:s,sign:l,cornerRadius:o,cornerIsExternal:c}),d=h.circleTangency,y=h.lineTangency,v=h.theta,p=Ai({cx:r,cy:n,radius:a,angle:f,sign:-l,cornerRadius:o,cornerIsExternal:c}),g=p.circleTangency,x=p.lineTangency,w=p.theta,O=c?Math.abs(s-f):Math.abs(s-f)-v-w;if(O<0)return u?"M ".concat(y.x,",").concat(y.y,`
- a`).concat(o,",").concat(o,",0,0,1,").concat(o*2,`,0
- a`).concat(o,",").concat(o,",0,0,1,").concat(-o*2,`,0
- `):aw({cx:r,cy:n,innerRadius:i,outerRadius:a,startAngle:s,endAngle:f});var m="M ".concat(y.x,",").concat(y.y,`
- A`).concat(o,",").concat(o,",0,0,").concat(+(l<0),",").concat(d.x,",").concat(d.y,`
- A`).concat(a,",").concat(a,",0,").concat(+(O>180),",").concat(+(l<0),",").concat(g.x,",").concat(g.y,`
- A`).concat(o,",").concat(o,",0,0,").concat(+(l<0),",").concat(x.x,",").concat(x.y,`
- `);if(i>0){var b=Ai({cx:r,cy:n,radius:i,angle:s,sign:l,isExternal:!0,cornerRadius:o,cornerIsExternal:c}),_=b.circleTangency,A=b.lineTangency,T=b.theta,M=Ai({cx:r,cy:n,radius:i,angle:f,sign:-l,isExternal:!0,cornerRadius:o,cornerIsExternal:c}),P=M.circleTangency,E=M.lineTangency,j=M.theta,C=c?Math.abs(s-f):Math.abs(s-f)-T-j;if(C<0&&o===0)return"".concat(m,"L").concat(r,",").concat(n,"Z");m+="L".concat(E.x,",").concat(E.y,`
- A`).concat(o,",").concat(o,",0,0,").concat(+(l<0),",").concat(P.x,",").concat(P.y,`
- A`).concat(i,",").concat(i,",0,").concat(+(C>180),",").concat(+(l>0),",").concat(_.x,",").concat(_.y,`
- A`).concat(o,",").concat(o,",0,0,").concat(+(l<0),",").concat(A.x,",").concat(A.y,"Z")}else m+="L".concat(r,",").concat(n,"Z");return m},w$={cx:0,cy:0,innerRadius:0,outerRadius:0,startAngle:0,endAngle:0,cornerRadius:0,forceCornerRadius:!1,cornerIsExternal:!1},ow=function(t){var r=Xm(Xm({},w$),t),n=r.cx,i=r.cy,a=r.innerRadius,o=r.outerRadius,u=r.cornerRadius,c=r.forceCornerRadius,s=r.cornerIsExternal,f=r.startAngle,l=r.endAngle,h=r.className;if(o0&&Math.abs(f-l)<360?p=x$({cx:n,cy:i,innerRadius:a,outerRadius:o,cornerRadius:Math.min(v,y/2),forceCornerRadius:c,cornerIsExternal:s,startAngle:f,endAngle:l}):p=aw({cx:n,cy:i,innerRadius:a,outerRadius:o,startAngle:f,endAngle:l}),S.createElement("path",Ql({},H(r,!0),{className:d,d:p,role:"img"}))};function Hn(e){"@babel/helpers - typeof";return Hn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Hn(e)}function ef(){return ef=Object.assign?Object.assign.bind():function(e){for(var t=1;t0;)if(!r.equals(e[n],t[n],n,n,e,t,r))return!1;return!0}function B$(e,t){return sr(e.getTime(),t.getTime())}function F$(e,t){return e.name===t.name&&e.message===t.message&&e.cause===t.cause&&e.stack===t.stack}function W$(e,t){return e===t}function og(e,t,r){var n=e.size;if(n!==t.size)return!1;if(!n)return!0;for(var i=new Array(n),a=e.entries(),o,u,c=0;(o=a.next())&&!o.done;){for(var s=t.entries(),f=!1,l=0;(u=s.next())&&!u.done;){if(i[l]){l++;continue}var h=o.value,d=u.value;if(r.equals(h[0],d[0],c,l,e,t,r)&&r.equals(h[1],d[1],h[0],d[0],e,t,r)){f=i[l]=!0;break}l++}if(!f)return!1;c++}return!0}var z$=sr;function U$(e,t,r){var n=ag(e),i=n.length;if(ag(t).length!==i)return!1;for(;i-- >0;)if(!uw(e,t,r,n[i]))return!1;return!0}function hn(e,t,r){var n=ng(e),i=n.length;if(ng(t).length!==i)return!1;for(var a,o,u;i-- >0;)if(a=n[i],!uw(e,t,r,a)||(o=ig(e,a),u=ig(t,a),(o||u)&&(!o||!u||o.configurable!==u.configurable||o.enumerable!==u.enumerable||o.writable!==u.writable)))return!1;return!0}function H$(e,t){return sr(e.valueOf(),t.valueOf())}function K$(e,t){return e.source===t.source&&e.flags===t.flags}function ug(e,t,r){var n=e.size;if(n!==t.size)return!1;if(!n)return!0;for(var i=new Array(n),a=e.values(),o,u;(o=a.next())&&!o.done;){for(var c=t.values(),s=!1,f=0;(u=c.next())&&!u.done;){if(!i[f]&&r.equals(o.value,u.value,o.value,u.value,e,t,r)){s=i[f]=!0;break}f++}if(!s)return!1}return!0}function G$(e,t){var r=e.length;if(t.length!==r)return!1;for(;r-- >0;)if(e[r]!==t[r])return!1;return!0}function V$(e,t){return e.hostname===t.hostname&&e.pathname===t.pathname&&e.protocol===t.protocol&&e.port===t.port&&e.hash===t.hash&&e.username===t.username&&e.password===t.password}function uw(e,t,r,n){return(n===q$||n===N$||n===D$)&&(e.$$typeof||t.$$typeof)?!0:R$(t,n)&&r.equals(e[n],t[n],n,n,e,t,r)}var X$="[object Arguments]",Y$="[object Boolean]",Z$="[object Date]",J$="[object Error]",Q$="[object Map]",eC="[object Number]",tC="[object Object]",rC="[object RegExp]",nC="[object Set]",iC="[object String]",aC="[object URL]",oC=Array.isArray,cg=typeof ArrayBuffer<"u"&&typeof ArrayBuffer.isView=="function"?ArrayBuffer.isView:null,sg=Object.assign,uC=Object.prototype.toString.call.bind(Object.prototype.toString);function cC(e){var t=e.areArraysEqual,r=e.areDatesEqual,n=e.areErrorsEqual,i=e.areFunctionsEqual,a=e.areMapsEqual,o=e.areNumbersEqual,u=e.areObjectsEqual,c=e.arePrimitiveWrappersEqual,s=e.areRegExpsEqual,f=e.areSetsEqual,l=e.areTypedArraysEqual,h=e.areUrlsEqual,d=e.unknownTagComparators;return function(v,p,g){if(v===p)return!0;if(v==null||p==null)return!1;var x=typeof v;if(x!==typeof p)return!1;if(x!=="object")return x==="number"?o(v,p,g):x==="function"?i(v,p,g):!1;var w=v.constructor;if(w!==p.constructor)return!1;if(w===Object)return u(v,p,g);if(oC(v))return t(v,p,g);if(cg!=null&&cg(v))return l(v,p,g);if(w===Date)return r(v,p,g);if(w===RegExp)return s(v,p,g);if(w===Map)return a(v,p,g);if(w===Set)return f(v,p,g);var O=uC(v);if(O===Z$)return r(v,p,g);if(O===rC)return s(v,p,g);if(O===Q$)return a(v,p,g);if(O===nC)return f(v,p,g);if(O===tC)return typeof v.then!="function"&&typeof p.then!="function"&&u(v,p,g);if(O===aC)return h(v,p,g);if(O===J$)return n(v,p,g);if(O===X$)return u(v,p,g);if(O===Y$||O===eC||O===iC)return c(v,p,g);if(d){var m=d[O];if(!m){var b=k$(v);b&&(m=d[b])}if(m)return m(v,p,g)}return!1}}function sC(e){var t=e.circular,r=e.createCustomConfig,n=e.strict,i={areArraysEqual:n?hn:L$,areDatesEqual:B$,areErrorsEqual:F$,areFunctionsEqual:W$,areMapsEqual:n?rg(og,hn):og,areNumbersEqual:z$,areObjectsEqual:n?hn:U$,arePrimitiveWrappersEqual:H$,areRegExpsEqual:K$,areSetsEqual:n?rg(ug,hn):ug,areTypedArraysEqual:n?hn:G$,areUrlsEqual:V$,unknownTagComparators:void 0};if(r&&(i=sg({},i,r(i))),t){var a=Pi(i.areArraysEqual),o=Pi(i.areMapsEqual),u=Pi(i.areObjectsEqual),c=Pi(i.areSetsEqual);i=sg({},i,{areArraysEqual:a,areMapsEqual:o,areObjectsEqual:u,areSetsEqual:c})}return i}function lC(e){return function(t,r,n,i,a,o,u){return e(t,r,u)}}function fC(e){var t=e.circular,r=e.comparator,n=e.createState,i=e.equals,a=e.strict;if(n)return function(c,s){var f=n(),l=f.cache,h=l===void 0?t?new WeakMap:void 0:l,d=f.meta;return r(c,s,{cache:h,equals:i,meta:d,strict:a})};if(t)return function(c,s){return r(c,s,{cache:new WeakMap,equals:i,meta:void 0,strict:a})};var o={cache:void 0,equals:i,meta:void 0,strict:a};return function(c,s){return r(c,s,o)}}var hC=Dt();Dt({strict:!0});Dt({circular:!0});Dt({circular:!0,strict:!0});Dt({createInternalComparator:function(){return sr}});Dt({strict:!0,createInternalComparator:function(){return sr}});Dt({circular:!0,createInternalComparator:function(){return sr}});Dt({circular:!0,createInternalComparator:function(){return sr},strict:!0});function Dt(e){e===void 0&&(e={});var t=e.circular,r=t===void 0?!1:t,n=e.createInternalComparator,i=e.createState,a=e.strict,o=a===void 0?!1:a,u=sC(e),c=cC(u),s=n?n(c):lC(c);return fC({circular:r,comparator:c,createState:i,equals:s,strict:o})}function pC(e){typeof requestAnimationFrame<"u"&&requestAnimationFrame(e)}function lg(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,r=-1,n=function i(a){r<0&&(r=a),a-r>t?(e(a),r=-1):pC(i)};requestAnimationFrame(n)}function tf(e){"@babel/helpers - typeof";return tf=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},tf(e)}function dC(e){return gC(e)||mC(e)||yC(e)||vC()}function vC(){throw new TypeError(`Invalid attempt to destructure non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function yC(e,t){if(e){if(typeof e=="string")return fg(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return fg(e,t)}}function fg(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);re.length)&&(t=e.length);for(var r=0,n=new Array(t);r1?1:g<0?0:g},v=function(g){for(var x=g>1?1:g,w=x,O=0;O<8;++O){var m=l(w)-x,b=d(w);if(Math.abs(m-x)0&&arguments[0]!==void 0?arguments[0]:{},r=t.stiff,n=r===void 0?100:r,i=t.damping,a=i===void 0?8:i,o=t.dt,u=o===void 0?17:o,c=function(f,l,h){var d=-(f-l)*n,y=h*a,v=h+(d-y)*u/1e3,p=h*u/1e3+f;return Math.abs(p-l)e.length)&&(t=e.length);for(var r=0,n=new Array(t);r=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function XC(e,t){if(e==null)return{};var r={},n=Object.keys(e),i,a;for(a=0;a=0)&&(r[i]=e[i]);return r}function zs(e){return QC(e)||JC(e)||ZC(e)||YC()}function YC(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function ZC(e,t){if(e){if(typeof e=="string")return uf(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return uf(e,t)}}function JC(e){if(typeof Symbol<"u"&&e[Symbol.iterator]!=null||e["@@iterator"]!=null)return Array.from(e)}function QC(e){if(Array.isArray(e))return uf(e)}function uf(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r"u"||!Reflect.construct||Reflect.construct.sham)return!1;if(typeof Proxy=="function")return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){})),!0}catch{return!1}}function ua(e){return ua=Object.setPrototypeOf?Object.getPrototypeOf.bind():function(r){return r.__proto__||Object.getPrototypeOf(r)},ua(e)}var lt=(function(e){iI(r,e);var t=aI(r);function r(n,i){var a;eI(this,r),a=t.call(this,n,i);var o=a.props,u=o.isActive,c=o.attributeName,s=o.from,f=o.to,l=o.steps,h=o.children,d=o.duration;if(a.handleStyleChange=a.handleStyleChange.bind(lf(a)),a.changeStyle=a.changeStyle.bind(lf(a)),!u||d<=0)return a.state={style:{}},typeof h=="function"&&(a.state={style:f}),sf(a);if(l&&l.length)a.state={style:l[0].style};else if(s){if(typeof h=="function")return a.state={style:s},sf(a);a.state={style:c?yn({},c,s):s}}else a.state={style:{}};return a}return rI(r,[{key:"componentDidMount",value:function(){var i=this.props,a=i.isActive,o=i.canBegin;this.mounted=!0,!(!a||!o)&&this.runAnimation(this.props)}},{key:"componentDidUpdate",value:function(i){var a=this.props,o=a.isActive,u=a.canBegin,c=a.attributeName,s=a.shouldReAnimate,f=a.to,l=a.from,h=this.state.style;if(u){if(!o){var d={style:c?yn({},c,f):f};this.state&&h&&(c&&h[c]!==f||!c&&h!==f)&&this.setState(d);return}if(!(hC(i.to,f)&&i.canBegin&&i.isActive)){var y=!i.canBegin||!i.isActive;this.manager&&this.manager.stop(),this.stopJSAnimation&&this.stopJSAnimation();var v=y||s?l:i.to;if(this.state&&h){var p={style:c?yn({},c,v):v};(c&&h[c]!==v||!c&&h!==v)&&this.setState(p)}this.runAnimation(et(et({},this.props),{},{from:v,begin:0}))}}}},{key:"componentWillUnmount",value:function(){this.mounted=!1;var i=this.props.onAnimationEnd;this.unSubscribe&&this.unSubscribe(),this.manager&&(this.manager.stop(),this.manager=null),this.stopJSAnimation&&this.stopJSAnimation(),i&&i()}},{key:"handleStyleChange",value:function(i){this.changeStyle(i)}},{key:"changeStyle",value:function(i){this.mounted&&this.setState({style:i})}},{key:"runJSAnimation",value:function(i){var a=this,o=i.from,u=i.to,c=i.duration,s=i.easing,f=i.begin,l=i.onAnimationEnd,h=i.onAnimationStart,d=KC(o,u,RC(s),c,this.changeStyle),y=function(){a.stopJSAnimation=d()};this.manager.start([h,f,y,c,l])}},{key:"runStepAnimation",value:function(i){var a=this,o=i.steps,u=i.begin,c=i.onAnimationStart,s=o[0],f=s.style,l=s.duration,h=l===void 0?0:l,d=function(v,p,g){if(g===0)return v;var x=p.duration,w=p.easing,O=w===void 0?"ease":w,m=p.style,b=p.properties,_=p.onAnimationEnd,A=g>0?o[g-1]:p,T=b||Object.keys(m);if(typeof O=="function"||O==="spring")return[].concat(zs(v),[a.runJSAnimation.bind(a,{from:A.style,to:m,duration:x,easing:O}),x]);var M=dg(T,x,O),P=et(et(et({},A.style),m),{},{transition:M});return[].concat(zs(v),[P,x,_]).filter(_C)};return this.manager.start([c].concat(zs(o.reduce(d,[f,Math.max(h,u)])),[i.onAnimationEnd]))}},{key:"runAnimation",value:function(i){this.manager||(this.manager=bC());var a=i.begin,o=i.duration,u=i.attributeName,c=i.to,s=i.easing,f=i.onAnimationStart,l=i.onAnimationEnd,h=i.steps,d=i.children,y=this.manager;if(this.unSubscribe=y.subscribe(this.handleStyleChange),typeof s=="function"||typeof d=="function"||s==="spring"){this.runJSAnimation(i);return}if(h.length>1){this.runStepAnimation(i);return}var v=u?yn({},u,c):c,p=dg(Object.keys(v),o,s);y.start([f,a,et(et({},v),{},{transition:p}),o,l])}},{key:"render",value:function(){var i=this.props,a=i.children;i.begin;var o=i.duration;i.attributeName,i.easing;var u=i.isActive;i.steps,i.from,i.to,i.canBegin,i.onAnimationEnd,i.shouldReAnimate,i.onAnimationReStart;var c=VC(i,GC),s=N.Children.count(a),f=this.state.style;if(typeof a=="function")return a(f);if(!u||s===0||o<=0)return a;var l=function(d){var y=d.props,v=y.style,p=v===void 0?{}:v,g=y.className,x=N.cloneElement(d,et(et({},c),{},{style:et(et({},p),f),className:g}));return x};return s===1?l(N.Children.only(a)):S.createElement("div",null,N.Children.map(a,function(h){return l(h)}))}}]),r})(N.PureComponent);lt.displayName="Animate";lt.defaultProps={begin:0,duration:1e3,from:"",to:"",attributeName:"",easing:"ease",isActive:!0,canBegin:!0,steps:[],onAnimationEnd:function(){},onAnimationStart:function(){}};lt.propTypes={from:ie.oneOfType([ie.object,ie.string]),to:ie.oneOfType([ie.object,ie.string]),attributeName:ie.string,duration:ie.number,begin:ie.number,easing:ie.oneOfType([ie.string,ie.func]),steps:ie.arrayOf(ie.shape({duration:ie.number.isRequired,style:ie.object.isRequired,easing:ie.oneOfType([ie.oneOf(["ease","ease-in","ease-out","ease-in-out","linear"]),ie.func]),properties:ie.arrayOf("string"),onAnimationEnd:ie.func})),children:ie.oneOfType([ie.node,ie.func]),isActive:ie.bool,canBegin:ie.bool,onAnimationEnd:ie.func,shouldReAnimate:ie.bool,onAnimationStart:ie.func,onAnimationReStart:ie.func};function xg(){return xg=Object.assign?Object.assign.bind():function(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,n=new Array(t);r=0?1:-1,c=n>=0?1:-1,s=i>=0&&n>=0||i<0&&n<0?1:0,f;if(o>0&&a instanceof Array){for(var l=[0,0,0,0],h=0,d=4;ho?o:a[h];f="M".concat(t,",").concat(r+u*l[0]),l[0]>0&&(f+="A ".concat(l[0],",").concat(l[0],",0,0,").concat(s,",").concat(t+c*l[0],",").concat(r)),f+="L ".concat(t+n-c*l[1],",").concat(r),l[1]>0&&(f+="A ".concat(l[1],",").concat(l[1],",0,0,").concat(s,`,
- `).concat(t+n,",").concat(r+u*l[1])),f+="L ".concat(t+n,",").concat(r+i-u*l[2]),l[2]>0&&(f+="A ".concat(l[2],",").concat(l[2],",0,0,").concat(s,`,
- `).concat(t+n-c*l[2],",").concat(r+i)),f+="L ".concat(t+c*l[3],",").concat(r+i),l[3]>0&&(f+="A ".concat(l[3],",").concat(l[3],",0,0,").concat(s,`,
- `).concat(t,",").concat(r+i-u*l[3])),f+="Z"}else if(o>0&&a===+a&&a>0){var y=Math.min(o,a);f="M ".concat(t,",").concat(r+u*y,`
- A `).concat(y,",").concat(y,",0,0,").concat(s,",").concat(t+c*y,",").concat(r,`
- L `).concat(t+n-c*y,",").concat(r,`
- A `).concat(y,",").concat(y,",0,0,").concat(s,",").concat(t+n,",").concat(r+u*y,`
- L `).concat(t+n,",").concat(r+i-u*y,`
- A `).concat(y,",").concat(y,",0,0,").concat(s,",").concat(t+n-c*y,",").concat(r+i,`
- L `).concat(t+c*y,",").concat(r+i,`
- A `).concat(y,",").concat(y,",0,0,").concat(s,",").concat(t,",").concat(r+i-u*y," Z")}else f="M ".concat(t,",").concat(r," h ").concat(n," v ").concat(i," h ").concat(-n," Z");return f},vI=function(t,r){if(!t||!r)return!1;var n=t.x,i=t.y,a=r.x,o=r.y,u=r.width,c=r.height;if(Math.abs(u)>0&&Math.abs(c)>0){var s=Math.min(a,a+u),f=Math.max(a,a+u),l=Math.min(o,o+c),h=Math.max(o,o+c);return n>=s&&n<=f&&i>=l&&i<=h}return!1},yI={x:0,y:0,width:0,height:0,radius:0,isAnimationActive:!1,isUpdateAnimationActive:!1,animationBegin:0,animationDuration:1500,animationEasing:"ease"},Ch=function(t){var r=_g(_g({},yI),t),n=N.useRef(),i=N.useState(-1),a=uI(i,2),o=a[0],u=a[1];N.useEffect(function(){if(n.current&&n.current.getTotalLength)try{var O=n.current.getTotalLength();O&&u(O)}catch{}},[]);var c=r.x,s=r.y,f=r.width,l=r.height,h=r.radius,d=r.className,y=r.animationEasing,v=r.animationDuration,p=r.animationBegin,g=r.isAnimationActive,x=r.isUpdateAnimationActive;if(c!==+c||s!==+s||f!==+f||l!==+l||f===0||l===0)return null;var w=J("recharts-rectangle",d);return x?S.createElement(lt,{canBegin:o>0,from:{width:f,height:l,x:c,y:s},to:{width:f,height:l,x:c,y:s},duration:v,animationEasing:y,isActive:x},function(O){var m=O.width,b=O.height,_=O.x,A=O.y;return S.createElement(lt,{canBegin:o>0,from:"0px ".concat(o===-1?1:o,"px"),to:"".concat(o,"px 0px"),attributeName:"strokeDasharray",begin:p,duration:v,isActive:g,easing:y},S.createElement("path",ca({},H(r,!0),{className:w,d:Ag(_,A,m,b,h),ref:n})))}):S.createElement("path",ca({},H(r,!0),{className:w,d:Ag(c,s,f,l,h)}))},mI=["points","className","baseLinePoints","connectNulls"];function yr(){return yr=Object.assign?Object.assign.bind():function(e){for(var t=1;t=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function bI(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function Sg(e){return _I(e)||OI(e)||wI(e)||xI()}function xI(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function wI(e,t){if(e){if(typeof e=="string")return ff(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return ff(e,t)}}function OI(e){if(typeof Symbol<"u"&&e[Symbol.iterator]!=null||e["@@iterator"]!=null)return Array.from(e)}function _I(e){if(Array.isArray(e))return ff(e)}function ff(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r0&&arguments[0]!==void 0?arguments[0]:[],r=[[]];return t.forEach(function(n){Pg(n)?r[r.length-1].push(n):r[r.length-1].length>0&&r.push([])}),Pg(t[0])&&r[r.length-1].push(t[0]),r[r.length-1].length<=0&&(r=r.slice(0,-1)),r},wn=function(t,r){var n=AI(t);r&&(n=[n.reduce(function(a,o){return[].concat(Sg(a),Sg(o))},[])]);var i=n.map(function(a){return a.reduce(function(o,u,c){return"".concat(o).concat(c===0?"M":"L").concat(u.x,",").concat(u.y)},"")}).join("");return n.length===1?"".concat(i,"Z"):i},SI=function(t,r,n){var i=wn(t,n);return"".concat(i.slice(-1)==="Z"?i.slice(0,-1):i,"L").concat(wn(r.reverse(),n).slice(1))},PI=function(t){var r=t.points,n=t.className,i=t.baseLinePoints,a=t.connectNulls,o=gI(t,mI);if(!r||!r.length)return null;var u=J("recharts-polygon",n);if(i&&i.length){var c=o.stroke&&o.stroke!=="none",s=SI(r,i,a);return S.createElement("g",{className:u},S.createElement("path",yr({},H(o,!0),{fill:s.slice(-1)==="Z"?o.fill:"none",stroke:"none",d:s})),c?S.createElement("path",yr({},H(o,!0),{fill:"none",d:wn(r,a)})):null,c?S.createElement("path",yr({},H(o,!0),{fill:"none",d:wn(i,a)})):null)}var f=wn(r,a);return S.createElement("path",yr({},H(o,!0),{fill:f.slice(-1)==="Z"?o.fill:"none",className:u,d:f}))};function hf(){return hf=Object.assign?Object.assign.bind():function(e){for(var t=1;t=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function II(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}var kI=function(t,r,n,i,a,o){return"M".concat(t,",").concat(a,"v").concat(i,"M").concat(o,",").concat(r,"h").concat(n)},RI=function(t){var r=t.x,n=r===void 0?0:r,i=t.y,a=i===void 0?0:i,o=t.top,u=o===void 0?0:o,c=t.left,s=c===void 0?0:c,f=t.width,l=f===void 0?0:f,h=t.height,d=h===void 0?0:h,y=t.className,v=CI(t,TI),p=EI({x:n,y:a,top:u,left:s,width:l,height:d},v);return!q(n)||!q(a)||!q(l)||!q(d)||!q(u)||!q(s)?null:S.createElement("path",pf({},H(p,!0),{className:J("recharts-cross",y),d:kI(n,a,l,d,u,s)}))},Us,Eg;function DI(){if(Eg)return Us;Eg=1;var e=Ka(),t=Ex(),r=ht();function n(i,a){return i&&i.length?e(i,r(a,2),t):void 0}return Us=n,Us}var NI=DI();const qI=oe(NI);var Hs,jg;function LI(){if(jg)return Hs;jg=1;var e=Ka(),t=ht(),r=jx();function n(i,a){return i&&i.length?e(i,t(a,2),r):void 0}return Hs=n,Hs}var BI=LI();const FI=oe(BI);var WI=["cx","cy","angle","ticks","axisLine"],zI=["ticks","tick","angle","tickFormatter","stroke"];function kr(e){"@babel/helpers - typeof";return kr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},kr(e)}function On(){return On=Object.assign?Object.assign.bind():function(e){for(var t=1;t=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function UI(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function HI(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function Cg(e,t){for(var r=0;rRg?o=i==="outer"?"start":"end":a<-Rg?o=i==="outer"?"end":"start":o="middle",o}},{key:"renderAxisLine",value:function(){var n=this.props,i=n.cx,a=n.cy,o=n.radius,u=n.axisLine,c=n.axisLineType,s=zt(zt({},H(this.props,!1)),{},{fill:"none"},H(u,!1));if(c==="circle")return S.createElement(Za,Kt({className:"recharts-polar-angle-axis-line"},s,{cx:i,cy:a,r:o}));var f=this.props.ticks,l=f.map(function(h){return le(i,a,o,h.coordinate)});return S.createElement(PI,Kt({className:"recharts-polar-angle-axis-line"},s,{points:l}))}},{key:"renderTicks",value:function(){var n=this,i=this.props,a=i.ticks,o=i.tick,u=i.tickLine,c=i.tickFormatter,s=i.stroke,f=H(this.props,!1),l=H(o,!1),h=zt(zt({},f),{},{fill:"none"},H(u,!1)),d=a.map(function(y,v){var p=n.getTickLineCoord(y),g=n.getTickTextAnchor(y),x=zt(zt(zt({textAnchor:g},f),{},{stroke:"none",fill:s},l),{},{index:v,payload:y,x:p.x2,y:p.y2});return S.createElement(te,Kt({className:J("recharts-polar-angle-axis-tick",nw(o)),key:"tick-".concat(y.coordinate)},tr(n.props,y,v)),u&&S.createElement("line",Kt({className:"recharts-polar-angle-axis-tick-line"},h,p)),o&&t.renderTickItem(o,x,c?c(y.value,v):y.value))});return S.createElement(te,{className:"recharts-polar-angle-axis-ticks"},d)}},{key:"render",value:function(){var n=this.props,i=n.ticks,a=n.radius,o=n.axisLine;return a<=0||!i||!i.length?null:S.createElement(te,{className:J("recharts-polar-angle-axis",this.props.className)},o&&this.renderAxisLine(),this.renderTicks())}}],[{key:"renderTickItem",value:function(n,i,a){var o;return S.isValidElement(n)?o=S.cloneElement(n,i):X(n)?o=n(i):o=S.createElement(rr,Kt({},i,{className:"recharts-polar-angle-axis-tick-value"}),a),o}}])})(N.PureComponent);eo(to,"displayName","PolarAngleAxis");eo(to,"axisType","angleAxis");eo(to,"defaultProps",{type:"category",angleAxisId:0,scale:"auto",cx:0,cy:0,orientation:"outer",axisLine:!0,tickLine:!0,tickSize:8,tick:!0,hide:!1,allowDuplicatedCategory:!0});var Ks,Dg;function ok(){if(Dg)return Ks;Dg=1;var e=T0(),t=e(Object.getPrototypeOf,Object);return Ks=t,Ks}var Gs,Ng;function uk(){if(Ng)return Gs;Ng=1;var e=St(),t=ok(),r=Pt(),n="[object Object]",i=Function.prototype,a=Object.prototype,o=i.toString,u=a.hasOwnProperty,c=o.call(Object);function s(f){if(!r(f)||e(f)!=n)return!1;var l=t(f);if(l===null)return!0;var h=u.call(l,"constructor")&&l.constructor;return typeof h=="function"&&h instanceof h&&o.call(h)==c}return Gs=s,Gs}var ck=uk();const sk=oe(ck);var Vs,qg;function lk(){if(qg)return Vs;qg=1;var e=St(),t=Pt(),r="[object Boolean]";function n(i){return i===!0||i===!1||t(i)&&e(i)==r}return Vs=n,Vs}var fk=lk();const hk=oe(fk);function Yn(e){"@babel/helpers - typeof";return Yn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Yn(e)}function fa(){return fa=Object.assign?Object.assign.bind():function(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,n=new Array(t);r0,from:{upperWidth:0,lowerWidth:0,height:h,x:c,y:s},to:{upperWidth:f,lowerWidth:l,height:h,x:c,y:s},duration:v,animationEasing:y,isActive:g},function(w){var O=w.upperWidth,m=w.lowerWidth,b=w.height,_=w.x,A=w.y;return S.createElement(lt,{canBegin:o>0,from:"0px ".concat(o===-1?1:o,"px"),to:"".concat(o,"px 0px"),attributeName:"strokeDasharray",begin:p,duration:v,easing:y},S.createElement("path",fa({},H(r,!0),{className:x,d:Wg(_,A,O,m,b),ref:n})))}):S.createElement("g",null,S.createElement("path",fa({},H(r,!0),{className:x,d:Wg(c,s,f,l,h)})))},_k=["option","shapeType","propTransformer","activeClassName","isActive"];function Zn(e){"@babel/helpers - typeof";return Zn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Zn(e)}function Ak(e,t){if(e==null)return{};var r=Sk(e,t),n,i;if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(i=0;i=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function Sk(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function zg(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function ha(e){for(var t=1;t0?He(w,"paddingAngle",0):0;if(m){var _=ze(m.endAngle-m.startAngle,w.endAngle-w.startAngle),A=ce(ce({},w),{},{startAngle:x+b,endAngle:x+_(v)+b});p.push(A),x=A.endAngle}else{var T=w.endAngle,M=w.startAngle,P=ze(0,T-M),E=P(v),j=ce(ce({},w),{},{startAngle:x+b,endAngle:x+E+b});p.push(j),x=j.endAngle}}),S.createElement(te,null,n.renderSectorsStatically(p))})}},{key:"attachKeyboardHandlers",value:function(n){var i=this;n.onkeydown=function(a){if(!a.altKey)switch(a.key){case"ArrowLeft":{var o=++i.state.sectorToFocus%i.sectorRefs.length;i.sectorRefs[o].focus(),i.setState({sectorToFocus:o});break}case"ArrowRight":{var u=--i.state.sectorToFocus<0?i.sectorRefs.length-1:i.state.sectorToFocus%i.sectorRefs.length;i.sectorRefs[u].focus(),i.setState({sectorToFocus:u});break}case"Escape":{i.sectorRefs[i.state.sectorToFocus].blur(),i.setState({sectorToFocus:0});break}}}}},{key:"renderSectors",value:function(){var n=this.props,i=n.sectors,a=n.isAnimationActive,o=this.state.prevSectors;return a&&i&&i.length&&(!o||!hi(o,i))?this.renderSectorsWithAnimation():this.renderSectorsStatically(i)}},{key:"componentDidMount",value:function(){this.pieRef&&this.attachKeyboardHandlers(this.pieRef)}},{key:"render",value:function(){var n=this,i=this.props,a=i.hide,o=i.sectors,u=i.className,c=i.label,s=i.cx,f=i.cy,l=i.innerRadius,h=i.outerRadius,d=i.isAnimationActive,y=this.state.isAnimationFinished;if(a||!o||!o.length||!q(s)||!q(f)||!q(l)||!q(h))return null;var v=J("recharts-pie",u);return S.createElement(te,{tabIndex:this.props.rootTabIndex,className:v,ref:function(g){n.pieRef=g}},this.renderSectors(),c&&this.renderLabels(o),Te.renderCallByParent(this.props,null,!1),(!d||y)&&wt.renderCallByParent(this.props,o,!1))}}],[{key:"getDerivedStateFromProps",value:function(n,i){return i.prevIsAnimationActive!==n.isAnimationActive?{prevIsAnimationActive:n.isAnimationActive,prevAnimationId:n.animationId,curSectors:n.sectors,prevSectors:[],isAnimationFinished:!0}:n.isAnimationActive&&n.animationId!==i.prevAnimationId?{prevAnimationId:n.animationId,curSectors:n.sectors,prevSectors:i.curSectors,isAnimationFinished:!0}:n.sectors!==i.curSectors?{curSectors:n.sectors,isAnimationFinished:!0}:null}},{key:"getTextAnchor",value:function(n,i){return n>i?"start":n=360?x:x-1)*c,O=p-x*d-w,m=i.reduce(function(A,T){var M=_e(T,g,0);return A+(q(M)?M:0)},0),b;if(m>0){var _;b=i.map(function(A,T){var M=_e(A,g,0),P=_e(A,f,T),E=(q(M)?M:0)/m,j;T?j=_.endAngle+Ce(v)*c*(M!==0?1:0):j=o;var C=j+Ce(v)*((M!==0?d:0)+E*O),$=(j+C)/2,k=(y.innerRadius+y.outerRadius)/2,R=[{name:P,value:M,payload:A,dataKey:g,type:h}],L=le(y.cx,y.cy,k,$);return _=ce(ce(ce({percent:E,cornerRadius:a,name:P,tooltipPayload:R,midAngle:$,middleRadius:k,tooltipPosition:L},A),y),{},{value:_e(A,g),startAngle:j,endAngle:C,payload:A,paddingAngle:Ce(v)*c}),_})}return ce(ce({},y),{},{sectors:b,data:i})});var Xs,Gg;function Kk(){if(Gg)return Xs;Gg=1;var e=Math.ceil,t=Math.max;function r(n,i,a,o){for(var u=-1,c=t(e((i-n)/(a||1)),0),s=Array(c);c--;)s[o?c:++u]=n,n+=a;return s}return Xs=r,Xs}var Ys,Vg;function ww(){if(Vg)return Ys;Vg=1;var e=z0(),t=1/0,r=17976931348623157e292;function n(i){if(!i)return i===0?i:0;if(i=e(i),i===t||i===-t){var a=i<0?-1:1;return a*r}return i===i?i:0}return Ys=n,Ys}var Zs,Xg;function Gk(){if(Xg)return Zs;Xg=1;var e=Kk(),t=La(),r=ww();function n(i){return function(a,o,u){return u&&typeof u!="number"&&t(a,o,u)&&(o=u=void 0),a=r(a),o===void 0?(o=a,a=0):o=r(o),u=u===void 0?a0&&n.handleDrag(i.changedTouches[0])}),Fe(n,"handleDragEnd",function(){n.setState({isTravellerMoving:!1,isSlideMoving:!1},function(){var i=n.props,a=i.endIndex,o=i.onDragEnd,u=i.startIndex;o?.({endIndex:a,startIndex:u})}),n.detachDragEndListener()}),Fe(n,"handleLeaveWrapper",function(){(n.state.isTravellerMoving||n.state.isSlideMoving)&&(n.leaveTimer=window.setTimeout(n.handleDragEnd,n.props.leaveTimeOut))}),Fe(n,"handleEnterSlideOrTraveller",function(){n.setState({isTextActive:!0})}),Fe(n,"handleLeaveSlideOrTraveller",function(){n.setState({isTextActive:!1})}),Fe(n,"handleSlideDragStart",function(i){var a=tb(i)?i.changedTouches[0]:i;n.setState({isTravellerMoving:!1,isSlideMoving:!0,slideMoveStartX:a.pageX}),n.attachDragEndListener()}),n.travellerDragStartHandlers={startX:n.handleTravellerDragStart.bind(n,"startX"),endX:n.handleTravellerDragStart.bind(n,"endX")},n.state={},n}return aR(t,e),tR(t,[{key:"componentWillUnmount",value:function(){this.leaveTimer&&(clearTimeout(this.leaveTimer),this.leaveTimer=null),this.detachDragEndListener()}},{key:"getIndex",value:function(n){var i=n.startX,a=n.endX,o=this.state.scaleValues,u=this.props,c=u.gap,s=u.data,f=s.length-1,l=Math.min(i,a),h=Math.max(i,a),d=t.getIndexInRange(o,l),y=t.getIndexInRange(o,h);return{startIndex:d-d%c,endIndex:y===f?f:y-y%c}}},{key:"getTextOfTick",value:function(n){var i=this.props,a=i.data,o=i.tickFormatter,u=i.dataKey,c=_e(a[n],u,n);return X(o)?o(c,n):c}},{key:"attachDragEndListener",value:function(){window.addEventListener("mouseup",this.handleDragEnd,!0),window.addEventListener("touchend",this.handleDragEnd,!0),window.addEventListener("mousemove",this.handleDrag,!0)}},{key:"detachDragEndListener",value:function(){window.removeEventListener("mouseup",this.handleDragEnd,!0),window.removeEventListener("touchend",this.handleDragEnd,!0),window.removeEventListener("mousemove",this.handleDrag,!0)}},{key:"handleSlideDrag",value:function(n){var i=this.state,a=i.slideMoveStartX,o=i.startX,u=i.endX,c=this.props,s=c.x,f=c.width,l=c.travellerWidth,h=c.startIndex,d=c.endIndex,y=c.onChange,v=n.pageX-a;v>0?v=Math.min(v,s+f-l-u,s+f-l-o):v<0&&(v=Math.max(v,s-o,s-u));var p=this.getIndex({startX:o+v,endX:u+v});(p.startIndex!==h||p.endIndex!==d)&&y&&y(p),this.setState({startX:o+v,endX:u+v,slideMoveStartX:n.pageX})}},{key:"handleTravellerDragStart",value:function(n,i){var a=tb(i)?i.changedTouches[0]:i;this.setState({isSlideMoving:!1,isTravellerMoving:!0,movingTravellerId:n,brushMoveStartX:a.pageX}),this.attachDragEndListener()}},{key:"handleTravellerMove",value:function(n){var i=this.state,a=i.brushMoveStartX,o=i.movingTravellerId,u=i.endX,c=i.startX,s=this.state[o],f=this.props,l=f.x,h=f.width,d=f.travellerWidth,y=f.onChange,v=f.gap,p=f.data,g={startX:this.state.startX,endX:this.state.endX},x=n.pageX-a;x>0?x=Math.min(x,l+h-d-s):x<0&&(x=Math.max(x,l-s)),g[o]=s+x;var w=this.getIndex(g),O=w.startIndex,m=w.endIndex,b=function(){var A=p.length-1;return o==="startX"&&(u>c?O%v===0:m%v===0)||uc?m%v===0:O%v===0)||u>c&&m===A};this.setState(Fe(Fe({},o,s+x),"brushMoveStartX",n.pageX),function(){y&&b()&&y(w)})}},{key:"handleTravellerMoveKeyboard",value:function(n,i){var a=this,o=this.state,u=o.scaleValues,c=o.startX,s=o.endX,f=this.state[i],l=u.indexOf(f);if(l!==-1){var h=l+n;if(!(h===-1||h>=u.length)){var d=u[h];i==="startX"&&d>=s||i==="endX"&&d<=c||this.setState(Fe({},i,d),function(){a.props.onChange(a.getIndex({startX:a.state.startX,endX:a.state.endX}))})}}}},{key:"renderBackground",value:function(){var n=this.props,i=n.x,a=n.y,o=n.width,u=n.height,c=n.fill,s=n.stroke;return S.createElement("rect",{stroke:s,fill:c,x:i,y:a,width:o,height:u})}},{key:"renderPanorama",value:function(){var n=this.props,i=n.x,a=n.y,o=n.width,u=n.height,c=n.data,s=n.children,f=n.padding,l=N.Children.only(s);return l?S.cloneElement(l,{x:i,y:a,width:o,height:u,margin:f,compact:!0,data:c}):null}},{key:"renderTravellerLayer",value:function(n,i){var a,o,u=this,c=this.props,s=c.y,f=c.travellerWidth,l=c.height,h=c.traveller,d=c.ariaLabel,y=c.data,v=c.startIndex,p=c.endIndex,g=Math.max(n,this.props.x),x=Qs(Qs({},H(this.props,!1)),{},{x:g,y:s,width:f,height:l}),w=d||"Min value: ".concat((a=y[v])===null||a===void 0?void 0:a.name,", Max value: ").concat((o=y[p])===null||o===void 0?void 0:o.name);return S.createElement(te,{tabIndex:0,role:"slider","aria-label":w,"aria-valuenow":n,className:"recharts-brush-traveller",onMouseEnter:this.handleEnterSlideOrTraveller,onMouseLeave:this.handleLeaveSlideOrTraveller,onMouseDown:this.travellerDragStartHandlers[i],onTouchStart:this.travellerDragStartHandlers[i],onKeyDown:function(m){["ArrowLeft","ArrowRight"].includes(m.key)&&(m.preventDefault(),m.stopPropagation(),u.handleTravellerMoveKeyboard(m.key==="ArrowRight"?1:-1,i))},onFocus:function(){u.setState({isTravellerFocused:!0})},onBlur:function(){u.setState({isTravellerFocused:!1})},style:{cursor:"col-resize"}},t.renderTraveller(h,x))}},{key:"renderSlide",value:function(n,i){var a=this.props,o=a.y,u=a.height,c=a.stroke,s=a.travellerWidth,f=Math.min(n,i)+s,l=Math.max(Math.abs(i-n)-s,0);return S.createElement("rect",{className:"recharts-brush-slide",onMouseEnter:this.handleEnterSlideOrTraveller,onMouseLeave:this.handleLeaveSlideOrTraveller,onMouseDown:this.handleSlideDragStart,onTouchStart:this.handleSlideDragStart,style:{cursor:"move"},stroke:"none",fill:c,fillOpacity:.2,x:f,y:o,width:l,height:u})}},{key:"renderText",value:function(){var n=this.props,i=n.startIndex,a=n.endIndex,o=n.y,u=n.height,c=n.travellerWidth,s=n.stroke,f=this.state,l=f.startX,h=f.endX,d=5,y={pointerEvents:"none",fill:s};return S.createElement(te,{className:"recharts-brush-texts"},S.createElement(rr,va({textAnchor:"end",verticalAnchor:"middle",x:Math.min(l,h)-d,y:o+u/2},y),this.getTextOfTick(i)),S.createElement(rr,va({textAnchor:"start",verticalAnchor:"middle",x:Math.max(l,h)+c+d,y:o+u/2},y),this.getTextOfTick(a)))}},{key:"render",value:function(){var n=this.props,i=n.data,a=n.className,o=n.children,u=n.x,c=n.y,s=n.width,f=n.height,l=n.alwaysShowText,h=this.state,d=h.startX,y=h.endX,v=h.isTextActive,p=h.isSlideMoving,g=h.isTravellerMoving,x=h.isTravellerFocused;if(!i||!i.length||!q(u)||!q(c)||!q(s)||!q(f)||s<=0||f<=0)return null;var w=J("recharts-brush",a),O=S.Children.count(o)===1,m=Qk("userSelect","none");return S.createElement(te,{className:w,onMouseLeave:this.handleLeaveWrapper,onTouchMove:this.handleTouchMove,style:m},this.renderBackground(),O&&this.renderPanorama(),this.renderSlide(d,y),this.renderTravellerLayer(d,"startX"),this.renderTravellerLayer(y,"endX"),(v||p||g||x||l)&&this.renderText())}}],[{key:"renderDefaultTraveller",value:function(n){var i=n.x,a=n.y,o=n.width,u=n.height,c=n.stroke,s=Math.floor(a+u/2)-1;return S.createElement(S.Fragment,null,S.createElement("rect",{x:i,y:a,width:o,height:u,fill:c,stroke:"none"}),S.createElement("line",{x1:i+1,y1:s,x2:i+o-1,y2:s,fill:"none",stroke:"#fff"}),S.createElement("line",{x1:i+1,y1:s+2,x2:i+o-1,y2:s+2,fill:"none",stroke:"#fff"}))}},{key:"renderTraveller",value:function(n,i){var a;return S.isValidElement(n)?a=S.cloneElement(n,i):X(n)?a=n(i):a=t.renderDefaultTraveller(i),a}},{key:"getDerivedStateFromProps",value:function(n,i){var a=n.data,o=n.width,u=n.x,c=n.travellerWidth,s=n.updateId,f=n.startIndex,l=n.endIndex;if(a!==i.prevData||s!==i.prevUpdateId)return Qs({prevData:a,prevTravellerWidth:c,prevUpdateId:s,prevX:u,prevWidth:o},a&&a.length?uR({data:a,width:o,x:u,travellerWidth:c,startIndex:f,endIndex:l}):{scale:null,scaleValues:null});if(i.scale&&(o!==i.prevWidth||u!==i.prevX||c!==i.prevTravellerWidth)){i.scale.range([u,u+o-c]);var h=i.scale.domain().map(function(d){return i.scale(d)});return{prevData:a,prevTravellerWidth:c,prevUpdateId:s,prevX:u,prevWidth:o,startX:i.scale(n.startIndex),endX:i.scale(n.endIndex),scaleValues:h}}return null}},{key:"getIndexInRange",value:function(n,i){for(var a=n.length,o=0,u=a-1;u-o>1;){var c=Math.floor((o+u)/2);n[c]>i?u=c:o=c}return i>=n[u]?u:o}}])})(N.PureComponent);Fe(qr,"displayName","Brush");Fe(qr,"defaultProps",{height:40,travellerWidth:5,gap:1,fill:"#fff",stroke:"#666",padding:{top:1,right:1,bottom:1,left:1},leaveTimeOut:1e3,alwaysShowText:!1});var el,rb;function cR(){if(rb)return el;rb=1;var e=nh();function t(r,n){var i;return e(r,function(a,o,u){return i=n(a,o,u),!i}),!!i}return el=t,el}var tl,nb;function sR(){if(nb)return tl;nb=1;var e=x0(),t=ht(),r=cR(),n=qe(),i=La();function a(o,u,c){var s=n(o)?e:r;return c&&i(o,u,c)&&(u=void 0),s(o,t(u,3))}return tl=a,tl}var lR=sR();const fR=oe(lR);var ct=function(t,r){var n=t.alwaysShow,i=t.ifOverflow;return n&&(i="extendDomain"),i===r},rl,ib;function hR(){if(ib)return rl;ib=1;var e=q0();function t(r,n,i){n=="__proto__"&&e?e(r,n,{configurable:!0,enumerable:!0,value:i,writable:!0}):r[n]=i}return rl=t,rl}var nl,ab;function pR(){if(ab)return nl;ab=1;var e=hR(),t=D0(),r=ht();function n(i,a){var o={};return a=r(a,3),t(i,function(u,c,s){e(o,c,a(u,c,s))}),o}return nl=n,nl}var dR=pR();const vR=oe(dR);var il,ob;function yR(){if(ob)return il;ob=1;function e(t,r){for(var n=-1,i=t==null?0:t.length;++n=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function SR(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function PR(e,t){var r=e.x,n=e.y,i=AR(e,xR),a="".concat(r),o=parseInt(a,10),u="".concat(n),c=parseInt(u,10),s="".concat(t.height||i.height),f=parseInt(s,10),l="".concat(t.width||i.width),h=parseInt(l,10);return pn(pn(pn(pn(pn({},t),i),o?{x:o}:{}),c?{y:c}:{}),{},{height:f,width:h,name:t.name,radius:t.radius})}function lb(e){return S.createElement(gw,gf({shapeType:"rectangle",propTransformer:PR,activeClassName:"recharts-active-bar"},e))}var TR=function(t){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;return function(n,i){if(typeof t=="number")return t;var a=q(n)||ZO(n);return a?t(n,i):(a||Qt(!1),r)}},ER=["value","background"],Pw;function Lr(e){"@babel/helpers - typeof";return Lr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Lr(e)}function jR(e,t){if(e==null)return{};var r=MR(e,t),n,i;if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(i=0;i=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function MR(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function ma(){return ma=Object.assign?Object.assign.bind():function(e){for(var t=1;t0&&Math.abs($)0&&Math.abs(C)0&&(j=Math.min((fe||0)-(C[ye-1]||0),j))}),Number.isFinite(j)){var $=j/E,k=v.layout==="vertical"?n.height:n.width;if(v.padding==="gap"&&(_=$*k/2),v.padding==="no-gap"){var R=Ie(t.barCategoryGap,$*k),L=$*k/2;_=L-R-(L-R)/k*R}}}i==="xAxis"?A=[n.left+(w.left||0)+(_||0),n.left+n.width-(w.right||0)-(_||0)]:i==="yAxis"?A=c==="horizontal"?[n.top+n.height-(w.bottom||0),n.top+(w.top||0)]:[n.top+(w.top||0)+(_||0),n.top+n.height-(w.bottom||0)-(_||0)]:A=v.range,m&&(A=[A[1],A[0]]);var B=Yx(v,a,h),U=B.scale,G=B.realScaleType;U.domain(g).range(A),Zx(U);var W=Jx(U,tt(tt({},v),{},{realScaleType:G}));i==="xAxis"?(P=p==="top"&&!O||p==="bottom"&&O,T=n.left,M=l[b]-P*v.height):i==="yAxis"&&(P=p==="left"&&!O||p==="right"&&O,T=l[b]-P*v.width,M=n.top);var V=tt(tt(tt({},v),W),{},{realScaleType:G,x:T,y:M,scale:U,width:i==="xAxis"?n.width:v.width,height:i==="yAxis"?n.height:v.height});return V.bandSize=ta(V,W),!v.hide&&i==="xAxis"?l[b]+=(P?-1:1)*V.height:v.hide||(l[b]+=(P?-1:1)*V.width),tt(tt({},d),{},io({},y,V))},{})},$w=function(t,r){var n=t.x,i=t.y,a=r.x,o=r.y;return{x:Math.min(n,a),y:Math.min(i,o),width:Math.abs(a-n),height:Math.abs(o-i)}},FR=function(t){var r=t.x1,n=t.y1,i=t.x2,a=t.y2;return $w({x:r,y:n},{x:i,y:a})},Cw=(function(){function e(t){qR(this,e),this.scale=t}return LR(e,[{key:"domain",get:function(){return this.scale.domain}},{key:"range",get:function(){return this.scale.range}},{key:"rangeMin",get:function(){return this.range()[0]}},{key:"rangeMax",get:function(){return this.range()[1]}},{key:"bandwidth",get:function(){return this.scale.bandwidth}},{key:"apply",value:function(r){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},i=n.bandAware,a=n.position;if(r!==void 0){if(a)switch(a){case"start":return this.scale(r);case"middle":{var o=this.bandwidth?this.bandwidth()/2:0;return this.scale(r)+o}case"end":{var u=this.bandwidth?this.bandwidth():0;return this.scale(r)+u}default:return this.scale(r)}if(i){var c=this.bandwidth?this.bandwidth()/2:0;return this.scale(r)+c}return this.scale(r)}}},{key:"isInRange",value:function(r){var n=this.range(),i=n[0],a=n[n.length-1];return i<=a?r>=i&&r<=a:r>=a&&r<=i}}],[{key:"create",value:function(r){return new e(r)}}])})();io(Cw,"EPS",1e-4);var Ih=function(t){var r=Object.keys(t).reduce(function(n,i){return tt(tt({},n),{},io({},i,Cw.create(t[i])))},{});return tt(tt({},r),{},{apply:function(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},o=a.bandAware,u=a.position;return vR(i,function(c,s){return r[s].apply(c,{bandAware:o,position:u})})},isInRange:function(i){return Sw(i,function(a,o){return r[o].isInRange(a)})}})};function WR(e){return(e%180+180)%180}var zR=function(t){var r=t.width,n=t.height,i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,a=WR(i),o=a*Math.PI/180,u=Math.atan(n/r),c=o>u&&o-1?c[s?a[f]:f]:void 0}}return ul=n,ul}var cl,yb;function HR(){if(yb)return cl;yb=1;var e=ww();function t(r){var n=e(r),i=n%1;return n===n?i?n-i:n:0}return cl=t,cl}var sl,mb;function KR(){if(mb)return sl;mb=1;var e=$0(),t=ht(),r=HR(),n=Math.max;function i(a,o,u){var c=a==null?0:a.length;if(!c)return-1;var s=u==null?0:r(u);return s<0&&(s=n(c+s,0)),e(a,t(o,3),s)}return sl=i,sl}var ll,gb;function GR(){if(gb)return ll;gb=1;var e=UR(),t=KR(),r=e(t);return ll=r,ll}var VR=GR();const XR=oe(VR);var YR=Gb();const ZR=oe(YR);var JR=ZR(function(e){return{x:e.left,y:e.top,width:e.width,height:e.height}},function(e){return["l",e.left,"t",e.top,"w",e.width,"h",e.height].join("")}),kh=N.createContext(void 0),Rh=N.createContext(void 0),Iw=N.createContext(void 0),kw=N.createContext({}),Rw=N.createContext(void 0),Dw=N.createContext(0),Nw=N.createContext(0),bb=function(t){var r=t.state,n=r.xAxisMap,i=r.yAxisMap,a=r.offset,o=t.clipPathId,u=t.children,c=t.width,s=t.height,f=JR(a);return S.createElement(kh.Provider,{value:n},S.createElement(Rh.Provider,{value:i},S.createElement(kw.Provider,{value:a},S.createElement(Iw.Provider,{value:f},S.createElement(Rw.Provider,{value:o},S.createElement(Dw.Provider,{value:s},S.createElement(Nw.Provider,{value:c},u)))))))},QR=function(){return N.useContext(Rw)},qw=function(t){var r=N.useContext(kh);r==null&&Qt(!1);var n=r[t];return n==null&&Qt(!1),n},eD=function(){var t=N.useContext(kh);return Mt(t)},tD=function(){var t=N.useContext(Rh),r=XR(t,function(n){return Sw(n.domain,Number.isFinite)});return r||Mt(t)},Lw=function(t){var r=N.useContext(Rh);r==null&&Qt(!1);var n=r[t];return n==null&&Qt(!1),n},rD=function(){var t=N.useContext(Iw);return t},nD=function(){return N.useContext(kw)},Dh=function(){return N.useContext(Nw)},Nh=function(){return N.useContext(Dw)};function Br(e){"@babel/helpers - typeof";return Br=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Br(e)}function iD(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function aD(e,t){for(var r=0;re.length)&&(t=e.length);for(var r=0,n=new Array(t);re*i)return!1;var a=r();return e*(t-e*a/2-n)>=0&&e*(t+e*a/2-i)<=0}function BD(e,t){return Kw(e,t+1)}function FD(e,t,r,n,i){for(var a=(n||[]).slice(),o=t.start,u=t.end,c=0,s=1,f=o,l=function(){var y=n?.[c];if(y===void 0)return{v:Kw(n,s)};var v=c,p,g=function(){return p===void 0&&(p=r(y,v)),p},x=y.coordinate,w=c===0||Oa(e,x,g,f,u);w||(c=0,f=o,s+=1),w&&(f=x+e*(g()/2+i),c+=s)},h;s<=a.length;)if(h=l(),h)return h.v;return[]}function ri(e){"@babel/helpers - typeof";return ri=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},ri(e)}function Tb(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function Me(e){for(var t=1;t0?d.coordinate-p*e:d.coordinate})}else a[h]=d=Me(Me({},d),{},{tickCoord:d.coordinate});var g=Oa(e,d.tickCoord,v,u,c);g&&(c=d.tickCoord-e*(v()/2+i),a[h]=Me(Me({},d),{},{isShow:!0}))},f=o-1;f>=0;f--)s(f);return a}function KD(e,t,r,n,i,a){var o=(n||[]).slice(),u=o.length,c=t.start,s=t.end;if(a){var f=n[u-1],l=r(f,u-1),h=e*(f.coordinate+e*l/2-s);o[u-1]=f=Me(Me({},f),{},{tickCoord:h>0?f.coordinate-h*e:f.coordinate});var d=Oa(e,f.tickCoord,function(){return l},c,s);d&&(s=f.tickCoord-e*(l/2+i),o[u-1]=Me(Me({},f),{},{isShow:!0}))}for(var y=a?u-1:u,v=function(x){var w=o[x],O,m=function(){return O===void 0&&(O=r(w,x)),O};if(x===0){var b=e*(w.coordinate-e*m()/2-c);o[x]=w=Me(Me({},w),{},{tickCoord:b<0?w.coordinate-b*e:w.coordinate})}else o[x]=w=Me(Me({},w),{},{tickCoord:w.coordinate});var _=Oa(e,w.tickCoord,m,c,s);_&&(c=w.tickCoord+e*(m()/2+i),o[x]=Me(Me({},w),{},{isShow:!0}))},p=0;p=2?Ce(i[1].coordinate-i[0].coordinate):1,g=LD(a,p,d);return c==="equidistantPreserveStart"?FD(p,g,v,i,o):(c==="preserveStart"||c==="preserveStartEnd"?h=KD(p,g,v,i,o,c==="preserveStartEnd"):h=HD(p,g,v,i,o),h.filter(function(x){return x.isShow}))}var GD=["viewBox"],VD=["viewBox"],XD=["ticks"];function zr(e){"@babel/helpers - typeof";return zr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},zr(e)}function gr(){return gr=Object.assign?Object.assign.bind():function(e){for(var t=1;t=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function YD(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function ZD(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function jb(e,t){for(var r=0;r0?c(this.props):c(d)),o<=0||u<=0||!y||!y.length?null:S.createElement(te,{className:J("recharts-cartesian-axis",s),ref:function(p){n.layerReference=p}},a&&this.renderAxisLine(),this.renderTicks(y,this.state.fontSize,this.state.letterSpacing),Te.renderCallByParent(this.props))}}],[{key:"renderTickItem",value:function(n,i,a){var o,u=J(i.className,"recharts-cartesian-axis-tick-value");return S.isValidElement(n)?o=S.cloneElement(n,we(we({},i),{},{className:u})):X(n)?o=n(we(we({},i),{},{className:u})):o=S.createElement(rr,gr({},i,{className:"recharts-cartesian-axis-tick-value"}),a),o}}])})(N.Component);Fh(nn,"displayName","CartesianAxis");Fh(nn,"defaultProps",{x:0,y:0,width:0,height:0,viewBox:{x:0,y:0,width:0,height:0},orientation:"bottom",ticks:[],stroke:"#666",tickLine:!0,axisLine:!0,tick:!0,mirror:!1,minTickGap:5,tickSize:6,tickMargin:2,interval:"preserveEnd"});var iN=["x1","y1","x2","y2","key"],aN=["offset"];function ir(e){"@babel/helpers - typeof";return ir=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},ir(e)}function Mb(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function $e(e){for(var t=1;t=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function sN(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}var lN=function(t){var r=t.fill;if(!r||r==="none")return null;var n=t.fillOpacity,i=t.x,a=t.y,o=t.width,u=t.height,c=t.ry;return S.createElement("rect",{x:i,y:a,ry:c,width:o,height:u,stroke:"none",fill:r,fillOpacity:n,className:"recharts-cartesian-grid-bg"})};function Xw(e,t){var r;if(S.isValidElement(e))r=S.cloneElement(e,t);else if(X(e))r=e(t);else{var n=t.x1,i=t.y1,a=t.x2,o=t.y2,u=t.key,c=$b(t,iN),s=H(c,!1);s.offset;var f=$b(s,aN);r=S.createElement("line",Yt({},f,{x1:n,y1:i,x2:a,y2:o,fill:"none",key:u}))}return r}function fN(e){var t=e.x,r=e.width,n=e.horizontal,i=n===void 0?!0:n,a=e.horizontalPoints;if(!i||!a||!a.length)return null;var o=a.map(function(u,c){var s=$e($e({},e),{},{x1:t,y1:u,x2:t+r,y2:u,key:"line-".concat(c),index:c});return Xw(i,s)});return S.createElement("g",{className:"recharts-cartesian-grid-horizontal"},o)}function hN(e){var t=e.y,r=e.height,n=e.vertical,i=n===void 0?!0:n,a=e.verticalPoints;if(!i||!a||!a.length)return null;var o=a.map(function(u,c){var s=$e($e({},e),{},{x1:u,y1:t,x2:u,y2:t+r,key:"line-".concat(c),index:c});return Xw(i,s)});return S.createElement("g",{className:"recharts-cartesian-grid-vertical"},o)}function pN(e){var t=e.horizontalFill,r=e.fillOpacity,n=e.x,i=e.y,a=e.width,o=e.height,u=e.horizontalPoints,c=e.horizontal,s=c===void 0?!0:c;if(!s||!t||!t.length)return null;var f=u.map(function(h){return Math.round(h+i-i)}).sort(function(h,d){return h-d});i!==f[0]&&f.unshift(0);var l=f.map(function(h,d){var y=!f[d+1],v=y?i+o-h:f[d+1]-h;if(v<=0)return null;var p=d%t.length;return S.createElement("rect",{key:"react-".concat(d),y:h,x:n,height:v,width:a,stroke:"none",fill:t[p],fillOpacity:r,className:"recharts-cartesian-grid-bg"})});return S.createElement("g",{className:"recharts-cartesian-gridstripes-horizontal"},l)}function dN(e){var t=e.vertical,r=t===void 0?!0:t,n=e.verticalFill,i=e.fillOpacity,a=e.x,o=e.y,u=e.width,c=e.height,s=e.verticalPoints;if(!r||!n||!n.length)return null;var f=s.map(function(h){return Math.round(h+a-a)}).sort(function(h,d){return h-d});a!==f[0]&&f.unshift(0);var l=f.map(function(h,d){var y=!f[d+1],v=y?a+u-h:f[d+1]-h;if(v<=0)return null;var p=d%n.length;return S.createElement("rect",{key:"react-".concat(d),x:h,y:o,width:v,height:c,stroke:"none",fill:n[p],fillOpacity:i,className:"recharts-cartesian-grid-bg"})});return S.createElement("g",{className:"recharts-cartesian-gridstripes-vertical"},l)}var vN=function(t,r){var n=t.xAxis,i=t.width,a=t.height,o=t.offset;return Xx(Bh($e($e($e({},nn.defaultProps),n),{},{ticks:gt(n,!0),viewBox:{x:0,y:0,width:i,height:a}})),o.left,o.left+o.width,r)},yN=function(t,r){var n=t.yAxis,i=t.width,a=t.height,o=t.offset;return Xx(Bh($e($e($e({},nn.defaultProps),n),{},{ticks:gt(n,!0),viewBox:{x:0,y:0,width:i,height:a}})),o.top,o.top+o.height,r)},pr={horizontal:!0,vertical:!0,stroke:"#ccc",fill:"none",verticalFill:[],horizontalFill:[]};function mN(e){var t,r,n,i,a,o,u=Dh(),c=Nh(),s=nD(),f=$e($e({},e),{},{stroke:(t=e.stroke)!==null&&t!==void 0?t:pr.stroke,fill:(r=e.fill)!==null&&r!==void 0?r:pr.fill,horizontal:(n=e.horizontal)!==null&&n!==void 0?n:pr.horizontal,horizontalFill:(i=e.horizontalFill)!==null&&i!==void 0?i:pr.horizontalFill,vertical:(a=e.vertical)!==null&&a!==void 0?a:pr.vertical,verticalFill:(o=e.verticalFill)!==null&&o!==void 0?o:pr.verticalFill,x:q(e.x)?e.x:s.left,y:q(e.y)?e.y:s.top,width:q(e.width)?e.width:s.width,height:q(e.height)?e.height:s.height}),l=f.x,h=f.y,d=f.width,y=f.height,v=f.syncWithTicks,p=f.horizontalValues,g=f.verticalValues,x=eD(),w=tD();if(!q(d)||d<=0||!q(y)||y<=0||!q(l)||l!==+l||!q(h)||h!==+h)return null;var O=f.verticalCoordinatesGenerator||vN,m=f.horizontalCoordinatesGenerator||yN,b=f.horizontalPoints,_=f.verticalPoints;if((!b||!b.length)&&X(m)){var A=p&&p.length,T=m({yAxis:w?$e($e({},w),{},{ticks:A?p:w.ticks}):void 0,width:u,height:c,offset:s},A?!0:v);it(Array.isArray(T),"horizontalCoordinatesGenerator should return Array but instead it returned [".concat(ir(T),"]")),Array.isArray(T)&&(b=T)}if((!_||!_.length)&&X(O)){var M=g&&g.length,P=O({xAxis:x?$e($e({},x),{},{ticks:M?g:x.ticks}):void 0,width:u,height:c,offset:s},M?!0:v);it(Array.isArray(P),"verticalCoordinatesGenerator should return Array but instead it returned [".concat(ir(P),"]")),Array.isArray(P)&&(_=P)}return S.createElement("g",{className:"recharts-cartesian-grid"},S.createElement(lN,{fill:f.fill,fillOpacity:f.fillOpacity,x:f.x,y:f.y,width:f.width,height:f.height,ry:f.ry}),S.createElement(fN,Yt({},f,{offset:s,horizontalPoints:b,xAxis:x,yAxis:w})),S.createElement(hN,Yt({},f,{offset:s,verticalPoints:_,xAxis:x,yAxis:w})),S.createElement(pN,Yt({},f,{horizontalPoints:b})),S.createElement(dN,Yt({},f,{verticalPoints:_})))}mN.displayName="CartesianGrid";var gN=["type","layout","connectNulls","ref"],bN=["key"];function Ur(e){"@babel/helpers - typeof";return Ur=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Ur(e)}function Cb(e,t){if(e==null)return{};var r=xN(e,t),n,i;if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(i=0;i=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function xN(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function _n(){return _n=Object.assign?Object.assign.bind():function(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,n=new Array(t);rl){d=[].concat(dr(c.slice(0,y)),[l-v]);break}var p=d.length%2===0?[0,h]:[h];return[].concat(dr(t.repeat(c,f)),dr(d),p).map(function(g){return"".concat(g,"px")}).join(", ")}),rt(r,"id",Zr("recharts-line-")),rt(r,"pathRef",function(o){r.mainCurve=o}),rt(r,"handleAnimationEnd",function(){r.setState({isAnimationFinished:!0}),r.props.onAnimationEnd&&r.props.onAnimationEnd()}),rt(r,"handleAnimationStart",function(){r.setState({isAnimationFinished:!1}),r.props.onAnimationStart&&r.props.onAnimationStart()}),r}return MN(t,e),PN(t,[{key:"componentDidMount",value:function(){if(this.props.isAnimationActive){var n=this.getTotalLength();this.setState({totalLength:n})}}},{key:"componentDidUpdate",value:function(){if(this.props.isAnimationActive){var n=this.getTotalLength();n!==this.state.totalLength&&this.setState({totalLength:n})}}},{key:"getTotalLength",value:function(){var n=this.mainCurve;try{return n&&n.getTotalLength&&n.getTotalLength()||0}catch{return 0}}},{key:"renderErrorBar",value:function(n,i){if(this.props.isAnimationActive&&!this.state.isAnimationFinished)return null;var a=this.props,o=a.points,u=a.xAxis,c=a.yAxis,s=a.layout,f=a.children,l=Ke(f,pi);if(!l)return null;var h=function(v,p){return{x:v.x,y:v.y,value:v.value,errorVal:_e(v.payload,p)}},d={clipPath:n?"url(#clipPath-".concat(i,")"):null};return S.createElement(te,d,l.map(function(y){return S.cloneElement(y,{key:"bar-".concat(y.props.dataKey),data:o,xAxis:u,yAxis:c,layout:s,dataPointFormatter:h})}))}},{key:"renderDots",value:function(n,i,a){var o=this.props.isAnimationActive;if(o&&!this.state.isAnimationFinished)return null;var u=this.props,c=u.dot,s=u.points,f=u.dataKey,l=H(this.props,!1),h=H(c,!0),d=s.map(function(v,p){var g=Be(Be(Be({key:"dot-".concat(p),r:3},l),h),{},{index:p,cx:v.x,cy:v.y,value:v.value,dataKey:f,payload:v.payload,points:s});return t.renderDotItem(c,g)}),y={clipPath:n?"url(#clipPath-".concat(i?"":"dots-").concat(a,")"):null};return S.createElement(te,_n({className:"recharts-line-dots",key:"dots"},y),d)}},{key:"renderCurveStatically",value:function(n,i,a,o){var u=this.props,c=u.type,s=u.layout,f=u.connectNulls;u.ref;var l=Cb(u,gN),h=Be(Be(Be({},H(l,!0)),{},{fill:"none",className:"recharts-line-curve",clipPath:i?"url(#clipPath-".concat(a,")"):null,points:n},o),{},{type:c,layout:s,connectNulls:f});return S.createElement(ia,_n({},h,{pathRef:this.pathRef}))}},{key:"renderCurveWithAnimation",value:function(n,i){var a=this,o=this.props,u=o.points,c=o.strokeDasharray,s=o.isAnimationActive,f=o.animationBegin,l=o.animationDuration,h=o.animationEasing,d=o.animationId,y=o.animateNewValues,v=o.width,p=o.height,g=this.state,x=g.prevPoints,w=g.totalLength;return S.createElement(lt,{begin:f,duration:l,isActive:s,easing:h,from:{t:0},to:{t:1},key:"line-".concat(d),onAnimationEnd:this.handleAnimationEnd,onAnimationStart:this.handleAnimationStart},function(O){var m=O.t;if(x){var b=x.length/u.length,_=u.map(function(E,j){var C=Math.floor(j*b);if(x[C]){var $=x[C],k=ze($.x,E.x),R=ze($.y,E.y);return Be(Be({},E),{},{x:k(m),y:R(m)})}if(y){var L=ze(v*2,E.x),B=ze(p/2,E.y);return Be(Be({},E),{},{x:L(m),y:B(m)})}return Be(Be({},E),{},{x:E.x,y:E.y})});return a.renderCurveStatically(_,n,i)}var A=ze(0,w),T=A(m),M;if(c){var P="".concat(c).split(/[,\s]+/gim).map(function(E){return parseFloat(E)});M=a.getStrokeDasharray(T,w,P)}else M=a.generateSimpleStrokeDasharray(w,T);return a.renderCurveStatically(u,n,i,{strokeDasharray:M})})}},{key:"renderCurve",value:function(n,i){var a=this.props,o=a.points,u=a.isAnimationActive,c=this.state,s=c.prevPoints,f=c.totalLength;return u&&o&&o.length&&(!s&&f>0||!hi(s,o))?this.renderCurveWithAnimation(n,i):this.renderCurveStatically(o,n,i)}},{key:"render",value:function(){var n,i=this.props,a=i.hide,o=i.dot,u=i.points,c=i.className,s=i.xAxis,f=i.yAxis,l=i.top,h=i.left,d=i.width,y=i.height,v=i.isAnimationActive,p=i.id;if(a||!u||!u.length)return null;var g=this.state.isAnimationFinished,x=u.length===1,w=J("recharts-line",c),O=s&&s.allowDataOverflow,m=f&&f.allowDataOverflow,b=O||m,_=Y(p)?this.id:p,A=(n=H(o,!1))!==null&&n!==void 0?n:{r:3,strokeWidth:2},T=A.r,M=T===void 0?3:T,P=A.strokeWidth,E=P===void 0?2:P,j=s_(o)?o:{},C=j.clipDot,$=C===void 0?!0:C,k=M*2+E;return S.createElement(te,{className:w},O||m?S.createElement("defs",null,S.createElement("clipPath",{id:"clipPath-".concat(_)},S.createElement("rect",{x:O?h:h-d/2,y:m?l:l-y/2,width:O?d:d*2,height:m?y:y*2})),!$&&S.createElement("clipPath",{id:"clipPath-dots-".concat(_)},S.createElement("rect",{x:h-k/2,y:l-k/2,width:d+k,height:y+k}))):null,!x&&this.renderCurve(b,_),this.renderErrorBar(b,_),(x||o)&&this.renderDots(b,$,_),(!v||g)&&wt.renderCallByParent(this.props,u))}}],[{key:"getDerivedStateFromProps",value:function(n,i){return n.animationId!==i.prevAnimationId?{prevAnimationId:n.animationId,curPoints:n.points,prevPoints:i.curPoints}:n.points!==i.curPoints?{curPoints:n.points}:null}},{key:"repeat",value:function(n,i){for(var a=n.length%2!==0?[].concat(dr(n),[0]):n,o=[],u=0;ue.length)&&(t=e.length);for(var r=0,n=new Array(t);r=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function x2(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function w2(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function O2(e,t){for(var r=0;re.length)&&(t=e.length);for(var r=0,n=new Array(t);r0?o:t&&t.length&&q(i)&&q(a)?t.slice(i,a+1):[]};function lO(e){return e==="number"?[0,"auto"]:void 0}var Nf=function(t,r,n,i){var a=t.graphicalItems,o=t.tooltipAxis,u=ho(r,t);return n<0||!a||!a.length||n>=u.length?null:a.reduce(function(c,s){var f,l=(f=s.props.data)!==null&&f!==void 0?f:r;l&&t.dataStartIndex+t.dataEndIndex!==0&&t.dataEndIndex-t.dataStartIndex>=n&&(l=l.slice(t.dataStartIndex,t.dataEndIndex+1));var h;if(o.dataKey&&!o.allowDuplicatedCategory){var d=l===void 0?u:l;h=Mi(d,o.dataKey,i)}else h=l&&l[n]||u[n];return h?[].concat(Vr(c),[ew(s,h)]):c},[])},Fb=function(t,r,n,i){var a=i||{x:t.chartX,y:t.chartY},o=k2(a,n),u=t.orderedTooltipTicks,c=t.tooltipAxis,s=t.tooltipTicks,f=aM(o,u,s,c);if(f>=0&&s){var l=s[f]&&s[f].value,h=Nf(t,r,f,l),d=R2(n,u,f,a);return{activeTooltipIndex:f,activeLabel:l,activePayload:h,activeCoordinate:d}}return null},D2=function(t,r){var n=r.axes,i=r.graphicalItems,a=r.axisType,o=r.axisIdKey,u=r.stackGroups,c=r.dataStartIndex,s=r.dataEndIndex,f=t.layout,l=t.children,h=t.stackOffset,d=Vx(f,a);return n.reduce(function(y,v){var p,g=v.type.defaultProps!==void 0?I(I({},v.type.defaultProps),v.props):v.props,x=g.type,w=g.dataKey,O=g.allowDataOverflow,m=g.allowDuplicatedCategory,b=g.scale,_=g.ticks,A=g.includeHidden,T=g[o];if(y[T])return y;var M=ho(t.data,{graphicalItems:i.filter(function(W){var V,fe=o in W.props?W.props[o]:(V=W.type.defaultProps)===null||V===void 0?void 0:V[o];return fe===T}),dataStartIndex:c,dataEndIndex:s}),P=M.length,E,j,C;c2(g.domain,O,x)&&(E=Yl(g.domain,null,O),d&&(x==="number"||b!=="auto")&&(C=bn(M,w,"category")));var $=lO(x);if(!E||E.length===0){var k,R=(k=g.domain)!==null&&k!==void 0?k:$;if(w){if(E=bn(M,w,x),x==="category"&&d){var L=QO(E);m&&L?(j=E,E=da(0,P)):m||(E=Lm(R,E,v).reduce(function(W,V){return W.indexOf(V)>=0?W:[].concat(Vr(W),[V])},[]))}else if(x==="category")m?E=E.filter(function(W){return W!==""&&!Y(W)}):E=Lm(R,E,v).reduce(function(W,V){return W.indexOf(V)>=0||V===""||Y(V)?W:[].concat(Vr(W),[V])},[]);else if(x==="number"){var B=lM(M,i.filter(function(W){var V,fe,ye=o in W.props?W.props[o]:(V=W.type.defaultProps)===null||V===void 0?void 0:V[o],Le="hide"in W.props?W.props.hide:(fe=W.type.defaultProps)===null||fe===void 0?void 0:fe.hide;return ye===T&&(A||!Le)}),w,a,f);B&&(E=B)}d&&(x==="number"||b!=="auto")&&(C=bn(M,w,"category"))}else d?E=da(0,P):u&&u[T]&&u[T].hasStack&&x==="number"?E=h==="expand"?[0,1]:Qx(u[T].stackGroups,c,s):E=Gx(M,i.filter(function(W){var V=o in W.props?W.props[o]:W.type.defaultProps[o],fe="hide"in W.props?W.props.hide:W.type.defaultProps.hide;return V===T&&(A||!fe)}),x,f,!0);if(x==="number")E=kf(l,E,T,a,_),R&&(E=Yl(R,E,O));else if(x==="category"&&R){var U=R,G=E.every(function(W){return U.indexOf(W)>=0});G&&(E=U)}}return I(I({},y),{},K({},T,I(I({},g),{},{axisType:a,domain:E,categoricalDomain:C,duplicateDomain:j,originalDomain:(p=g.domain)!==null&&p!==void 0?p:$,isCategorical:d,layout:f})))},{})},N2=function(t,r){var n=r.graphicalItems,i=r.Axis,a=r.axisType,o=r.axisIdKey,u=r.stackGroups,c=r.dataStartIndex,s=r.dataEndIndex,f=t.layout,l=t.children,h=ho(t.data,{graphicalItems:n,dataStartIndex:c,dataEndIndex:s}),d=h.length,y=Vx(f,a),v=-1;return n.reduce(function(p,g){var x=g.type.defaultProps!==void 0?I(I({},g.type.defaultProps),g.props):g.props,w=x[o],O=lO("number");if(!p[w]){v++;var m;return y?m=da(0,d):u&&u[w]&&u[w].hasStack?(m=Qx(u[w].stackGroups,c,s),m=kf(l,m,w,a)):(m=Yl(O,Gx(h,n.filter(function(b){var _,A,T=o in b.props?b.props[o]:(_=b.type.defaultProps)===null||_===void 0?void 0:_[o],M="hide"in b.props?b.props.hide:(A=b.type.defaultProps)===null||A===void 0?void 0:A.hide;return T===w&&!M}),"number",f),i.defaultProps.allowDataOverflow),m=kf(l,m,w,a)),I(I({},p),{},K({},w,I(I({axisType:a},i.defaultProps),{},{hide:!0,orientation:He(C2,"".concat(a,".").concat(v%2),null),domain:m,originalDomain:O,isCategorical:y,layout:f})))}return p},{})},q2=function(t,r){var n=r.axisType,i=n===void 0?"xAxis":n,a=r.AxisComp,o=r.graphicalItems,u=r.stackGroups,c=r.dataStartIndex,s=r.dataEndIndex,f=t.children,l="".concat(i,"Id"),h=Ke(f,a),d={};return h&&h.length?d=D2(t,{axes:h,graphicalItems:o,axisType:i,axisIdKey:l,stackGroups:u,dataStartIndex:c,dataEndIndex:s}):o&&o.length&&(d=N2(t,{Axis:a,graphicalItems:o,axisType:i,axisIdKey:l,stackGroups:u,dataStartIndex:c,dataEndIndex:s})),d},L2=function(t){var r=Mt(t),n=gt(r,!1,!0);return{tooltipTicks:n,orderedTooltipTicks:ih(n,function(i){return i.coordinate}),tooltipAxis:r,tooltipAxisBandSize:ta(r,n)}},Wb=function(t){var r=t.children,n=t.defaultShowTooltip,i=We(r,qr),a=0,o=0;return t.data&&t.data.length!==0&&(o=t.data.length-1),i&&i.props&&(i.props.startIndex>=0&&(a=i.props.startIndex),i.props.endIndex>=0&&(o=i.props.endIndex)),{chartX:0,chartY:0,dataStartIndex:a,dataEndIndex:o,activeTooltipIndex:-1,isTooltipActive:!!n}},B2=function(t){return!t||!t.length?!1:t.some(function(r){var n=bt(r&&r.type);return n&&n.indexOf("Bar")>=0})},zb=function(t){return t==="horizontal"?{numericAxisName:"yAxis",cateAxisName:"xAxis"}:t==="vertical"?{numericAxisName:"xAxis",cateAxisName:"yAxis"}:t==="centric"?{numericAxisName:"radiusAxis",cateAxisName:"angleAxis"}:{numericAxisName:"angleAxis",cateAxisName:"radiusAxis"}},F2=function(t,r){var n=t.props,i=t.graphicalItems,a=t.xAxisMap,o=a===void 0?{}:a,u=t.yAxisMap,c=u===void 0?{}:u,s=n.width,f=n.height,l=n.children,h=n.margin||{},d=We(l,qr),y=We(l,wr),v=Object.keys(c).reduce(function(m,b){var _=c[b],A=_.orientation;return!_.mirror&&!_.hide?I(I({},m),{},K({},A,m[A]+_.width)):m},{left:h.left||0,right:h.right||0}),p=Object.keys(o).reduce(function(m,b){var _=o[b],A=_.orientation;return!_.mirror&&!_.hide?I(I({},m),{},K({},A,He(m,"".concat(A))+_.height)):m},{top:h.top||0,bottom:h.bottom||0}),g=I(I({},p),v),x=g.bottom;d&&(g.bottom+=d.props.height||qr.defaultProps.height),y&&r&&(g=cM(g,i,n,r));var w=s-g.left-g.right,O=f-g.top-g.bottom;return I(I({brushBottom:x},g),{},{width:Math.max(w,0),height:Math.max(O,0)})},W2=function(t,r){if(r==="xAxis")return t[r].width;if(r==="yAxis")return t[r].height},Wh=function(t){var r=t.chartName,n=t.GraphicalChild,i=t.defaultTooltipEventType,a=i===void 0?"axis":i,o=t.validateTooltipEventTypes,u=o===void 0?["axis"]:o,c=t.axisComponents,s=t.legendContent,f=t.formatAxisMap,l=t.defaultProps,h=function(g,x){var w=x.graphicalItems,O=x.stackGroups,m=x.offset,b=x.updateId,_=x.dataStartIndex,A=x.dataEndIndex,T=g.barSize,M=g.layout,P=g.barGap,E=g.barCategoryGap,j=g.maxBarSize,C=zb(M),$=C.numericAxisName,k=C.cateAxisName,R=B2(w),L=[];return w.forEach(function(B,U){var G=ho(g.data,{graphicalItems:[B],dataStartIndex:_,dataEndIndex:A}),W=B.type.defaultProps!==void 0?I(I({},B.type.defaultProps),B.props):B.props,V=W.dataKey,fe=W.maxBarSize,ye=W["".concat($,"Id")],Le=W["".concat(k,"Id")],qt={},Re=c.reduce(function(Lt,Bt){var po=x["".concat(Bt.axisType,"Map")],zh=W["".concat(Bt.axisType,"Id")];po&&po[zh]||Bt.axisType==="zAxis"||Qt(!1);var Uh=po[zh];return I(I({},Lt),{},K(K({},Bt.axisType,Uh),"".concat(Bt.axisType,"Ticks"),gt(Uh)))},qt),F=Re[k],Z=Re["".concat(k,"Ticks")],Q=O&&O[ye]&&O[ye].hasStack&&bM(B,O[ye].stackGroups),D=bt(B.type).indexOf("Bar")>=0,de=ta(F,Z),ee=[],be=R&&oM({barSize:T,stackGroups:O,totalSize:W2(Re,k)});if(D){var xe,De,Et=Y(fe)?j:fe,lr=(xe=(De=ta(F,Z,!0))!==null&&De!==void 0?De:Et)!==null&&xe!==void 0?xe:0;ee=uM({barGap:P,barCategoryGap:E,bandSize:lr!==de?lr:de,sizeList:be[Le],maxBarSize:Et}),lr!==de&&(ee=ee.map(function(Lt){return I(I({},Lt),{},{position:I(I({},Lt.position),{},{offset:Lt.position.offset-lr/2})})}))}var di=B&&B.type&&B.type.getComposedData;di&&L.push({props:I(I({},di(I(I({},Re),{},{displayedData:G,props:g,dataKey:V,item:B,bandSize:de,barPosition:ee,offset:m,stackedData:Q,layout:M,dataStartIndex:_,dataEndIndex:A}))),{},K(K(K({key:B.key||"item-".concat(U)},$,Re[$]),k,Re[k]),"animationId",b)),childIndex:h_(B,g.children),item:B})}),L},d=function(g,x){var w=g.props,O=g.dataStartIndex,m=g.dataEndIndex,b=g.updateId;if(!Qp({props:w}))return null;var _=w.children,A=w.layout,T=w.stackOffset,M=w.data,P=w.reverseStackOrder,E=zb(A),j=E.numericAxisName,C=E.cateAxisName,$=Ke(_,n),k=mM(M,$,"".concat(j,"Id"),"".concat(C,"Id"),T,P),R=c.reduce(function(W,V){var fe="".concat(V.axisType,"Map");return I(I({},W),{},K({},fe,q2(w,I(I({},V),{},{graphicalItems:$,stackGroups:V.axisType===j&&k,dataStartIndex:O,dataEndIndex:m}))))},{}),L=F2(I(I({},R),{},{props:w,graphicalItems:$}),x?.legendBBox);Object.keys(R).forEach(function(W){R[W]=f(w,R[W],L,W.replace("Map",""),r)});var B=R["".concat(C,"Map")],U=L2(B),G=h(w,I(I({},R),{},{dataStartIndex:O,dataEndIndex:m,updateId:b,graphicalItems:$,stackGroups:k,offset:L}));return I(I({formattedGraphicalItems:G,graphicalItems:$,offset:L,stackGroups:k},U),R)},y=(function(p){function g(x){var w,O,m;return w2(this,g),m=A2(this,g,[x]),K(m,"eventEmitterSymbol",Symbol("rechartsEventEmitter")),K(m,"accessibilityManager",new u2),K(m,"handleLegendBBoxUpdate",function(b){if(b){var _=m.state,A=_.dataStartIndex,T=_.dataEndIndex,M=_.updateId;m.setState(I({legendBBox:b},d({props:m.props,dataStartIndex:A,dataEndIndex:T,updateId:M},I(I({},m.state),{},{legendBBox:b}))))}}),K(m,"handleReceiveSyncEvent",function(b,_,A){if(m.props.syncId===b){if(A===m.eventEmitterSymbol&&typeof m.props.syncMethod!="function")return;m.applySyncEvent(_)}}),K(m,"handleBrushChange",function(b){var _=b.startIndex,A=b.endIndex;if(_!==m.state.dataStartIndex||A!==m.state.dataEndIndex){var T=m.state.updateId;m.setState(function(){return I({dataStartIndex:_,dataEndIndex:A},d({props:m.props,dataStartIndex:_,dataEndIndex:A,updateId:T},m.state))}),m.triggerSyncEvent({dataStartIndex:_,dataEndIndex:A})}}),K(m,"handleMouseEnter",function(b){var _=m.getMouseInfo(b);if(_){var A=I(I({},_),{},{isTooltipActive:!0});m.setState(A),m.triggerSyncEvent(A);var T=m.props.onMouseEnter;X(T)&&T(A,b)}}),K(m,"triggeredAfterMouseMove",function(b){var _=m.getMouseInfo(b),A=_?I(I({},_),{},{isTooltipActive:!0}):{isTooltipActive:!1};m.setState(A),m.triggerSyncEvent(A);var T=m.props.onMouseMove;X(T)&&T(A,b)}),K(m,"handleItemMouseEnter",function(b){m.setState(function(){return{isTooltipActive:!0,activeItem:b,activePayload:b.tooltipPayload,activeCoordinate:b.tooltipPosition||{x:b.cx,y:b.cy}}})}),K(m,"handleItemMouseLeave",function(){m.setState(function(){return{isTooltipActive:!1}})}),K(m,"handleMouseMove",function(b){b.persist(),m.throttleTriggeredAfterMouseMove(b)}),K(m,"handleMouseLeave",function(b){m.throttleTriggeredAfterMouseMove.cancel();var _={isTooltipActive:!1};m.setState(_),m.triggerSyncEvent(_);var A=m.props.onMouseLeave;X(A)&&A(_,b)}),K(m,"handleOuterEvent",function(b){var _=f_(b),A=He(m.props,"".concat(_));if(_&&X(A)){var T,M;/.*touch.*/i.test(_)?M=m.getMouseInfo(b.changedTouches[0]):M=m.getMouseInfo(b),A((T=M)!==null&&T!==void 0?T:{},b)}}),K(m,"handleClick",function(b){var _=m.getMouseInfo(b);if(_){var A=I(I({},_),{},{isTooltipActive:!0});m.setState(A),m.triggerSyncEvent(A);var T=m.props.onClick;X(T)&&T(A,b)}}),K(m,"handleMouseDown",function(b){var _=m.props.onMouseDown;if(X(_)){var A=m.getMouseInfo(b);_(A,b)}}),K(m,"handleMouseUp",function(b){var _=m.props.onMouseUp;if(X(_)){var A=m.getMouseInfo(b);_(A,b)}}),K(m,"handleTouchMove",function(b){b.changedTouches!=null&&b.changedTouches.length>0&&m.throttleTriggeredAfterMouseMove(b.changedTouches[0])}),K(m,"handleTouchStart",function(b){b.changedTouches!=null&&b.changedTouches.length>0&&m.handleMouseDown(b.changedTouches[0])}),K(m,"handleTouchEnd",function(b){b.changedTouches!=null&&b.changedTouches.length>0&&m.handleMouseUp(b.changedTouches[0])}),K(m,"handleDoubleClick",function(b){var _=m.props.onDoubleClick;if(X(_)){var A=m.getMouseInfo(b);_(A,b)}}),K(m,"handleContextMenu",function(b){var _=m.props.onContextMenu;if(X(_)){var A=m.getMouseInfo(b);_(A,b)}}),K(m,"triggerSyncEvent",function(b){m.props.syncId!==void 0&&pl.emit(dl,m.props.syncId,b,m.eventEmitterSymbol)}),K(m,"applySyncEvent",function(b){var _=m.props,A=_.layout,T=_.syncMethod,M=m.state.updateId,P=b.dataStartIndex,E=b.dataEndIndex;if(b.dataStartIndex!==void 0||b.dataEndIndex!==void 0)m.setState(I({dataStartIndex:P,dataEndIndex:E},d({props:m.props,dataStartIndex:P,dataEndIndex:E,updateId:M},m.state)));else if(b.activeTooltipIndex!==void 0){var j=b.chartX,C=b.chartY,$=b.activeTooltipIndex,k=m.state,R=k.offset,L=k.tooltipTicks;if(!R)return;if(typeof T=="function")$=T(L,b);else if(T==="value"){$=-1;for(var B=0;B=0){var Q,D;if(j.dataKey&&!j.allowDuplicatedCategory){var de=typeof j.dataKey=="function"?Z:"payload.".concat(j.dataKey.toString());Q=Mi(B,de,$),D=U&&G&&Mi(G,de,$)}else Q=B?.[C],D=U&&G&&G[C];if(Le||ye){var ee=b.props.activeIndex!==void 0?b.props.activeIndex:C;return[N.cloneElement(b,I(I(I({},T.props),Re),{},{activeIndex:ee})),null,null]}if(!Y(Q))return[F].concat(Vr(m.renderActivePoints({item:T,activePoint:Q,basePoint:D,childIndex:C,isRange:U})))}else{var be,xe=(be=m.getItemByXY(m.state.activeCoordinate))!==null&&be!==void 0?be:{graphicalItem:F},De=xe.graphicalItem,Et=De.item,lr=Et===void 0?b:Et,di=De.childIndex,Lt=I(I(I({},T.props),Re),{},{activeIndex:di});return[N.cloneElement(lr,Lt),null,null]}return U?[F,null,null]:[F,null]}),K(m,"renderCustomized",function(b,_,A){return N.cloneElement(b,I(I({key:"recharts-customized-".concat(A)},m.props),m.state))}),K(m,"renderMap",{CartesianGrid:{handler:Ei,once:!0},ReferenceArea:{handler:m.renderReferenceElement},ReferenceLine:{handler:Ei},ReferenceDot:{handler:m.renderReferenceElement},XAxis:{handler:Ei},YAxis:{handler:Ei},Brush:{handler:m.renderBrush,once:!0},Bar:{handler:m.renderGraphicChild},Line:{handler:m.renderGraphicChild},Area:{handler:m.renderGraphicChild},Radar:{handler:m.renderGraphicChild},RadialBar:{handler:m.renderGraphicChild},Scatter:{handler:m.renderGraphicChild},Pie:{handler:m.renderGraphicChild},Funnel:{handler:m.renderGraphicChild},Tooltip:{handler:m.renderCursor,once:!0},PolarGrid:{handler:m.renderPolarGrid,once:!0},PolarAngleAxis:{handler:m.renderPolarAxis},PolarRadiusAxis:{handler:m.renderPolarAxis},Customized:{handler:m.renderCustomized}}),m.clipPathId="".concat((w=x.id)!==null&&w!==void 0?w:Zr("recharts"),"-clip"),m.throttleTriggeredAfterMouseMove=U0(m.triggeredAfterMouseMove,(O=x.throttleDelay)!==null&&O!==void 0?O:1e3/60),m.state={},m}return T2(g,p),_2(g,[{key:"componentDidMount",value:function(){var w,O;this.addListener(),this.accessibilityManager.setDetails({container:this.container,offset:{left:(w=this.props.margin.left)!==null&&w!==void 0?w:0,top:(O=this.props.margin.top)!==null&&O!==void 0?O:0},coordinateList:this.state.tooltipTicks,mouseHandlerCallback:this.triggeredAfterMouseMove,layout:this.props.layout}),this.displayDefaultTooltip()}},{key:"displayDefaultTooltip",value:function(){var w=this.props,O=w.children,m=w.data,b=w.height,_=w.layout,A=We(O,dt);if(A){var T=A.props.defaultIndex;if(!(typeof T!="number"||T<0||T>this.state.tooltipTicks.length-1)){var M=this.state.tooltipTicks[T]&&this.state.tooltipTicks[T].value,P=Nf(this.state,m,T,M),E=this.state.tooltipTicks[T].coordinate,j=(this.state.offset.top+b)/2,C=_==="horizontal",$=C?{x:E,y:j}:{y:E,x:j},k=this.state.formattedGraphicalItems.find(function(L){var B=L.item;return B.type.name==="Scatter"});k&&($=I(I({},$),k.props.points[T].tooltipPosition),P=k.props.points[T].tooltipPayload);var R={activeTooltipIndex:T,isTooltipActive:!0,activeLabel:M,activePayload:P,activeCoordinate:$};this.setState(R),this.renderCursor(A),this.accessibilityManager.setIndex(T)}}}},{key:"getSnapshotBeforeUpdate",value:function(w,O){if(!this.props.accessibilityLayer)return null;if(this.state.tooltipTicks!==O.tooltipTicks&&this.accessibilityManager.setDetails({coordinateList:this.state.tooltipTicks}),this.props.layout!==w.layout&&this.accessibilityManager.setDetails({layout:this.props.layout}),this.props.margin!==w.margin){var m,b;this.accessibilityManager.setDetails({offset:{left:(m=this.props.margin.left)!==null&&m!==void 0?m:0,top:(b=this.props.margin.top)!==null&&b!==void 0?b:0}})}return null}},{key:"componentDidUpdate",value:function(w){gl([We(w.children,dt)],[We(this.props.children,dt)])||this.displayDefaultTooltip()}},{key:"componentWillUnmount",value:function(){this.removeListener(),this.throttleTriggeredAfterMouseMove.cancel()}},{key:"getTooltipEventType",value:function(){var w=We(this.props.children,dt);if(w&&typeof w.props.shared=="boolean"){var O=w.props.shared?"axis":"item";return u.indexOf(O)>=0?O:a}return a}},{key:"getMouseInfo",value:function(w){if(!this.container)return null;var O=this.container,m=O.getBoundingClientRect(),b=JS(m),_={chartX:Math.round(w.pageX-b.left),chartY:Math.round(w.pageY-b.top)},A=m.width/O.offsetWidth||1,T=this.inRange(_.chartX,_.chartY,A);if(!T)return null;var M=this.state,P=M.xAxisMap,E=M.yAxisMap,j=this.getTooltipEventType(),C=Fb(this.state,this.props.data,this.props.layout,T);if(j!=="axis"&&P&&E){var $=Mt(P).scale,k=Mt(E).scale,R=$&&$.invert?$.invert(_.chartX):null,L=k&&k.invert?k.invert(_.chartY):null;return I(I({},_),{},{xValue:R,yValue:L},C)}return C?I(I({},_),C):null}},{key:"inRange",value:function(w,O){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:1,b=this.props.layout,_=w/m,A=O/m;if(b==="horizontal"||b==="vertical"){var T=this.state.offset,M=_>=T.left&&_<=T.left+T.width&&A>=T.top&&A<=T.top+T.height;return M?{x:_,y:A}:null}var P=this.state,E=P.angleAxisMap,j=P.radiusAxisMap;if(E&&j){var C=Mt(E);return Wm({x:_,y:A},C)}return null}},{key:"parseEventsOfWrapper",value:function(){var w=this.props.children,O=this.getTooltipEventType(),m=We(w,dt),b={};m&&O==="axis"&&(m.props.trigger==="click"?b={onClick:this.handleClick}:b={onMouseEnter:this.handleMouseEnter,onDoubleClick:this.handleDoubleClick,onMouseMove:this.handleMouseMove,onMouseLeave:this.handleMouseLeave,onTouchMove:this.handleTouchMove,onTouchStart:this.handleTouchStart,onTouchEnd:this.handleTouchEnd,onContextMenu:this.handleContextMenu});var _=$i(this.props,this.handleOuterEvent);return I(I({},_),b)}},{key:"addListener",value:function(){pl.on(dl,this.handleReceiveSyncEvent)}},{key:"removeListener",value:function(){pl.removeListener(dl,this.handleReceiveSyncEvent)}},{key:"filterFormatItem",value:function(w,O,m){for(var b=this.state.formattedGraphicalItems,_=0,A=b.length;_-1}return ru=t,ru}var nu,wd;function f1(){if(wd)return nu;wd=1;var e=La();function t(r,n){var i=this.__data__,a=e(i,r);return a<0?(++this.size,i.push([r,n])):i[a][1]=n,this}return nu=t,nu}var iu,Od;function Ba(){if(Od)return iu;Od=1;var e=u1(),t=c1(),r=s1(),n=l1(),i=f1();function a(o){var u=-1,c=o==null?0:o.length;for(this.clear();++u0?1:-1},er=function(t){return ur(t)&&t.indexOf("%")===t.length-1},q=function(t){return k1(t)&&!gi(t)},R1=function(t){return J(t)},Se=function(t){return q(t)||ur(t)},D1=0,un=function(t){var r=++D1;return"".concat(t||"").concat(r)},Le=function(t,r){var n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,i=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(!q(t)&&!ur(t))return n;var a;if(er(t)){var o=t.indexOf("%");a=r*parseFloat(t.slice(0,o))/100}else a=+t;return gi(a)&&(a=n),i&&a>r&&(a=r),a},qt=function(t){if(!t)return null;var r=Object.keys(t);return r&&r.length?t[r[0]]:null},N1=function(t){if(!Array.isArray(t))return!1;for(var r=t.length,n={},i=0;i=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function z1(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function nf(e){"@babel/helpers - typeof";return nf=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},nf(e)}var Yd={click:"onClick",mousedown:"onMouseDown",mouseup:"onMouseUp",mouseover:"onMouseOver",mousemove:"onMouseMove",mouseout:"onMouseOut",mouseenter:"onMouseEnter",mouseleave:"onMouseLeave",touchcancel:"onTouchCancel",touchend:"onTouchEnd",touchmove:"onTouchMove",touchstart:"onTouchStart",contextmenu:"onContextMenu",dblclick:"onDoubleClick"},Et=function(t){return typeof t=="string"?t:t?t.displayName||t.name||"Component":""},Zd=null,Mu=null,Ih=function e(t){if(t===Zd&&Array.isArray(Mu))return Mu;var r=[];return N.Children.forEach(t,function(n){J(n)||(M1.isFragment(n)?r=r.concat(e(n.props.children)):r.push(n))}),Mu=r,Zd=t,r};function Ye(e,t){var r=[],n=[];return Array.isArray(t)?n=t.map(function(i){return Et(i)}):n=[Et(t)],Ih(e).forEach(function(i){var a=Xe(i,"type.displayName")||Xe(i,"type.name");n.indexOf(a)!==-1&&r.push(i)}),r}function He(e,t){var r=Ye(e,t);return r&&r[0]}var Jd=function(t){if(!t||!t.props)return!1;var r=t.props,n=r.width,i=r.height;return!(!q(n)||n<=0||!q(i)||i<=0)},K1=["a","altGlyph","altGlyphDef","altGlyphItem","animate","animateColor","animateMotion","animateTransform","circle","clipPath","color-profile","cursor","defs","desc","ellipse","feBlend","feColormatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDistantLight","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feImage","feMerge","feMergeNode","feMorphology","feOffset","fePointLight","feSpecularLighting","feSpotLight","feTile","feTurbulence","filter","font","font-face","font-face-format","font-face-name","font-face-url","foreignObject","g","glyph","glyphRef","hkern","image","line","lineGradient","marker","mask","metadata","missing-glyph","mpath","path","pattern","polygon","polyline","radialGradient","rect","script","set","stop","style","svg","switch","symbol","text","textPath","title","tref","tspan","use","view","vkern"],H1=function(t){return t&&t.type&&ur(t.type)&&K1.indexOf(t.type)>=0},G1=function(t){return t&&nf(t)==="object"&&"clipDot"in t},V1=function(t,r,n,i){var a,o=(a=ju?.[i])!==null&&a!==void 0?a:[];return r.startsWith("data-")||!X(t)&&(i&&o.includes(r)||B1.includes(r))||n&&$h.includes(r)},K=function(t,r,n){if(!t||typeof t=="function"||typeof t=="boolean")return null;var i=t;if(N.isValidElement(t)&&(i=t.props),!on(i))return null;var a={};return Object.keys(i).forEach(function(o){var u;V1((u=i)===null||u===void 0?void 0:u[o],o,r,n)&&(a[o]=i[o])}),a},af=function e(t,r){if(t===r)return!0;var n=N.Children.count(t);if(n!==N.Children.count(r))return!1;if(n===0)return!0;if(n===1)return Qd(Array.isArray(t)?t[0]:t,Array.isArray(r)?r[0]:r);for(var i=0;i=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function Q1(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function uf(e){var t=e.children,r=e.width,n=e.height,i=e.viewBox,a=e.className,o=e.style,u=e.title,c=e.desc,s=J1(e,Z1),f=i||{width:r,height:n,x:0,y:0},l=te("recharts-surface",a);return S.createElement("svg",of({},K(s,!0,"svg"),{className:l,width:r,height:n,style:o,viewBox:"".concat(f.x," ").concat(f.y," ").concat(f.width," ").concat(f.height)}),S.createElement("title",null,u),S.createElement("desc",null,c),t)}var eA=["children","className"];function cf(){return cf=Object.assign?Object.assign.bind():function(e){for(var t=1;t=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function rA(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}var ne=S.forwardRef(function(e,t){var r=e.children,n=e.className,i=tA(e,eA),a=te("recharts-layer",n);return S.createElement("g",cf({className:a},K(i,!0),{ref:t}),r)}),st=function(t,r){for(var n=arguments.length,i=new Array(n>2?n-2:0),a=2;aa?0:a+r),n=n>a?a:n,n<0&&(n+=a),a=r>n?0:n-r>>>0,r>>>=0;for(var o=Array(a);++i=a?r:e(r,n,i)}return Iu=t,Iu}var Cu,nv;function Ex(){if(nv)return Cu;nv=1;var e="\\ud800-\\udfff",t="\\u0300-\\u036f",r="\\ufe20-\\ufe2f",n="\\u20d0-\\u20ff",i=t+r+n,a="\\ufe0e\\ufe0f",o="\\u200d",u=RegExp("["+o+e+i+a+"]");function c(s){return u.test(s)}return Cu=c,Cu}var ku,iv;function aA(){if(iv)return ku;iv=1;function e(t){return t.split("")}return ku=e,ku}var Ru,av;function oA(){if(av)return Ru;av=1;var e="\\ud800-\\udfff",t="\\u0300-\\u036f",r="\\ufe20-\\ufe2f",n="\\u20d0-\\u20ff",i=t+r+n,a="\\ufe0e\\ufe0f",o="["+e+"]",u="["+i+"]",c="\\ud83c[\\udffb-\\udfff]",s="(?:"+u+"|"+c+")",f="[^"+e+"]",l="(?:\\ud83c[\\udde6-\\uddff]){2}",h="[\\ud800-\\udbff][\\udc00-\\udfff]",p="\\u200d",y=s+"?",v="["+a+"]?",d="(?:"+p+"(?:"+[f,l,h].join("|")+")"+v+y+")*",m=v+y+d,x="(?:"+[f+u+"?",u,l,h,o].join("|")+")",w=RegExp(c+"(?="+c+")|"+x+m,"g");function O(g){return g.match(w)||[]}return Ru=O,Ru}var Du,ov;function uA(){if(ov)return Du;ov=1;var e=aA(),t=Ex(),r=oA();function n(i){return t(i)?r(i):e(i)}return Du=n,Du}var Nu,uv;function cA(){if(uv)return Nu;uv=1;var e=iA(),t=Ex(),r=uA(),n=Ax();function i(a){return function(o){o=n(o);var u=t(o)?r(o):void 0,c=u?u[0]:o.charAt(0),s=u?e(u,1).join(""):o.slice(1);return c[a]()+s}}return Nu=i,Nu}var qu,cv;function sA(){if(cv)return qu;cv=1;var e=cA(),t=e("toUpperCase");return qu=t,qu}var lA=sA();const Wa=ce(lA);function he(e){return function(){return e}}const jx=Math.cos,Ui=Math.sin,pt=Math.sqrt,Wi=Math.PI,za=2*Wi,sf=Math.PI,lf=2*sf,Zt=1e-6,fA=lf-Zt;function Mx(e){this._+=e[0];for(let t=1,r=e.length;t=0))throw new Error(`invalid digits: ${e}`);if(t>15)return Mx;const r=10**t;return function(n){this._+=n[0];for(let i=1,a=n.length;iZt)if(!(Math.abs(l*c-s*f)>Zt)||!a)this._append`L${this._x1=t},${this._y1=r}`;else{let p=n-o,y=i-u,v=c*c+s*s,d=p*p+y*y,m=Math.sqrt(v),x=Math.sqrt(h),w=a*Math.tan((sf-Math.acos((v+h-d)/(2*m*x)))/2),O=w/x,g=w/m;Math.abs(O-1)>Zt&&this._append`L${t+O*f},${r+O*l}`,this._append`A${a},${a},0,0,${+(l*p>f*y)},${this._x1=t+g*c},${this._y1=r+g*s}`}}arc(t,r,n,i,a,o){if(t=+t,r=+r,n=+n,o=!!o,n<0)throw new Error(`negative radius: ${n}`);let u=n*Math.cos(i),c=n*Math.sin(i),s=t+u,f=r+c,l=1^o,h=o?i-a:a-i;this._x1===null?this._append`M${s},${f}`:(Math.abs(this._x1-s)>Zt||Math.abs(this._y1-f)>Zt)&&this._append`L${s},${f}`,n&&(h<0&&(h=h%lf+lf),h>fA?this._append`A${n},${n},0,1,${l},${t-u},${r-c}A${n},${n},0,1,${l},${this._x1=s},${this._y1=f}`:h>Zt&&this._append`A${n},${n},0,${+(h>=sf)},${l},${this._x1=t+n*Math.cos(a)},${this._y1=r+n*Math.sin(a)}`)}rect(t,r,n,i){this._append`M${this._x0=this._x1=+t},${this._y0=this._y1=+r}h${n=+n}v${+i}h${-n}Z`}toString(){return this._}}function Ch(e){let t=3;return e.digits=function(r){if(!arguments.length)return t;if(r==null)t=null;else{const n=Math.floor(r);if(!(n>=0))throw new RangeError(`invalid digits: ${r}`);t=n}return e},()=>new pA(t)}function kh(e){return typeof e=="object"&&"length"in e?e:Array.from(e)}function $x(e){this._context=e}$x.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}};function Ka(e){return new $x(e)}function Ix(e){return e[0]}function Cx(e){return e[1]}function kx(e,t){var r=he(!0),n=null,i=Ka,a=null,o=Ch(u);e=typeof e=="function"?e:e===void 0?Ix:he(e),t=typeof t=="function"?t:t===void 0?Cx:he(t);function u(c){var s,f=(c=kh(c)).length,l,h=!1,p;for(n==null&&(a=i(p=o())),s=0;s<=f;++s)!(s=p;--y)u.point(w[y],O[y]);u.lineEnd(),u.areaEnd()}m&&(w[h]=+e(d,h,l),O[h]=+t(d,h,l),u.point(n?+n(d,h,l):w[h],r?+r(d,h,l):O[h]))}if(x)return u=null,x+""||null}function f(){return kx().defined(i).curve(o).context(a)}return s.x=function(l){return arguments.length?(e=typeof l=="function"?l:he(+l),n=null,s):e},s.x0=function(l){return arguments.length?(e=typeof l=="function"?l:he(+l),s):e},s.x1=function(l){return arguments.length?(n=l==null?null:typeof l=="function"?l:he(+l),s):n},s.y=function(l){return arguments.length?(t=typeof l=="function"?l:he(+l),r=null,s):t},s.y0=function(l){return arguments.length?(t=typeof l=="function"?l:he(+l),s):t},s.y1=function(l){return arguments.length?(r=l==null?null:typeof l=="function"?l:he(+l),s):r},s.lineX0=s.lineY0=function(){return f().x(e).y(t)},s.lineY1=function(){return f().x(e).y(r)},s.lineX1=function(){return f().x(n).y(t)},s.defined=function(l){return arguments.length?(i=typeof l=="function"?l:he(!!l),s):i},s.curve=function(l){return arguments.length?(o=l,a!=null&&(u=o(a)),s):o},s.context=function(l){return arguments.length?(l==null?a=u=null:u=o(a=l),s):a},s}class Rx{constructor(t,r){this._context=t,this._x=r}areaStart(){this._line=0}areaEnd(){this._line=NaN}lineStart(){this._point=0}lineEnd(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line}point(t,r){switch(t=+t,r=+r,this._point){case 0:{this._point=1,this._line?this._context.lineTo(t,r):this._context.moveTo(t,r);break}case 1:this._point=2;default:{this._x?this._context.bezierCurveTo(this._x0=(this._x0+t)/2,this._y0,this._x0,r,t,r):this._context.bezierCurveTo(this._x0,this._y0=(this._y0+r)/2,t,this._y0,t,r);break}}this._x0=t,this._y0=r}}function dA(e){return new Rx(e,!0)}function vA(e){return new Rx(e,!1)}const Rh={draw(e,t){const r=pt(t/Wi);e.moveTo(r,0),e.arc(0,0,r,0,za)}},yA={draw(e,t){const r=pt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}},Dx=pt(1/3),gA=Dx*2,mA={draw(e,t){const r=pt(t/gA),n=r*Dx;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}},bA={draw(e,t){const r=pt(t),n=-r/2;e.rect(n,n,r,r)}},xA=.8908130915292852,Nx=Ui(Wi/10)/Ui(7*Wi/10),wA=Ui(za/10)*Nx,OA=-jx(za/10)*Nx,_A={draw(e,t){const r=pt(t*xA),n=wA*r,i=OA*r;e.moveTo(0,-r),e.lineTo(n,i);for(let a=1;a<5;++a){const o=za*a/5,u=jx(o),c=Ui(o);e.lineTo(c*r,-u*r),e.lineTo(u*n-c*i,c*n+u*i)}e.closePath()}},Lu=pt(3),AA={draw(e,t){const r=-pt(t/(Lu*3));e.moveTo(0,r*2),e.lineTo(-Lu*r,-r),e.lineTo(Lu*r,-r),e.closePath()}},Je=-.5,Qe=pt(3)/2,ff=1/pt(12),SA=(ff/2+1)*3,PA={draw(e,t){const r=pt(t/SA),n=r/2,i=r*ff,a=n,o=r*ff+r,u=-a,c=o;e.moveTo(n,i),e.lineTo(a,o),e.lineTo(u,c),e.lineTo(Je*n-Qe*i,Qe*n+Je*i),e.lineTo(Je*a-Qe*o,Qe*a+Je*o),e.lineTo(Je*u-Qe*c,Qe*u+Je*c),e.lineTo(Je*n+Qe*i,Je*i-Qe*n),e.lineTo(Je*a+Qe*o,Je*o-Qe*a),e.lineTo(Je*u+Qe*c,Je*c-Qe*u),e.closePath()}};function TA(e,t){let r=null,n=Ch(i);e=typeof e=="function"?e:he(e||Rh),t=typeof t=="function"?t:he(t===void 0?64:+t);function i(){let a;if(r||(r=a=n()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),a)return r=null,a+""||null}return i.type=function(a){return arguments.length?(e=typeof a=="function"?a:he(a),i):e},i.size=function(a){return arguments.length?(t=typeof a=="function"?a:he(+a),i):t},i.context=function(a){return arguments.length?(r=a??null,i):r},i}function zi(){}function Ki(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function qx(e){this._context=e}qx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Ki(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Ki(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function EA(e){return new qx(e)}function Lx(e){this._context=e}Lx.prototype={areaStart:zi,areaEnd:zi,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Ki(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function jA(e){return new Lx(e)}function Bx(e){this._context=e}Bx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Ki(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function MA(e){return new Bx(e)}function Fx(e){this._context=e}Fx.prototype={areaStart:zi,areaEnd:zi,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}};function $A(e){return new Fx(e)}function sv(e){return e<0?-1:1}function lv(e,t,r){var n=e._x1-e._x0,i=t-e._x1,a=(e._y1-e._y0)/(n||i<0&&-0),o=(r-e._y1)/(i||n<0&&-0),u=(a*i+o*n)/(n+i);return(sv(a)+sv(o))*Math.min(Math.abs(a),Math.abs(o),.5*Math.abs(u))||0}function fv(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function Bu(e,t,r){var n=e._x0,i=e._y0,a=e._x1,o=e._y1,u=(a-n)/3;e._context.bezierCurveTo(n+u,i+u*t,a-u,o-u*r,a,o)}function Hi(e){this._context=e}Hi.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:Bu(this,this._t0,fv(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,Bu(this,fv(this,r=lv(this,e,t)),r);break;default:Bu(this,this._t0,r=lv(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};function Ux(e){this._context=new Wx(e)}(Ux.prototype=Object.create(Hi.prototype)).point=function(e,t){Hi.prototype.point.call(this,t,e)};function Wx(e){this._context=e}Wx.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,a){this._context.bezierCurveTo(t,e,n,r,a,i)}};function IA(e){return new Hi(e)}function CA(e){return new Ux(e)}function zx(e){this._context=e}zx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=hv(e),i=hv(t),a=0,o=1;o=0;--t)i[t]=(o[t]-i[t+1])/a[t];for(a[r-1]=(e[r]+i[r-1])/2,t=0;t=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}};function RA(e){return new Ha(e,.5)}function DA(e){return new Ha(e,0)}function NA(e){return new Ha(e,1)}function Ir(e,t){if((o=e.length)>1)for(var r=1,n,i,a=e[t[0]],o,u=a.length;r=0;)r[t]=t;return r}function qA(e,t){return e[t]}function LA(e){const t=[];return t.key=e,t}function BA(){var e=he([]),t=hf,r=Ir,n=qA;function i(a){var o=Array.from(e.apply(this,arguments),LA),u,c=o.length,s=-1,f;for(const l of a)for(u=0,++s;u0){for(var r,n,i=0,a=e[0].length,o;i0){for(var r=0,n=e[t[0]],i,a=n.length;r0)||!((a=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,a,o;n=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function XA(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}var Kx={symbolCircle:Rh,symbolCross:yA,symbolDiamond:mA,symbolSquare:bA,symbolStar:_A,symbolTriangle:AA,symbolWye:PA},YA=Math.PI/180,ZA=function(t){var r="symbol".concat(Wa(t));return Kx[r]||Rh},JA=function(t,r,n){if(r==="area")return t;switch(n){case"cross":return 5*t*t/9;case"diamond":return .5*t*t/Math.sqrt(3);case"square":return t*t;case"star":{var i=18*YA;return 1.25*t*t*(Math.tan(i)-Math.tan(i*2)*Math.pow(Math.tan(i),2))}case"triangle":return Math.sqrt(3)*t*t/4;case"wye":return(21-10*Math.sqrt(3))*t*t/8;default:return Math.PI*t*t/4}},QA=function(t,r){Kx["symbol".concat(Wa(t))]=r},Dh=function(t){var r=t.type,n=r===void 0?"circle":r,i=t.size,a=i===void 0?64:i,o=t.sizeType,u=o===void 0?"area":o,c=VA(t,zA),s=dv(dv({},c),{},{type:n,size:a,sizeType:u}),f=function(){var d=ZA(n),m=TA().type(d).size(JA(a,u,n));return m()},l=s.className,h=s.cx,p=s.cy,y=K(s,!0);return h===+h&&p===+p&&a===+a?S.createElement("path",pf({},y,{className:te("recharts-symbols",l),transform:"translate(".concat(h,", ").concat(p,")"),d:f()})):null};Dh.registerSymbol=QA;function Cr(e){"@babel/helpers - typeof";return Cr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Cr(e)}function df(){return df=Object.assign?Object.assign.bind():function(e){for(var t=1;t`);var x=p.inactive?s:p.color;return S.createElement("li",df({className:d,style:l,key:"legend-item-".concat(y)},cr(n.props,p,y)),S.createElement(uf,{width:o,height:o,viewBox:f,style:h},n.renderIcon(p)),S.createElement("span",{className:"recharts-legend-item-text",style:{color:x}},v?v(m,p,y):m))})}},{key:"render",value:function(){var n=this.props,i=n.payload,a=n.layout,o=n.align;if(!i||!i.length)return null;var u={padding:0,margin:0,textAlign:a==="horizontal"?o:"left"};return S.createElement("ul",{className:"recharts-default-legend",style:u},this.renderItems())}}])})(N.PureComponent);Nn(Nh,"displayName","Legend");Nn(Nh,"defaultProps",{iconSize:14,layout:"horizontal",align:"center",verticalAlign:"middle",inactiveColor:"#ccc"});var Fu,yv;function sS(){if(yv)return Fu;yv=1;var e=Ba();function t(){this.__data__=new e,this.size=0}return Fu=t,Fu}var Uu,gv;function lS(){if(gv)return Uu;gv=1;function e(t){var r=this.__data__,n=r.delete(t);return this.size=r.size,n}return Uu=e,Uu}var Wu,mv;function fS(){if(mv)return Wu;mv=1;function e(t){return this.__data__.get(t)}return Wu=e,Wu}var zu,bv;function hS(){if(bv)return zu;bv=1;function e(t){return this.__data__.has(t)}return zu=e,zu}var Ku,xv;function pS(){if(xv)return Ku;xv=1;var e=Ba(),t=Th(),r=Eh(),n=200;function i(a,o){var u=this.__data__;if(u instanceof e){var c=u.__data__;if(!t||c.lengthp))return!1;var v=l.get(o),d=l.get(u);if(v&&d)return v==u&&d==o;var m=-1,x=!0,w=c&i?new e:void 0;for(l.set(o,u),l.set(u,o);++m-1&&n%1==0&&n-1&&r%1==0&&r<=e}return pc=t,pc}var dc,zv;function OS(){if(zv)return dc;zv=1;var e=kt(),t=Kh(),r=ft(),n="[object Arguments]",i="[object Array]",a="[object Boolean]",o="[object Date]",u="[object Error]",c="[object Function]",s="[object Map]",f="[object Number]",l="[object Object]",h="[object RegExp]",p="[object Set]",y="[object String]",v="[object WeakMap]",d="[object ArrayBuffer]",m="[object DataView]",x="[object Float32Array]",w="[object Float64Array]",O="[object Int8Array]",g="[object Int16Array]",b="[object Int32Array]",_="[object Uint8Array]",A="[object Uint8ClampedArray]",P="[object Uint16Array]",j="[object Uint32Array]",T={};T[x]=T[w]=T[O]=T[g]=T[b]=T[_]=T[A]=T[P]=T[j]=!0,T[n]=T[i]=T[d]=T[a]=T[m]=T[o]=T[u]=T[c]=T[s]=T[f]=T[l]=T[h]=T[p]=T[y]=T[v]=!1;function E(M){return r(M)&&t(M.length)&&!!T[e(M)]}return dc=E,dc}var vc,Kv;function Ga(){if(Kv)return vc;Kv=1;function e(t){return function(r){return t(r)}}return vc=e,vc}var Pn={exports:{}};Pn.exports;var Hv;function Hh(){return Hv||(Hv=1,(function(e,t){var r=wx(),n=t&&!t.nodeType&&t,i=n&&!0&&e&&!e.nodeType&&e,a=i&&i.exports===n,o=a&&r.process,u=(function(){try{var c=i&&i.require&&i.require("util").types;return c||o&&o.binding&&o.binding("util")}catch{}})();e.exports=u})(Pn,Pn.exports)),Pn.exports}var yc,Gv;function tw(){if(Gv)return yc;Gv=1;var e=OS(),t=Ga(),r=Hh(),n=r&&r.isTypedArray,i=n?t(n):e;return yc=i,yc}var gc,Vv;function rw(){if(Vv)return gc;Vv=1;var e=bS(),t=Uh(),r=Fe(),n=Wh(),i=zh(),a=tw(),o=Object.prototype,u=o.hasOwnProperty;function c(s,f){var l=r(s),h=!l&&t(s),p=!l&&!h&&n(s),y=!l&&!h&&!p&&a(s),v=l||h||p||y,d=v?e(s.length,String):[],m=d.length;for(var x in s)(f||u.call(s,x))&&!(v&&(x=="length"||p&&(x=="offset"||x=="parent")||y&&(x=="buffer"||x=="byteLength"||x=="byteOffset")||i(x,m)))&&d.push(x);return d}return gc=c,gc}var mc,Xv;function Gh(){if(Xv)return mc;Xv=1;var e=Object.prototype;function t(r){var n=r&&r.constructor,i=typeof n=="function"&&n.prototype||e;return r===i}return mc=t,mc}var bc,Yv;function nw(){if(Yv)return bc;Yv=1;function e(t,r){return function(n){return t(r(n))}}return bc=e,bc}var xc,Zv;function _S(){if(Zv)return xc;Zv=1;var e=nw(),t=e(Object.keys,Object);return xc=t,xc}var wc,Jv;function AS(){if(Jv)return wc;Jv=1;var e=Gh(),t=_S(),r=Object.prototype,n=r.hasOwnProperty;function i(a){if(!e(a))return t(a);var o=[];for(var u in Object(a))n.call(a,u)&&u!="constructor"&&o.push(u);return o}return wc=i,wc}var Oc,Qv;function cn(){if(Qv)return Oc;Qv=1;var e=Ph(),t=Kh();function r(n){return n!=null&&t(n.length)&&!e(n)}return Oc=r,Oc}var _c,ey;function sn(){if(ey)return _c;ey=1;var e=rw(),t=AS(),r=cn();function n(i){return r(i)?e(i):t(i)}return _c=n,_c}var Ac,ty;function iw(){if(ty)return Ac;ty=1;var e=Qx(),t=Fh(),r=sn();function n(i){return e(i,r,t)}return Ac=n,Ac}var Sc,ry;function SS(){if(ry)return Sc;ry=1;var e=iw(),t=1,r=Object.prototype,n=r.hasOwnProperty;function i(a,o,u,c,s,f){var l=u&t,h=e(a),p=h.length,y=e(o),v=y.length;if(p!=v&&!l)return!1;for(var d=p;d--;){var m=h[d];if(!(l?m in o:n.call(o,m)))return!1}var x=f.get(a),w=f.get(o);if(x&&w)return x==o&&w==a;var O=!0;f.set(a,o),f.set(o,a);for(var g=l;++d-1}return Zc=t,Zc}var Jc,jy;function zS(){if(jy)return Jc;jy=1;function e(t,r,n){for(var i=-1,a=t==null?0:t.length;++i=o){var m=s?null:i(c);if(m)return a(m);y=!1,h=n,d=new e}else d=s?[]:v;e:for(;++l=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function aP(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function oP(e){return e.value}function uP(e,t){if(S.isValidElement(e))return S.cloneElement(e,t);if(typeof e=="function")return S.createElement(e,t);t.ref;var r=iP(t,YS);return S.createElement(Nh,r)}var Ny=1,jr=(function(e){function t(){var r;ZS(this,t);for(var n=arguments.length,i=new Array(n),a=0;aNy||Math.abs(i.height-this.lastBoundingBox.height)>Ny)&&(this.lastBoundingBox.width=i.width,this.lastBoundingBox.height=i.height,n&&n(i)):(this.lastBoundingBox.width!==-1||this.lastBoundingBox.height!==-1)&&(this.lastBoundingBox.width=-1,this.lastBoundingBox.height=-1,n&&n(null))}},{key:"getBBoxSnapshot",value:function(){return this.lastBoundingBox.width>=0&&this.lastBoundingBox.height>=0?Ot({},this.lastBoundingBox):{width:0,height:0}}},{key:"getDefaultPosition",value:function(n){var i=this.props,a=i.layout,o=i.align,u=i.verticalAlign,c=i.margin,s=i.chartWidth,f=i.chartHeight,l,h;if(!n||(n.left===void 0||n.left===null)&&(n.right===void 0||n.right===null))if(o==="center"&&a==="vertical"){var p=this.getBBoxSnapshot();l={left:((s||0)-p.width)/2}}else l=o==="right"?{right:c&&c.right||0}:{left:c&&c.left||0};if(!n||(n.top===void 0||n.top===null)&&(n.bottom===void 0||n.bottom===null))if(u==="middle"){var y=this.getBBoxSnapshot();h={top:((f||0)-y.height)/2}}else h=u==="bottom"?{bottom:c&&c.bottom||0}:{top:c&&c.top||0};return Ot(Ot({},l),h)}},{key:"render",value:function(){var n=this,i=this.props,a=i.content,o=i.width,u=i.height,c=i.wrapperStyle,s=i.payloadUniqBy,f=i.payload,l=Ot(Ot({position:"absolute",width:o||"auto",height:u||"auto"},this.getDefaultPosition(c)),c);return S.createElement("div",{className:"recharts-legend-wrapper",style:l,ref:function(p){n.wrapperNode=p}},uP(a,Ot(Ot({},this.props),{},{payload:sw(f,s,oP)})))}}],[{key:"getWithHeight",value:function(n,i){var a=Ot(Ot({},this.defaultProps),n.props),o=a.layout;return o==="vertical"&&q(n.props.height)?{height:n.props.height}:o==="horizontal"?{width:n.props.width||i}:null}}])})(N.PureComponent);Xa(jr,"displayName","Legend");Xa(jr,"defaultProps",{iconSize:14,layout:"horizontal",align:"center",verticalAlign:"bottom"});var ns,qy;function cP(){if(qy)return ns;qy=1;var e=nn(),t=Uh(),r=Fe(),n=e?e.isConcatSpreadable:void 0;function i(a){return r(a)||t(a)||!!(n&&a&&a[n])}return ns=i,ns}var is,Ly;function Xh(){if(Ly)return is;Ly=1;var e=Bh(),t=cP();function r(n,i,a,o,u){var c=-1,s=n.length;for(a||(a=t),u||(u=[]);++c0&&a(f)?i>1?r(f,i-1,a,o,u):e(u,f):o||(u[u.length]=f)}return u}return is=r,is}var as,By;function sP(){if(By)return as;By=1;function e(t){return function(r,n,i){for(var a=-1,o=Object(r),u=i(r),c=u.length;c--;){var s=u[t?c:++a];if(n(o[s],s,o)===!1)break}return r}}return as=e,as}var os,Fy;function lP(){if(Fy)return os;Fy=1;var e=sP(),t=e();return os=t,os}var us,Uy;function hw(){if(Uy)return us;Uy=1;var e=lP(),t=sn();function r(n,i){return n&&e(n,i,t)}return us=r,us}var cs,Wy;function fP(){if(Wy)return cs;Wy=1;var e=cn();function t(r,n){return function(i,a){if(i==null)return i;if(!e(i))return r(i,a);for(var o=i.length,u=n?o:-1,c=Object(i);(n?u--:++un||u&&c&&f&&!s&&!l||a&&c&&f||!i&&f||!o)return 1;if(!a&&!u&&!l&&r=s)return f;var l=i[a];return f*(l=="desc"?-1:1)}}return r.index-n.index}return ps=t,ps}var ds,Xy;function vP(){if(Xy)return ds;Xy=1;var e=jh(),t=Mh(),r=xt(),n=pw(),i=hP(),a=Ga(),o=dP(),u=ln(),c=Fe();function s(f,l,h){l.length?l=e(l,function(v){return c(v)?function(d){return t(d,v.length===1?v[0]:v)}:v}):l=[u];var p=-1;l=e(l,a(r));var y=n(f,function(v,d,m){var x=e(l,function(w){return w(v)});return{criteria:x,index:++p,value:v}});return i(y,function(v,d){return o(v,d,h)})}return ds=s,ds}var vs,Yy;function yP(){if(Yy)return vs;Yy=1;function e(t,r,n){switch(n.length){case 0:return t.call(r);case 1:return t.call(r,n[0]);case 2:return t.call(r,n[0],n[1]);case 3:return t.call(r,n[0],n[1],n[2])}return t.apply(r,n)}return vs=e,vs}var ys,Zy;function dw(){if(Zy)return ys;Zy=1;var e=yP(),t=Math.max;function r(n,i,a){return i=t(i===void 0?n.length-1:i,0),function(){for(var o=arguments,u=-1,c=t(o.length-i,0),s=Array(c);++u0){if(++a>=e)return arguments[0]}else a=0;return i.apply(void 0,arguments)}}return xs=n,xs}var ws,rg;function yw(){if(rg)return ws;rg=1;var e=mP(),t=bP(),r=t(e);return ws=r,ws}var Os,ng;function xP(){if(ng)return Os;ng=1;var e=ln(),t=dw(),r=yw();function n(i,a){return r(t(i,a,e),i+"")}return Os=n,Os}var _s,ig;function Ya(){if(ig)return _s;ig=1;var e=qa(),t=cn(),r=zh(),n=ht();function i(a,o,u){if(!n(u))return!1;var c=typeof o;return(c=="number"?t(u)&&r(o,u.length):c=="string"&&o in u)?e(u[o],a):!1}return _s=i,_s}var As,ag;function wP(){if(ag)return As;ag=1;var e=Xh(),t=vP(),r=xP(),n=Ya(),i=r(function(a,o){if(a==null)return[];var u=o.length;return u>1&&n(a,o[0],o[1])?o=[]:u>2&&n(o[0],o[1],o[2])&&(o=[o[0]]),t(a,e(o,1),[])});return As=i,As}var OP=wP();const Zh=ce(OP);function qn(e){"@babel/helpers - typeof";return qn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},qn(e)}function gf(){return gf=Object.assign?Object.assign.bind():function(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,n=new Array(t);r=t.x),"".concat(yn,"-left"),q(r)&&t&&q(t.x)&&r=t.y),"".concat(yn,"-top"),q(n)&&t&&q(t.y)&&nv?Math.max(f,c[n]):Math.max(l,c[n])}function NP(e){var t=e.translateX,r=e.translateY,n=e.useTranslate3d;return{transform:n?"translate3d(".concat(t,"px, ").concat(r,"px, 0)"):"translate(".concat(t,"px, ").concat(r,"px)")}}function qP(e){var t=e.allowEscapeViewBox,r=e.coordinate,n=e.offsetTopLeft,i=e.position,a=e.reverseDirection,o=e.tooltipBox,u=e.useTranslate3d,c=e.viewBox,s,f,l;return o.height>0&&o.width>0&&r?(f=cg({allowEscapeViewBox:t,coordinate:r,key:"x",offsetTopLeft:n,position:i,reverseDirection:a,tooltipDimension:o.width,viewBox:c,viewBoxDimension:c.width}),l=cg({allowEscapeViewBox:t,coordinate:r,key:"y",offsetTopLeft:n,position:i,reverseDirection:a,tooltipDimension:o.height,viewBox:c,viewBoxDimension:c.height}),s=NP({translateX:f,translateY:l,useTranslate3d:u})):s=RP,{cssProperties:s,cssClasses:DP({translateX:f,translateY:l,coordinate:r})}}function Rr(e){"@babel/helpers - typeof";return Rr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Rr(e)}function sg(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function lg(e){for(var t=1;tfg||Math.abs(n.height-this.state.lastBoundingBox.height)>fg)&&this.setState({lastBoundingBox:{width:n.width,height:n.height}})}else(this.state.lastBoundingBox.width!==-1||this.state.lastBoundingBox.height!==-1)&&this.setState({lastBoundingBox:{width:-1,height:-1}})}},{key:"componentDidMount",value:function(){document.addEventListener("keydown",this.handleKeyDown),this.updateBBox()}},{key:"componentWillUnmount",value:function(){document.removeEventListener("keydown",this.handleKeyDown)}},{key:"componentDidUpdate",value:function(){var n,i;this.props.active&&this.updateBBox(),this.state.dismissed&&(((n=this.props.coordinate)===null||n===void 0?void 0:n.x)!==this.state.dismissedAtCoordinate.x||((i=this.props.coordinate)===null||i===void 0?void 0:i.y)!==this.state.dismissedAtCoordinate.y)&&(this.state.dismissed=!1)}},{key:"render",value:function(){var n=this,i=this.props,a=i.active,o=i.allowEscapeViewBox,u=i.animationDuration,c=i.animationEasing,s=i.children,f=i.coordinate,l=i.hasPayload,h=i.isAnimationActive,p=i.offset,y=i.position,v=i.reverseDirection,d=i.useTranslate3d,m=i.viewBox,x=i.wrapperStyle,w=qP({allowEscapeViewBox:o,coordinate:f,offsetTopLeft:p,position:y,reverseDirection:v,tooltipBox:this.state.lastBoundingBox,useTranslate3d:d,viewBox:m}),O=w.cssClasses,g=w.cssProperties,b=lg(lg({transition:h&&a?"transform ".concat(u,"ms ").concat(c):void 0},g),{},{pointerEvents:"none",visibility:!this.state.dismissed&&a&&l?"visible":"hidden",position:"absolute",top:0,left:0},x);return S.createElement("div",{tabIndex:-1,className:O,style:b,ref:function(A){n.wrapperNode=A}},s)}}])})(N.PureComponent),VP=function(){return!(typeof window<"u"&&window.document&&window.document.createElement&&window.setTimeout)},pr={isSsr:VP()};function Dr(e){"@babel/helpers - typeof";return Dr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Dr(e)}function hg(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function pg(e){for(var t=1;t0;return S.createElement(GP,{allowEscapeViewBox:o,animationDuration:u,animationEasing:c,isAnimationActive:h,active:a,coordinate:f,hasPayload:b,offset:p,position:d,reverseDirection:m,useTranslate3d:x,viewBox:w,wrapperStyle:O},iT(s,pg(pg({},this.props),{},{payload:g})))}}])})(N.PureComponent);Jh(_t,"displayName","Tooltip");Jh(_t,"defaultProps",{accessibilityLayer:!1,allowEscapeViewBox:{x:!1,y:!1},animationDuration:400,animationEasing:"ease",contentStyle:{},coordinate:{x:0,y:0},cursor:!0,cursorStyle:{},filterNull:!0,isAnimationActive:!pr.isSsr,itemStyle:{},labelStyle:{},offset:10,reverseDirection:{x:!1,y:!1},separator:" : ",trigger:"hover",useTranslate3d:!1,viewBox:{x:0,y:0,height:0,width:0},wrapperStyle:{}});var Ps,dg;function aT(){if(dg)return Ps;dg=1;var e=lt(),t=function(){return e.Date.now()};return Ps=t,Ps}var Ts,vg;function oT(){if(vg)return Ts;vg=1;var e=/\s/;function t(r){for(var n=r.length;n--&&e.test(r.charAt(n)););return n}return Ts=t,Ts}var Es,yg;function uT(){if(yg)return Es;yg=1;var e=oT(),t=/^\s+/;function r(n){return n&&n.slice(0,e(n)+1).replace(t,"")}return Es=r,Es}var js,gg;function ww(){if(gg)return js;gg=1;var e=uT(),t=ht(),r=an(),n=NaN,i=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,o=/^0o[0-7]+$/i,u=parseInt;function c(s){if(typeof s=="number")return s;if(r(s))return n;if(t(s)){var f=typeof s.valueOf=="function"?s.valueOf():s;s=t(f)?f+"":f}if(typeof s!="string")return s===0?s:+s;s=e(s);var l=a.test(s);return l||o.test(s)?u(s.slice(2),l?2:8):i.test(s)?n:+s}return js=c,js}var Ms,mg;function cT(){if(mg)return Ms;mg=1;var e=ht(),t=aT(),r=ww(),n="Expected a function",i=Math.max,a=Math.min;function o(u,c,s){var f,l,h,p,y,v,d=0,m=!1,x=!1,w=!0;if(typeof u!="function")throw new TypeError(n);c=r(c)||0,e(s)&&(m=!!s.leading,x="maxWait"in s,h=x?i(r(s.maxWait)||0,c):h,w="trailing"in s?!!s.trailing:w);function O(M){var I=f,$=l;return f=l=void 0,d=M,p=u.apply($,I),p}function g(M){return d=M,y=setTimeout(A,c),m?O(M):p}function b(M){var I=M-v,$=M-d,k=c-I;return x?a(k,h-$):k}function _(M){var I=M-v,$=M-d;return v===void 0||I>=c||I<0||x&&$>=h}function A(){var M=t();if(_(M))return P(M);y=setTimeout(A,b(M))}function P(M){return y=void 0,w&&f?O(M):(f=l=void 0,p)}function j(){y!==void 0&&clearTimeout(y),d=0,f=v=l=y=void 0}function T(){return y===void 0?p:P(t())}function E(){var M=t(),I=_(M);if(f=arguments,l=this,v=M,I){if(y===void 0)return g(v);if(x)return clearTimeout(y),y=setTimeout(A,c),O(v)}return y===void 0&&(y=setTimeout(A,c)),p}return E.cancel=j,E.flush=T,E}return Ms=o,Ms}var $s,bg;function sT(){if(bg)return $s;bg=1;var e=cT(),t=ht(),r="Expected a function";function n(i,a,o){var u=!0,c=!0;if(typeof i!="function")throw new TypeError(r);return t(o)&&(u="leading"in o?!!o.leading:u,c="trailing"in o?!!o.trailing:c),e(i,a,{leading:u,maxWait:a,trailing:c})}return $s=n,$s}var lT=sT();const Ow=ce(lT);function Bn(e){"@babel/helpers - typeof";return Bn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Bn(e)}function xg(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function Ti(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,n=new Array(t);r0&&(M=Ow(M,v,{trailing:!0,leading:!1}));var I=new ResizeObserver(M),$=g.current.getBoundingClientRect(),k=$.width,R=$.height;return T(k,R),I.observe(g.current),function(){I.disconnect()}},[T,v]);var E=N.useMemo(function(){var M=P.containerWidth,I=P.containerHeight;if(M<0||I<0)return null;st(er(o)||er(c),`The width(%s) and height(%s) are both fixed numbers,
+ maybe you don't need to use a ResponsiveContainer.`,o,c),st(!r||r>0,"The aspect(%s) must be greater than zero.",r);var $=er(o)?M:o,k=er(c)?I:c;r&&r>0&&($?k=$/r:k&&($=k*r),h&&k>h&&(k=h)),st($>0||k>0,`The width(%s) and height(%s) of chart should be greater than 0,
+ please check the style of container, or the props width(%s) and height(%s),
+ or add a minWidth(%s) or minHeight(%s) or use aspect(%s) to control the
+ height and width.`,$,k,o,c,f,l,r);var R=!Array.isArray(p)&&Et(p.type).endsWith("Chart");return S.Children.map(p,function(L){return S.isValidElement(L)?N.cloneElement(L,Ti({width:$,height:k},R?{style:Ti({height:"100%",width:"100%",maxHeight:k,maxWidth:$},L.props.style)}:{})):L})},[r,p,c,h,l,f,P,o]);return S.createElement("div",{id:d?"".concat(d):void 0,className:te("recharts-responsive-container",m),style:Ti(Ti({},O),{},{width:o,height:c,minWidth:f,minHeight:l,maxHeight:h}),ref:g},E)}),Qh=function(t){return null};Qh.displayName="Cell";function Fn(e){"@babel/helpers - typeof";return Fn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Fn(e)}function Og(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function wf(e){for(var t=1;t1&&arguments[1]!==void 0?arguments[1]:{};if(t==null||pr.isSsr)return{width:0,height:0};var n=AT(r),i=JSON.stringify({text:t,copyStyle:n});if(br.widthCache[i])return br.widthCache[i];try{var a=document.getElementById(_g);a||(a=document.createElement("span"),a.setAttribute("id",_g),a.setAttribute("aria-hidden","true"),document.body.appendChild(a));var o=wf(wf({},_T),n);Object.assign(a.style,o),a.textContent="".concat(t);var u=a.getBoundingClientRect(),c={width:u.width,height:u.height};return br.widthCache[i]=c,++br.cacheCount>OT&&(br.cacheCount=0,br.widthCache={}),c}catch{return{width:0,height:0}}},ST=function(t){return{top:t.top+window.scrollY-document.documentElement.clientTop,left:t.left+window.scrollX-document.documentElement.clientLeft}};function Un(e){"@babel/helpers - typeof";return Un=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Un(e)}function Zi(e,t){return jT(e)||ET(e,t)||TT(e,t)||PT()}function PT(){throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function TT(e,t){if(e){if(typeof e=="string")return Ag(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return Ag(e,t)}}function Ag(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r=0)&&Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function WT(e,t){if(e==null)return{};var r={};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)){if(t.indexOf(n)>=0)continue;r[n]=e[n]}return r}function Mg(e,t){return GT(e)||HT(e,t)||KT(e,t)||zT()}function zT(){throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function KT(e,t){if(e){if(typeof e=="string")return $g(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if(r==="Object"&&e.constructor&&(r=e.constructor.name),r==="Map"||r==="Set")return Array.from(e);if(r==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return $g(e,t)}}function $g(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r0&&arguments[0]!==void 0?arguments[0]:[];return $.reduce(function(k,R){var L=R.word,B=R.width,z=k[k.length-1];if(z&&(i==null||a||z.width+B+nR.width?k:R})};if(!f)return p;for(var v="…",d=function($){var k=l.slice(0,$),R=Pw({breakAll:s,style:c,children:k+v}).wordsWithComputedWidth,L=h(R),B=L.length>o||y(L).width>Number(i);return[B,L]},m=0,x=l.length-1,w=0,O;m<=x&&w<=l.length-1;){var g=Math.floor((m+x)/2),b=g-1,_=d(b),A=Mg(_,2),P=A[0],j=A[1],T=d(g),E=Mg(T,1),M=E[0];if(!P&&!M&&(m=g+1),P&&M&&(x=g-1),!P&&M){O=j;break}w++}return O||p},Ig=function(t){var r=J(t)?[]:t.toString().split(Sw);return[{words:r}]},XT=function(t){var r=t.width,n=t.scaleToFit,i=t.children,a=t.style,o=t.breakAll,u=t.maxLines;if((r||n)&&!pr.isSsr){var c,s,f=Pw({breakAll:o,children:i,style:a});if(f){var l=f.wordsWithComputedWidth,h=f.spaceWidth;c=l,s=h}else return Ig(i);return VT({breakAll:o,children:i,maxLines:u,style:a},c,s,r,n)}return Ig(i)},Cg="#808080",sr=function(t){var r=t.x,n=r===void 0?0:r,i=t.y,a=i===void 0?0:i,o=t.lineHeight,u=o===void 0?"1em":o,c=t.capHeight,s=c===void 0?"0.71em":c,f=t.scaleToFit,l=f===void 0?!1:f,h=t.textAnchor,p=h===void 0?"start":h,y=t.verticalAnchor,v=y===void 0?"end":y,d=t.fill,m=d===void 0?Cg:d,x=jg(t,FT),w=N.useMemo(function(){return XT({breakAll:x.breakAll,children:x.children,maxLines:x.maxLines,scaleToFit:l,style:x.style,width:x.width})},[x.breakAll,x.children,x.maxLines,l,x.style,x.width]),O=x.dx,g=x.dy,b=x.angle,_=x.className,A=x.breakAll,P=jg(x,UT);if(!Se(n)||!Se(a))return null;var j=n+(q(O)?O:0),T=a+(q(g)?g:0),E;switch(v){case"start":E=Is("calc(".concat(s,")"));break;case"middle":E=Is("calc(".concat((w.length-1)/2," * -").concat(u," + (").concat(s," / 2))"));break;default:E=Is("calc(".concat(w.length-1," * -").concat(u,")"));break}var M=[];if(l){var I=w[0].width,$=x.width;M.push("scale(".concat((q($)?$/I:1)/I,")"))}return b&&M.push("rotate(".concat(b,", ").concat(j,", ").concat(T,")")),M.length&&(P.transform=M.join(" ")),S.createElement("text",Of({},K(P,!0),{x:j,y:T,className:te("recharts-text",_),textAnchor:p,fill:m.includes("url")?Cg:m}),w.map(function(k,R){var L=k.words.join(A?"":" ");return S.createElement("tspan",{x:j,dy:R===0?E:u,key:"".concat(L,"-").concat(R)},L)}))};function Bt(e,t){return e==null||t==null?NaN:et?1:e>=t?0:NaN}function YT(e,t){return e==null||t==null?NaN:te?1:t>=e?0:NaN}function ep(e){let t,r,n;e.length!==2?(t=Bt,r=(u,c)=>Bt(e(u),c),n=(u,c)=>e(u)-c):(t=e===Bt||e===YT?e:ZT,r=e,n=e);function i(u,c,s=0,f=u.length){if(s>>1;r(u[l],c)<0?s=l+1:f=l}while(s>>1;r(u[l],c)<=0?s=l+1:f=l}while(ss&&n(u[l-1],c)>-n(u[l],c)?l-1:l}return{left:i,center:o,right:a}}function ZT(){return 0}function Tw(e){return e===null?NaN:+e}function*JT(e,t){for(let r of e)r!=null&&(r=+r)>=r&&(yield r)}const QT=ep(Bt),mi=QT.right;ep(Tw).center;class kg extends Map{constructor(t,r=rE){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:r}}),t!=null)for(const[n,i]of t)this.set(n,i)}get(t){return super.get(Rg(this,t))}has(t){return super.has(Rg(this,t))}set(t,r){return super.set(eE(this,t),r)}delete(t){return super.delete(tE(this,t))}}function Rg({_intern:e,_key:t},r){const n=t(r);return e.has(n)?e.get(n):r}function eE({_intern:e,_key:t},r){const n=t(r);return e.has(n)?e.get(n):(e.set(n,r),r)}function tE({_intern:e,_key:t},r){const n=t(r);return e.has(n)&&(r=e.get(n),e.delete(n)),r}function rE(e){return e!==null&&typeof e=="object"?e.valueOf():e}function nE(e=Bt){if(e===Bt)return Ew;if(typeof e!="function")throw new TypeError("compare is not a function");return(t,r)=>{const n=e(t,r);return n||n===0?n:(e(r,r)===0)-(e(t,t)===0)}}function Ew(e,t){return(e==null||!(e>=e))-(t==null||!(t>=t))||(et?1:0)}const iE=Math.sqrt(50),aE=Math.sqrt(10),oE=Math.sqrt(2);function Ji(e,t,r){const n=(t-e)/Math.max(0,r),i=Math.floor(Math.log10(n)),a=n/Math.pow(10,i),o=a>=iE?10:a>=aE?5:a>=oE?2:1;let u,c,s;return i<0?(s=Math.pow(10,-i)/o,u=Math.round(e*s),c=Math.round(t*s),u/st&&--c,s=-s):(s=Math.pow(10,i)*o,u=Math.round(e/s),c=Math.round(t/s),u*st&&--c),c0))return[];if(e===t)return[e];const n=t=i))return[];const u=a-i+1,c=new Array(u);if(n)if(o<0)for(let s=0;s=n)&&(r=n);return r}function Ng(e,t){let r;for(const n of e)n!=null&&(r>n||r===void 0&&n>=n)&&(r=n);return r}function jw(e,t,r=0,n=1/0,i){if(t=Math.floor(t),r=Math.floor(Math.max(0,r)),n=Math.floor(Math.min(e.length-1,n)),!(r<=t&&t<=n))return e;for(i=i===void 0?Ew:nE(i);n>r;){if(n-r>600){const c=n-r+1,s=t-r+1,f=Math.log(c),l=.5*Math.exp(2*f/3),h=.5*Math.sqrt(f*l*(c-l)/c)*(s-c/2<0?-1:1),p=Math.max(r,Math.floor(t-s*l/c+h)),y=Math.min(n,Math.floor(t+(c-s)*l/c+h));jw(e,t,p,y,i)}const a=e[t];let o=r,u=n;for(gn(e,r,t),i(e[n],a)>0&&gn(e,r,n);o0;)--u}i(e[r],a)===0?gn(e,r,u):(++u,gn(e,u,n)),u<=t&&(r=u+1),t<=u&&(n=u-1)}return e}function gn(e,t,r){const n=e[t];e[t]=e[r],e[r]=n}function uE(e,t,r){if(e=Float64Array.from(JT(e)),!(!(n=e.length)||isNaN(t=+t))){if(t<=0||n<2)return Ng(e);if(t>=1)return Dg(e);var n,i=(n-1)*t,a=Math.floor(i),o=Dg(jw(e,a).subarray(0,a+1)),u=Ng(e.subarray(a+1));return o+(u-o)*(i-a)}}function cE(e,t,r=Tw){if(!(!(n=e.length)||isNaN(t=+t))){if(t<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,a=Math.floor(i),o=+r(e[a],a,e),u=+r(e[a+1],a+1,e);return o+(u-o)*(i-a)}}function sE(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,a=new Array(i);++n>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?ji(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?ji(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=fE.exec(e))?new Ue(t[1],t[2],t[3],1):(t=hE.exec(e))?new Ue(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=pE.exec(e))?ji(t[1],t[2],t[3],t[4]):(t=dE.exec(e))?ji(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=vE.exec(e))?zg(t[1],t[2]/100,t[3]/100,1):(t=yE.exec(e))?zg(t[1],t[2]/100,t[3]/100,t[4]):qg.hasOwnProperty(e)?Fg(qg[e]):e==="transparent"?new Ue(NaN,NaN,NaN,0):null}function Fg(e){return new Ue(e>>16&255,e>>8&255,e&255,1)}function ji(e,t,r,n){return n<=0&&(e=t=r=NaN),new Ue(e,t,r,n)}function bE(e){return e instanceof bi||(e=Hn(e)),e?(e=e.rgb(),new Ue(e.r,e.g,e.b,e.opacity)):new Ue}function Tf(e,t,r,n){return arguments.length===1?bE(e):new Ue(e,t,r,n??1)}function Ue(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}rp(Ue,Tf,$w(bi,{brighter(e){return e=e==null?Qi:Math.pow(Qi,e),new Ue(this.r*e,this.g*e,this.b*e,this.opacity)},darker(e){return e=e==null?zn:Math.pow(zn,e),new Ue(this.r*e,this.g*e,this.b*e,this.opacity)},rgb(){return this},clamp(){return new Ue(ir(this.r),ir(this.g),ir(this.b),ea(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Ug,formatHex:Ug,formatHex8:xE,formatRgb:Wg,toString:Wg}));function Ug(){return`#${tr(this.r)}${tr(this.g)}${tr(this.b)}`}function xE(){return`#${tr(this.r)}${tr(this.g)}${tr(this.b)}${tr((isNaN(this.opacity)?1:this.opacity)*255)}`}function Wg(){const e=ea(this.opacity);return`${e===1?"rgb(":"rgba("}${ir(this.r)}, ${ir(this.g)}, ${ir(this.b)}${e===1?")":`, ${e})`}`}function ea(e){return isNaN(e)?1:Math.max(0,Math.min(1,e))}function ir(e){return Math.max(0,Math.min(255,Math.round(e)||0))}function tr(e){return e=ir(e),(e<16?"0":"")+e.toString(16)}function zg(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new ct(e,t,r,n)}function Iw(e){if(e instanceof ct)return new ct(e.h,e.s,e.l,e.opacity);if(e instanceof bi||(e=Hn(e)),!e)return new ct;if(e instanceof ct)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),a=Math.max(t,r,n),o=NaN,u=a-i,c=(a+i)/2;return u?(t===a?o=(r-n)/u+(r0&&c<1?0:o,new ct(o,u,c,e.opacity)}function wE(e,t,r,n){return arguments.length===1?Iw(e):new ct(e,t,r,n??1)}function ct(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}rp(ct,wE,$w(bi,{brighter(e){return e=e==null?Qi:Math.pow(Qi,e),new ct(this.h,this.s,this.l*e,this.opacity)},darker(e){return e=e==null?zn:Math.pow(zn,e),new ct(this.h,this.s,this.l*e,this.opacity)},rgb(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new Ue(Cs(e>=240?e-240:e+120,i,n),Cs(e,i,n),Cs(e<120?e+240:e-120,i,n),this.opacity)},clamp(){return new ct(Kg(this.h),Mi(this.s),Mi(this.l),ea(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const e=ea(this.opacity);return`${e===1?"hsl(":"hsla("}${Kg(this.h)}, ${Mi(this.s)*100}%, ${Mi(this.l)*100}%${e===1?")":`, ${e})`}`}}));function Kg(e){return e=(e||0)%360,e<0?e+360:e}function Mi(e){return Math.max(0,Math.min(1,e||0))}function Cs(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}const np=e=>()=>e;function OE(e,t){return function(r){return e+r*t}}function _E(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function AE(e){return(e=+e)==1?Cw:function(t,r){return r-t?_E(t,r,e):np(isNaN(t)?r:t)}}function Cw(e,t){var r=t-e;return r?OE(e,r):np(isNaN(e)?t:e)}const Hg=(function e(t){var r=AE(t);function n(i,a){var o=r((i=Tf(i)).r,(a=Tf(a)).r),u=r(i.g,a.g),c=r(i.b,a.b),s=Cw(i.opacity,a.opacity);return function(f){return i.r=o(f),i.g=u(f),i.b=c(f),i.opacity=s(f),i+""}}return n.gamma=e,n})(1);function SE(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(a){for(i=0;ir&&(a=t.slice(r,a),u[o]?u[o]+=a:u[++o]=a),(n=n[0])===(i=i[0])?u[o]?u[o]+=i:u[++o]=i:(u[++o]=null,c.push({i:o,x:dt(n,i)})),r=ks.lastIndex;return r180?f+=360:f-s>180&&(s+=360),h.push({i:l.push(i(l)+"rotate(",null,n)-2,x:dt(s,f)})):f&&l.push(i(l)+"rotate("+f+n)}function u(s,f,l,h){s!==f?h.push({i:l.push(i(l)+"skewX(",null,n)-2,x:dt(s,f)}):f&&l.push(i(l)+"skewX("+f+n)}function c(s,f,l,h,p,y){if(s!==l||f!==h){var v=p.push(i(p)+"scale(",null,",",null,")");y.push({i:v-4,x:dt(s,l)},{i:v-2,x:dt(f,h)})}else(l!==1||h!==1)&&p.push(i(p)+"scale("+l+","+h+")")}return function(s,f){var l=[],h=[];return s=e(s),f=e(f),a(s.translateX,s.translateY,f.translateX,f.translateY,l,h),o(s.rotate,f.rotate,l,h),u(s.skewX,f.skewX,l,h),c(s.scaleX,s.scaleY,f.scaleX,f.scaleY,l,h),s=f=null,function(p){for(var y=-1,v=h.length,d;++yt&&(r=e,e=t,t=r),function(n){return Math.max(e,Math.min(t,n))}}function FE(e,t,r){var n=e[0],i=e[1],a=t[0],o=t[1];return i2?UE:FE,c=s=null,l}function l(h){return h==null||isNaN(h=+h)?a:(c||(c=u(e.map(n),t,r)))(n(o(h)))}return l.invert=function(h){return o(i((s||(s=u(t,e.map(n),dt)))(h)))},l.domain=function(h){return arguments.length?(e=Array.from(h,ta),f()):e.slice()},l.range=function(h){return arguments.length?(t=Array.from(h),f()):t.slice()},l.rangeRound=function(h){return t=Array.from(h),r=ip,f()},l.clamp=function(h){return arguments.length?(o=h?!0:Be,f()):o!==Be},l.interpolate=function(h){return arguments.length?(r=h,f()):r},l.unknown=function(h){return arguments.length?(a=h,l):a},function(h,p){return n=h,i=p,f()}}function ap(){return Za()(Be,Be)}function WE(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function ra(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}function Nr(e){return e=ra(Math.abs(e)),e?e[1]:NaN}function zE(e,t){return function(r,n){for(var i=r.length,a=[],o=0,u=e[0],c=0;i>0&&u>0&&(c+u+1>n&&(u=Math.max(1,n-c)),a.push(r.substring(i-=u,i+u)),!((c+=u+1)>n));)u=e[o=(o+1)%e.length];return a.reverse().join(t)}}function KE(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var HE=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Gn(e){if(!(t=HE.exec(e)))throw new Error("invalid format: "+e);var t;return new op({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Gn.prototype=op.prototype;function op(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}op.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function GE(e){e:for(var t=e.length,r=1,n=-1,i;r0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var Dw;function VE(e,t){var r=ra(e,t);if(!r)return e+"";var n=r[0],i=r[1],a=i-(Dw=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,o=n.length;return a===o?n:a>o?n+new Array(a-o+1).join("0"):a>0?n.slice(0,a)+"."+n.slice(a):"0."+new Array(1-a).join("0")+ra(e,Math.max(0,t+a-1))[0]}function Yg(e,t){var r=ra(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}const Zg={"%":(e,t)=>(e*100).toFixed(t),b:e=>Math.round(e).toString(2),c:e=>e+"",d:WE,e:(e,t)=>e.toExponential(t),f:(e,t)=>e.toFixed(t),g:(e,t)=>e.toPrecision(t),o:e=>Math.round(e).toString(8),p:(e,t)=>Yg(e*100,t),r:Yg,s:VE,X:e=>Math.round(e).toString(16).toUpperCase(),x:e=>Math.round(e).toString(16)};function Jg(e){return e}var Qg=Array.prototype.map,em=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function XE(e){var t=e.grouping===void 0||e.thousands===void 0?Jg:zE(Qg.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",a=e.numerals===void 0?Jg:KE(Qg.call(e.numerals,String)),o=e.percent===void 0?"%":e.percent+"",u=e.minus===void 0?"−":e.minus+"",c=e.nan===void 0?"NaN":e.nan+"";function s(l){l=Gn(l);var h=l.fill,p=l.align,y=l.sign,v=l.symbol,d=l.zero,m=l.width,x=l.comma,w=l.precision,O=l.trim,g=l.type;g==="n"?(x=!0,g="g"):Zg[g]||(w===void 0&&(w=12),O=!0,g="g"),(d||h==="0"&&p==="=")&&(d=!0,h="0",p="=");var b=v==="$"?r:v==="#"&&/[boxX]/.test(g)?"0"+g.toLowerCase():"",_=v==="$"?n:/[%p]/.test(g)?o:"",A=Zg[g],P=/[defgprs%]/.test(g);w=w===void 0?6:/[gprs]/.test(g)?Math.max(1,Math.min(21,w)):Math.max(0,Math.min(20,w));function j(T){var E=b,M=_,I,$,k;if(g==="c")M=A(T)+M,T="";else{T=+T;var R=T<0||1/T<0;if(T=isNaN(T)?c:A(Math.abs(T),w),O&&(T=GE(T)),R&&+T==0&&y!=="+"&&(R=!1),E=(R?y==="("?y:u:y==="-"||y==="("?"":y)+E,M=(g==="s"?em[8+Dw/3]:"")+M+(R&&y==="("?")":""),P){for(I=-1,$=T.length;++I<$;)if(k=T.charCodeAt(I),48>k||k>57){M=(k===46?i+T.slice(I+1):T.slice(I))+M,T=T.slice(0,I);break}}}x&&!d&&(T=t(T,1/0));var L=E.length+T.length+M.length,B=L>1)+E+T+M+B.slice(L);break;default:T=B+E+T+M;break}return a(T)}return j.toString=function(){return l+""},j}function f(l,h){var p=s((l=Gn(l),l.type="f",l)),y=Math.max(-8,Math.min(8,Math.floor(Nr(h)/3)))*3,v=Math.pow(10,-y),d=em[8+y/3];return function(m){return p(v*m)+d}}return{format:s,formatPrefix:f}}var Ii,up,Nw;YE({thousands:",",grouping:[3],currency:["$",""]});function YE(e){return Ii=XE(e),up=Ii.format,Nw=Ii.formatPrefix,Ii}function ZE(e){return Math.max(0,-Nr(Math.abs(e)))}function JE(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(Nr(t)/3)))*3-Nr(Math.abs(e)))}function QE(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,Nr(t)-Nr(e))+1}function qw(e,t,r,n){var i=Sf(e,t,r),a;switch(n=Gn(n??",f"),n.type){case"s":{var o=Math.max(Math.abs(e),Math.abs(t));return n.precision==null&&!isNaN(a=JE(i,o))&&(n.precision=a),Nw(n,o)}case"":case"e":case"g":case"p":case"r":{n.precision==null&&!isNaN(a=QE(i,Math.max(Math.abs(e),Math.abs(t))))&&(n.precision=a-(n.type==="e"));break}case"f":case"%":{n.precision==null&&!isNaN(a=ZE(i))&&(n.precision=a-(n.type==="%")*2);break}}return up(n)}function Ft(e){var t=e.domain;return e.ticks=function(r){var n=t();return _f(n[0],n[n.length-1],r??10)},e.tickFormat=function(r,n){var i=t();return qw(i[0],i[i.length-1],r??10,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,a=n.length-1,o=n[i],u=n[a],c,s,f=10;for(u0;){if(s=Af(o,u,r),s===c)return n[i]=o,n[a]=u,t(n);if(s>0)o=Math.floor(o/s)*s,u=Math.ceil(u/s)*s;else if(s<0)o=Math.ceil(o*s)/s,u=Math.floor(u*s)/s;else break;c=s}return e},e}function na(){var e=ap();return e.copy=function(){return xi(e,na())},it.apply(e,arguments),Ft(e)}function Lw(e){var t;function r(n){return n==null||isNaN(n=+n)?t:n}return r.invert=r,r.domain=r.range=function(n){return arguments.length?(e=Array.from(n,ta),r):e.slice()},r.unknown=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return Lw(e).unknown(t)},e=arguments.length?Array.from(e,ta):[0,1],Ft(r)}function Bw(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],a=e[n],o;return aMath.pow(e,t)}function ij(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),t=>Math.log(t)/e)}function nm(e){return(t,r)=>-e(-t,r)}function cp(e){const t=e(tm,rm),r=t.domain;let n=10,i,a;function o(){return i=ij(n),a=nj(n),r()[0]<0?(i=nm(i),a=nm(a),e(ej,tj)):e(tm,rm),t}return t.base=function(u){return arguments.length?(n=+u,o()):n},t.domain=function(u){return arguments.length?(r(u),o()):r()},t.ticks=u=>{const c=r();let s=c[0],f=c[c.length-1];const l=f0){for(;h<=p;++h)for(y=1;yf)break;m.push(v)}}else for(;h<=p;++h)for(y=n-1;y>=1;--y)if(v=h>0?y/a(-h):y*a(h),!(vf)break;m.push(v)}m.length*2{if(u==null&&(u=10),c==null&&(c=n===10?"s":","),typeof c!="function"&&(!(n%1)&&(c=Gn(c)).precision==null&&(c.trim=!0),c=up(c)),u===1/0)return c;const s=Math.max(1,n*u/t.ticks().length);return f=>{let l=f/a(Math.round(i(f)));return l*nr(Bw(r(),{floor:u=>a(Math.floor(i(u))),ceil:u=>a(Math.ceil(i(u)))})),t}function Fw(){const e=cp(Za()).domain([1,10]);return e.copy=()=>xi(e,Fw()).base(e.base()),it.apply(e,arguments),e}function im(e){return function(t){return Math.sign(t)*Math.log1p(Math.abs(t/e))}}function am(e){return function(t){return Math.sign(t)*Math.expm1(Math.abs(t))*e}}function sp(e){var t=1,r=e(im(t),am(t));return r.constant=function(n){return arguments.length?e(im(t=+n),am(t)):t},Ft(r)}function Uw(){var e=sp(Za());return e.copy=function(){return xi(e,Uw()).constant(e.constant())},it.apply(e,arguments)}function om(e){return function(t){return t<0?-Math.pow(-t,e):Math.pow(t,e)}}function aj(e){return e<0?-Math.sqrt(-e):Math.sqrt(e)}function oj(e){return e<0?-e*e:e*e}function lp(e){var t=e(Be,Be),r=1;function n(){return r===1?e(Be,Be):r===.5?e(aj,oj):e(om(r),om(1/r))}return t.exponent=function(i){return arguments.length?(r=+i,n()):r},Ft(t)}function fp(){var e=lp(Za());return e.copy=function(){return xi(e,fp()).exponent(e.exponent())},it.apply(e,arguments),e}function uj(){return fp.apply(null,arguments).exponent(.5)}function um(e){return Math.sign(e)*e*e}function cj(e){return Math.sign(e)*Math.sqrt(Math.abs(e))}function Ww(){var e=ap(),t=[0,1],r=!1,n;function i(a){var o=cj(e(a));return isNaN(o)?n:r?Math.round(o):o}return i.invert=function(a){return e.invert(um(a))},i.domain=function(a){return arguments.length?(e.domain(a),i):e.domain()},i.range=function(a){return arguments.length?(e.range((t=Array.from(a,ta)).map(um)),i):t.slice()},i.rangeRound=function(a){return i.range(a).round(!0)},i.round=function(a){return arguments.length?(r=!!a,i):r},i.clamp=function(a){return arguments.length?(e.clamp(a),i):e.clamp()},i.unknown=function(a){return arguments.length?(n=a,i):n},i.copy=function(){return Ww(e.domain(),t).round(r).clamp(e.clamp()).unknown(n)},it.apply(i,arguments),Ft(i)}function zw(){var e=[],t=[],r=[],n;function i(){var o=0,u=Math.max(1,t.length);for(r=new Array(u-1);++o0?r[u-1]:e[0],u=r?[n[r-1],t]:[n[s-1],n[s]]},o.unknown=function(c){return arguments.length&&(a=c),o},o.thresholds=function(){return n.slice()},o.copy=function(){return Kw().domain([e,t]).range(i).unknown(a)},it.apply(Ft(o),arguments)}function Hw(){var e=[.5],t=[0,1],r,n=1;function i(a){return a!=null&&a<=a?t[mi(e,a,0,n)]:r}return i.domain=function(a){return arguments.length?(e=Array.from(a),n=Math.min(e.length,t.length-1),i):e.slice()},i.range=function(a){return arguments.length?(t=Array.from(a),n=Math.min(e.length,t.length-1),i):t.slice()},i.invertExtent=function(a){var o=t.indexOf(a);return[e[o-1],e[o]]},i.unknown=function(a){return arguments.length?(r=a,i):r},i.copy=function(){return Hw().domain(e).range(t).unknown(r)},it.apply(i,arguments)}const Rs=new Date,Ds=new Date;function Pe(e,t,r,n){function i(a){return e(a=arguments.length===0?new Date:new Date(+a)),a}return i.floor=a=>(e(a=new Date(+a)),a),i.ceil=a=>(e(a=new Date(a-1)),t(a,1),e(a),a),i.round=a=>{const o=i(a),u=i.ceil(a);return a-o(t(a=new Date(+a),o==null?1:Math.floor(o)),a),i.range=(a,o,u)=>{const c=[];if(a=i.ceil(a),u=u==null?1:Math.floor(u),!(a0))return c;let s;do c.push(s=new Date(+a)),t(a,u),e(a);while(sPe(o=>{if(o>=o)for(;e(o),!a(o);)o.setTime(o-1)},(o,u)=>{if(o>=o)if(u<0)for(;++u<=0;)for(;t(o,-1),!a(o););else for(;--u>=0;)for(;t(o,1),!a(o););}),r&&(i.count=(a,o)=>(Rs.setTime(+a),Ds.setTime(+o),e(Rs),e(Ds),Math.floor(r(Rs,Ds))),i.every=a=>(a=Math.floor(a),!isFinite(a)||!(a>0)?null:a>1?i.filter(n?o=>n(o)%a===0:o=>i.count(0,o)%a===0):i)),i}const ia=Pe(()=>{},(e,t)=>{e.setTime(+e+t)},(e,t)=>t-e);ia.every=e=>(e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Pe(t=>{t.setTime(Math.floor(t/e)*e)},(t,r)=>{t.setTime(+t+r*e)},(t,r)=>(r-t)/e):ia);ia.range;const St=1e3,rt=St*60,Pt=rt*60,$t=Pt*24,hp=$t*7,cm=$t*30,Ns=$t*365,rr=Pe(e=>{e.setTime(e-e.getMilliseconds())},(e,t)=>{e.setTime(+e+t*St)},(e,t)=>(t-e)/St,e=>e.getUTCSeconds());rr.range;const pp=Pe(e=>{e.setTime(e-e.getMilliseconds()-e.getSeconds()*St)},(e,t)=>{e.setTime(+e+t*rt)},(e,t)=>(t-e)/rt,e=>e.getMinutes());pp.range;const dp=Pe(e=>{e.setUTCSeconds(0,0)},(e,t)=>{e.setTime(+e+t*rt)},(e,t)=>(t-e)/rt,e=>e.getUTCMinutes());dp.range;const vp=Pe(e=>{e.setTime(e-e.getMilliseconds()-e.getSeconds()*St-e.getMinutes()*rt)},(e,t)=>{e.setTime(+e+t*Pt)},(e,t)=>(t-e)/Pt,e=>e.getHours());vp.range;const yp=Pe(e=>{e.setUTCMinutes(0,0,0)},(e,t)=>{e.setTime(+e+t*Pt)},(e,t)=>(t-e)/Pt,e=>e.getUTCHours());yp.range;const wi=Pe(e=>e.setHours(0,0,0,0),(e,t)=>e.setDate(e.getDate()+t),(e,t)=>(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*rt)/$t,e=>e.getDate()-1);wi.range;const Ja=Pe(e=>{e.setUTCHours(0,0,0,0)},(e,t)=>{e.setUTCDate(e.getUTCDate()+t)},(e,t)=>(t-e)/$t,e=>e.getUTCDate()-1);Ja.range;const Gw=Pe(e=>{e.setUTCHours(0,0,0,0)},(e,t)=>{e.setUTCDate(e.getUTCDate()+t)},(e,t)=>(t-e)/$t,e=>Math.floor(e/$t));Gw.range;function dr(e){return Pe(t=>{t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},(t,r)=>{t.setDate(t.getDate()+r*7)},(t,r)=>(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*rt)/hp)}const Qa=dr(0),aa=dr(1),sj=dr(2),lj=dr(3),qr=dr(4),fj=dr(5),hj=dr(6);Qa.range;aa.range;sj.range;lj.range;qr.range;fj.range;hj.range;function vr(e){return Pe(t=>{t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},(t,r)=>{t.setUTCDate(t.getUTCDate()+r*7)},(t,r)=>(r-t)/hp)}const eo=vr(0),oa=vr(1),pj=vr(2),dj=vr(3),Lr=vr(4),vj=vr(5),yj=vr(6);eo.range;oa.range;pj.range;dj.range;Lr.range;vj.range;yj.range;const gp=Pe(e=>{e.setDate(1),e.setHours(0,0,0,0)},(e,t)=>{e.setMonth(e.getMonth()+t)},(e,t)=>t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12,e=>e.getMonth());gp.range;const mp=Pe(e=>{e.setUTCDate(1),e.setUTCHours(0,0,0,0)},(e,t)=>{e.setUTCMonth(e.getUTCMonth()+t)},(e,t)=>t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12,e=>e.getUTCMonth());mp.range;const It=Pe(e=>{e.setMonth(0,1),e.setHours(0,0,0,0)},(e,t)=>{e.setFullYear(e.getFullYear()+t)},(e,t)=>t.getFullYear()-e.getFullYear(),e=>e.getFullYear());It.every=e=>!isFinite(e=Math.floor(e))||!(e>0)?null:Pe(t=>{t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},(t,r)=>{t.setFullYear(t.getFullYear()+r*e)});It.range;const Ct=Pe(e=>{e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},(e,t)=>{e.setUTCFullYear(e.getUTCFullYear()+t)},(e,t)=>t.getUTCFullYear()-e.getUTCFullYear(),e=>e.getUTCFullYear());Ct.every=e=>!isFinite(e=Math.floor(e))||!(e>0)?null:Pe(t=>{t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},(t,r)=>{t.setUTCFullYear(t.getUTCFullYear()+r*e)});Ct.range;function Vw(e,t,r,n,i,a){const o=[[rr,1,St],[rr,5,5*St],[rr,15,15*St],[rr,30,30*St],[a,1,rt],[a,5,5*rt],[a,15,15*rt],[a,30,30*rt],[i,1,Pt],[i,3,3*Pt],[i,6,6*Pt],[i,12,12*Pt],[n,1,$t],[n,2,2*$t],[r,1,hp],[t,1,cm],[t,3,3*cm],[e,1,Ns]];function u(s,f,l){const h=fd).right(o,h);if(p===o.length)return e.every(Sf(s/Ns,f/Ns,l));if(p===0)return ia.every(Math.max(Sf(s,f,l),1));const[y,v]=o[h/o[p-1][2]53)return null;"w"in D||(D.w=1),"Z"in D?(re=Ls(mn(D.y,0,1)),Y=re.getUTCDay(),re=Y>4||Y===0?oa.ceil(re):oa(re),re=Ja.offset(re,(D.V-1)*7),D.y=re.getUTCFullYear(),D.m=re.getUTCMonth(),D.d=re.getUTCDate()+(D.w+6)%7):(re=qs(mn(D.y,0,1)),Y=re.getDay(),re=Y>4||Y===0?aa.ceil(re):aa(re),re=wi.offset(re,(D.V-1)*7),D.y=re.getFullYear(),D.m=re.getMonth(),D.d=re.getDate()+(D.w+6)%7)}else("W"in D||"U"in D)&&("w"in D||(D.w="u"in D?D.u%7:"W"in D?1:0),Y="Z"in D?Ls(mn(D.y,0,1)).getUTCDay():qs(mn(D.y,0,1)).getDay(),D.m=0,D.d="W"in D?(D.w+6)%7+D.W*7-(Y+5)%7:D.w+D.U*7-(Y+6)%7);return"Z"in D?(D.H+=D.Z/100|0,D.M+=D.Z%100,Ls(D)):qs(D)}}function A(F,Q,ee,D){for(var ve=0,re=Q.length,Y=ee.length,ye,Z;ve=Y)return-1;if(ye=Q.charCodeAt(ve++),ye===37){if(ye=Q.charAt(ve++),Z=g[ye in sm?Q.charAt(ve++):ye],!Z||(D=Z(F,ee,D))<0)return-1}else if(ye!=ee.charCodeAt(D++))return-1}return D}function P(F,Q,ee){var D=s.exec(Q.slice(ee));return D?(F.p=f.get(D[0].toLowerCase()),ee+D[0].length):-1}function j(F,Q,ee){var D=p.exec(Q.slice(ee));return D?(F.w=y.get(D[0].toLowerCase()),ee+D[0].length):-1}function T(F,Q,ee){var D=l.exec(Q.slice(ee));return D?(F.w=h.get(D[0].toLowerCase()),ee+D[0].length):-1}function E(F,Q,ee){var D=m.exec(Q.slice(ee));return D?(F.m=x.get(D[0].toLowerCase()),ee+D[0].length):-1}function M(F,Q,ee){var D=v.exec(Q.slice(ee));return D?(F.m=d.get(D[0].toLowerCase()),ee+D[0].length):-1}function I(F,Q,ee){return A(F,t,Q,ee)}function $(F,Q,ee){return A(F,r,Q,ee)}function k(F,Q,ee){return A(F,n,Q,ee)}function R(F){return o[F.getDay()]}function L(F){return a[F.getDay()]}function B(F){return c[F.getMonth()]}function z(F){return u[F.getMonth()]}function H(F){return i[+(F.getHours()>=12)]}function U(F){return 1+~~(F.getMonth()/3)}function G(F){return o[F.getUTCDay()]}function se(F){return a[F.getUTCDay()]}function me(F){return c[F.getUTCMonth()]}function De(F){return u[F.getUTCMonth()]}function wt(F){return i[+(F.getUTCHours()>=12)]}function Ie(F){return 1+~~(F.getUTCMonth()/3)}return{format:function(F){var Q=b(F+="",w);return Q.toString=function(){return F},Q},parse:function(F){var Q=_(F+="",!1);return Q.toString=function(){return F},Q},utcFormat:function(F){var Q=b(F+="",O);return Q.toString=function(){return F},Q},utcParse:function(F){var Q=_(F+="",!0);return Q.toString=function(){return F},Q}}}var sm={"-":"",_:" ",0:"0"},Me=/^\s*\d+/,Oj=/^%/,_j=/[\\^$*+?|[\]().{}]/g;function ie(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",a=i.length;return n+(a[t.toLowerCase(),r]))}function Sj(e,t,r){var n=Me.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function Pj(e,t,r){var n=Me.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function Tj(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function Ej(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function jj(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function lm(e,t,r){var n=Me.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function fm(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function Mj(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function $j(e,t,r){var n=Me.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function Ij(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function hm(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function Cj(e,t,r){var n=Me.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function pm(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function kj(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function Rj(e,t,r){var n=Me.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function Dj(e,t,r){var n=Me.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function Nj(e,t,r){var n=Me.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function qj(e,t,r){var n=Oj.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function Lj(e,t,r){var n=Me.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function Bj(e,t,r){var n=Me.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function dm(e,t){return ie(e.getDate(),t,2)}function Fj(e,t){return ie(e.getHours(),t,2)}function Uj(e,t){return ie(e.getHours()%12||12,t,2)}function Wj(e,t){return ie(1+wi.count(It(e),e),t,3)}function Xw(e,t){return ie(e.getMilliseconds(),t,3)}function zj(e,t){return Xw(e,t)+"000"}function Kj(e,t){return ie(e.getMonth()+1,t,2)}function Hj(e,t){return ie(e.getMinutes(),t,2)}function Gj(e,t){return ie(e.getSeconds(),t,2)}function Vj(e){var t=e.getDay();return t===0?7:t}function Xj(e,t){return ie(Qa.count(It(e)-1,e),t,2)}function Yw(e){var t=e.getDay();return t>=4||t===0?qr(e):qr.ceil(e)}function Yj(e,t){return e=Yw(e),ie(qr.count(It(e),e)+(It(e).getDay()===4),t,2)}function Zj(e){return e.getDay()}function Jj(e,t){return ie(aa.count(It(e)-1,e),t,2)}function Qj(e,t){return ie(e.getFullYear()%100,t,2)}function eM(e,t){return e=Yw(e),ie(e.getFullYear()%100,t,2)}function tM(e,t){return ie(e.getFullYear()%1e4,t,4)}function rM(e,t){var r=e.getDay();return e=r>=4||r===0?qr(e):qr.ceil(e),ie(e.getFullYear()%1e4,t,4)}function nM(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+ie(t/60|0,"0",2)+ie(t%60,"0",2)}function vm(e,t){return ie(e.getUTCDate(),t,2)}function iM(e,t){return ie(e.getUTCHours(),t,2)}function aM(e,t){return ie(e.getUTCHours()%12||12,t,2)}function oM(e,t){return ie(1+Ja.count(Ct(e),e),t,3)}function Zw(e,t){return ie(e.getUTCMilliseconds(),t,3)}function uM(e,t){return Zw(e,t)+"000"}function cM(e,t){return ie(e.getUTCMonth()+1,t,2)}function sM(e,t){return ie(e.getUTCMinutes(),t,2)}function lM(e,t){return ie(e.getUTCSeconds(),t,2)}function fM(e){var t=e.getUTCDay();return t===0?7:t}function hM(e,t){return ie(eo.count(Ct(e)-1,e),t,2)}function Jw(e){var t=e.getUTCDay();return t>=4||t===0?Lr(e):Lr.ceil(e)}function pM(e,t){return e=Jw(e),ie(Lr.count(Ct(e),e)+(Ct(e).getUTCDay()===4),t,2)}function dM(e){return e.getUTCDay()}function vM(e,t){return ie(oa.count(Ct(e)-1,e),t,2)}function yM(e,t){return ie(e.getUTCFullYear()%100,t,2)}function gM(e,t){return e=Jw(e),ie(e.getUTCFullYear()%100,t,2)}function mM(e,t){return ie(e.getUTCFullYear()%1e4,t,4)}function bM(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Lr(e):Lr.ceil(e),ie(e.getUTCFullYear()%1e4,t,4)}function xM(){return"+0000"}function ym(){return"%"}function gm(e){return+e}function mm(e){return Math.floor(+e/1e3)}var xr,Qw,eO;wM({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function wM(e){return xr=wj(e),Qw=xr.format,xr.parse,eO=xr.utcFormat,xr.utcParse,xr}function OM(e){return new Date(e)}function _M(e){return e instanceof Date?+e:+new Date(+e)}function bp(e,t,r,n,i,a,o,u,c,s){var f=ap(),l=f.invert,h=f.domain,p=s(".%L"),y=s(":%S"),v=s("%I:%M"),d=s("%I %p"),m=s("%a %d"),x=s("%b %d"),w=s("%B"),O=s("%Y");function g(b){return(c(b)t(i/(e.length-1)))},r.quantiles=function(n){return Array.from({length:n+1},(i,a)=>uE(e,a/n))},r.copy=function(){return iO(t).domain(e)},Rt.apply(r,arguments)}function ro(){var e=0,t=.5,r=1,n=1,i,a,o,u,c,s=Be,f,l=!1,h;function p(v){return isNaN(v=+v)?h:(v=.5+((v=+f(v))-a)*(n*vr}return Fs=e,Fs}var Us,Om;function EM(){if(Om)return Us;Om=1;var e=no(),t=cO(),r=ln();function n(i){return i&&i.length?e(i,r,t):void 0}return Us=n,Us}var jM=EM();const io=ce(jM);var Ws,_m;function sO(){if(_m)return Ws;_m=1;function e(t,r){return te.e^a.s<0?1:-1;for(n=a.d.length,i=e.d.length,t=0,r=ne.d[t]^a.s<0?1:-1;return n===i?0:n>i^a.s<0?1:-1};W.decimalPlaces=W.dp=function(){var e=this,t=e.d.length-1,r=(t-e.e)*de;if(t=e.d[t],t)for(;t%10==0;t/=10)r--;return r<0?0:r};W.dividedBy=W.div=function(e){return jt(this,new this.constructor(e))};W.dividedToIntegerBy=W.idiv=function(e){var t=this,r=t.constructor;return le(jt(t,new r(e),0,1),r.precision)};W.equals=W.eq=function(e){return!this.cmp(e)};W.exponent=function(){return we(this)};W.greaterThan=W.gt=function(e){return this.cmp(e)>0};W.greaterThanOrEqualTo=W.gte=function(e){return this.cmp(e)>=0};W.isInteger=W.isint=function(){return this.e>this.d.length-2};W.isNegative=W.isneg=function(){return this.s<0};W.isPositive=W.ispos=function(){return this.s>0};W.isZero=function(){return this.s===0};W.lessThan=W.lt=function(e){return this.cmp(e)<0};W.lessThanOrEqualTo=W.lte=function(e){return this.cmp(e)<1};W.logarithm=W.log=function(e){var t,r=this,n=r.constructor,i=n.precision,a=i+5;if(e===void 0)e=new n(10);else if(e=new n(e),e.s<1||e.eq(Ve))throw Error(nt+"NaN");if(r.s<1)throw Error(nt+(r.s?"NaN":"-Infinity"));return r.eq(Ve)?new n(0):(ge=!1,t=jt(Vn(r,a),Vn(e,a),a),ge=!0,le(t,i))};W.minus=W.sub=function(e){var t=this;return e=new t.constructor(e),t.s==e.s?pO(t,e):fO(t,(e.s=-e.s,e))};W.modulo=W.mod=function(e){var t,r=this,n=r.constructor,i=n.precision;if(e=new n(e),!e.s)throw Error(nt+"NaN");return r.s?(ge=!1,t=jt(r,e,0,1).times(e),ge=!0,r.minus(t)):le(new n(r),i)};W.naturalExponential=W.exp=function(){return hO(this)};W.naturalLogarithm=W.ln=function(){return Vn(this)};W.negated=W.neg=function(){var e=new this.constructor(this);return e.s=-e.s||0,e};W.plus=W.add=function(e){var t=this;return e=new t.constructor(e),t.s==e.s?fO(t,e):pO(t,(e.s=-e.s,e))};W.precision=W.sd=function(e){var t,r,n,i=this;if(e!==void 0&&e!==!!e&&e!==1&&e!==0)throw Error(ar+e);if(t=we(i)+1,n=i.d.length-1,r=n*de+1,n=i.d[n],n){for(;n%10==0;n/=10)r--;for(n=i.d[0];n>=10;n/=10)r++}return e&&t>r?t:r};W.squareRoot=W.sqrt=function(){var e,t,r,n,i,a,o,u=this,c=u.constructor;if(u.s<1){if(!u.s)return new c(0);throw Error(nt+"NaN")}for(e=we(u),ge=!1,i=Math.sqrt(+u),i==0||i==1/0?(t=vt(u.d),(t.length+e)%2==0&&(t+="0"),i=Math.sqrt(t),e=pn((e+1)/2)-(e<0||e%2),i==1/0?t="5e"+e:(t=i.toExponential(),t=t.slice(0,t.indexOf("e")+1)+e),n=new c(t)):n=new c(i.toString()),r=c.precision,i=o=r+3;;)if(a=n,n=a.plus(jt(u,a,o+2)).times(.5),vt(a.d).slice(0,o)===(t=vt(n.d)).slice(0,o)){if(t=t.slice(o-3,o+1),i==o&&t=="4999"){if(le(a,r+1,0),a.times(a).eq(u)){n=a;break}}else if(t!="9999")break;o+=4}return ge=!0,le(n,r)};W.times=W.mul=function(e){var t,r,n,i,a,o,u,c,s,f=this,l=f.constructor,h=f.d,p=(e=new l(e)).d;if(!f.s||!e.s)return new l(0);for(e.s*=f.s,r=f.e+e.e,c=h.length,s=p.length,c=0;){for(t=0,i=c+n;i>n;)u=a[i]+p[n]*h[i-n-1]+t,a[i--]=u%Ee|0,t=u/Ee|0;a[i]=(a[i]+t)%Ee|0}for(;!a[--o];)a.pop();return t?++r:a.shift(),e.d=a,e.e=r,ge?le(e,l.precision):e};W.toDecimalPlaces=W.todp=function(e,t){var r=this,n=r.constructor;return r=new n(r),e===void 0?r:(mt(e,0,hn),t===void 0?t=n.rounding:mt(t,0,8),le(r,e+we(r)+1,t))};W.toExponential=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=lr(n,!0):(mt(e,0,hn),t===void 0?t=i.rounding:mt(t,0,8),n=le(new i(n),e+1,t),r=lr(n,!0,e+1)),r};W.toFixed=function(e,t){var r,n,i=this,a=i.constructor;return e===void 0?lr(i):(mt(e,0,hn),t===void 0?t=a.rounding:mt(t,0,8),n=le(new a(i),e+we(i)+1,t),r=lr(n.abs(),!1,e+we(n)+1),i.isneg()&&!i.isZero()?"-"+r:r)};W.toInteger=W.toint=function(){var e=this,t=e.constructor;return le(new t(e),we(e)+1,t.rounding)};W.toNumber=function(){return+this};W.toPower=W.pow=function(e){var t,r,n,i,a,o,u=this,c=u.constructor,s=12,f=+(e=new c(e));if(!e.s)return new c(Ve);if(u=new c(u),!u.s){if(e.s<1)throw Error(nt+"Infinity");return u}if(u.eq(Ve))return u;if(n=c.precision,e.eq(Ve))return le(u,n);if(t=e.e,r=e.d.length-1,o=t>=r,a=u.s,o){if((r=f<0?-f:f)<=lO){for(i=new c(Ve),t=Math.ceil(n/de+4),ge=!1;r%2&&(i=i.times(u),jm(i.d,t)),r=pn(r/2),r!==0;)u=u.times(u),jm(u.d,t);return ge=!0,e.s<0?new c(Ve).div(i):le(i,n)}}else if(a<0)throw Error(nt+"NaN");return a=a<0&&e.d[Math.max(t,r)]&1?-1:1,u.s=1,ge=!1,i=e.times(Vn(u,n+s)),ge=!0,i=hO(i),i.s=a,i};W.toPrecision=function(e,t){var r,n,i=this,a=i.constructor;return e===void 0?(r=we(i),n=lr(i,r<=a.toExpNeg||r>=a.toExpPos)):(mt(e,1,hn),t===void 0?t=a.rounding:mt(t,0,8),i=le(new a(i),e,t),r=we(i),n=lr(i,e<=r||r<=a.toExpNeg,e)),n};W.toSignificantDigits=W.tosd=function(e,t){var r=this,n=r.constructor;return e===void 0?(e=n.precision,t=n.rounding):(mt(e,1,hn),t===void 0?t=n.rounding:mt(t,0,8)),le(new n(r),e,t)};W.toString=W.valueOf=W.val=W.toJSON=W[Symbol.for("nodejs.util.inspect.custom")]=function(){var e=this,t=we(e),r=e.constructor;return lr(e,t<=r.toExpNeg||t>=r.toExpPos)};function fO(e,t){var r,n,i,a,o,u,c,s,f=e.constructor,l=f.precision;if(!e.s||!t.s)return t.s||(t=new f(e)),ge?le(t,l):t;if(c=e.d,s=t.d,o=e.e,i=t.e,c=c.slice(),a=o-i,a){for(a<0?(n=c,a=-a,u=s.length):(n=s,i=o,u=c.length),o=Math.ceil(l/de),u=o>u?o+1:u+1,a>u&&(a=u,n.length=1),n.reverse();a--;)n.push(0);n.reverse()}for(u=c.length,a=s.length,u-a<0&&(a=u,n=s,s=c,c=n),r=0;a;)r=(c[--a]=c[a]+s[a]+r)/Ee|0,c[a]%=Ee;for(r&&(c.unshift(r),++i),u=c.length;c[--u]==0;)c.pop();return t.d=c,t.e=i,ge?le(t,l):t}function mt(e,t,r){if(e!==~~e||e