diff --git a/.envrc b/.envrc deleted file mode 100644 index 8392d159..00000000 --- a/.envrc +++ /dev/null @@ -1 +0,0 @@ -use flake \ No newline at end of file diff --git a/.gitattributes b/.gitattributes index 1c452177..cf5cffa2 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,3 +1,2 @@ *.bat text eol=crlf -*.cmd text eol=crlf -MaiLauncher.bat text eol=crlf working-tree-encoding=GBK \ No newline at end of file +*.cmd text eol=crlf \ No newline at end of file diff --git a/.gitignore b/.gitignore index 104a3012..c84210b1 100644 --- a/.gitignore +++ b/.gitignore @@ -20,6 +20,8 @@ MaiBot-Napcat-Adapter nonebot-maibot-adapter/ MaiMBot-LPMM *.zip +run_bot.bat +run_na.bat run.bat log_debug/ run_amds.bat @@ -41,16 +43,13 @@ config/bot_config.toml config/bot_config.toml.bak config/lpmm_config.toml config/lpmm_config.toml.bak -src/mais4u/config/s4u_config.toml -src/mais4u/config/old template/compare/bot_config_template.toml template/compare/model_config_template.toml （测试版）麦麦生成人格.bat （临时版）麦麦开始学习.bat src/plugins/utils/statistic.py CLAUDE.md -s4u.s4u -s4u.s4u1 + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] @@ -321,9 +320,14 @@ run_pet.bat /plugins/* !/plugins !/plugins/hello_world_plugin +!/plugins/emoji_manage_plugin !/plugins/take_picture_plugin +!/plugins/deep_think +!/plugins/ChatFrequency/ +!/plugins/__init__.py config.toml interested_rates.txt MaiBot.code-workspace +*.lock \ No newline at end of file diff --git a/bot.py b/bot.py index bb7d72ea..3f47e435 100644 --- a/bot.py +++ b/bot.py @@ -5,16 +5,29 @@ import sys import time import platform import traceback +import shutil from dotenv import load_dotenv from pathlib import Path from rich.traceback import install -if os.path.exists(".env"): - load_dotenv(".env", override=True) +env_path = Path(__file__).parent / ".env" +template_env_path = Path(__file__).parent / "template" / "template.env" + +if env_path.exists(): + load_dotenv(str(env_path), override=True) print("成功加载环境变量配置") else: - print("未找到.env文件，请确保程序所需的环境变量被正确设置") - raise FileNotFoundError(".env 文件不存在，请创建并配置所需的环境变量") + try: + if template_env_path.exists(): + shutil.copyfile(template_env_path, env_path) + print("未找到.env，已从 template/template.env 自动创建") + load_dotenv(str(env_path), override=True) + else: + print("未找到.env文件，也未找到模板 template/template.env") + raise FileNotFoundError(".env 文件不存在，请创建并配置所需的环境变量") + except Exception as e: + print(f"自动创建 .env 失败: {e}") + raise # 最早期初始化日志系统，确保所有后续模块都使用正确的日志格式 from src.common.logger import initialize_logging, get_logger, shutdown_logging diff --git a/changelogs/changelog.md b/changelogs/changelog.md index a8e26f8f..a35f2ef6 100644 --- a/changelogs/changelog.md +++ b/changelogs/changelog.md @@ -1,14 +1,27 @@ # Changelog -0.10.4饼 表达方式优化 -无了 +## [0.11.0] - 2025-9-22 +### 🌟 主要功能更改 +- 重构记忆系统，新的记忆系统更可靠，记忆能力更强大 +- 麦麦好奇功能，麦麦会自主提出问题 +- 添加deepthink插件（默认关闭），让麦麦可以深度思考一些问题 +- 添加表情包管理插件 -## [0.10.3] - 2025-9-1x +### 细节功能更改 +- 修复配置文件转义问题 +- 情绪系统现在可以由配置文件控制开关 +- 修复平行动作控制失效的问题 +- 添加planner防抖，防止短时间快速消耗token +- 修复吞字问题 +- 更新依赖表 +- 修复负载均衡 +- 优化了对gemini和不同模型的支持 + +## [0.10.3] - 2025-9-22 ### 🌟 主要功能更改 - planner支持多动作，移除Sub_planner - 移除激活度系统，现在回复完全由planner控制 -- 现可自定义planner行为 -- 更丰富的聊天行为 +- 现可自定义planner行为，更优化的聊天频率控制 - 支持发送转发和合并转发 - 关系现在支持多人的信息 - 更好的event系统，正式建立 @@ -20,6 +33,8 @@ - 优化识图token限制 - 为空回复添加重试机制 - 加入brainchat模式，为私聊支持做准备 +- 修复qq号格式 + ## [0.10.2] - 2025-8-31 diff --git a/changelogs/changelog_config.md b/changelogs/changelog_config.md deleted file mode 100644 index 5aa5fb92..00000000 --- a/changelogs/changelog_config.md +++ /dev/null @@ -1,51 +0,0 @@ -# Changelog - -## [1.0.3] - 2025-3-31 -### Added -- 新增了心流相关配置项： - - `heartflow` 配置项，用于控制心流功能 - -### Removed -- 移除了 `response` 配置项中的 `model_r1_probability` 和 `model_v3_probability` 选项 -- 移除了次级推理模型相关配置 - -## [1.0.1] - 2025-3-30 -### Added -- 增加了流式输出控制项 `stream` -- 修复 `LLM_Request` 不会自动为 `payload` 增加流式输出标志的问题 - -## [1.0.0] - 2025-3-30 -### Added -- 修复了错误的版本命名 -- 杀掉了所有无关文件 - -## [0.0.11] - 2025-3-12 -### Added -- 新增了 `schedule` 配置项，用于配置日程表生成功能 -- 新增了 `response_splitter` 配置项，用于控制回复分割 -- 新增了 `experimental` 配置项，用于实验性功能开关 -- 新增了 `llm_observation` 和 `llm_sub_heartflow` 模型配置 -- 新增了 `llm_heartflow` 模型配置 -- 在 `personality` 配置项中新增了 `prompt_schedule_gen` 参数 - -### Changed -- 优化了模型配置的组织结构 -- 调整了部分配置项的默认值 -- 调整了配置项的顺序，将 `groups` 配置项移到了更靠前的位置 -- 在 `message` 配置项中： - - 新增了 `model_max_output_length` 参数 -- 在 `willing` 配置项中新增了 `emoji_response_penalty` 参数 -- 将 `personality` 配置项中的 `prompt_schedule` 重命名为 `prompt_schedule_gen` - -### Removed -- 移除了 `min_text_length` 配置项 -- 移除了 `cq_code` 配置项 -- 移除了 `others` 配置项（其功能已整合到 `experimental` 中） - -## [0.0.5] - 2025-3-11 -### Added -- 新增了 `alias_names` 配置项，用于指定麦麦的别名。 - -## [0.0.4] - 2025-3-9 -### Added -- 新增了 `memory_ban_words` 配置项，用于指定不希望记忆的词汇。 \ No newline at end of file diff --git a/docs/model_configuration_guide.md b/docs/model_configuration_guide.md index fd1cb018..f2da8be1 100644 --- a/docs/model_configuration_guide.md +++ b/docs/model_configuration_guide.md @@ -28,7 +28,7 @@ version = "1.1.1" ```toml [[api_providers]] name = "DeepSeek" # 服务商名称（自定义） -base_url = "https://api.deepseek.cn/v1" # API服务的基础URL +base_url = "https://api.deepseek.com/v1" # API服务的基础URL api_key = "your-api-key-here" # API密钥 client_type = "openai" # 客户端类型 max_retry = 2 # 最大重试次数 @@ -43,19 +43,19 @@ retry_interval = 10 # 重试间隔（秒） | `name` | ✅ | 服务商名称，需要在模型配置中引用 | - | | `base_url` | ✅ | API服务的基础URL | - | | `api_key` | ✅ | API密钥，请替换为实际密钥 | - | -| `client_type` | ❌ | 客户端类型：`openai`（OpenAI格式）或 `gemini`（Gemini格式，现在支持不良好） | `openai` | +| `client_type` | ❌ | 客户端类型：`openai`（OpenAI格式）或 `gemini`（Gemini格式） | `openai` | | `max_retry` | ❌ | API调用失败时的最大重试次数 | 2 | | `timeout` | ❌ | API请求超时时间（秒） | 30 | | `retry_interval` | ❌ | 重试间隔时间（秒） | 10 | -**请注意，对于`client_type`为`gemini`的模型，`base_url`字段无效。** +**请注意，对于`client_type`为`gemini`的模型，`retry`字段由`gemini`自己决定。** ### 2.3 支持的服务商示例 #### DeepSeek ```toml [[api_providers]] name = "DeepSeek" -base_url = "https://api.deepseek.cn/v1" +base_url = "https://api.deepseek.com/v1" api_key = "your-deepseek-api-key" client_type = "openai" ``` @@ -73,7 +73,7 @@ client_type = "openai" ```toml [[api_providers]] name = "Google" -base_url = "https://api.google.com/v1" +base_url = "https://generativelanguage.googleapis.com/v1beta" api_key = "your-google-api-key" client_type = "gemini" # 注意：Gemini需要使用特殊客户端 ``` @@ -131,9 +131,20 @@ enable_thinking = false # 禁用思考 [models.extra_params] thinking = {type = "disabled"} # 禁用思考 ``` + +而对于`gemini`需要单独进行配置 +```toml +[[models]] +model_identifier = "gemini-2.5-flash" +name = "gemini-2.5-flash" +api_provider = "Google" +[models.extra_params] +thinking_budget = 0 # 禁用思考 +# thinking_budget = -1 由模型自己决定 +``` + 请注意，`extra_params` 的配置应该构成一个合法的TOML字典结构，具体内容取决于API服务商的要求。 -**请注意，对于`client_type`为`gemini`的模型，此字段无效。** ### 3.3 配置参数说明 | 参数 | 必填 | 说明 | diff --git a/flake.lock b/flake.lock deleted file mode 100644 index 894acd48..00000000 --- a/flake.lock +++ /dev/null @@ -1,57 +0,0 @@ -{ - "nodes": { - "nixpkgs": { - "locked": { - "lastModified": 0, - "narHash": "sha256-nJj8f78AYAxl/zqLiFGXn5Im1qjFKU8yBPKoWEeZN5M=", - "path": "/nix/store/f30jn7l0bf7a01qj029fq55i466vmnkh-source", - "type": "path" - }, - "original": { - "id": "nixpkgs", - "type": "indirect" - } - }, - "root": { - "inputs": { - "nixpkgs": "nixpkgs", - "utils": "utils" - } - }, - "systems": { - "locked": { - "lastModified": 1681028828, - "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", - "owner": "nix-systems", - "repo": "default", - "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", - "type": "github" - }, - "original": { - "owner": "nix-systems", - "repo": "default", - "type": "github" - } - }, - "utils": { - "inputs": { - "systems": "systems" - }, - "locked": { - "lastModified": 1731533236, - "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", - "owner": "numtide", - "repo": "flake-utils", - "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", - "type": "github" - }, - "original": { - "owner": "numtide", - "repo": "flake-utils", - "type": "github" - } - } - }, - "root": "root", - "version": 7 -} diff --git a/flake.nix b/flake.nix deleted file mode 100644 index 23b82bb7..00000000 --- a/flake.nix +++ /dev/null @@ -1,39 +0,0 @@ -{ - description = "MaiMBot Nix Dev Env"; - - inputs = { - utils.url = "github:numtide/flake-utils"; - }; - - outputs = { - self, - nixpkgs, - utils, - ... - }: - utils.lib.eachDefaultSystem (system: let - pkgs = import nixpkgs {inherit system;}; - pythonPackages = pkgs.python3Packages; - in { - devShells.default = pkgs.mkShell { - name = "python-venv"; - venvDir = "./.venv"; - buildInputs = with pythonPackages; [ - python - venvShellHook - scipy - numpy - ]; - - postVenvCreation = '' - unset SOURCE_DATE_EPOCH - pip install -r requirements.txt - ''; - - postShellHook = '' - # allow pip to install wheels - unset SOURCE_DATE_EPOCH - ''; - }; - }); -} diff --git a/scripts/log_viewer_optimized.py b/log_viewer/log_viewer_optimized.py similarity index 100% rename from scripts/log_viewer_optimized.py rename to log_viewer/log_viewer_optimized.py diff --git a/plugins/ChatFrequency/README.md b/plugins/ChatFrequency/README.md new file mode 100644 index 00000000..6da16772 --- /dev/null +++ b/plugins/ChatFrequency/README.md @@ -0,0 +1,75 @@ +# BetterFrequency 频率控制插件 + +这是一个用于控制MaiBot聊天频率的插件，支持实时调整talk_frequency参数。 + +## 功能特性 + +- 💬 **Talk Frequency控制**: 调整机器人的发言频率 +- 📊 **状态显示**: 实时查看当前频率控制状态 +- ⚡ **实时生效**: 设置后立即生效，无需重启 +- 💾 **不保存消息**: 命令执行反馈不会保存到数据库 +- 🚀 **简化命令**: 支持完整命令和简化命令两种形式 + +## 命令列表 + +### 1. 设置Talk Frequency +``` +/chat talk_frequency <数字> # 完整命令 +/chat t <数字> # 简化命令 +``` +- 功能：设置当前聊天的talk_frequency调整值 +- 参数：支持0到1之间的数值 +- 示例： + - `/chat talk_frequency 1.0` 或 `/chat t 1.0` - 设置发言频率调整为1.0（最高频率） + - `/chat talk_frequency 0.5` 或 `/chat t 0.5` - 设置发言频率调整为0.5 + - `/chat talk_frequency 0.0` 或 `/chat t 0.0` - 设置发言频率调整为0.0（最低频率） + +### 2. 显示当前状态 +``` +/chat show # 完整命令 +/chat s # 简化命令 +``` +- 功能：显示当前聊天的频率控制状态 +- 显示内容： + - 当前talk_frequency值 + - 可用命令提示（包含简化命令） + +## 配置说明 + +插件配置文件 `config.toml` 包含以下选项： + +```toml +[plugin] +name = "better_frequency_plugin" +version = "1.0.0" +enabled = true + +[frequency] +default_talk_adjust = 1.0 # 默认talk_frequency调整值 +max_adjust_value = 1.0 # 最大调整值 +min_adjust_value = 0.0 # 最小调整值 +``` + +## 使用场景 + +- **提高机器人活跃度**: 设置较高的talk_frequency值（接近1.0） +- **降低机器人活跃度**: 设置较低的talk_frequency值（接近0.0） +- **精细调节**: 使用小数进行微调 +- **实时监控**: 通过show命令查看当前状态 +- **快速操作**: 使用简化命令提高操作效率 + +## 注意事项 + +1. 调整值会立即生效，影响当前聊天的机器人行为 +2. 命令执行反馈消息不会保存到数据库 +3. 支持0到1之间的数值 +4. 每个聊天都有独立的频率控制设置 +5. 简化命令和完整命令功能完全相同，可根据个人习惯选择 + +## 技术实现 + +- 基于MaiCore插件系统开发 +- 使用frequency_api进行频率控制操作 +- 使用send_api发送反馈消息 +- 支持异步操作和错误处理 +- 正则表达式支持多种命令格式 diff --git a/plugins/ChatFrequency/_manifest.json b/plugins/ChatFrequency/_manifest.json new file mode 100644 index 00000000..bc07c000 --- /dev/null +++ b/plugins/ChatFrequency/_manifest.json @@ -0,0 +1,56 @@ +{ + "manifest_version": 1, + "name": "发言频率控制插件|BetterFrequency Plugin", + "version": "2.0.0", + "description": "控制聊天频率，支持设置focus_value和talk_frequency调整值，提供完整命令和简化命令", + "author": { + "name": "SengokuCola", + "url": "https://github.com/MaiM-with-u" + }, + "license": "GPL-v3.0-or-later", + + "host_application": { + "min_version": "0.10.3" + }, + "homepage_url": "https://github.com/SengokuCola/BetterFrequency", + "repository_url": "https://github.com/SengokuCola/BetterFrequency", + "keywords": ["frequency", "control", "talk_frequency", "plugin", "shortcut"], + "categories": ["Chat", "Frequency", "Control"], + + "default_locale": "zh-CN", + "locales_path": "_locales", + + "plugin_info": { + "is_built_in": false, + "plugin_type": "frequency", + "components": [ + { + "type": "command", + "name": "set_talk_frequency", + "description": "设置当前聊天的talk_frequency调整值", + "pattern": "/chat talk_frequency <数字> 或 /chat t <数字>" + }, + { + "type": "action", + "name": "frequency_adjust", + "description": "调整当前聊天的发言频率", + "pattern": "/chat frequency_adjust <数字> 或 /chat f <数字>" + }, + { + "type": "command", + "name": "show_frequency", + "description": "显示当前聊天的频率控制状态", + "pattern": "/chat show 或 /chat s" + } + ], + "features": [ + "设置talk_frequency调整值", + "调整当前聊天的发言频率", + "显示当前频率控制状态", + "实时频率控制调整", + "命令执行反馈（不保存消息）", + "支持完整命令和简化命令", + "快速操作支持" + ] + } +} \ No newline at end of file diff --git a/plugins/ChatFrequency/frequency_adjust_action.py b/plugins/ChatFrequency/frequency_adjust_action.py new file mode 100644 index 00000000..9c1e4741 --- /dev/null +++ b/plugins/ChatFrequency/frequency_adjust_action.py @@ -0,0 +1,121 @@ +from typing import Tuple + +# 导入新插件系统 +from src.plugin_system import BaseAction, ActionActivationType + +# 导入依赖的系统组件 +from src.common.logger import get_logger + +# 导入API模块 +from src.plugin_system.apis import frequency_api, send_api, config_api, generator_api + +logger = get_logger("frequency_adjust") + + +class FrequencyAdjustAction(BaseAction): + """频率调节动作 - 调整聊天发言频率""" + + activation_type = ActionActivationType.LLM_JUDGE + parallel_action = False + + # 动作基本信息 + action_name = "frequency_adjust" + + action_description = "调整当前聊天的发言频率" + + # 动作参数定义 + action_parameters = { + "direction": "调整方向：'increase'（增加）或'decrease'（降低）", + } + + # 动作使用场景 + bot_name = config_api.get_global_config("bot.nickname") + + + action_require = [ + f"当用户提到 {bot_name} 太安静或太活跃时使用", + f"有人提到 {bot_name} 的发言太多或太少", + f"需要根据聊天氛围调整 {bot_name} 的活跃度", + ] + + # 关联类型 + associated_types = ["text"] + + async def execute(self) -> Tuple[bool, str]: + """执行频率调节动作""" + try: + # 1. 获取动作参数 + direction = self.action_data.get("direction") + # multiply = 1.2 + # multiply = self.action_data.get("multiply") + + if not direction: + error_msg = "缺少必要的参数：direction或multiply" + logger.error(f"{self.log_prefix} {error_msg}") + return False, error_msg + + # 2. 获取当前频率值 + current_frequency = frequency_api.get_current_talk_frequency(self.chat_id) + + # 3. 计算新的频率值（使用比率而不是绝对值） + # calculated_frequency = current_frequency * multiply + if direction == "increase": + calculated_frequency = current_frequency * 1.2 + if calculated_frequency > 1.0: + new_frequency = 1.0 + action_desc = f"增加到最大值" + # 记录超出限制的action + logger.warning(f"{self.log_prefix} 尝试调整频率超出最大值: current={current_frequency:.2f}, calculated={calculated_frequency:.2f}") + await self.store_action_info( + action_build_into_prompt=True, + action_prompt_display=f"你尝试调整发言频率到{calculated_frequency:.2f}，但最大值只能为1.0，已设置为最大值", + action_done=True, + ) + return True, f"调整发言频率超出限制: {current_frequency:.2f} → {new_frequency:.2f}" + else: + new_frequency = calculated_frequency + action_desc = f"增加" + elif direction == "decrease": + calculated_frequency = current_frequency * 0.8 + new_frequency = max(0.0, calculated_frequency) + action_desc = f"降低" + else: + error_msg = f"无效的调整方向: {direction}" + logger.error(f"{self.log_prefix} {error_msg}") + return False, error_msg + + # 4. 设置新的频率值 + frequency_api.set_talk_frequency_adjust(self.chat_id, new_frequency) + + # 5. 发送反馈消息 + feedback_msg = f"已{action_desc}发言频率：{current_frequency:.2f} → {new_frequency:.2f}" + result_status, data = await generator_api.rewrite_reply( + chat_stream=self.chat_stream, + reply_data={ + "raw_reply": feedback_msg, + "reason": "表达自己已经调整了发言频率，不一定要说具体数值，可以有趣一些", + }, + ) + + + if result_status: + for reply_seg in data.reply_set.reply_data: + send_data = reply_seg.content + await self.send_text(send_data) + logger.info(f"{self.log_prefix} {send_data}") + + # 6. 存储动作信息（仅在未超出限制时） + if calculated_frequency <= 1.0: + await self.store_action_info( + action_build_into_prompt=True, + action_prompt_display=f"你{action_desc}了发言频率，从{current_frequency:.2f}调整到{new_frequency:.2f}", + action_done=True, + ) + + return True, f"成功调整发言频率: {current_frequency:.2f} → {new_frequency:.2f}" + + except Exception as e: + error_msg = f"频率调节失败: {str(e)}" + logger.error(f"{self.log_prefix} {error_msg}", exc_info=True) + await self.send_text("频率调节失败") + return False, error_msg \ No newline at end of file diff --git a/plugins/ChatFrequency/plugin.py b/plugins/ChatFrequency/plugin.py new file mode 100644 index 00000000..2c50cb5e --- /dev/null +++ b/plugins/ChatFrequency/plugin.py @@ -0,0 +1,137 @@ +from typing import List, Tuple, Type, Any, Optional +from src.plugin_system import ( + BasePlugin, + register_plugin, + BaseCommand, + ComponentInfo, + ConfigField +) +from src.plugin_system.apis import send_api, frequency_api +from .frequency_adjust_action import FrequencyAdjustAction + + +class SetTalkFrequencyCommand(BaseCommand): + """设置当前聊天的talk_frequency值""" + command_name = "set_talk_frequency" + command_description = "设置当前聊天的talk_frequency值：/chat talk_frequency <数字> 或 /chat t <数字>" + command_pattern = r"^/chat\s+(?:talk_frequency|t)\s+(?P[+-]?\d*\.?\d+)$" + + async def execute(self) -> Tuple[bool, Optional[str], bool]: + try: + # 获取命令参数 - 使用命名捕获组 + if not self.matched_groups or "value" not in self.matched_groups: + return False, "命令格式错误", False + + value_str = self.matched_groups["value"] + if not value_str: + return False, "无法获取数值参数", False + + value = float(value_str) + + # 获取聊天流ID + if not self.message.chat_stream or not hasattr(self.message.chat_stream, "stream_id"): + return False, "无法获取聊天流信息", False + + chat_id = self.message.chat_stream.stream_id + + # 设置talk_frequency + frequency_api.set_talk_frequency_adjust(chat_id, value) + + # 发送反馈消息（不保存到数据库） + await send_api.text_to_stream( + f"已设置当前聊天的talk_frequency调整值为: {value}", + chat_id, + storage_message=False + ) + + return True, None, False + + except ValueError: + error_msg = "数值格式错误，请输入有效的数字" + await self.send_text(error_msg, storage_message=False) + return False, error_msg, False + except Exception as e: + error_msg = f"设置talk_frequency失败: {str(e)}" + await self.send_text(error_msg, storage_message=False) + return False, error_msg, False + + +class ShowFrequencyCommand(BaseCommand): + """显示当前聊天的频率控制状态""" + command_name = "show_frequency" + command_description = "显示当前聊天的频率控制状态：/chat show 或 /chat s" + command_pattern = r"^/chat\s+(?:show|s)$" + + async def execute(self) -> Tuple[bool, Optional[str], bool]: + try: + # 获取聊天流ID + if not self.message.chat_stream or not hasattr(self.message.chat_stream, "stream_id"): + return False, "无法获取聊天流信息", False + + chat_id = self.message.chat_stream.stream_id + + # 获取当前频率控制状态 + current_talk_frequency = frequency_api.get_current_talk_frequency(chat_id) + talk_frequency_adjust = frequency_api.get_talk_frequency_adjust(chat_id) + + # 构建显示消息 + status_msg = f"""当前聊天频率控制状态 +Talk Frequency (发言频率): + • 当前值: {current_talk_frequency:.2f} + +使用命令: + • /chat talk_frequency <数字> 或 /chat t <数字> - 设置发言频率调整 + • /chat show 或 /chat s - 显示当前状态""" + + # 发送状态消息（不保存到数据库） + await send_api.text_to_stream(status_msg, chat_id, storage_message=False) + + return True, None, False + + except Exception as e: + error_msg = f"获取频率控制状态失败: {str(e)}" + # 使用内置的send_text方法发送错误消息 + await self.send_text(error_msg, storage_message=False) + return False, error_msg, False + + +# ===== 插件注册 ===== + + +@register_plugin +class BetterFrequencyPlugin(BasePlugin): + """BetterFrequency插件 - 控制聊天频率的插件""" + + # 插件基本信息 + plugin_name: str = "better_frequency_plugin" + enable_plugin: bool = True + dependencies: List[str] = [] + python_dependencies: List[str] = [] + config_file_name: str = "config.toml" + + # 配置节描述 + config_section_descriptions = { + "plugin": "插件基本信息", + "frequency": "频率控制配置" + } + + # 配置Schema定义 + config_schema: dict = { + "plugin": { + "name": ConfigField(type=str, default="better_frequency_plugin", description="插件名称"), + "version": ConfigField(type=str, default="1.0.0", description="插件版本"), + "enabled": ConfigField(type=bool, default=True, description="是否启用插件"), + }, + "frequency": { + "default_talk_adjust": ConfigField(type=float, default=1.0, description="默认talk_frequency调整值"), + "max_adjust_value": ConfigField(type=float, default=1.0, description="最大调整值"), + "min_adjust_value": ConfigField(type=float, default=0.0, description="最小调整值"), + } + } + + def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]: + return [ + (SetTalkFrequencyCommand.get_command_info(), SetTalkFrequencyCommand), + (ShowFrequencyCommand.get_command_info(), ShowFrequencyCommand), + (FrequencyAdjustAction.get_action_info(), FrequencyAdjustAction), + ] diff --git a/src/migrate_helper/__init__.py b/plugins/__init__.py similarity index 100% rename from src/migrate_helper/__init__.py rename to plugins/__init__.py diff --git a/plugins/deep_think/_manifest.json b/plugins/deep_think/_manifest.json new file mode 100644 index 00000000..036bab0c --- /dev/null +++ b/plugins/deep_think/_manifest.json @@ -0,0 +1,34 @@ +{ + "manifest_version": 1, + "name": "Deep Think插件 (Deep Think Actions)", + "version": "1.0.0", + "description": "可以深度思考", + "author": { + "name": "SengokuCola", + "url": "https://github.com/MaiM-with-u" + }, + "license": "GPL-v3.0-or-later", + + "host_application": { + "min_version": "0.11.0" + }, + "homepage_url": "https://github.com/MaiM-with-u/maibot", + "repository_url": "https://github.com/MaiM-with-u/maibot", + "keywords": ["deep", "think", "action", "built-in"], + "categories": ["Deep Think"], + + "default_locale": "zh-CN", + "locales_path": "_locales", + + "plugin_info": { + "is_built_in": true, + "plugin_type": "action_provider", + "components": [ + { + "type": "action", + "name": "deep_think", + "description": "发送深度思考" + } + ] + } +} diff --git a/plugins/deep_think/plugin.py b/plugins/deep_think/plugin.py new file mode 100644 index 00000000..19f177bc --- /dev/null +++ b/plugins/deep_think/plugin.py @@ -0,0 +1,102 @@ +from typing import List, Tuple, Type, Any + +# 导入新插件系统 +from src.plugin_system import BasePlugin, register_plugin, ComponentInfo +from src.plugin_system.base.config_types import ConfigField +from src.person_info.person_info import Person +from src.plugin_system.base.base_tool import BaseTool, ToolParamType + +# 导入依赖的系统组件 +from src.common.logger import get_logger + +from src.plugins.built_in.relation.relation import BuildRelationAction +from src.plugin_system.apis import llm_api + +logger = get_logger("relation_actions") + + + +class DeepThinkTool(BaseTool): + """获取用户信息""" + + name = "deep_think" + description = "深度思考，对某个知识，概念或逻辑问题进行全面且深入的思考，当面临复杂环境或重要问题时，使用此获得更好的解决方案。" + parameters = [ + ("question", ToolParamType.STRING, "需要思考的问题，越具体越好（从上下文中总结）", True, None), + ] + + available_for_llm = True + + async def execute(self, function_args: dict[str, Any]) -> dict[str, Any]: + """执行比较两个数的大小 + + Args: + function_args: 工具参数 + + Returns: + dict: 工具执行结果 + """ + question: str = function_args.get("question") # type: ignore + + print(f"question: {question}") + + prompt = f""" +请你思考以下问题，以简洁的一段话回答： +{question} + """ + + models = llm_api.get_available_models() + chat_model_config = models.get("replyer") # 使用字典访问方式 + + success, thinking_result, _, _ = await llm_api.generate_with_model( + prompt, model_config=chat_model_config, request_type="deep_think" + ) + + logger.info(f"{question}: {thinking_result}") + + thinking_result =f"思考结果：{thinking_result}\n**注意** 因为你进行了深度思考，最后的回复内容可以回复的长一些，更加详细一些，不用太简洁。\n" + + return {"content": thinking_result} + + +@register_plugin +class DeepThinkPlugin(BasePlugin): + """关系动作插件 + + 系统内置插件，提供基础的聊天交互功能： + - Reply: 回复动作 + - NoReply: 不回复动作 + - Emoji: 表情动作 + + 注意：插件基本信息优先从_manifest.json文件中读取 + """ + + # 插件基本信息 + plugin_name: str = "deep_think" # 内部标识符 + enable_plugin: bool = True + dependencies: list[str] = [] # 插件依赖列表 + python_dependencies: list[str] = [] # Python包依赖列表 + config_file_name: str = "config.toml" + + # 配置节描述 + config_section_descriptions = { + "plugin": "插件启用配置", + "components": "核心组件启用配置", + } + + # 配置Schema定义 + config_schema: dict = { + "plugin": { + "enabled": ConfigField(type=bool, default=False, description="是否启用插件"), + "config_version": ConfigField(type=str, default="2.0.0", description="配置文件版本"), + } + } + + def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]: + """返回插件包含的组件列表""" + + # --- 根据配置注册组件 --- + components = [] + components.append((DeepThinkTool.get_tool_info(), DeepThinkTool)) + + return components diff --git a/plugins/emoji_manage_plugin/_manifest.json b/plugins/emoji_manage_plugin/_manifest.json new file mode 100644 index 00000000..ee8d8318 --- /dev/null +++ b/plugins/emoji_manage_plugin/_manifest.json @@ -0,0 +1,53 @@ +{ + "manifest_version": 1, + "name": "BetterEmoji", + "version": "1.0.0", + "description": "更好的表情包管理插件", + "author": { + "name": "SengokuCola", + "url": "https://github.com/SengokuCola" + }, + "license": "GPL-v3.0-or-later", + + "host_application": { + "min_version": "0.10.4" + }, + "homepage_url": "https://github.com/SengokuCola/BetterEmoji", + "repository_url": "https://github.com/SengokuCola/BetterEmoji", + "keywords": ["emoji", "manage", "plugin"], + "categories": ["Examples", "Tutorial"], + + "default_locale": "zh-CN", + "locales_path": "_locales", + + "plugin_info": { + "is_built_in": false, + "plugin_type": "emoji_manage", + "components": [ + { + "type": "action", + "name": "hello_greeting", + "description": "向用户发送问候消息" + }, + { + "type": "action", + "name": "bye_greeting", + "description": "向用户发送告别消息", + "activation_modes": ["keyword"], + "keywords": ["再见", "bye", "88", "拜拜"] + }, + { + "type": "command", + "name": "time", + "description": "查询当前时间", + "pattern": "/time" + } + ], + "features": [ + "问候和告别功能", + "时间查询命令", + "配置文件示例", + "新手教程代码" + ] + } +} \ No newline at end of file diff --git a/plugins/emoji_manage_plugin/plugin.py b/plugins/emoji_manage_plugin/plugin.py new file mode 100644 index 00000000..453afbc2 --- /dev/null +++ b/plugins/emoji_manage_plugin/plugin.py @@ -0,0 +1,399 @@ +from typing import List, Tuple, Type +from src.plugin_system import ( + BasePlugin, + register_plugin, + BaseCommand, + ComponentInfo, + ConfigField, + ReplyContentType, + emoji_api, +) +from maim_message import Seg +from src.common.logger import get_logger + +logger = get_logger("emoji_manage_plugin") + + +class AddEmojiCommand(BaseCommand): + command_name = "add_emoji" + command_description = "添加表情包" + command_pattern = r".*/emoji add.*" + + async def execute(self) -> Tuple[bool, str, bool]: + # 查找消息中的表情包 + # logger.info(f"查找消息中的表情包: {self.message.message_segment}") + + emoji_base64_list = self.find_and_return_emoji_in_message(self.message.message_segment) + + if not emoji_base64_list: + return False, "未在消息中找到表情包或图片", False + + # 注册找到的表情包 + success_count = 0 + fail_count = 0 + results = [] + + for i, emoji_base64 in enumerate(emoji_base64_list): + try: + # 使用emoji_api注册表情包（让API自动生成唯一文件名） + result = await emoji_api.register_emoji(emoji_base64) + + if result["success"]: + success_count += 1 + description = result.get("description", "未知描述") + emotions = result.get("emotions", []) + replaced = result.get("replaced", False) + + result_msg = f"表情包 {i + 1} 注册成功{'(替换旧表情包)' if replaced else '(新增表情包)'}" + if description: + result_msg += f"\n描述: {description}" + if emotions: + result_msg += f"\n情感标签: {', '.join(emotions)}" + + results.append(result_msg) + else: + fail_count += 1 + error_msg = result.get("message", "注册失败") + results.append(f"表情包 {i + 1} 注册失败: {error_msg}") + + except Exception as e: + fail_count += 1 + results.append(f"表情包 {i + 1} 注册时发生错误: {str(e)}") + + # 构建返回消息 + total_count = success_count + fail_count + summary_msg = f"表情包注册完成: 成功 {success_count} 个，失败 {fail_count} 个，共处理 {total_count} 个" + + # 如果有结果详情，添加到返回消息中 + details_msg = "" + if results: + details_msg = "\n" + "\n".join(results) + final_msg = summary_msg + details_msg + else: + final_msg = summary_msg + + # 使用表达器重写回复 + try: + from src.plugin_system.apis import generator_api + + # 构建重写数据 + rewrite_data = { + "raw_reply": summary_msg, + "reason": f"注册了表情包：{details_msg}\n", + } + + # 调用表达器重写 + result_status, data = await generator_api.rewrite_reply( + chat_stream=self.message.chat_stream, + reply_data=rewrite_data, + ) + + if result_status: + # 发送重写后的回复 + for reply_seg in data.reply_set.reply_data: + send_data = reply_seg.content + await self.send_text(send_data) + + return success_count > 0, final_msg, success_count > 0 + else: + # 如果重写失败，发送原始消息 + await self.send_text(final_msg) + return success_count > 0, final_msg, success_count > 0 + + except Exception as e: + # 如果表达器调用失败，发送原始消息 + logger.error(f"[add_emoji] 表达器重写失败: {e}") + await self.send_text(final_msg) + return success_count > 0, final_msg, success_count > 0 + + def find_and_return_emoji_in_message(self, message_segments) -> List[str]: + emoji_base64_list = [] + + # 处理单个Seg对象的情况 + if isinstance(message_segments, Seg): + if message_segments.type == "emoji": + emoji_base64_list.append(message_segments.data) + elif message_segments.type == "image": + # 假设图片数据是base64编码的 + emoji_base64_list.append(message_segments.data) + elif message_segments.type == "seglist": + # 递归处理嵌套的Seg列表 + emoji_base64_list.extend(self.find_and_return_emoji_in_message(message_segments.data)) + return emoji_base64_list + + # 处理Seg列表的情况 + for seg in message_segments: + if seg.type == "emoji": + emoji_base64_list.append(seg.data) + elif seg.type == "image": + # 假设图片数据是base64编码的 + emoji_base64_list.append(seg.data) + elif seg.type == "seglist": + # 递归处理嵌套的Seg列表 + emoji_base64_list.extend(self.find_and_return_emoji_in_message(seg.data)) + return emoji_base64_list + + +class ListEmojiCommand(BaseCommand): + """列表表情包Command - 响应/emoji list命令""" + + command_name = "emoji_list" + command_description = "列表表情包" + + # === 命令设置（必须填写）=== + command_pattern = r"^/emoji list(\s+\d+)?$" # 匹配 "/emoji list" 或 "/emoji list 数量" + + async def execute(self) -> Tuple[bool, str, bool]: + """执行列表表情包""" + from src.plugin_system.apis import emoji_api + import datetime + + # 解析命令参数 + import re + + match = re.match(r"^/emoji list(?:\s+(\d+))?$", self.message.raw_message) + max_count = 10 # 默认显示10个 + if match and match.group(1): + max_count = min(int(match.group(1)), 50) # 最多显示50个 + + # 获取当前时间 + time_format: str = self.get_config("time.format", "%Y-%m-%d %H:%M:%S") # type: ignore + now = datetime.datetime.now() + time_str = now.strftime(time_format) + + # 获取表情包信息 + emoji_count = emoji_api.get_count() + emoji_info = emoji_api.get_info() + + # 构建返回消息 + message_lines = [ + f"📊 表情包统计信息 ({time_str})", + f"• 总数: {emoji_count} / {emoji_info['max_count']}", + f"• 可用: {emoji_info['available_emojis']}", + ] + + if emoji_count == 0: + message_lines.append("\n❌ 暂无表情包") + final_message = "\n".join(message_lines) + await self.send_text(final_message) + return True, final_message, True + + # 获取所有表情包 + all_emojis = await emoji_api.get_all() + if not all_emojis: + message_lines.append("\n❌ 无法获取表情包列表") + final_message = "\n".join(message_lines) + await self.send_text(final_message) + return False, final_message, True + + # 显示前N个表情包 + display_emojis = all_emojis[:max_count] + message_lines.append(f"\n📋 显示前 {len(display_emojis)} 个表情包:") + + for i, (_, description, emotion) in enumerate(display_emojis, 1): + # 截断过长的描述 + short_desc = description[:50] + "..." if len(description) > 50 else description + message_lines.append(f"{i}. {short_desc} [{emotion}]") + + # 如果还有更多表情包，显示总数 + if len(all_emojis) > max_count: + message_lines.append(f"\n💡 还有 {len(all_emojis) - max_count} 个表情包未显示") + + final_message = "\n".join(message_lines) + + # 直接发送文本消息 + await self.send_text(final_message) + + return True, final_message, True + + +class DeleteEmojiCommand(BaseCommand): + command_name = "delete_emoji" + command_description = "删除表情包" + command_pattern = r".*/emoji delete.*" + + async def execute(self) -> Tuple[bool, str, bool]: + # 查找消息中的表情包图片 + logger.info(f"查找消息中的表情包用于删除: {self.message.message_segment}") + + emoji_base64_list = self.find_and_return_emoji_in_message(self.message.message_segment) + + if not emoji_base64_list: + return False, "未在消息中找到表情包或图片", False + + # 删除找到的表情包 + success_count = 0 + fail_count = 0 + results = [] + + for i, emoji_base64 in enumerate(emoji_base64_list): + try: + # 计算图片的哈希值来查找对应的表情包 + import base64 + import hashlib + + # 确保base64字符串只包含ASCII字符 + if isinstance(emoji_base64, str): + emoji_base64_clean = emoji_base64.encode("ascii", errors="ignore").decode("ascii") + else: + emoji_base64_clean = str(emoji_base64) + + # 计算哈希值 + image_bytes = base64.b64decode(emoji_base64_clean) + emoji_hash = hashlib.md5(image_bytes).hexdigest() + + # 使用emoji_api删除表情包 + result = await emoji_api.delete_emoji(emoji_hash) + + if result["success"]: + success_count += 1 + description = result.get("description", "未知描述") + count_before = result.get("count_before", 0) + count_after = result.get("count_after", 0) + emotions = result.get("emotions", []) + + result_msg = f"表情包 {i + 1} 删除成功" + if description: + result_msg += f"\n描述: {description}" + if emotions: + result_msg += f"\n情感标签: {', '.join(emotions)}" + result_msg += f"\n表情包数量: {count_before} → {count_after}" + + results.append(result_msg) + else: + fail_count += 1 + error_msg = result.get("message", "删除失败") + results.append(f"表情包 {i + 1} 删除失败: {error_msg}") + + except Exception as e: + fail_count += 1 + results.append(f"表情包 {i + 1} 删除时发生错误: {str(e)}") + + # 构建返回消息 + total_count = success_count + fail_count + summary_msg = f"表情包删除完成: 成功 {success_count} 个，失败 {fail_count} 个，共处理 {total_count} 个" + + # 如果有结果详情，添加到返回消息中 + details_msg = "" + if results: + details_msg = "\n" + "\n".join(results) + final_msg = summary_msg + details_msg + else: + final_msg = summary_msg + + # 使用表达器重写回复 + try: + from src.plugin_system.apis import generator_api + + # 构建重写数据 + rewrite_data = { + "raw_reply": summary_msg, + "reason": f"删除了表情包：{details_msg}\n", + } + + # 调用表达器重写 + result_status, data = await generator_api.rewrite_reply( + chat_stream=self.message.chat_stream, + reply_data=rewrite_data, + ) + + if result_status: + # 发送重写后的回复 + for reply_seg in data.reply_set.reply_data: + send_data = reply_seg.content + await self.send_text(send_data) + + return success_count > 0, final_msg, success_count > 0 + else: + # 如果重写失败，发送原始消息 + await self.send_text(final_msg) + return success_count > 0, final_msg, success_count > 0 + + except Exception as e: + # 如果表达器调用失败，发送原始消息 + logger.error(f"[delete_emoji] 表达器重写失败: {e}") + await self.send_text(final_msg) + return success_count > 0, final_msg, success_count > 0 + + def find_and_return_emoji_in_message(self, message_segments) -> List[str]: + emoji_base64_list = [] + + # 处理单个Seg对象的情况 + if isinstance(message_segments, Seg): + if message_segments.type == "emoji": + emoji_base64_list.append(message_segments.data) + elif message_segments.type == "image": + # 假设图片数据是base64编码的 + emoji_base64_list.append(message_segments.data) + elif message_segments.type == "seglist": + # 递归处理嵌套的Seg列表 + emoji_base64_list.extend(self.find_and_return_emoji_in_message(message_segments.data)) + return emoji_base64_list + + # 处理Seg列表的情况 + for seg in message_segments: + if seg.type == "emoji": + emoji_base64_list.append(seg.data) + elif seg.type == "image": + # 假设图片数据是base64编码的 + emoji_base64_list.append(seg.data) + elif seg.type == "seglist": + # 递归处理嵌套的Seg列表 + emoji_base64_list.extend(self.find_and_return_emoji_in_message(seg.data)) + return emoji_base64_list + + +class RandomEmojis(BaseCommand): + command_name = "random_emojis" + command_description = "发送多张随机表情包" + command_pattern = r"^/random_emojis$" + + async def execute(self): + emojis = await emoji_api.get_random(5) + if not emojis: + return False, "未找到表情包", False + emoji_base64_list = [] + for emoji in emojis: + emoji_base64_list.append(emoji[0]) + return await self.forward_images(emoji_base64_list) + + async def forward_images(self, images: List[str]): + """ + 把多张图片用合并转发的方式发给用户 + """ + success = await self.send_forward([("0", "神秘用户", [(ReplyContentType.IMAGE, img)]) for img in images]) + return (True, "已发送随机表情包", True) if success else (False, "发送随机表情包失败", False) + + +# ===== 插件注册 ===== + + +@register_plugin +class EmojiManagePlugin(BasePlugin): + """表情包管理插件 - 管理表情包""" + + # 插件基本信息 + plugin_name: str = "emoji_manage_plugin" # 内部标识符 + enable_plugin: bool = False + dependencies: List[str] = [] # 插件依赖列表 + python_dependencies: List[str] = [] # Python包依赖列表 + config_file_name: str = "config.toml" # 配置文件名 + + # 配置节描述 + config_section_descriptions = {"plugin": "插件基本信息", "emoji": "表情包功能配置"} + + # 配置Schema定义 + config_schema: dict = { + "plugin": { + "enabled": ConfigField(type=bool, default=True, description="是否启用插件"), + "config_version": ConfigField(type=str, default="1.0.1", description="配置文件版本"), + }, + } + + def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]: + return [ + (RandomEmojis.get_command_info(), RandomEmojis), + (AddEmojiCommand.get_command_info(), AddEmojiCommand), + (ListEmojiCommand.get_command_info(), ListEmojiCommand), + (DeleteEmojiCommand.get_command_info(), DeleteEmojiCommand), + ] diff --git a/plugins/hello_world_plugin/plugin.py b/plugins/hello_world_plugin/plugin.py index 020748a3..3965ca97 100644 --- a/plugins/hello_world_plugin/plugin.py +++ b/plugins/hello_world_plugin/plugin.py @@ -237,8 +237,7 @@ class HelloWorldPlugin(BasePlugin): # 配置Schema定义 config_schema: dict = { "plugin": { - "name": ConfigField(type=str, default="hello_world_plugin", description="插件名称"), - "version": ConfigField(type=str, default="1.0.0", description="插件版本"), + "config_version": ConfigField(type=str, default="1.0.0", description="配置文件版本"), "enabled": ConfigField(type=bool, default=False, description="是否启用插件"), }, "greeting": { diff --git a/pyproject.toml b/pyproject.toml index 700844c4..fb613e19 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,56 +1,37 @@ [project] name = "MaiBot" -version = "0.8.1" +version = "0.11.0" description = "MaiCore 是一个基于大语言模型的可交互智能体" requires-python = ">=3.10" dependencies = [ "aiohttp>=3.12.14", - "apscheduler>=3.11.0", + "aiohttp-cors>=0.8.1", "colorama>=0.4.6", - "cryptography>=45.0.5", - "customtkinter>=5.2.2", - "dotenv>=0.9.9", "faiss-cpu>=1.11.0", "fastapi>=0.116.0", + "google-genai>=1.39.1", "jieba>=0.42.1", "json-repair>=0.47.6", - "jsonlines>=4.0.0", - "maim-message>=0.3.8", + "maim-message", "matplotlib>=3.10.3", - "networkx>=3.4.2", "numpy>=2.2.6", "openai>=1.95.0", - "packaging>=25.0", "pandas>=2.3.1", "peewee>=3.18.2", "pillow>=11.3.0", - "psutil>=7.0.0", "pyarrow>=20.0.0", "pydantic>=2.11.7", - "pymongo>=4.13.2", "pypinyin>=0.54.0", - "python-dateutil>=2.9.0.post0", "python-dotenv>=1.1.1", - "python-igraph>=0.11.9", "quick-algo>=0.1.3", - "reportportal-client>=5.6.5", - "requests>=2.32.4", "rich>=14.0.0", "ruff>=0.12.2", - "scikit-learn>=1.7.0", - "scipy>=1.15.3", - "seaborn>=0.13.2", "setuptools>=80.9.0", - "strawberry-graphql[fastapi]>=0.275.5", "structlog>=25.4.0", "toml>=0.10.2", - "tomli>=2.2.1", - "tomli-w>=1.2.0", "tomlkit>=0.13.3", - "tqdm>=4.67.1", "urllib3>=2.5.0", "uvicorn>=0.35.0", - "websockets>=15.0.1", ] diff --git a/requirements.lock b/requirements.lock deleted file mode 100644 index 4eea567b..00000000 --- a/requirements.lock +++ /dev/null @@ -1,271 +0,0 @@ -# This file was autogenerated by uv via the following command: -# uv pip compile requirements.txt -o requirements.lock -aenum==3.1.16 - # via reportportal-client -aiohappyeyeballs==2.6.1 - # via aiohttp -aiohttp==3.12.14 - # via - # -r requirements.txt - # maim-message - # reportportal-client -aiosignal==1.4.0 - # via aiohttp -annotated-types==0.7.0 - # via pydantic -anyio==4.9.0 - # via - # httpx - # openai - # starlette -apscheduler==3.11.0 - # via -r requirements.txt -attrs==25.3.0 - # via - # aiohttp - # jsonlines -certifi==2025.7.9 - # via - # httpcore - # httpx - # reportportal-client - # requests -cffi==1.17.1 - # via cryptography -charset-normalizer==3.4.2 - # via requests -click==8.2.1 - # via uvicorn -colorama==0.4.6 - # via - # -r requirements.txt - # click - # tqdm -contourpy==1.3.2 - # via matplotlib -cryptography==45.0.5 - # via - # -r requirements.txt - # maim-message -customtkinter==5.2.2 - # via -r requirements.txt -cycler==0.12.1 - # via matplotlib -darkdetect==0.8.0 - # via customtkinter -distro==1.9.0 - # via openai -dnspython==2.7.0 - # via pymongo -dotenv==0.9.9 - # via -r requirements.txt -faiss-cpu==1.11.0 - # via -r requirements.txt -fastapi==0.116.0 - # via - # -r requirements.txt - # maim-message - # strawberry-graphql -fonttools==4.58.5 - # via matplotlib -frozenlist==1.7.0 - # via - # aiohttp - # aiosignal -graphql-core==3.2.6 - # via strawberry-graphql -h11==0.16.0 - # via - # httpcore - # uvicorn -httpcore==1.0.9 - # via httpx -httpx==0.28.1 - # via openai -idna==3.10 - # via - # anyio - # httpx - # requests - # yarl -igraph==0.11.9 - # via python-igraph -jieba==0.42.1 - # via -r requirements.txt -jiter==0.10.0 - # via openai -joblib==1.5.1 - # via scikit-learn -json-repair==0.47.6 - # via -r requirements.txt -jsonlines==4.0.0 - # via -r requirements.txt -kiwisolver==1.4.8 - # via matplotlib -maim-message==0.3.8 - # via -r requirements.txt -markdown-it-py==3.0.0 - # via rich -matplotlib==3.10.3 - # via - # -r requirements.txt - # seaborn -mdurl==0.1.2 - # via markdown-it-py -multidict==6.6.3 - # via - # aiohttp - # yarl -networkx==3.5 - # via -r requirements.txt -numpy==2.3.1 - # via - # -r requirements.txt - # contourpy - # faiss-cpu - # matplotlib - # pandas - # scikit-learn - # scipy - # seaborn -openai==1.95.0 - # via -r requirements.txt -packaging==25.0 - # via - # -r requirements.txt - # customtkinter - # faiss-cpu - # matplotlib - # strawberry-graphql -pandas==2.3.1 - # via - # -r requirements.txt - # seaborn -peewee==3.18.2 - # via -r requirements.txt -pillow==11.3.0 - # via - # -r requirements.txt - # matplotlib -propcache==0.3.2 - # via - # aiohttp - # yarl -psutil==7.0.0 - # via -r requirements.txt -pyarrow==20.0.0 - # via -r requirements.txt -pycparser==2.22 - # via cffi -pydantic==2.11.7 - # via - # -r requirements.txt - # fastapi - # maim-message - # openai -pydantic-core==2.33.2 - # via pydantic -pygments==2.19.2 - # via rich -pymongo==4.13.2 - # via -r requirements.txt -pyparsing==3.2.3 - # via matplotlib -pypinyin==0.54.0 - # via -r requirements.txt -python-dateutil==2.9.0.post0 - # via - # -r requirements.txt - # matplotlib - # pandas - # strawberry-graphql -python-dotenv==1.1.1 - # via - # -r requirements.txt - # dotenv -python-igraph==0.11.9 - # via -r requirements.txt -python-multipart==0.0.20 - # via strawberry-graphql -pytz==2025.2 - # via pandas -quick-algo==0.1.3 - # via -r requirements.txt -reportportal-client==5.6.5 - # via -r requirements.txt -requests==2.32.4 - # via - # -r requirements.txt - # reportportal-client -rich==14.0.0 - # via -r requirements.txt -ruff==0.12.2 - # via -r requirements.txt -scikit-learn==1.7.0 - # via -r requirements.txt -scipy==1.16.0 - # via - # -r requirements.txt - # scikit-learn -seaborn==0.13.2 - # via -r requirements.txt -setuptools==80.9.0 - # via -r requirements.txt -six==1.17.0 - # via python-dateutil -sniffio==1.3.1 - # via - # anyio - # openai -starlette==0.46.2 - # via fastapi -strawberry-graphql==0.275.5 - # via -r requirements.txt -structlog==25.4.0 - # via -r requirements.txt -texttable==1.7.0 - # via igraph -threadpoolctl==3.6.0 - # via scikit-learn -toml==0.10.2 - # via -r requirements.txt -tomli==2.2.1 - # via -r requirements.txt -tomli-w==1.2.0 - # via -r requirements.txt -tomlkit==0.13.3 - # via -r requirements.txt -tqdm==4.67.1 - # via - # -r requirements.txt - # openai -typing-extensions==4.14.1 - # via - # fastapi - # openai - # pydantic - # pydantic-core - # strawberry-graphql - # typing-inspection -typing-inspection==0.4.1 - # via pydantic -tzdata==2025.2 - # via - # pandas - # tzlocal -tzlocal==5.3.1 - # via apscheduler -urllib3==2.5.0 - # via - # -r requirements.txt - # requests -uvicorn==0.35.0 - # via - # -r requirements.txt - # maim-message -websockets==15.0.1 - # via - # -r requirements.txt - # maim-message -yarl==1.20.1 - # via aiohttp diff --git a/requirements.txt b/requirements.txt index d4dd2339..30328554 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,49 +1,28 @@ -APScheduler -Pillow -aiohttp -aiohttp-cors -colorama -customtkinter -dotenv -faiss-cpu -fastapi -jieba -jsonlines -maim_message -quick_algo -matplotlib -networkx -numpy -openai -pandas -peewee -pyarrow -pydantic -pypinyin -python-dateutil -python-dotenv -python-igraph -pymongo -requests -ruff -scipy -setuptools -toml -tomli -tomli_w -tomlkit -tqdm -urllib3 -uvicorn -websockets -strawberry-graphql[fastapi] -packaging -rich -psutil -cryptography -json-repair -reportportal-client -scikit-learn -seaborn -structlog -google.genai +aiohttp>=3.12.14 +aiohttp-cors>=0.8.1 +colorama>=0.4.6 +faiss-cpu>=1.11.0 +fastapi>=0.116.0 +google-genai>=1.39.1 +jieba>=0.42.1 +json-repair>=0.47.6 +maim-message +matplotlib>=3.10.3 +numpy>=2.2.6 +openai>=1.95.0 +pandas>=2.3.1 +peewee>=3.18.2 +pillow>=11.3.0 +pyarrow>=20.0.0 +pydantic>=2.11.7 +pypinyin>=0.54.0 +python-dotenv>=1.1.1 +quick-algo>=0.1.3 +rich>=14.0.0 +ruff>=0.12.2 +setuptools>=80.9.0 +structlog>=25.4.0 +toml>=0.10.2 +tomlkit>=0.13.3 +urllib3>=2.5.0 +uvicorn>=0.35.0 \ No newline at end of file diff --git a/scripts/build_io_pairs.py b/scripts/build_io_pairs.py new file mode 100644 index 00000000..b298dcd2 --- /dev/null +++ b/scripts/build_io_pairs.py @@ -0,0 +1,389 @@ +import argparse +import json +import random +import re +import sys +import os +from datetime import datetime +from typing import Dict, Iterable, List, Optional, Tuple + +# 确保可从任意工作目录运行：将项目根目录加入 sys.path（scripts 的上一级） +PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +if PROJECT_ROOT not in sys.path: + sys.path.insert(0, PROJECT_ROOT) + +from src.common.data_models.database_data_model import DatabaseMessages +from src.common.message_repository import find_messages +from src.chat.utils.chat_message_builder import build_readable_messages + + +SECONDS_5_MINUTES = 5 * 60 + + +def clean_output_text(text: str) -> str: + """ + 清理输出文本，移除表情包和回复内容 + - 移除 [表情包：...] 格式的内容 + - 移除 [回复...] 格式的内容 + """ + if not text: + return text + + # 移除表情包内容：[表情包：...] + text = re.sub(r'\[表情包：[^\]]*\]', '', text) + + # 移除回复内容：[回复...]，说：... 的完整模式 + text = re.sub(r'\[回复[^\]]*\]，说：[^@]*@[^:]*:', '', text) + + # 清理多余的空格和换行 + text = re.sub(r'\s+', ' ', text).strip() + + return text + + +def parse_datetime_to_timestamp(value: str) -> float: + """ + 接受多种常见格式并转换为时间戳（秒） + 支持示例： + - 2025-09-29 + - 2025-09-29 00:00:00 + - 2025/09/29 00:00 + - 2025-09-29T00:00:00 + """ + value = value.strip() + fmts = [ + "%Y-%m-%d %H:%M:%S", + "%Y-%m-%d %H:%M", + "%Y/%m/%d %H:%M:%S", + "%Y/%m/%d %H:%M", + "%Y-%m-%d", + "%Y/%m/%d", + "%Y-%m-%dT%H:%M:%S", + "%Y-%m-%dT%H:%M", + ] + last_err: Optional[Exception] = None + for fmt in fmts: + try: + dt = datetime.strptime(value, fmt) + return dt.timestamp() + except Exception as e: # noqa: BLE001 + last_err = e + raise ValueError(f"无法解析时间: {value} ({last_err})") + + +def fetch_messages_between( + start_ts: float, + end_ts: float, + platform: Optional[str] = None, +) -> List[DatabaseMessages]: + """使用 find_messages 获取指定区间的消息，可选按 chat_info_platform 过滤。按时间升序返回。""" + filter_query: Dict[str, object] = {"time": {"$gt": start_ts, "$lt": end_ts}} + if platform: + filter_query["chat_info_platform"] = platform + # 当 limit==0 时，sort 生效，这里按时间升序 + return find_messages(message_filter=filter_query, sort=[("time", 1)], limit=0) + + +def group_by_chat(messages: Iterable[DatabaseMessages]) -> Dict[str, List[DatabaseMessages]]: + groups: Dict[str, List[DatabaseMessages]] = {} + for msg in messages: + groups.setdefault(msg.chat_id, []).append(msg) + # 保证每个分组内按时间升序 + for chat_id, msgs in groups.items(): + msgs.sort(key=lambda m: m.time or 0) + return groups + + +def _merge_bucket_to_message(bucket: List[DatabaseMessages]) -> DatabaseMessages: + """ + 将相邻、同一 user_id 且 5 分钟内的消息 bucket 合并为一条。 + processed_plain_text 合并（以换行连接），其余字段取最新一条（时间最大）。 + """ + if not bucket: + raise ValueError("bucket 为空，无法合并") + + latest = bucket[-1] + merged_texts: List[str] = [] + for m in bucket: + text = m.processed_plain_text or "" + if text: + merged_texts.append(text) + + merged = DatabaseMessages( + # 其他信息采用最新消息 + message_id=latest.message_id, + time=latest.time, + chat_id=latest.chat_id, + reply_to=latest.reply_to, + interest_value=latest.interest_value, + key_words=latest.key_words, + key_words_lite=latest.key_words_lite, + is_mentioned=latest.is_mentioned, + is_at=latest.is_at, + reply_probability_boost=latest.reply_probability_boost, + processed_plain_text="\n".join(merged_texts) if merged_texts else latest.processed_plain_text, + display_message=latest.display_message, + priority_mode=latest.priority_mode, + priority_info=latest.priority_info, + additional_config=latest.additional_config, + is_emoji=latest.is_emoji, + is_picid=latest.is_picid, + is_command=latest.is_command, + is_notify=latest.is_notify, + selected_expressions=latest.selected_expressions, + user_id=latest.user_info.user_id, + user_nickname=latest.user_info.user_nickname, + user_cardname=latest.user_info.user_cardname, + user_platform=latest.user_info.platform, + chat_info_group_id=(latest.group_info.group_id if latest.group_info else None), + chat_info_group_name=(latest.group_info.group_name if latest.group_info else None), + chat_info_group_platform=(latest.group_info.group_platform if latest.group_info else None), + chat_info_user_id=latest.chat_info.user_info.user_id, + chat_info_user_nickname=latest.chat_info.user_info.user_nickname, + chat_info_user_cardname=latest.chat_info.user_info.user_cardname, + chat_info_user_platform=latest.chat_info.user_info.platform, + chat_info_stream_id=latest.chat_info.stream_id, + chat_info_platform=latest.chat_info.platform, + chat_info_create_time=latest.chat_info.create_time, + chat_info_last_active_time=latest.chat_info.last_active_time, + ) + return merged + + +def merge_adjacent_same_user(messages: List[DatabaseMessages]) -> List[DatabaseMessages]: + """按 5 分钟窗口合并相邻同 user_id 的消息。输入需按时间升序。""" + if not messages: + return [] + + merged: List[DatabaseMessages] = [] + bucket: List[DatabaseMessages] = [] + + def flush_bucket() -> None: + nonlocal bucket + if bucket: + merged.append(_merge_bucket_to_message(bucket)) + bucket = [] + + for msg in messages: + if not bucket: + bucket = [msg] + continue + + last = bucket[-1] + same_user = (msg.user_info.user_id == last.user_info.user_id) + close_enough = ((msg.time or 0) - (last.time or 0) <= SECONDS_5_MINUTES) + + if same_user and close_enough: + bucket.append(msg) + else: + flush_bucket() + bucket = [msg] + + flush_bucket() + return merged + + +def build_pairs_for_chat( + original_messages: List[DatabaseMessages], + merged_messages: List[DatabaseMessages], + min_ctx: int, + max_ctx: int, + target_user_id: Optional[str] = None, +) -> List[Tuple[str, str, str]]: + """ + 对每条合并后的消息作为 output，从其前面取 20-30 条（可配置）的原始消息作为 input。 + input 使用原始未合并的消息构建上下文。 + output 使用合并后消息的 processed_plain_text。 + 如果指定了 target_user_id，则只处理该用户的消息作为 output。 + """ + pairs: List[Tuple[str, str, str]] = [] + n_merged = len(merged_messages) + n_original = len(original_messages) + + if n_merged == 0 or n_original == 0: + return pairs + + # 为每个合并后的消息找到对应的原始消息位置 + merged_to_original_map = {} + original_idx = 0 + + for merged_idx, merged_msg in enumerate(merged_messages): + # 找到这个合并消息对应的第一个原始消息 + while (original_idx < n_original and + original_messages[original_idx].time < merged_msg.time): + original_idx += 1 + + # 如果找到了时间匹配的原始消息，建立映射 + if (original_idx < n_original and + original_messages[original_idx].time == merged_msg.time): + merged_to_original_map[merged_idx] = original_idx + + for merged_idx in range(n_merged): + merged_msg = merged_messages[merged_idx] + + # 如果指定了 target_user_id，只处理该用户的消息作为 output + if target_user_id and merged_msg.user_info.user_id != target_user_id: + continue + + # 找到对应的原始消息位置 + if merged_idx not in merged_to_original_map: + continue + + original_idx = merged_to_original_map[merged_idx] + + # 选择上下文窗口大小 + window = random.randint(min_ctx, max_ctx) if max_ctx > min_ctx else min_ctx + start = max(0, original_idx - window) + context_msgs = original_messages[start:original_idx] + + # 使用原始未合并消息构建 input + input_str = build_readable_messages( + messages=context_msgs, + timestamp_mode="normal_no_YMD", + show_actions=False, + show_pic=True, + ) + + # 输出取合并后消息的 processed_plain_text 并清理表情包和回复内容 + output_text = merged_msg.processed_plain_text or "" + output_text = clean_output_text(output_text) + output_id = merged_msg.message_id or "" + pairs.append((input_str, output_text, output_id)) + + return pairs + + +def build_pairs( + start_ts: float, + end_ts: float, + platform: Optional[str], + user_id: Optional[str], + min_ctx: int, + max_ctx: int, +) -> List[Tuple[str, str, str]]: + # 获取所有消息（不按user_id过滤），这样input上下文可以包含所有用户的消息 + messages = fetch_messages_between(start_ts, end_ts, platform) + groups = group_by_chat(messages) + + all_pairs: List[Tuple[str, str, str]] = [] + for chat_id, msgs in groups.items(): # noqa: F841 - chat_id 未直接使用 + # 对消息进行合并，用于output + merged = merge_adjacent_same_user(msgs) + # 传递原始消息和合并后消息，input使用原始消息，output使用合并后消息 + pairs = build_pairs_for_chat(msgs, merged, min_ctx, max_ctx, user_id) + all_pairs.extend(pairs) + + return all_pairs + + +def main(argv: Optional[List[str]] = None) -> int: + # 若未提供参数，则进入交互模式 + if argv is None: + argv = sys.argv[1:] + + if len(argv) == 0: + return run_interactive() + + parser = argparse.ArgumentParser(description="构建 (input_str, output_str, message_id) 列表，支持按用户ID筛选消息") + parser.add_argument("start", help="起始时间，如 2025-09-28 00:00:00") + parser.add_argument("end", help="结束时间，如 2025-09-29 00:00:00") + parser.add_argument("--platform", default=None, help="仅选择 chat_info_platform 为该值的消息") + parser.add_argument("--user_id", default=None, help="仅选择指定 user_id 的消息") + parser.add_argument("--min_ctx", type=int, default=20, help="输入上下文的最少条数，默认20") + parser.add_argument("--max_ctx", type=int, default=30, help="输入上下文的最多条数，默认30") + parser.add_argument( + "--output", + default=None, + help="输出保存路径，支持 .jsonl（每行 {input, output}），若不指定则打印到stdout", + ) + + args = parser.parse_args(argv) + + start_ts = parse_datetime_to_timestamp(args.start) + end_ts = parse_datetime_to_timestamp(args.end) + if end_ts <= start_ts: + raise ValueError("结束时间必须大于起始时间") + + if args.max_ctx < args.min_ctx: + raise ValueError("max_ctx 不能小于 min_ctx") + + pairs = build_pairs(start_ts, end_ts, args.platform, args.user_id, args.min_ctx, args.max_ctx) + + if args.output: + # 保存为 JSONL，每行一个 {input, output, message_id} + with open(args.output, "w", encoding="utf-8") as f: + for input_str, output_str, message_id in pairs: + obj = {"input": input_str, "output": output_str, "message_id": message_id} + f.write(json.dumps(obj, ensure_ascii=False) + "\n") + print(f"已保存 {len(pairs)} 条到 {args.output}") + else: + # 打印到 stdout + for input_str, output_str, message_id in pairs: + print(json.dumps({"input": input_str, "output": output_str, "message_id": message_id}, ensure_ascii=False)) + + return 0 + + +def _prompt_with_default(prompt_text: str, default: Optional[str]) -> str: + suffix = f"[{default}]" if default not in (None, "") else "" + value = input(f"{prompt_text}{' ' + suffix if suffix else ''}: ").strip() + if value == "" and default is not None: + return default + return value + + +def run_interactive() -> int: + print("进入交互模式（直接回车采用默认值）。时间格式例如：2025-09-28 00:00:00 或 2025-09-28") + start_str = _prompt_with_default("请输入起始时间", None) + end_str = _prompt_with_default("请输入结束时间", None) + platform = _prompt_with_default("平台（可留空表示不限）", "") + user_id = _prompt_with_default("用户ID（可留空表示不限）", "") + try: + min_ctx = int(_prompt_with_default("输入上下文最少条数", "20")) + max_ctx = int(_prompt_with_default("输入上下文最多条数", "30")) + except Exception: + print("上下文条数输入有误，使用默认 20/30") + min_ctx, max_ctx = 20, 30 + output_path = _prompt_with_default("输出路径（.jsonl，可留空打印到控制台）", "") + + if not start_str or not end_str: + print("必须提供起始与结束时间。") + return 2 + + try: + start_ts = parse_datetime_to_timestamp(start_str) + end_ts = parse_datetime_to_timestamp(end_str) + except Exception as e: # noqa: BLE001 + print(f"时间解析失败：{e}") + return 2 + + if end_ts <= start_ts: + print("结束时间必须大于起始时间。") + return 2 + + if max_ctx < min_ctx: + print("最多条数不能小于最少条数。") + return 2 + + platform_val = platform if platform != "" else None + user_id_val = user_id if user_id != "" else None + pairs = build_pairs(start_ts, end_ts, platform_val, user_id_val, min_ctx, max_ctx) + + if output_path: + with open(output_path, "w", encoding="utf-8") as f: + for input_str, output_str, message_id in pairs: + obj = {"input": input_str, "output": output_str, "message_id": message_id} + f.write(json.dumps(obj, ensure_ascii=False) + "\n") + print(f"已保存 {len(pairs)} 条到 {output_path}") + else: + for input_str, output_str, message_id in pairs: + print(json.dumps({"input": input_str, "output": output_str, "message_id": message_id}, ensure_ascii=False)) + print(f"总计 {len(pairs)} 条。") + + return 0 + + +if __name__ == "__main__": + sys.exit(main()) + + diff --git a/scripts/expression_scatter_analysis.py b/scripts/expression_scatter_analysis.py new file mode 100644 index 00000000..f6243ada --- /dev/null +++ b/scripts/expression_scatter_analysis.py @@ -0,0 +1,334 @@ +import time +import sys +import os +import matplotlib.pyplot as plt +import matplotlib.dates as mdates +from datetime import datetime +from typing import List, Tuple +import numpy as np + +# Add project root to Python path +project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +sys.path.insert(0, project_root) + +from src.common.database.database_model import Expression, ChatStreams + +# 设置中文字体 +plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'DejaVu Sans'] +plt.rcParams['axes.unicode_minus'] = False + + +def get_chat_name(chat_id: str) -> str: + """Get chat name from chat_id by querying ChatStreams table directly""" + try: + chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == chat_id) + if chat_stream is None: + return f"未知聊天 ({chat_id})" + + if chat_stream.group_name: + return f"{chat_stream.group_name} ({chat_id})" + elif chat_stream.user_nickname: + return f"{chat_stream.user_nickname}的私聊 ({chat_id})" + else: + return f"未知聊天 ({chat_id})" + except Exception: + return f"查询失败 ({chat_id})" + + +def get_expression_data() -> List[Tuple[float, float, str, str]]: + """获取Expression表中的数据，返回(create_date, count, chat_id, expression_type)的列表""" + expressions = Expression.select() + data = [] + + for expr in expressions: + # 如果create_date为空，跳过该记录 + if expr.create_date is None: + continue + + data.append(( + expr.create_date, + expr.count, + expr.chat_id, + expr.type + )) + + return data + + +def create_scatter_plot(data: List[Tuple[float, float, str, str]], save_path: str = None): + """创建散点图""" + if not data: + print("没有找到有效的表达式数据") + return + + # 分离数据 + create_dates = [item[0] for item in data] + counts = [item[1] for item in data] + chat_ids = [item[2] for item in data] + expression_types = [item[3] for item in data] + + # 转换时间戳为datetime对象 + dates = [datetime.fromtimestamp(ts) for ts in create_dates] + + # 计算时间跨度，自动调整显示格式 + time_span = max(dates) - min(dates) + if time_span.days > 30: # 超过30天，按月显示 + date_format = '%Y-%m-%d' + major_locator = mdates.MonthLocator() + minor_locator = mdates.DayLocator(interval=7) + elif time_span.days > 7: # 超过7天，按天显示 + date_format = '%Y-%m-%d' + major_locator = mdates.DayLocator(interval=1) + minor_locator = mdates.HourLocator(interval=12) + else: # 7天内，按小时显示 + date_format = '%Y-%m-%d %H:%M' + major_locator = mdates.HourLocator(interval=6) + minor_locator = mdates.HourLocator(interval=1) + + # 创建图形 + fig, ax = plt.subplots(figsize=(12, 8)) + + # 创建散点图 + scatter = ax.scatter(dates, counts, alpha=0.6, s=30, c=range(len(dates)), cmap='viridis') + + # 设置标签和标题 + ax.set_xlabel('创建日期 (Create Date)', fontsize=12) + ax.set_ylabel('使用次数 (Count)', fontsize=12) + ax.set_title('表达式使用次数随时间分布散点图', fontsize=14, fontweight='bold') + + # 设置x轴日期格式 - 根据时间跨度自动调整 + ax.xaxis.set_major_formatter(mdates.DateFormatter(date_format)) + ax.xaxis.set_major_locator(major_locator) + ax.xaxis.set_minor_locator(minor_locator) + plt.xticks(rotation=45) + + # 添加网格 + ax.grid(True, alpha=0.3) + + # 添加颜色条 + cbar = plt.colorbar(scatter) + cbar.set_label('数据点顺序', fontsize=10) + + # 调整布局 + plt.tight_layout() + + # 显示统计信息 + print(f"\n=== 数据统计 ===") + print(f"总数据点数量: {len(data)}") + print(f"时间范围: {min(dates).strftime('%Y-%m-%d %H:%M:%S')} 到 {max(dates).strftime('%Y-%m-%d %H:%M:%S')}") + print(f"使用次数范围: {min(counts):.1f} 到 {max(counts):.1f}") + print(f"平均使用次数: {np.mean(counts):.2f}") + print(f"中位数使用次数: {np.median(counts):.2f}") + + # 保存图片 + if save_path: + plt.savefig(save_path, dpi=300, bbox_inches='tight') + print(f"\n散点图已保存到: {save_path}") + + # 显示图片 + plt.show() + + +def create_grouped_scatter_plot(data: List[Tuple[float, float, str, str]], save_path: str = None): + """创建按聊天分组的散点图""" + if not data: + print("没有找到有效的表达式数据") + return + + # 按chat_id分组 + chat_groups = {} + for item in data: + chat_id = item[2] + if chat_id not in chat_groups: + chat_groups[chat_id] = [] + chat_groups[chat_id].append(item) + + # 计算时间跨度，自动调整显示格式 + all_dates = [datetime.fromtimestamp(item[0]) for item in data] + time_span = max(all_dates) - min(all_dates) + if time_span.days > 30: # 超过30天，按月显示 + date_format = '%Y-%m-%d' + major_locator = mdates.MonthLocator() + minor_locator = mdates.DayLocator(interval=7) + elif time_span.days > 7: # 超过7天，按天显示 + date_format = '%Y-%m-%d' + major_locator = mdates.DayLocator(interval=1) + minor_locator = mdates.HourLocator(interval=12) + else: # 7天内，按小时显示 + date_format = '%Y-%m-%d %H:%M' + major_locator = mdates.HourLocator(interval=6) + minor_locator = mdates.HourLocator(interval=1) + + # 创建图形 + fig, ax = plt.subplots(figsize=(14, 10)) + + # 为每个聊天分配不同颜色 + colors = plt.cm.Set3(np.linspace(0, 1, len(chat_groups))) + + for i, (chat_id, chat_data) in enumerate(chat_groups.items()): + create_dates = [item[0] for item in chat_data] + counts = [item[1] for item in chat_data] + dates = [datetime.fromtimestamp(ts) for ts in create_dates] + + chat_name = get_chat_name(chat_id) + # 截断过长的聊天名称 + display_name = chat_name[:20] + "..." if len(chat_name) > 20 else chat_name + + ax.scatter(dates, counts, alpha=0.7, s=40, + c=[colors[i]], label=f"{display_name} ({len(chat_data)}个)", + edgecolors='black', linewidth=0.5) + + # 设置标签和标题 + ax.set_xlabel('创建日期 (Create Date)', fontsize=12) + ax.set_ylabel('使用次数 (Count)', fontsize=12) + ax.set_title('按聊天分组的表达式使用次数散点图', fontsize=14, fontweight='bold') + + # 设置x轴日期格式 - 根据时间跨度自动调整 + ax.xaxis.set_major_formatter(mdates.DateFormatter(date_format)) + ax.xaxis.set_major_locator(major_locator) + ax.xaxis.set_minor_locator(minor_locator) + plt.xticks(rotation=45) + + # 添加图例 + ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=8) + + # 添加网格 + ax.grid(True, alpha=0.3) + + # 调整布局 + plt.tight_layout() + + # 显示统计信息 + print(f"\n=== 分组统计 ===") + print(f"总聊天数量: {len(chat_groups)}") + for chat_id, chat_data in chat_groups.items(): + chat_name = get_chat_name(chat_id) + counts = [item[1] for item in chat_data] + print(f"{chat_name}: {len(chat_data)}个表达式, 平均使用次数: {np.mean(counts):.2f}") + + # 保存图片 + if save_path: + plt.savefig(save_path, dpi=300, bbox_inches='tight') + print(f"\n分组散点图已保存到: {save_path}") + + # 显示图片 + plt.show() + + +def create_type_scatter_plot(data: List[Tuple[float, float, str, str]], save_path: str = None): + """创建按表达式类型分组的散点图""" + if not data: + print("没有找到有效的表达式数据") + return + + # 按type分组 + type_groups = {} + for item in data: + expr_type = item[3] + if expr_type not in type_groups: + type_groups[expr_type] = [] + type_groups[expr_type].append(item) + + # 计算时间跨度，自动调整显示格式 + all_dates = [datetime.fromtimestamp(item[0]) for item in data] + time_span = max(all_dates) - min(all_dates) + if time_span.days > 30: # 超过30天，按月显示 + date_format = '%Y-%m-%d' + major_locator = mdates.MonthLocator() + minor_locator = mdates.DayLocator(interval=7) + elif time_span.days > 7: # 超过7天，按天显示 + date_format = '%Y-%m-%d' + major_locator = mdates.DayLocator(interval=1) + minor_locator = mdates.HourLocator(interval=12) + else: # 7天内，按小时显示 + date_format = '%Y-%m-%d %H:%M' + major_locator = mdates.HourLocator(interval=6) + minor_locator = mdates.HourLocator(interval=1) + + # 创建图形 + fig, ax = plt.subplots(figsize=(12, 8)) + + # 为每个类型分配不同颜色 + colors = plt.cm.tab10(np.linspace(0, 1, len(type_groups))) + + for i, (expr_type, type_data) in enumerate(type_groups.items()): + create_dates = [item[0] for item in type_data] + counts = [item[1] for item in type_data] + dates = [datetime.fromtimestamp(ts) for ts in create_dates] + + ax.scatter(dates, counts, alpha=0.7, s=40, + c=[colors[i]], label=f"{expr_type} ({len(type_data)}个)", + edgecolors='black', linewidth=0.5) + + # 设置标签和标题 + ax.set_xlabel('创建日期 (Create Date)', fontsize=12) + ax.set_ylabel('使用次数 (Count)', fontsize=12) + ax.set_title('按表达式类型分组的散点图', fontsize=14, fontweight='bold') + + # 设置x轴日期格式 - 根据时间跨度自动调整 + ax.xaxis.set_major_formatter(mdates.DateFormatter(date_format)) + ax.xaxis.set_major_locator(major_locator) + ax.xaxis.set_minor_locator(minor_locator) + plt.xticks(rotation=45) + + # 添加图例 + ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + + # 添加网格 + ax.grid(True, alpha=0.3) + + # 调整布局 + plt.tight_layout() + + # 显示统计信息 + print(f"\n=== 类型统计 ===") + for expr_type, type_data in type_groups.items(): + counts = [item[1] for item in type_data] + print(f"{expr_type}: {len(type_data)}个表达式, 平均使用次数: {np.mean(counts):.2f}") + + # 保存图片 + if save_path: + plt.savefig(save_path, dpi=300, bbox_inches='tight') + print(f"\n类型散点图已保存到: {save_path}") + + # 显示图片 + plt.show() + + +def main(): + """主函数""" + print("开始分析表达式数据...") + + # 获取数据 + data = get_expression_data() + + if not data: + print("没有找到有效的表达式数据（create_date不为空的数据）") + return + + print(f"找到 {len(data)} 条有效数据") + + # 创建输出目录 + output_dir = os.path.join(project_root, "data", "temp") + os.makedirs(output_dir, exist_ok=True) + + # 生成时间戳用于文件名 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + + # 1. 创建基础散点图 + print("\n1. 创建基础散点图...") + create_scatter_plot(data, os.path.join(output_dir, f"expression_scatter_{timestamp}.png")) + + # 2. 创建按聊天分组的散点图 + print("\n2. 创建按聊天分组的散点图...") + create_grouped_scatter_plot(data, os.path.join(output_dir, f"expression_scatter_by_chat_{timestamp}.png")) + + # 3. 创建按类型分组的散点图 + print("\n3. 创建按类型分组的散点图...") + create_type_scatter_plot(data, os.path.join(output_dir, f"expression_scatter_by_type_{timestamp}.png")) + + print("\n分析完成！") + + +if __name__ == "__main__": + main() diff --git a/scripts/interest_value_analysis.py b/scripts/interest_value_analysis.py deleted file mode 100644 index bce37b4a..00000000 --- a/scripts/interest_value_analysis.py +++ /dev/null @@ -1,285 +0,0 @@ -import time -import sys -import os -from typing import Dict, List, Tuple, Optional -from datetime import datetime - -# Add project root to Python path -project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) -sys.path.insert(0, project_root) -from src.common.database.database_model import Messages, ChatStreams # noqa - - -def get_chat_name(chat_id: str) -> str: - """Get chat name from chat_id by querying ChatStreams table directly""" - try: - chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == chat_id) - if chat_stream is None: - return f"未知聊天 ({chat_id})" - - if chat_stream.group_name: - return f"{chat_stream.group_name} ({chat_id})" - elif chat_stream.user_nickname: - return f"{chat_stream.user_nickname}的私聊 ({chat_id})" - else: - return f"未知聊天 ({chat_id})" - except Exception: - return f"查询失败 ({chat_id})" - - -def format_timestamp(timestamp: float) -> str: - """Format timestamp to readable date string""" - try: - return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S") - except (ValueError, OSError): - return "未知时间" - - -def calculate_interest_value_distribution(messages) -> Dict[str, int]: - """Calculate distribution of interest_value""" - distribution = { - "0.000-0.010": 0, - "0.010-0.050": 0, - "0.050-0.100": 0, - "0.100-0.500": 0, - "0.500-1.000": 0, - "1.000-2.000": 0, - "2.000-5.000": 0, - "5.000-10.000": 0, - "10.000+": 0, - } - - for msg in messages: - if msg.interest_value is None or msg.interest_value == 0.0: - continue - - value = float(msg.interest_value) - if value < 0.010: - distribution["0.000-0.010"] += 1 - elif value < 0.050: - distribution["0.010-0.050"] += 1 - elif value < 0.100: - distribution["0.050-0.100"] += 1 - elif value < 0.500: - distribution["0.100-0.500"] += 1 - elif value < 1.000: - distribution["0.500-1.000"] += 1 - elif value < 2.000: - distribution["1.000-2.000"] += 1 - elif value < 5.000: - distribution["2.000-5.000"] += 1 - elif value < 10.000: - distribution["5.000-10.000"] += 1 - else: - distribution["10.000+"] += 1 - - return distribution - - -def get_interest_value_stats(messages) -> Dict[str, float]: - """Calculate basic statistics for interest_value""" - values = [ - float(msg.interest_value) for msg in messages if msg.interest_value is not None and msg.interest_value != 0.0 - ] - - if not values: - return {"count": 0, "min": 0, "max": 0, "avg": 0, "median": 0} - - values.sort() - count = len(values) - - return { - "count": count, - "min": min(values), - "max": max(values), - "avg": sum(values) / count, - "median": values[count // 2] if count % 2 == 1 else (values[count // 2 - 1] + values[count // 2]) / 2, - } - - -def get_available_chats() -> List[Tuple[str, str, int]]: - """Get all available chats with message counts""" - try: - # 获取所有有消息的chat_id - chat_counts = {} - for msg in Messages.select(Messages.chat_id).distinct(): - chat_id = msg.chat_id - count = ( - Messages.select() - .where( - (Messages.chat_id == chat_id) - & (Messages.interest_value.is_null(False)) - & (Messages.interest_value != 0.0) - ) - .count() - ) - if count > 0: - chat_counts[chat_id] = count - - # 获取聊天名称 - result = [] - for chat_id, count in chat_counts.items(): - chat_name = get_chat_name(chat_id) - result.append((chat_id, chat_name, count)) - - # 按消息数量排序 - result.sort(key=lambda x: x[2], reverse=True) - return result - except Exception as e: - print(f"获取聊天列表失败: {e}") - return [] - - -def get_time_range_input() -> Tuple[Optional[float], Optional[float]]: - """Get time range input from user""" - print("\n时间范围选择:") - print("1. 最近1天") - print("2. 最近3天") - print("3. 最近7天") - print("4. 最近30天") - print("5. 自定义时间范围") - print("6. 不限制时间") - - choice = input("请选择时间范围 (1-6): ").strip() - - now = time.time() - - if choice == "1": - return now - 24 * 3600, now - elif choice == "2": - return now - 3 * 24 * 3600, now - elif choice == "3": - return now - 7 * 24 * 3600, now - elif choice == "4": - return now - 30 * 24 * 3600, now - elif choice == "5": - print("请输入开始时间 (格式: YYYY-MM-DD HH:MM:SS):") - start_str = input().strip() - print("请输入结束时间 (格式: YYYY-MM-DD HH:MM:SS):") - end_str = input().strip() - - try: - start_time = datetime.strptime(start_str, "%Y-%m-%d %H:%M:%S").timestamp() - end_time = datetime.strptime(end_str, "%Y-%m-%d %H:%M:%S").timestamp() - return start_time, end_time - except ValueError: - print("时间格式错误，将不限制时间范围") - return None, None - else: - return None, None - - -def analyze_interest_values( - chat_id: Optional[str] = None, start_time: Optional[float] = None, end_time: Optional[float] = None -) -> None: - """Analyze interest values with optional filters""" - - # 构建查询条件 - query = Messages.select().where((Messages.interest_value.is_null(False)) & (Messages.interest_value != 0.0)) - - if chat_id: - query = query.where(Messages.chat_id == chat_id) - - if start_time: - query = query.where(Messages.time >= start_time) - - if end_time: - query = query.where(Messages.time <= end_time) - - messages = list(query) - - if not messages: - print("没有找到符合条件的消息") - return - - # 计算统计信息 - distribution = calculate_interest_value_distribution(messages) - stats = get_interest_value_stats(messages) - - # 显示结果 - print("\n=== Interest Value 分析结果 ===") - if chat_id: - print(f"聊天: {get_chat_name(chat_id)}") - else: - print("聊天: 全部聊天") - - if start_time and end_time: - print(f"时间范围: {format_timestamp(start_time)} 到 {format_timestamp(end_time)}") - elif start_time: - print(f"时间范围: {format_timestamp(start_time)} 之后") - elif end_time: - print(f"时间范围: {format_timestamp(end_time)} 之前") - else: - print("时间范围: 不限制") - - print("\n基本统计:") - print(f"有效消息数量: {stats['count']} (排除null和0值)") - print(f"最小值: {stats['min']:.3f}") - print(f"最大值: {stats['max']:.3f}") - print(f"平均值: {stats['avg']:.3f}") - print(f"中位数: {stats['median']:.3f}") - - print("\nInterest Value 分布:") - total = stats["count"] - for range_name, count in distribution.items(): - if count > 0: - percentage = count / total * 100 - print(f"{range_name}: {count} ({percentage:.2f}%)") - - -def interactive_menu() -> None: - """Interactive menu for interest value analysis""" - - while True: - print("\n" + "=" * 50) - print("Interest Value 分析工具") - print("=" * 50) - print("1. 分析全部聊天") - print("2. 选择特定聊天分析") - print("q. 退出") - - choice = input("\n请选择分析模式 (1-2, q): ").strip() - - if choice.lower() == "q": - print("再见！") - break - - chat_id = None - - if choice == "2": - # 显示可用的聊天列表 - chats = get_available_chats() - if not chats: - print("没有找到有interest_value数据的聊天") - continue - - print(f"\n可用的聊天 (共{len(chats)}个):") - for i, (_cid, name, count) in enumerate(chats, 1): - print(f"{i}. {name} ({count}条有效消息)") - - try: - chat_choice = int(input(f"\n请选择聊天 (1-{len(chats)}): ").strip()) - if 1 <= chat_choice <= len(chats): - chat_id = chats[chat_choice - 1][0] - else: - print("无效选择") - continue - except ValueError: - print("请输入有效数字") - continue - - elif choice != "1": - print("无效选择") - continue - - # 获取时间范围 - start_time, end_time = get_time_range_input() - - # 执行分析 - analyze_interest_values(chat_id, start_time, end_time) - - input("\n按回车键继续...") - - -if __name__ == "__main__": - interactive_menu() diff --git a/scripts/text_length_analysis.py b/scripts/text_length_analysis.py deleted file mode 100644 index 5a329b93..00000000 --- a/scripts/text_length_analysis.py +++ /dev/null @@ -1,397 +0,0 @@ -import time -import sys -import os -import re -from typing import Dict, List, Tuple, Optional -from datetime import datetime - -# Add project root to Python path -project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) -sys.path.insert(0, project_root) -from src.common.database.database_model import Messages, ChatStreams # noqa - - -def contains_emoji_or_image_tags(text: str) -> bool: - """Check if text contains [表情包xxxxx] or [图片xxxxx] tags""" - if not text: - return False - - # 检查是否包含 [表情包] 或 [图片] 标记 - emoji_pattern = r"\[表情包[^\]]*\]" - image_pattern = r"\[图片[^\]]*\]" - - return bool(re.search(emoji_pattern, text) or re.search(image_pattern, text)) - - -def clean_reply_text(text: str) -> str: - """Remove reply references like [回复 xxxx...] from text""" - if not text: - return text - - # 匹配 [回复 xxxx...] 格式的内容 - # 使用非贪婪匹配，匹配到第一个 ] 就停止 - cleaned_text = re.sub(r"\[回复[^\]]*\]", "", text) - - # 去除多余的空白字符 - cleaned_text = cleaned_text.strip() - - return cleaned_text - - -def get_chat_name(chat_id: str) -> str: - """Get chat name from chat_id by querying ChatStreams table directly""" - try: - chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == chat_id) - if chat_stream is None: - return f"未知聊天 ({chat_id})" - - if chat_stream.group_name: - return f"{chat_stream.group_name} ({chat_id})" - elif chat_stream.user_nickname: - return f"{chat_stream.user_nickname}的私聊 ({chat_id})" - else: - return f"未知聊天 ({chat_id})" - except Exception: - return f"查询失败 ({chat_id})" - - -def format_timestamp(timestamp: float) -> str: - """Format timestamp to readable date string""" - try: - return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S") - except (ValueError, OSError): - return "未知时间" - - -def calculate_text_length_distribution(messages) -> Dict[str, int]: - """Calculate distribution of processed_plain_text length""" - distribution = { - "0": 0, # 空文本 - "1-5": 0, # 极短文本 - "6-10": 0, # 很短文本 - "11-20": 0, # 短文本 - "21-30": 0, # 较短文本 - "31-50": 0, # 中短文本 - "51-70": 0, # 中等文本 - "71-100": 0, # 较长文本 - "101-150": 0, # 长文本 - "151-200": 0, # 很长文本 - "201-300": 0, # 超长文本 - "301-500": 0, # 极长文本 - "501-1000": 0, # 巨长文本 - "1000+": 0, # 超巨长文本 - } - - for msg in messages: - if msg.processed_plain_text is None: - continue - - # 排除包含表情包或图片标记的消息 - if contains_emoji_or_image_tags(msg.processed_plain_text): - continue - - # 清理文本中的回复引用 - cleaned_text = clean_reply_text(msg.processed_plain_text) - length = len(cleaned_text) - - if length == 0: - distribution["0"] += 1 - elif length <= 5: - distribution["1-5"] += 1 - elif length <= 10: - distribution["6-10"] += 1 - elif length <= 20: - distribution["11-20"] += 1 - elif length <= 30: - distribution["21-30"] += 1 - elif length <= 50: - distribution["31-50"] += 1 - elif length <= 70: - distribution["51-70"] += 1 - elif length <= 100: - distribution["71-100"] += 1 - elif length <= 150: - distribution["101-150"] += 1 - elif length <= 200: - distribution["151-200"] += 1 - elif length <= 300: - distribution["201-300"] += 1 - elif length <= 500: - distribution["301-500"] += 1 - elif length <= 1000: - distribution["501-1000"] += 1 - else: - distribution["1000+"] += 1 - - return distribution - - -def get_text_length_stats(messages) -> Dict[str, float]: - """Calculate basic statistics for processed_plain_text length""" - lengths = [] - null_count = 0 - excluded_count = 0 # 被排除的消息数量 - - for msg in messages: - if msg.processed_plain_text is None: - null_count += 1 - elif contains_emoji_or_image_tags(msg.processed_plain_text): - # 排除包含表情包或图片标记的消息 - excluded_count += 1 - else: - # 清理文本中的回复引用 - cleaned_text = clean_reply_text(msg.processed_plain_text) - lengths.append(len(cleaned_text)) - - if not lengths: - return { - "count": 0, - "null_count": null_count, - "excluded_count": excluded_count, - "min": 0, - "max": 0, - "avg": 0, - "median": 0, - } - - lengths.sort() - count = len(lengths) - - return { - "count": count, - "null_count": null_count, - "excluded_count": excluded_count, - "min": min(lengths), - "max": max(lengths), - "avg": sum(lengths) / count, - "median": lengths[count // 2] if count % 2 == 1 else (lengths[count // 2 - 1] + lengths[count // 2]) / 2, - } - - -def get_available_chats() -> List[Tuple[str, str, int]]: - """Get all available chats with message counts""" - try: - # 获取所有有消息的chat_id，排除特殊类型消息 - chat_counts = {} - for msg in Messages.select(Messages.chat_id).distinct(): - chat_id = msg.chat_id - count = ( - Messages.select() - .where( - (Messages.chat_id == chat_id) - & (Messages.is_emoji != 1) - & (Messages.is_picid != 1) - & (Messages.is_command != 1) - ) - .count() - ) - if count > 0: - chat_counts[chat_id] = count - - # 获取聊天名称 - result = [] - for chat_id, count in chat_counts.items(): - chat_name = get_chat_name(chat_id) - result.append((chat_id, chat_name, count)) - - # 按消息数量排序 - result.sort(key=lambda x: x[2], reverse=True) - return result - except Exception as e: - print(f"获取聊天列表失败: {e}") - return [] - - -def get_time_range_input() -> Tuple[Optional[float], Optional[float]]: - """Get time range input from user""" - print("\n时间范围选择:") - print("1. 最近1天") - print("2. 最近3天") - print("3. 最近7天") - print("4. 最近30天") - print("5. 自定义时间范围") - print("6. 不限制时间") - - choice = input("请选择时间范围 (1-6): ").strip() - - now = time.time() - - if choice == "1": - return now - 24 * 3600, now - elif choice == "2": - return now - 3 * 24 * 3600, now - elif choice == "3": - return now - 7 * 24 * 3600, now - elif choice == "4": - return now - 30 * 24 * 3600, now - elif choice == "5": - print("请输入开始时间 (格式: YYYY-MM-DD HH:MM:SS):") - start_str = input().strip() - print("请输入结束时间 (格式: YYYY-MM-DD HH:MM:SS):") - end_str = input().strip() - - try: - start_time = datetime.strptime(start_str, "%Y-%m-%d %H:%M:%S").timestamp() - end_time = datetime.strptime(end_str, "%Y-%m-%d %H:%M:%S").timestamp() - return start_time, end_time - except ValueError: - print("时间格式错误，将不限制时间范围") - return None, None - else: - return None, None - - -def get_top_longest_messages(messages, top_n: int = 10) -> List[Tuple[str, int, str, str]]: - """Get top N longest messages""" - message_lengths = [] - - for msg in messages: - if msg.processed_plain_text is not None: - # 排除包含表情包或图片标记的消息 - if contains_emoji_or_image_tags(msg.processed_plain_text): - continue - - # 清理文本中的回复引用 - cleaned_text = clean_reply_text(msg.processed_plain_text) - length = len(cleaned_text) - chat_name = get_chat_name(msg.chat_id) - time_str = format_timestamp(msg.time) - # 截取前100个字符作为预览 - preview = cleaned_text[:100] + "..." if len(cleaned_text) > 100 else cleaned_text - message_lengths.append((chat_name, length, time_str, preview)) - - # 按长度排序，取前N个 - message_lengths.sort(key=lambda x: x[1], reverse=True) - return message_lengths[:top_n] - - -def analyze_text_lengths( - chat_id: Optional[str] = None, start_time: Optional[float] = None, end_time: Optional[float] = None -) -> None: - """Analyze processed_plain_text lengths with optional filters""" - - # 构建查询条件，排除特殊类型的消息 - query = Messages.select().where((Messages.is_emoji != 1) & (Messages.is_picid != 1) & (Messages.is_command != 1)) - - if chat_id: - query = query.where(Messages.chat_id == chat_id) - - if start_time: - query = query.where(Messages.time >= start_time) - - if end_time: - query = query.where(Messages.time <= end_time) - - messages = list(query) - - if not messages: - print("没有找到符合条件的消息") - return - - # 计算统计信息 - distribution = calculate_text_length_distribution(messages) - stats = get_text_length_stats(messages) - top_longest = get_top_longest_messages(messages, 10) - - # 显示结果 - print("\n=== Processed Plain Text 长度分析结果 ===") - print("(已排除表情、图片ID、命令类型消息，已排除[表情包]和[图片]标记消息，已清理回复引用)") - if chat_id: - print(f"聊天: {get_chat_name(chat_id)}") - else: - print("聊天: 全部聊天") - - if start_time and end_time: - print(f"时间范围: {format_timestamp(start_time)} 到 {format_timestamp(end_time)}") - elif start_time: - print(f"时间范围: {format_timestamp(start_time)} 之后") - elif end_time: - print(f"时间范围: {format_timestamp(end_time)} 之前") - else: - print("时间范围: 不限制") - - print("\n基本统计:") - print(f"总消息数量: {len(messages)}") - print(f"有文本消息数量: {stats['count']}") - print(f"空文本消息数量: {stats['null_count']}") - print(f"被排除的消息数量: {stats['excluded_count']}") - if stats["count"] > 0: - print(f"最短长度: {stats['min']} 字符") - print(f"最长长度: {stats['max']} 字符") - print(f"平均长度: {stats['avg']:.2f} 字符") - print(f"中位数长度: {stats['median']:.2f} 字符") - - print("\n文本长度分布:") - total = stats["count"] - if total > 0: - for range_name, count in distribution.items(): - if count > 0: - percentage = count / total * 100 - print(f"{range_name} 字符: {count} ({percentage:.2f}%)") - - # 显示最长的消息 - if top_longest: - print(f"\n最长的 {len(top_longest)} 条消息:") - for i, (chat_name, length, time_str, preview) in enumerate(top_longest, 1): - print(f"{i}. [{chat_name}] {time_str}") - print(f" 长度: {length} 字符") - print(f" 预览: {preview}") - print() - - -def interactive_menu() -> None: - """Interactive menu for text length analysis""" - - while True: - print("\n" + "=" * 50) - print("Processed Plain Text 长度分析工具") - print("=" * 50) - print("1. 分析全部聊天") - print("2. 选择特定聊天分析") - print("q. 退出") - - choice = input("\n请选择分析模式 (1-2, q): ").strip() - - if choice.lower() == "q": - print("再见！") - break - - chat_id = None - - if choice == "2": - # 显示可用的聊天列表 - chats = get_available_chats() - if not chats: - print("没有找到聊天数据") - continue - - print(f"\n可用的聊天 (共{len(chats)}个):") - for i, (_cid, name, count) in enumerate(chats, 1): - print(f"{i}. {name} ({count}条消息)") - - try: - chat_choice = int(input(f"\n请选择聊天 (1-{len(chats)}): ").strip()) - if 1 <= chat_choice <= len(chats): - chat_id = chats[chat_choice - 1][0] - else: - print("无效选择") - continue - except ValueError: - print("请输入有效数字") - continue - - elif choice != "1": - print("无效选择") - continue - - # 获取时间范围 - start_time, end_time = get_time_range_input() - - # 执行分析 - analyze_text_lengths(chat_id, start_time, end_time) - - input("\n按回车键继续...") - - -if __name__ == "__main__": - interactive_menu() diff --git a/src/chat/brain_chat/brain_chat.py b/src/chat/brain_chat/brain_chat.py index 5ba077ab..b5d2cec7 100644 --- a/src/chat/brain_chat/brain_chat.py +++ b/src/chat/brain_chat/brain_chat.py @@ -16,8 +16,7 @@ from src.chat.brain_chat.brain_planner import BrainPlanner from src.chat.planner_actions.action_modifier import ActionModifier from src.chat.planner_actions.action_manager import ActionManager from src.chat.heart_flow.hfc_utils import CycleDetail -from src.chat.heart_flow.hfc_utils import send_typing, stop_typing -from src.chat.express.expression_learner import expression_learner_manager +from src.express.expression_learner import expression_learner_manager from src.person_info.person_info import Person from src.plugin_system.base.component_types import EventType, ActionInfo from src.plugin_system.core import events_manager @@ -96,7 +95,6 @@ class BrainChatting: self.last_read_time = time.time() - 2 self.more_plan = False - async def start(self): """检查是否需要启动主循环，如果未激活则启动。""" @@ -171,10 +169,8 @@ class BrainChatting: if len(recent_messages_list) >= 1: self.last_read_time = time.time() - await self._observe( - recent_messages_list=recent_messages_list - ) - + await self._observe(recent_messages_list=recent_messages_list) + else: # Normal模式：消息数量不足，等待 await asyncio.sleep(0.2) @@ -233,11 +229,11 @@ class BrainChatting: async def _observe( self, # interest_value: float = 0.0, - recent_messages_list: Optional[List["DatabaseMessages"]] = None + recent_messages_list: Optional[List["DatabaseMessages"]] = None, ) -> bool: # sourcery skip: merge-else-if-into-elif, remove-redundant-if if recent_messages_list is None: recent_messages_list = [] - reply_text = "" # 初始化reply_text变量，避免UnboundLocalError + _reply_text = "" # 初始化reply_text变量，避免UnboundLocalError async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()): await self.expression_learner.trigger_learning_for_chat() @@ -286,7 +282,7 @@ class BrainChatting: prompt_info = (modified_message.llm_prompt, prompt_info[1]) with Timer("规划器", cycle_timers): - action_to_use_info, _ = await self.action_planner.plan( + action_to_use_info = await self.action_planner.plan( loop_start_time=self.last_read_time, available_actions=available_actions, ) @@ -334,7 +330,7 @@ class BrainChatting: "taken_time": time.time(), } ) - reply_text = reply_text_from_reply + _reply_text = reply_text_from_reply else: # 没有回复信息，构建纯动作的loop_info loop_info = { @@ -347,7 +343,7 @@ class BrainChatting: "taken_time": time.time(), }, } - reply_text = action_reply_text + _reply_text = action_reply_text self.end_cycle(loop_info, cycle_timers) self.print_cycle_info(cycle_timers) @@ -401,7 +397,7 @@ class BrainChatting: action_handler = self.action_manager.create_action( action_name=action, action_data=action_data, - reasoning=reasoning, + action_reasoning=reasoning, cycle_timers=cycle_timers, thinking_id=thinking_id, chat_stream=self.chat_stream, @@ -417,8 +413,8 @@ class BrainChatting: logger.warning(f"{self.log_prefix} 未能创建动作处理器: {action}") return False, "", "" - # 处理动作并获取结果 - result = await action_handler.execute() + # 处理动作并获取结果（固定记录一次动作信息） + result = await action_handler.run() success, action_text = result command = "" @@ -484,13 +480,12 @@ class BrainChatting: """执行单个动作的通用函数""" try: with Timer(f"动作{action_planner_info.action_type}", cycle_timers): - if action_planner_info.action_type == "no_reply": - # 直接处理no_action逻辑，不再通过动作系统 + # 直接处理no_reply逻辑，不再通过动作系统 reason = action_planner_info.reasoning or "选择不回复" # logger.info(f"{self.log_prefix} 选择不回复，原因: {reason}") - # 存储no_action信息到数据库 + # 存储no_reply信息到数据库 await database_api.store_action_info( chat_stream=self.chat_stream, action_build_into_prompt=False, @@ -498,9 +493,9 @@ class BrainChatting: action_done=True, thinking_id=thinking_id, action_data={"reason": reason}, - action_name="no_action", + action_name="no_reply", ) - return {"action_type": "no_action", "success": True, "reply_text": "", "command": ""} + return {"action_type": "no_reply", "success": True, "reply_text": "", "command": ""} elif action_planner_info.action_type == "reply": try: @@ -517,7 +512,9 @@ class BrainChatting: if not success or not llm_response or not llm_response.reply_set: if action_planner_info.action_message: - logger.info(f"对 {action_planner_info.action_message.processed_plain_text} 的回复生成失败") + logger.info( + f"对 {action_planner_info.action_message.processed_plain_text} 的回复生成失败" + ) else: logger.info("回复生成失败") return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None} diff --git a/src/chat/brain_chat/brain_planner.py b/src/chat/brain_chat/brain_planner.py index 971a7356..35cdf172 100644 --- a/src/chat/brain_chat/brain_planner.py +++ b/src/chat/brain_chat/brain_planner.py @@ -152,10 +152,10 @@ class BrainPlanner: action_planner_infos = [] try: - action = action_json.get("action", "no_action") + action = action_json.get("action", "no_reply") reasoning = action_json.get("reason", "未提供原因") action_data = {key: value for key, value in action_json.items() if key not in ["action", "reason"]} - # 非no_action动作需要target_message_id + # 非no_reply动作需要target_message_id target_message = None if target_message_id := action_json.get("target_message_id"): @@ -215,12 +215,11 @@ class BrainPlanner: self, available_actions: Dict[str, ActionInfo], loop_start_time: float = 0.0, - ) -> Tuple[List[ActionPlannerInfo], Optional["DatabaseMessages"]]: + ) -> List[ActionPlannerInfo]: # sourcery skip: use-named-expression """ 规划器 (Planner): 使用LLM根据上下文决定做出什么动作。 """ - target_message: Optional["DatabaseMessages"] = None # 获取聊天上下文 message_list_before_now = get_raw_msg_before_timestamp_with_chat( @@ -274,12 +273,7 @@ class BrainPlanner: loop_start_time=loop_start_time, ) - # 获取target_message（如果有非no_action的动作） - non_no_actions = [a for a in actions if a.action_type != "no_reply"] - if non_no_actions: - target_message = non_no_actions[0].action_message - - return actions, target_message + return actions async def build_planner_prompt( self, @@ -307,7 +301,9 @@ class BrainPlanner: if chat_target_info: # 构建聊天上下文描述 - chat_context_description = f"你正在和 {chat_target_info.person_name or chat_target_info.user_nickname or '对方'} 聊天中" + chat_context_description = ( + f"你正在和 {chat_target_info.person_name or chat_target_info.user_nickname or '对方'} 聊天中" + ) # 构建动作选项块 action_options_block = await self._build_action_options_block(current_available_actions) @@ -487,19 +483,19 @@ class BrainPlanner: else: actions = self._create_no_reply("规划器没有获得LLM响应", available_actions) - # 添加循环开始时间到所有非no_action动作 + # 添加循环开始时间到所有非no_reply动作 for action in actions: action.action_data = action.action_data or {} action.action_data["loop_start_time"] = loop_start_time - logger.info( + logger.debug( f"{self.log_prefix}规划器决定执行{len(actions)}个动作: {' '.join([a.action_type for a in actions])}" ) return actions def _create_no_reply(self, reasoning: str, available_actions: Dict[str, ActionInfo]) -> List[ActionPlannerInfo]: - """创建no_action""" + """创建no_reply""" return [ ActionPlannerInfo( action_type="no_reply", diff --git a/src/chat/express/expression_learner.py b/src/chat/express/expression_learner.py deleted file mode 100644 index e36d4d57..00000000 --- a/src/chat/express/expression_learner.py +++ /dev/null @@ -1,604 +0,0 @@ -import time -import random -import json -import os -from datetime import datetime - -from typing import List, Dict, Optional, Any, Tuple - -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.config.config import model_config, global_config -from src.chat.utils.chat_message_builder import get_raw_msg_by_timestamp_with_chat_inclusive, build_anonymous_messages -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager -from src.chat.message_receive.chat_stream import get_chat_manager - - -MAX_EXPRESSION_COUNT = 300 -DECAY_DAYS = 15 # 30天衰减到0.01 -DECAY_MIN = 0.01 # 最小衰减值 - -logger = get_logger("expressor") - - -def format_create_date(timestamp: float) -> str: - """ - 将时间戳格式化为可读的日期字符串 - """ - try: - return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S") - except (ValueError, OSError): - return "未知时间" - - -def init_prompt() -> None: - learn_style_prompt = """ -{chat_str} - -请从上面这段群聊中概括除了人名为"SELF"之外的人的语言风格 -1. 只考虑文字，不要考虑表情包和图片 -2. 不要涉及具体的人名，但是可以涉及具体名词 -3. 思考有没有特殊的梗，一并总结成语言风格 -4. 例子仅供参考，请严格根据群聊内容总结!!! -注意：总结成如下格式的规律，总结的内容要详细，但具有概括性： -例如：当"AAAAA"时，可以"BBBBB", AAAAA代表某个具体的场景，不超过20个字。BBBBB代表对应的语言风格，特定句式或表达方式，不超过20个字。 - -例如： -当"对某件事表示十分惊叹"时，使用"我嘞个xxxx" -当"表示讽刺的赞同，不讲道理"时，使用"对对对" -当"想说明某个具体的事实观点，但懒得明说，使用"懂的都懂" -当"当涉及游戏相关时，夸赞，略带戏谑意味"时，使用"这么强！" - -请注意：不要总结你自己（SELF）的发言，尽量保证总结内容的逻辑性 -现在请你概括 -""" - Prompt(learn_style_prompt, "learn_style_prompt") - - -class ExpressionLearner: - def __init__(self, chat_id: str) -> None: - self.express_learn_model: LLMRequest = LLMRequest( - model_set=model_config.model_task_config.replyer, request_type="expression.learner" - ) - self.chat_id = chat_id - self.chat_name = get_chat_manager().get_stream_name(chat_id) or chat_id - - # 维护每个chat的上次学习时间 - self.last_learning_time: float = time.time() - - # 学习参数 - self.min_messages_for_learning = 25 # 触发学习所需的最少消息数 - self.min_learning_interval = 300 # 最短学习时间间隔（秒） - - def can_learn_for_chat(self) -> bool: - """ - 检查指定聊天流是否允许学习表达 - - Args: - chat_id: 聊天流ID - - Returns: - bool: 是否允许学习 - """ - try: - use_expression, enable_learning, _ = global_config.expression.get_expression_config_for_chat(self.chat_id) - return enable_learning - except Exception as e: - logger.error(f"检查学习权限失败: {e}") - return False - - def should_trigger_learning(self) -> bool: - """ - 检查是否应该触发学习 - - Args: - chat_id: 聊天流ID - - Returns: - bool: 是否应该触发学习 - """ - current_time = time.time() - - # 获取该聊天流的学习强度 - try: - _, enable_learning, learning_intensity = global_config.expression.get_expression_config_for_chat( - self.chat_id - ) - except Exception as e: - logger.error(f"获取聊天流 {self.chat_id} 的学习配置失败: {e}") - return False - - # 检查是否允许学习 - if not enable_learning: - return False - - # 根据学习强度计算最短学习时间间隔 - min_interval = self.min_learning_interval / learning_intensity - - # 检查时间间隔 - time_diff = current_time - self.last_learning_time - if time_diff < min_interval: - return False - - # 检查消息数量（只检查指定聊天流的消息） - recent_messages = get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id=self.chat_id, - timestamp_start=self.last_learning_time, - timestamp_end=time.time(), - ) - - if not recent_messages or len(recent_messages) < self.min_messages_for_learning: - return False - - return True - - async def trigger_learning_for_chat(self) -> bool: - """ - 为指定聊天流触发学习 - - Args: - chat_id: 聊天流ID - - Returns: - bool: 是否成功触发学习 - """ - if not self.should_trigger_learning(): - return False - - try: - logger.info(f"为聊天流 {self.chat_name} 触发表达学习") - - # 学习语言风格 - learnt_style = await self.learn_and_store(num=25) - - # 更新学习时间 - self.last_learning_time = time.time() - - if learnt_style: - logger.info(f"聊天流 {self.chat_name} 表达学习完成") - return True - else: - logger.warning(f"聊天流 {self.chat_name} 表达学习未获得有效结果") - return False - - except Exception as e: - logger.error(f"为聊天流 {self.chat_name} 触发学习失败: {e}") - return False - - def _apply_global_decay_to_database(self, current_time: float) -> None: - """ - 对数据库中的所有表达方式应用全局衰减 - """ - try: - # 获取所有表达方式 - all_expressions = Expression.select() - - updated_count = 0 - deleted_count = 0 - - for expr in all_expressions: - # 计算时间差 - last_active = expr.last_active_time - time_diff_days = (current_time - last_active) / (24 * 3600) # 转换为天 - - # 计算衰减值 - decay_value = self.calculate_decay_factor(time_diff_days) - new_count = max(0.01, expr.count - decay_value) - - if new_count <= 0.01: - # 如果count太小，删除这个表达方式 - expr.delete_instance() - deleted_count += 1 - else: - # 更新count - expr.count = new_count - expr.save() - updated_count += 1 - - if updated_count > 0 or deleted_count > 0: - logger.info(f"全局衰减完成：更新了 {updated_count} 个表达方式，删除了 {deleted_count} 个表达方式") - - except Exception as e: - logger.error(f"数据库全局衰减失败: {e}") - - def calculate_decay_factor(self, time_diff_days: float) -> float: - """ - 计算衰减值 - 当时间差为0天时，衰减值为0（最近活跃的不衰减） - 当时间差为7天时，衰减值为0.002（中等衰减） - 当时间差为30天或更长时，衰减值为0.01（高衰减） - 使用二次函数进行曲线插值 - """ - if time_diff_days <= 0: - return 0.0 # 刚激活的表达式不衰减 - - if time_diff_days >= DECAY_DAYS: - return 0.01 # 长时间未活跃的表达式大幅衰减 - - # 使用二次函数插值：在0-30天之间从0衰减到0.01 - # 使用简单的二次函数：y = a * x^2 - # 当x=30时，y=0.01，所以 a = 0.01 / (30^2) = 0.01 / 900 - a = 0.01 / (DECAY_DAYS**2) - decay = a * (time_diff_days**2) - - return min(0.01, decay) - - async def learn_and_store(self, num: int = 10) -> List[Tuple[str, str, str]]: - """ - 学习并存储表达方式 - """ - # 检查是否允许在此聊天流中学习（在函数最前面检查） - if not self.can_learn_for_chat(): - logger.debug(f"聊天流 {self.chat_name} 不允许学习表达，跳过学习") - return [] - - res = await self.learn_expression(num) - - if res is None: - return [] - learnt_expressions, chat_id = res - - chat_stream = get_chat_manager().get_stream(chat_id) - if chat_stream is None: - group_name = f"聊天流 {chat_id}" - elif chat_stream.group_info: - group_name = chat_stream.group_info.group_name - else: - group_name = f"{chat_stream.user_info.user_nickname}的私聊" - learnt_expressions_str = "" - for _chat_id, situation, style in learnt_expressions: - learnt_expressions_str += f"{situation}->{style}\n" - logger.info(f"在 {group_name} 学习到表达风格:\n{learnt_expressions_str}") - - if not learnt_expressions: - logger.info("没有学习到表达风格") - return [] - - # 按chat_id分组 - chat_dict: Dict[str, List[Dict[str, Any]]] = {} - for chat_id, situation, style in learnt_expressions: - if chat_id not in chat_dict: - chat_dict[chat_id] = [] - chat_dict[chat_id].append({"situation": situation, "style": style}) - - current_time = time.time() - - # 存储到数据库 Expression 表 - for chat_id, expr_list in chat_dict.items(): - for new_expr in expr_list: - # 查找是否已存在相似表达方式 - query = Expression.select().where( - (Expression.chat_id == chat_id) - & (Expression.type == "style") - & (Expression.situation == new_expr["situation"]) - & (Expression.style == new_expr["style"]) - ) - if query.exists(): - expr_obj = query.get() - # 50%概率替换内容 - if random.random() < 0.5: - expr_obj.situation = new_expr["situation"] - expr_obj.style = new_expr["style"] - expr_obj.count = expr_obj.count + 1 - expr_obj.last_active_time = current_time - expr_obj.save() - else: - Expression.create( - situation=new_expr["situation"], - style=new_expr["style"], - count=1, - last_active_time=current_time, - chat_id=chat_id, - type="style", - create_date=current_time, # 手动设置创建日期 - ) - # 限制最大数量 - exprs = list( - Expression.select() - .where((Expression.chat_id == chat_id) & (Expression.type == "style")) - .order_by(Expression.count.asc()) - ) - if len(exprs) > MAX_EXPRESSION_COUNT: - # 删除count最小的多余表达方式 - for expr in exprs[: len(exprs) - MAX_EXPRESSION_COUNT]: - expr.delete_instance() - return learnt_expressions - - async def learn_expression(self, num: int = 10) -> Optional[Tuple[List[Tuple[str, str, str]], str]]: - """从指定聊天流学习表达方式 - - Args: - num: 学习数量 - """ - type_str = "语言风格" - prompt = "learn_style_prompt" - - current_time = time.time() - - # 获取上次学习时间 - random_msg = get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id=self.chat_id, - timestamp_start=self.last_learning_time, - timestamp_end=current_time, - limit=num, - ) - # print(random_msg) - if not random_msg or random_msg == []: - return None - # 转化成str - chat_id: str = random_msg[0].chat_id - # random_msg_str: str = build_readable_messages(random_msg, timestamp_mode="normal") - random_msg_str: str = await build_anonymous_messages(random_msg) - # print(f"random_msg_str:{random_msg_str}") - - prompt: str = await global_prompt_manager.format_prompt( - prompt, - chat_str=random_msg_str, - ) - - logger.debug(f"学习{type_str}的prompt: {prompt}") - - try: - response, _ = await self.express_learn_model.generate_response_async(prompt, temperature=0.3) - except Exception as e: - logger.error(f"学习{type_str}失败: {e}") - return None - - logger.debug(f"学习{type_str}的response: {response}") - - expressions: List[Tuple[str, str, str]] = self.parse_expression_response(response, chat_id) - - return expressions, chat_id - - def parse_expression_response(self, response: str, chat_id: str) -> List[Tuple[str, str, str]]: - """ - 解析LLM返回的表达风格总结，每一行提取"当"和"使用"之间的内容，存储为(situation, style)元组 - """ - expressions: List[Tuple[str, str, str]] = [] - for line in response.splitlines(): - line = line.strip() - if not line: - continue - # 查找"当"和下一个引号 - idx_when = line.find('当"') - if idx_when == -1: - continue - idx_quote1 = idx_when + 1 - idx_quote2 = line.find('"', idx_quote1 + 1) - if idx_quote2 == -1: - continue - situation = line[idx_quote1 + 1 : idx_quote2] - # 查找"使用" - idx_use = line.find('使用"', idx_quote2) - if idx_use == -1: - continue - idx_quote3 = idx_use + 2 - idx_quote4 = line.find('"', idx_quote3 + 1) - if idx_quote4 == -1: - continue - style = line[idx_quote3 + 1 : idx_quote4] - expressions.append((chat_id, situation, style)) - return expressions - - -init_prompt() - - -class ExpressionLearnerManager: - def __init__(self): - self.expression_learners = {} - - self._ensure_expression_directories() - self._auto_migrate_json_to_db() - self._migrate_old_data_create_date() - - def get_expression_learner(self, chat_id: str) -> ExpressionLearner: - if chat_id not in self.expression_learners: - self.expression_learners[chat_id] = ExpressionLearner(chat_id) - return self.expression_learners[chat_id] - - def _ensure_expression_directories(self): - """ - 确保表达方式相关的目录结构存在 - """ - base_dir = os.path.join("data", "expression") - directories_to_create = [ - base_dir, - os.path.join(base_dir, "learnt_style"), - os.path.join(base_dir, "learnt_grammar"), - ] - - for directory in directories_to_create: - try: - os.makedirs(directory, exist_ok=True) - logger.debug(f"确保目录存在: {directory}") - except Exception as e: - logger.error(f"创建目录失败 {directory}: {e}") - - def _auto_migrate_json_to_db(self): - """ - 自动将/data/expression/learnt_style 和 learnt_grammar 下所有expressions.json迁移到数据库。 - 迁移完成后在/data/expression/done.done写入标记文件，存在则跳过。 - 然后检查done.done2，如果没有就删除所有grammar表达并创建该标记文件。 - """ - base_dir = os.path.join("data", "expression") - done_flag = os.path.join(base_dir, "done.done") - done_flag2 = os.path.join(base_dir, "done.done2") - - # 确保基础目录存在 - try: - os.makedirs(base_dir, exist_ok=True) - logger.debug(f"确保目录存在: {base_dir}") - except Exception as e: - logger.error(f"创建表达方式目录失败: {e}") - return - - if os.path.exists(done_flag): - logger.info("表达方式JSON已迁移，无需重复迁移。") - else: - logger.info("开始迁移表达方式JSON到数据库...") - migrated_count = 0 - - for type in ["learnt_style", "learnt_grammar"]: - type_str = "style" if type == "learnt_style" else "grammar" - type_dir = os.path.join(base_dir, type) - if not os.path.exists(type_dir): - logger.debug(f"目录不存在，跳过: {type_dir}") - continue - - try: - chat_ids = os.listdir(type_dir) - logger.debug(f"在 {type_dir} 中找到 {len(chat_ids)} 个聊天ID目录") - except Exception as e: - logger.error(f"读取目录失败 {type_dir}: {e}") - continue - - for chat_id in chat_ids: - expr_file = os.path.join(type_dir, chat_id, "expressions.json") - if not os.path.exists(expr_file): - continue - try: - with open(expr_file, "r", encoding="utf-8") as f: - expressions = json.load(f) - - if not isinstance(expressions, list): - logger.warning(f"表达方式文件格式错误，跳过: {expr_file}") - continue - - for expr in expressions: - if not isinstance(expr, dict): - continue - - situation = expr.get("situation") - style_val = expr.get("style") - count = expr.get("count", 1) - last_active_time = expr.get("last_active_time", time.time()) - - if not situation or not style_val: - logger.warning(f"表达方式缺少必要字段，跳过: {expr}") - continue - - # 查重：同chat_id+type+situation+style - from src.common.database.database_model import Expression - - query = Expression.select().where( - (Expression.chat_id == chat_id) - & (Expression.type == type_str) - & (Expression.situation == situation) - & (Expression.style == style_val) - ) - if query.exists(): - expr_obj = query.get() - expr_obj.count = max(expr_obj.count, count) - expr_obj.last_active_time = max(expr_obj.last_active_time, last_active_time) - expr_obj.save() - else: - Expression.create( - situation=situation, - style=style_val, - count=count, - last_active_time=last_active_time, - chat_id=chat_id, - type=type_str, - create_date=last_active_time, # 迁移时使用last_active_time作为创建时间 - ) - migrated_count += 1 - logger.info(f"已迁移 {expr_file} 到数据库，包含 {len(expressions)} 个表达方式") - except json.JSONDecodeError as e: - logger.error(f"JSON解析失败 {expr_file}: {e}") - except Exception as e: - logger.error(f"迁移表达方式 {expr_file} 失败: {e}") - - # 标记迁移完成 - try: - # 确保done.done文件的父目录存在 - done_parent_dir = os.path.dirname(done_flag) - if not os.path.exists(done_parent_dir): - os.makedirs(done_parent_dir, exist_ok=True) - logger.debug(f"为done.done创建父目录: {done_parent_dir}") - - with open(done_flag, "w", encoding="utf-8") as f: - f.write("done\n") - logger.info(f"表达方式JSON迁移已完成，共迁移 {migrated_count} 个表达方式，已写入done.done标记文件") - except PermissionError as e: - logger.error(f"权限不足，无法写入done.done标记文件: {e}") - except OSError as e: - logger.error(f"文件系统错误，无法写入done.done标记文件: {e}") - except Exception as e: - logger.error(f"写入done.done标记文件失败: {e}") - - # 检查并处理grammar表达删除 - if not os.path.exists(done_flag2): - logger.info("开始删除所有grammar类型的表达...") - try: - deleted_count = self.delete_all_grammar_expressions() - logger.info(f"grammar表达删除完成，共删除 {deleted_count} 个表达") - - # 创建done.done2标记文件 - with open(done_flag2, "w", encoding="utf-8") as f: - f.write("done\n") - logger.info("已创建done.done2标记文件，grammar表达删除标记完成") - except Exception as e: - logger.error(f"删除grammar表达或创建标记文件失败: {e}") - else: - logger.info("grammar表达已删除，跳过重复删除") - - def _migrate_old_data_create_date(self): - """ - 为没有create_date的老数据设置创建日期 - 使用last_active_time作为create_date的默认值 - """ - try: - # 查找所有create_date为空的表达方式 - old_expressions = Expression.select().where(Expression.create_date.is_null()) - updated_count = 0 - - for expr in old_expressions: - # 使用last_active_time作为create_date - expr.create_date = expr.last_active_time - expr.save() - updated_count += 1 - - if updated_count > 0: - logger.info(f"已为 {updated_count} 个老的表达方式设置创建日期") - except Exception as e: - logger.error(f"迁移老数据创建日期失败: {e}") - - def delete_all_grammar_expressions(self) -> int: - """ - 检查expression库中所有type为"grammar"的表达并全部删除 - - Returns: - int: 删除的grammar表达数量 - """ - try: - # 查询所有type为"grammar"的表达 - grammar_expressions = Expression.select().where(Expression.type == "grammar") - grammar_count = grammar_expressions.count() - - if grammar_count == 0: - logger.info("expression库中没有找到grammar类型的表达") - return 0 - - logger.info(f"找到 {grammar_count} 个grammar类型的表达，开始删除...") - - # 删除所有grammar类型的表达 - deleted_count = 0 - for expr in grammar_expressions: - try: - expr.delete_instance() - deleted_count += 1 - except Exception as e: - logger.error(f"删除grammar表达失败: {e}") - continue - - logger.info(f"成功删除 {deleted_count} 个grammar类型的表达") - return deleted_count - - except Exception as e: - logger.error(f"删除grammar表达过程中发生错误: {e}") - return 0 - - -expression_learner_manager = ExpressionLearnerManager() diff --git a/src/chat/express/expression_selector.py b/src/chat/express/expression_selector.py deleted file mode 100644 index 557ffd11..00000000 --- a/src/chat/express/expression_selector.py +++ /dev/null @@ -1,316 +0,0 @@ -import json -import time -import random -import hashlib - -from typing import List, Dict, Optional, Any, Tuple -from json_repair import repair_json - -from src.llm_models.utils_model import LLMRequest -from src.config.config import global_config, model_config -from src.common.logger import get_logger -from src.common.database.database_model import Expression -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager - -logger = get_logger("expression_selector") - - -def init_prompt(): - expression_evaluation_prompt = """ -以下是正在进行的聊天内容： -{chat_observe_info} - -你的名字是{bot_name}{target_message} - -以下是可选的表达情境： -{all_situations} - -请你分析聊天内容的语境、情绪、话题类型，从上述情境中选择最适合当前聊天情境的，最多{max_num}个情境。 -考虑因素包括： -1. 聊天的情绪氛围（轻松、严肃、幽默等） -2. 话题类型（日常、技术、游戏、情感等） -3. 情境与当前语境的匹配度 -{target_message_extra_block} - -请以JSON格式输出，只需要输出选中的情境编号： -例如： -{{ - "selected_situations": [2, 3, 5, 7, 19] -}} - -请严格按照JSON格式输出，不要包含其他内容： -""" - Prompt(expression_evaluation_prompt, "expression_evaluation_prompt") - - -def weighted_sample(population: List[Dict], weights: List[float], k: int) -> List[Dict]: - """按权重随机抽样""" - if not population or not weights or k <= 0: - return [] - - if len(population) <= k: - return population.copy() - - # 使用累积权重的方法进行加权抽样 - selected = [] - population_copy = population.copy() - weights_copy = weights.copy() - - for _ in range(k): - if not population_copy: - break - - # 选择一个元素 - chosen_idx = random.choices(range(len(population_copy)), weights=weights_copy)[0] - selected.append(population_copy.pop(chosen_idx)) - weights_copy.pop(chosen_idx) - - return selected - - -class ExpressionSelector: - def __init__(self): - self.llm_model = LLMRequest( - model_set=model_config.model_task_config.utils_small, request_type="expression.selector" - ) - - def can_use_expression_for_chat(self, chat_id: str) -> bool: - """ - 检查指定聊天流是否允许使用表达 - - Args: - chat_id: 聊天流ID - - Returns: - bool: 是否允许使用表达 - """ - try: - use_expression, _, _ = global_config.expression.get_expression_config_for_chat(chat_id) - return use_expression - except Exception as e: - logger.error(f"检查表达使用权限失败: {e}") - return False - - @staticmethod - def _parse_stream_config_to_chat_id(stream_config_str: str) -> Optional[str]: - """解析'platform:id:type'为chat_id（与get_stream_id一致）""" - try: - parts = stream_config_str.split(":") - if len(parts) != 3: - return None - platform = parts[0] - id_str = parts[1] - stream_type = parts[2] - is_group = stream_type == "group" - if is_group: - components = [platform, str(id_str)] - else: - components = [platform, str(id_str), "private"] - key = "_".join(components) - return hashlib.md5(key.encode()).hexdigest() - except Exception: - return None - - def get_related_chat_ids(self, chat_id: str) -> List[str]: - """根据expression_groups配置，获取与当前chat_id相关的所有chat_id（包括自身）""" - groups = global_config.expression.expression_groups - - # 检查是否存在全局共享组（包含"*"的组） - global_group_exists = any("*" in group for group in groups) - - if global_group_exists: - # 如果存在全局共享组，则返回所有可用的chat_id - all_chat_ids = set() - for group in groups: - for stream_config_str in group: - if chat_id_candidate := self._parse_stream_config_to_chat_id(stream_config_str): - all_chat_ids.add(chat_id_candidate) - return list(all_chat_ids) if all_chat_ids else [chat_id] - - # 否则使用现有的组逻辑 - for group in groups: - group_chat_ids = [] - for stream_config_str in group: - if chat_id_candidate := self._parse_stream_config_to_chat_id(stream_config_str): - group_chat_ids.append(chat_id_candidate) - if chat_id in group_chat_ids: - return group_chat_ids - return [chat_id] - - def get_random_expressions(self, chat_id: str, total_num: int) -> List[Dict[str, Any]]: - # sourcery skip: extract-duplicate-method, move-assign - # 支持多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)) & (Expression.type == "style") - ) - - style_exprs = [ - { - "id": expr.id, - "situation": expr.situation, - "style": expr.style, - "count": expr.count, - "last_active_time": expr.last_active_time, - "source_id": expr.chat_id, - "type": "style", - "create_date": expr.create_date if expr.create_date is not None else expr.last_active_time, - } - for expr in style_query - ] - - # 按权重抽样（使用count作为权重） - if style_exprs: - style_weights = [expr.get("count", 1) for expr in style_exprs] - selected_style = weighted_sample(style_exprs, style_weights, total_num) - else: - selected_style = [] - return selected_style - - def update_expressions_count_batch(self, expressions_to_update: List[Dict[str, Any]], increment: float = 0.1): - """对一批表达方式更新count值，按chat_id+type分组后一次性写入数据库""" - if not expressions_to_update: - return - updates_by_key = {} - for expr in expressions_to_update: - source_id: str = expr.get("source_id") # type: ignore - expr_type: str = expr.get("type", "style") - situation: str = expr.get("situation") # type: ignore - style: str = expr.get("style") # type: ignore - if not source_id or not situation or not style: - logger.warning(f"表达方式缺少必要字段，无法更新: {expr}") - continue - key = (source_id, expr_type, situation, style) - if key not in updates_by_key: - updates_by_key[key] = expr - for chat_id, expr_type, situation, style in updates_by_key: - query = Expression.select().where( - (Expression.chat_id == chat_id) - & (Expression.type == expr_type) - & (Expression.situation == situation) - & (Expression.style == style) - ) - if query.exists(): - expr_obj = query.get() - current_count = expr_obj.count - new_count = min(current_count + increment, 5.0) - expr_obj.count = new_count - expr_obj.last_active_time = time.time() - expr_obj.save() - logger.debug( - f"表达方式激活: 原count={current_count:.3f}, 增量={increment}, 新count={new_count:.3f} in db" - ) - - async def select_suitable_expressions_llm( - self, - chat_id: str, - chat_info: str, - max_num: int = 10, - target_message: Optional[str] = None, - ) -> Tuple[List[Dict[str, Any]], List[int]]: - # sourcery skip: inline-variable, list-comprehension - """使用LLM选择适合的表达方式""" - - # 检查是否允许在此聊天流中使用表达 - if not self.can_use_expression_for_chat(chat_id): - logger.debug(f"聊天流 {chat_id} 不允许使用表达，返回空列表") - return [], [] - - # 1. 获取20个随机表达方式（现在按权重抽取） - style_exprs = self.get_random_expressions(chat_id, 20) - - if len(style_exprs) < 10: - logger.info(f"聊天流 {chat_id} 表达方式正在积累中") - return [], [] - - # 2. 构建所有表达方式的索引和情境列表 - all_expressions: List[Dict[str, Any]] = [] - all_situations: List[str] = [] - - # 添加style表达方式 - for expr in style_exprs: - expr = expr.copy() - all_expressions.append(expr) - all_situations.append(f"{len(all_expressions)}.当 {expr['situation']} 时，使用 {expr['style']}") - - if not all_expressions: - logger.warning("没有找到可用的表达方式") - return [], [] - - all_situations_str = "\n".join(all_situations) - - if target_message: - target_message_str = f"，现在你想要回复消息：{target_message}" - target_message_extra_block = "4.考虑你要回复的目标消息" - else: - target_message_str = "" - target_message_extra_block = "" - - # 3. 构建prompt（只包含情境，不包含完整的表达方式） - prompt = (await global_prompt_manager.get_prompt_async("expression_evaluation_prompt")).format( - bot_name=global_config.bot.nickname, - chat_observe_info=chat_info, - all_situations=all_situations_str, - max_num=max_num, - target_message=target_message_str, - target_message_extra_block=target_message_extra_block, - ) - - # 4. 调用LLM - try: - # start_time = time.time() - content, (reasoning_content, model_name, _) = await self.llm_model.generate_response_async(prompt=prompt) - # logger.info(f"LLM请求时间: {model_name} {time.time() - start_time} \n{prompt}") - - # logger.info(f"模型名称: {model_name}") - # logger.info(f"LLM返回结果: {content}") - # if reasoning_content: - # logger.info(f"LLM推理: {reasoning_content}") - # else: - # logger.info(f"LLM推理: 无") - - if not content: - logger.warning("LLM返回空结果") - return [], [] - - # 5. 解析结果 - result = repair_json(content) - if isinstance(result, str): - result = json.loads(result) - - if not isinstance(result, dict) or "selected_situations" not in result: - logger.error("LLM返回格式错误") - logger.info(f"LLM返回结果: \n{content}") - return [], [] - - selected_indices = result["selected_situations"] - - # 根据索引获取完整的表达方式 - valid_expressions: List[Dict[str, Any]] = [] - selected_ids = [] - for idx in selected_indices: - if isinstance(idx, int) and 1 <= idx <= len(all_expressions): - expression = all_expressions[idx - 1] # 索引从1开始 - selected_ids.append(expression["id"]) - valid_expressions.append(expression) - - # 对选中的所有表达方式，一次性更新count数 - if valid_expressions: - self.update_expressions_count_batch(valid_expressions, 0.006) - - # logger.info(f"LLM从{len(all_expressions)}个情境中选择了{len(valid_expressions)}个") - return valid_expressions, selected_ids - - except Exception as e: - logger.error(f"LLM处理表达方式选择时出错: {e}") - return [], [] - - -init_prompt() - -try: - expression_selector = ExpressionSelector() -except Exception as e: - logger.error(f"ExpressionSelector初始化失败: {e}") diff --git a/src/chat/frequency_control/frequency_control.py b/src/chat/frequency_control/frequency_control.py index 1d9b1fbb..60056c21 100644 --- a/src/chat/frequency_control/frequency_control.py +++ b/src/chat/frequency_control/frequency_control.py @@ -43,4 +43,4 @@ class FrequencyControlManager: # 创建全局实例 -frequency_control_manager = FrequencyControlManager() \ No newline at end of file +frequency_control_manager = FrequencyControlManager() diff --git a/src/chat/heart_flow/heartFC_chat.py b/src/chat/heart_flow/heartFC_chat.py index 2ea8b519..676616e5 100644 --- a/src/chat/heart_flow/heartFC_chat.py +++ b/src/chat/heart_flow/heartFC_chat.py @@ -1,4 +1,5 @@ import asyncio +from multiprocessing import context import time import traceback import random @@ -17,14 +18,15 @@ from src.chat.planner_actions.action_modifier import ActionModifier from src.chat.planner_actions.action_manager import ActionManager from src.chat.heart_flow.hfc_utils import CycleDetail from src.chat.heart_flow.hfc_utils import send_typing, stop_typing -from src.chat.express.expression_learner import expression_learner_manager +from src.express.expression_learner import expression_learner_manager from src.chat.frequency_control.frequency_control import frequency_control_manager +from src.memory_system.question_maker import QuestionMaker +from src.memory_system.questions import global_conflict_tracker from src.person_info.person_info import Person from src.plugin_system.base.component_types import EventType, ActionInfo from src.plugin_system.core import events_manager from src.plugin_system.apis import generator_api, send_api, message_api, database_api -from src.mais4u.mai_think import mai_thinking_manager -from src.mais4u.s4u_config import s4u_config +from src.memory_system.Memory_chest import global_memory_chest from src.chat.utils.chat_message_builder import ( build_readable_messages_with_id, get_raw_msg_before_timestamp_with_chat, @@ -98,11 +100,15 @@ class HeartFChatting: self._current_cycle_detail: CycleDetail = None # type: ignore self.last_read_time = time.time() - 2 - - self.talk_threshold = global_config.chat.talk_value - self.no_reply_until_call = False + self.is_mute = False + + self.last_active_time = time.time() # 记录上一次非noreply时间 + + self.questioned = False + + async def start(self): """检查是否需要启动主循环，如果未激活则启动。""" @@ -154,16 +160,19 @@ class HeartFChatting: # 记录循环信息和计时器结果 timer_strings = [] for name, elapsed in cycle_timers.items(): - formatted_time = f"{elapsed * 1000:.2f}毫秒" if elapsed < 1 else f"{elapsed:.2f}秒" + if elapsed < 0.1: + # 不显示小于0.1秒的计时器 + continue + formatted_time = f"{elapsed:.2f}秒" timer_strings.append(f"{name}: {formatted_time}") logger.info( f"{self.log_prefix} 第{self._current_cycle_detail.cycle_id}次思考," - f"耗时: {self._current_cycle_detail.end_time - self._current_cycle_detail.start_time:.1f}秒" # type: ignore - + (f"\n详情: {'; '.join(timer_strings)}" if timer_strings else "") + f"耗时: {self._current_cycle_detail.end_time - self._current_cycle_detail.start_time:.1f}秒;" # type: ignore + + (f"详情: {'; '.join(timer_strings)}" if timer_strings else "") ) - async def _loopbody(self): # sourcery skip: hoist-if-from-if + async def _loopbody(self): recent_messages_list = message_api.get_messages_by_time_in_chat( chat_id=self.stream_id, start_time=self.last_read_time, @@ -174,7 +183,43 @@ class HeartFChatting: filter_command=True, ) + question_probability = 0 + if time.time() - self.last_active_time > 3600: + question_probability = 0.001 + elif time.time() - self.last_active_time > 1200: + question_probability = 0.0003 + else: + question_probability = 0.0001 + + question_probability = question_probability * global_config.chat.get_auto_chat_value(self.stream_id) + + # print(f"{self.log_prefix} questioned: {self.questioned},len: {len(global_conflict_tracker.get_questions_by_chat_id(self.stream_id))}") + if question_probability > 0 and not self.questioned and len(global_conflict_tracker.get_questions_by_chat_id(self.stream_id)) == 0: #长久没有回复，可以试试主动发言，提问概率随着时间增加 + # logger.info(f"{self.log_prefix} 长久没有回复，可以试试主动发言，概率: {question_probability}") + if random.random() < question_probability: # 30%概率主动发言 + try: + self.questioned = True + self.last_active_time = time.time() + # print(f"{self.log_prefix} 长久没有回复，可以试试主动发言，开始生成问题") + logger.info(f"{self.log_prefix} 长久没有回复，可以试试主动发言，开始生成问题") + cycle_timers, thinking_id = self.start_cycle() + question_maker = QuestionMaker(self.stream_id) + question, context,conflict_context = await question_maker.make_question() + if question: + logger.info(f"{self.log_prefix} 问题: {question}") + await global_conflict_tracker.track_conflict(question, conflict_context, True, self.stream_id) + await self._lift_question_reply(question,context,thinking_id) + else: + logger.info(f"{self.log_prefix} 无问题") + # self.end_cycle(cycle_timers, thinking_id) + except Exception as e: + logger.error(f"{self.log_prefix} 主动提问失败: {e}") + print(traceback.format_exc()) + + if len(recent_messages_list) >= 1: + # for message in recent_messages_list: + # print(message.processed_plain_text) # !处理no_reply_until_call逻辑 if self.no_reply_until_call: for message in recent_messages_list: @@ -185,6 +230,7 @@ class HeartFChatting: or time.time() - self.last_read_time > 600 ): self.no_reply_until_call = False + self.last_read_time = time.time() break # 没有提到，继续保持沉默 if self.no_reply_until_call: @@ -200,15 +246,22 @@ class HeartFChatting: if (message.is_mentioned or message.is_at) and global_config.chat.mentioned_bot_reply: mentioned_message = message + logger.info(f"{self.log_prefix} 当前talk_value: {global_config.chat.get_talk_value(self.stream_id)}") + # *控制频率用 if mentioned_message: await self._observe(recent_messages_list=recent_messages_list, force_reply_message=mentioned_message) - elif random.random() < global_config.chat.talk_value * frequency_control_manager.get_or_create_frequency_control(self.stream_id).get_talk_frequency_adjust(): + elif ( + random.random() + < global_config.chat.get_talk_value(self.stream_id) + * frequency_control_manager.get_or_create_frequency_control(self.stream_id).get_talk_frequency_adjust() + ): await self._observe(recent_messages_list=recent_messages_list) else: + # 没有提到，继续保持沉默，等待5秒防止频繁触发 + await asyncio.sleep(10) return True else: - # Normal模式：消息数量不足，等待 await asyncio.sleep(0.2) return True return True @@ -272,12 +325,14 @@ class HeartFChatting: recent_messages_list = [] reply_text = "" # 初始化reply_text变量，避免UnboundLocalError - if s4u_config.enable_s4u: - await send_typing() + start_time = time.time() + async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()): - await self.expression_learner.trigger_learning_for_chat() - + asyncio.create_task(self.expression_learner.trigger_learning_for_chat()) + asyncio.create_task(global_memory_chest.build_running_content(chat_id=self.stream_id)) + + cycle_timers, thinking_id = self.start_cycle() logger.info(f"{self.log_prefix} 开始第{self._cycle_counter}次思考") @@ -322,7 +377,7 @@ class HeartFChatting: prompt_info = (modified_message.llm_prompt, prompt_info[1]) with Timer("规划器", cycle_timers): - action_to_use_info, _ = await self.action_planner.plan( + action_to_use_info = await self.action_planner.plan( loop_start_time=self.last_read_time, available_actions=available_actions, ) @@ -344,6 +399,10 @@ class HeartFChatting: ) ) + logger.info( + f"{self.log_prefix} 决定执行{len(action_to_use_info)}个动作: {' '.join([a.action_type for a in action_to_use_info])}" + ) + # 3. 并行执行所有动作 action_tasks = [ asyncio.create_task( @@ -361,21 +420,26 @@ class HeartFChatting: action_success = False action_reply_text = "" + excute_result_str = "" for result in results: + excute_result_str += f"{result['action_type']} 执行结果:{result['result']}\n" + if isinstance(result, BaseException): logger.error(f"{self.log_prefix} 动作执行异常: {result}") continue if result["action_type"] != "reply": action_success = result["success"] - action_reply_text = result["reply_text"] + action_reply_text = result["result"] elif result["action_type"] == "reply": if result["success"]: reply_loop_info = result["loop_info"] - reply_text_from_reply = result["reply_text"] + reply_text_from_reply = result["result"] else: logger.warning(f"{self.log_prefix} 回复动作执行失败") + self.action_planner.add_plan_excute_log(result=excute_result_str) + # 构建最终的循环信息 if reply_loop_info: # 如果有回复信息，使用回复的loop_info作为基础 @@ -405,12 +469,12 @@ class HeartFChatting: self.end_cycle(loop_info, cycle_timers) self.print_cycle_info(cycle_timers) - """S4U内容，暂时保留""" - if s4u_config.enable_s4u: - await stop_typing() - await mai_thinking_manager.get_mai_think(self.stream_id).do_think_after_response(reply_text) - """S4U内容，暂时保留""" - + end_time = time.time() + if end_time - start_time < global_config.chat.planner_smooth: + wait_time = global_config.chat.planner_smooth - (end_time - start_time) + await asyncio.sleep(wait_time) + else: + await asyncio.sleep(0.1) return True async def _main_chat_loop(self): @@ -435,7 +499,7 @@ class HeartFChatting: async def _handle_action( self, action: str, - reasoning: str, + action_reasoning: str, action_data: dict, cycle_timers: Dict[str, float], thinking_id: str, @@ -446,11 +510,11 @@ class HeartFChatting: 参数: action: 动作类型 - reasoning: 决策理由 + action_reasoning: 决策理由 action_data: 动作数据，包含不同动作需要的参数 cycle_timers: 计时器字典 thinking_id: 思考ID - + action_message: 消息数据 返回: tuple[bool, str, str]: (是否执行了动作, 思考消息ID, 命令) """ @@ -460,33 +524,101 @@ class HeartFChatting: action_handler = self.action_manager.create_action( action_name=action, action_data=action_data, - reasoning=reasoning, cycle_timers=cycle_timers, thinking_id=thinking_id, chat_stream=self.chat_stream, log_prefix=self.log_prefix, + action_reasoning=action_reasoning, action_message=action_message, ) except Exception as e: logger.error(f"{self.log_prefix} 创建动作处理器时出错: {e}") traceback.print_exc() - return False, "", "" + return False, "" - if not action_handler: - logger.warning(f"{self.log_prefix} 未能创建动作处理器: {action}") - return False, "", "" - - # 处理动作并获取结果 + # 处理动作并获取结果（固定记录一次动作信息） result = await action_handler.execute() success, action_text = result - command = "" - return success, action_text, command + + return success, action_text except Exception as e: logger.error(f"{self.log_prefix} 处理{action}时出错: {e}") traceback.print_exc() - return False, "", "" + return False, "" + + async def _lift_question_reply(self, question: str, question_context: str, thinking_id: str): + reason = f"在聊天中：\n{question_context}\n你对问题\"{question}\"感到好奇，想要和群友讨论" + new_msg = get_raw_msg_before_timestamp_with_chat( + chat_id=self.stream_id, + timestamp=time.time(), + limit=1, + ) + + reply_action_info = ActionPlannerInfo( + action_type="reply", + reasoning= "", + action_data={}, + action_message=new_msg[0], + available_actions=None, + loop_start_time=time.time(), + action_reasoning=reason) + self.action_planner.add_plan_log(reasoning=f"你对问题\"{question}\"感到好奇，想要和群友讨论", actions=[reply_action_info]) + + success, llm_response = await generator_api.rewrite_reply( + chat_stream=self.chat_stream, + reply_data={ + "raw_reply": f"我对这个问题感到好奇：{question}", + "reason": reason, + }, + ) + + if not success or not llm_response or not llm_response.reply_set: + logger.info("主动提问发言失败") + self.action_planner.add_plan_excute_log(result="主动回复生成失败") + return {"action_type": "reply", "success": False, "result": "主动回复生成失败", "loop_info": None} + + if success: + for reply_seg in llm_response.reply_set.reply_data: + send_data = reply_seg.content + await send_api.text_to_stream( + text=send_data, + stream_id=self.stream_id, + ) + + await database_api.store_action_info( + chat_stream=self.chat_stream, + action_build_into_prompt=False, + action_prompt_display=reason, + action_done=True, + thinking_id=thinking_id, + action_data={"reply_text": llm_response.reply_set.reply_data[0].content}, + action_name="reply", + ) + + # 构建循环信息 + loop_info: Dict[str, Any] = { + "loop_plan_info": { + "action_result": [reply_action_info], + }, + "loop_action_info": { + "action_taken": True, + "reply_text": llm_response.reply_set.reply_data[0].content, + "command": "", + "taken_time": time.time(), + }, + } + self.last_active_time = time.time() + self.action_planner.add_plan_excute_log(result=f"你提问：{question}") + + return { + "action_type": "reply", + "success": True, + "result": f"你提问：{question}", + "loop_info": loop_info, + } + async def _send_response( self, @@ -498,7 +630,7 @@ class HeartFChatting: chat_id=self.chat_stream.stream_id, start_time=self.last_read_time, end_time=time.time() ) - need_reply = new_message_count >= random.randint(2, 4) + need_reply = new_message_count >= random.randint(2, 3) if need_reply: logger.info(f"{self.log_prefix} 从思考到回复，共有{new_message_count}条新消息，使用引用回复") @@ -543,59 +675,83 @@ class HeartFChatting: """执行单个动作的通用函数""" try: with Timer(f"动作{action_planner_info.action_type}", cycle_timers): + # 直接当场执行no_reply逻辑 if action_planner_info.action_type == "no_reply": - # 直接处理no_action逻辑，不再通过动作系统 + # 直接处理no_reply逻辑，不再通过动作系统 reason = action_planner_info.reasoning or "选择不回复" # logger.info(f"{self.log_prefix} 选择不回复，原因: {reason}") - # 存储no_action信息到数据库 await database_api.store_action_info( chat_stream=self.chat_stream, action_build_into_prompt=False, action_prompt_display=reason, action_done=True, thinking_id=thinking_id, - action_data={"reason": reason}, - action_name="no_action", + action_data={}, + action_name="no_reply", + action_reasoning=reason, ) - return {"action_type": "no_action", "success": True, "reply_text": "", "command": ""} - elif action_planner_info.action_type == "wait_time": - action_planner_info.action_data = action_planner_info.action_data or {} - logger.info(f"{self.log_prefix} 等待{action_planner_info.action_data['time']}秒后回复") - await asyncio.sleep(action_planner_info.action_data["time"]) - return {"action_type": "wait_time", "success": True, "reply_text": "", "command": ""} + + return {"action_type": "no_reply", "success": True, "result": "选择不回复", "command": ""} elif action_planner_info.action_type == "no_reply_until_call": + # 直接当场执行no_reply_until_call逻辑 logger.info(f"{self.log_prefix} 保持沉默，直到有人直接叫的名字") + reason = action_planner_info.reasoning or "选择不回复" + self.no_reply_until_call = True - return {"action_type": "no_reply_until_call", "success": True, "reply_text": "", "command": ""} + await database_api.store_action_info( + chat_stream=self.chat_stream, + action_build_into_prompt=False, + action_prompt_display=reason, + action_done=True, + thinking_id=thinking_id, + action_data={}, + action_name="no_reply_until_call", + action_reasoning=reason, + ) + return {"action_type": "no_reply_until_call", "success": True, "result": "保持沉默，直到有人直接叫的名字", "command": ""} elif action_planner_info.action_type == "reply": - try: - success, llm_response = await generator_api.generate_reply( - chat_stream=self.chat_stream, - reply_message=action_planner_info.action_message, - available_actions=available_actions, - chosen_actions=chosen_action_plan_infos, - reply_reason=action_planner_info.reasoning or "", - enable_tool=global_config.tool.enable_tool, - request_type="replyer", - from_plugin=False, - ) + # 直接当场执行reply逻辑 + self.questioned = False + # 刷新主动发言状态 + + reason = action_planner_info.reasoning or "选择回复" + await database_api.store_action_info( + chat_stream=self.chat_stream, + action_build_into_prompt=False, + action_prompt_display=reason, + action_done=True, + thinking_id=thinking_id, + action_data={}, + action_name="reply", + action_reasoning=reason, + ) + + success, llm_response = await generator_api.generate_reply( + chat_stream=self.chat_stream, + reply_message=action_planner_info.action_message, + available_actions=available_actions, + chosen_actions=chosen_action_plan_infos, + reply_reason=reason, + enable_tool=global_config.tool.enable_tool, + request_type="replyer", + from_plugin=False, + reply_time_point = action_planner_info.action_data.get("loop_start_time", time.time()), + ) + + if not success or not llm_response or not llm_response.reply_set: + if action_planner_info.action_message: + logger.info( + f"对 {action_planner_info.action_message.processed_plain_text} 的回复生成失败" + ) + else: + logger.info("回复生成失败") + return {"action_type": "reply", "success": False, "result": "回复生成失败", "loop_info": None} - if not success or not llm_response or not llm_response.reply_set: - if action_planner_info.action_message: - logger.info( - f"对 {action_planner_info.action_message.processed_plain_text} 的回复生成失败" - ) - else: - logger.info("回复生成失败") - return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None} - except asyncio.CancelledError: - logger.debug(f"{self.log_prefix} 并行执行：回复生成任务已被取消") - return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None} response_set = llm_response.reply_set selected_expressions = llm_response.selected_expressions loop_info, reply_text, _ = await self._send_and_store_reply( @@ -606,30 +762,30 @@ class HeartFChatting: actions=chosen_action_plan_infos, selected_expressions=selected_expressions, ) + self.last_active_time = time.time() return { "action_type": "reply", "success": True, - "reply_text": reply_text, + "result": f"你回复内容{reply_text}", "loop_info": loop_info, } - - # 其他动作 else: # 执行普通动作 with Timer("动作执行", cycle_timers): - success, reply_text, command = await self._handle_action( - action_planner_info.action_type, - action_planner_info.reasoning or "", - action_planner_info.action_data or {}, - cycle_timers, - thinking_id, - action_planner_info.action_message, + success, result = await self._handle_action( + action = action_planner_info.action_type, + action_reasoning = action_planner_info.action_reasoning or "", + action_data = action_planner_info.action_data or {}, + cycle_timers = cycle_timers, + thinking_id = thinking_id, + action_message= action_planner_info.action_message, ) + + self.last_active_time = time.time() return { "action_type": action_planner_info.action_type, "success": success, - "reply_text": reply_text, - "command": command, + "result": result, } except Exception as e: @@ -638,7 +794,7 @@ class HeartFChatting: return { "action_type": action_planner_info.action_type, "success": False, - "reply_text": "", + "result": "", "loop_info": None, "error": str(e), } diff --git a/src/chat/heart_flow/heartflow_message_processor.py b/src/chat/heart_flow/heartflow_message_processor.py index b39704ba..fdc13e2f 100644 --- a/src/chat/heart_flow/heartflow_message_processor.py +++ b/src/chat/heart_flow/heartflow_message_processor.py @@ -1,17 +1,14 @@ -import asyncio import re import traceback from typing import Tuple, TYPE_CHECKING -from src.config.config import global_config from src.chat.message_receive.message import MessageRecv from src.chat.message_receive.storage import MessageStorage from src.chat.heart_flow.heartflow import heartflow from src.chat.utils.utils import is_mentioned_bot_in_message from src.chat.utils.chat_message_builder import replace_user_references from src.common.logger import get_logger -from src.mood.mood_manager import mood_manager from src.person_info.person_info import Person from src.common.database.database_model import Images @@ -75,11 +72,7 @@ class HeartFCMessageReceiver: await self.storage.store_message(message, chat) - heartflow_chat: HeartFChatting = await heartflow.get_or_create_heartflow_chat(chat.stream_id) # type: ignore - - if global_config.mood.enable_mood: - chat_mood = mood_manager.get_mood_by_chat_id(heartflow_chat.stream_id) - asyncio.create_task(chat_mood.update_mood_by_message(message)) + _heartflow_chat: HeartFChatting = await heartflow.get_or_create_heartflow_chat(chat.stream_id) # type: ignore # 3. 日志记录 mes_name = chat.group_info.group_name if chat.group_info else "私聊" @@ -107,7 +100,7 @@ class HeartFCMessageReceiver: replace_bot_name=True, ) # if not processed_plain_text: - # print(message) + # print(message) logger.info(f"[{mes_name}]{userinfo.user_nickname}:{processed_plain_text}") # type: ignore diff --git a/src/chat/memory_system/Hippocampus.py b/src/chat/memory_system/Hippocampus.py deleted file mode 100644 index 8c499843..00000000 --- a/src/chat/memory_system/Hippocampus.py +++ /dev/null @@ -1,1514 +0,0 @@ -# -*- coding: utf-8 -*- -import datetime -import math -import random -import time -import re -import jieba -import networkx as nx -import numpy as np -from typing import List, Tuple, Set, Coroutine, Any -from collections import Counter -import traceback - -from rich.traceback import install - -from src.llm_models.utils_model import LLMRequest -from src.config.config import global_config, model_config -from src.common.data_models.database_data_model import DatabaseMessages -from src.common.database.database_model import GraphNodes, GraphEdges # Peewee Models导入 -from src.common.logger import get_logger -from src.chat.utils.utils import cut_key_words -from src.chat.utils.chat_message_builder import ( - build_readable_messages, -) # 导入 build_readable_messages - - -# 添加cosine_similarity函数 -def cosine_similarity(v1, v2): - """计算余弦相似度""" - dot_product = np.dot(v1, v2) - norm1 = np.linalg.norm(v1) - norm2 = np.linalg.norm(v2) - return 0 if norm1 == 0 or norm2 == 0 else dot_product / (norm1 * norm2) - - -install(extra_lines=3) - - -def calculate_information_content(text): - """计算文本的信息量（熵）""" - char_count = Counter(text) - total_chars = len(text) - if total_chars == 0: - return 0 - entropy = 0 - for count in char_count.values(): - probability = count / total_chars - entropy -= probability * math.log2(probability) - - return entropy - - -logger = get_logger("memory") - - -class MemoryGraph: - def __init__(self): - self.G = nx.Graph() # 使用 networkx 的图结构 - - def connect_dot(self, concept1, concept2): - # 避免自连接 - if concept1 == concept2: - return - - current_time = datetime.datetime.now().timestamp() - - # 如果边已存在,增加 strength - if self.G.has_edge(concept1, concept2): - self.G[concept1][concept2]["strength"] = self.G[concept1][concept2].get("strength", 1) + 1 - # 更新最后修改时间 - self.G[concept1][concept2]["last_modified"] = current_time - else: - # 如果是新边,初始化 strength 为 1 - self.G.add_edge( - concept1, - concept2, - strength=1, - created_time=current_time, # 添加创建时间 - last_modified=current_time, - ) # 添加最后修改时间 - - async def add_dot(self, concept, memory, hippocampus_instance=None): - current_time = datetime.datetime.now().timestamp() - - if concept in self.G: - if "memory_items" in self.G.nodes[concept]: - # 获取现有的记忆项（已经是str格式） - existing_memory = self.G.nodes[concept]["memory_items"] - - # 如果现有记忆不为空，则使用LLM整合新旧记忆 - if existing_memory and hippocampus_instance and hippocampus_instance.model_small: - try: - integrated_memory = await self._integrate_memories_with_llm( - existing_memory, str(memory), hippocampus_instance.model_small - ) - self.G.nodes[concept]["memory_items"] = integrated_memory - # 整合成功，增加权重 - current_weight = self.G.nodes[concept].get("weight", 0.0) - self.G.nodes[concept]["weight"] = current_weight + 1.0 - logger.debug(f"节点 {concept} 记忆整合成功，权重增加到 {current_weight + 1.0}") - logger.info(f"节点 {concept} 记忆内容已更新：{integrated_memory}") - except Exception as e: - logger.error(f"LLM整合记忆失败: {e}") - # 降级到简单连接 - new_memory_str = f"{existing_memory} | {memory}" - self.G.nodes[concept]["memory_items"] = new_memory_str - logger.info(f"节点 {concept} 记忆内容已简单拼接并更新：{new_memory_str}") - else: - new_memory_str = str(memory) - self.G.nodes[concept]["memory_items"] = new_memory_str - logger.info(f"节点 {concept} 记忆内容已直接更新：{new_memory_str}") - else: - self.G.nodes[concept]["memory_items"] = str(memory) - # 如果节点存在但没有memory_items,说明是第一次添加memory,设置created_time - if "created_time" not in self.G.nodes[concept]: - self.G.nodes[concept]["created_time"] = current_time - logger.info(f"节点 {concept} 创建新记忆：{str(memory)}") - # 更新最后修改时间 - self.G.nodes[concept]["last_modified"] = current_time - else: - # 如果是新节点,创建新的记忆字符串 - self.G.add_node( - concept, - memory_items=str(memory), - weight=1.0, # 新节点初始权重为1.0 - created_time=current_time, # 添加创建时间 - last_modified=current_time, - ) # 添加最后修改时间 - logger.info(f"新节点 {concept} 已添加，记忆内容已写入：{str(memory)}") - - def get_dot(self, concept): - # 检查节点是否存在于图中 - return (concept, self.G.nodes[concept]) if concept in self.G else None - - def get_related_item(self, topic, depth=1): - if topic not in self.G: - return [], [] - - first_layer_items = [] - second_layer_items = [] - - # 获取相邻节点 - neighbors = list(self.G.neighbors(topic)) - - # 获取当前节点的记忆项 - node_data = self.get_dot(topic) - if node_data: - _, data = node_data - if "memory_items" in data: - # 直接使用完整的记忆内容 - if memory_items := data["memory_items"]: - first_layer_items.append(memory_items) - - # 只在depth=2时获取第二层记忆 - if depth >= 2: - # 获取相邻节点的记忆项 - for neighbor in neighbors: - if node_data := self.get_dot(neighbor): - _, data = node_data - if "memory_items" in data: - # 直接使用完整的记忆内容 - if memory_items := data["memory_items"]: - second_layer_items.append(memory_items) - - return first_layer_items, second_layer_items - - async def _integrate_memories_with_llm(self, existing_memory: str, new_memory: str, llm_model: LLMRequest) -> str: - """ - 使用LLM整合新旧记忆内容 - - Args: - existing_memory: 现有的记忆内容（字符串格式，可能包含多条记忆） - new_memory: 新的记忆内容 - llm_model: LLM模型实例 - - Returns: - str: 整合后的记忆内容 - """ - try: - # 构建整合提示 - integration_prompt = f"""你是一个记忆整合专家。请将以下的旧记忆和新记忆整合成一条更完整、更准确的记忆内容。 - -旧记忆内容： -{existing_memory} - -新记忆内容： -{new_memory} - -整合要求： -1. 保留重要信息，去除重复内容 -2. 如果新旧记忆有冲突，合理整合矛盾的地方 -3. 将相关信息合并，形成更完整的描述 -4. 保持语言简洁、准确 -5. 只返回整合后的记忆内容，不要添加任何解释 - -整合后的记忆：""" - - # 调用LLM进行整合 - content, (reasoning_content, model_name, tool_calls) = await llm_model.generate_response_async( - integration_prompt - ) - - if content and content.strip(): - integrated_content = content.strip() - logger.debug(f"LLM记忆整合成功，模型: {model_name}") - return integrated_content - else: - logger.warning("LLM返回的整合结果为空，使用默认连接方式") - return f"{existing_memory} | {new_memory}" - - except Exception as e: - logger.error(f"LLM记忆整合过程中出错: {e}") - return f"{existing_memory} | {new_memory}" - - @property - def dots(self): - # 返回所有节点对应的 Memory_dot 对象 - return [self.get_dot(node) for node in self.G.nodes()] - - def forget_topic(self, topic): - """随机删除指定话题中的一条记忆，如果话题没有记忆则移除该话题节点""" - if topic not in self.G: - return None - - # 获取话题节点数据 - node_data = self.G.nodes[topic] - - # 删除整个节点 - self.G.remove_node(topic) - # 如果节点存在memory_items - if "memory_items" in node_data: - if memory_items := node_data["memory_items"]: - return ( - f"删除了节点 {topic} 的完整记忆: {memory_items[:50]}..." - if len(memory_items) > 50 - else f"删除了节点 {topic} 的完整记忆: {memory_items}" - ) - return None - - -# 海马体 -class Hippocampus: - def __init__(self): - self.memory_graph = MemoryGraph() - self.model_small: LLMRequest = None # type: ignore - self.entorhinal_cortex: EntorhinalCortex = None # type: ignore - self.parahippocampal_gyrus: ParahippocampalGyrus = None # type: ignore - - def initialize(self): - # 初始化子组件 - self.entorhinal_cortex = EntorhinalCortex(self) - self.parahippocampal_gyrus = ParahippocampalGyrus(self) - # 从数据库加载记忆图 - self.entorhinal_cortex.sync_memory_from_db() - self.model_small = LLMRequest( - model_set=model_config.model_task_config.utils_small, request_type="memory.modify" - ) - - def get_all_node_names(self) -> list: - """获取记忆图中所有节点的名字列表""" - return list(self.memory_graph.G.nodes()) - - def calculate_weighted_activation(self, current_activation: float, edge_strength: int, target_node: str) -> float: - """ - 计算考虑节点权重的激活值 - - Args: - current_activation: 当前激活值 - edge_strength: 边的强度 - target_node: 目标节点名称 - - Returns: - float: 计算后的激活值 - """ - # 基础激活值计算 - base_activation = current_activation - (1 / edge_strength) - - if base_activation <= 0: - return 0.0 - - # 获取目标节点的权重 - if target_node in self.memory_graph.G: - node_data = self.memory_graph.G.nodes[target_node] - node_weight = node_data.get("weight", 1.0) - - # 权重加成：每次整合增加10%激活值，最大加成200% - weight_multiplier = 1.0 + min((node_weight - 1.0) * 0.1, 2.0) - - return base_activation * weight_multiplier - else: - return base_activation - - @staticmethod - def calculate_node_hash(concept, memory_items) -> int: - """计算节点的特征值""" - # memory_items已经是str格式，直接按分隔符分割 - if memory_items: - unique_items = {item.strip() for item in memory_items.split(" | ") if item.strip()} - else: - unique_items = set() - - # 使用frozenset来保证顺序一致性 - content = f"{concept}:{frozenset(unique_items)}" - return hash(content) - - @staticmethod - def calculate_edge_hash(source, target) -> int: - """计算边的特征值""" - # 直接使用元组，保证顺序一致性 - return hash((source, target)) - - @staticmethod - def find_topic_llm(text: str, topic_num: int | list[int]): - # sourcery skip: inline-immediately-returned-variable - topic_num_str = "" - if isinstance(topic_num, list): - topic_num_str = f"{topic_num[0]}-{topic_num[1]}" - else: - topic_num_str = topic_num - - prompt = ( - f"这是一段文字：\n{text}\n\n请你从这段话中总结出最多{topic_num_str}个关键的概念，必须是某种概念，比如人，事，物，概念，事件，地点 等等，帮我列出来，" - f"将主题用逗号隔开，并加上<>,例如<主题1>,<主题2>......尽可能精简。只需要列举最多{topic_num}个话题就好，不要有序号，不要告诉我其他内容。" - f"如果确定找不出主题或者没有明显主题，返回。" - ) - - return prompt - - @staticmethod - def topic_what(text, topic): - # sourcery skip: inline-immediately-returned-variable - # 不再需要 time_info 参数 - prompt = ( - f'这是一段文字：\n{text}\n\n我想让你基于这段文字来概括"{topic}"这个概念，帮我总结成几句自然的话，' - f"要求包含对这个概念的定义，内容，知识，时间和人物，这些信息必须来自这段文字，不能添加信息。\n只输出几句自然的话就好" - ) - return prompt - - @staticmethod - def calculate_topic_num(text, compress_rate): - """计算文本的话题数量""" - information_content = calculate_information_content(text) - topic_by_length = text.count("\n") * compress_rate - topic_by_information_content = max(1, min(5, int((information_content - 3) * 2))) - topic_num = int((topic_by_length + topic_by_information_content) / 2) - logger.debug( - f"topic_by_length: {topic_by_length}, topic_by_information_content: {topic_by_information_content}, " - f"topic_num: {topic_num}" - ) - return topic_num - - def get_memory_from_keyword(self, keyword: str, max_depth: int = 2) -> list: - """从关键词获取相关记忆。 - - Args: - keyword (str): 关键词 - max_depth (int, optional): 记忆检索深度，默认为2。1表示只获取直接相关的记忆，2表示获取间接相关的记忆。 - - Returns: - list: 记忆列表，每个元素是一个元组 (topic, memory_content, similarity) - - topic: str, 记忆主题 - - memory_content: str, 该主题下的完整记忆内容 - - similarity: float, 与关键词的相似度 - """ - if not keyword: - return [] - - # 获取所有节点 - all_nodes = list(self.memory_graph.G.nodes()) - memories = [] - - # 计算关键词的词集合 - keyword_words = set(jieba.cut(keyword)) - - # 遍历所有节点，计算相似度 - for node in all_nodes: - node_words = set(jieba.cut(node)) - all_words = keyword_words | node_words - v1 = [1 if word in keyword_words else 0 for word in all_words] - v2 = [1 if word in node_words else 0 for word in all_words] - similarity = cosine_similarity(v1, v2) - - # 如果相似度超过阈值，获取该节点的记忆 - if similarity >= 0.3: # 可以调整这个阈值 - node_data = self.memory_graph.G.nodes[node] - # 直接使用完整的记忆内容 - if memory_items := node_data.get("memory_items", ""): - memories.append((node, memory_items, similarity)) - - # 按相似度降序排序 - memories.sort(key=lambda x: x[2], reverse=True) - return memories - - async def get_keywords_from_text(self, text: str) -> Tuple[List[str], List]: - """从文本中提取关键词。 - - Args: - text (str): 输入文本 - fast_retrieval (bool, optional): 是否使用快速检索。默认为False。 - 如果为True，使用jieba分词提取关键词，速度更快但可能不够准确。 - 如果为False，使用LLM提取关键词，速度较慢但更准确。 - """ - if not text: - return [], [] - - # 使用LLM提取关键词 - 根据详细文本长度分布优化topic_num计算 - text_length = len(text) - topic_num: int | list[int] = 0 - - keywords_lite = cut_key_words(text) - if keywords_lite: - logger.debug(f"提取关键词极简版: {keywords_lite}") - - if text_length <= 12: - topic_num = [1, 3] # 6-10字符: 1个关键词 (27.18%的文本) - elif text_length <= 20: - topic_num = [2, 4] # 11-20字符: 2个关键词 (22.76%的文本) - elif text_length <= 30: - topic_num = [3, 5] # 21-30字符: 3个关键词 (10.33%的文本) - elif text_length <= 50: - topic_num = [4, 5] # 31-50字符: 4个关键词 (9.79%的文本) - else: - topic_num = 5 # 51+字符: 5个关键词 (其余长文本) - - topics_response, _ = await self.model_small.generate_response_async(self.find_topic_llm(text, topic_num)) - - # 提取关键词 - keywords = re.findall(r"<([^>]+)>", topics_response) - if not keywords: - keywords = [] - else: - keywords = [ - keyword.strip() - for keyword in ",".join(keywords).replace("，", ",").replace("、", ",").replace(" ", ",").split(",") - if keyword.strip() - ] - - if keywords: - logger.debug(f"提取关键词: {keywords}") - - return keywords, keywords_lite - - async def get_memory_from_topic( - self, - keywords: list[str], - max_memory_num: int = 3, - max_memory_length: int = 2, - max_depth: int = 3, - ) -> list: - """从文本中提取关键词并获取相关记忆。 - - Args: - keywords (list): 输入文本 - max_memory_num (int, optional): 返回的记忆条目数量上限。默认为3，表示最多返回3条与输入文本相关度最高的记忆。 - max_memory_length (int, optional): 每个主题最多返回的记忆条目数量。默认为2，表示每个主题最多返回2条相似度最高的记忆。 - max_depth (int, optional): 记忆检索深度。默认为3。值越大，检索范围越广，可以获取更多间接相关的记忆，但速度会变慢。 - - Returns: - list: 记忆列表，每个元素是一个元组 (topic, memory_content) - - topic: str, 记忆主题 - - memory_content: str, 该主题下的完整记忆内容 - """ - if not keywords: - return [] - - logger.info(f"提取的关键词: {', '.join(keywords)}") - - # 过滤掉不存在于记忆图中的关键词 - valid_keywords = [keyword for keyword in keywords if keyword in self.memory_graph.G] - if not valid_keywords: - logger.debug("没有找到有效的关键词节点") - return [] - - logger.debug(f"有效的关键词: {', '.join(valid_keywords)}") - - # 从每个关键词获取记忆 - activate_map = {} # 存储每个词的累计激活值 - - # 对每个关键词进行扩散式检索 - for keyword in valid_keywords: - logger.debug(f"开始以关键词 '{keyword}' 为中心进行扩散检索 (最大深度: {max_depth}):") - # 初始化激活值 - activation_values = {keyword: 1.0} - # 记录已访问的节点 - visited_nodes = {keyword} - # 待处理的节点队列，每个元素是(节点, 激活值, 当前深度) - nodes_to_process = [(keyword, 1.0, 0)] - - while nodes_to_process: - current_node, current_activation, current_depth = nodes_to_process.pop(0) - - # 如果激活值小于0或超过最大深度，停止扩散 - if current_activation <= 0 or current_depth >= max_depth: - continue - - # 获取当前节点的所有邻居 - neighbors = list(self.memory_graph.G.neighbors(current_node)) - - for neighbor in neighbors: - if neighbor in visited_nodes: - continue - - # 获取连接强度 - edge_data = self.memory_graph.G[current_node][neighbor] - strength = edge_data.get("strength", 1) - - # 计算新的激活值 - new_activation = current_activation - (1 / strength) - - if new_activation > 0: - activation_values[neighbor] = new_activation - visited_nodes.add(neighbor) - nodes_to_process.append((neighbor, new_activation, current_depth + 1)) - # logger.debug( - # f"节点 '{neighbor}' 被激活，激活值: {new_activation:.2f} (通过 '{current_node}' 连接，强度: {strength}, 深度: {current_depth + 1})" - # ) # noqa: E501 - - # 更新激活映射 - for node, activation_value in activation_values.items(): - if activation_value > 0: - if node in activate_map: - activate_map[node] += activation_value - else: - activate_map[node] = activation_value - - # 基于激活值平方的独立概率选择 - remember_map = {} - # logger.info("基于激活值平方的归一化选择:") - - # 计算所有激活值的平方和 - total_squared_activation = sum(activation**2 for activation in activate_map.values()) - if total_squared_activation > 0: - # 计算归一化的激活值 - normalized_activations = { - node: (activation**2) / total_squared_activation for node, activation in activate_map.items() - } - - # 按归一化激活值排序并选择前max_memory_num个 - sorted_nodes = sorted(normalized_activations.items(), key=lambda x: x[1], reverse=True)[:max_memory_num] - - # 将选中的节点添加到remember_map - for node, normalized_activation in sorted_nodes: - remember_map[node] = activate_map[node] # 使用原始激活值 - logger.debug( - f"节点 '{node}' (归一化激活值: {normalized_activation:.2f}, 激活值: {activate_map[node]:.2f})" - ) - else: - logger.info("没有有效的激活值") - - # 从选中的节点中提取记忆 - all_memories = [] - # logger.info("开始从选中的节点中提取记忆:") - for node, activation in remember_map.items(): - logger.debug(f"处理节点 '{node}' (激活值: {activation:.2f}):") - node_data = self.memory_graph.G.nodes[node] - if memory_items := node_data.get("memory_items", ""): - logger.debug("节点包含完整记忆") - # 计算记忆与关键词的相似度 - memory_words = set(jieba.cut(memory_items)) - text_words = set(keywords) - if all_words := memory_words | text_words: - # 计算相似度（虽然这里没有使用，但保持逻辑一致性） - v1 = [1 if word in memory_words else 0 for word in all_words] - v2 = [1 if word in text_words else 0 for word in all_words] - _ = cosine_similarity(v1, v2) # 计算但不使用，用_表示 - - # 添加完整记忆到结果中 - all_memories.append((node, memory_items, activation)) - else: - logger.info("节点没有记忆") - - # 去重（基于记忆内容） - logger.debug("开始记忆去重:") - seen_memories = set() - unique_memories = [] - for topic, memory_items, activation_value in all_memories: - # memory_items现在是完整的字符串格式 - memory = memory_items or "" - if memory not in seen_memories: - seen_memories.add(memory) - unique_memories.append((topic, memory_items, activation_value)) - logger.debug(f"保留记忆: {memory} (来自节点: {topic}, 激活值: {activation_value:.2f})") - else: - logger.debug(f"跳过重复记忆: {memory} (来自节点: {topic})") - - # 转换为(关键词, 记忆)格式 - result = [] - for topic, memory_items, _ in unique_memories: - # memory_items现在是完整的字符串格式 - memory = memory_items or "" - result.append((topic, memory)) - logger.debug(f"选中记忆: {memory} (来自节点: {topic})") - - return result - - async def get_activate_from_text( - self, text: str, max_depth: int = 3, fast_retrieval: bool = False - ) -> tuple[float, list[str], list[str]]: - """从文本中提取关键词并获取相关记忆。 - - Args: - text (str): 输入文本 - max_depth (int, optional): 记忆检索深度。默认为2。 - fast_retrieval (bool, optional): 是否使用快速检索。默认为False。 - 如果为True，使用jieba分词和TF-IDF提取关键词，速度更快但可能不够准确。 - 如果为False，使用LLM提取关键词，速度较慢但更准确。 - - Returns: - float: 激活节点数与总节点数的比值 - list[str]: 有效的关键词 - """ - keywords, keywords_lite = await self.get_keywords_from_text(text) - - # 过滤掉不存在于记忆图中的关键词 - valid_keywords = [keyword for keyword in keywords if keyword in self.memory_graph.G] - if not valid_keywords: - # logger.info("没有找到有效的关键词节点") - return 0, keywords, keywords_lite - - logger.debug(f"有效的关键词: {', '.join(valid_keywords)}") - - # 从每个关键词获取记忆 - activate_map = {} # 存储每个词的累计激活值 - - # 对每个关键词进行扩散式检索 - for keyword in valid_keywords: - logger.debug(f"开始以关键词 '{keyword}' 为中心进行扩散检索 (最大深度: {max_depth}):") - # 初始化激活值 - activation_values = {keyword: 1.5} - # 记录已访问的节点 - visited_nodes = {keyword} - # 待处理的节点队列，每个元素是(节点, 激活值, 当前深度) - nodes_to_process = [(keyword, 1.0, 0)] - - while nodes_to_process: - current_node, current_activation, current_depth = nodes_to_process.pop(0) - - # 如果激活值小于0或超过最大深度，停止扩散 - if current_activation <= 0 or current_depth >= max_depth: - continue - - # 获取当前节点的所有邻居 - neighbors = list(self.memory_graph.G.neighbors(current_node)) - - for neighbor in neighbors: - if neighbor in visited_nodes: - continue - - # 获取连接强度 - edge_data = self.memory_graph.G[current_node][neighbor] - strength = edge_data.get("strength", 1) - - # 计算新的激活值 - new_activation = current_activation - (1 / strength) - - if new_activation > 0: - activation_values[neighbor] = new_activation - visited_nodes.add(neighbor) - nodes_to_process.append((neighbor, new_activation, current_depth + 1)) - # logger.debug( - # f"节点 '{neighbor}' 被激活，激活值: {new_activation:.2f} (通过 '{current_node}' 连接，强度: {strength}, 深度: {current_depth + 1})") # noqa: E501 - - # 更新激活映射 - for node, activation_value in activation_values.items(): - if activation_value > 0: - if node in activate_map: - activate_map[node] += activation_value - else: - activate_map[node] = activation_value - - # 输出激活映射 - # logger.info("激活映射统计:") - # for node, total_activation in sorted(activate_map.items(), key=lambda x: x[1], reverse=True): - # logger.info(f"节点 '{node}': 累计激活值 = {total_activation:.2f}") - - # 计算激活节点数与总节点数的比值 - total_activation = sum(activate_map.values()) - # logger.debug(f"总激活值: {total_activation:.2f}") - total_nodes = len(self.memory_graph.G.nodes()) - # activated_nodes = len(activate_map) - activation_ratio = total_activation / total_nodes if total_nodes > 0 else 0 - activation_ratio = activation_ratio * 50 - logger.debug(f"总激活值: {total_activation:.2f}, 总节点数: {total_nodes}, 激活: {activation_ratio}") - - return activation_ratio, keywords, keywords_lite - - -# 负责海马体与其他部分的交互 -class EntorhinalCortex: - def __init__(self, hippocampus: Hippocampus): - self.hippocampus = hippocampus - self.memory_graph = hippocampus.memory_graph - - async def sync_memory_to_db(self): - """将记忆图同步到数据库""" - start_time = time.time() - current_time = datetime.datetime.now().timestamp() - - # 获取数据库中所有节点和内存中所有节点 - db_nodes = {node.concept: node for node in GraphNodes.select()} - memory_nodes = list(self.memory_graph.G.nodes(data=True)) - - # 批量准备节点数据 - nodes_to_create = [] - nodes_to_update = [] - nodes_to_delete = set() - - # 处理节点 - for concept, data in memory_nodes: - if not concept or not isinstance(concept, str): - self.memory_graph.G.remove_node(concept) - continue - - memory_items = data.get("memory_items", "") - - # 直接检查字符串是否为空，不需要分割成列表 - if not memory_items or memory_items.strip() == "": - self.memory_graph.G.remove_node(concept) - continue - - # 计算内存中节点的特征值 - memory_hash = self.hippocampus.calculate_node_hash(concept, memory_items) - created_time = data.get("created_time", current_time) - last_modified = data.get("last_modified", current_time) - - # memory_items直接作为字符串存储，不需要JSON序列化 - if not memory_items: - continue - - # 获取权重属性 - weight = data.get("weight", 1.0) - - if concept not in db_nodes: - nodes_to_create.append( - { - "concept": concept, - "memory_items": memory_items, - "weight": weight, - "hash": memory_hash, - "created_time": created_time, - "last_modified": last_modified, - } - ) - else: - db_node = db_nodes[concept] - if db_node.hash != memory_hash: - nodes_to_update.append( - { - "concept": concept, - "memory_items": memory_items, - "weight": weight, - "hash": memory_hash, - "last_modified": last_modified, - } - ) - - # 计算需要删除的节点 - memory_concepts = {concept for concept, _ in memory_nodes} - nodes_to_delete = set(db_nodes.keys()) - memory_concepts - - # 批量处理节点 - if nodes_to_create: - batch_size = 100 - for i in range(0, len(nodes_to_create), batch_size): - batch = nodes_to_create[i : i + batch_size] - GraphNodes.insert_many(batch).execute() - - if nodes_to_update: - batch_size = 100 - for i in range(0, len(nodes_to_update), batch_size): - batch = nodes_to_update[i : i + batch_size] - for node_data in batch: - GraphNodes.update(**{k: v for k, v in node_data.items() if k != "concept"}).where( - GraphNodes.concept == node_data["concept"] - ).execute() - - if nodes_to_delete: - GraphNodes.delete().where(GraphNodes.concept.in_(nodes_to_delete)).execute() # type: ignore - - # 处理边的信息 - db_edges = list(GraphEdges.select()) - memory_edges = list(self.memory_graph.G.edges(data=True)) - - # 创建边的哈希值字典 - db_edge_dict = {} - for edge in db_edges: - edge_hash = self.hippocampus.calculate_edge_hash(edge.source, edge.target) - db_edge_dict[(edge.source, edge.target)] = {"hash": edge_hash, "strength": edge.strength} - - # 批量准备边数据 - edges_to_create = [] - edges_to_update = [] - - # 处理边 - for source, target, data in memory_edges: - edge_hash = self.hippocampus.calculate_edge_hash(source, target) - edge_key = (source, target) - strength = data.get("strength", 1) - created_time = data.get("created_time", current_time) - last_modified = data.get("last_modified", current_time) - - if edge_key not in db_edge_dict: - edges_to_create.append( - { - "source": source, - "target": target, - "strength": strength, - "hash": edge_hash, - "created_time": created_time, - "last_modified": last_modified, - } - ) - elif db_edge_dict[edge_key]["hash"] != edge_hash: - edges_to_update.append( - { - "source": source, - "target": target, - "strength": strength, - "hash": edge_hash, - "last_modified": last_modified, - } - ) - - # 计算需要删除的边 - memory_edge_keys = {(source, target) for source, target, _ in memory_edges} - edges_to_delete = set(db_edge_dict.keys()) - memory_edge_keys - - # 批量处理边 - if edges_to_create: - batch_size = 100 - for i in range(0, len(edges_to_create), batch_size): - batch = edges_to_create[i : i + batch_size] - GraphEdges.insert_many(batch).execute() - - if edges_to_update: - batch_size = 100 - for i in range(0, len(edges_to_update), batch_size): - batch = edges_to_update[i : i + batch_size] - for edge_data in batch: - GraphEdges.update(**{k: v for k, v in edge_data.items() if k not in ["source", "target"]}).where( - (GraphEdges.source == edge_data["source"]) & (GraphEdges.target == edge_data["target"]) - ).execute() - - if edges_to_delete: - for source, target in edges_to_delete: - GraphEdges.delete().where((GraphEdges.source == source) & (GraphEdges.target == target)).execute() - - end_time = time.time() - logger.info(f"[数据库] 同步完成，总耗时: {end_time - start_time:.2f}秒") - logger.info( - f"[数据库] 同步了 {len(nodes_to_create) + len(nodes_to_update)} 个节点和 {len(edges_to_create) + len(edges_to_update)} 条边" - ) - - async def resync_memory_to_db(self): - """清空数据库并重新同步所有记忆数据""" - start_time = time.time() - logger.info("[数据库] 开始重新同步所有记忆数据...") - - # 清空数据库 - clear_start = time.time() - GraphNodes.delete().execute() - GraphEdges.delete().execute() - clear_end = time.time() - logger.info(f"[数据库] 清空数据库耗时: {clear_end - clear_start:.2f}秒") - - # 获取所有节点和边 - memory_nodes = list(self.memory_graph.G.nodes(data=True)) - memory_edges = list(self.memory_graph.G.edges(data=True)) - current_time = datetime.datetime.now().timestamp() - - # 批量准备节点数据 - nodes_data = [] - for concept, data in memory_nodes: - memory_items = data.get("memory_items", "") - - # 直接检查字符串是否为空，不需要分割成列表 - if not memory_items or memory_items.strip() == "": - self.memory_graph.G.remove_node(concept) - continue - - # 计算内存中节点的特征值 - memory_hash = self.hippocampus.calculate_node_hash(concept, memory_items) - created_time = data.get("created_time", current_time) - last_modified = data.get("last_modified", current_time) - - # memory_items直接作为字符串存储，不需要JSON序列化 - if not memory_items: - continue - - # 获取权重属性 - weight = data.get("weight", 1.0) - - nodes_data.append( - { - "concept": concept, - "memory_items": memory_items, - "weight": weight, - "hash": memory_hash, - "created_time": created_time, - "last_modified": last_modified, - } - ) - - # 批量插入节点 - if nodes_data: - batch_size = 100 - for i in range(0, len(nodes_data), batch_size): - batch = nodes_data[i : i + batch_size] - GraphNodes.insert_many(batch).execute() - - # 批量准备边数据 - edges_data = [] - for source, target, data in memory_edges: - try: - edges_data.append( - { - "source": source, - "target": target, - "strength": data.get("strength", 1), - "hash": self.hippocampus.calculate_edge_hash(source, target), - "created_time": data.get("created_time", current_time), - "last_modified": data.get("last_modified", current_time), - } - ) - except Exception as e: - logger.error(f"准备边 {source}-{target} 数据时发生错误: {e}") - continue - - # 批量插入边 - if edges_data: - batch_size = 100 - for i in range(0, len(edges_data), batch_size): - batch = edges_data[i : i + batch_size] - GraphEdges.insert_many(batch).execute() - - end_time = time.time() - logger.info(f"[数据库] 重新同步完成，总耗时: {end_time - start_time:.2f}秒") - logger.info(f"[数据库] 同步了 {len(nodes_data)} 个节点和 {len(edges_data)} 条边") - - def sync_memory_from_db(self): - """从数据库同步数据到内存中的图结构""" - current_time = datetime.datetime.now().timestamp() - need_update = False - - # 清空当前图 - self.memory_graph.G.clear() - - # 统计加载情况 - total_nodes = 0 - loaded_nodes = 0 - skipped_nodes = 0 - - # 从数据库加载所有节点 - nodes = list(GraphNodes.select()) - total_nodes = len(nodes) - - for node in nodes: - concept = node.concept - try: - # 处理空字符串或None的情况 - if not node.memory_items or node.memory_items.strip() == "": - logger.warning(f"节点 {concept} 的memory_items为空，跳过") - skipped_nodes += 1 - continue - - # 直接使用memory_items - memory_items = node.memory_items.strip() - - # 检查时间字段是否存在 - if not node.created_time or not node.last_modified: - # 更新数据库中的节点 - update_data = {} - if not node.created_time: - update_data["created_time"] = current_time - if not node.last_modified: - update_data["last_modified"] = current_time - - if update_data: - GraphNodes.update(**update_data).where(GraphNodes.concept == concept).execute() - - # 获取时间信息(如果不存在则使用当前时间) - created_time = node.created_time or current_time - last_modified = node.last_modified or current_time - - # 获取权重属性 - weight = node.weight if hasattr(node, "weight") and node.weight is not None else 1.0 - - # 添加节点到图中 - self.memory_graph.G.add_node( - concept, - memory_items=memory_items, - weight=weight, - created_time=created_time, - last_modified=last_modified, - ) - loaded_nodes += 1 - except Exception as e: - logger.error(f"加载节点 {concept} 时发生错误: {e}") - skipped_nodes += 1 - continue - - # 从数据库加载所有边 - edges = list(GraphEdges.select()) - for edge in edges: - source = edge.source - target = edge.target - strength = edge.strength - - # 检查时间字段是否存在 - if not edge.created_time or not edge.last_modified: - need_update = True - # 更新数据库中的边 - update_data = {} - if not edge.created_time: - update_data["created_time"] = current_time - if not edge.last_modified: - update_data["last_modified"] = current_time - - GraphEdges.update(**update_data).where( - (GraphEdges.source == source) & (GraphEdges.target == target) - ).execute() - - # 获取时间信息(如果不存在则使用当前时间) - created_time = edge.created_time or current_time - last_modified = edge.last_modified or current_time - - # 只有当源节点和目标节点都存在时才添加边 - if source in self.memory_graph.G and target in self.memory_graph.G: - self.memory_graph.G.add_edge( - source, target, strength=strength, created_time=created_time, last_modified=last_modified - ) - - if need_update: - logger.info("[数据库] 已为缺失的时间字段进行补充") - - # 输出加载统计信息 - logger.info( - f"[数据库] 记忆加载完成: 总计 {total_nodes} 个节点, 成功加载 {loaded_nodes} 个, 跳过 {skipped_nodes} 个" - ) - - -# 负责整合，遗忘，合并记忆 -class ParahippocampalGyrus: - def __init__(self, hippocampus: Hippocampus): - self.hippocampus = hippocampus - self.memory_graph = hippocampus.memory_graph - - self.memory_modify_model = LLMRequest( - model_set=model_config.model_task_config.utils, request_type="memory.modify" - ) - - async def memory_compress(self, messages: list[DatabaseMessages], compress_rate=0.1): - """压缩和总结消息内容，生成记忆主题和摘要。 - - Args: - messages (list): 消息列表，每个消息是一个字典，包含数据库消息结构。 - compress_rate (float, optional): 压缩率，用于控制生成的主题数量。默认为0.1。 - - Returns: - tuple: (compressed_memory, similar_topics_dict) - - compressed_memory: set, 压缩后的记忆集合，每个元素是一个元组 (topic, summary) - - similar_topics_dict: dict, 相似主题字典 - - Process: - 1. 使用 build_readable_messages 生成包含时间、人物信息的格式化文本。 - 2. 使用LLM提取关键主题。 - 3. 过滤掉包含禁用关键词的主题。 - 4. 为每个主题生成摘要。 - 5. 查找与现有记忆中的相似主题。 - """ - if not messages: - return set(), {} - - # 1. 使用 build_readable_messages 生成格式化文本 - # build_readable_messages 只返回一个字符串，不需要解包 - input_text = build_readable_messages( - messages, - timestamp_mode="normal_no_YMD", # 使用 'YYYY-MM-DD HH:MM:SS' 格式 - replace_bot_name=False, # 保留原始用户名 - ) - - # 如果生成的可读文本为空（例如所有消息都无效），则直接返回 - if not input_text: - logger.warning("无法从提供的消息生成可读文本，跳过记忆压缩。") - return set(), {} - - current_date = f"当前日期: {datetime.datetime.now().isoformat()}" - input_text = f"{current_date}\n{input_text}" - - logger.debug(f"记忆来源:\n{input_text}") - - # 2. 使用LLM提取关键主题 - topic_num = self.hippocampus.calculate_topic_num(input_text, compress_rate) - topics_response, _ = await self.memory_modify_model.generate_response_async( - self.hippocampus.find_topic_llm(input_text, topic_num) - ) - - # 提取<>中的内容 - topics = re.findall(r"<([^>]+)>", topics_response) - - if not topics: - topics = ["none"] - else: - topics = [ - topic.strip() - for topic in ",".join(topics).replace("，", ",").replace("、", ",").replace(" ", ",").split(",") - if topic.strip() - ] - - # 3. 过滤掉包含禁用关键词的topic - filtered_topics = [ - topic for topic in topics if all(keyword not in topic for keyword in global_config.memory.memory_ban_words) - ] - - logger.debug(f"过滤后话题: {filtered_topics}") - - # 4. 创建所有话题的摘要生成任务 - tasks: List[Tuple[str, Coroutine[Any, Any, Tuple[str, Tuple[str, str, List | None]]]]] = [] - topic_what_prompt: str = "" - for topic in filtered_topics: - # 调用修改后的 topic_what，不再需要 time_info - topic_what_prompt = self.hippocampus.topic_what(input_text, topic) - try: - task = self.memory_modify_model.generate_response_async(topic_what_prompt) - tasks.append((topic.strip(), task)) - except Exception as e: - logger.error(f"生成话题 '{topic}' 的摘要时发生错误: {e}") - continue - - # 等待所有任务完成 - compressed_memory: Set[Tuple[str, str]] = set() - similar_topics_dict = {} - - for topic, task in tasks: - response = await task - if response: - compressed_memory.add((topic, response[0])) - - existing_topics = list(self.memory_graph.G.nodes()) - similar_topics = [] - - for existing_topic in existing_topics: - topic_words = set(jieba.cut(topic)) - existing_words = set(jieba.cut(existing_topic)) - - all_words = topic_words | existing_words - v1 = [1 if word in topic_words else 0 for word in all_words] - v2 = [1 if word in existing_words else 0 for word in all_words] - - similarity = cosine_similarity(v1, v2) - - if similarity >= 0.7: - similar_topics.append((existing_topic, similarity)) - - similar_topics.sort(key=lambda x: x[1], reverse=True) - similar_topics = similar_topics[:3] - similar_topics_dict[topic] = similar_topics - - if global_config.debug.show_prompt: - logger.info(f"prompt: {topic_what_prompt}") - logger.info(f"压缩后的记忆: {compressed_memory}") - logger.info(f"相似主题: {similar_topics_dict}") - - return compressed_memory, similar_topics_dict - - def get_similar_topics_from_keywords( - self, - keywords: list[str] | str, - top_k: int = 3, - threshold: float = 0.7, - ) -> dict[str, list[tuple[str, float]]]: - """基于输入的关键词，返回每个关键词对应的相似主题列表。 - - Args: - keywords: 关键词列表或以逗号/空格/顿号分隔的字符串。 - top_k: 每个关键词返回的相似主题数量上限。 - threshold: 相似度阈值，低于该值的主题将被过滤。 - - Returns: - dict[str, list[tuple[str, float]]]: {keyword: [(topic, similarity), ...]} - """ - # 规范化输入为列表[str] - if isinstance(keywords, str): - # 支持中英文逗号、顿号、空格分隔 - parts = keywords.replace("，", ",").replace("、", ",").replace(" ", ",").strip(", ") - keyword_list = [p.strip() for p in parts.split(",") if p.strip()] - else: - keyword_list = [k.strip() for k in keywords if isinstance(k, str) and k.strip()] - - if not keyword_list: - return {} - - existing_topics = list(self.memory_graph.G.nodes()) - result: dict[str, list[tuple[str, float]]] = {} - - for kw in keyword_list: - kw_words = set(jieba.cut(kw)) - similar_topics: list[tuple[str, float]] = [] - - for topic in existing_topics: - topic_words = set(jieba.cut(topic)) - all_words = kw_words | topic_words - if not all_words: - continue - v1 = [1 if w in kw_words else 0 for w in all_words] - v2 = [1 if w in topic_words else 0 for w in all_words] - sim = cosine_similarity(v1, v2) - if sim >= threshold: - similar_topics.append((topic, sim)) - - similar_topics.sort(key=lambda x: x[1], reverse=True) - result[kw] = similar_topics[:top_k] - - return result - - async def add_memory_with_similar( - self, - memory_item: str, - similar_topics_dict: dict[str, list[tuple[str, float]]], - ) -> bool: - """将单条记忆内容与相似主题写入记忆网络并同步数据库。 - - 按 build_memory_for_chat 的方式：为 similar_topics_dict 的每个键作为主题添加节点内容， - 并与其相似主题建立连接，连接强度为 int(similarity * 10)。 - - Args: - memory_item: 记忆内容字符串，将作为每个主题节点的 memory_items。 - similar_topics_dict: {topic: [(similar_topic, similarity), ...]} - - Returns: - bool: 是否成功执行添加与同步。 - """ - try: - if not memory_item or not isinstance(memory_item, str): - return False - - if not similar_topics_dict or not isinstance(similar_topics_dict, dict): - return False - - current_time = time.time() - - # 为每个主题写入节点 - for topic, similar_list in similar_topics_dict.items(): - if not topic or not isinstance(topic, str): - continue - - await self.hippocampus.memory_graph.add_dot(topic, memory_item, self.hippocampus) - - # 连接相似主题 - if isinstance(similar_list, list): - for item in similar_list: - try: - similar_topic, similarity = item - except Exception: - continue - if not isinstance(similar_topic, str): - continue - if topic == similar_topic: - continue - # 强度按 build_memory_for_chat 的规则 - strength = int(max(0.0, float(similarity)) * 10) if similarity is not None else 0 - if strength <= 0: - continue - # 确保相似主题节点存在（如果没有，也可以只建立边，networkx会创建节点，但需初始化属性） - if similar_topic not in self.memory_graph.G: - # 创建一个空的相似主题节点，避免悬空边，memory_items 为空字符串 - self.memory_graph.G.add_node( - similar_topic, - memory_items="", - weight=1.0, - created_time=current_time, - last_modified=current_time, - ) - self.memory_graph.G.add_edge( - topic, - similar_topic, - strength=strength, - created_time=current_time, - last_modified=current_time, - ) - - # 同步数据库 - await self.hippocampus.entorhinal_cortex.sync_memory_to_db() - return True - except Exception as e: - logger.error(f"添加记忆节点失败: {e}") - return False - - async def operation_forget_topic(self, percentage=0.005): - start_time = time.time() - logger.info("[遗忘] 开始检查数据库...") - - # 验证百分比参数 - if not 0 <= percentage <= 1: - logger.warning(f"[遗忘] 无效的遗忘百分比: {percentage}, 使用默认值 0.005") - percentage = 0.005 - - all_nodes = list(self.memory_graph.G.nodes()) - all_edges = list(self.memory_graph.G.edges()) - - if not all_nodes and not all_edges: - logger.info("[遗忘] 记忆图为空,无需进行遗忘操作") - return - - # 确保至少检查1个节点和边，且不超过总数 - check_nodes_count = max(1, min(len(all_nodes), int(len(all_nodes) * percentage))) - check_edges_count = max(1, min(len(all_edges), int(len(all_edges) * percentage))) - - # 只有在有足够的节点和边时才进行采样 - if len(all_nodes) >= check_nodes_count and len(all_edges) >= check_edges_count: - try: - nodes_to_check = random.sample(all_nodes, check_nodes_count) - edges_to_check = random.sample(all_edges, check_edges_count) - except ValueError as e: - logger.error(f"[遗忘] 采样错误: {str(e)}") - return - else: - logger.info("[遗忘] 没有足够的节点或边进行遗忘操作") - return - - # 使用列表存储变化信息 - edge_changes = { - "weakened": [], # 存储减弱的边 - "removed": [], # 存储移除的边 - } - node_changes = { - "reduced": [], # 存储减少记忆的节点 - "removed": [], # 存储移除的节点 - } - - current_time = datetime.datetime.now().timestamp() - - logger.info("[遗忘] 开始检查连接...") - edge_check_start = time.time() - for source, target in edges_to_check: - edge_data = self.memory_graph.G[source][target] - last_modified = edge_data.get("last_modified") - - if current_time - last_modified > 3600 * global_config.memory.memory_forget_time: - current_strength = edge_data.get("strength", 1) - new_strength = current_strength - 1 - - if new_strength <= 0: - self.memory_graph.G.remove_edge(source, target) - edge_changes["removed"].append(f"{source} -> {target}") - else: - edge_data["strength"] = new_strength - edge_data["last_modified"] = current_time - edge_changes["weakened"].append(f"{source}-{target} (强度: {current_strength} -> {new_strength})") - edge_check_end = time.time() - logger.info(f"[遗忘] 连接检查耗时: {edge_check_end - edge_check_start:.2f}秒") - - logger.info("[遗忘] 开始检查节点...") - node_check_start = time.time() - for node in nodes_to_check: - # 检查节点是否存在，以防在迭代中被移除（例如边移除导致） - if node not in self.memory_graph.G: - continue - - node_data = self.memory_graph.G.nodes[node] - - # 首先获取记忆项 - memory_items = node_data.get("memory_items", "") - # 直接检查记忆内容是否为空 - if not memory_items or memory_items.strip() == "": - try: - self.memory_graph.G.remove_node(node) - node_changes["removed"].append(f"{node}(空节点)") # 标记为空节点移除 - logger.debug(f"[遗忘] 移除了空的节点: {node}") - except nx.NetworkXError as e: - logger.warning(f"[遗忘] 移除空节点 {node} 时发生错误（可能已被移除）: {e}") - continue # 处理下一个节点 - - # --- 如果节点不为空，则执行原来的不活跃检查和随机移除逻辑 --- - last_modified = node_data.get("last_modified", current_time) - node_weight = node_data.get("weight", 1.0) - - # 条件1：检查是否长时间未修改 (使用配置的遗忘时间) - time_threshold = 3600 * global_config.memory.memory_forget_time - - # 基于权重调整遗忘阈值：权重越高，需要更长时间才能被遗忘 - # 权重为1时使用默认阈值，权重越高阈值越大（越难遗忘） - adjusted_threshold = time_threshold * node_weight - - if current_time - last_modified > adjusted_threshold and memory_items: - # 既然每个节点现在是完整记忆，直接删除整个节点 - try: - self.memory_graph.G.remove_node(node) - node_changes["removed"].append(f"{node}(长时间未修改,权重{node_weight:.1f})") - logger.debug(f"[遗忘] 移除了长时间未修改的节点: {node} (权重: {node_weight:.1f})") - except nx.NetworkXError as e: - logger.warning(f"[遗忘] 移除节点 {node} 时发生错误（可能已被移除）: {e}") - continue - node_check_end = time.time() - logger.info(f"[遗忘] 节点检查耗时: {node_check_end - node_check_start:.2f}秒") - - if any(edge_changes.values()) or any(node_changes.values()): - sync_start = time.time() - - await self.hippocampus.entorhinal_cortex.resync_memory_to_db() - - sync_end = time.time() - logger.info(f"[遗忘] 数据库同步耗时: {sync_end - sync_start:.2f}秒") - - # 汇总输出所有变化 - logger.info("[遗忘] 遗忘操作统计:") - if edge_changes["weakened"]: - logger.info( - f"[遗忘] 减弱的连接 ({len(edge_changes['weakened'])}个): {', '.join(edge_changes['weakened'])}" - ) - - if edge_changes["removed"]: - logger.info( - f"[遗忘] 移除的连接 ({len(edge_changes['removed'])}个): {', '.join(edge_changes['removed'])}" - ) - - if node_changes["reduced"]: - logger.info( - f"[遗忘] 减少记忆的节点 ({len(node_changes['reduced'])}个): {', '.join(node_changes['reduced'])}" - ) - - if node_changes["removed"]: - logger.info( - f"[遗忘] 移除的节点 ({len(node_changes['removed'])}个): {', '.join(node_changes['removed'])}" - ) - else: - logger.info("[遗忘] 本次检查没有节点或连接满足遗忘条件") - - end_time = time.time() - logger.info(f"[遗忘] 总耗时: {end_time - start_time:.2f}秒") - - -class HippocampusManager: - def __init__(self): - self._hippocampus: Hippocampus = None # type: ignore - self._initialized = False - - def initialize(self): - """初始化海马体实例""" - if self._initialized: - return self._hippocampus - - self._hippocampus = Hippocampus() - self._hippocampus.initialize() - self._initialized = True - - # 输出记忆图统计信息 - memory_graph = self._hippocampus.memory_graph.G - node_count = len(memory_graph.nodes()) - edge_count = len(memory_graph.edges()) - - logger.info(f""" - -------------------------------- - 记忆系统参数配置: - 遗忘间隔: {global_config.memory.forget_memory_interval}秒|遗忘比例: {global_config.memory.memory_forget_percentage}|遗忘: {global_config.memory.memory_forget_time}小时之后 - 记忆图统计信息: 节点数量: {node_count}, 连接数量: {edge_count} - --------------------------------""") # noqa: E501 - - return self._hippocampus - - def get_hippocampus(self): - if not self._initialized: - raise RuntimeError("HippocampusManager 尚未初始化，请先调用 initialize 方法") - return self._hippocampus - - async def forget_memory(self, percentage: float = 0.005): - """遗忘记忆的公共接口""" - if not self._initialized: - raise RuntimeError("HippocampusManager 尚未初始化，请先调用 initialize 方法") - return await self._hippocampus.parahippocampal_gyrus.operation_forget_topic(percentage) - - async def get_memory_from_topic( - self, valid_keywords: list[str], max_memory_num: int = 3, max_memory_length: int = 2, max_depth: int = 3 - ) -> list: - """从文本中获取相关记忆的公共接口""" - if not self._initialized: - raise RuntimeError("HippocampusManager 尚未初始化，请先调用 initialize 方法") - try: - response = await self._hippocampus.get_memory_from_topic( - valid_keywords, max_memory_num, max_memory_length, max_depth - ) - except Exception as e: - logger.error(f"文本激活记忆失败: {e}") - response = [] - return response - - async def get_activate_from_text( - self, text: str, max_depth: int = 3, fast_retrieval: bool = False - ) -> tuple[float, list[str], list[str]]: - """从文本中获取激活值的公共接口""" - if not self._initialized: - raise RuntimeError("HippocampusManager 尚未初始化，请先调用 initialize 方法") - try: - return await self._hippocampus.get_activate_from_text(text, max_depth, fast_retrieval) - except Exception as e: - logger.error(f"文本产生激活值失败: {e}") - logger.error(traceback.format_exc()) - return 0.0, [], [] - - def get_memory_from_keyword(self, keyword: str, max_depth: int = 2) -> list: - """从关键词获取相关记忆的公共接口""" - if not self._initialized: - raise RuntimeError("HippocampusManager 尚未初始化，请先调用 initialize 方法") - return self._hippocampus.get_memory_from_keyword(keyword, max_depth) - - def get_all_node_names(self) -> list: - """获取所有节点名称的公共接口""" - if not self._initialized: - raise RuntimeError("HippocampusManager 尚未初始化，请先调用 initialize 方法") - return self._hippocampus.get_all_node_names() - - -# 创建全局实例 -hippocampus_manager = HippocampusManager() diff --git a/src/chat/memory_system/memory_activator.py b/src/chat/memory_system/memory_activator.py deleted file mode 100644 index ce7daef5..00000000 --- a/src/chat/memory_system/memory_activator.py +++ /dev/null @@ -1,241 +0,0 @@ -import json -import random - -from json_repair import repair_json -from typing import List, Tuple - -from src.config.config import global_config, model_config -from src.common.logger import get_logger -from src.common.data_models.database_data_model import DatabaseMessages -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager -from src.chat.utils.utils import parse_keywords_string -from src.chat.utils.chat_message_builder import build_readable_messages -from src.chat.memory_system.Hippocampus import hippocampus_manager -from src.llm_models.utils_model import LLMRequest - - -logger = get_logger("memory_activator") - - -def get_keywords_from_json(json_str) -> List: - """ - 从JSON字符串中提取关键词列表 - - Args: - json_str: JSON格式的字符串 - - Returns: - List[str]: 关键词列表 - """ - try: - # 使用repair_json修复JSON格式 - fixed_json = repair_json(json_str) - - # 如果repair_json返回的是字符串，需要解析为Python对象 - result = json.loads(fixed_json) if isinstance(fixed_json, str) else fixed_json - return result.get("keywords", []) - except Exception as e: - logger.error(f"解析关键词JSON失败: {e}") - return [] - - -def init_prompt(): - # --- Group Chat Prompt --- - memory_activator_prompt = """ - 你需要根据以下信息来挑选合适的记忆编号 - 以下是一段聊天记录，请根据这些信息，和下方的记忆，挑选和群聊内容有关的记忆编号 - - 聊天记录: - {obs_info_text} - 你想要回复的消息: - {target_message} - - 记忆： - {memory_info} - - 请输出一个json格式，包含以下字段： - {{ - "memory_ids": "记忆1编号,记忆2编号,记忆3编号,......" - }} - 不要输出其他多余内容，只输出json格式就好 - """ - - Prompt(memory_activator_prompt, "memory_activator_prompt") - - -class MemoryActivator: - def __init__(self): - self.key_words_model = LLMRequest( - model_set=model_config.model_task_config.utils_small, - request_type="memory.activator", - ) - # 用于记忆选择的 LLM 模型 - self.memory_selection_model = LLMRequest( - model_set=model_config.model_task_config.utils_small, - request_type="memory.selection", - ) - - async def activate_memory_with_chat_history( - self, target_message, chat_history: List[DatabaseMessages] - ) -> List[Tuple[str, str]]: - """ - 激活记忆 - """ - # 如果记忆系统被禁用，直接返回空列表 - if not global_config.memory.enable_memory: - return [] - - keywords_list = set() - - for msg in chat_history: - keywords = parse_keywords_string(msg.key_words) - if keywords: - if len(keywords_list) < 30: - # 最多容纳30个关键词 - keywords_list.update(keywords) - logger.debug(f"提取关键词: {keywords_list}") - else: - break - - if not keywords_list: - logger.debug("没有提取到关键词，返回空记忆列表") - return [] - - # 从海马体获取相关记忆 - related_memory = await hippocampus_manager.get_memory_from_topic( - valid_keywords=list(keywords_list), max_memory_num=5, max_memory_length=3, max_depth=3 - ) - - # logger.info(f"当前记忆关键词: {keywords_list}") - logger.debug(f"获取到的记忆: {related_memory}") - - if not related_memory: - logger.debug("海马体没有返回相关记忆") - return [] - - used_ids = set() - candidate_memories = [] - - # 为每个记忆分配随机ID并过滤相关记忆 - for memory in related_memory: - keyword, content = memory - found = any(kw in content for kw in keywords_list) - if found: - # 随机分配一个不重复的2位数id - while True: - random_id = "{:02d}".format(random.randint(0, 99)) - if random_id not in used_ids: - used_ids.add(random_id) - break - candidate_memories.append({"memory_id": random_id, "keyword": keyword, "content": content}) - - if not candidate_memories: - logger.info("没有找到相关的候选记忆") - return [] - - # 如果只有少量记忆，直接返回 - if len(candidate_memories) <= 2: - logger.debug(f"候选记忆较少({len(candidate_memories)}个)，直接返回") - # 转换为 (keyword, content) 格式 - return [(mem["keyword"], mem["content"]) for mem in candidate_memories] - - return await self._select_memories_with_llm(target_message, chat_history, candidate_memories) - - async def _select_memories_with_llm( - self, target_message, chat_history: List[DatabaseMessages], candidate_memories - ) -> List[Tuple[str, str]]: - """ - 使用 LLM 选择合适的记忆 - - Args: - target_message: 目标消息 - chat_history_prompt: 聊天历史 - candidate_memories: 候选记忆列表，每个记忆包含 memory_id、keyword、content - - Returns: - List[Tuple[str, str]]: 选择的记忆列表，格式为 (keyword, content) - """ - try: - # 构建聊天历史字符串 - obs_info_text = build_readable_messages( - chat_history, - replace_bot_name=True, - timestamp_mode="relative", - read_mark=0.0, - show_actions=True, - ) - - # 构建记忆信息字符串 - memory_lines = [] - for memory in candidate_memories: - memory_id = memory["memory_id"] - keyword = memory["keyword"] - content = memory["content"] - - # 将 content 列表转换为字符串 - if isinstance(content, list): - content_str = " | ".join(str(item) for item in content) - else: - content_str = str(content) - - memory_lines.append(f"记忆编号 {memory_id}: [关键词: {keyword}] {content_str}") - - memory_info = "\n".join(memory_lines) - - # 获取并格式化 prompt - prompt_template = await global_prompt_manager.get_prompt_async("memory_activator_prompt") - formatted_prompt = prompt_template.format( - obs_info_text=obs_info_text, target_message=target_message, memory_info=memory_info - ) - - # 调用 LLM - response, (reasoning_content, model_name, _) = await self.memory_selection_model.generate_response_async( - formatted_prompt, temperature=0.3, max_tokens=150 - ) - - if global_config.debug.show_prompt: - logger.info(f"记忆选择 prompt: {formatted_prompt}") - logger.info(f"LLM 记忆选择响应: {response}") - else: - logger.debug(f"记忆选择 prompt: {formatted_prompt}") - logger.debug(f"LLM 记忆选择响应: {response}") - - # 解析响应获取选择的记忆编号 - try: - fixed_json = repair_json(response) - - # 解析为 Python 对象 - result = json.loads(fixed_json) if isinstance(fixed_json, str) else fixed_json - - # 提取 memory_ids 字段并解析逗号分隔的编号 - if memory_ids_str := result.get("memory_ids", ""): - memory_ids = [mid.strip() for mid in str(memory_ids_str).split(",") if mid.strip()] - # 过滤掉空字符串和无效编号 - valid_memory_ids = [mid for mid in memory_ids if mid and len(mid) <= 3] - selected_memory_ids = valid_memory_ids - else: - selected_memory_ids = [] - except Exception as e: - logger.error(f"解析记忆选择响应失败: {e}", exc_info=True) - selected_memory_ids = [] - - # 根据编号筛选记忆 - selected_memories = [] - memory_id_to_memory = {mem["memory_id"]: mem for mem in candidate_memories} - - selected_memories = [ - memory_id_to_memory[memory_id] for memory_id in selected_memory_ids if memory_id in memory_id_to_memory - ] - logger.info(f"LLM 选择的记忆编号: {selected_memory_ids}") - logger.info(f"最终选择的记忆数量: {len(selected_memories)}") - - # 转换为 (keyword, content) 格式 - return [(mem["keyword"], mem["content"]) for mem in selected_memories] - - except Exception as e: - logger.error(f"LLM 选择记忆时出错: {e}", exc_info=True) - # 出错时返回前3个候选记忆作为备选，转换为 (keyword, content) 格式 - return [(mem["keyword"], mem["content"]) for mem in candidate_memories[:3]] - - -init_prompt() diff --git a/src/chat/message_receive/bot.py b/src/chat/message_receive/bot.py index 0709dcd8..2eb0b4e3 100644 --- a/src/chat/message_receive/bot.py +++ b/src/chat/message_receive/bot.py @@ -3,19 +3,18 @@ import os import re from typing import Dict, Any, Optional -from maim_message import UserInfo, Seg +from maim_message import UserInfo, Seg, GroupInfo from src.common.logger import get_logger from src.config.config import global_config from src.mood.mood_manager import mood_manager # 导入情绪管理器 -from src.chat.message_receive.chat_stream import get_chat_manager, ChatStream -from src.chat.message_receive.message import MessageRecv, MessageRecvS4U +from src.chat.message_receive.chat_stream import get_chat_manager +from src.chat.message_receive.message import MessageRecv from src.chat.message_receive.storage import MessageStorage from src.chat.heart_flow.heartflow_message_processor import HeartFCMessageReceiver from src.chat.utils.prompt_builder import Prompt, global_prompt_manager from src.plugin_system.core import component_registry, events_manager, global_announcement_manager from src.plugin_system.base import BaseCommand, EventType -from src.mais4u.mais4u_chat.s4u_msg_processor import S4UMessageProcessor from src.person_info.person_info import Person # 定义日志配置 @@ -27,7 +26,7 @@ PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.. logger = get_logger("chat") -def _check_ban_words(text: str, chat: ChatStream, userinfo: UserInfo) -> bool: +def _check_ban_words(text: str, userinfo: UserInfo, group_info: Optional[GroupInfo] = None) -> bool: """检查消息是否包含过滤词 Args: @@ -40,14 +39,14 @@ def _check_ban_words(text: str, chat: ChatStream, userinfo: UserInfo) -> bool: """ for word in global_config.message_receive.ban_words: if word in text: - chat_name = chat.group_info.group_name if chat.group_info else "私聊" + chat_name = group_info.group_name if group_info else "私聊" logger.info(f"[{chat_name}]{userinfo.user_nickname}:{text}") logger.info(f"[过滤词识别]消息中含有{word}，filtered") return True return False -def _check_ban_regex(text: str, chat: ChatStream, userinfo: UserInfo) -> bool: +def _check_ban_regex(text: str, userinfo: UserInfo, group_info: Optional[GroupInfo] = None) -> bool: """检查消息是否匹配过滤正则表达式 Args: @@ -61,10 +60,10 @@ def _check_ban_regex(text: str, chat: ChatStream, userinfo: UserInfo) -> bool: # 检查text是否为None或空字符串 if text is None or not text: return False - + for pattern in global_config.message_receive.ban_msgs_regex: if re.search(pattern, text): - chat_name = chat.group_info.group_name if chat.group_info else "私聊" + chat_name = group_info.group_name if group_info else "私聊" logger.info(f"[{chat_name}]{userinfo.user_nickname}:{text}") logger.info(f"[正则表达式过滤]消息匹配到{pattern}，filtered") return True @@ -78,8 +77,6 @@ class ChatBot: self.mood_manager = mood_manager # 获取情绪管理器单例 self.heartflow_message_receiver = HeartFCMessageReceiver() # 新增 - self.s4u_message_processor = S4UMessageProcessor() - async def _ensure_started(self): """确保所有任务已启动""" if not self._started: @@ -153,35 +150,10 @@ class ChatBot: if message.message_info.message_id == "notice": message.is_notify = True logger.info("notice消息") - # print(message) + print(message) return True - async def do_s4u(self, message_data: Dict[str, Any]): - message = MessageRecvS4U(message_data) - group_info = message.message_info.group_info - user_info = message.message_info.user_info - - get_chat_manager().register_message(message) - chat = await get_chat_manager().get_or_create_stream( - platform=message.message_info.platform, # type: ignore - user_info=user_info, # type: ignore - group_info=group_info, - ) - - message.update_chat_stream(chat) - - # 处理消息内容 - await message.process() - - _ = Person.register_person( - platform=message.message_info.platform, # type: ignore - user_id=message.message_info.user_info.user_id, # type: ignore - nickname=user_info.user_nickname, # type: ignore - ) - - await self.s4u_message_processor.process_message(message) - return async def echo_message_process(self, raw_data: Dict[str, Any]) -> None: @@ -219,11 +191,6 @@ class ChatBot: # 确保所有任务已启动 await self._ensure_started() - platform = message_data["message_info"].get("platform") - - if platform == "amaidesu_default": - await self.do_s4u(message_data) - return if message_data["message_info"].get("group_info") is not None: message_data["message_info"]["group_info"]["group_id"] = str( @@ -251,6 +218,21 @@ class ChatBot: # return pass + # 处理消息内容，生成纯文本 + await message.process() + + # 过滤检查 + if _check_ban_words( + message.processed_plain_text, + user_info, # type: ignore + group_info, + ) or _check_ban_regex( + message.raw_message, # type: ignore + user_info, # type: ignore + group_info, + ): + return + get_chat_manager().register_message(message) chat = await get_chat_manager().get_or_create_stream( @@ -261,21 +243,10 @@ class ChatBot: message.update_chat_stream(chat) - # 处理消息内容，生成纯文本 - await message.process() - # if await self.check_ban_content(message): # logger.warning(f"检测到消息中含有违法，色情，暴力，反动，敏感内容，消息内容：{message.processed_plain_text}，发送者：{message.message_info.user_info.user_nickname}") # return - # 过滤检查 - if _check_ban_words(message.processed_plain_text, chat, user_info) or _check_ban_regex( # type: ignore - message.raw_message, # type: ignore - chat, - user_info, # type: ignore - ): - return - # 命令处理 - 使用新插件系统检查并处理命令 is_command, cmd_result, continue_process = await self._process_commands_with_new_system(message) diff --git a/src/chat/message_receive/message.py b/src/chat/message_receive/message.py index d45103fe..aa992552 100644 --- a/src/chat/message_receive/message.py +++ b/src/chat/message_receive/message.py @@ -138,6 +138,7 @@ class MessageRecv(Message): 这个方法必须在创建实例后显式调用，因为它包含异步操作。 """ + # print(f"self.message_segment: {self.message_segment}") self.processed_plain_text = await self._process_message_segments(self.message_segment) async def _process_single_segment(self, segment: Seg) -> str: @@ -208,129 +209,6 @@ class MessageRecv(Message): return f"[处理失败的{segment.type}消息]" -@dataclass -class MessageRecvS4U(MessageRecv): - def __init__(self, message_dict: dict[str, Any]): - super().__init__(message_dict) - self.is_gift = False - self.is_fake_gift = False - self.is_superchat = False - self.gift_info = None - self.gift_name = None - self.gift_count: Optional[str] = None - self.superchat_info = None - self.superchat_price = None - self.superchat_message_text = None - self.is_screen = False - self.is_internal = False - self.voice_done = None - - self.chat_info = None - - async def process(self) -> None: - self.processed_plain_text = await self._process_message_segments(self.message_segment) - - async def _process_single_segment(self, segment: Seg) -> str: - """处理单个消息段 - - Args: - segment: 消息段 - - Returns: - str: 处理后的文本 - """ - try: - if segment.type == "text": - self.is_voice = False - self.is_picid = False - self.is_emoji = False - return segment.data # type: ignore - elif segment.type == "image": - self.is_voice = False - # 如果是base64图片数据 - if isinstance(segment.data, str): - self.has_picid = True - self.is_picid = True - self.is_emoji = False - image_manager = get_image_manager() - # print(f"segment.data: {segment.data}") - _, processed_text = await image_manager.process_image(segment.data) - return processed_text - return "[发了一张图片，网卡了加载不出来]" - elif segment.type == "emoji": - self.has_emoji = True - self.is_emoji = True - self.is_picid = False - if isinstance(segment.data, str): - return await get_image_manager().get_emoji_description(segment.data) - return "[发了一个表情包，网卡了加载不出来]" - elif segment.type == "voice": - self.has_picid = False - self.is_picid = False - self.is_emoji = False - self.is_voice = True - if isinstance(segment.data, str): - return await get_voice_text(segment.data) - return "[发了一段语音，网卡了加载不出来]" - elif segment.type == "mention_bot": - self.is_voice = False - self.is_picid = False - self.is_emoji = False - self.is_mentioned = float(segment.data) # type: ignore - return "" - elif segment.type == "priority_info": - self.is_voice = False - self.is_picid = False - self.is_emoji = False - if isinstance(segment.data, dict): - # 处理优先级信息 - self.priority_mode = "priority" - self.priority_info = segment.data - """ - { - 'message_type': 'vip', # vip or normal - 'message_priority': 1.0, # 优先级，大为优先，float - } - """ - return "" - elif segment.type == "gift": - self.is_voice = False - self.is_gift = True - # 解析gift_info，格式为"名称:数量" - name, count = segment.data.split(":", 1) # type: ignore - self.gift_info = segment.data - self.gift_name = name.strip() - self.gift_count = int(count.strip()) - return "" - elif segment.type == "voice_done": - msg_id = segment.data - logger.info(f"voice_done: {msg_id}") - self.voice_done = msg_id - return "" - elif segment.type == "superchat": - self.is_superchat = True - self.superchat_info = segment.data - price, message_text = segment.data.split(":", 1) # type: ignore - self.superchat_price = price.strip() - self.superchat_message_text = message_text.strip() - - self.processed_plain_text = str(self.superchat_message_text) - self.processed_plain_text += ( - f"（注意：这是一条超级弹幕信息，价值{self.superchat_price}元，请你认真回复）" - ) - - return self.processed_plain_text - elif segment.type == "screen": - self.is_screen = True - self.screen_info = segment.data - return "屏幕信息" - else: - return "" - except Exception as e: - logger.error(f"处理消息段失败: {str(e)}, 类型: {segment.type}, 数据: {segment.data}") - return f"[处理失败的{segment.type}消息]" - - @dataclass class MessageProcessBase(Message): """消息处理基类，用于处理中和发送中的消息""" diff --git a/src/chat/planner_actions/action_manager.py b/src/chat/planner_actions/action_manager.py index 013d78e1..287d4063 100644 --- a/src/chat/planner_actions/action_manager.py +++ b/src/chat/planner_actions/action_manager.py @@ -32,7 +32,7 @@ class ActionManager: self, action_name: str, action_data: dict, - reasoning: str, + action_reasoning: str, cycle_timers: dict, thinking_id: str, chat_stream: ChatStream, @@ -46,7 +46,7 @@ class ActionManager: Args: action_name: 动作名称 action_data: 动作数据 - reasoning: 执行理由 + action_reasoning: 执行理由 cycle_timers: 计时器字典 thinking_id: 思考ID chat_stream: 聊天流 @@ -77,7 +77,7 @@ class ActionManager: # 创建动作实例 instance = component_class( action_data=action_data, - reasoning=reasoning, + action_reasoning=action_reasoning, cycle_timers=cycle_timers, thinking_id=thinking_id, chat_stream=chat_stream, diff --git a/src/chat/planner_actions/planner.py b/src/chat/planner_actions/planner.py index 741aa94b..7274afdc 100644 --- a/src/chat/planner_actions/planner.py +++ b/src/chat/planner_actions/planner.py @@ -3,7 +3,7 @@ import time import traceback import random import re -from typing import Dict, Optional, Tuple, List, TYPE_CHECKING +from typing import Dict, Optional, Tuple, List, TYPE_CHECKING, Union from rich.traceback import install from datetime import datetime from json_repair import repair_json @@ -44,14 +44,13 @@ def init_prompt(): **聊天内容** {chat_content_block} -**动作记录** -{actions_before_now_block} - -**可用的action** +**可选的action** reply 动作描述： 1.你可以选择呼叫了你的名字，但是你没有做出回应的消息进行回复 2.你可以自然的顺着正在进行的聊天内容进行回复或自然的提出一个问题 +3.不要回复你自己发送的消息 +4.不要单独对表情包进行回复 {{ "action": "reply", "target_message_id":"想要回复的消息id", @@ -76,7 +75,11 @@ no_reply_until_call {action_options_text} -请选择合适的action，并说明触发action的消息id和选择该action的原因。消息id格式:m+数字 +**你之前的action执行和思考记录** +{actions_before_now_block} + +请选择**可选的**且符合使用条件的action，并说明触发action的消息id(消息id格式:m+数字) +不要回复你自己发送的消息 先输出你的选择思考理由，再输出你选择的action，理由是一段平文本，不要分点，精简。 **动作选择要求** 请你根据聊天内容,用户的最新消息和以下标准选择合适的动作: @@ -99,9 +102,7 @@ no_reply_until_call "target_message_id":"触发动作的消息id", //对应参数 }} -``` - -""", +```""", "planner_prompt", ) @@ -109,7 +110,7 @@ no_reply_until_call """ {action_name} 动作描述：{action_description} -使用条件： +使用条件{parallel_text}： {action_require} {{ "action": "{action_name}",{action_parameters}, @@ -133,6 +134,9 @@ class ActionPlanner: self.last_obs_time_mark = 0.0 + + self.plan_log: List[Tuple[str, float, Union[List[ActionPlannerInfo], str]]] = [] + def find_message_by_id( self, message_id: str, message_id_list: List[Tuple[str, "DatabaseMessages"]] ) -> Optional["DatabaseMessages"]: @@ -157,15 +161,16 @@ class ActionPlanner: action_json: dict, message_id_list: List[Tuple[str, "DatabaseMessages"]], current_available_actions: List[Tuple[str, ActionInfo]], + extracted_reasoning: str = "", ) -> List[ActionPlannerInfo]: """解析单个action JSON并返回ActionPlannerInfo列表""" action_planner_infos = [] try: - action = action_json.get("action", "no_action") + action = action_json.get("action", "no_reply") reasoning = action_json.get("reason", "未提供原因") action_data = {key: value for key, value in action_json.items() if key not in ["action", "reason"]} - # 非no_action动作需要target_message_id + # 非no_reply动作需要target_message_id target_message = None if target_message_id := action_json.get("target_message_id"): @@ -202,6 +207,7 @@ class ActionPlanner: action_data=action_data, action_message=target_message, available_actions=available_actions_dict, + action_reasoning=extracted_reasoning if extracted_reasoning else None, ) ) @@ -216,6 +222,7 @@ class ActionPlanner: action_data={}, action_message=None, available_actions=available_actions_dict, + action_reasoning=extracted_reasoning if extracted_reasoning else None, ) ) @@ -225,12 +232,11 @@ class ActionPlanner: self, available_actions: Dict[str, ActionInfo], loop_start_time: float = 0.0, - ) -> Tuple[List[ActionPlannerInfo], Optional["DatabaseMessages"]]: + ) -> List[ActionPlannerInfo]: # sourcery skip: use-named-expression """ 规划器 (Planner): 使用LLM根据上下文决定做出什么动作。 """ - target_message: Optional["DatabaseMessages"] = None # 获取聊天上下文 message_list_before_now = get_raw_msg_before_timestamp_with_chat( @@ -276,7 +282,7 @@ class ActionPlanner: ) # 调用LLM获取决策 - actions = await self._execute_main_planner( + reasoning, actions = await self._execute_main_planner( prompt=prompt, message_id_list=message_id_list, filtered_actions=filtered_actions, @@ -284,12 +290,34 @@ class ActionPlanner: loop_start_time=loop_start_time, ) - # 获取target_message（如果有非no_action的动作） - non_no_actions = [a for a in actions if a.action_type != "no_reply"] - if non_no_actions: - target_message = non_no_actions[0].action_message + logger.info(f"{self.log_prefix}Planner:{reasoning}。选择了{len(actions)}个动作: {' '.join([a.action_type for a in actions])}") + + self.add_plan_log(reasoning, actions) + + return actions + + def add_plan_log(self, reasoning: str, actions: List[ActionPlannerInfo]): + self.plan_log.append((reasoning, time.time(), actions)) + if len(self.plan_log) > 20: + self.plan_log.pop(0) + + def add_plan_excute_log(self, result: str): + self.plan_log.append(("", time.time(), result)) + if len(self.plan_log) > 20: + self.plan_log.pop(0) + + def get_plan_log_str(self) -> str: + plan_log_str = "" + for reasoning, time, content in self.plan_log: + if isinstance(content, list) and all(isinstance(action, ActionPlannerInfo) for action in content): + time = datetime.fromtimestamp(time).strftime("%H:%M:%S") + plan_log_str += f"{time}:{reasoning}|你使用了{','.join([action.action_type for action in content])}\n" + else: + time = datetime.fromtimestamp(time).strftime("%H:%M:%S") + plan_log_str += f"{time}:{content}\n" + + return plan_log_str - return actions, target_message async def build_planner_prompt( self, @@ -302,18 +330,8 @@ class ActionPlanner: ) -> tuple[str, List[Tuple[str, "DatabaseMessages"]]]: """构建 Planner LLM 的提示词 (获取模板并填充数据)""" try: - # 获取最近执行过的动作 - actions_before_now = get_actions_by_timestamp_with_chat( - chat_id=self.chat_id, - timestamp_start=time.time() - 600, - timestamp_end=time.time(), - limit=6, - ) - actions_before_now_block = build_readable_actions(actions=actions_before_now) - if actions_before_now_block: - actions_before_now_block = f"你刚刚选择并执行过的action是：\n{actions_before_now_block}" - else: - actions_before_now_block = "" + + actions_before_now_block=self.get_plan_log_str() # 构建聊天上下文描述 chat_context_description = "你现在正在一个群聊中" @@ -343,7 +361,6 @@ class ActionPlanner: interest=interest, plan_style=global_config.personality.plan_style, ) - return prompt, message_id_list except Exception as e: @@ -421,6 +438,11 @@ class ActionPlanner: for require_item in action_info.action_require: require_text += f"- {require_item}\n" require_text = require_text.rstrip("\n") + + if not action_info.parallel_action: + parallel_text = "(当选择这个动作时，请不要选择其他动作)" + else: + parallel_text = "" # 获取动作提示模板并填充 using_action_prompt = await global_prompt_manager.get_prompt_async("action_prompt") @@ -429,6 +451,7 @@ class ActionPlanner: action_description=action_info.description, action_parameters=param_text, action_require=require_text, + parallel_text=parallel_text, ) action_options_block += using_action_prompt @@ -442,7 +465,7 @@ class ActionPlanner: filtered_actions: Dict[str, ActionInfo], available_actions: Dict[str, ActionInfo], loop_start_time: float, - ) -> List[ActionPlannerInfo]: + ) -> Tuple[str,List[ActionPlannerInfo]]: """执行主规划器""" llm_content = None actions: List[ActionPlannerInfo] = [] @@ -451,8 +474,8 @@ class ActionPlanner: # 调用LLM llm_content, (reasoning_content, _, _) = await self.planner_llm.generate_response_async(prompt=prompt) - logger.info(f"{self.log_prefix}规划器原始提示词: {prompt}") - logger.info(f"{self.log_prefix}规划器原始响应: {llm_content}") + # logger.info(f"{self.log_prefix}规划器原始提示词: {prompt}") + # logger.info(f"{self.log_prefix}规划器原始响应: {llm_content}") if global_config.debug.show_prompt: logger.info(f"{self.log_prefix}规划器原始提示词: {prompt}") @@ -467,7 +490,7 @@ class ActionPlanner: except Exception as req_e: logger.error(f"{self.log_prefix}LLM 请求执行失败: {req_e}") - return [ + return f"LLM 请求失败，模型出现问题: {req_e}",[ ActionPlannerInfo( action_type="no_reply", reasoning=f"LLM 请求失败，模型出现问题: {req_e}", @@ -478,38 +501,41 @@ class ActionPlanner: ] # 解析LLM响应 + extracted_reasoning = "" if llm_content: try: - if json_objects := self._extract_json_from_markdown(llm_content): + json_objects, extracted_reasoning = self._extract_json_from_markdown(llm_content) + if json_objects: logger.debug(f"{self.log_prefix}从响应中提取到{len(json_objects)}个JSON对象") filtered_actions_list = list(filtered_actions.items()) for json_obj in json_objects: - actions.extend(self._parse_single_action(json_obj, message_id_list, filtered_actions_list)) + actions.extend(self._parse_single_action(json_obj, message_id_list, filtered_actions_list, extracted_reasoning)) else: # 尝试解析为直接的JSON logger.warning(f"{self.log_prefix}LLM没有返回可用动作: {llm_content}") + extracted_reasoning = "LLM没有返回可用动作" actions = self._create_no_reply("LLM没有返回可用动作", available_actions) except Exception as json_e: logger.warning(f"{self.log_prefix}解析LLM响应JSON失败 {json_e}. LLM原始输出: '{llm_content}'") + extracted_reasoning = f"解析LLM响应JSON失败: {json_e}" actions = self._create_no_reply(f"解析LLM响应JSON失败: {json_e}", available_actions) traceback.print_exc() else: + extracted_reasoning = "规划器没有获得LLM响应" actions = self._create_no_reply("规划器没有获得LLM响应", available_actions) - # 添加循环开始时间到所有非no_action动作 + # 添加循环开始时间到所有非no_reply动作 for action in actions: action.action_data = action.action_data or {} action.action_data["loop_start_time"] = loop_start_time - logger.info( - f"{self.log_prefix}规划器决定执行{len(actions)}个动作: {' '.join([a.action_type for a in actions])}" - ) + logger.debug(f"{self.log_prefix}规划器选择了{len(actions)}个动作: {' '.join([a.action_type for a in actions])}") - return actions + return extracted_reasoning,actions def _create_no_reply(self, reasoning: str, available_actions: Dict[str, ActionInfo]) -> List[ActionPlannerInfo]: - """创建no_action""" + """创建no_reply""" return [ ActionPlannerInfo( action_type="no_reply", @@ -520,15 +546,26 @@ class ActionPlanner: ) ] - def _extract_json_from_markdown(self, content: str) -> List[dict]: + def _extract_json_from_markdown(self, content: str) -> Tuple[List[dict], str]: # sourcery skip: for-append-to-extend - """从Markdown格式的内容中提取JSON对象""" + """从Markdown格式的内容中提取JSON对象和推理内容""" json_objects = [] + reasoning_content = "" # 使用正则表达式查找```json包裹的JSON内容 json_pattern = r"```json\s*(.*?)\s*```" matches = re.findall(json_pattern, content, re.DOTALL) + # 提取JSON之前的内容作为推理文本 + if matches: + # 找到第一个```json的位置 + first_json_pos = content.find("```json") + if first_json_pos > 0: + reasoning_content = content[: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: # 清理可能的注释和格式问题 @@ -546,7 +583,7 @@ class ActionPlanner: logger.warning(f"解析JSON块失败: {e}, 块内容: {match[:100]}...") continue - return json_objects + return json_objects, reasoning_content init_prompt() diff --git a/src/chat/replyer/group_generator.py b/src/chat/replyer/group_generator.py index 178aa7d6..88935da7 100644 --- a/src/chat/replyer/group_generator.py +++ b/src/chat/replyer/group_generator.py @@ -6,7 +6,8 @@ import re from typing import List, Optional, Dict, Any, Tuple from datetime import datetime -from src.mais4u.mai_think import mai_thinking_manager +from src.memory_system.Memory_chest import global_memory_chest +from src.memory_system.questions import global_conflict_tracker from src.common.logger import get_logger from src.common.data_models.database_data_model import DatabaseMessages from src.common.data_models.info_data_model import ActionPlannerInfo @@ -19,16 +20,17 @@ from src.chat.message_receive.uni_message_sender import UniversalMessageSender from src.chat.utils.timer_calculator import Timer # <--- Import Timer from src.chat.utils.utils import get_chat_type_and_target_info from src.chat.utils.prompt_builder import global_prompt_manager +from src.mood.mood_manager import mood_manager from src.chat.utils.chat_message_builder import ( build_readable_messages, get_raw_msg_before_timestamp_with_chat, replace_user_references, ) -from src.chat.express.expression_selector import expression_selector +from src.express.expression_selector import expression_selector +from src.plugin_system.apis.message_api import translate_pid_to_description -# from src.chat.memory_system.memory_activator import MemoryActivator -from src.mood.mood_manager import mood_manager -from src.person_info.person_info import Person, is_person_known +# from src.memory_system.memory_activator import MemoryActivator +from src.person_info.person_info import Person from src.plugin_system.base.component_types import ActionInfo, EventType from src.plugin_system.apis import llm_api @@ -43,6 +45,7 @@ init_rewrite_prompt() logger = get_logger("replyer") + class DefaultReplyer: def __init__( self, @@ -69,6 +72,7 @@ class DefaultReplyer: from_plugin: bool = True, stream_id: Optional[str] = None, reply_message: Optional[DatabaseMessages] = None, + reply_time_point: Optional[float] = time.time(), ) -> Tuple[bool, LLMGenerationDataModel]: # sourcery skip: merge-nested-ifs """ @@ -102,6 +106,7 @@ class DefaultReplyer: enable_tool=enable_tool, reply_message=reply_message, reply_reason=reply_reason, + reply_time_point=reply_time_point, ) llm_response.prompt = prompt llm_response.selected_expressions = selected_expressions @@ -216,30 +221,6 @@ class DefaultReplyer: traceback.print_exc() return False, llm_response - async def build_relation_info(self, chat_content: str, sender: str, person_list: List[Person]): - if not global_config.relationship.enable_relationship: - return "" - - if not sender: - return "" - - if sender == global_config.bot.nickname: - return "" - - # 获取用户ID - person = Person(person_name=sender) - if not is_person_known(person_name=sender): - logger.warning(f"未找到用户 {sender} 的ID，跳过信息提取") - return f"你完全不认识{sender}，不理解ta的相关信息。" - - sender_relation = await person.build_relationship(chat_content) - others_relation = "" - for person in person_list: - person_relation = await person.build_relationship() - others_relation += person_relation - - return f"{sender_relation}\n{others_relation}" - async def build_expression_habits(self, chat_history: str, target: str) -> Tuple[str, List[int]]: # sourcery skip: for-append-to-extend """构建表达习惯块 @@ -257,8 +238,8 @@ class DefaultReplyer: return "", [] style_habits = [] # 使用从处理器传来的选中表达方式 - # LLM模式：调用LLM选择5-10个，然后随机选5个 - selected_expressions, selected_ids = await expression_selector.select_suitable_expressions_llm( + # 根据配置模式选择表达方式：exp_model模式直接使用模型预测，classic模式使用LLM选择 + selected_expressions, selected_ids = await expression_selector.select_suitable_expressions( self.chat_stream.stream_id, chat_history, max_num=8, target_message=target ) @@ -277,44 +258,42 @@ class DefaultReplyer: expression_habits_block = "" expression_habits_title = "" if style_habits_str.strip(): - expression_habits_title = ( - "在回复时,你可以参考以下的语言习惯，不要生硬使用：" - ) + expression_habits_title = "在回复时,你可以参考以下的语言习惯，不要生硬使用：" expression_habits_block += f"{style_habits_str}\n" return f"{expression_habits_title}\n{expression_habits_block}", selected_ids + + async def build_mood_state_prompt(self) -> str: + """构建情绪状态提示""" + if not global_config.mood.enable_mood: + return "" + mood_state = await mood_manager.get_mood_by_chat_id(self.chat_stream.stream_id).get_mood() + return f"你现在的心情是：{mood_state}" + + async def build_memory_block(self) -> str: + """构建记忆块 + """ + # if not global_config.memory.enable_memory: + # return "" - # async def build_memory_block(self, chat_history: List[DatabaseMessages], target: str) -> str: - # """构建记忆块 + if global_memory_chest.get_chat_memories_as_string(self.chat_stream.stream_id): + return f"你有以下记忆：\n{global_memory_chest.get_chat_memories_as_string(self.chat_stream.stream_id)}" + else: + return "" - # Args: - # chat_history: 聊天历史记录 - # target: 目标消息内容 - - # Returns: - # str: 记忆信息字符串 - # """ - - # if not global_config.memory.enable_memory: - # return "" - - # instant_memory = None - - # running_memories = await self.memory_activator.activate_memory_with_chat_history( - # target_message=target, chat_history=chat_history - # ) - # if not running_memories: - # return "" - - # memory_str = "以下是当前在聊天中，你回忆起的记忆：\n" - # for running_memory in running_memories: - # keywords, content = running_memory - # memory_str += f"- {keywords}：{content}\n" - - # if instant_memory: - # memory_str += f"- {instant_memory}\n" - - # return memory_str + async def build_question_block(self) -> str: + """构建问题块""" + # if not global_config.question.enable_question: + # return "" + questions = global_conflict_tracker.get_questions_by_chat_id(self.chat_stream.stream_id) + questions_str = "" + for question in questions: + questions_str += f"- {question.question}\n" + if questions_str: + return f"你在聊天中，有以下问题想要得到解答：\n{questions_str}" + else: + return "" + async def build_tool_info(self, chat_history: str, sender: str, target: str, enable_tool: bool = True) -> str: """构建工具信息块 @@ -344,7 +323,7 @@ class DefaultReplyer: content = tool_result.get("content", "") result_type = tool_result.get("type", "tool_result") - tool_info_str += f"- 【{tool_name}】{result_type}: {content}\n" + tool_info_str += f"- 【{tool_name}】: {content}\n" tool_info_str += "以上是你获取到的实时信息，请在回复时参考这些信息。" logger.info(f"获取到 {len(tool_results)} 个工具结果") @@ -380,6 +359,64 @@ class DefaultReplyer: target = parts[1].strip() return sender, target + def _replace_picids_with_descriptions(self, text: str) -> str: + """将文本中的[picid:xxx]替换为具体的图片描述 + + Args: + text: 包含picid标记的文本 + + Returns: + 替换后的文本 + """ + # 匹配 [picid:xxxxx] 格式 + pic_pattern = r"\[picid:([^\]]+)\]" + + def replace_pic_id(match: re.Match) -> str: + pic_id = match.group(1) + description = translate_pid_to_description(pic_id) + return f"[图片：{description}]" + + return re.sub(pic_pattern, replace_pic_id, text) + + def _analyze_target_content(self, target: str) -> Tuple[bool, bool, str, str]: + """分析target内容类型（基于原始picid格式） + + Args: + target: 目标消息内容（包含[picid:xxx]格式） + + Returns: + Tuple[bool, bool, str, str]: (是否只包含图片, 是否包含文字, 图片部分, 文字部分) + """ + if not target or not target.strip(): + return False, False, "", "" + + # 检查是否只包含picid标记 + picid_pattern = r"\[picid:[^\]]+\]" + picid_matches = re.findall(picid_pattern, target) + + # 移除所有picid标记后检查是否还有文字内容 + text_without_picids = re.sub(picid_pattern, "", target).strip() + + has_only_pics = len(picid_matches) > 0 and not text_without_picids + has_text = bool(text_without_picids) + + # 提取图片部分（转换为[图片:描述]格式） + pic_part = "" + if picid_matches: + pic_descriptions = [] + for picid_match in picid_matches: + pic_id = picid_match[7:-1] # 提取picid:xxx中的xxx部分（从第7个字符开始） + description = translate_pid_to_description(pic_id) + logger.info(f"图片ID: {pic_id}, 描述: {description}") + # 如果description已经是[图片]格式，直接使用；否则包装为[图片:描述]格式 + if description == "[图片]": + pic_descriptions.append(description) + else: + pic_descriptions.append(f"[图片:{description}]") + pic_part = "".join(pic_descriptions) + + return has_only_pics, has_text, pic_part, text_without_picids + async def build_keywords_reaction_prompt(self, target: Optional[str]) -> str: """构建关键词反应提示 @@ -438,11 +475,10 @@ class DefaultReplyer: duration = end_time - start_time return name, result, duration - def build_s4u_chat_history_prompts( + def build_chat_history_prompts( self, message_list_before_now: List[DatabaseMessages], target_user_id: str, sender: str ) -> Tuple[str, str]: """ - 构建 s4u 风格的分离对话 prompt Args: message_list_before_now: 历史消息列表 @@ -498,7 +534,6 @@ class DefaultReplyer: -------------------------------- """ - # 构建背景对话 prompt all_dialogue_prompt = "" if message_list_before_now: @@ -516,51 +551,6 @@ class DefaultReplyer: return core_dialogue_prompt, all_dialogue_prompt - def build_mai_think_context( - self, - chat_id: str, - memory_block: str, - relation_info: str, - time_block: str, - chat_target_1: str, - chat_target_2: str, - mood_prompt: str, - identity_block: str, - sender: str, - target: str, - chat_info: str, - ) -> Any: - """构建 mai_think 上下文信息 - - Args: - chat_id: 聊天ID - memory_block: 记忆块内容 - relation_info: 关系信息 - time_block: 时间块内容 - chat_target_1: 聊天目标1 - chat_target_2: 聊天目标2 - mood_prompt: 情绪提示 - identity_block: 身份块内容 - sender: 发送者名称 - target: 目标消息内容 - chat_info: 聊天信息 - - Returns: - Any: mai_think 实例 - """ - mai_think = mai_thinking_manager.get_mai_think(chat_id) - mai_think.memory_block = memory_block - mai_think.relation_info_block = relation_info - mai_think.time_block = time_block - mai_think.chat_target = chat_target_1 - mai_think.chat_target_2 = chat_target_2 - mai_think.chat_info = chat_info - mai_think.mood_state = mood_prompt - mai_think.identity = identity_block - mai_think.sender = sender - mai_think.target = target - return mai_think - async def build_actions_prompt( self, available_actions: Dict[str, ActionInfo], chosen_actions_info: Optional[List[ActionPlannerInfo]] = None ) -> str: @@ -615,6 +605,7 @@ class DefaultReplyer: available_actions: Optional[Dict[str, ActionInfo]] = None, chosen_actions: Optional[List[ActionPlannerInfo]] = None, enable_tool: bool = True, + reply_time_point: Optional[float] = time.time(), ) -> Tuple[str, List[int]]: """ 构建回复器上下文 @@ -649,23 +640,23 @@ class DefaultReplyer: sender = person_name target = reply_message.processed_plain_text - mood_prompt: str = "" - if global_config.mood.enable_mood: - chat_mood = mood_manager.get_mood_by_chat_id(chat_id) - mood_prompt = chat_mood.mood_state - target = replace_user_references(target, chat_stream.platform, replace_bot_name=True) - target = re.sub(r"\\[picid:[^\\]]+\\]", "[图片]", target) + + # 在picid替换之前分析内容类型（防止prompt注入） + has_only_pics, has_text, pic_part, text_part = self._analyze_target_content(target) + + # 将[picid:xxx]替换为具体的图片描述 + target = self._replace_picids_with_descriptions(target) message_list_before_now_long = get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, - timestamp=time.time(), + timestamp=reply_time_point, limit=global_config.chat.max_context_size * 1, ) message_list_before_short = get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, - timestamp=time.time(), + timestamp=reply_time_point, limit=int(global_config.chat.max_context_size * 0.33), ) @@ -686,8 +677,8 @@ class DefaultReplyer: if person.is_known: person_list_short.append(person) - for person in person_list_short: - print(person.person_name) + # for person in person_list_short: + # print(person.person_name) chat_talking_prompt_short = build_readable_messages( message_list_before_short, @@ -702,16 +693,15 @@ class DefaultReplyer: self._time_and_run_task( self.build_expression_habits(chat_talking_prompt_short, target), "expression_habits" ), - # self._time_and_run_task( - # self.build_relation_info(chat_talking_prompt_short, sender, person_list_short), "relation_info" - # ), - # self._time_and_run_task(self.build_memory_block(message_list_before_short, target), "memory_block"), + self._time_and_run_task(self.build_memory_block(), "memory_block"), self._time_and_run_task( self.build_tool_info(chat_talking_prompt_short, sender, target, enable_tool=enable_tool), "tool_info" ), self._time_and_run_task(self.get_prompt_info(chat_talking_prompt_short, sender, target), "prompt_info"), self._time_and_run_task(self.build_actions_prompt(available_actions, chosen_actions), "actions_info"), self._time_and_run_task(self.build_personality_prompt(), "personality_prompt"), + self._time_and_run_task(self.build_mood_state_prompt(), "mood_state_prompt"), + self._time_and_run_task(self.build_question_block(), "question_block"), ) # 任务名称中英文映射 @@ -719,10 +709,13 @@ class DefaultReplyer: "expression_habits": "选取表达方式", "relation_info": "感受关系", # "memory_block": "回忆", + "memory_block": "记忆", "tool_info": "使用工具", "prompt_info": "获取知识", "actions_info": "动作信息", "personality_prompt": "人格信息", + "mood_state_prompt": "情绪状态", + "question_block": "问题", } # 处理结果 @@ -747,11 +740,14 @@ class DefaultReplyer: selected_expressions: List[int] # relation_info: str = results_dict["relation_info"] # memory_block: str = results_dict["memory_block"] + memory_block: str = results_dict["memory_block"] tool_info: str = results_dict["tool_info"] prompt_info: str = results_dict["prompt_info"] # 直接使用格式化后的结果 actions_info: str = results_dict["actions_info"] personality_prompt: str = results_dict["personality_prompt"] + question_block: str = results_dict["question_block"] keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) + mood_state_prompt: str = results_dict["mood_state_prompt"] if extra_info: extra_info_block = f"以下是你在回复时需要参考的信息，现在请你阅读以下内容，进行决策\n{extra_info}\n以上是你在回复时需要参考的信息，现在请你阅读以下内容，进行决策" @@ -763,63 +759,49 @@ class DefaultReplyer: moderation_prompt_block = "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。" if sender: - if is_group_chat: - reply_target_block = ( - f"现在{sender}说的:{target}。引起了你的注意" - ) - else: # private chat - reply_target_block = ( - f"现在{sender}说的:{target}。引起了你的注意" - ) + # 使用预先分析的内容类型结果 + if has_only_pics and not has_text: + # 只包含图片 + reply_target_block = f"现在{sender}发送的图片：{pic_part}。引起了你的注意" + elif has_text and pic_part: + # 既有图片又有文字 + reply_target_block = f"现在{sender}发送了图片：{pic_part}，并说：{text_part}。引起了你的注意" + elif has_text: + # 只包含文字 + reply_target_block = f"现在{sender}说的：{text_part}。引起了你的注意" + else: + # 其他情况（空内容等） + reply_target_block = f"现在{sender}说的：{target}。引起了你的注意" else: reply_target_block = "" # 构建分离的对话 prompt - core_dialogue_prompt, background_dialogue_prompt = self.build_s4u_chat_history_prompts( + core_dialogue_prompt, background_dialogue_prompt = self.build_chat_history_prompts( message_list_before_now_long, user_id, sender ) - if global_config.bot.qq_account == user_id and platform == global_config.bot.platform: - return await global_prompt_manager.format_prompt( - "replyer_self_prompt", - expression_habits_block=expression_habits_block, - tool_info_block=tool_info, - knowledge_prompt=prompt_info, - # memory_block=memory_block, - # relation_info_block=relation_info, - extra_info_block=extra_info_block, - identity=personality_prompt, - action_descriptions=actions_info, - mood_state=mood_prompt, - background_dialogue_prompt=background_dialogue_prompt, - time_block=time_block, - target=target, - reason=reply_reason, - reply_style=global_config.personality.reply_style, - keywords_reaction_prompt=keywords_reaction_prompt, - moderation_prompt=moderation_prompt_block, - ), selected_expressions - else: - return await global_prompt_manager.format_prompt( - "replyer_prompt", - expression_habits_block=expression_habits_block, - tool_info_block=tool_info, - knowledge_prompt=prompt_info, - # memory_block=memory_block, - # relation_info_block=relation_info, - extra_info_block=extra_info_block, - identity=personality_prompt, - action_descriptions=actions_info, - sender_name=sender, - mood_state=mood_prompt, - background_dialogue_prompt=background_dialogue_prompt, - time_block=time_block, - core_dialogue_prompt=core_dialogue_prompt, - reply_target_block=reply_target_block, - reply_style=global_config.personality.reply_style, - keywords_reaction_prompt=keywords_reaction_prompt, - moderation_prompt=moderation_prompt_block, - ), selected_expressions + return await global_prompt_manager.format_prompt( + "replyer_prompt", + expression_habits_block=expression_habits_block, + tool_info_block=tool_info, + memory_block=memory_block, + knowledge_prompt=prompt_info, + mood_state=mood_state_prompt, + # memory_block=memory_block, + # relation_info_block=relation_info, + extra_info_block=extra_info_block, + identity=personality_prompt, + action_descriptions=actions_info, + sender_name=sender, + background_dialogue_prompt=background_dialogue_prompt, + time_block=time_block, + core_dialogue_prompt=core_dialogue_prompt, + reply_target_block=reply_target_block, + reply_style=global_config.personality.reply_style, + keywords_reaction_prompt=keywords_reaction_prompt, + moderation_prompt=moderation_prompt_block, + question_block=question_block, + ), selected_expressions async def build_prompt_rewrite_context( self, @@ -833,14 +815,12 @@ class DefaultReplyer: sender, target = self._parse_reply_target(reply_to) target = replace_user_references(target, chat_stream.platform, replace_bot_name=True) - target = re.sub(r"\\[picid:[^\\]]+\\]", "[图片]", target) - - # 添加情绪状态获取 - if global_config.mood.enable_mood: - chat_mood = mood_manager.get_mood_by_chat_id(chat_id) - mood_prompt = chat_mood.mood_state - else: - mood_prompt = "" + + # 在picid替换之前分析内容类型（防止prompt注入） + has_only_pics, has_text, pic_part, text_part = self._analyze_target_content(target) + + # 将[picid:xxx]替换为具体的图片描述 + target = self._replace_picids_with_descriptions(target) message_list_before_now_half = get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, @@ -858,7 +838,6 @@ class DefaultReplyer: # 并行执行2个构建任务 (expression_habits_block, _), personality_prompt = await asyncio.gather( self.build_expression_habits(chat_talking_prompt_half, target), - # self.build_relation_info(chat_talking_prompt_half, sender, []), self.build_personality_prompt(), ) @@ -871,18 +850,39 @@ class DefaultReplyer: ) if sender and target: + # 使用预先分析的内容类型结果 if is_group_chat: if sender: - reply_target_block = ( - f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。" - ) + if has_only_pics and not has_text: + # 只包含图片 + reply_target_block = ( + f"现在{sender}发送的图片：{pic_part}。引起了你的注意，你想要在群里发言或者回复这条消息。" + ) + elif has_text and pic_part: + # 既有图片又有文字 + reply_target_block = ( + f"现在{sender}发送了图片：{pic_part}，并说：{text_part}。引起了你的注意，你想要在群里发言或者回复这条消息。" + ) + else: + # 只包含文字 + reply_target_block = ( + f"现在{sender}说的:{text_part}。引起了你的注意，你想要在群里发言或者回复这条消息。" + ) elif target: reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。" else: reply_target_block = "现在，你想要在群里发言或者回复消息。" else: # private chat if sender: - reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。" + if has_only_pics and not has_text: + # 只包含图片 + reply_target_block = f"现在{sender}发送的图片：{pic_part}。引起了你的注意，针对这条消息回复。" + elif has_text and pic_part: + # 既有图片又有文字 + reply_target_block = f"现在{sender}发送了图片：{pic_part}，并说：{text_part}。引起了你的注意，针对这条消息回复。" + else: + # 只包含文字 + reply_target_block = f"现在{sender}说的:{text_part}。引起了你的注意，针对这条消息回复。" elif target: reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。" else: @@ -918,7 +918,6 @@ class DefaultReplyer: reply_target_block=reply_target_block, raw_reply=raw_reply, reason=reason, - mood_state=mood_prompt, # 添加情绪状态参数 reply_style=global_config.personality.reply_style, keywords_reaction_prompt=keywords_reaction_prompt, moderation_prompt=moderation_prompt_block, @@ -966,13 +965,13 @@ class DefaultReplyer: if global_config.debug.show_prompt: logger.info(f"\n{prompt}\n") else: - logger.debug(f"\n{prompt}\n") + logger.debug(f"\nreplyer_Prompt:{prompt}\n") content, (reasoning_content, model_name, tool_calls) = await self.express_model.generate_response_async( prompt ) - logger.debug(f"replyer生成内容: {content}") + logger.info(f"使用 {model_name} 生成回复内容: {content}") return content, reasoning_content, model_name, tool_calls async def get_prompt_info(self, message: str, sender: str, target: str): @@ -1059,6 +1058,3 @@ def weighted_sample_no_replacement(items, weights, k) -> list: pool.pop(idx) break return selected - - - diff --git a/src/chat/replyer/private_generator.py b/src/chat/replyer/private_generator.py index e4a9ade0..c7702bbb 100644 --- a/src/chat/replyer/private_generator.py +++ b/src/chat/replyer/private_generator.py @@ -6,7 +6,7 @@ import re from typing import List, Optional, Dict, Any, Tuple from datetime import datetime -from src.mais4u.mai_think import mai_thinking_manager +from src.memory_system.Memory_chest import global_memory_chest from src.common.logger import get_logger from src.common.data_models.database_data_model import DatabaseMessages from src.common.data_models.info_data_model import ActionPlannerInfo @@ -24,10 +24,12 @@ from src.chat.utils.chat_message_builder import ( get_raw_msg_before_timestamp_with_chat, replace_user_references, ) -from src.chat.express.expression_selector import expression_selector - -# from src.chat.memory_system.memory_activator import MemoryActivator +from src.express.expression_selector import expression_selector +from src.plugin_system.apis.message_api import translate_pid_to_description from src.mood.mood_manager import mood_manager + +# from src.memory_system.memory_activator import MemoryActivator + from src.person_info.person_info import Person, is_person_known from src.plugin_system.base.component_types import ActionInfo, EventType from src.plugin_system.apis import llm_api @@ -69,6 +71,7 @@ class PrivateReplyer: from_plugin: bool = True, stream_id: Optional[str] = None, reply_message: Optional[DatabaseMessages] = None, + reply_time_point: Optional[float] = time.time(), ) -> Tuple[bool, LLMGenerationDataModel]: # sourcery skip: merge-nested-ifs """ @@ -253,8 +256,8 @@ class PrivateReplyer: return "", [] style_habits = [] # 使用从处理器传来的选中表达方式 - # LLM模式：调用LLM选择5-10个，然后随机选5个 - selected_expressions, selected_ids = await expression_selector.select_suitable_expressions_llm( + # 根据配置模式选择表达方式：exp_model模式直接使用模型预测，classic模式使用LLM选择 + selected_expressions, selected_ids = await expression_selector.select_suitable_expressions( self.chat_stream.stream_id, chat_history, max_num=8, target_message=target ) @@ -280,38 +283,22 @@ class PrivateReplyer: return f"{expression_habits_title}\n{expression_habits_block}", selected_ids - # async def build_memory_block(self, chat_history: List[DatabaseMessages], target: str) -> str: - # """构建记忆块 + async def build_mood_state_prompt(self) -> str: + """构建情绪状态提示""" + if not global_config.mood.enable_mood: + return "" + mood_state = await mood_manager.get_mood_by_chat_id(self.chat_stream.stream_id).get_mood() + return f"你现在的心情是：{mood_state}" - # Args: - # chat_history: 聊天历史记录 - # target: 目标消息内容 - - # Returns: - # str: 记忆信息字符串 - # """ - - # if not global_config.memory.enable_memory: - # return "" - - # instant_memory = None - - # running_memories = await self.memory_activator.activate_memory_with_chat_history( - # target_message=target, chat_history=chat_history - # ) - # if not running_memories: - # return "" - - # memory_str = "以下是当前在聊天中，你回忆起的记忆：\n" - # for running_memory in running_memories: - # keywords, content = running_memory - # memory_str += f"- {keywords}：{content}\n" - - # if instant_memory: - # memory_str += f"- {instant_memory}\n" - - # return memory_str + async def build_memory_block(self) -> str: + """构建记忆块 + """ + if global_memory_chest.get_chat_memories_as_string(self.chat_stream.stream_id): + return f"你有以下记忆：\n{global_memory_chest.get_chat_memories_as_string(self.chat_stream.stream_id)}" + else: + return "" + async def build_tool_info(self, chat_history: str, sender: str, target: str, enable_tool: bool = True) -> str: """构建工具信息块 @@ -376,6 +363,64 @@ class PrivateReplyer: target = parts[1].strip() return sender, target + def _replace_picids_with_descriptions(self, text: str) -> str: + """将文本中的[picid:xxx]替换为具体的图片描述 + + Args: + text: 包含picid标记的文本 + + Returns: + 替换后的文本 + """ + # 匹配 [picid:xxxxx] 格式 + pic_pattern = r"\[picid:([^\]]+)\]" + + def replace_pic_id(match: re.Match) -> str: + pic_id = match.group(1) + description = translate_pid_to_description(pic_id) + return f"[图片：{description}]" + + return re.sub(pic_pattern, replace_pic_id, text) + + def _analyze_target_content(self, target: str) -> Tuple[bool, bool, str, str]: + """分析target内容类型（基于原始picid格式） + + Args: + target: 目标消息内容（包含[picid:xxx]格式） + + Returns: + Tuple[bool, bool, str, str]: (是否只包含图片, 是否包含文字, 图片部分, 文字部分) + """ + if not target or not target.strip(): + return False, False, "", "" + + # 检查是否只包含picid标记 + picid_pattern = r"\[picid:[^\]]+\]" + picid_matches = re.findall(picid_pattern, target) + + # 移除所有picid标记后检查是否还有文字内容 + text_without_picids = re.sub(picid_pattern, "", target).strip() + + has_only_pics = len(picid_matches) > 0 and not text_without_picids + has_text = bool(text_without_picids) + + # 提取图片部分（转换为[图片:描述]格式） + pic_part = "" + if picid_matches: + pic_descriptions = [] + for picid_match in picid_matches: + pic_id = picid_match[7:-1] # 提取picid:xxx中的xxx部分（从第7个字符开始） + description = translate_pid_to_description(pic_id) + logger.debug(f"图片ID: {pic_id}, 描述: {description}") + # 如果description已经是[图片]格式，直接使用；否则包装为[图片:描述]格式 + if description == "[图片]": + pic_descriptions.append(description) + else: + pic_descriptions.append(f"[图片:{description}]") + pic_part = "".join(pic_descriptions) + + return has_only_pics, has_text, pic_part, text_without_picids + async def build_keywords_reaction_prompt(self, target: Optional[str]) -> str: """构建关键词反应提示 @@ -521,13 +566,15 @@ class PrivateReplyer: sender = person_name target = reply_message.processed_plain_text - mood_prompt: str = "" - if global_config.mood.enable_mood: - chat_mood = mood_manager.get_mood_by_chat_id(chat_id) - mood_prompt = chat_mood.mood_state + target = replace_user_references(target, chat_stream.platform, replace_bot_name=True) - target = re.sub(r"\\[picid:[^\\]]+\\]", "[图片]", target) + + # 在picid替换之前分析内容类型（防止prompt注入） + has_only_pics, has_text, pic_part, text_part = self._analyze_target_content(target) + + # 将[picid:xxx]替换为具体的图片描述 + target = self._replace_picids_with_descriptions(target) message_list_before_now_long = get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, @@ -566,8 +613,8 @@ class PrivateReplyer: if person.is_known: person_list_short.append(person) - for person in person_list_short: - print(person.person_name) + # for person in person_list_short: + # print(person.person_name) chat_talking_prompt_short = build_readable_messages( message_list_before_short, @@ -585,6 +632,7 @@ class PrivateReplyer: self._time_and_run_task( self.build_relation_info(chat_talking_prompt_short, sender), "relation_info" ), + self._time_and_run_task(self.build_memory_block(), "memory_block"), # self._time_and_run_task(self.build_memory_block(message_list_before_short, target), "memory_block"), self._time_and_run_task( self.build_tool_info(chat_talking_prompt_short, sender, target, enable_tool=enable_tool), "tool_info" @@ -592,17 +640,19 @@ class PrivateReplyer: self._time_and_run_task(self.get_prompt_info(chat_talking_prompt_short, sender, target), "prompt_info"), self._time_and_run_task(self.build_actions_prompt(available_actions, chosen_actions), "actions_info"), self._time_and_run_task(self.build_personality_prompt(), "personality_prompt"), + self._time_and_run_task(self.build_mood_state_prompt(), "mood_state_prompt"), ) # 任务名称中英文映射 task_name_mapping = { "expression_habits": "选取表达方式", "relation_info": "感受关系", - # "memory_block": "回忆", + "memory_block": "回忆", "tool_info": "使用工具", "prompt_info": "获取知识", "actions_info": "动作信息", "personality_prompt": "人格信息", + "mood_state_prompt": "情绪状态", } # 处理结果 @@ -626,11 +676,12 @@ class PrivateReplyer: expression_habits_block: str selected_expressions: List[int] relation_info: str = results_dict["relation_info"] - # memory_block: str = results_dict["memory_block"] + memory_block: str = results_dict["memory_block"] tool_info: str = results_dict["tool_info"] prompt_info: str = results_dict["prompt_info"] # 直接使用格式化后的结果 actions_info: str = results_dict["actions_info"] personality_prompt: str = results_dict["personality_prompt"] + mood_state_prompt: str = results_dict["mood_state_prompt"] keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) if extra_info: @@ -642,9 +693,19 @@ class PrivateReplyer: moderation_prompt_block = "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。" - reply_target_block = ( - f"现在对方说的:{target}。引起了你的注意" - ) + # 使用预先分析的内容类型结果 + if has_only_pics and not has_text: + # 只包含图片 + reply_target_block = f"现在对方发送的图片：{pic_part}。引起了你的注意" + elif has_text and pic_part: + # 既有图片又有文字 + reply_target_block = f"现在对方发送了图片：{pic_part}，并说：{text_part}。引起了你的注意" + elif has_text: + # 只包含文字 + reply_target_block = f"现在对方说的：{text_part}。引起了你的注意" + else: + # 其他情况（空内容等） + reply_target_block = f"现在对方说的:{target}。引起了你的注意" if global_config.bot.qq_account == user_id and platform == global_config.bot.platform: return await global_prompt_manager.format_prompt( @@ -652,12 +713,12 @@ class PrivateReplyer: expression_habits_block=expression_habits_block, tool_info_block=tool_info, knowledge_prompt=prompt_info, - # memory_block=memory_block, + mood_state=mood_state_prompt, + memory_block=memory_block, relation_info_block=relation_info, extra_info_block=extra_info_block, identity=personality_prompt, action_descriptions=actions_info, - mood_state=mood_prompt, dialogue_prompt=dialogue_prompt, time_block=time_block, target=target, @@ -673,12 +734,12 @@ class PrivateReplyer: expression_habits_block=expression_habits_block, tool_info_block=tool_info, knowledge_prompt=prompt_info, - # memory_block=memory_block, + mood_state=mood_state_prompt, + memory_block=memory_block, relation_info_block=relation_info, extra_info_block=extra_info_block, identity=personality_prompt, action_descriptions=actions_info, - mood_state=mood_prompt, dialogue_prompt=dialogue_prompt, time_block=time_block, reply_target_block=reply_target_block, @@ -700,14 +761,14 @@ class PrivateReplyer: sender, target = self._parse_reply_target(reply_to) target = replace_user_references(target, chat_stream.platform, replace_bot_name=True) - target = re.sub(r"\\[picid:[^\\]]+\\]", "[图片]", target) + + # 在picid替换之前分析内容类型（防止prompt注入） + has_only_pics, has_text, pic_part, text_part = self._analyze_target_content(target) + + # 将[picid:xxx]替换为具体的图片描述 + target = self._replace_picids_with_descriptions(target) + - # 添加情绪状态获取 - if global_config.mood.enable_mood: - chat_mood = mood_manager.get_mood_by_chat_id(chat_id) - mood_prompt = chat_mood.mood_state - else: - mood_prompt = "" message_list_before_now_half = get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, @@ -738,18 +799,39 @@ class PrivateReplyer: ) if sender and target: + # 使用预先分析的内容类型结果 if is_group_chat: if sender: - reply_target_block = ( - f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。" - ) + if has_only_pics and not has_text: + # 只包含图片 + reply_target_block = ( + f"现在{sender}发送的图片：{pic_part}。引起了你的注意，你想要在群里发言或者回复这条消息。" + ) + elif has_text and pic_part: + # 既有图片又有文字 + reply_target_block = ( + f"现在{sender}发送了图片：{pic_part}，并说：{text_part}。引起了你的注意，你想要在群里发言或者回复这条消息。" + ) + else: + # 只包含文字 + reply_target_block = ( + f"现在{sender}说的:{text_part}。引起了你的注意，你想要在群里发言或者回复这条消息。" + ) elif target: reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。" else: reply_target_block = "现在，你想要在群里发言或者回复消息。" else: # private chat if sender: - reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。" + if has_only_pics and not has_text: + # 只包含图片 + reply_target_block = f"现在{sender}发送的图片：{pic_part}。引起了你的注意，针对这条消息回复。" + elif has_text and pic_part: + # 既有图片又有文字 + reply_target_block = f"现在{sender}发送了图片：{pic_part}，并说：{text_part}。引起了你的注意，针对这条消息回复。" + else: + # 只包含文字 + reply_target_block = f"现在{sender}说的:{text_part}。引起了你的注意，针对这条消息回复。" elif target: reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。" else: @@ -785,7 +867,6 @@ class PrivateReplyer: reply_target_block=reply_target_block, raw_reply=raw_reply, reason=reason, - mood_state=mood_prompt, # 添加情绪状态参数 reply_style=global_config.personality.reply_style, keywords_reaction_prompt=keywords_reaction_prompt, moderation_prompt=moderation_prompt_block, @@ -839,7 +920,7 @@ class PrivateReplyer: prompt ) - logger.debug(f"replyer生成内容: {content}") + logger.info(f"使用 {model_name} 生成回复内容: {content}") return content, reasoning_content, model_name, tool_calls async def get_prompt_info(self, message: str, sender: str, target: str): diff --git a/src/chat/replyer/prompt/lpmm_prompt.py b/src/chat/replyer/prompt/lpmm_prompt.py index d5d02664..43eb41f2 100644 --- a/src/chat/replyer/prompt/lpmm_prompt.py +++ b/src/chat/replyer/prompt/lpmm_prompt.py @@ -1,7 +1,5 @@ - from src.chat.utils.prompt_builder import Prompt -# from src.chat.memory_system.memory_activator import MemoryActivator - +# from src.memory_system.memory_activator import MemoryActivator def init_lpmm_prompt(): @@ -20,5 +18,3 @@ If you need to use the search tool, please directly call the function "lpmm_sear """, name="lpmm_get_knowledge_prompt", ) - - diff --git a/src/chat/replyer/prompt/replyer_prompt.py b/src/chat/replyer/prompt/replyer_prompt.py index 44423362..d8f59e91 100644 --- a/src/chat/replyer/prompt/replyer_prompt.py +++ b/src/chat/replyer/prompt/replyer_prompt.py @@ -13,7 +13,7 @@ def init_replyer_prompt(): Prompt( """{knowledge_prompt}{tool_info_block}{extra_info_block} -{expression_habits_block} +{expression_habits_block}{memory_block}{question_block} 你正在qq群里聊天，下面是群里正在聊的内容: {time_block} @@ -22,40 +22,19 @@ def init_replyer_prompt(): {reply_target_block}。 {identity} -你正在群里聊天,现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些， +你正在群里聊天,现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些，{mood_state} 尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。 {reply_style} -请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 -{moderation_prompt}不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。""", +请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出一句回复内容就好。 +{moderation_prompt}不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。 +现在，你说：""", "replyer_prompt", ) - - - - Prompt( - """{knowledge_prompt}{tool_info_block}{extra_info_block} -{expression_habits_block} - -你正在qq群里聊天，下面是群里正在聊的内容: -{time_block} -{background_dialogue_prompt} - -你现在想补充说明你刚刚自己的发言内容：{target}，原因是{reason} -请你根据聊天内容，组织一条新回复。注意，{target} 是刚刚你自己的发言，你要在这基础上进一步发言，请按照你自己的角度来继续进行回复。注意保持上下文的连贯性。 -{identity} -尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。 -{reply_style} -请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 -{moderation_prompt}不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。 -""", - "replyer_self_prompt", - ) - Prompt( """{knowledge_prompt}{tool_info_block}{extra_info_block} -{expression_habits_block} +{expression_habits_block}{memory_block} 你正在和{sender_name}聊天，这是你们之前聊的内容: {time_block} @@ -63,7 +42,7 @@ def init_replyer_prompt(): {reply_target_block}。 {identity} -你正在和{sender_name}聊天,现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些， +你正在和{sender_name}聊天,现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些，{mood_state} 尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。 {reply_style} 请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 @@ -74,19 +53,19 @@ def init_replyer_prompt(): Prompt( """{knowledge_prompt}{tool_info_block}{extra_info_block} -{expression_habits_block} +{expression_habits_block}{memory_block} 你正在和{sender_name}聊天，这是你们之前聊的内容: {time_block} {dialogue_prompt} 你现在想补充说明你刚刚自己的发言内容：{target}，原因是{reason} -请你根据聊天内容，组织一条新回复。注意，{target} 是刚刚你自己的发言，你要在这基础上进一步发言，请按照你自己的角度来继续进行回复。注意保持上下文的连贯性。 +请你根据聊天内容，组织一条新回复。注意，{target} 是刚刚你自己的发言，你要在这基础上进一步发言，请按照你自己的角度来继续进行回复。注意保持上下文的连贯性。{mood_state} {identity} 尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。 {reply_style} 请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 -{moderation_prompt}不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。 +{moderation_prompt}不要输出多余内容(包括冒号和引号，括号，表情包，at或 @等 )。 """, "private_replyer_self_prompt", ) \ No newline at end of file diff --git a/src/chat/replyer/prompt/rewrite_prompt.py b/src/chat/replyer/prompt/rewrite_prompt.py index 187eddf9..c574de4a 100644 --- a/src/chat/replyer/prompt/rewrite_prompt.py +++ b/src/chat/replyer/prompt/rewrite_prompt.py @@ -1,7 +1,5 @@ - from src.chat.utils.prompt_builder import Prompt -# from src.chat.memory_system.memory_activator import MemoryActivator - +# from src.memory_system.memory_activator import MemoryActivator def init_rewrite_prompt(): @@ -14,13 +12,11 @@ def init_rewrite_prompt(): """ {expression_habits_block} {chat_target} -{time_block} {chat_info} {identity} -你现在的心情是：{mood_state} 你正在{chat_target_2},{reply_target_block} -你想要对上述的发言进行回复，回复的具体内容（原句）是：{raw_reply} +现在请你对这句内容进行改写，请你参考上述内容进行改写，原句是：{raw_reply}： 原因是：{reason} 现在请你将这条具体内容改写成一条适合在群聊中发送的回复消息。 你需要使用合适的语法和句法，参考聊天内容，组织一条日常且口语化的回复。请你修改你想表达的原句，符合你的表达风格和语言习惯 @@ -28,8 +24,8 @@ def init_rewrite_prompt(): 你可以完全重组回复，保留最基本的表达含义就好，但重组后保持语意通顺。 {keywords_reaction_prompt} {moderation_prompt} -不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，emoji,at或 @等 )，只输出一条回复就好。 -现在，你说： +不要输出多余内容(包括冒号和引号，表情包，emoji,at或 @等 )，只输出一条回复就好。 +改写后的回复： """, "default_expressor_prompt", - ) \ No newline at end of file + ) diff --git a/src/chat/utils/chat_message_builder.py b/src/chat/utils/chat_message_builder.py index 1bd72c85..52559ecb 100644 --- a/src/chat/utils/chat_message_builder.py +++ b/src/chat/utils/chat_message_builder.py @@ -2,7 +2,7 @@ import time import random import re -from typing import List, Dict, Any, Tuple, Optional, Callable +from typing import List, Dict, Any, Tuple, Optional, Callable, Iterable from rich.traceback import install from src.config.config import global_config @@ -124,6 +124,7 @@ def get_raw_msg_by_timestamp_with_chat( # 只有当 limit 为 0 时才应用外部 sort sort_order = [("time", 1)] if limit == 0 else None # 直接将 limit_mode 传递给 find_messages + # print(f"get_raw_msg_by_timestamp_with_chat: {chat_id}, {timestamp_start}, {timestamp_end}, {limit}, {limit_mode}, {filter_bot}, {filter_command}") return find_messages( message_filter=filter_query, sort=sort_order, @@ -215,6 +216,7 @@ def get_actions_by_timestamp_with_chat( chat_id=action.chat_id, chat_info_stream_id=action.chat_info_stream_id, chat_info_platform=action.chat_info_platform, + action_reasoning=action.action_reasoning, ) for action in actions ] @@ -417,12 +419,6 @@ def _build_readable_messages_internal( timestamp = message.time content = message.display_message or message.processed_plain_text or "" - # 向下兼容 - if "ᶠ" in content: - content = content.replace("ᶠ", "") - if "ⁿ" in content: - content = content.replace("ⁿ", "") - # 处理图片ID if show_pic: content = process_pic_ids(content) @@ -564,14 +560,12 @@ def build_readable_actions(actions: List[DatabaseActionRecords], mode: str = "re output_lines = [] current_time = time.time() - # The get functions return actions sorted ascending by time. Let's reverse it to show newest first. - # sorted_actions = sorted(actions, key=lambda x: x.get("time", 0), reverse=True) for action in actions: action_time = action.time or current_time action_name = action.action_name or "未知动作" # action_reason = action.get(action_data") - if action_name in ["no_action", "no_action"]: + if action_name in ["no_reply", "no_reply"]: continue action_prompt_display = action.action_prompt_display or "无具体内容" @@ -593,6 +587,7 @@ def build_readable_actions(actions: List[DatabaseActionRecords], mode: str = "re line = f"{time_ago_str}，你使用了“{action_name}”，具体内容是：“{action_prompt_display}”" output_lines.append(line) + return "\n".join(output_lines) @@ -628,6 +623,7 @@ def build_readable_messages_with_id( truncate: bool = False, show_actions: bool = False, show_pic: bool = True, + remove_emoji_stickers: bool = False, ) -> Tuple[str, List[Tuple[str, DatabaseMessages]]]: """ 将消息列表转换为可读的文本格式，并返回原始(时间戳, 昵称, 内容)列表。 @@ -644,6 +640,7 @@ def build_readable_messages_with_id( show_pic=show_pic, read_mark=read_mark, message_id_list=message_id_list, + remove_emoji_stickers=remove_emoji_stickers, ) return formatted_string, message_id_list @@ -658,6 +655,7 @@ def build_readable_messages( show_actions: bool = False, show_pic: bool = True, message_id_list: Optional[List[Tuple[str, DatabaseMessages]]] = None, + remove_emoji_stickers: bool = False, ) -> str: # sourcery skip: extract-method """ 将消息列表转换为可读的文本格式。 @@ -672,13 +670,40 @@ def build_readable_messages( read_mark: 已读标记时间戳 truncate: 是否截断长消息 show_actions: 是否显示动作记录 + remove_emoji_stickers: 是否移除表情包并过滤空消息 """ # WIP HERE and BELOW ---------------------------------------------- # 创建messages的深拷贝，避免修改原始列表 if not messages: return "" - copy_messages: List[MessageAndActionModel] = [MessageAndActionModel.from_DatabaseMessages(msg) for msg in messages] + # 如果启用移除表情包，先过滤消息 + if remove_emoji_stickers: + filtered_messages = [] + for msg in messages: + # 获取消息内容 + content = msg.processed_plain_text + # 移除表情包 + emoji_pattern = r"\[表情包：[^\]]+\]" + content = re.sub(emoji_pattern, "", content) + + # 如果移除表情包后内容不为空，则保留消息 + if content.strip(): + filtered_messages.append(msg) + + messages = filtered_messages + + copy_messages: List[MessageAndActionModel] = [] + for msg in messages: + if remove_emoji_stickers: + # 创建 MessageAndActionModel 但移除表情包 + model = MessageAndActionModel.from_DatabaseMessages(msg) + # 移除表情包 + if model.processed_plain_text: + model.processed_plain_text = re.sub(r"\[表情包：[^\]]+\]", "", model.processed_plain_text) + copy_messages.append(model) + else: + copy_messages.append(MessageAndActionModel.from_DatabaseMessages(msg)) if show_actions and copy_messages: # 获取所有消息的时间范围 @@ -862,17 +887,9 @@ async def build_anonymous_messages(messages: List[DatabaseMessages]) -> str: user_id = msg.user_info.user_id content = msg.display_message or msg.processed_plain_text or "" - if "ᶠ" in content: - content = content.replace("ᶠ", "") - if "ⁿ" in content: - content = content.replace("ⁿ", "") - # 处理图片ID content = process_pic_ids(content) - # if not all([platform, user_id, timestamp is not None]): - # continue - anon_name = get_anon_name(platform, user_id) # print(f"anon_name:{anon_name}") @@ -909,6 +926,7 @@ async def build_anonymous_messages(messages: List[DatabaseMessages]) -> str: return formatted_string + async def get_person_id_list(messages: List[Dict[str, Any]]) -> List[str]: """ 从消息列表中提取不重复的 person_id 列表 (忽略机器人自身)。 @@ -937,3 +955,45 @@ async def get_person_id_list(messages: List[Dict[str, Any]]) -> List[str]: person_ids_set.add(person_id) return list(person_ids_set) # 将集合转换为列表返回 + + +async def build_bare_messages(messages: List[DatabaseMessages]) -> str: + """ + 构建简化版消息字符串，只包含processed_plain_text内容，不考虑用户名和时间戳 + + Args: + messages: 消息列表 + + Returns: + 只包含消息内容的字符串 + """ + if not messages: + return "" + + output_lines = [] + + for msg in messages: + # 获取纯文本内容 + content = msg.processed_plain_text or "" + + # 处理图片ID + pic_pattern = r"\[picid:[^\]]+\]" + + def replace_pic_id(match): + return "[图片]" + + content = re.sub(pic_pattern, replace_pic_id, content) + + # 处理用户引用格式，移除回复和@标记 + reply_pattern = r"回复<[^:<>]+:[^:<>]+>" + content = re.sub(reply_pattern, "回复[某人]", content) + + at_pattern = r"@<[^:<>]+:[^:<>]+>" + content = re.sub(at_pattern, "@[某人]", content) + + # 清理并添加到输出 + content = content.strip() + if content: + output_lines.append(content) + + return "\n".join(output_lines) diff --git a/src/chat/utils/prompt_builder.py b/src/chat/utils/prompt_builder.py index 1b107904..8b706b20 100644 --- a/src/chat/utils/prompt_builder.py +++ b/src/chat/utils/prompt_builder.py @@ -151,7 +151,7 @@ class Prompt(str): @staticmethod def _process_escaped_braces(template) -> str: - """处理模板中的转义花括号，将 \{ 和 \} 替换为临时标记""" # type: ignore + """处理模板中的转义花括号,替换为临时标记""" # type: ignore # 如果传入的是列表，将其转换为字符串 if isinstance(template, list): template = "\n".join(str(item) for item in template) diff --git a/src/chat/utils/utils.py b/src/chat/utils/utils.py index 2fb24245..240ce609 100644 --- a/src/chat/utils/utils.py +++ b/src/chat/utils/utils.py @@ -383,10 +383,6 @@ def calculate_typing_time( - 在所有输入结束后，额外加上回车时间0.3秒 - 如果is_emoji为True，将使用固定1秒的输入时间 """ - # # 将0-1的唤醒度映射到-1到1 - # mood_arousal = mood_manager.current_mood.arousal - # # 映射到0.5到2倍的速度系数 - # typing_speed_multiplier = 1.5**mood_arousal # 唤醒度为1时速度翻倍,为-1时速度减半 # chinese_time *= 1 / typing_speed_multiplier # english_time *= 1 / typing_speed_multiplier # 计算中文字符数 diff --git a/src/chat/utils/utils_image.py b/src/chat/utils/utils_image.py index 94565b78..deba60a4 100644 --- a/src/chat/utils/utils_image.py +++ b/src/chat/utils/utils_image.py @@ -623,3 +623,41 @@ def image_path_to_base64(image_path: str) -> str: return base64.b64encode(image_data).decode("utf-8") else: raise IOError(f"读取图片文件失败: {image_path}") + + +def base64_to_image(image_base64: str, output_path: str) -> bool: + """将base64编码的图片保存为文件 + + Args: + image_base64: 图片的base64编码 + output_path: 输出文件路径 + + Returns: + bool: 是否成功保存 + + Raises: + ValueError: 当base64编码无效时 + IOError: 当保存文件失败时 + """ + try: + # 确保base64字符串只包含ASCII字符 + if isinstance(image_base64, str): + image_base64 = image_base64.encode("ascii", errors="ignore").decode("ascii") + + # 解码base64 + image_bytes = base64.b64decode(image_base64) + + # 确保输出目录存在 + output_dir = os.path.dirname(output_path) + if output_dir: + os.makedirs(output_dir, exist_ok=True) + + # 保存文件 + with open(output_path, "wb") as f: + f.write(image_bytes) + + return True + + except Exception as e: + logger.error(f"保存base64图片失败: {e}") + return False diff --git a/src/common/data_models/database_data_model.py b/src/common/data_models/database_data_model.py index 18465b00..8b2e94c3 100644 --- a/src/common/data_models/database_data_model.py +++ b/src/common/data_models/database_data_model.py @@ -220,6 +220,7 @@ class DatabaseActionRecords(BaseDataModel): chat_id: str, chat_info_stream_id: str, chat_info_platform: str, + action_reasoning:str ): self.action_id = action_id self.time = time @@ -234,3 +235,4 @@ class DatabaseActionRecords(BaseDataModel): self.chat_id = chat_id self.chat_info_stream_id = chat_info_stream_id self.chat_info_platform = chat_info_platform + self.action_reasoning = action_reasoning \ No newline at end of file diff --git a/src/common/data_models/info_data_model.py b/src/common/data_models/info_data_model.py index 156f021c..24cbc640 100644 --- a/src/common/data_models/info_data_model.py +++ b/src/common/data_models/info_data_model.py @@ -24,3 +24,4 @@ class ActionPlannerInfo(BaseDataModel): action_message: Optional["DatabaseMessages"] = None available_actions: Optional[Dict[str, "ActionInfo"]] = None loop_start_time: Optional[float] = None + action_reasoning: Optional[str] = None diff --git a/src/common/data_models/llm_data_model.py b/src/common/data_models/llm_data_model.py index e8d57b41..2d2ee0c3 100644 --- a/src/common/data_models/llm_data_model.py +++ b/src/common/data_models/llm_data_model.py @@ -16,4 +16,4 @@ class LLMGenerationDataModel(BaseDataModel): tool_calls: Optional[List["ToolCall"]] = None prompt: Optional[str] = None selected_expressions: Optional[List[int]] = None - reply_set: Optional["ReplySetModel"] = None \ No newline at end of file + reply_set: Optional["ReplySetModel"] = None diff --git a/src/common/database/database.py b/src/common/database/database.py index ca361481..0fa26866 100644 --- a/src/common/database/database.py +++ b/src/common/database/database.py @@ -1,64 +1,9 @@ import os -from pymongo import MongoClient from peewee import SqliteDatabase -from pymongo.database import Database from rich.traceback import install install(extra_lines=3) -_client = None -_db = None - - -def __create_database_instance(): - uri = os.getenv("MONGODB_URI") - host = os.getenv("MONGODB_HOST", "127.0.0.1") - port = int(os.getenv("MONGODB_PORT", "27017")) - # db_name 变量在创建连接时不需要，在获取数据库实例时才使用 - username = os.getenv("MONGODB_USERNAME") - password = os.getenv("MONGODB_PASSWORD") - auth_source = os.getenv("MONGODB_AUTH_SOURCE") - - if uri: - # 支持标准mongodb://和mongodb+srv://连接字符串 - if uri.startswith(("mongodb://", "mongodb+srv://")): - return MongoClient(uri) - else: - raise ValueError( - "Invalid MongoDB URI format. URI must start with 'mongodb://' or 'mongodb+srv://'. " - "For MongoDB Atlas, use 'mongodb+srv://' format. " - "See: https://www.mongodb.com/docs/manual/reference/connection-string/" - ) - - if username and password: - # 如果有用户名和密码，使用认证连接 - return MongoClient(host, port, username=username, password=password, authSource=auth_source) - - # 否则使用无认证连接 - return MongoClient(host, port) - - -def get_db(): - """获取数据库连接实例，延迟初始化。""" - global _client, _db - if _client is None: - _client = __create_database_instance() - _db = _client[os.getenv("DATABASE_NAME", "MegBot")] - return _db - - -class DBWrapper: - """数据库代理类，保持接口兼容性同时实现懒加载。""" - - def __getattr__(self, name): - return getattr(get_db(), name) - - def __getitem__(self, key): - return get_db()[key] # type: ignore - - -# 全局数据库访问点 -memory_db: Database = DBWrapper() # type: ignore # 定义数据库文件路径 ROOT_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..")) diff --git a/src/common/database/database_model.py b/src/common/database/database_model.py index eff1eeee..89e0a019 100644 --- a/src/common/database/database_model.py +++ b/src/common/database/database_model.py @@ -185,6 +185,8 @@ class ActionRecords(BaseModel): action_id = TextField(index=True) # 消息 ID (更改自 IntegerField) time = DoubleField() # 消息时间戳 + action_reasoning = TextField(null=True) + action_name = TextField() action_data = TextField() action_done = BooleanField(default=False) @@ -301,46 +303,47 @@ class Expression(BaseModel): situation = TextField() style = TextField() - count = FloatField() + + # new mode fields + context = TextField(null=True) + up_content = TextField(null=True) + last_active_time = FloatField() chat_id = TextField(index=True) - type = TextField() create_date = FloatField(null=True) # 创建日期，允许为空以兼容老数据 class Meta: table_name = "expression" - -class GraphNodes(BaseModel): +class MemoryChest(BaseModel): """ - 用于存储记忆图节点的模型 + 用于存储记忆仓库的模型 """ - concept = TextField(unique=True, index=True) # 节点概念 - memory_items = TextField() # JSON格式存储的记忆列表 - weight = FloatField(default=0.0) # 节点权重 - hash = TextField() # 节点哈希值 - created_time = FloatField() # 创建时间戳 - last_modified = FloatField() # 最后修改时间戳 + title = TextField() # 标题 + content = TextField() # 内容 + chat_id = TextField(null=True) # 聊天ID + locked = BooleanField(default=False) # 是否锁定 class Meta: - table_name = "graph_nodes" + table_name = "memory_chest" - -class GraphEdges(BaseModel): +class MemoryConflict(BaseModel): """ - 用于存储记忆图边的模型 + 用于存储记忆整合过程中冲突内容的模型 """ - source = TextField(index=True) # 源节点 - target = TextField(index=True) # 目标节点 - strength = IntegerField() # 连接强度 - hash = TextField() # 边哈希值 - created_time = FloatField() # 创建时间戳 - last_modified = FloatField() # 最后修改时间戳 + conflict_content = TextField() # 冲突内容 + answer = TextField(null=True) # 回答内容 + create_time = FloatField() # 创建时间 + update_time = FloatField() # 更新时间 + context = TextField(null=True) # 上下文 + chat_id = TextField(null=True) # 聊天ID + raise_time = FloatField(null=True) # 触发次数 class Meta: - table_name = "graph_edges" + table_name = "memory_conflicts" + def create_tables(): @@ -359,9 +362,9 @@ def create_tables(): OnlineTime, PersonInfo, Expression, - GraphNodes, # 添加图节点表 - GraphEdges, # 添加图边表 ActionRecords, # 添加 ActionRecords 到初始化列表 + MemoryChest, + MemoryConflict, # 添加记忆冲突表 ] ) @@ -386,9 +389,9 @@ def initialize_database(sync_constraints=False): OnlineTime, PersonInfo, Expression, - GraphNodes, - GraphEdges, ActionRecords, # 添加 ActionRecords 到初始化列表 + MemoryChest, + MemoryConflict, ] try: @@ -483,9 +486,9 @@ def sync_field_constraints(): OnlineTime, PersonInfo, Expression, - GraphNodes, - GraphEdges, ActionRecords, + MemoryChest, + MemoryConflict, ] try: @@ -667,9 +670,9 @@ def check_field_constraints(): OnlineTime, PersonInfo, Expression, - GraphNodes, - GraphEdges, ActionRecords, + MemoryChest, + MemoryConflict, ] inconsistencies = {} @@ -725,11 +728,14 @@ def check_field_constraints(): logger.exception(f"检查字段约束时出错: {e}") return inconsistencies + + def fix_image_id(): """ 修复表情包的 image_id 字段 """ import uuid + try: with db: for img in Images.select(): @@ -740,6 +746,7 @@ def fix_image_id(): except Exception as e: logger.exception(f"修复 image_id 时出错: {e}") + # 模块加载时调用初始化函数 initialize_database(sync_constraints=True) -fix_image_id() \ No newline at end of file +fix_image_id() diff --git a/src/common/logger.py b/src/common/logger.py index f980064f..86c39f75 100644 --- a/src/common/logger.py +++ b/src/common/logger.py @@ -363,8 +363,8 @@ MODULE_COLORS = { "planner": "\033[36m", "relation": "\033[38;5;139m", # 柔和的紫色，不刺眼 # 聊天相关模块 - "normal_chat": "\033[38;5;81m", # 亮蓝绿色 - "heartflow": "\033[38;5;175m", # 柔和的粉色，不显眼但保持粉色系 + "hfc": "\033[38;5;175m", # 柔和的粉色，不显眼但保持粉色系 + "bc": "\033[38;5;175m", # 柔和的粉色，不显眼但保持粉色系 "sub_heartflow": "\033[38;5;207m", # 粉紫色 "subheartflow_manager": "\033[38;5;201m", # 深粉色 "background_tasks": "\033[38;5;240m", # 灰色 @@ -372,8 +372,6 @@ MODULE_COLORS = { "chat_stream": "\033[38;5;51m", # 亮青色 "message_storage": "\033[38;5;33m", # 深蓝色 "expressor": "\033[38;5;166m", # 橙色 - # 专注聊天模块 - "memory_activator": "\033[38;5;117m", # 天蓝色 # 插件系统 "plugins": "\033[31m", # 红色 "plugin_api": "\033[33m", # 黄色 @@ -408,7 +406,7 @@ MODULE_COLORS = { "tts_action": "\033[38;5;58m", # 深黄色 "doubao_pic_plugin": "\033[38;5;64m", # 深绿色 # Action组件 - "no_action_action": "\033[38;5;214m", # 亮橙色，显眼但不像警告 + "no_reply_action": "\033[38;5;214m", # 亮橙色，显眼但不像警告 "reply_action": "\033[38;5;46m", # 亮绿色 "base_action": "\033[38;5;250m", # 浅灰色 # 数据库和消息 @@ -421,9 +419,7 @@ MODULE_COLORS = { "model_utils": "\033[38;5;164m", # 紫红色 "relationship_fetcher": "\033[38;5;170m", # 浅紫色 "relationship_builder": "\033[38;5;93m", # 浅蓝色 - # s4u - "context_web_api": "\033[38;5;240m", # 深灰色 - "S4U_chat": "\033[92m", # 深灰色 + "conflict_tracker": "\033[38;5;82m", # 柔和的粉色，不显眼但保持粉色系 } # 定义模块别名映射 - 将真实的logger名称映射到显示的别名 diff --git a/src/common/message_repository.py b/src/common/message_repository.py index ab2eda32..fb9120ac 100644 --- a/src/common/message_repository.py +++ b/src/common/message_repository.py @@ -81,7 +81,8 @@ def find_messages( query = query.where(Messages.user_id != global_config.bot.qq_account) if filter_command: - query = query.where(not Messages.is_command) + # 使用按位取反构造 Peewee 的 NOT 条件，避免直接与 False 比较 + query = query.where(~Messages.is_command) if limit > 0: if limit_mode == "earliest": diff --git a/src/config/config.py b/src/config/config.py index 920a155c..e49d427d 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -18,7 +18,6 @@ from src.config.official_configs import ( ExpressionConfig, ChatConfig, EmojiConfig, - MoodConfig, KeywordReactionConfig, ChineseTypoConfig, ResponsePostProcessConfig, @@ -31,6 +30,8 @@ from src.config.official_configs import ( RelationshipConfig, ToolConfig, VoiceConfig, + MoodConfig, + MemoryConfig, DebugConfig, ) @@ -54,7 +55,7 @@ TEMPLATE_DIR = os.path.join(PROJECT_ROOT, "template") # 考虑到，实际上配置文件中的mai_version是不会自动更新的,所以采用硬编码 # 对该字段的更新，请严格参照语义化版本规范：https://semver.org/lang/zh-CN/ -MMC_VERSION = "0.10.3-snapshot.4" +MMC_VERSION = "0.11.0-snapshot.3" def get_key_comment(toml_table, key): @@ -173,13 +174,8 @@ def _update_dict(target: TOMLDocument | dict | Table, source: TOMLDocument | dic _update_dict(target_value, value) else: try: - # 对数组类型进行特殊处理 - if isinstance(value, list): - # 如果是空数组，确保它保持为空数组 - target[key] = tomlkit.array(str(value)) if value else tomlkit.array() - else: - # 其他类型使用item方法创建新值 - target[key] = tomlkit.item(value) + # 统一使用 tomlkit.item 来保持原生类型与转义，不对列表做字符串化处理 + target[key] = tomlkit.item(value) except (TypeError, ValueError): # 如果转换失败，直接赋值 target[key] = value @@ -345,7 +341,6 @@ class Config(ConfigBase): message_receive: MessageReceiveConfig emoji: EmojiConfig expression: ExpressionConfig - mood: MoodConfig keyword_reaction: KeywordReactionConfig chinese_typo: ChineseTypoConfig response_post_process: ResponsePostProcessConfig @@ -355,7 +350,9 @@ class Config(ConfigBase): maim_message: MaimMessageConfig lpmm_knowledge: LPMMKnowledgeConfig tool: ToolConfig + memory: MemoryConfig debug: DebugConfig + mood: MoodConfig voice: VoiceConfig diff --git a/src/config/official_configs.py b/src/config/official_configs.py index b3cd8627..df616a64 100644 --- a/src/config/official_configs.py +++ b/src/config/official_configs.py @@ -2,6 +2,7 @@ import re from dataclasses import dataclass, field from typing import Literal, Optional +import time from src.config.config_base import ConfigBase @@ -38,21 +39,18 @@ class PersonalityConfig(ConfigBase): personality: str """人格""" - emotion_style: str - """情感特征""" - reply_style: str = "" """表达风格""" interest: str = "" """兴趣""" - + plan_style: str = "" """说话规则，行为风格""" - + visual_style: str = "" """图片提示词""" - + private_plan_style: str = "" """私聊说话规则，行为风格""" @@ -81,48 +79,212 @@ class ChatConfig(ConfigBase): mentioned_bot_reply: bool = True """是否启用提及必回复""" + auto_chat_value: float = 1 + """自动聊天，越小，麦麦主动聊天的概率越低""" + at_bot_inevitable_reply: float = 1 """@bot 必然回复，1为100%回复，0为不额外增幅""" - talk_frequency: float = 0.5 - """回复频率阈值""" - + planner_smooth: float = 3 + """规划器平滑，增大数值会减小planner负荷，略微降低反应速度，推荐2-5，0为关闭，必须大于等于0""" + talk_value: float = 1 """思考频率""" - # 合并后的时段频率配置 - talk_frequency_adjust: list[list[str]] = field(default_factory=lambda: []) - - focus_value: float = 0.5 - """麦麦的专注思考能力，越低越容易专注，消耗token也越多""" - - focus_value_adjust: list[list[str]] = field(default_factory=lambda: []) - + talk_value_rules: list[dict] = field(default_factory=lambda: []) """ - 统一的活跃度和专注度配置 - 格式：[["platform:chat_id:type", "HH:MM,frequency", "HH:MM,frequency", ...], ...] - - 全局配置示例： - [["", "8:00,1", "12:00,2", "18:00,1.5", "00:00,0.5"]] - - 特定聊天流配置示例： + 思考频率规则列表，支持按聊天流/按日内时段配置。 + 规则格式：{ target="platform:id:type" 或 "", time="HH:MM-HH:MM", value=0.5 } + + 示例: [ - ["", "8:00,1", "12:00,1.2", "18:00,1.5", "01:00,0.6"], # 全局默认配置 - ["qq:1026294844:group", "12:20,1", "16:10,2", "20:10,1", "00:10,0.3"], # 特定群聊配置 - ["qq:729957033:private", "8:20,1", "12:10,2", "20:10,1.5", "00:10,0.2"] # 特定私聊配置 + ["", "00:00-08:59", 0.2], # 全局规则：凌晨到早上更安静 + ["", "09:00-22:59", 1.0], # 全局规则：白天正常 + ["qq:1919810:group", "20:00-23:59", 0.6], # 指定群在晚高峰降低发言 + ["qq:114514:private", "00:00-23:59", 0.3],# 指定私聊全时段较安静 ] - - 说明： - - 当第一个元素为空字符串""时，表示全局默认配置 - - 当第一个元素为"platform:id:type"格式时，表示特定聊天流配置 - - 后续元素是"时间,频率"格式，表示从该时间开始使用该频率，直到下一个时间点 - - 优先级：特定聊天流配置 > 全局配置 > 默认值 - - 注意： - - talk_frequency_adjust 控制回复频率，数值越高回复越频繁 - - focus_value_adjust 控制专注思考能力，数值越低越容易专注，消耗token也越多 + + 匹配优先级: 先匹配指定 chat 流规则，再匹配全局规则(\"\"). + 时间区间支持跨夜，例如 "23:00-02:00"。 """ + auto_chat_value_rules: list[dict] = field(default_factory=lambda: []) + """ + 自动聊天频率规则列表，支持按聊天流/按日内时段配置。 + 规则格式：{ target="platform:id:type" 或 "", time="HH:MM-HH:MM", value=0.5 } + + 示例: + [ + ["", "00:00-08:59", 0.2], # 全局规则：凌晨到早上更安静 + ["", "09:00-22:59", 1.0], # 全局规则：白天正常 + ["qq:1919810:group", "20:00-23:59", 0.6], # 指定群在晚高峰降低发言 + ["qq:114514:private", "00:00-23:59", 0.3],# 指定私聊全时段较安静 + ] + + 匹配优先级: 先匹配指定 chat 流规则，再匹配全局规则(\"\"). + 时间区间支持跨夜，例如 "23:00-02:00"。 + """ + + def _parse_stream_config_to_chat_id(self, stream_config_str: str) -> Optional[str]: + """与 ChatStream.get_stream_id 一致地从 "platform:id:type" 生成 chat_id。""" + try: + parts = stream_config_str.split(":") + if len(parts) != 3: + return None + + platform = parts[0] + id_str = parts[1] + stream_type = parts[2] + + is_group = stream_type == "group" + + import hashlib + + if is_group: + components = [platform, str(id_str)] + else: + components = [platform, str(id_str), "private"] + key = "_".join(components) + return hashlib.md5(key.encode()).hexdigest() + + except (ValueError, IndexError): + return None + + def _now_minutes(self) -> int: + """返回本地时间的分钟数(0-1439)。""" + lt = time.localtime() + return lt.tm_hour * 60 + lt.tm_min + + def _parse_range(self, range_str: str) -> Optional[tuple[int, int]]: + """解析 "HH:MM-HH:MM" 到 (start_min, end_min)。""" + try: + start_str, end_str = [s.strip() for s in range_str.split("-")] + sh, sm = [int(x) for x in start_str.split(":")] + eh, em = [int(x) for x in end_str.split(":")] + return sh * 60 + sm, eh * 60 + em + except Exception: + return None + + def _in_range(self, now_min: int, start_min: int, end_min: int) -> bool: + """ + 判断 now_min 是否在 [start_min, end_min] 区间内。 + 支持跨夜：如果 start > end，则表示跨越午夜。 + """ + if start_min <= end_min: + return start_min <= now_min <= end_min + # 跨夜：例如 23:00-02:00 + return now_min >= start_min or now_min <= end_min + + def get_talk_value(self, chat_id: Optional[str]) -> float: + """根据规则返回当前 chat 的动态 talk_value，未匹配则回退到基础值。""" + if not self.talk_value_rules: + return self.talk_value + + now_min = self._now_minutes() + + # 1) 先尝试匹配指定 chat 的规则 + if chat_id: + for rule in self.talk_value_rules: + if not isinstance(rule, dict): + continue + target = rule.get("target", "") + time_range = rule.get("time", "") + value = rule.get("value", None) + if not isinstance(time_range, str): + continue + # 跳过全局 + if target == "": + continue + config_chat_id = self._parse_stream_config_to_chat_id(str(target)) + if config_chat_id is None or config_chat_id != chat_id: + continue + parsed = self._parse_range(time_range) + if not parsed: + continue + start_min, end_min = parsed + if self._in_range(now_min, start_min, end_min): + try: + return float(value) + except Exception: + continue + + # 2) 再匹配全局规则("") + for rule in self.talk_value_rules: + if not isinstance(rule, dict): + continue + target = rule.get("target", None) + time_range = rule.get("time", "") + value = rule.get("value", None) + if target != "" or not isinstance(time_range, str): + continue + parsed = self._parse_range(time_range) + if not parsed: + continue + start_min, end_min = parsed + if self._in_range(now_min, start_min, end_min): + try: + return float(value) + except Exception: + continue + + # 3) 未命中规则返回基础值 + return self.talk_value + + def get_auto_chat_value(self, chat_id: Optional[str]) -> float: + """根据规则返回当前 chat 的动态 auto_chat_value，未匹配则回退到基础值。""" + if not self.auto_chat_value_rules: + return self.auto_chat_value + + now_min = self._now_minutes() + + # 1) 先尝试匹配指定 chat 的规则 + if chat_id: + for rule in self.auto_chat_value_rules: + if not isinstance(rule, dict): + continue + target = rule.get("target", "") + time_range = rule.get("time", "") + value = rule.get("value", None) + if not isinstance(time_range, str): + continue + # 跳过全局 + if target == "": + continue + config_chat_id = self._parse_stream_config_to_chat_id(str(target)) + if config_chat_id is None or config_chat_id != chat_id: + continue + parsed = self._parse_range(time_range) + if not parsed: + continue + start_min, end_min = parsed + if self._in_range(now_min, start_min, end_min): + try: + return float(value) + except Exception: + continue + + # 2) 再匹配全局规则("") + for rule in self.auto_chat_value_rules: + if not isinstance(rule, dict): + continue + target = rule.get("target", None) + time_range = rule.get("time", "") + value = rule.get("value", None) + if target != "" or not isinstance(time_range, str): + continue + parsed = self._parse_range(time_range) + if not parsed: + continue + start_min, end_min = parsed + if self._in_range(now_min, start_min, end_min): + try: + return float(value) + except Exception: + continue + + # 3) 未命中规则返回基础值 + return self.auto_chat_value + @dataclass class MessageReceiveConfig(ConfigBase): @@ -134,11 +296,23 @@ class MessageReceiveConfig(ConfigBase): ban_msgs_regex: set[str] = field(default_factory=lambda: set()) """过滤正则表达式列表""" +@dataclass +class MemoryConfig(ConfigBase): + """记忆配置类""" + + max_memory_number: int = 100 + """记忆最大数量""" + + memory_build_frequency: int = 1 + """记忆构建频率""" @dataclass class ExpressionConfig(ConfigBase): """表达配置类""" + mode: str = "classic" + """表达方式模式，可选：classic经典模式，exp_model 表达模型模式""" + learning_list: list[list] = field(default_factory=lambda: []) """ 表达学习配置列表，支持按聊天流配置 @@ -299,6 +473,19 @@ class ToolConfig(ConfigBase): """是否在聊天中启用工具""" +@dataclass +class MoodConfig(ConfigBase): + """情绪配置类""" + + enable_mood: bool = True + """是否启用情绪系统""" + + mood_update_threshold: float = 1 + """情绪更新阈值,越高，更新越慢""" + + emotion_style: str = "情绪较为稳定，但遭遇特定事件的时候起伏较大" + """情感特征，影响情绪的变化情况""" + @dataclass class VoiceConfig(ConfigBase): """语音识别配置类""" @@ -333,17 +520,6 @@ class EmojiConfig(ConfigBase): """表情包过滤要求""" -@dataclass -class MoodConfig(ConfigBase): - """情绪配置类""" - - enable_mood: bool = False - """是否启用情绪系统""" - - mood_update_threshold: float = 1.0 - """情绪更新阈值,越高，更新越慢""" - - @dataclass class KeywordRuleConfig(ConfigBase): """关键词规则配置类""" diff --git a/src/express/expression_learner.py b/src/express/expression_learner.py new file mode 100644 index 00000000..e0bc6d71 --- /dev/null +++ b/src/express/expression_learner.py @@ -0,0 +1,580 @@ +import time +import json +import os +import re +from datetime import datetime +from typing import List, Optional, Tuple +import traceback +import difflib +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.config.config import model_config, global_config +from src.chat.utils.chat_message_builder import ( + get_raw_msg_by_timestamp_with_chat_inclusive, + build_anonymous_messages, + build_bare_messages, +) +from src.chat.utils.prompt_builder import Prompt, global_prompt_manager +from src.chat.message_receive.chat_stream import get_chat_manager +from src.express.style_learner import style_learner_manager +from json_repair import repair_json + + +# MAX_EXPRESSION_COUNT = 300 + +logger = get_logger("expressor") + + +def calculate_similarity(text1: str, text2: str) -> float: + """ + 计算两个文本的相似度，返回0-1之间的值 + 使用SequenceMatcher计算相似度 + """ + return difflib.SequenceMatcher(None, text1, text2).ratio() + + +def format_create_date(timestamp: float) -> str: + """ + 将时间戳格式化为可读的日期字符串 + """ + try: + return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S") + except (ValueError, OSError): + return "未知时间" + + +def init_prompt() -> None: + learn_style_prompt = """ +{chat_str} + +请从上面这段群聊中概括除了人名为"SELF"之外的人的语言风格 +1. 只考虑文字，不要考虑表情包和图片 +2. 不要涉及具体的人名，但是可以涉及具体名词 +3. 思考有没有特殊的梗，一并总结成语言风格 +4. 例子仅供参考，请严格根据群聊内容总结!!! +注意：总结成如下格式的规律，总结的内容要详细，但具有概括性： +例如：当"AAAAA"时，可以"BBBBB", AAAAA代表某个具体的场景，不超过20个字。BBBBB代表对应的语言风格，特定句式或表达方式，不超过20个字。 + +例如： +当"对某件事表示十分惊叹"时，使用"我嘞个xxxx" +当"表示讽刺的赞同，不讲道理"时，使用"对对对" +当"想说明某个具体的事实观点，但懒得明说，使用"懂的都懂" +当"当涉及游戏相关时，夸赞，略带戏谑意味"时，使用"这么强！" + +请注意：不要总结你自己（SELF）的发言，尽量保证总结内容的逻辑性 +现在请你概括 +""" + Prompt(learn_style_prompt, "learn_style_prompt") + + match_expression_context_prompt = """ +**聊天内容** +{chat_str} + +**从聊天内容总结的表达方式pairs** +{expression_pairs} + +请你为上面的每一条表达方式，找到该表达方式的原文句子，并输出匹配结果，expression_pair不能有重复，每个expression_pair仅输出一个最合适的context。 +如果找不到原句，就不输出该句的匹配结果。 +以json格式输出： +格式如下： +{{ + "expression_pair": "表达方式pair的序号（数字）", + "context": "与表达方式对应的原文句子的原始内容，不要修改原文句子的内容", +}}， +{{ + "expression_pair": "表达方式pair的序号（数字）", + "context": "与表达方式对应的原文句子的原始内容，不要修改原文句子的内容", +}}， +... + +现在请你输出匹配结果： +""" + Prompt(match_expression_context_prompt, "match_expression_context_prompt") + + +class ExpressionLearner: + def __init__(self, chat_id: str) -> None: + self.express_learn_model: LLMRequest = LLMRequest( + model_set=model_config.model_task_config.utils, request_type="expression.learner" + ) + self.embedding_model: LLMRequest = LLMRequest( + model_set=model_config.model_task_config.embedding, request_type="expression.embedding" + ) + self.chat_id = chat_id + self.chat_stream = get_chat_manager().get_stream(chat_id) + self.chat_name = get_chat_manager().get_stream_name(chat_id) or chat_id + + # 维护每个chat的上次学习时间 + self.last_learning_time: float = time.time() + + # 学习参数 + _, self.enable_learning, self.learning_intensity = global_config.expression.get_expression_config_for_chat( + self.chat_id + ) + self.min_messages_for_learning = 30 / self.learning_intensity # 触发学习所需的最少消息数 + self.min_learning_interval = 300 / self.learning_intensity + + def should_trigger_learning(self) -> bool: + """ + 检查是否应该触发学习 + + Args: + chat_id: 聊天流ID + + Returns: + bool: 是否应该触发学习 + """ + # 检查是否允许学习 + if not self.enable_learning: + return False + + # 检查时间间隔 + time_diff = time.time() - self.last_learning_time + if time_diff < self.min_learning_interval: + return False + + # 检查消息数量（只检查指定聊天流的消息） + recent_messages = get_raw_msg_by_timestamp_with_chat_inclusive( + chat_id=self.chat_id, + timestamp_start=self.last_learning_time, + timestamp_end=time.time(), + ) + + if not recent_messages or len(recent_messages) < self.min_messages_for_learning: + return False + + return True + + async def trigger_learning_for_chat(self): + """ + 为指定聊天流触发学习 + + Args: + chat_id: 聊天流ID + + Returns: + bool: 是否成功触发学习 + """ + if not self.should_trigger_learning(): + return + + try: + logger.info(f"在聊天流 {self.chat_name} 学习表达方式") + # 学习语言风格 + learnt_style = await self.learn_and_store(num=25) + + # 更新学习时间 + self.last_learning_time = time.time() + + 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 + + + + async def learn_and_store(self, num: int = 10) -> List[Tuple[str, str, str]]: + """ + 学习并存储表达方式 + """ + learnt_expressions = await self.learn_expression(num) + + if learnt_expressions is None: + logger.info("没有学习到表达风格") + return [] + + # 展示学到的表达方式 + learnt_expressions_str = "" + for ( + situation, + style, + _context, + _up_content, + ) in learnt_expressions: + learnt_expressions_str += f"{situation}->{style}\n" + logger.info(f"在 {self.chat_name} 学习到表达风格:\n{learnt_expressions_str}") + + current_time = time.time() + + # 存储到数据库 Expression 表并训练 style_learner + has_new_expressions = False # 记录是否有新的表达方式 + learner = style_learner_manager.get_learner(self.chat_id) # 获取 learner 实例 + + for ( + situation, + style, + context, + up_content, + ) in learnt_expressions: + # 查找是否已存在相似表达方式 + query = Expression.select().where( + (Expression.chat_id == self.chat_id) + & (Expression.situation == situation) + & (Expression.style == style) + ) + if query.exists(): + # 表达方式完全相同，只更新时间戳 + expr_obj = query.get() + expr_obj.last_active_time = current_time + expr_obj.save() + continue + else: + Expression.create( + situation=situation, + style=style, + last_active_time=current_time, + chat_id=self.chat_id, + create_date=current_time, # 手动设置创建日期 + context=context, + up_content=up_content, + ) + has_new_expressions = True + + # 训练 style_learner（up_content 和 style 必定存在） + try: + learner.add_style(style, situation) + + # 学习映射关系 + success = style_learner_manager.learn_mapping( + self.chat_id, + up_content, + style + ) + if success: + logger.debug(f"StyleLearner学习成功: {self.chat_id} - {up_content} -> {style}" + (f" (situation: {situation})" if situation else "")) + else: + logger.warning(f"StyleLearner学习失败: {self.chat_id} - {up_content} -> {style}") + except Exception as e: + logger.error(f"StyleLearner学习异常: {self.chat_id} - {e}") + + + # 保存当前聊天室的 style_learner 模型 + if has_new_expressions: + try: + logger.info(f"开始保存聊天室 {self.chat_id} 的 StyleLearner 模型...") + save_success = learner.save(style_learner_manager.model_save_path) + + if save_success: + logger.info(f"StyleLearner 模型保存成功，聊天室: {self.chat_id}") + else: + logger.warning(f"StyleLearner 模型保存失败，聊天室: {self.chat_id}") + + except Exception as e: + logger.error(f"StyleLearner 模型保存异常: {e}") + + return learnt_expressions + + async def match_expression_context( + self, expression_pairs: List[Tuple[str, str]], random_msg_match_str: str + ) -> List[Tuple[str, str, str]]: + # 为expression_pairs逐个条目赋予编号，并构建成字符串 + numbered_pairs = [] + for i, (situation, style) in enumerate(expression_pairs, 1): + numbered_pairs.append(f'{i}. 当"{situation}"时，使用"{style}"') + + expression_pairs_str = "\n".join(numbered_pairs) + + prompt = "match_expression_context_prompt" + prompt = await global_prompt_manager.format_prompt( + prompt, + expression_pairs=expression_pairs_str, + chat_str=random_msg_match_str, + ) + + response, _ = await self.express_learn_model.generate_response_async(prompt, temperature=0.3) + + # print(f"match_expression_context_prompt: {prompt}") + # print(f"{response}") + + # 解析JSON响应 + match_responses = [] + try: + response = response.strip() + # 检查是否已经是标准JSON数组格式 + if response.startswith("[") and response.endswith("]"): + match_responses = json.loads(response) + else: + # 尝试直接解析多个JSON对象 + try: + # 如果是多个JSON对象用逗号分隔，包装成数组 + if response.startswith("{") and not response.startswith("["): + response = "[" + response + "]" + match_responses = json.loads(response) + else: + # 使用repair_json处理响应 + repaired_content = repair_json(response) + + # 确保repaired_content是列表格式 + if isinstance(repaired_content, str): + try: + parsed_data = json.loads(repaired_content) + if isinstance(parsed_data, dict): + # 如果是字典，包装成列表 + match_responses = [parsed_data] + elif isinstance(parsed_data, list): + match_responses = parsed_data + else: + match_responses = [] + except json.JSONDecodeError: + match_responses = [] + elif isinstance(repaired_content, dict): + # 如果是字典，包装成列表 + match_responses = [repaired_content] + elif isinstance(repaired_content, list): + match_responses = repaired_content + else: + match_responses = [] + except json.JSONDecodeError: + # 如果还是失败，尝试repair_json + repaired_content = repair_json(response) + if isinstance(repaired_content, str): + parsed_data = json.loads(repaired_content) + match_responses = parsed_data if isinstance(parsed_data, list) else [parsed_data] + else: + match_responses = repaired_content if isinstance(repaired_content, list) else [repaired_content] + + except (json.JSONDecodeError, Exception) as e: + logger.error(f"解析匹配响应JSON失败: {e}, 响应内容: \n{response}") + return [] + + # 确保 match_responses 是一个列表 + if not isinstance(match_responses, list): + if isinstance(match_responses, dict): + match_responses = [match_responses] + else: + logger.error(f"match_responses 不是列表或字典类型: {type(match_responses)}, 内容: {match_responses}") + return [] + + 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}") + + for match_response in match_responses: + try: + # 检查 match_response 的类型 + if not isinstance(match_response, dict): + logger.error(f"match_response 不是字典类型: {type(match_response)}, 内容: {match_response}") + continue + + # 获取表达方式序号 + if "expression_pair" not in match_response: + logger.error(f"match_response 缺少 'expression_pair' 字段: {match_response}") + continue + + pair_index = int(match_response["expression_pair"]) - 1 # 转换为0-based索引 + + # 检查索引是否有效且未被使用过 + if 0 <= pair_index < len(expression_pairs) and pair_index not in used_pair_indices: + situation, style = expression_pairs[pair_index] + context = match_response.get("context", "") + matched_expressions.append((situation, style, context)) + used_pair_indices.add(pair_index) # 标记该索引已使用 + logger.debug(f"成功匹配表达方式 {pair_index + 1}: {situation} -> {style}") + elif pair_index in used_pair_indices: + logger.debug(f"跳过重复的表达方式 {pair_index + 1}") + except (ValueError, KeyError, IndexError, TypeError) as e: + logger.error(f"解析匹配条目失败: {e}, 条目: {match_response}") + continue + + return matched_expressions + + async def learn_expression( + self, num: int = 10 + ) -> Optional[List[Tuple[str, str, str, str]]]: + """从指定聊天流学习表达方式 + + Args: + num: 学习数量 + """ + current_time = time.time() + + # 获取上次学习之后的消息 + random_msg = get_raw_msg_by_timestamp_with_chat_inclusive( + chat_id=self.chat_id, + timestamp_start=self.last_learning_time, + timestamp_end=current_time, + limit=num, + ) + # print(random_msg) + if not random_msg or random_msg == []: + return None + + # 学习用 + random_msg_str: str = await build_anonymous_messages(random_msg) + # 溯源用 + random_msg_match_str: str = await build_bare_messages(random_msg) + + prompt: str = await global_prompt_manager.format_prompt( + "learn_style_prompt", + chat_str=random_msg_str, + ) + + # print(f"random_msg_str:{random_msg_str}") + # logger.info(f"学习{type_str}的prompt: {prompt}") + + try: + response, _ = await self.express_learn_model.generate_response_async(prompt, temperature=0.3) + except Exception as e: + logger.error(f"学习表达方式失败,模型生成出错: {e}") + return None + expressions: List[Tuple[str, str]] = self.parse_expression_response(response) + # logger.debug(f"学习{type_str}的response: {response}") + + + # 对表达方式溯源 + matched_expressions: List[Tuple[str, str, str]] = await self.match_expression_context( + expressions, random_msg_match_str + ) + # 为每条消息构建精简文本列表，保留到原消息索引的映射 + bare_lines: List[Tuple[int, str]] = self._build_bare_lines(random_msg) + # 将 matched_expressions 结合上一句 up_content（若不存在上一句则跳过） + filtered_with_up: List[Tuple[str, str, str, str]] = [] # (situation, style, context, up_content) + for situation, style, context in matched_expressions: + # 在 bare_lines 中找到第一处相似度达到85%的行 + pos = None + for i, (_, c) in enumerate(bare_lines): + similarity = calculate_similarity(c, context) + if similarity >= 0.85: # 85%相似度阈值 + pos = i + break + + if pos is None or pos == 0: + # 没有匹配到目标句或没有上一句，跳过该表达 + continue + + # 检查目标句是否为空 + target_content = bare_lines[pos][1] + if not target_content: + # 目标句为空，跳过该表达 + continue + + prev_original_idx = bare_lines[pos - 1][0] + up_content = self._filter_message_content(random_msg[prev_original_idx].processed_plain_text or "") + if not up_content: + # 上一句为空，跳过该表达 + continue + filtered_with_up.append((situation, style, context, up_content)) + + if not filtered_with_up: + return None + + return filtered_with_up + + + def parse_expression_response(self, response: str) -> List[Tuple[str, str, str]]: + """ + 解析LLM返回的表达风格总结，每一行提取"当"和"使用"之间的内容，存储为(situation, style)元组 + """ + expressions: List[Tuple[str, str, str]] = [] + for line in response.splitlines(): + line = line.strip() + if not line: + continue + # 查找"当"和下一个引号 + idx_when = line.find('当"') + if idx_when == -1: + continue + idx_quote1 = idx_when + 1 + idx_quote2 = line.find('"', idx_quote1 + 1) + if idx_quote2 == -1: + continue + situation = line[idx_quote1 + 1 : idx_quote2] + # 查找"使用" + idx_use = line.find('使用"', idx_quote2) + if idx_use == -1: + continue + idx_quote3 = idx_use + 2 + idx_quote4 = line.find('"', idx_quote3 + 1) + if idx_quote4 == -1: + continue + style = line[idx_quote3 + 1 : idx_quote4] + expressions.append((situation, style)) + return expressions + + def _filter_message_content(self, content: str) -> str: + """ + 过滤消息内容，移除回复、@、图片等格式 + + Args: + content: 原始消息内容 + + Returns: + str: 过滤后的内容 + """ + if not content: + return "" + + # 移除以[回复开头、]结尾的部分，包括后面的"，说："部分 + content = re.sub(r'\[回复.*?\]，说：\s*', '', content) + # 移除@<...>格式的内容 + content = re.sub(r'@<[^>]*>', '', content) + # 移除[picid:...]格式的图片ID + content = re.sub(r'\[picid:[^\]]*\]', '', content) + # 移除[表情包：...]格式的内容 + content = re.sub(r'\[表情包：[^\]]*\]', '', content) + + return content.strip() + + def _build_bare_lines(self, messages: List) -> List[Tuple[int, str]]: + """ + 为每条消息构建精简文本列表，保留到原消息索引的映射 + + Args: + messages: 消息列表 + + Returns: + List[Tuple[int, str]]: (original_index, bare_content) 元组列表 + """ + bare_lines: List[Tuple[int, str]] = [] + + for idx, msg in enumerate(messages): + content = msg.processed_plain_text or "" + content = self._filter_message_content(content) + # 即使content为空也要记录，防止错位 + bare_lines.append((idx, content)) + + return bare_lines + + +init_prompt() + + +class ExpressionLearnerManager: + def __init__(self): + self.expression_learners = {} + + self._ensure_expression_directories() + + def get_expression_learner(self, chat_id: str) -> ExpressionLearner: + if chat_id not in self.expression_learners: + self.expression_learners[chat_id] = ExpressionLearner(chat_id) + return self.expression_learners[chat_id] + + def _ensure_expression_directories(self): + """ + 确保表达方式相关的目录结构存在 + """ + base_dir = os.path.join("data", "expression") + directories_to_create = [ + base_dir, + os.path.join(base_dir, "learnt_style"), + os.path.join(base_dir, "learnt_grammar"), + ] + + for directory in directories_to_create: + try: + os.makedirs(directory, exist_ok=True) + logger.debug(f"确保目录存在: {directory}") + except Exception as e: + logger.error(f"创建目录失败 {directory}: {e}") + + +expression_learner_manager = ExpressionLearnerManager() diff --git a/src/express/expression_selector.py b/src/express/expression_selector.py new file mode 100644 index 00000000..9ebef43c --- /dev/null +++ b/src/express/expression_selector.py @@ -0,0 +1,462 @@ +import json +import time +import random +import hashlib + +from typing import List, Dict, Optional, Any, Tuple +from json_repair import repair_json + +from src.llm_models.utils_model import LLMRequest +from src.config.config import global_config, model_config +from src.common.logger import get_logger +from src.common.database.database_model import Expression +from src.chat.utils.prompt_builder import Prompt, global_prompt_manager +from src.express.style_learner import style_learner_manager + +logger = get_logger("expression_selector") + + +def init_prompt(): + expression_evaluation_prompt = """ +以下是正在进行的聊天内容： +{chat_observe_info} + +你的名字是{bot_name}{target_message} + +以下是可选的表达情境： +{all_situations} + +请你分析聊天内容的语境、情绪、话题类型，从上述情境中选择最适合当前聊天情境的，最多{max_num}个情境。 +考虑因素包括： +1. 聊天的情绪氛围（轻松、严肃、幽默等） +2. 话题类型（日常、技术、游戏、情感等） +3. 情境与当前语境的匹配度 +{target_message_extra_block} + +请以JSON格式输出，只需要输出选中的情境编号： +例如： +{{ + "selected_situations": [2, 3, 5, 7, 19] +}} + +请严格按照JSON格式输出，不要包含其他内容： +""" + Prompt(expression_evaluation_prompt, "expression_evaluation_prompt") + + +def weighted_sample(population: List[Dict], k: int) -> List[Dict]: + """随机抽样""" + if not population or k <= 0: + return [] + + if len(population) <= k: + return population.copy() + + # 使用随机抽样 + selected = [] + population_copy = population.copy() + + for _ in range(k): + if not population_copy: + break + + # 随机选择一个元素 + chosen_idx = random.randint(0, len(population_copy) - 1) + selected.append(population_copy.pop(chosen_idx)) + + return selected + + +class ExpressionSelector: + def __init__(self): + self.llm_model = LLMRequest( + model_set=model_config.model_task_config.utils_small, request_type="expression.selector" + ) + + def can_use_expression_for_chat(self, chat_id: str) -> bool: + """ + 检查指定聊天流是否允许使用表达 + + Args: + chat_id: 聊天流ID + + Returns: + bool: 是否允许使用表达 + """ + try: + use_expression, _, _ = global_config.expression.get_expression_config_for_chat(chat_id) + return use_expression + except Exception as e: + logger.error(f"检查表达使用权限失败: {e}") + return False + + @staticmethod + def _parse_stream_config_to_chat_id(stream_config_str: str) -> Optional[str]: + """解析'platform:id:type'为chat_id（与get_stream_id一致）""" + try: + parts = stream_config_str.split(":") + if len(parts) != 3: + return None + platform = parts[0] + id_str = parts[1] + stream_type = parts[2] + is_group = stream_type == "group" + if is_group: + components = [platform, str(id_str)] + else: + components = [platform, str(id_str), "private"] + key = "_".join(components) + return hashlib.md5(key.encode()).hexdigest() + except Exception: + return None + + def get_related_chat_ids(self, chat_id: str) -> List[str]: + """根据expression_groups配置，获取与当前chat_id相关的所有chat_id（包括自身）""" + groups = global_config.expression.expression_groups + + # 检查是否存在全局共享组（包含"*"的组） + global_group_exists = any("*" in group for group in groups) + + if global_group_exists: + # 如果存在全局共享组，则返回所有可用的chat_id + all_chat_ids = set() + for group in groups: + for stream_config_str in group: + if chat_id_candidate := self._parse_stream_config_to_chat_id(stream_config_str): + all_chat_ids.add(chat_id_candidate) + return list(all_chat_ids) if all_chat_ids else [chat_id] + + # 否则使用现有的组逻辑 + for group in groups: + group_chat_ids = [] + for stream_config_str in group: + if chat_id_candidate := self._parse_stream_config_to_chat_id(stream_config_str): + group_chat_ids.append(chat_id_candidate) + if chat_id in group_chat_ids: + return group_chat_ids + return [chat_id] + + def get_model_predicted_expressions(self, chat_id: str, target_message: str, total_num: int = 10) -> List[Dict[str, Any]]: + """ + 使用 style_learner 模型预测最合适的表达方式 + + Args: + chat_id: 聊天室ID + target_message: 目标消息内容 + total_num: 需要预测的数量 + + Returns: + List[Dict[str, Any]]: 预测的表达方式列表 + """ + try: + # 支持多chat_id合并预测 + related_chat_ids = self.get_related_chat_ids(chat_id) + + + predicted_expressions = [] + + # 为每个相关的chat_id进行预测 + for related_chat_id in related_chat_ids: + try: + # 使用 style_learner 预测最合适的风格 + best_style, scores = style_learner_manager.predict_style( + related_chat_id, target_message, top_k=total_num + ) + + if best_style and scores: + # 获取预测风格的完整信息 + learner = style_learner_manager.get_learner(related_chat_id) + style_id, situation = learner.get_style_info(best_style) + + if style_id and situation: + # 从数据库查找对应的表达记录 + expr_query = Expression.select().where( + (Expression.chat_id == related_chat_id) & + (Expression.situation == situation) & + (Expression.style == best_style) + ) + + if expr_query.exists(): + expr = expr_query.get() + predicted_expressions.append({ + "id": expr.id, + "situation": expr.situation, + "style": expr.style, + "last_active_time": expr.last_active_time, + "source_id": expr.chat_id, + "create_date": expr.create_date if expr.create_date is not None else expr.last_active_time, + "prediction_score": scores.get(best_style, 0.0), + "prediction_input": target_message + }) + else: + logger.warning(f"为聊天室 {related_chat_id} 预测表达方式失败: {best_style} 没有找到对应的表达方式") + + except Exception as e: + logger.warning(f"为聊天室 {related_chat_id} 预测表达方式失败: {e}") + continue + + # 按预测分数排序，取前 total_num 个 + predicted_expressions.sort(key=lambda x: x.get("prediction_score", 0.0), reverse=True) + selected_expressions = predicted_expressions[:total_num] + + logger.info(f"为聊天室 {chat_id} 预测到 {len(selected_expressions)} 个表达方式") + return selected_expressions + + except Exception as e: + logger.error(f"模型预测表达方式失败: {e}") + # 如果预测失败，回退到随机选择 + return self._random_expressions(chat_id, total_num) + + def _random_expressions(self, chat_id: str, total_num: int) -> List[Dict[str, Any]]: + """ + 随机选择表达方式 + + Args: + chat_id: 聊天室ID + total_num: 需要选择的数量 + + Returns: + List[Dict[str, Any]]: 随机选择的表达方式列表 + """ + try: + # 支持多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)) + ) + + style_exprs = [ + { + "id": expr.id, + "situation": expr.situation, + "style": expr.style, + "last_active_time": expr.last_active_time, + "source_id": expr.chat_id, + "create_date": expr.create_date if expr.create_date is not None else expr.last_active_time, + } + for expr in style_query + ] + + # 随机抽样 + if style_exprs: + selected_style = weighted_sample(style_exprs, total_num) + else: + selected_style = [] + + logger.info(f"随机选择，为聊天室 {chat_id} 选择了 {len(selected_style)} 个表达方式") + return selected_style + + except Exception as e: + logger.error(f"随机选择表达方式失败: {e}") + return [] + + + async def select_suitable_expressions( + self, + chat_id: str, + chat_info: str, + max_num: int = 10, + target_message: Optional[str] = None, + ) -> Tuple[List[Dict[str, Any]], List[int]]: + """ + 根据配置模式选择适合的表达方式 + + Args: + chat_id: 聊天流ID + chat_info: 聊天内容信息 + max_num: 最大选择数量 + target_message: 目标消息内容 + + Returns: + Tuple[List[Dict[str, Any]], List[int]]: 选中的表达方式列表和ID列表 + """ + # 检查是否允许在此聊天流中使用表达 + if not self.can_use_expression_for_chat(chat_id): + logger.debug(f"聊天流 {chat_id} 不允许使用表达，返回空列表") + return [], [] + + # 获取配置模式 + expression_mode = global_config.expression.mode + + if expression_mode == "exp_model": + # exp_model模式：直接使用模型预测，不经过LLM + logger.debug(f"使用exp_model模式为聊天流 {chat_id} 选择表达方式") + return await self._select_expressions_model_only(chat_id, target_message, max_num) + elif expression_mode == "classic": + # classic模式：随机选择+LLM选择 + logger.debug(f"使用classic模式为聊天流 {chat_id} 选择表达方式") + return await self._select_expressions_classic(chat_id, chat_info, max_num, target_message) + else: + logger.warning(f"未知的表达模式: {expression_mode}，回退到classic模式") + return await self._select_expressions_classic(chat_id, chat_info, max_num, target_message) + + async def _select_expressions_model_only( + self, + chat_id: str, + target_message: str, + max_num: int = 10, + ) -> Tuple[List[Dict[str, Any]], List[int]]: + """ + exp_model模式：直接使用模型预测，不经过LLM + + Args: + chat_id: 聊天流ID + target_message: 目标消息内容 + max_num: 最大选择数量 + + Returns: + Tuple[List[Dict[str, Any]], List[int]]: 选中的表达方式列表和ID列表 + """ + try: + # 使用模型预测最合适的表达方式 + selected_expressions = self.get_model_predicted_expressions(chat_id, target_message, max_num) + selected_ids = [expr["id"] for expr in selected_expressions] + + # 更新last_active_time + if selected_expressions: + self.update_expressions_last_active_time(selected_expressions) + + logger.info(f"exp_model模式为聊天流 {chat_id} 选择了 {len(selected_expressions)} 个表达方式") + return selected_expressions, selected_ids + + except Exception as e: + logger.error(f"exp_model模式选择表达方式失败: {e}") + return [], [] + + async def _select_expressions_classic( + self, + chat_id: str, + chat_info: str, + max_num: int = 10, + target_message: Optional[str] = None, + ) -> Tuple[List[Dict[str, Any]], List[int]]: + """ + classic模式：随机选择+LLM选择 + + Args: + chat_id: 聊天流ID + chat_info: 聊天内容信息 + max_num: 最大选择数量 + target_message: 目标消息内容 + + Returns: + Tuple[List[Dict[str, Any]], List[int]]: 选中的表达方式列表和ID列表 + """ + try: + # 1. 使用随机抽样选择表达方式 + style_exprs = self._random_expressions(chat_id, 20) + + if len(style_exprs) < 10: + logger.info(f"聊天流 {chat_id} 表达方式正在积累中") + return [], [] + + # 2. 构建所有表达方式的索引和情境列表 + all_expressions: List[Dict[str, Any]] = [] + all_situations: List[str] = [] + + # 添加style表达方式 + for expr in style_exprs: + expr = expr.copy() + all_expressions.append(expr) + all_situations.append(f"{len(all_expressions)}.当 {expr['situation']} 时，使用 {expr['style']}") + + if not all_expressions: + logger.warning("没有找到可用的表达方式") + return [], [] + + all_situations_str = "\n".join(all_situations) + + if target_message: + target_message_str = f"，现在你想要回复消息：{target_message}" + target_message_extra_block = "4.考虑你要回复的目标消息" + else: + target_message_str = "" + target_message_extra_block = "" + + # 3. 构建prompt（只包含情境，不包含完整的表达方式） + prompt = (await global_prompt_manager.get_prompt_async("expression_evaluation_prompt")).format( + bot_name=global_config.bot.nickname, + chat_observe_info=chat_info, + all_situations=all_situations_str, + max_num=max_num, + target_message=target_message_str, + target_message_extra_block=target_message_extra_block, + ) + + # 4. 调用LLM + content, (reasoning_content, model_name, _) = await self.llm_model.generate_response_async(prompt=prompt) + + if not content: + logger.warning("LLM返回空结果") + return [], [] + + # 5. 解析结果 + result = repair_json(content) + if isinstance(result, str): + result = json.loads(result) + + if not isinstance(result, dict) or "selected_situations" not in result: + logger.error("LLM返回格式错误") + logger.info(f"LLM返回结果: \n{content}") + return [], [] + + selected_indices = result["selected_situations"] + + # 根据索引获取完整的表达方式 + valid_expressions: List[Dict[str, Any]] = [] + selected_ids = [] + for idx in selected_indices: + if isinstance(idx, int) and 1 <= idx <= len(all_expressions): + expression = all_expressions[idx - 1] # 索引从1开始 + selected_ids.append(expression["id"]) + valid_expressions.append(expression) + + # 对选中的所有表达方式，更新last_active_time + if valid_expressions: + self.update_expressions_last_active_time(valid_expressions) + + logger.info(f"classic模式从{len(all_expressions)}个情境中选择了{len(valid_expressions)}个") + return valid_expressions, selected_ids + + except Exception as e: + logger.error(f"classic模式处理表达方式选择时出错: {e}") + return [], [] + + def update_expressions_last_active_time(self, expressions_to_update: List[Dict[str, Any]]): + """对一批表达方式更新last_active_time""" + if not expressions_to_update: + return + updates_by_key = {} + for expr in expressions_to_update: + source_id: str = expr.get("source_id") # type: ignore + situation: str = expr.get("situation") # type: ignore + style: str = expr.get("style") # type: ignore + if not source_id or not situation or not style: + logger.warning(f"表达方式缺少必要字段，无法更新: {expr}") + continue + key = (source_id, situation, style) + if key not in updates_by_key: + updates_by_key[key] = expr + for chat_id, situation, style in updates_by_key: + query = Expression.select().where( + (Expression.chat_id == chat_id) + & (Expression.situation == situation) + & (Expression.style == style) + ) + if query.exists(): + expr_obj = query.get() + expr_obj.last_active_time = time.time() + expr_obj.save() + logger.debug( + "表达方式激活: 更新last_active_time in db" + ) + + +init_prompt() + +try: + expression_selector = ExpressionSelector() +except Exception as e: + logger.error(f"ExpressionSelector初始化失败: {e}") diff --git a/src/express/expressor_model/model.py b/src/express/expressor_model/model.py new file mode 100644 index 00000000..d47873d9 --- /dev/null +++ b/src/express/expressor_model/model.py @@ -0,0 +1,141 @@ +from typing import Dict, Optional, Tuple, List +from collections import Counter, defaultdict +import pickle +import os + +from .tokenizer import Tokenizer +from .online_nb import OnlineNaiveBayes + +class ExpressorModel: + """ + 直接使用朴素贝叶斯精排（可在线学习） + 支持存储situation字段，不参与计算，仅与style对应 + """ + + def __init__(self, + alpha: float = 0.5, + beta: float = 0.5, + gamma: float = 1.0, + vocab_size: int = 200000, + use_jieba: bool = True): + self.tokenizer = Tokenizer(stopwords=set(), use_jieba=use_jieba) + self.nb = OnlineNaiveBayes(alpha=alpha, beta=beta, gamma=gamma, vocab_size=vocab_size) + self._candidates: Dict[str, str] = {} # cid -> text (style) + self._situations: Dict[str, str] = {} # cid -> situation (不参与计算) + + def add_candidate(self, cid: str, text: str, situation: str = None): + """添加候选文本和对应的situation""" + self._candidates[cid] = text + if situation is not None: + self._situations[cid] = situation + + # 确保在nb模型中初始化该候选的计数 + if cid not in self.nb.cls_counts: + self.nb.cls_counts[cid] = 0.0 + if cid not in self.nb.token_counts: + self.nb.token_counts[cid] = defaultdict(float) + + def add_candidates_bulk(self, items: List[Tuple[str, str]], situations: List[str] = None): + """批量添加候选文本和对应的situations""" + for i, (cid, text) in enumerate(items): + situation = situations[i] if situations and i < len(situations) else None + self.add_candidate(cid, text, situation) + + def predict(self, text: str, k: int = None) -> Tuple[Optional[str], Dict[str, float]]: + """直接对所有候选进行朴素贝叶斯评分""" + toks = self.tokenizer.tokenize(text) + if not toks: + return None, {} + + if not self._candidates: + return None, {} + + # 对所有候选进行评分 + tf = Counter(toks) + all_cids = list(self._candidates.keys()) + scores = self.nb.score_batch(tf, all_cids) + + # 取最高分 + if not scores: + return None, {} + + # 根据k参数限制返回的候选数量 + if k is not None and k > 0: + # 按分数降序排序，取前k个 + sorted_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True) + limited_scores = dict(sorted_scores[:k]) + best = sorted_scores[0][0] if sorted_scores else None + return best, limited_scores + else: + # 如果没有指定k，返回所有分数 + best = max(scores.items(), key=lambda x: x[1])[0] + return best, scores + + def update_positive(self, text: str, cid: str): + """更新正反馈学习""" + toks = self.tokenizer.tokenize(text) + if not toks: + return + tf = Counter(toks) + self.nb.update_positive(tf, cid) + + def decay(self, factor: float): + self.nb.decay(factor=factor) + + def get_situation(self, cid: str) -> Optional[str]: + """获取候选对应的situation""" + return self._situations.get(cid) + + def get_style(self, cid: str) -> Optional[str]: + """获取候选对应的style""" + return self._candidates.get(cid) + + def get_candidate_info(self, cid: str) -> Tuple[Optional[str], Optional[str]]: + """获取候选的style和situation信息""" + return self._candidates.get(cid), self._situations.get(cid) + + def get_all_candidates(self) -> Dict[str, Tuple[str, Optional[str]]]: + """获取所有候选的style和situation信息""" + return {cid: (style, self._situations.get(cid)) + for cid, style in self._candidates.items()} + + def save(self, path: str): + """保存模型""" + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "wb") as f: + pickle.dump({ + "candidates": self._candidates, + "situations": self._situations, + "nb": { + "cls_counts": dict(self.nb.cls_counts), + "token_counts": {cid: dict(tc) for cid, tc in self.nb.token_counts.items()}, + "alpha": self.nb.alpha, + "beta": self.nb.beta, + "gamma": self.nb.gamma, + "V": self.nb.V, + } + }, f) + + def load(self, path: str): + """加载模型""" + with open(path, "rb") as f: + obj = pickle.load(f) + # 还原候选文本 + self._candidates = obj["candidates"] + # 还原situations（兼容旧版本） + self._situations = obj.get("situations", {}) + # 还原朴素贝叶斯模型 + self.nb.cls_counts = obj["nb"]["cls_counts"] + self.nb.token_counts = defaultdict_dict(obj["nb"]["token_counts"]) + self.nb.alpha = obj["nb"]["alpha"] + self.nb.beta = obj["nb"]["beta"] + self.nb.gamma = obj["nb"]["gamma"] + self.nb.V = obj["nb"]["V"] + self.nb._logZ.clear() + +def defaultdict_dict(d: Dict[str, Dict[str, float]]): + from collections import defaultdict + outer = defaultdict(lambda: defaultdict(float)) + for k, inner in d.items(): + outer[k].update(inner) + return outer \ No newline at end of file diff --git a/src/express/expressor_model/online_nb.py b/src/express/expressor_model/online_nb.py new file mode 100644 index 00000000..9705043b --- /dev/null +++ b/src/express/expressor_model/online_nb.py @@ -0,0 +1,60 @@ +import math +from typing import Dict, List +from collections import defaultdict, Counter + +class OnlineNaiveBayes: + def __init__(self, alpha: float = 0.5, beta: float = 0.5, gamma: float = 1.0, vocab_size: int = 200000): + self.alpha = alpha + self.beta = beta + self.gamma = gamma + self.V = vocab_size + + self.cls_counts: Dict[str, float] = defaultdict(float) # cid -> total token count + self.token_counts: Dict[str, Dict[str, float]] = defaultdict(lambda: defaultdict(float)) # cid -> term -> count + self._logZ: Dict[str, float] = {} # cache log(∑counts + Vα) + + def _invalidate(self, cid: str): + if cid in self._logZ: + del self._logZ[cid] + + def _logZ_c(self, cid: str) -> float: + if cid not in self._logZ: + Z = self.cls_counts[cid] + self.V * self.alpha + self._logZ[cid] = math.log(max(Z, 1e-12)) + return self._logZ[cid] + + def score_batch(self, tf: Counter, cids: List[str]) -> Dict[str, float]: + total_cls = sum(self.cls_counts.values()) + n_cls = max(1, len(self.cls_counts)) + denom_prior = math.log(total_cls + self.beta * n_cls) + + out: Dict[str, float] = {} + for cid in cids: + prior = math.log(self.cls_counts[cid] + self.beta) - denom_prior + s = prior + logZ = self._logZ_c(cid) + tc = self.token_counts[cid] + for term, qtf in tf.items(): + num = tc.get(term, 0.0) + self.alpha + s += qtf * (math.log(num) - logZ) + out[cid] = s + return out + + def update_positive(self, tf: Counter, cid: str): + inc = 0.0 + tc = self.token_counts[cid] + for term, c in tf.items(): + tc[term] += float(c) + inc += float(c) + self.cls_counts[cid] += inc + self._invalidate(cid) + + def decay(self, factor: float = None): + g = self.gamma if factor is None else factor + if g >= 1.0: + return + for cid in list(self.cls_counts.keys()): + self.cls_counts[cid] *= g + for term in list(self.token_counts[cid].keys()): + self.token_counts[cid][term] *= g + self._invalidate(cid) \ No newline at end of file diff --git a/src/express/expressor_model/tokenizer.py b/src/express/expressor_model/tokenizer.py new file mode 100644 index 00000000..709e6a54 --- /dev/null +++ b/src/express/expressor_model/tokenizer.py @@ -0,0 +1,28 @@ +import re +from typing import List, Optional, Set + +try: + import jieba + _HAS_JIEBA = True +except Exception: + _HAS_JIEBA = False + +_WORD_RE = re.compile(r"[A-Za-z0-9_]+") + +def simple_en_tokenize(text: str) -> List[str]: + return _WORD_RE.findall(text.lower()) + +class Tokenizer: + def __init__(self, stopwords: Optional[Set[str]] = None, use_jieba: bool = True): + self.stopwords = stopwords or set() + self.use_jieba = use_jieba and _HAS_JIEBA + + def tokenize(self, text: str) -> List[str]: + text = (text or "").strip() + if not text: + return [] + if self.use_jieba: + toks = [t.strip().lower() for t in jieba.cut(text) if t.strip()] + else: + toks = simple_en_tokenize(text) + return [t for t in toks if t not in self.stopwords] \ No newline at end of file diff --git a/src/express/style_learner.py b/src/express/style_learner.py new file mode 100644 index 00000000..4cacba78 --- /dev/null +++ b/src/express/style_learner.py @@ -0,0 +1,628 @@ +""" +多聊天室表达风格学习系统 +支持为每个chat_id维护独立的表达模型，学习从up_content到style的映射 +""" + +import os +import pickle +import traceback +from typing import Dict, List, Optional, Tuple +from collections import defaultdict +import asyncio + +from src.common.logger import get_logger +from .expressor_model.model import ExpressorModel + +logger = get_logger("style_learner") + + +class StyleLearner: + """ + 单个聊天室的表达风格学习器 + 学习从up_content到style的映射关系 + 支持动态管理风格集合（最多2000个） + """ + + def __init__(self, chat_id: str, model_config: Optional[Dict] = None): + self.chat_id = chat_id + self.model_config = model_config or { + "alpha": 0.5, + "beta": 0.5, + "gamma": 0.99, # 衰减因子，支持遗忘 + "vocab_size": 200000, + "use_jieba": True + } + + # 初始化表达模型 + self.expressor = ExpressorModel(**self.model_config) + + # 动态风格管理 + self.max_styles = 2000 # 每个chat_id最多2000个风格 + self.style_to_id: Dict[str, str] = {} # style文本 -> style_id + self.id_to_style: Dict[str, str] = {} # style_id -> style文本 + self.id_to_situation: Dict[str, str] = {} # style_id -> situation文本 + self.next_style_id = 0 # 下一个可用的style_id + + # 学习统计 + self.learning_stats = { + "total_samples": 0, + "style_counts": defaultdict(int), + "last_update": None, + "style_usage_frequency": defaultdict(int) # 风格使用频率 + } + + def add_style(self, style: str, situation: str = None) -> bool: + """ + 动态添加一个新的风格 + + Args: + style: 风格文本 + situation: 对应的situation文本（可选） + + Returns: + bool: 添加是否成功 + """ + try: + # 检查是否已存在 + if style in self.style_to_id: + logger.debug(f"[{self.chat_id}] 风格 '{style}' 已存在") + return True + + # 检查是否超过最大限制 + if len(self.style_to_id) >= self.max_styles: + logger.warning(f"[{self.chat_id}] 已达到最大风格数量限制 ({self.max_styles})") + return False + + # 生成新的style_id + style_id = f"style_{self.next_style_id}" + self.next_style_id += 1 + + # 添加到映射 + self.style_to_id[style] = style_id + self.id_to_style[style_id] = style + if situation: + self.id_to_situation[style_id] = situation + + # 添加到expressor模型 + self.expressor.add_candidate(style_id, style, situation) + + logger.info(f"[{self.chat_id}] 已添加风格: '{style}' (ID: {style_id})" + + (f", situation: '{situation}'" if situation else "")) + return True + + except Exception as e: + logger.error(f"[{self.chat_id}] 添加风格失败: {e}") + return False + + def remove_style(self, style: str) -> bool: + """ + 删除一个风格 + + Args: + style: 要删除的风格文本 + + Returns: + bool: 删除是否成功 + """ + try: + if style not in self.style_to_id: + logger.warning(f"[{self.chat_id}] 风格 '{style}' 不存在") + return False + + style_id = self.style_to_id[style] + + # 从映射中删除 + del self.style_to_id[style] + del self.id_to_style[style_id] + if style_id in self.id_to_situation: + del self.id_to_situation[style_id] + + # 从expressor模型中删除（通过重新构建） + self._rebuild_expressor() + + logger.info(f"[{self.chat_id}] 已删除风格: '{style}' (ID: {style_id})") + return True + + except Exception as e: + logger.error(f"[{self.chat_id}] 删除风格失败: {e}") + return False + + def update_style(self, old_style: str, new_style: str) -> bool: + """ + 更新一个风格 + + Args: + old_style: 原风格文本 + new_style: 新风格文本 + + Returns: + bool: 更新是否成功 + """ + try: + if old_style not in self.style_to_id: + logger.warning(f"[{self.chat_id}] 原风格 '{old_style}' 不存在") + return False + + if new_style in self.style_to_id and new_style != old_style: + logger.warning(f"[{self.chat_id}] 新风格 '{new_style}' 已存在") + return False + + style_id = self.style_to_id[old_style] + + # 更新映射 + del self.style_to_id[old_style] + self.style_to_id[new_style] = style_id + self.id_to_style[style_id] = new_style + + # 更新expressor模型（保留原有的situation） + situation = self.id_to_situation.get(style_id) + self.expressor.add_candidate(style_id, new_style, situation) + + logger.info(f"[{self.chat_id}] 已更新风格: '{old_style}' -> '{new_style}'") + return True + + except Exception as e: + logger.error(f"[{self.chat_id}] 更新风格失败: {e}") + return False + + def add_styles_batch(self, styles: List[str], situations: List[str] = None) -> int: + """ + 批量添加风格 + + Args: + styles: 风格文本列表 + situations: 对应的situation文本列表（可选） + + Returns: + int: 成功添加的数量 + """ + success_count = 0 + for i, style in enumerate(styles): + situation = situations[i] if situations and i < len(situations) else None + if self.add_style(style, situation): + success_count += 1 + + logger.info(f"[{self.chat_id}] 批量添加风格: {success_count}/{len(styles)} 成功") + return success_count + + def get_all_styles(self) -> List[str]: + """获取所有已注册的风格""" + return list(self.style_to_id.keys()) + + def get_style_count(self) -> int: + """获取当前风格数量""" + return len(self.style_to_id) + + def get_situation(self, style: str) -> Optional[str]: + """ + 获取风格对应的situation + + Args: + style: 风格文本 + + Returns: + Optional[str]: 对应的situation，如果不存在则返回None + """ + if style not in self.style_to_id: + return None + + style_id = self.style_to_id[style] + return self.id_to_situation.get(style_id) + + def get_style_info(self, style: str) -> Tuple[Optional[str], Optional[str]]: + """ + 获取风格的完整信息 + + Args: + style: 风格文本 + + Returns: + Tuple[Optional[str], Optional[str]]: (style_id, situation) + """ + if style not in self.style_to_id: + return None, None + + style_id = self.style_to_id[style] + situation = self.id_to_situation.get(style_id) + return style_id, situation + + def get_all_style_info(self) -> Dict[str, Tuple[str, Optional[str]]]: + """ + 获取所有风格的完整信息 + + Returns: + Dict[str, Tuple[str, Optional[str]]]: {style: (style_id, situation)} + """ + result = {} + for style, style_id in self.style_to_id.items(): + situation = self.id_to_situation.get(style_id) + result[style] = (style_id, situation) + return result + + def _rebuild_expressor(self): + """重新构建expressor模型（删除风格后使用）""" + try: + # 重新创建expressor + self.expressor = ExpressorModel(**self.model_config) + + # 重新添加所有风格和situation + for style_id, style_text in self.id_to_style.items(): + situation = self.id_to_situation.get(style_id) + self.expressor.add_candidate(style_id, style_text, situation) + + logger.debug(f"[{self.chat_id}] 已重新构建expressor模型") + + except Exception as e: + logger.error(f"[{self.chat_id}] 重新构建expressor失败: {e}") + + def learn_mapping(self, up_content: str, style: str) -> bool: + """ + 学习一个up_content到style的映射 + 如果style不存在，会自动添加 + + Args: + up_content: 输入内容 + style: 对应的style文本 + + Returns: + bool: 学习是否成功 + """ + try: + # 如果style不存在，先添加它 + if style not in self.style_to_id: + if not self.add_style(style): + logger.warning(f"[{self.chat_id}] 无法添加风格 '{style}'，学习失败") + return False + + # 获取style_id + style_id = self.style_to_id[style] + + # 使用正反馈学习 + self.expressor.update_positive(up_content, style_id) + + # 更新统计 + self.learning_stats["total_samples"] += 1 + self.learning_stats["style_counts"][style_id] += 1 + self.learning_stats["style_usage_frequency"][style] += 1 + self.learning_stats["last_update"] = asyncio.get_event_loop().time() + + logger.debug(f"[{self.chat_id}] 学习映射: '{up_content}' -> '{style}'") + return True + + except Exception as e: + logger.error(f"[{self.chat_id}] 学习映射失败: {e}") + traceback.print_exc() + return False + + def predict_style(self, up_content: str, top_k: int = 5) -> Tuple[Optional[str], Dict[str, float]]: + """ + 根据up_content预测最合适的style + + Args: + up_content: 输入内容 + top_k: 返回前k个候选 + + Returns: + Tuple[最佳style文本, 所有候选的分数] + """ + try: + best_style_id, scores = self.expressor.predict(up_content, k=top_k) + + if best_style_id is None: + return None, {} + + # 将style_id转换为style文本 + best_style = self.id_to_style.get(best_style_id) + + # 转换所有分数 + style_scores = {} + for sid, score in scores.items(): + style_text = self.id_to_style.get(sid) + if style_text: + style_scores[style_text] = score + + return best_style, style_scores + + except Exception as e: + logger.error(f"[{self.chat_id}] 预测style失败: {e}") + traceback.print_exc() + return None, {} + + def decay_learning(self, factor: Optional[float] = None) -> None: + """ + 对学习到的知识进行衰减（遗忘） + + Args: + factor: 衰减因子，None则使用配置中的gamma + """ + self.expressor.decay(factor) + logger.debug(f"[{self.chat_id}] 执行知识衰减") + + def get_stats(self) -> Dict: + """获取学习统计信息""" + return { + "chat_id": self.chat_id, + "total_samples": self.learning_stats["total_samples"], + "style_count": len(self.style_to_id), + "max_styles": self.max_styles, + "style_counts": dict(self.learning_stats["style_counts"]), + "style_usage_frequency": dict(self.learning_stats["style_usage_frequency"]), + "last_update": self.learning_stats["last_update"], + "all_styles": list(self.style_to_id.keys()) + } + + def save(self, base_path: str) -> bool: + """ + 保存模型到文件 + + Args: + base_path: 基础路径，实际文件为 {base_path}/{chat_id}_style_model.pkl + """ + try: + os.makedirs(base_path, exist_ok=True) + file_path = os.path.join(base_path, f"{self.chat_id}_style_model.pkl") + + # 保存模型和统计信息 + save_data = { + "model_config": self.model_config, + "style_to_id": self.style_to_id, + "id_to_style": self.id_to_style, + "id_to_situation": self.id_to_situation, + "next_style_id": self.next_style_id, + "max_styles": self.max_styles, + "learning_stats": self.learning_stats + } + + # 先保存expressor模型 + expressor_path = os.path.join(base_path, f"{self.chat_id}_expressor.pkl") + self.expressor.save(expressor_path) + + # 保存其他数据 + with open(file_path, "wb") as f: + pickle.dump(save_data, f) + + logger.info(f"[{self.chat_id}] 模型已保存到 {file_path}") + return True + + except Exception as e: + logger.error(f"[{self.chat_id}] 保存模型失败: {e}") + return False + + def load(self, base_path: str) -> bool: + """ + 从文件加载模型 + + Args: + base_path: 基础路径 + """ + try: + file_path = os.path.join(base_path, f"{self.chat_id}_style_model.pkl") + expressor_path = os.path.join(base_path, f"{self.chat_id}_expressor.pkl") + + if not os.path.exists(file_path) or not os.path.exists(expressor_path): + logger.warning(f"[{self.chat_id}] 模型文件不存在，将使用默认配置") + return False + + # 加载其他数据 + with open(file_path, "rb") as f: + save_data = pickle.load(f) + + # 恢复配置和状态 + self.model_config = save_data["model_config"] + self.style_to_id = save_data["style_to_id"] + self.id_to_style = save_data["id_to_style"] + self.id_to_situation = save_data.get("id_to_situation", {}) # 兼容旧版本 + self.next_style_id = save_data["next_style_id"] + self.max_styles = save_data.get("max_styles", 2000) + self.learning_stats = save_data["learning_stats"] + + # 重新创建expressor并加载 + self.expressor = ExpressorModel(**self.model_config) + self.expressor.load(expressor_path) + + logger.info(f"[{self.chat_id}] 模型已从 {file_path} 加载") + return True + + except Exception as e: + logger.error(f"[{self.chat_id}] 加载模型失败: {e}") + return False + + +class StyleLearnerManager: + """ + 多聊天室表达风格学习管理器 + 为每个chat_id维护独立的StyleLearner实例 + 每个chat_id可以动态管理自己的风格集合（最多2000个） + """ + + def __init__(self, model_save_path: str = "data/style_models"): + self.model_save_path = model_save_path + self.learners: Dict[str, StyleLearner] = {} + + # 自动保存配置 + self.auto_save_interval = 300 # 5分钟 + self._auto_save_task: Optional[asyncio.Task] = None + + logger.info("StyleLearnerManager 已初始化") + + def get_learner(self, chat_id: str, model_config: Optional[Dict] = None) -> StyleLearner: + """ + 获取或创建指定chat_id的学习器 + + Args: + chat_id: 聊天室ID + model_config: 模型配置，None则使用默认配置 + + Returns: + StyleLearner实例 + """ + if chat_id not in self.learners: + # 创建新的学习器 + learner = StyleLearner(chat_id, model_config) + + # 尝试加载已保存的模型 + learner.load(self.model_save_path) + + self.learners[chat_id] = learner + logger.info(f"为 chat_id={chat_id} 创建新的StyleLearner") + + return self.learners[chat_id] + + def add_style(self, chat_id: str, style: str) -> bool: + """ + 为指定chat_id添加风格 + + Args: + chat_id: 聊天室ID + style: 风格文本 + + Returns: + bool: 添加是否成功 + """ + learner = self.get_learner(chat_id) + return learner.add_style(style) + + def remove_style(self, chat_id: str, style: str) -> bool: + """ + 为指定chat_id删除风格 + + Args: + chat_id: 聊天室ID + style: 风格文本 + + Returns: + bool: 删除是否成功 + """ + learner = self.get_learner(chat_id) + return learner.remove_style(style) + + def update_style(self, chat_id: str, old_style: str, new_style: str) -> bool: + """ + 为指定chat_id更新风格 + + Args: + chat_id: 聊天室ID + old_style: 原风格文本 + new_style: 新风格文本 + + Returns: + bool: 更新是否成功 + """ + learner = self.get_learner(chat_id) + return learner.update_style(old_style, new_style) + + def get_chat_styles(self, chat_id: str) -> List[str]: + """ + 获取指定chat_id的所有风格 + + Args: + chat_id: 聊天室ID + + Returns: + List[str]: 风格列表 + """ + learner = self.get_learner(chat_id) + return learner.get_all_styles() + + def learn_mapping(self, chat_id: str, up_content: str, style: str) -> bool: + """ + 学习一个映射关系 + + Args: + chat_id: 聊天室ID + up_content: 输入内容 + style: 对应的style + + Returns: + bool: 学习是否成功 + """ + learner = self.get_learner(chat_id) + return learner.learn_mapping(up_content, style) + + def predict_style(self, chat_id: str, up_content: str, top_k: int = 5) -> Tuple[Optional[str], Dict[str, float]]: + """ + 预测最合适的style + + Args: + chat_id: 聊天室ID + up_content: 输入内容 + top_k: 返回前k个候选 + + Returns: + Tuple[最佳style, 所有候选分数] + """ + learner = self.get_learner(chat_id) + return learner.predict_style(up_content, top_k) + + def decay_all_learners(self, factor: Optional[float] = None) -> None: + """ + 对所有学习器执行衰减 + + Args: + factor: 衰减因子 + """ + for learner in self.learners.values(): + learner.decay_learning(factor) + logger.info("已对所有学习器执行衰减") + + def get_all_stats(self) -> Dict[str, Dict]: + """获取所有学习器的统计信息""" + return {chat_id: learner.get_stats() for chat_id, learner in self.learners.items()} + + def save_all_models(self) -> bool: + """保存所有模型""" + success_count = 0 + for learner in self.learners.values(): + if learner.save(self.model_save_path): + success_count += 1 + + logger.info(f"已保存 {success_count}/{len(self.learners)} 个模型") + return success_count == len(self.learners) + + def load_all_models(self) -> int: + """加载所有已保存的模型""" + if not os.path.exists(self.model_save_path): + return 0 + + loaded_count = 0 + for filename in os.listdir(self.model_save_path): + if filename.endswith("_style_model.pkl"): + chat_id = filename.replace("_style_model.pkl", "") + learner = StyleLearner(chat_id) + if learner.load(self.model_save_path): + self.learners[chat_id] = learner + loaded_count += 1 + + logger.info(f"已加载 {loaded_count} 个模型") + return loaded_count + + async def start_auto_save(self) -> None: + """启动自动保存任务""" + if self._auto_save_task is None or self._auto_save_task.done(): + self._auto_save_task = asyncio.create_task(self._auto_save_loop()) + logger.info("已启动自动保存任务") + + async def stop_auto_save(self) -> None: + """停止自动保存任务""" + if self._auto_save_task and not self._auto_save_task.done(): + self._auto_save_task.cancel() + try: + await self._auto_save_task + except asyncio.CancelledError: + pass + logger.info("已停止自动保存任务") + + async def _auto_save_loop(self) -> None: + """自动保存循环""" + while True: + try: + await asyncio.sleep(self.auto_save_interval) + self.save_all_models() + except asyncio.CancelledError: + break + except Exception as e: + logger.error(f"自动保存失败: {e}") + + +# 全局管理器实例 +style_learner_manager = StyleLearnerManager() diff --git a/src/llm_models/exceptions.py b/src/llm_models/exceptions.py index bf1c88de..65e49f74 100644 --- a/src/llm_models/exceptions.py +++ b/src/llm_models/exceptions.py @@ -85,4 +85,4 @@ class ModelAttemptFailed(Exception): self.original_exception = original_exception def __str__(self): - return self.message \ No newline at end of file + return self.message diff --git a/src/llm_models/model_client/base_client.py b/src/llm_models/model_client/base_client.py index eb74b0df..dcb710fe 100644 --- a/src/llm_models/model_client/base_client.py +++ b/src/llm_models/model_client/base_client.py @@ -72,8 +72,8 @@ class BaseClient(ABC): model_info: ModelInfo, message_list: list[Message], tool_options: list[ToolOption] | None = None, - max_tokens: int = 1024, - temperature: float = 0.7, + max_tokens: Optional[int] = None, + temperature: Optional[float] = None, response_format: RespFormat | None = None, stream_response_handler: Optional[ Callable[[Any, asyncio.Event | None], tuple[APIResponse, tuple[int, int, int]]] @@ -117,6 +117,7 @@ class BaseClient(ABC): self, model_info: ModelInfo, audio_base64: str, + max_tokens: Optional[int] = None, extra_params: dict[str, Any] | None = None, ) -> APIResponse: """ diff --git a/src/llm_models/model_client/gemini_client.py b/src/llm_models/model_client/gemini_client.py index e58466d1..e8cf44f7 100644 --- a/src/llm_models/model_client/gemini_client.py +++ b/src/llm_models/model_client/gemini_client.py @@ -1,7 +1,7 @@ import asyncio import io import base64 -from typing import Callable, AsyncIterator, Optional, Coroutine, Any, List +from typing import Callable, AsyncIterator, Optional, Coroutine, Any, List, Dict from google import genai from google.genai.types import ( @@ -17,6 +17,7 @@ from google.genai.types import ( EmbedContentResponse, EmbedContentConfig, SafetySetting, + HttpOptions, HarmCategory, HarmBlockThreshold, ) @@ -182,6 +183,14 @@ def _process_delta( if delta.text: fc_delta_buffer.write(delta.text) + # 处理 thought（Gemini 的特殊字段） + for c in getattr(delta, "candidates", []): + if c.content and getattr(c.content, "parts", None): + for p in c.content.parts: + if getattr(p, "thought", False) and getattr(p, "text", None): + # 把 thought 写入 buffer，避免 resp.content 永远为空 + fc_delta_buffer.write(p.text) + if delta.function_calls: # 为什么不用hasattr呢，是因为这个属性一定有，即使是个空的 for call in delta.function_calls: try: @@ -203,6 +212,7 @@ def _process_delta( def _build_stream_api_resp( _fc_delta_buffer: io.StringIO, _tool_calls_buffer: list[tuple[str, str, dict]], + last_resp: GenerateContentResponse | None = None, # 传入 last_resp ) -> APIResponse: # sourcery skip: simplify-len-comparison, use-assigned-variable resp = APIResponse() @@ -227,6 +237,21 @@ def _build_stream_api_resp( resp.tool_calls.append(ToolCall(call_id, function_name, arguments)) + # 检查是否因为 max_tokens 截断 + reason = None + if last_resp and getattr(last_resp, "candidates", None): + c0 = last_resp.candidates[0] + reason = getattr(c0, "finish_reason", None) or getattr(c0, "finishReason", None) + + if str(reason).endswith("MAX_TOKENS"): + if resp.content and resp.content.strip(): + logger.warning( + "⚠ Gemini 响应因达到 max_tokens 限制被部分截断，\n" + " 可能会对回复内容造成影响，建议修改模型 max_tokens 配置！" + ) + else: + logger.warning("⚠ Gemini 响应因达到 max_tokens 限制被截断，\n 请修改模型 max_tokens 配置！") + if not resp.content and not resp.tool_calls: raise EmptyResponseException() @@ -245,12 +270,14 @@ async def _default_stream_response_handler( _fc_delta_buffer = io.StringIO() # 正式内容缓冲区，用于存储接收到的正式内容 _tool_calls_buffer: list[tuple[str, str, dict]] = [] # 工具调用缓冲区，用于存储接收到的工具调用 _usage_record = None # 使用情况记录 + last_resp: GenerateContentResponse | None = None # 保存最后一个 chunk def _insure_buffer_closed(): if _fc_delta_buffer and not _fc_delta_buffer.closed: _fc_delta_buffer.close() async for chunk in resp_stream: + last_resp = chunk # 保存最后一个响应 # 检查是否有中断量 if interrupt_flag and interrupt_flag.is_set(): # 如果中断量被设置，则抛出ReqAbortException @@ -269,10 +296,12 @@ async def _default_stream_response_handler( (chunk.usage_metadata.candidates_token_count or 0) + (chunk.usage_metadata.thoughts_token_count or 0), chunk.usage_metadata.total_token_count or 0, ) + try: return _build_stream_api_resp( _fc_delta_buffer, _tool_calls_buffer, + last_resp=last_resp, ), _usage_record except Exception: # 确保缓冲区被关闭 @@ -332,6 +361,35 @@ def _default_normal_response_parser( api_response.raw_data = resp + # 检查是否因为 max_tokens 截断 + try: + if resp.candidates: + c0 = resp.candidates[0] + reason = getattr(c0, "finish_reason", None) or getattr(c0, "finishReason", None) + if reason and "MAX_TOKENS" in str(reason): + # 检查第二个及之后的 parts 是否有内容 + has_real_output = False + if getattr(c0, "content", None) and getattr(c0.content, "parts", None): + for p in c0.content.parts[1:]: # 跳过第一个 thought + if getattr(p, "text", None) and p.text.strip(): + has_real_output = True + break + + if not has_real_output and getattr(resp, "text", None): + has_real_output = True + + if has_real_output: + logger.warning( + "⚠ Gemini 响应因达到 max_tokens 限制被部分截断，\n" + " 可能会对回复内容造成影响，建议修改模型 max_tokens 配置！" + ) + else: + logger.warning("⚠ Gemini 响应因达到 max_tokens 限制被截断，\n 请修改模型 max_tokens 配置！") + + return api_response, _usage_record + except Exception as e: + logger.debug(f"检查 MAX_TOKENS 截断时异常: {e}") + # 最终的、唯一的空响应检查 if not api_response.content and not api_response.tool_calls: raise EmptyResponseException("响应中既无文本内容也无工具调用") @@ -345,17 +403,45 @@ class GeminiClient(BaseClient): def __init__(self, api_provider: APIProvider): super().__init__(api_provider) + + # 增加传入参数处理 + http_options_kwargs: Dict[str, Any] = {} + + # 秒转换为毫秒传入 + if api_provider.timeout is not None: + http_options_kwargs["timeout"] = int(api_provider.timeout * 1000) + + # 传入并处理地址和版本(必须为Gemini格式) + if api_provider.base_url: + parts = api_provider.base_url.rstrip("/").rsplit("/", 1) + if len(parts) == 2 and parts[1].startswith("v"): + http_options_kwargs["base_url"] = f"{parts[0]}/" + http_options_kwargs["api_version"] = parts[1] + else: + http_options_kwargs["base_url"] = api_provider.base_url + http_options_kwargs["api_version"] = None self.client = genai.Client( + http_options=HttpOptions(**http_options_kwargs), api_key=api_provider.api_key, ) # 这里和openai不一样，gemini会自己决定自己是否需要retry @staticmethod - def clamp_thinking_budget(tb: int, model_id: str) -> int: + def clamp_thinking_budget(extra_params: dict[str, Any] | None, model_id: str) -> int: """ 按模型限制思考预算范围，仅支持指定的模型（支持带数字后缀的新版本） """ limits = None + # 参数传入处理 + tb = THINKING_BUDGET_AUTO + if extra_params and "thinking_budget" in extra_params: + try: + tb = int(extra_params["thinking_budget"]) + except (ValueError, TypeError): + logger.warning( + f"无效的 thinking_budget 值 {extra_params['thinking_budget']}，将使用模型自动预算模式 {tb}" + ) + # 优先尝试精确匹配 if model_id in THINKING_BUDGET_LIMITS: limits = THINKING_BUDGET_LIMITS[model_id] @@ -368,20 +454,29 @@ class GeminiClient(BaseClient): limits = THINKING_BUDGET_LIMITS[key] break - # 特殊值处理 + # 预算值处理 if tb == THINKING_BUDGET_AUTO: return THINKING_BUDGET_AUTO if tb == THINKING_BUDGET_DISABLED: if limits and limits.get("can_disable", False): return THINKING_BUDGET_DISABLED - return limits["min"] if limits else THINKING_BUDGET_AUTO + if limits: + logger.warning(f"模型 {model_id} 不支持禁用思考预算，已回退到最小值 {limits['min']}") + return limits["min"] + return THINKING_BUDGET_AUTO - # 已知模型裁剪到范围 + # 已知模型范围裁剪 + 提示 if limits: - return max(limits["min"], min(tb, limits["max"])) + if tb < limits["min"]: + logger.warning(f"模型 {model_id} 的 thinking_budget={tb} 过小，已调整为最小值 {limits['min']}") + return limits["min"] + if tb > limits["max"]: + logger.warning(f"模型 {model_id} 的 thinking_budget={tb} 过大，已调整为最大值 {limits['max']}") + return limits["max"] + return tb - # 未知模型，返回动态模式 - logger.warning(f"模型 {model_id} 未在 THINKING_BUDGET_LIMITS 中定义，将使用动态模式 tb=-1 兼容。") + # 未知模型 → 默认自动模式 + logger.warning(f"模型 {model_id} 未在 THINKING_BUDGET_LIMITS 中定义，已启用模型自动预算兼容") return THINKING_BUDGET_AUTO async def get_response( @@ -389,8 +484,8 @@ class GeminiClient(BaseClient): model_info: ModelInfo, message_list: list[Message], tool_options: list[ToolOption] | None = None, - max_tokens: int = 1024, - temperature: float = 0.4, + max_tokens: Optional[int] = 1024, + temperature: Optional[float] = 0.4, response_format: RespFormat | None = None, stream_response_handler: Optional[ Callable[ @@ -429,16 +524,8 @@ class GeminiClient(BaseClient): messages = _convert_messages(message_list) # 将tool_options转换为Gemini API所需的格式 tools = _convert_tool_options(tool_options) if tool_options else None - - tb = THINKING_BUDGET_AUTO - # 空处理 - if extra_params and "thinking_budget" in extra_params: - try: - tb = int(extra_params["thinking_budget"]) - except (ValueError, TypeError): - logger.warning(f"无效的 thinking_budget 值 {extra_params['thinking_budget']}，将使用默认动态模式 {tb}") - # 裁剪到模型支持的范围 - tb = self.clamp_thinking_budget(tb, model_info.model_identifier) + # 解析并裁剪 thinking_budget + tb = self.clamp_thinking_budget(extra_params, model_info.model_identifier) # 将response_format转换为Gemini API所需的格式 generation_config_dict = { @@ -497,15 +584,20 @@ class GeminiClient(BaseClient): resp, usage_record = async_response_parser(req_task.result()) except (ClientError, ServerError) as e: - # 重封装ClientError和ServerError为RespNotOkException + # 重封装 ClientError 和 ServerError 为 RespNotOkException raise RespNotOkException(e.code, e.message) from None except ( UnknownFunctionCallArgumentError, UnsupportedFunctionError, FunctionInvocationError, ) as e: - raise ValueError(f"工具类型错误：请检查工具选项和参数：{str(e)}") from None + # 工具调用相关错误 + raise RespParseException(None, f"工具调用参数错误: {str(e)}") from None + except EmptyResponseException as e: + # 保持原始异常，便于区分“空响应”和网络异常 + raise e except Exception as e: + # 其他未预料的错误，才归为网络连接类 raise NetworkConnectionError() from e if usage_record: @@ -561,41 +653,51 @@ class GeminiClient(BaseClient): return response - def get_audio_transcriptions( - self, model_info: ModelInfo, audio_base64: str, extra_params: dict[str, Any] | None = None + async def get_audio_transcriptions( + self, + model_info: ModelInfo, + audio_base64: str, + max_tokens: Optional[int] = 2048, + extra_params: dict[str, Any] | None = None, ) -> APIResponse: """ 获取音频转录 :param model_info: 模型信息 :param audio_base64: 音频文件的Base64编码字符串 + :param max_tokens: 最大输出token数（默认2048） :param extra_params: 额外参数（可选） :return: 转录响应 """ + # 解析并裁剪 thinking_budget + tb = self.clamp_thinking_budget(extra_params, model_info.model_identifier) + + # 构造 prompt + 音频输入 + prompt = "Generate a transcript of the speech. The language of the transcript should **match the language of the speech**." + contents = [ + Content( + role="user", + parts=[ + Part.from_text(text=prompt), + Part.from_bytes(data=base64.b64decode(audio_base64), mime_type="audio/wav"), + ], + ) + ] + generation_config_dict = { - "max_output_tokens": 2048, + "max_output_tokens": max_tokens, "response_modalities": ["TEXT"], "thinking_config": ThinkingConfig( include_thoughts=True, - thinking_budget=( - extra_params["thinking_budget"] if extra_params and "thinking_budget" in extra_params else 1024 - ), + thinking_budget=tb, ), "safety_settings": gemini_safe_settings, } generate_content_config = GenerateContentConfig(**generation_config_dict) - prompt = "Generate a transcript of the speech. The language of the transcript should **match the language of the speech**." + try: - raw_response: GenerateContentResponse = self.client.models.generate_content( + raw_response: GenerateContentResponse = await self.client.aio.models.generate_content( model=model_info.model_identifier, - contents=[ - Content( - role="user", - parts=[ - Part.from_text(text=prompt), - Part.from_bytes(data=base64.b64decode(audio_base64), mime_type="audio/wav"), - ], - ) - ], + contents=contents, config=generate_content_config, ) resp, usage_record = _default_normal_response_parser(raw_response) diff --git a/src/llm_models/model_client/openai_client.py b/src/llm_models/model_client/openai_client.py index 34134a15..148ec8cb 100644 --- a/src/llm_models/model_client/openai_client.py +++ b/src/llm_models/model_client/openai_client.py @@ -403,8 +403,8 @@ class OpenaiClient(BaseClient): model_info: ModelInfo, message_list: list[Message], tool_options: list[ToolOption] | None = None, - max_tokens: int = 1024, - temperature: float = 0.7, + max_tokens: Optional[int] = 1024, + temperature: Optional[float] = 0.7, response_format: RespFormat | None = None, stream_response_handler: Optional[ Callable[ @@ -488,6 +488,9 @@ class OpenaiClient(BaseClient): raise ReqAbortException("请求被外部信号中断") await asyncio.sleep(0.1) # 等待0.5秒后再次检查任务&中断信号量状态 + # logger. + logger.debug(f"OpenAI API响应(非流式): {req_task.result()}") + # logger.info(f"OpenAI请求时间: {model_info.model_identifier} {time.time() - start_time} \n{messages}") resp, usage_record = async_response_parser(req_task.result()) @@ -507,6 +510,8 @@ class OpenaiClient(BaseClient): total_tokens=usage_record[2], ) + # logger.debug(f"OpenAI API响应: {resp}") + return resp async def get_embedding( diff --git a/src/llm_models/utils_model.py b/src/llm_models/utils_model.py index 8bb35ef0..4d7865d9 100644 --- a/src/llm_models/utils_model.py +++ b/src/llm_models/utils_model.py @@ -26,18 +26,6 @@ install(extra_lines=3) logger = get_logger("model_utils") -# 常见Error Code Mapping -error_code_mapping = { - 400: "参数不正确", - 401: "API key 错误，认证失败，请检查 config/model_config.toml 中的配置是否正确", - 402: "账号余额不足", - 403: "需要实名,或余额不足", - 404: "Not Found", - 429: "请求过于频繁，请稍后再试", - 500: "服务器内部故障", - 503: "服务器负载过高", -} - class RequestType(Enum): """请求类型枚举""" @@ -160,6 +148,8 @@ class LLMRequest: ) logger.debug(f"LLM请求总耗时: {time.time() - start_time}") + logger.debug(f"LLM生成内容: {response}") + content = response.content reasoning_content = response.reasoning_content or "" tool_calls = response.tool_calls @@ -267,14 +257,14 @@ class LLMRequest: extra_params=model_info.extra_params, ) elif request_type == RequestType.EMBEDDING: - assert embedding_input is not None + assert embedding_input is not None, "嵌入输入不能为空" return await client.get_embedding( model_info=model_info, embedding_input=embedding_input, extra_params=model_info.extra_params, ) elif request_type == RequestType.AUDIO: - assert audio_base64 is not None + assert audio_base64 is not None, "音频Base64不能为空" return await client.get_audio_transcriptions( model_info=model_info, audio_base64=audio_base64, @@ -365,24 +355,23 @@ class LLMRequest: embedding_input=embedding_input, audio_base64=audio_base64, ) + total_tokens, penalty, usage_penalty = self.model_usage[model_info.name] + if response_usage := response.usage: + total_tokens += response_usage.total_tokens + self.model_usage[model_info.name] = (total_tokens, penalty, usage_penalty - 1) return response, model_info except ModelAttemptFailed as e: last_exception = e.original_exception or e logger.warning(f"模型 '{model_info.name}' 尝试失败，切换到下一个模型。原因: {e}") total_tokens, penalty, usage_penalty = self.model_usage[model_info.name] - self.model_usage[model_info.name] = (total_tokens, penalty + 1, usage_penalty) + self.model_usage[model_info.name] = (total_tokens, penalty + 1, usage_penalty - 1) failed_models_this_request.add(model_info.name) if isinstance(last_exception, RespNotOkException) and last_exception.status_code == 400: logger.error("收到不可恢复的客户端错误 (400)，中止所有尝试。") raise last_exception from e - finally: - total_tokens, penalty, usage_penalty = self.model_usage[model_info.name] - if usage_penalty > 0: - self.model_usage[model_info.name] = (total_tokens, penalty, usage_penalty - 1) - logger.error(f"所有 {max_attempts} 个模型均尝试失败。") if last_exception: raise last_exception diff --git a/src/main.py b/src/main.py index e4935559..f02a7098 100644 --- a/src/main.py +++ b/src/main.py @@ -13,8 +13,8 @@ from src.common.logger import get_logger from src.common.server import get_global_server, Server from src.mood.mood_manager import mood_manager from src.chat.knowledge import lpmm_start_up +from src.memory_system.memory_management_task import MemoryManagementTask from rich.traceback import install -from src.migrate_helper.migrate import check_and_run_migrations # from src.api.main import start_api_server # 导入新的插件管理器 @@ -83,22 +83,19 @@ class MainSystem: logger.info("表情包管理器初始化成功") # 启动情绪管理器 - await mood_manager.start() - logger.info("情绪管理器初始化成功") + if global_config.mood.enable_mood: + await mood_manager.start() + logger.info("情绪管理器初始化成功") # 初始化聊天管理器 await get_chat_manager()._initialize() asyncio.create_task(get_chat_manager()._auto_save_task()) logger.info("聊天管理器初始化成功") - - # # 根据配置条件性地初始化记忆系统 - # if global_config.memory.enable_memory: - # if self.hippocampus_manager: - # self.hippocampus_manager.initialize() - # logger.info("记忆系统初始化成功") - # else: - # logger.info("记忆系统已禁用，跳过初始化") + + # 添加记忆管理任务 + await async_task_manager.add_task(MemoryManagementTask()) + logger.info("记忆管理任务已启动") # await asyncio.sleep(0.5) #防止logger输出飞了 @@ -106,7 +103,6 @@ class MainSystem: self.app.register_message_handler(chat_bot.message_process) self.app.register_custom_message_handler("message_id_echo", chat_bot.echo_message_process) - await check_and_run_migrations() # 触发 ON_START 事件 from src.plugin_system.core.events_manager import events_manager diff --git a/src/mais4u/config/old/s4u_config_20250715_141713.toml b/src/mais4u/config/old/s4u_config_20250715_141713.toml deleted file mode 100644 index 538fcd88..00000000 --- a/src/mais4u/config/old/s4u_config_20250715_141713.toml +++ /dev/null @@ -1,36 +0,0 @@ -[inner] -version = "1.0.0" - -#----以下是S4U聊天系统配置文件---- -# S4U (Smart 4 U) 聊天系统是MaiBot的核心对话模块 -# 支持优先级队列、消息中断、VIP用户等高级功能 -# -# 如果你想要修改配置文件，请在修改后将version的值进行变更 -# 如果新增项目，请参考src/mais4u/s4u_config.py中的S4UConfig类 -# -# 版本格式：主版本号.次版本号.修订号 -#----S4U配置说明结束---- - -[s4u] -# 消息管理配置 -message_timeout_seconds = 120 # 普通消息存活时间（秒），超过此时间的消息将被丢弃 -recent_message_keep_count = 6 # 保留最近N条消息，超出范围的普通消息将被移除 - -# 优先级系统配置 -at_bot_priority_bonus = 100.0 # @机器人时的优先级加成分数 -vip_queue_priority = true # 是否启用VIP队列优先级系统 -enable_message_interruption = true # 是否允许高优先级消息中断当前回复 - -# 打字效果配置 -typing_delay = 0.1 # 打字延迟时间（秒），模拟真实打字速度 -enable_dynamic_typing_delay = false # 是否启用基于文本长度的动态打字延迟 - -# 动态打字延迟参数（仅在enable_dynamic_typing_delay=true时生效） -chars_per_second = 15.0 # 每秒字符数，用于计算动态打字延迟 -min_typing_delay = 0.2 # 最小打字延迟（秒） -max_typing_delay = 2.0 # 最大打字延迟（秒） - -# 系统功能开关 -enable_old_message_cleanup = true # 是否自动清理过旧的普通消息 -enable_loading_indicator = true # 是否显示加载提示 - diff --git a/src/mais4u/config/s4u_config_template.toml b/src/mais4u/config/s4u_config_template.toml deleted file mode 100644 index bf04673d..00000000 --- a/src/mais4u/config/s4u_config_template.toml +++ /dev/null @@ -1,68 +0,0 @@ -[inner] -version = "1.2.0" - -#----以下是S4U聊天系统配置文件---- -# S4U (Smart 4 U) 聊天系统是MaiBot的核心对话模块 -# 支持优先级队列、消息中断、VIP用户等高级功能 -# -# 如果你想要修改配置文件，请在修改后将version的值进行变更 -# 如果新增项目，请参考src/mais4u/s4u_config.py中的S4UConfig类 -# -# 版本格式：主版本号.次版本号.修订号 -#----S4U配置说明结束---- - -[s4u] -enable_s4u = false -# 消息管理配置 -message_timeout_seconds = 120 # 普通消息存活时间（秒），超过此时间的消息将被丢弃 -recent_message_keep_count = 6 # 保留最近N条消息，超出范围的普通消息将被移除 - -# 优先级系统配置 -at_bot_priority_bonus = 100.0 # @机器人时的优先级加成分数 -vip_queue_priority = true # 是否启用VIP队列优先级系统 -enable_message_interruption = true # 是否允许高优先级消息中断当前回复 - -# 打字效果配置 -typing_delay = 0.1 # 打字延迟时间（秒），模拟真实打字速度 -enable_dynamic_typing_delay = false # 是否启用基于文本长度的动态打字延迟 - -# 动态打字延迟参数（仅在enable_dynamic_typing_delay=true时生效） -chars_per_second = 15.0 # 每秒字符数，用于计算动态打字延迟 -min_typing_delay = 0.2 # 最小打字延迟（秒） -max_typing_delay = 2.0 # 最大打字延迟（秒） - -# 系统功能开关 -enable_old_message_cleanup = true # 是否自动清理过旧的普通消息 - -enable_streaming_output = true # 是否启用流式输出，false时全部生成后一次性发送 - -max_context_message_length = 20 -max_core_message_length = 30 - -# 模型配置 -[models] -# 主要对话模型配置 -[models.chat] -name = "qwen3-8b" -provider = "BAILIAN" -pri_in = 0.5 -pri_out = 2 -temp = 0.7 -enable_thinking = false - -# 规划模型配置 -[models.motion] -name = "qwen3-32b" -provider = "BAILIAN" -pri_in = 0.5 -pri_out = 2 -temp = 0.7 -enable_thinking = false - -# 情感分析模型配置 -[models.emotion] -name = "qwen3-8b" -provider = "BAILIAN" -pri_in = 0.5 -pri_out = 2 -temp = 0.7 diff --git a/src/mais4u/mai_think.py b/src/mais4u/mai_think.py deleted file mode 100644 index 3daa5875..00000000 --- a/src/mais4u/mai_think.py +++ /dev/null @@ -1,167 +0,0 @@ -from src.chat.message_receive.chat_stream import get_chat_manager -import time -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager -from src.llm_models.utils_model import LLMRequest -from src.config.config import model_config -from src.chat.message_receive.message import MessageRecvS4U -from src.mais4u.mais4u_chat.s4u_msg_processor import S4UMessageProcessor -from src.mais4u.mais4u_chat.internal_manager import internal_manager -from src.common.logger import get_logger - -logger = get_logger(__name__) - - -def init_prompt(): - Prompt( - """ -你之前的内心想法是：{mind} - -{memory_block} -{relation_info_block} - -{chat_target} -{time_block} -{chat_info} -{identity} - -你刚刚在{chat_target_2},你你刚刚的心情是：{mood_state} ---------------------- -在这样的情况下，你对上面的内容，你对 {sender} 发送的 消息 “{target}” 进行了回复 -你刚刚选择回复的内容是：{reponse} -现在，根据你之前的想法和回复的内容，推测你现在的想法，思考你现在的想法是什么，为什么做出上面的回复内容 -请不要浮夸和夸张修辞，不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出想法：""", - "after_response_think_prompt", - ) - - -class MaiThinking: - def __init__(self, chat_id): - self.chat_id = chat_id - self.chat_stream = get_chat_manager().get_stream(chat_id) - self.platform = self.chat_stream.platform - - if self.chat_stream.group_info: - self.is_group = True - else: - self.is_group = False - - self.s4u_message_processor = S4UMessageProcessor() - - self.mind = "" - - self.memory_block = "" - self.relation_info_block = "" - self.time_block = "" - self.chat_target = "" - self.chat_target_2 = "" - self.chat_info = "" - self.mood_state = "" - self.identity = "" - self.sender = "" - self.target = "" - - self.thinking_model = LLMRequest(model_set=model_config.model_task_config.replyer, request_type="thinking") - - async def do_think_before_response(self): - pass - - async def do_think_after_response(self, reponse: str): - prompt = await global_prompt_manager.format_prompt( - "after_response_think_prompt", - mind=self.mind, - reponse=reponse, - memory_block=self.memory_block, - relation_info_block=self.relation_info_block, - time_block=self.time_block, - chat_target=self.chat_target, - chat_target_2=self.chat_target_2, - chat_info=self.chat_info, - mood_state=self.mood_state, - identity=self.identity, - sender=self.sender, - target=self.target, - ) - - result, _ = await self.thinking_model.generate_response_async(prompt) - self.mind = result - - logger.info(f"[{self.chat_id}] 思考前想法：{self.mind}") - # logger.info(f"[{self.chat_id}] 思考前prompt：{prompt}") - logger.info(f"[{self.chat_id}] 思考后想法：{self.mind}") - - msg_recv = await self.build_internal_message_recv(self.mind) - await self.s4u_message_processor.process_message(msg_recv) - internal_manager.set_internal_state(self.mind) - - async def do_think_when_receive_message(self): - pass - - async def build_internal_message_recv(self, message_text: str): - msg_id = f"internal_{time.time()}" - - message_dict = { - "message_info": { - "message_id": msg_id, - "time": time.time(), - "user_info": { - "user_id": "internal", # 内部用户ID - "user_nickname": "内心", # 内部昵称 - "platform": self.platform, # 平台标记为 internal - # 其他 user_info 字段按需补充 - }, - "platform": self.platform, # 平台 - # 其他 message_info 字段按需补充 - }, - "message_segment": { - "type": "text", # 消息类型 - "data": message_text, # 消息内容 - # 其他 segment 字段按需补充 - }, - "raw_message": message_text, # 原始消息内容 - "processed_plain_text": message_text, # 处理后的纯文本 - # 下面这些字段可选，根据 MessageRecv 需要 - "is_emoji": False, - "has_emoji": False, - "is_picid": False, - "has_picid": False, - "is_voice": False, - "is_mentioned": False, - "is_command": False, - "is_internal": True, - "priority_mode": "interest", - "priority_info": {"message_priority": 10.0}, # 内部消息可设高优先级 - "interest_value": 1.0, - } - - if self.is_group: - message_dict["message_info"]["group_info"] = { - "platform": self.platform, - "group_id": self.chat_stream.group_info.group_id, - "group_name": self.chat_stream.group_info.group_name, - } - - msg_recv = MessageRecvS4U(message_dict) - msg_recv.chat_info = self.chat_info - msg_recv.chat_stream = self.chat_stream - msg_recv.is_internal = True - - return msg_recv - - -class MaiThinkingManager: - def __init__(self): - self.mai_think_list = [] - - def get_mai_think(self, chat_id): - for mai_think in self.mai_think_list: - if mai_think.chat_id == chat_id: - return mai_think - mai_think = MaiThinking(chat_id) - self.mai_think_list.append(mai_think) - return mai_think - - -mai_thinking_manager = MaiThinkingManager() - - -init_prompt() diff --git a/src/mais4u/mais4u_chat/body_emotion_action_manager.py b/src/mais4u/mais4u_chat/body_emotion_action_manager.py deleted file mode 100644 index 7b128db4..00000000 --- a/src/mais4u/mais4u_chat/body_emotion_action_manager.py +++ /dev/null @@ -1,342 +0,0 @@ -import json -import time - -from json_repair import repair_json -from src.chat.message_receive.message import MessageRecv -from src.llm_models.utils_model import LLMRequest -from src.common.logger import get_logger -from src.chat.utils.chat_message_builder import build_readable_messages, get_raw_msg_by_timestamp_with_chat_inclusive -from src.config.config import global_config, model_config -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager -from src.manager.async_task_manager import AsyncTask, async_task_manager -from src.plugin_system.apis import send_api - -from src.mais4u.s4u_config import s4u_config - -logger = get_logger("action") - -# 使用字典作为默认值，但通过Prompt来注册以便外部重载 -DEFAULT_HEAD_CODE = { - "看向上方": "(0,0.5,0)", - "看向下方": "(0,-0.5,0)", - "看向左边": "(-1,0,0)", - "看向右边": "(1,0,0)", - "随意朝向": "random", - "看向摄像机": "camera", - "注视对方": "(0,0,0)", - "看向正前方": "(0,0,0)", -} - -DEFAULT_BODY_CODE = { - "双手背后向前弯腰": "010_0070", - "歪头双手合十": "010_0100", - "标准文静站立": "010_0101", - "双手交叠腹部站立": "010_0150", - "帅气的姿势": "010_0190", - "另一个帅气的姿势": "010_0191", - "手掌朝前可爱": "010_0210", - "平静，双手后放": "平静，双手后放", - "思考": "思考", - "优雅，左手放在腰上": "优雅，左手放在腰上", - "一般": "一般", - "可爱，双手前放": "可爱，双手前放", -} - - -async def get_head_code() -> dict: - """获取头部动作代码字典""" - head_code_str = await global_prompt_manager.format_prompt("head_code_prompt") - if not head_code_str: - return DEFAULT_HEAD_CODE - try: - return json.loads(head_code_str) - except Exception as e: - logger.error(f"解析head_code_prompt失败，使用默认值: {e}") - return DEFAULT_HEAD_CODE - - -async def get_body_code() -> dict: - """获取身体动作代码字典""" - body_code_str = await global_prompt_manager.format_prompt("body_code_prompt") - if not body_code_str: - return DEFAULT_BODY_CODE - try: - return json.loads(body_code_str) - except Exception as e: - logger.error(f"解析body_code_prompt失败，使用默认值: {e}") - return DEFAULT_BODY_CODE - - -def init_prompt(): - # 注册头部动作代码 - Prompt( - json.dumps(DEFAULT_HEAD_CODE, ensure_ascii=False, indent=2), - "head_code_prompt", - ) - - # 注册身体动作代码 - Prompt( - json.dumps(DEFAULT_BODY_CODE, ensure_ascii=False, indent=2), - "body_code_prompt", - ) - - # 注册原有提示模板 - Prompt( - """ -{chat_talking_prompt} -以上是群里正在进行的聊天记录 - -{indentify_block} -你现在的动作状态是： -- 身体动作：{body_action} - -现在，因为你发送了消息，或者群里其他人发送了消息，引起了你的注意，你对其进行了阅读和思考，请你更新你的动作状态。 -身体动作可选： -{all_actions} - -请只按照以下json格式输出，描述你新的动作状态，确保每个字段都存在： -{{ - "body_action": "..." -}} -""", - "change_action_prompt", - ) - Prompt( - """ -{chat_talking_prompt} -以上是群里最近的聊天记录 - -{indentify_block} -你之前的动作状态是 -- 身体动作：{body_action} - -身体动作可选： -{all_actions} - -距离你上次关注群里消息已经过去了一段时间，你冷静了下来，你的动作会趋于平缓或静止，请你输出你现在新的动作状态，用中文。 -请只按照以下json格式输出，描述你新的动作状态，确保每个字段都存在： -{{ - "body_action": "..." -}} -""", - "regress_action_prompt", - ) - - -class ChatAction: - def __init__(self, chat_id: str): - self.chat_id: str = chat_id - self.body_action: str = "一般" - self.head_action: str = "注视摄像机" - - self.regression_count: int = 0 - # 新增：body_action冷却池，key为动作名，value为剩余冷却次数 - self.body_action_cooldown: dict[str, int] = {} - - print(s4u_config.models.motion) - print(model_config.model_task_config.emotion) - - self.action_model = LLMRequest(model_set=model_config.model_task_config.emotion, request_type="motion") - - self.last_change_time: float = 0 - - async def send_action_update(self): - """发送动作更新到前端""" - - body_code = (await get_body_code()).get(self.body_action, "") - await send_api.custom_to_stream( - message_type="body_action", - content=body_code, - stream_id=self.chat_id, - storage_message=False, - show_log=True, - ) - - async def update_action_by_message(self, message: MessageRecv): - self.regression_count = 0 - - message_time: float = message.message_info.time # type: ignore - message_list_before_now = get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id=self.chat_id, - timestamp_start=self.last_change_time, - timestamp_end=message_time, - limit=15, - limit_mode="last", - ) - chat_talking_prompt = build_readable_messages( - message_list_before_now, - replace_bot_name=True, - timestamp_mode="normal_no_YMD", - read_mark=0.0, - truncate=True, - show_actions=True, - ) - - bot_name = global_config.bot.nickname - if global_config.bot.alias_names: - bot_nickname = f",也有人叫你{','.join(global_config.bot.alias_names)}" - else: - bot_nickname = "" - - prompt_personality = global_config.personality.personality - indentify_block = f"你的名字是{bot_name}{bot_nickname}，你{prompt_personality}：" - - try: - # 冷却池处理：过滤掉冷却中的动作 - self._update_body_action_cooldown() - available_actions = [k for k in (await get_body_code()).keys() if k not in self.body_action_cooldown] - all_actions = "\n".join(available_actions) - - prompt = await global_prompt_manager.format_prompt( - "change_action_prompt", - chat_talking_prompt=chat_talking_prompt, - indentify_block=indentify_block, - body_action=self.body_action, - all_actions=all_actions, - ) - - logger.info(f"prompt: {prompt}") - response, (reasoning_content, _, _) = await self.action_model.generate_response_async( - prompt=prompt, temperature=0.7 - ) - logger.info(f"response: {response}") - logger.info(f"reasoning_content: {reasoning_content}") - - if action_data := json.loads(repair_json(response)): - # 记录原动作，切换后进入冷却 - prev_body_action = self.body_action - new_body_action = action_data.get("body_action", self.body_action) - if new_body_action != prev_body_action and prev_body_action: - self.body_action_cooldown[prev_body_action] = 3 - self.body_action = new_body_action - self.head_action = action_data.get("head_action", self.head_action) - # 发送动作更新 - await self.send_action_update() - - self.last_change_time = message_time - except Exception as e: - logger.error(f"update_action_by_message error: {e}") - - async def regress_action(self): - message_time = time.time() - message_list_before_now = get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id=self.chat_id, - timestamp_start=self.last_change_time, - timestamp_end=message_time, - limit=10, - limit_mode="last", - ) - chat_talking_prompt = build_readable_messages( - message_list_before_now, - replace_bot_name=True, - timestamp_mode="normal_no_YMD", - read_mark=0.0, - truncate=True, - show_actions=True, - ) - - bot_name = global_config.bot.nickname - if global_config.bot.alias_names: - bot_nickname = f",也有人叫你{','.join(global_config.bot.alias_names)}" - else: - bot_nickname = "" - - prompt_personality = global_config.personality.personality - indentify_block = f"你的名字是{bot_name}{bot_nickname}，你{prompt_personality}：" - try: - # 冷却池处理：过滤掉冷却中的动作 - self._update_body_action_cooldown() - available_actions = [k for k in (await get_body_code()).keys() if k not in self.body_action_cooldown] - all_actions = "\n".join(available_actions) - - prompt = await global_prompt_manager.format_prompt( - "regress_action_prompt", - chat_talking_prompt=chat_talking_prompt, - indentify_block=indentify_block, - body_action=self.body_action, - all_actions=all_actions, - ) - - logger.info(f"prompt: {prompt}") - response, (reasoning_content, _, _) = await self.action_model.generate_response_async( - prompt=prompt, temperature=0.7 - ) - logger.info(f"response: {response}") - logger.info(f"reasoning_content: {reasoning_content}") - - if action_data := json.loads(repair_json(response)): - prev_body_action = self.body_action - new_body_action = action_data.get("body_action", self.body_action) - if new_body_action != prev_body_action and prev_body_action: - self.body_action_cooldown[prev_body_action] = 6 - self.body_action = new_body_action - # 发送动作更新 - await self.send_action_update() - - self.regression_count += 1 - self.last_change_time = message_time - except Exception as e: - logger.error(f"regress_action error: {e}") - - # 新增：冷却池维护方法 - def _update_body_action_cooldown(self): - remove_keys = [] - for k in self.body_action_cooldown: - self.body_action_cooldown[k] -= 1 - if self.body_action_cooldown[k] <= 0: - remove_keys.append(k) - for k in remove_keys: - del self.body_action_cooldown[k] - - -class ActionRegressionTask(AsyncTask): - def __init__(self, action_manager: "ActionManager"): - super().__init__(task_name="ActionRegressionTask", run_interval=3) - self.action_manager = action_manager - - async def run(self): - logger.debug("Running action regression task...") - now = time.time() - for action_state in self.action_manager.action_state_list: - if action_state.last_change_time == 0: - continue - - if now - action_state.last_change_time > 10: - if action_state.regression_count >= 3: - continue - - logger.info(f"chat {action_state.chat_id} 开始动作回归, 这是第 {action_state.regression_count + 1} 次") - await action_state.regress_action() - - -class ActionManager: - def __init__(self): - self.action_state_list: list[ChatAction] = [] - """当前动作状态""" - self.task_started: bool = False - - async def start(self): - """启动动作回归后台任务""" - if self.task_started: - return - - logger.info("启动动作回归任务...") - task = ActionRegressionTask(self) - await async_task_manager.add_task(task) - self.task_started = True - logger.info("动作回归任务已启动") - - def get_action_state_by_chat_id(self, chat_id: str) -> ChatAction: - for action_state in self.action_state_list: - if action_state.chat_id == chat_id: - return action_state - - new_action_state = ChatAction(chat_id) - self.action_state_list.append(new_action_state) - return new_action_state - - -init_prompt() - -action_manager = ActionManager() -"""全局动作管理器""" diff --git a/src/mais4u/mais4u_chat/context_web_manager.py b/src/mais4u/mais4u_chat/context_web_manager.py deleted file mode 100644 index 1e11f725..00000000 --- a/src/mais4u/mais4u_chat/context_web_manager.py +++ /dev/null @@ -1,692 +0,0 @@ -import asyncio -import json -from collections import deque -from datetime import datetime -from typing import Dict, List, Optional -from aiohttp import web, WSMsgType -import aiohttp_cors - -from src.chat.message_receive.message import MessageRecv -from src.common.logger import get_logger - -logger = get_logger("context_web") - - -class ContextMessage: - """上下文消息类""" - - def __init__(self, message: MessageRecv): - self.user_name = message.message_info.user_info.user_nickname - self.user_id = message.message_info.user_info.user_id - self.content = message.processed_plain_text - self.timestamp = datetime.now() - self.group_name = message.message_info.group_info.group_name if message.message_info.group_info else "私聊" - - # 识别消息类型 - self.is_gift = getattr(message, "is_gift", False) - self.is_superchat = getattr(message, "is_superchat", False) - - # 添加礼物和SC相关信息 - if self.is_gift: - self.gift_name = getattr(message, "gift_name", "") - self.gift_count = getattr(message, "gift_count", "1") - self.content = f"送出了 {self.gift_name} x{self.gift_count}" - elif self.is_superchat: - self.superchat_price = getattr(message, "superchat_price", "0") - self.superchat_message = getattr(message, "superchat_message_text", "") - if self.superchat_message: - self.content = f"[¥{self.superchat_price}] {self.superchat_message}" - else: - self.content = f"[¥{self.superchat_price}] {self.content}" - - def to_dict(self): - return { - "user_name": self.user_name, - "user_id": self.user_id, - "content": self.content, - "timestamp": self.timestamp.strftime("%m-%d %H:%M:%S"), - "group_name": self.group_name, - "is_gift": self.is_gift, - "is_superchat": self.is_superchat, - } - - -class ContextWebManager: - """上下文网页管理器""" - - def __init__(self, max_messages: int = 10, port: int = 8765): - self.max_messages = max_messages - self.port = port - self.contexts: Dict[str, deque] = {} # chat_id -> deque of ContextMessage - self.websockets: List[web.WebSocketResponse] = [] - self.app = None - self.runner = None - self.site = None - self._server_starting = False # 添加启动标志防止并发 - - async def start_server(self): - """启动web服务器""" - if self.site is not None: - logger.debug("Web服务器已经启动，跳过重复启动") - return - - if self._server_starting: - logger.debug("Web服务器正在启动中，等待启动完成...") - # 等待启动完成 - while self._server_starting and self.site is None: - await asyncio.sleep(0.1) - return - - self._server_starting = True - - try: - self.app = web.Application() - - # 设置CORS - cors = aiohttp_cors.setup( - self.app, - defaults={ - "*": aiohttp_cors.ResourceOptions( - allow_credentials=True, expose_headers="*", allow_headers="*", allow_methods="*" - ) - }, - ) - - # 添加路由 - self.app.router.add_get("/", self.index_handler) - self.app.router.add_get("/ws", self.websocket_handler) - self.app.router.add_get("/api/contexts", self.get_contexts_handler) - self.app.router.add_get("/debug", self.debug_handler) - - # 为所有路由添加CORS - for route in list(self.app.router.routes()): - cors.add(route) - - self.runner = web.AppRunner(self.app) - await self.runner.setup() - - self.site = web.TCPSite(self.runner, "localhost", self.port) - await self.site.start() - - logger.info(f"🌐 上下文网页服务器启动成功在 http://localhost:{self.port}") - - except Exception as e: - logger.error(f"❌ 启动Web服务器失败: {e}") - # 清理部分启动的资源 - if self.runner: - await self.runner.cleanup() - self.app = None - self.runner = None - self.site = None - raise - finally: - self._server_starting = False - - async def stop_server(self): - """停止web服务器""" - if self.site: - await self.site.stop() - if self.runner: - await self.runner.cleanup() - self.app = None - self.runner = None - self.site = None - self._server_starting = False - - async def index_handler(self, request): - """主页处理器""" - html_content = ( - """ - - - - - 聊天上下文 - - - -
- 🔧 调试 -
-
暂无消息
-
-
- - - - - """ - ) - return web.Response(text=html_content, content_type="text/html") - - async def websocket_handler(self, request): - """WebSocket处理器""" - ws = web.WebSocketResponse() - await ws.prepare(request) - - self.websockets.append(ws) - logger.debug(f"WebSocket连接建立，当前连接数: {len(self.websockets)}") - - # 发送初始数据 - await self.send_contexts_to_websocket(ws) - - async for msg in ws: - if msg.type == WSMsgType.ERROR: - logger.error(f"WebSocket错误: {ws.exception()}") - break - - # 清理断开的连接 - if ws in self.websockets: - self.websockets.remove(ws) - logger.debug(f"WebSocket连接断开，当前连接数: {len(self.websockets)}") - - return ws - - async def get_contexts_handler(self, request): - """获取上下文API""" - all_context_msgs = [] - for _chat_id, contexts in self.contexts.items(): - all_context_msgs.extend(list(contexts)) - - # 按时间排序，最新的在最后 - all_context_msgs.sort(key=lambda x: x.timestamp) - - # 转换为字典格式 - contexts_data = [msg.to_dict() for msg in all_context_msgs[-self.max_messages :]] - - logger.debug(f"返回上下文数据，共 {len(contexts_data)} 条消息") - return web.json_response({"contexts": contexts_data}) - - async def debug_handler(self, request): - """调试信息处理器""" - debug_info = { - "server_status": "running", - "websocket_connections": len(self.websockets), - "total_chats": len(self.contexts), - "total_messages": sum(len(contexts) for contexts in self.contexts.values()), - } - - # 构建聊天详情HTML - chats_html = "" - for chat_id, contexts in self.contexts.items(): - messages_html = "" - for msg in contexts: - timestamp = msg.timestamp.strftime("%H:%M:%S") - content = msg.content[:50] + "..." if len(msg.content) > 50 else msg.content - messages_html += f'
[{timestamp}] {msg.user_name}: {content}
' - - chats_html += f""" -
-

聊天 {chat_id} ({len(contexts)} 条消息)

- {messages_html} -
- """ - - html_content = f""" - - - - - 调试信息 - - - -

上下文网页管理器调试信息

- -
-

服务器状态

-

状态: {debug_info["server_status"]}

-

WebSocket连接数: {debug_info["websocket_connections"]}

-

聊天总数: {debug_info["total_chats"]}

-

消息总数: {debug_info["total_messages"]}

-
- -
-

聊天详情

- {chats_html} -
- -
-

操作

- - - -
- - - - - """ - - return web.Response(text=html_content, content_type="text/html") - - async def add_message(self, chat_id: str, message: MessageRecv): - """添加新消息到上下文""" - if chat_id not in self.contexts: - self.contexts[chat_id] = deque(maxlen=self.max_messages) - logger.debug(f"为聊天 {chat_id} 创建新的上下文队列") - - context_msg = ContextMessage(message) - self.contexts[chat_id].append(context_msg) - - # 统计当前总消息数 - total_messages = sum(len(contexts) for contexts in self.contexts.values()) - - logger.info( - f"✅ 添加消息到上下文 [总数: {total_messages}]: [{context_msg.group_name}] {context_msg.user_name}: {context_msg.content}" - ) - - # 调试：打印当前所有消息 - logger.info("📝 当前上下文中的所有消息：") - for cid, contexts in self.contexts.items(): - logger.info(f" 聊天 {cid}: {len(contexts)} 条消息") - for i, msg in enumerate(contexts): - logger.info( - f" {i + 1}. [{msg.timestamp.strftime('%H:%M:%S')}] {msg.user_name}: {msg.content[:30]}..." - ) - - # 广播更新给所有WebSocket连接 - await self.broadcast_contexts() - - async def send_contexts_to_websocket(self, ws: web.WebSocketResponse): - """向单个WebSocket发送上下文数据""" - all_context_msgs = [] - for _chat_id, contexts in self.contexts.items(): - all_context_msgs.extend(list(contexts)) - - # 按时间排序，最新的在最后 - all_context_msgs.sort(key=lambda x: x.timestamp) - - # 转换为字典格式 - contexts_data = [msg.to_dict() for msg in all_context_msgs[-self.max_messages :]] - - data = {"contexts": contexts_data} - await ws.send_str(json.dumps(data, ensure_ascii=False)) - - async def broadcast_contexts(self): - """向所有WebSocket连接广播上下文更新""" - if not self.websockets: - logger.debug("没有WebSocket连接，跳过广播") - return - - all_context_msgs = [] - for _chat_id, contexts in self.contexts.items(): - all_context_msgs.extend(list(contexts)) - - # 按时间排序，最新的在最后 - all_context_msgs.sort(key=lambda x: x.timestamp) - - # 转换为字典格式 - contexts_data = [msg.to_dict() for msg in all_context_msgs[-self.max_messages :]] - - data = {"contexts": contexts_data} - message = json.dumps(data, ensure_ascii=False) - - logger.info(f"广播 {len(contexts_data)} 条消息到 {len(self.websockets)} 个WebSocket连接") - - # 创建WebSocket列表的副本，避免在遍历时修改 - websockets_copy = self.websockets.copy() - removed_count = 0 - - for ws in websockets_copy: - if ws.closed: - if ws in self.websockets: - self.websockets.remove(ws) - removed_count += 1 - else: - try: - await ws.send_str(message) - logger.debug("消息发送成功") - except Exception as e: - logger.error(f"发送WebSocket消息失败: {e}") - if ws in self.websockets: - self.websockets.remove(ws) - removed_count += 1 - - if removed_count > 0: - logger.debug(f"清理了 {removed_count} 个断开的WebSocket连接") - - -# 全局实例 -_context_web_manager: Optional[ContextWebManager] = None - - -def get_context_web_manager() -> ContextWebManager: - """获取上下文网页管理器实例""" - global _context_web_manager - if _context_web_manager is None: - _context_web_manager = ContextWebManager() - return _context_web_manager - - -async def init_context_web_manager(): - """初始化上下文网页管理器""" - manager = get_context_web_manager() - await manager.start_server() - return manager diff --git a/src/mais4u/mais4u_chat/gift_manager.py b/src/mais4u/mais4u_chat/gift_manager.py deleted file mode 100644 index d489550c..00000000 --- a/src/mais4u/mais4u_chat/gift_manager.py +++ /dev/null @@ -1,147 +0,0 @@ -import asyncio -from typing import Dict, Tuple, Callable, Optional -from dataclasses import dataclass - -from src.chat.message_receive.message import MessageRecvS4U -from src.common.logger import get_logger - -logger = get_logger("gift_manager") - - -@dataclass -class PendingGift: - """等待中的礼物消息""" - - message: MessageRecvS4U - total_count: int - timer_task: asyncio.Task - callback: Callable[[MessageRecvS4U], None] - - -class GiftManager: - """礼物管理器，提供防抖功能""" - - def __init__(self): - """初始化礼物管理器""" - self.pending_gifts: Dict[Tuple[str, str], PendingGift] = {} - self.debounce_timeout = 5.0 # 3秒防抖时间 - - async def handle_gift( - self, message: MessageRecvS4U, callback: Optional[Callable[[MessageRecvS4U], None]] = None - ) -> bool: - """处理礼物消息，返回是否应该立即处理 - - Args: - message: 礼物消息 - callback: 防抖完成后的回调函数 - - Returns: - bool: False表示消息被暂存等待防抖，True表示应该立即处理 - """ - if not message.is_gift: - return True - - # 构建礼物的唯一键：(发送人ID, 礼物名称) - gift_key = (message.message_info.user_info.user_id, message.gift_name) - - # 如果已经有相同的礼物在等待中，则合并 - if gift_key in self.pending_gifts: - await self._merge_gift(gift_key, message) - return False - - # 创建新的等待礼物 - await self._create_pending_gift(gift_key, message, callback) - return False - - async def _merge_gift(self, gift_key: Tuple[str, str], new_message: MessageRecvS4U) -> None: - """合并礼物消息""" - pending_gift = self.pending_gifts[gift_key] - - # 取消之前的定时器 - if not pending_gift.timer_task.cancelled(): - pending_gift.timer_task.cancel() - - # 累加礼物数量 - try: - new_count = int(new_message.gift_count) - pending_gift.total_count += new_count - - # 更新消息为最新的（保留最新的消息，但累加数量） - pending_gift.message = new_message - pending_gift.message.gift_count = str(pending_gift.total_count) - pending_gift.message.gift_info = f"{pending_gift.message.gift_name}:{pending_gift.total_count}" - - except ValueError: - logger.warning(f"无法解析礼物数量: {new_message.gift_count}") - # 如果无法解析数量，保持原有数量不变 - - # 重新创建定时器 - pending_gift.timer_task = asyncio.create_task(self._gift_timeout(gift_key)) - - logger.debug(f"合并礼物: {gift_key}, 总数量: {pending_gift.total_count}") - - async def _create_pending_gift( - self, gift_key: Tuple[str, str], message: MessageRecvS4U, callback: Optional[Callable[[MessageRecvS4U], None]] - ) -> None: - """创建新的等待礼物""" - try: - initial_count = int(message.gift_count) - except ValueError: - initial_count = 1 - logger.warning(f"无法解析礼物数量: {message.gift_count}，默认设为1") - - # 创建定时器任务 - timer_task = asyncio.create_task(self._gift_timeout(gift_key)) - - # 创建等待礼物对象 - pending_gift = PendingGift(message=message, total_count=initial_count, timer_task=timer_task, callback=callback) - - self.pending_gifts[gift_key] = pending_gift - - logger.debug(f"创建等待礼物: {gift_key}, 初始数量: {initial_count}") - - async def _gift_timeout(self, gift_key: Tuple[str, str]) -> None: - """礼物防抖超时处理""" - try: - # 等待防抖时间 - await asyncio.sleep(self.debounce_timeout) - - # 获取等待中的礼物 - if gift_key not in self.pending_gifts: - return - - pending_gift = self.pending_gifts.pop(gift_key) - - logger.info(f"礼物防抖完成: {gift_key}, 最终数量: {pending_gift.total_count}") - - message = pending_gift.message - message.processed_plain_text = f"用户{message.message_info.user_info.user_nickname}送出了礼物{message.gift_name} x{pending_gift.total_count}" - - # 执行回调 - if pending_gift.callback: - try: - pending_gift.callback(message) - except Exception as e: - logger.error(f"礼物回调执行失败: {e}", exc_info=True) - - except asyncio.CancelledError: - # 定时器被取消，不需要处理 - pass - except Exception as e: - logger.error(f"礼物防抖处理异常: {e}", exc_info=True) - - def get_pending_count(self) -> int: - """获取当前等待中的礼物数量""" - return len(self.pending_gifts) - - async def flush_all(self) -> None: - """立即处理所有等待中的礼物""" - for gift_key in list(self.pending_gifts.keys()): - pending_gift = self.pending_gifts.get(gift_key) - if pending_gift and not pending_gift.timer_task.cancelled(): - pending_gift.timer_task.cancel() - await self._gift_timeout(gift_key) - - -# 创建全局礼物管理器实例 -gift_manager = GiftManager() diff --git a/src/mais4u/mais4u_chat/internal_manager.py b/src/mais4u/mais4u_chat/internal_manager.py deleted file mode 100644 index 4b3db326..00000000 --- a/src/mais4u/mais4u_chat/internal_manager.py +++ /dev/null @@ -1,15 +0,0 @@ -class InternalManager: - def __init__(self): - self.now_internal_state = str() - - def set_internal_state(self, internal_state: str): - self.now_internal_state = internal_state - - def get_internal_state(self): - return self.now_internal_state - - def get_internal_state_str(self): - return f"你今天的直播内容是直播QQ水群，你正在一边回复弹幕，一边在QQ群聊天，你在QQ群聊天中产生的想法是：{self.now_internal_state}" - - -internal_manager = InternalManager() diff --git a/src/mais4u/mais4u_chat/s4u_chat.py b/src/mais4u/mais4u_chat/s4u_chat.py deleted file mode 100644 index 8d749697..00000000 --- a/src/mais4u/mais4u_chat/s4u_chat.py +++ /dev/null @@ -1,584 +0,0 @@ -import asyncio -import traceback -import time -import random -from typing import Optional, Dict, Tuple, List # 导入类型提示 -from maim_message import UserInfo, Seg -from src.common.logger import get_logger -from src.chat.message_receive.chat_stream import ChatStream, get_chat_manager -from .s4u_stream_generator import S4UStreamGenerator -from src.chat.message_receive.message import MessageSending, MessageRecv, MessageRecvS4U -from src.config.config import global_config -from src.common.message.api import get_global_api -from src.chat.message_receive.storage import MessageStorage -from .s4u_watching_manager import watching_manager -import json -from .s4u_mood_manager import mood_manager -from src.mais4u.s4u_config import s4u_config -from src.person_info.person_info import get_person_id -from .yes_or_no import yes_or_no_head - -logger = get_logger("S4U_chat") - - -class MessageSenderContainer: - """一个简单的容器，用于按顺序发送消息并模拟打字效果。""" - - def __init__(self, chat_stream: ChatStream, original_message: MessageRecv): - self.chat_stream = chat_stream - self.original_message = original_message - self.queue = asyncio.Queue() - self.storage = MessageStorage() - self._task: Optional[asyncio.Task] = None - self._paused_event = asyncio.Event() - self._paused_event.set() # 默认设置为非暂停状态 - - self.msg_id = "" - - self.last_msg_id = "" - - self.voice_done = "" - - async def add_message(self, chunk: str): - """向队列中添加一个消息块。""" - await self.queue.put(chunk) - - async def close(self): - """表示没有更多消息了，关闭队列。""" - await self.queue.put(None) # Sentinel - - def pause(self): - """暂停发送。""" - self._paused_event.clear() - - def resume(self): - """恢复发送。""" - self._paused_event.set() - - def _calculate_typing_delay(self, text: str) -> float: - """根据文本长度计算模拟打字延迟。""" - chars_per_second = s4u_config.chars_per_second - min_delay = s4u_config.min_typing_delay - max_delay = s4u_config.max_typing_delay - - delay = len(text) / chars_per_second - return max(min_delay, min(delay, max_delay)) - - async def _send_worker(self): - """从队列中取出消息并发送。""" - while True: - try: - # This structure ensures that task_done() is called for every item retrieved, - # even if the worker is cancelled while processing the item. - chunk = await self.queue.get() - except asyncio.CancelledError: - break - - try: - if chunk is None: - break - - # Check for pause signal *after* getting an item. - await self._paused_event.wait() - - # 根据配置选择延迟模式 - if s4u_config.enable_dynamic_typing_delay: - delay = self._calculate_typing_delay(chunk) - else: - delay = s4u_config.typing_delay - await asyncio.sleep(delay) - - message_segment = Seg(type="tts_text", data=f"{self.msg_id}:{chunk}") - bot_message = MessageSending( - message_id=self.msg_id, - chat_stream=self.chat_stream, - bot_user_info=UserInfo( - user_id=global_config.bot.qq_account, - user_nickname=global_config.bot.nickname, - platform=self.original_message.message_info.platform, - ), - sender_info=self.original_message.message_info.user_info, - message_segment=message_segment, - reply=self.original_message, - is_emoji=False, - apply_set_reply_logic=True, - reply_to=f"{self.original_message.message_info.user_info.platform}:{self.original_message.message_info.user_info.user_id}", - ) - - await bot_message.process() - - await get_global_api().send_message(bot_message) - logger.info(f"已将消息 '{self.msg_id}:{chunk}' 发往平台 '{bot_message.message_info.platform}'") - - message_segment = Seg(type="text", data=chunk) - bot_message = MessageSending( - message_id=self.msg_id, - chat_stream=self.chat_stream, - bot_user_info=UserInfo( - user_id=global_config.bot.qq_account, - user_nickname=global_config.bot.nickname, - platform=self.original_message.message_info.platform, - ), - sender_info=self.original_message.message_info.user_info, - message_segment=message_segment, - reply=self.original_message, - is_emoji=False, - apply_set_reply_logic=True, - reply_to=f"{self.original_message.message_info.user_info.platform}:{self.original_message.message_info.user_info.user_id}", - ) - await bot_message.process() - - await self.storage.store_message(bot_message, self.chat_stream) - - except Exception as e: - logger.error(f"[消息流: {self.chat_stream.stream_id}] 消息发送或存储时出现错误: {e}", exc_info=True) - - finally: - # CRUCIAL: Always call task_done() for any item that was successfully retrieved. - self.queue.task_done() - - def start(self): - """启动发送任务。""" - if self._task is None: - self._task = asyncio.create_task(self._send_worker()) - - async def join(self): - """等待所有消息发送完毕。""" - if self._task: - await self._task - - -class S4UChatManager: - def __init__(self): - self.s4u_chats: Dict[str, "S4UChat"] = {} - - def get_or_create_chat(self, chat_stream: ChatStream) -> "S4UChat": - if chat_stream.stream_id not in self.s4u_chats: - stream_name = get_chat_manager().get_stream_name(chat_stream.stream_id) or chat_stream.stream_id - logger.info(f"Creating new S4UChat for stream: {stream_name}") - self.s4u_chats[chat_stream.stream_id] = S4UChat(chat_stream) - return self.s4u_chats[chat_stream.stream_id] - - -if not s4u_config.enable_s4u: - s4u_chat_manager = None -else: - s4u_chat_manager = S4UChatManager() - - -def get_s4u_chat_manager() -> S4UChatManager: - return s4u_chat_manager - - -class S4UChat: - def __init__(self, chat_stream: ChatStream): - """初始化 S4UChat 实例。""" - - self.chat_stream = chat_stream - self.stream_id = chat_stream.stream_id - self.stream_name = get_chat_manager().get_stream_name(self.stream_id) or self.stream_id - - # 两个消息队列 - self._vip_queue = asyncio.PriorityQueue() - self._normal_queue = asyncio.PriorityQueue() - - self._entry_counter = 0 # 保证FIFO的全局计数器 - self._new_message_event = asyncio.Event() # 用于唤醒处理器 - - self._processing_task = asyncio.create_task(self._message_processor()) - self._current_generation_task: Optional[asyncio.Task] = None - # 当前消息的元数据：(队列类型, 优先级分数, 计数器, 消息对象) - self._current_message_being_replied: Optional[Tuple[str, float, int, MessageRecv]] = None - - self._is_replying = False - self.gpt = S4UStreamGenerator() - self.gpt.chat_stream = self.chat_stream - self.interest_dict: Dict[str, float] = {} # 用户兴趣分 - - self.internal_message: List[MessageRecvS4U] = [] - - self.msg_id = "" - self.voice_done = "" - - logger.info(f"[{self.stream_name}] S4UChat with two-queue system initialized.") - - def _get_priority_info(self, message: MessageRecv) -> dict: - """安全地从消息中提取和解析 priority_info""" - priority_info_raw = message.priority_info - priority_info = {} - if isinstance(priority_info_raw, str): - try: - priority_info = json.loads(priority_info_raw) - except json.JSONDecodeError: - logger.warning(f"Failed to parse priority_info JSON: {priority_info_raw}") - elif isinstance(priority_info_raw, dict): - priority_info = priority_info_raw - return priority_info - - def _is_vip(self, priority_info: dict) -> bool: - """检查消息是否来自VIP用户。""" - return priority_info.get("message_type") == "vip" - - def _get_interest_score(self, user_id: str) -> float: - """获取用户的兴趣分，默认为1.0""" - return self.interest_dict.get(user_id, 1.0) - - def go_processing(self): - if self.voice_done == self.last_msg_id: - return True - return False - - def _calculate_base_priority_score(self, message: MessageRecv, priority_info: dict) -> float: - """ - 为消息计算基础优先级分数。分数越高，优先级越高。 - """ - score = 0.0 - - # 加上消息自带的优先级 - score += priority_info.get("message_priority", 0.0) - - # 加上用户的固有兴趣分 - score += self._get_interest_score(message.message_info.user_info.user_id) - return score - - def decay_interest_score(self): - for person_id, score in self.interest_dict.items(): - if score > 0: - self.interest_dict[person_id] = score * 0.95 - else: - self.interest_dict[person_id] = 0 - - async def add_message(self, message: MessageRecvS4U | MessageRecv) -> None: - self.decay_interest_score() - - """根据VIP状态和中断逻辑将消息放入相应队列。""" - user_id = message.message_info.user_info.user_id - platform = message.message_info.platform - _person_id = get_person_id(platform, user_id) - - # try: - # is_gift = message.is_gift - # is_superchat = message.is_superchat - # # print(is_gift) - # # print(is_superchat) - # if is_gift: - # await self.relationship_builder.build_relation(immediate_build=person_id) - # # 安全地增加兴趣分，如果person_id不存在则先初始化为1.0 - # current_score = self.interest_dict.get(person_id, 1.0) - # self.interest_dict[person_id] = current_score + 0.1 * message.gift_count - # elif is_superchat: - # await self.relationship_builder.build_relation(immediate_build=person_id) - # # 安全地增加兴趣分，如果person_id不存在则先初始化为1.0 - # current_score = self.interest_dict.get(person_id, 1.0) - # self.interest_dict[person_id] = current_score + 0.1 * float(message.superchat_price) - - # # 添加SuperChat到管理器 - # super_chat_manager = get_super_chat_manager() - # await super_chat_manager.add_superchat(message) - # else: - # await self.relationship_builder.build_relation(20) - # except Exception: - # traceback.print_exc() - - logger.info(f"[{self.stream_name}] 消息处理完毕，消息内容：{message.processed_plain_text}") - - priority_info = self._get_priority_info(message) - is_vip = self._is_vip(priority_info) - new_priority_score = self._calculate_base_priority_score(message, priority_info) - - should_interrupt = False - if ( - s4u_config.enable_message_interruption - and self._current_generation_task - and not self._current_generation_task.done() - ): - if self._current_message_being_replied: - current_queue, current_priority, _, current_msg = self._current_message_being_replied - - # 规则：VIP从不被打断 - if current_queue == "vip": - pass # Do nothing - - # 规则：普通消息可以被打断 - elif current_queue == "normal": - # VIP消息可以打断普通消息 - if is_vip: - should_interrupt = True - logger.info(f"[{self.stream_name}] VIP message received, interrupting current normal task.") - # 普通消息的内部打断逻辑 - else: - new_sender_id = message.message_info.user_info.user_id - current_sender_id = current_msg.message_info.user_info.user_id - # 新消息优先级更高 - if new_priority_score > current_priority: - should_interrupt = True - logger.info(f"[{self.stream_name}] New normal message has higher priority, interrupting.") - # 同用户，新消息的优先级不能更低 - elif new_sender_id == current_sender_id and new_priority_score >= current_priority: - should_interrupt = True - logger.info(f"[{self.stream_name}] Same user sent new message, interrupting.") - - if should_interrupt: - if self.gpt.partial_response: - logger.warning( - f"[{self.stream_name}] Interrupting reply. Already generated: '{self.gpt.partial_response}'" - ) - self._current_generation_task.cancel() - - # asyncio.PriorityQueue 是最小堆，所以我们存入分数的相反数 - # 这样，原始分数越高的消息，在队列中的优先级数字越小，越靠前 - item = (-new_priority_score, self._entry_counter, time.time(), message) - - if is_vip and s4u_config.vip_queue_priority: - await self._vip_queue.put(item) - logger.info(f"[{self.stream_name}] VIP message added to queue.") - else: - await self._normal_queue.put(item) - - self._entry_counter += 1 - self._new_message_event.set() # 唤醒处理器 - - def _cleanup_old_normal_messages(self): - """清理普通队列中不在最近N条消息范围内的消息""" - if not s4u_config.enable_old_message_cleanup or self._normal_queue.empty(): - return - - # 计算阈值：保留最近 recent_message_keep_count 条消息 - cutoff_counter = max(0, self._entry_counter - s4u_config.recent_message_keep_count) - - # 临时存储需要保留的消息 - temp_messages = [] - removed_count = 0 - - # 取出所有普通队列中的消息 - while not self._normal_queue.empty(): - try: - item = self._normal_queue.get_nowait() - neg_priority, entry_count, timestamp, message = item - - # 如果消息在最近N条消息范围内，保留它 - logger.info( - f"检查消息:{message.processed_plain_text},entry_count:{entry_count} cutoff_counter:{cutoff_counter}" - ) - - if entry_count >= cutoff_counter: - temp_messages.append(item) - else: - removed_count += 1 - self._normal_queue.task_done() # 标记被移除的任务为完成 - - except asyncio.QueueEmpty: - break - - # 将保留的消息重新放入队列 - for item in temp_messages: - self._normal_queue.put_nowait(item) - - if removed_count > 0: - logger.info( - f"消息{message.processed_plain_text}超过{s4u_config.recent_message_keep_count}条，现在counter:{self._entry_counter}被移除" - ) - logger.info( - f"[{self.stream_name}] Cleaned up {removed_count} old normal messages outside recent {s4u_config.recent_message_keep_count} range." - ) - - async def _message_processor(self): - """调度器：优先处理VIP队列，然后处理普通队列。""" - while True: - try: - # 等待有新消息的信号，避免空转 - await self._new_message_event.wait() - self._new_message_event.clear() - - # 清理普通队列中的过旧消息 - self._cleanup_old_normal_messages() - - # 优先处理VIP队列 - if not self._vip_queue.empty(): - neg_priority, entry_count, _, message = self._vip_queue.get_nowait() - priority = -neg_priority - queue_name = "vip" - # 其次处理普通队列 - elif not self._normal_queue.empty(): - neg_priority, entry_count, timestamp, message = self._normal_queue.get_nowait() - priority = -neg_priority - # 检查普通消息是否超时 - if time.time() - timestamp > s4u_config.message_timeout_seconds: - logger.info( - f"[{self.stream_name}] Discarding stale normal message: {message.processed_plain_text[:20]}..." - ) - self._normal_queue.task_done() - continue # 处理下一条 - queue_name = "normal" - else: - if self.internal_message: - message = self.internal_message[-1] - self.internal_message = [] - - priority = 0 - neg_priority = 0 - entry_count = 0 - queue_name = "internal" - - logger.info( - f"[{self.stream_name}] normal/vip 队列都空，触发 internal_message 回复: {getattr(message, 'processed_plain_text', str(message))[:20]}..." - ) - else: - continue # 没有消息了，回去等事件 - - self._current_message_being_replied = (queue_name, priority, entry_count, message) - self._current_generation_task = asyncio.create_task(self._generate_and_send(message)) - - try: - await self._current_generation_task - except asyncio.CancelledError: - logger.info( - f"[{self.stream_name}] Reply generation was interrupted externally for {queue_name} message. The message will be discarded." - ) - # 被中断的消息应该被丢弃，而不是重新排队，以响应最新的用户输入。 - # 旧的重新入队逻辑会导致所有中断的消息最终都被回复。 - - except Exception as e: - logger.error(f"[{self.stream_name}] _generate_and_send task error: {e}", exc_info=True) - finally: - self._current_generation_task = None - self._current_message_being_replied = None - # 标记任务完成 - if queue_name == "vip": - self._vip_queue.task_done() - elif queue_name == "internal": - # 如果使用 internal_message 生成回复，则不从 normal 队列中移除 - pass - else: - self._normal_queue.task_done() - - # 检查是否还有任务，有则立即再次触发事件 - if not self._vip_queue.empty() or not self._normal_queue.empty(): - self._new_message_event.set() - - except asyncio.CancelledError: - logger.info(f"[{self.stream_name}] Message processor is shutting down.") - break - except Exception as e: - logger.error(f"[{self.stream_name}] Message processor main loop error: {e}", exc_info=True) - await asyncio.sleep(1) - - def get_processing_message_id(self): - self.last_msg_id = self.msg_id - self.msg_id = f"{time.time()}_{random.randint(1000, 9999)}" - - async def _generate_and_send(self, message: MessageRecv): - """为单个消息生成文本回复。整个过程可以被中断。""" - self._is_replying = True - total_chars_sent = 0 # 跟踪发送的总字符数 - - self.get_processing_message_id() - - # 视线管理：开始生成回复时切换视线状态 - chat_watching = watching_manager.get_watching_by_chat_id(self.stream_id) - - if message.is_internal: - await chat_watching.on_internal_message_start() - else: - await chat_watching.on_reply_start() - - sender_container = MessageSenderContainer(self.chat_stream, message) - sender_container.start() - - async def generate_and_send_inner(): - nonlocal total_chars_sent - logger.info(f"[S4U] 开始为消息生成文本和音频流: '{message.processed_plain_text[:30]}...'") - - if s4u_config.enable_streaming_output: - logger.info("[S4U] 开始流式输出") - # 流式输出，边生成边发送 - gen = self.gpt.generate_response(message, "") - async for chunk in gen: - sender_container.msg_id = self.msg_id - await sender_container.add_message(chunk) - total_chars_sent += len(chunk) - else: - logger.info("[S4U] 开始一次性输出") - # 一次性输出，先收集所有chunk - all_chunks = [] - gen = self.gpt.generate_response(message, "") - async for chunk in gen: - all_chunks.append(chunk) - total_chars_sent += len(chunk) - # 一次性发送 - sender_container.msg_id = self.msg_id - await sender_container.add_message("".join(all_chunks)) - - try: - try: - await asyncio.wait_for(generate_and_send_inner(), timeout=10) - except asyncio.TimeoutError: - logger.warning(f"[{self.stream_name}] 回复生成超时，发送默认回复。") - sender_container.msg_id = self.msg_id - await sender_container.add_message("麦麦不知道哦") - total_chars_sent = len("麦麦不知道哦") - - mood = mood_manager.get_mood_by_chat_id(self.stream_id) - await yes_or_no_head( - text=total_chars_sent, - emotion=mood.mood_state, - chat_history=message.processed_plain_text, - chat_id=self.stream_id, - ) - - # 等待所有文本消息发送完成 - await sender_container.close() - await sender_container.join() - - await chat_watching.on_thinking_finished() - - start_time = time.time() - logged = False - while not self.go_processing(): - if time.time() - start_time > 60: - logger.warning(f"[{self.stream_name}] 等待消息发送超时（60秒），强制跳出循环。") - break - if not logged: - logger.info(f"[{self.stream_name}] 等待消息发送完成...") - logged = True - await asyncio.sleep(0.2) - - logger.info(f"[{self.stream_name}] 所有文本块处理完毕。") - - except asyncio.CancelledError: - logger.info(f"[{self.stream_name}] 回复流程（文本）被中断。") - raise # 将取消异常向上传播 - except Exception as e: - traceback.print_exc() - logger.error(f"[{self.stream_name}] 回复生成过程中出现错误: {e}", exc_info=True) - # 回复生成实时展示：清空内容（出错时） - finally: - self._is_replying = False - - # 视线管理：回复结束时切换视线状态 - chat_watching = watching_manager.get_watching_by_chat_id(self.stream_id) - await chat_watching.on_reply_finished() - - # 确保发送器被妥善关闭（即使已关闭，再次调用也是安全的） - sender_container.resume() - if not sender_container._task.done(): - await sender_container.close() - await sender_container.join() - logger.info(f"[{self.stream_name}] _generate_and_send 任务结束，资源已清理。") - - async def shutdown(self): - """平滑关闭处理任务。""" - logger.info(f"正在关闭 S4UChat: {self.stream_name}") - - # 取消正在运行的任务 - if self._current_generation_task and not self._current_generation_task.done(): - self._current_generation_task.cancel() - - if self._processing_task and not self._processing_task.done(): - self._processing_task.cancel() - - # 等待任务响应取消 - try: - await self._processing_task - except asyncio.CancelledError: - logger.info(f"处理任务已成功取消: {self.stream_name}") diff --git a/src/mais4u/mais4u_chat/s4u_mood_manager.py b/src/mais4u/mais4u_chat/s4u_mood_manager.py deleted file mode 100644 index aff32ac9..00000000 --- a/src/mais4u/mais4u_chat/s4u_mood_manager.py +++ /dev/null @@ -1,456 +0,0 @@ -import asyncio -import json -import time - -from src.chat.message_receive.message import MessageRecv -from src.llm_models.utils_model import LLMRequest -from src.common.logger import get_logger -from src.chat.utils.chat_message_builder import build_readable_messages, get_raw_msg_by_timestamp_with_chat_inclusive -from src.config.config import global_config, model_config -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager -from src.manager.async_task_manager import AsyncTask, async_task_manager -from src.plugin_system.apis import send_api -from src.mais4u.s4u_config import s4u_config - -""" -情绪管理系统使用说明： - -1. 情绪数值系统： - - 情绪包含四个维度：joy(喜), anger(怒), sorrow(哀), fear(惧) - - 每个维度的取值范围为1-10 - - 当情绪发生变化时，会自动发送到ws端处理 - -2. 情绪更新机制： - - 接收到新消息时会更新情绪状态 - - 定期进行情绪回归（冷静下来） - - 每次情绪变化都会发送到ws端，格式为： - type: "emotion" - data: {"joy": 5, "anger": 1, "sorrow": 1, "fear": 1} - -3. ws端处理： - - 本地只负责情绪计算和发送情绪数值 - - 表情渲染和动作由ws端根据情绪数值处理 -""" - -logger = get_logger("mood") - - -def init_prompt(): - Prompt( - """ -{chat_talking_prompt} -以上是直播间里正在进行的对话 - -{indentify_block} -你刚刚的情绪状态是：{mood_state} - -现在，发送了消息，引起了你的注意，你对其进行了阅读和思考，请你输出一句话描述你新的情绪状态，不要输出任何其他内容 -请只输出情绪状态，不要输出其他内容： -""", - "change_mood_prompt_vtb", - ) - Prompt( - """ -{chat_talking_prompt} -以上是直播间里最近的对话 - -{indentify_block} -你之前的情绪状态是：{mood_state} - -距离你上次关注直播间消息已经过去了一段时间，你冷静了下来，请你输出一句话描述你现在的情绪状态 -请只输出情绪状态，不要输出其他内容： -""", - "regress_mood_prompt_vtb", - ) - Prompt( - """ -{chat_talking_prompt} -以上是直播间里正在进行的对话 - -{indentify_block} -你刚刚的情绪状态是：{mood_state} -具体来说，从1-10分，你的情绪状态是： -喜(Joy): {joy} -怒(Anger): {anger} -哀(Sorrow): {sorrow} -惧(Fear): {fear} - -现在，发送了消息，引起了你的注意，你对其进行了阅读和思考。请基于对话内容，评估你新的情绪状态。 -请以JSON格式输出你新的情绪状态，包含"喜怒哀惧"四个维度，每个维度的取值范围为1-10。 -键值请使用英文: "joy", "anger", "sorrow", "fear". -例如: {{"joy": 5, "anger": 1, "sorrow": 1, "fear": 1}} -不要输出任何其他内容，只输出JSON。 -""", - "change_mood_numerical_prompt", - ) - Prompt( - """ -{chat_talking_prompt} -以上是直播间里最近的对话 - -{indentify_block} -你之前的情绪状态是：{mood_state} -具体来说，从1-10分，你的情绪状态是： -喜(Joy): {joy} -怒(Anger): {anger} -哀(Sorrow): {sorrow} -惧(Fear): {fear} - -距离你上次关注直播间消息已经过去了一段时间，你冷静了下来。请基于此，评估你现在的情绪状态。 -请以JSON格式输出你新的情绪状态，包含"喜怒哀惧"四个维度，每个维度的取值范围为1-10。 -键值请使用英文: "joy", "anger", "sorrow", "fear". -例如: {{"joy": 5, "anger": 1, "sorrow": 1, "fear": 1}} -不要输出任何其他内容，只输出JSON。 -""", - "regress_mood_numerical_prompt", - ) - - -class ChatMood: - def __init__(self, chat_id: str): - self.chat_id: str = chat_id - self.mood_state: str = "感觉很平静" - self.mood_values: dict[str, int] = {"joy": 5, "anger": 1, "sorrow": 1, "fear": 1} - - self.regression_count: int = 0 - - self.mood_model = LLMRequest(model_set=model_config.model_task_config.emotion, request_type="mood_text") - self.mood_model_numerical = LLMRequest( - model_set=model_config.model_task_config.emotion, request_type="mood_numerical" - ) - - self.last_change_time: float = 0 - - # 发送初始情绪状态到ws端 - asyncio.create_task(self.send_emotion_update(self.mood_values)) - - def _parse_numerical_mood(self, response: str) -> dict[str, int] | None: - try: - # The LLM might output markdown with json inside - if "```json" in response: - response = response.split("```json")[1].split("```")[0] - elif "```" in response: - response = response.split("```")[1].split("```")[0] - - data = json.loads(response) - - # Validate - required_keys = {"joy", "anger", "sorrow", "fear"} - if not required_keys.issubset(data.keys()): - logger.warning(f"Numerical mood response missing keys: {response}") - return None - - for key in required_keys: - value = data[key] - if not isinstance(value, int) or not (1 <= value <= 10): - logger.warning(f"Numerical mood response invalid value for {key}: {value} in {response}") - return None - - return {key: data[key] for key in required_keys} - - except json.JSONDecodeError: - logger.warning(f"Failed to parse numerical mood JSON: {response}") - return None - except Exception as e: - logger.error(f"Error parsing numerical mood: {e}, response: {response}") - return None - - async def update_mood_by_message(self, message: MessageRecv): - self.regression_count = 0 - - message_time: float = message.message_info.time # type: ignore - message_list_before_now = get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id=self.chat_id, - timestamp_start=self.last_change_time, - timestamp_end=message_time, - limit=10, - limit_mode="last", - ) - - chat_talking_prompt = build_readable_messages( - message_list_before_now, - replace_bot_name=True, - timestamp_mode="normal_no_YMD", - read_mark=0.0, - truncate=True, - show_actions=True, - ) - - bot_name = global_config.bot.nickname - if global_config.bot.alias_names: - bot_nickname = f",也有人叫你{','.join(global_config.bot.alias_names)}" - else: - bot_nickname = "" - - prompt_personality = global_config.personality.personality - indentify_block = f"你的名字是{bot_name}{bot_nickname}，你{prompt_personality}：" - - async def _update_text_mood(): - prompt = await global_prompt_manager.format_prompt( - "change_mood_prompt_vtb", - chat_talking_prompt=chat_talking_prompt, - indentify_block=indentify_block, - mood_state=self.mood_state, - ) - logger.debug(f"text mood prompt: {prompt}") - response, (reasoning_content, _, _) = await self.mood_model.generate_response_async( - prompt=prompt, temperature=0.7 - ) - logger.info(f"text mood response: {response}") - logger.debug(f"text mood reasoning_content: {reasoning_content}") - return response - - async def _update_numerical_mood(): - prompt = await global_prompt_manager.format_prompt( - "change_mood_numerical_prompt", - chat_talking_prompt=chat_talking_prompt, - indentify_block=indentify_block, - mood_state=self.mood_state, - joy=self.mood_values["joy"], - anger=self.mood_values["anger"], - sorrow=self.mood_values["sorrow"], - fear=self.mood_values["fear"], - ) - logger.debug(f"numerical mood prompt: {prompt}") - response, (reasoning_content, _, _) = await self.mood_model_numerical.generate_response_async( - prompt=prompt, temperature=0.4 - ) - logger.info(f"numerical mood response: {response}") - logger.debug(f"numerical mood reasoning_content: {reasoning_content}") - return self._parse_numerical_mood(response) - - results = await asyncio.gather(_update_text_mood(), _update_numerical_mood()) - text_mood_response, numerical_mood_response = results - - if text_mood_response: - self.mood_state = text_mood_response - - if numerical_mood_response: - _old_mood_values = self.mood_values.copy() - self.mood_values = numerical_mood_response - - # 发送情绪更新到ws端 - await self.send_emotion_update(self.mood_values) - - logger.info(f"[{self.chat_id}] 情绪变化: {_old_mood_values} -> {self.mood_values}") - - self.last_change_time = message_time - - async def regress_mood(self): - message_time = time.time() - message_list_before_now = get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id=self.chat_id, - timestamp_start=self.last_change_time, - timestamp_end=message_time, - limit=5, - limit_mode="last", - ) - - chat_talking_prompt = build_readable_messages( - message_list_before_now, - replace_bot_name=True, - timestamp_mode="normal_no_YMD", - read_mark=0.0, - truncate=True, - show_actions=True, - ) - - bot_name = global_config.bot.nickname - if global_config.bot.alias_names: - bot_nickname = f",也有人叫你{','.join(global_config.bot.alias_names)}" - else: - bot_nickname = "" - - prompt_personality = global_config.personality.personality - indentify_block = f"你的名字是{bot_name}{bot_nickname}，你{prompt_personality}：" - - async def _regress_text_mood(): - prompt = await global_prompt_manager.format_prompt( - "regress_mood_prompt_vtb", - chat_talking_prompt=chat_talking_prompt, - indentify_block=indentify_block, - mood_state=self.mood_state, - ) - logger.debug(f"text regress prompt: {prompt}") - response, (reasoning_content, _, _) = await self.mood_model.generate_response_async( - prompt=prompt, temperature=0.7 - ) - logger.info(f"text regress response: {response}") - logger.debug(f"text regress reasoning_content: {reasoning_content}") - return response - - async def _regress_numerical_mood(): - prompt = await global_prompt_manager.format_prompt( - "regress_mood_numerical_prompt", - chat_talking_prompt=chat_talking_prompt, - indentify_block=indentify_block, - mood_state=self.mood_state, - joy=self.mood_values["joy"], - anger=self.mood_values["anger"], - sorrow=self.mood_values["sorrow"], - fear=self.mood_values["fear"], - ) - logger.debug(f"numerical regress prompt: {prompt}") - response, (reasoning_content, _, _) = await self.mood_model_numerical.generate_response_async( - prompt=prompt, - temperature=0.4, - ) - logger.info(f"numerical regress response: {response}") - logger.debug(f"numerical regress reasoning_content: {reasoning_content}") - return self._parse_numerical_mood(response) - - results = await asyncio.gather(_regress_text_mood(), _regress_numerical_mood()) - text_mood_response, numerical_mood_response = results - - if text_mood_response: - self.mood_state = text_mood_response - - if numerical_mood_response: - _old_mood_values = self.mood_values.copy() - self.mood_values = numerical_mood_response - - # 发送情绪更新到ws端 - await self.send_emotion_update(self.mood_values) - - logger.info(f"[{self.chat_id}] 情绪回归: {_old_mood_values} -> {self.mood_values}") - - self.regression_count += 1 - - async def send_emotion_update(self, mood_values: dict[str, int]): - """发送情绪更新到ws端""" - emotion_data = { - "joy": mood_values.get("joy", 5), - "anger": mood_values.get("anger", 1), - "sorrow": mood_values.get("sorrow", 1), - "fear": mood_values.get("fear", 1), - } - - await send_api.custom_to_stream( - message_type="emotion", - content=emotion_data, - stream_id=self.chat_id, - storage_message=False, - show_log=True, - ) - - logger.info(f"[{self.chat_id}] 发送情绪更新: {emotion_data}") - - -class MoodRegressionTask(AsyncTask): - def __init__(self, mood_manager: "MoodManager"): - super().__init__(task_name="MoodRegressionTask", run_interval=30) - self.mood_manager = mood_manager - self.run_count = 0 - - async def run(self): - self.run_count += 1 - logger.info(f"[回归任务] 第{self.run_count}次检查，当前管理{len(self.mood_manager.mood_list)}个聊天的情绪状态") - - now = time.time() - regression_executed = 0 - - for mood in self.mood_manager.mood_list: - chat_info = f"chat {mood.chat_id}" - - if mood.last_change_time == 0: - logger.debug(f"[回归任务] {chat_info} 尚未有情绪变化，跳过回归") - continue - - time_since_last_change = now - mood.last_change_time - - # 检查是否有极端情绪需要快速回归 - high_emotions = {k: v for k, v in mood.mood_values.items() if v >= 8} - has_extreme_emotion = len(high_emotions) > 0 - - # 回归条件：1. 正常时间间隔(120s) 或 2. 有极端情绪且距上次变化>=30s - should_regress = False - regress_reason = "" - - if time_since_last_change > 120: - should_regress = True - regress_reason = f"常规回归(距上次变化{int(time_since_last_change)}秒)" - elif has_extreme_emotion and time_since_last_change > 30: - should_regress = True - high_emotion_str = ", ".join([f"{k}={v}" for k, v in high_emotions.items()]) - regress_reason = f"极端情绪快速回归({high_emotion_str}, 距上次变化{int(time_since_last_change)}秒)" - - if should_regress: - if mood.regression_count >= 3: - logger.debug(f"[回归任务] {chat_info} 已达到最大回归次数(3次)，停止回归") - continue - - logger.info( - f"[回归任务] {chat_info} 开始情绪回归 ({regress_reason}，第{mood.regression_count + 1}次回归)" - ) - await mood.regress_mood() - regression_executed += 1 - else: - if has_extreme_emotion: - remaining_time = 5 - time_since_last_change - high_emotion_str = ", ".join([f"{k}={v}" for k, v in high_emotions.items()]) - logger.debug( - f"[回归任务] {chat_info} 存在极端情绪({high_emotion_str})，距离快速回归还需等待{int(remaining_time)}秒" - ) - else: - remaining_time = 120 - time_since_last_change - logger.debug(f"[回归任务] {chat_info} 距离回归还需等待{int(remaining_time)}秒") - - if regression_executed > 0: - logger.info(f"[回归任务] 本次执行了{regression_executed}个聊天的情绪回归") - else: - logger.debug("[回归任务] 本次没有符合回归条件的聊天") - - -class MoodManager: - def __init__(self): - self.mood_list: list[ChatMood] = [] - """当前情绪状态""" - self.task_started: bool = False - - async def start(self): - """启动情绪回归后台任务""" - if self.task_started: - return - - logger.info("启动情绪管理任务...") - - # 启动情绪回归任务 - regression_task = MoodRegressionTask(self) - await async_task_manager.add_task(regression_task) - - self.task_started = True - logger.info("情绪管理任务已启动（情绪回归）") - - def get_mood_by_chat_id(self, chat_id: str) -> ChatMood: - for mood in self.mood_list: - if mood.chat_id == chat_id: - return mood - - new_mood = ChatMood(chat_id) - self.mood_list.append(new_mood) - return new_mood - - def reset_mood_by_chat_id(self, chat_id: str): - for mood in self.mood_list: - if mood.chat_id == chat_id: - mood.mood_state = "感觉很平静" - mood.mood_values = {"joy": 5, "anger": 1, "sorrow": 1, "fear": 1} - mood.regression_count = 0 - # 发送重置后的情绪状态到ws端 - asyncio.create_task(mood.send_emotion_update(mood.mood_values)) - return - - # 如果没有找到现有的mood，创建新的 - new_mood = ChatMood(chat_id) - self.mood_list.append(new_mood) - # 发送初始情绪状态到ws端 - asyncio.create_task(new_mood.send_emotion_update(new_mood.mood_values)) - - -if s4u_config.enable_s4u: - init_prompt() - mood_manager = MoodManager() -else: - mood_manager = None - -"""全局情绪管理器""" diff --git a/src/mais4u/mais4u_chat/s4u_msg_processor.py b/src/mais4u/mais4u_chat/s4u_msg_processor.py deleted file mode 100644 index 4263194b..00000000 --- a/src/mais4u/mais4u_chat/s4u_msg_processor.py +++ /dev/null @@ -1,255 +0,0 @@ -import asyncio -import math -from typing import Tuple - -from src.chat.memory_system.Hippocampus import hippocampus_manager -from src.chat.message_receive.message import MessageRecv, MessageRecvS4U -from maim_message.message_base import GroupInfo -from src.chat.message_receive.storage import MessageStorage -from src.chat.message_receive.chat_stream import get_chat_manager -from src.chat.utils.timer_calculator import Timer -from src.chat.utils.utils import is_mentioned_bot_in_message -from src.common.logger import get_logger -from src.config.config import global_config -from src.mais4u.mais4u_chat.body_emotion_action_manager import action_manager -from src.mais4u.mais4u_chat.s4u_mood_manager import mood_manager -from src.mais4u.mais4u_chat.s4u_watching_manager import watching_manager -from src.mais4u.mais4u_chat.context_web_manager import get_context_web_manager -from src.mais4u.mais4u_chat.gift_manager import gift_manager -from src.mais4u.mais4u_chat.screen_manager import screen_manager - -from .s4u_chat import get_s4u_chat_manager - - -# from ..message_receive.message_buffer import message_buffer - -logger = get_logger("chat") - - -async def _calculate_interest(message: MessageRecv) -> Tuple[float, bool]: - """计算消息的兴趣度 - - Args: - message: 待处理的消息对象 - - Returns: - Tuple[float, bool]: (兴趣度, 是否被提及) - """ - is_mentioned, _ = is_mentioned_bot_in_message(message) - interested_rate = 0.0 - - if global_config.memory.enable_memory: - with Timer("记忆激活"): - interested_rate, _, _ = await hippocampus_manager.get_activate_from_text( - message.processed_plain_text, - fast_retrieval=True, - ) - logger.debug(f"记忆激活率: {interested_rate:.2f}") - - text_len = len(message.processed_plain_text) - # 根据文本长度分布调整兴趣度，采用分段函数实现更精确的兴趣度计算 - # 基于实际分布：0-5字符(26.57%), 6-10字符(27.18%), 11-20字符(22.76%), 21-30字符(10.33%), 31+字符(13.86%) - - if text_len == 0: - base_interest = 0.01 # 空消息最低兴趣度 - elif text_len <= 5: - # 1-5字符：线性增长 0.01 -> 0.03 - base_interest = 0.01 + (text_len - 1) * (0.03 - 0.01) / 4 - elif text_len <= 10: - # 6-10字符：线性增长 0.03 -> 0.06 - base_interest = 0.03 + (text_len - 5) * (0.06 - 0.03) / 5 - elif text_len <= 20: - # 11-20字符：线性增长 0.06 -> 0.12 - base_interest = 0.06 + (text_len - 10) * (0.12 - 0.06) / 10 - elif text_len <= 30: - # 21-30字符：线性增长 0.12 -> 0.18 - base_interest = 0.12 + (text_len - 20) * (0.18 - 0.12) / 10 - elif text_len <= 50: - # 31-50字符：线性增长 0.18 -> 0.22 - base_interest = 0.18 + (text_len - 30) * (0.22 - 0.18) / 20 - elif text_len <= 100: - # 51-100字符：线性增长 0.22 -> 0.26 - base_interest = 0.22 + (text_len - 50) * (0.26 - 0.22) / 50 - else: - # 100+字符：对数增长 0.26 -> 0.3，增长率递减 - base_interest = 0.26 + (0.3 - 0.26) * (math.log10(text_len - 99) / math.log10(901)) # 1000-99=901 - - # 确保在范围内 - base_interest = min(max(base_interest, 0.01), 0.3) - - interested_rate += base_interest - - if is_mentioned: - interest_increase_on_mention = 1 - interested_rate += interest_increase_on_mention - - return interested_rate, is_mentioned - - -class S4UMessageProcessor: - """心流处理器，负责处理接收到的消息并计算兴趣度""" - - def __init__(self): - """初始化心流处理器，创建消息存储实例""" - self.storage = MessageStorage() - - async def process_message(self, message: MessageRecvS4U, skip_gift_debounce: bool = False) -> None: - """处理接收到的原始消息数据 - - 主要流程: - 1. 消息解析与初始化 - 2. 消息缓冲处理 - 3. 过滤检查 - 4. 兴趣度计算 - 5. 关系处理 - - Args: - message_data: 原始消息字符串 - """ - - # 1. 消息解析与初始化 - groupinfo = message.message_info.group_info - userinfo = message.message_info.user_info - message_info = message.message_info - - chat = await get_chat_manager().get_or_create_stream( - platform=message_info.platform, - user_info=userinfo, - group_info=groupinfo, - ) - - if await self.handle_internal_message(message): - return - - if await self.hadle_if_voice_done(message): - return - - # 处理礼物消息，如果消息被暂存则停止当前处理流程 - if not skip_gift_debounce and not await self.handle_if_gift(message): - return - await self.check_if_fake_gift(message) - - # 处理屏幕消息 - if await self.handle_screen_message(message): - return - - await self.storage.store_message(message, chat) - - s4u_chat = get_s4u_chat_manager().get_or_create_chat(chat) - - await s4u_chat.add_message(message) - - _interested_rate, _ = await _calculate_interest(message) - - await mood_manager.start() - - # 一系列llm驱动的前处理 - chat_mood = mood_manager.get_mood_by_chat_id(chat.stream_id) - asyncio.create_task(chat_mood.update_mood_by_message(message)) - chat_action = action_manager.get_action_state_by_chat_id(chat.stream_id) - asyncio.create_task(chat_action.update_action_by_message(message)) - # 视线管理：收到消息时切换视线状态 - chat_watching = watching_manager.get_watching_by_chat_id(chat.stream_id) - await chat_watching.on_message_received() - - # 上下文网页管理：启动独立task处理消息上下文 - asyncio.create_task(self._handle_context_web_update(chat.stream_id, message)) - - # 日志记录 - if message.is_gift: - logger.info(f"[S4U-礼物] {userinfo.user_nickname} 送出了 {message.gift_name} x{message.gift_count}") - else: - logger.info(f"[S4U]{userinfo.user_nickname}:{message.processed_plain_text}") - - async def handle_internal_message(self, message: MessageRecvS4U): - if message.is_internal: - group_info = GroupInfo(platform="amaidesu_default", group_id=660154, group_name="内心") - - chat = await get_chat_manager().get_or_create_stream( - platform="amaidesu_default", user_info=message.message_info.user_info, group_info=group_info - ) - s4u_chat = get_s4u_chat_manager().get_or_create_chat(chat) - message.message_info.group_info = s4u_chat.chat_stream.group_info - message.message_info.platform = s4u_chat.chat_stream.platform - - s4u_chat.internal_message.append(message) - s4u_chat._new_message_event.set() - - logger.info( - f"[{s4u_chat.stream_name}] 添加内部消息-------------------------------------------------------: {message.processed_plain_text}" - ) - - return True - return False - - async def handle_screen_message(self, message: MessageRecvS4U): - if message.is_screen: - screen_manager.set_screen(message.screen_info) - return True - return False - - async def hadle_if_voice_done(self, message: MessageRecvS4U): - if message.voice_done: - s4u_chat = get_s4u_chat_manager().get_or_create_chat(message.chat_stream) - s4u_chat.voice_done = message.voice_done - return True - return False - - async def check_if_fake_gift(self, message: MessageRecvS4U) -> bool: - """检查消息是否为假礼物""" - if message.is_gift: - return False - - gift_keywords = ["送出了礼物", "礼物", "送出了", "投喂"] - if any(keyword in message.processed_plain_text for keyword in gift_keywords): - message.is_fake_gift = True - return True - - return False - - async def handle_if_gift(self, message: MessageRecvS4U) -> bool: - """处理礼物消息 - - Returns: - bool: True表示应该继续处理消息，False表示消息已被暂存不需要继续处理 - """ - if message.is_gift: - # 定义防抖完成后的回调函数 - def gift_callback(merged_message: MessageRecvS4U): - """礼物防抖完成后的回调""" - # 创建异步任务来处理合并后的礼物消息，跳过防抖处理 - asyncio.create_task(self.process_message(merged_message, skip_gift_debounce=True)) - - # 交给礼物管理器处理，并传入回调函数 - # 对于礼物消息，handle_gift 总是返回 False（消息被暂存） - await gift_manager.handle_gift(message, gift_callback) - return False # 消息被暂存，不继续处理 - - return True # 非礼物消息，继续正常处理 - - async def _handle_context_web_update(self, chat_id: str, message: MessageRecv): - """处理上下文网页更新的独立task - - Args: - chat_id: 聊天ID - message: 消息对象 - """ - try: - logger.debug(f"🔄 开始处理上下文网页更新: {message.message_info.user_info.user_nickname}") - - context_manager = get_context_web_manager() - - # 只在服务器未启动时启动（避免重复启动） - if context_manager.site is None: - logger.info("🚀 首次启动上下文网页服务器...") - await context_manager.start_server() - - # 添加消息到上下文并更新网页 - await asyncio.sleep(1.5) - - await context_manager.add_message(chat_id, message) - - logger.debug(f"✅ 上下文网页更新完成: {message.message_info.user_info.user_nickname}") - - except Exception as e: - logger.error(f"❌ 处理上下文网页更新失败: {e}", exc_info=True) diff --git a/src/mais4u/mais4u_chat/s4u_prompt.py b/src/mais4u/mais4u_chat/s4u_prompt.py deleted file mode 100644 index 15e4d729..00000000 --- a/src/mais4u/mais4u_chat/s4u_prompt.py +++ /dev/null @@ -1,400 +0,0 @@ -from src.config.config import global_config -from src.common.logger import get_logger -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager -from src.chat.utils.chat_message_builder import build_readable_messages, get_raw_msg_before_timestamp_with_chat -import time -from src.chat.utils.utils import get_recent_group_speaker -from src.chat.memory_system.Hippocampus import hippocampus_manager -import random -from datetime import datetime -import asyncio -from src.mais4u.s4u_config import s4u_config -from src.chat.message_receive.message import MessageRecvS4U -from src.person_info.person_info import Person, get_person_id -from src.chat.message_receive.chat_stream import ChatStream -from src.mais4u.mais4u_chat.super_chat_manager import get_super_chat_manager -from src.mais4u.mais4u_chat.screen_manager import screen_manager -from src.chat.express.expression_selector import expression_selector -from .s4u_mood_manager import mood_manager -from src.mais4u.mais4u_chat.internal_manager import internal_manager -from src.common.data_models.database_data_model import DatabaseMessages - -from typing import List - -logger = get_logger("prompt") - - -def init_prompt(): - Prompt("\n你有以下这些**知识**：\n{prompt_info}\n请你**记住上面的知识**，之后可能会用到。\n", "knowledge_prompt") - Prompt("\n关于你们的关系，你需要知道：\n{relation_info}\n", "relation_prompt") - Prompt("你回想起了一些事情：\n{memory_info}\n", "memory_prompt") - - Prompt( - """ -你的名字是麦麦, 是千石可乐开发的程序，可以在QQ，微信等平台发言，你现在正在哔哩哔哩作为虚拟主播进行直播 -虽然是个AI，但你在努力扮演真人, 人设的配色是橙色和紫色和绿色 -你有一头法式橙色卷发，你很可爱，穿戴英式侦探风格学院风裙子和帽子，你正在一个教室场景里进行虚拟线上直播。不过不要刻意提及这些内容，自然回复 -你可以看见用户发送的弹幕，礼物和superchat -{screen_info} -{internal_state} - -{relation_info_block} -{memory_block} -{expression_habits_block} - -你现在的主要任务是和 {sender_name} 发送的弹幕聊天。同时，也有其他用户会参与你们的聊天，你可以参考他们的回复内容，但是你主要还是关注你和{sender_name}的聊天内容。 - -{sc_info} - -{background_dialogue_prompt} --------------------------------- -{time_block} -这是你和{sender_name}的对话，你们正在交流中： -{core_dialogue_prompt} - -对方最新发送的内容：{message_txt} -{gift_info} -回复简短一些，平淡一些，可以参考贴吧，知乎和微博的回复风格，回复不要浮夸，不要用夸张修辞。 -表现的有个性，不要随意服从他人要求，积极互动。你现在的心情是：{mood_state} -不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出回复内容，现在{sender_name}正在等待你的回复。 -你的回复风格不要浮夸，有逻辑和条理，请你继续回复{sender_name}。 -你的发言： -""", - "s4u_prompt", # New template for private CHAT chat - ) - - Prompt( - """ -你的名字是麦麦, 是千石可乐开发的程序，可以在QQ，微信等平台发言，你现在正在哔哩哔哩作为虚拟主播进行直播 -虽然是个AI，但你在努力扮演真人, 人设的配色是橙色和紫色和绿色 -你有一头法式橙色卷发，你很可爱，穿戴英式侦探风格学院风裙子和帽子，你正在一个教室场景里进行虚拟线上直播。不过不要刻意提及这些内容，自然回复 -你可以看见用户发送的弹幕，礼物和superchat -你可以看见面前的屏幕，目前屏幕的内容是: -{screen_info} - -{memory_block} -{expression_habits_block} - -{sc_info} - -{time_block} -{chat_info_danmu} --------------------------------- -以上是你和弹幕的对话，与此同时，你在与QQ群友聊天，聊天记录如下： -{chat_info_qq} --------------------------------- -你刚刚回复了QQ群，你内心的想法是：{mind} -请根据你内心的想法，组织一条回复，在直播间进行发言，可以点名吐槽对象，让观众知道你在说谁 -{gift_info} -回复简短一些，平淡一些，可以参考贴吧，知乎和微博的回复风格。不要浮夸，有逻辑和条理。 -表现的有个性，不要随意服从他人要求，积极互动。你现在的心情是：{mood_state} -不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。 -你的发言： -""", - "s4u_prompt_internal", # New template for private CHAT chat - ) - - -class PromptBuilder: - def __init__(self): - self.prompt_built = "" - self.activate_messages = "" - - async def build_expression_habits(self, chat_stream: ChatStream, chat_history, target): - style_habits = [] - - # 使用从处理器传来的选中表达方式 - # LLM模式：调用LLM选择5-10个，然后随机选5个 - selected_expressions, _ = await expression_selector.select_suitable_expressions_llm( - chat_stream.stream_id, chat_history, max_num=12, target_message=target - ) - - if selected_expressions: - logger.debug(f" 使用处理器选中的{len(selected_expressions)}个表达方式") - for expr in selected_expressions: - if isinstance(expr, dict) and "situation" in expr and "style" in expr: - style_habits.append(f"当{expr['situation']}时，使用 {expr['style']}") - else: - logger.debug("没有从处理器获得表达方式，将使用空的表达方式") - # 不再在replyer中进行随机选择，全部交给处理器处理 - - style_habits_str = "\n".join(style_habits) - - # 动态构建expression habits块 - expression_habits_block = "" - if style_habits_str.strip(): - expression_habits_block += f"你可以参考以下的语言习惯，如果情景合适就使用，不要盲目使用,不要生硬使用，而是结合到表达中：\n{style_habits_str}\n\n" - - return expression_habits_block - - async def build_relation_info(self, chat_stream) -> str: - is_group_chat = bool(chat_stream.group_info) - who_chat_in_group = [] - if is_group_chat: - who_chat_in_group = get_recent_group_speaker( - chat_stream.stream_id, - (chat_stream.user_info.platform, chat_stream.user_info.user_id) if chat_stream.user_info else None, - limit=global_config.chat.max_context_size, - ) - elif chat_stream.user_info: - who_chat_in_group.append( - (chat_stream.user_info.platform, chat_stream.user_info.user_id, chat_stream.user_info.user_nickname) - ) - - relation_prompt = "" - if global_config.relationship.enable_relationship and who_chat_in_group: - # 将 (platform, user_id, nickname) 转换为 person_id - person_ids = [] - for person in who_chat_in_group: - person_id = get_person_id(person[0], person[1]) - person_ids.append(person_id) - - # 使用 Person 的 build_relationship 方法，设置 points_num=3 保持与原来相同的行为 - relation_info_list = [Person(person_id=person_id).build_relationship() for person_id in person_ids] - if relation_info := "".join(relation_info_list): - relation_prompt = await global_prompt_manager.format_prompt( - "relation_prompt", relation_info=relation_info - ) - return relation_prompt - - async def build_memory_block(self, text: str) -> str: - # 待更新记忆系统 - return "" - - related_memory = await hippocampus_manager.get_memory_from_text( - text=text, max_memory_num=2, max_memory_length=2, max_depth=3, fast_retrieval=False - ) - - related_memory_info = "" - if related_memory: - for memory in related_memory: - related_memory_info += memory[1] - return await global_prompt_manager.format_prompt("memory_prompt", memory_info=related_memory_info) - return "" - - def build_chat_history_prompts(self, chat_stream: ChatStream, message: MessageRecvS4U): - message_list_before_now = get_raw_msg_before_timestamp_with_chat( - chat_id=chat_stream.stream_id, - timestamp=time.time(), - # sourcery skip: lift-duplicated-conditional, merge-duplicate-blocks, remove-redundant-if - limit=300, - ) - - talk_type = f"{message.message_info.platform}:{str(message.chat_stream.user_info.user_id)}" - - core_dialogue_list: List[DatabaseMessages] = [] - background_dialogue_list: List[DatabaseMessages] = [] - bot_id = str(global_config.bot.qq_account) - target_user_id = str(message.chat_stream.user_info.user_id) - - for msg in message_list_before_now: - try: - msg_user_id = str(msg.user_info.user_id) - if msg_user_id == bot_id: - if msg.reply_to and talk_type == msg.reply_to: - core_dialogue_list.append(msg) - elif msg.reply_to and talk_type != msg.reply_to: - background_dialogue_list.append(msg) - # else: - # background_dialogue_list.append(msg_dict) - elif msg_user_id == target_user_id: - core_dialogue_list.append(msg) - else: - background_dialogue_list.append(msg) - except Exception as e: - logger.error(f"无法处理历史消息记录: {msg.__dict__}, 错误: {e}") - - background_dialogue_prompt = "" - if background_dialogue_list: - context_msgs = background_dialogue_list[-s4u_config.max_context_message_length :] - background_dialogue_prompt_str = build_readable_messages( - context_msgs, - timestamp_mode="normal_no_YMD", - show_pic=False, - ) - background_dialogue_prompt = f"这是其他用户的发言：\n{background_dialogue_prompt_str}" - - core_msg_str = "" - if core_dialogue_list: - core_dialogue_list = core_dialogue_list[-s4u_config.max_core_message_length :] - - first_msg = core_dialogue_list[0] - start_speaking_user_id = first_msg.user_info.user_id - if start_speaking_user_id == bot_id: - last_speaking_user_id = bot_id - msg_seg_str = "你的发言：\n" - else: - start_speaking_user_id = target_user_id - last_speaking_user_id = start_speaking_user_id - msg_seg_str = "对方的发言：\n" - - msg_seg_str += ( - f"{time.strftime('%H:%M:%S', time.localtime(first_msg.time))}: {first_msg.processed_plain_text}\n" - ) - - all_msg_seg_list = [] - for msg in core_dialogue_list[1:]: - speaker = msg.user_info.user_id - if speaker == last_speaking_user_id: - msg_seg_str += ( - f"{time.strftime('%H:%M:%S', time.localtime(msg.time))}: {msg.processed_plain_text}\n" - ) - else: - msg_seg_str = f"{msg_seg_str}\n" - all_msg_seg_list.append(msg_seg_str) - - if speaker == bot_id: - msg_seg_str = "你的发言：\n" - else: - msg_seg_str = "对方的发言：\n" - - msg_seg_str += f"{time.strftime('%H:%M:%S', time.localtime(msg.get('time')))}: {msg.get('processed_plain_text')}\n" - last_speaking_user_id = speaker - - all_msg_seg_list.append(msg_seg_str) - for msg in all_msg_seg_list: - core_msg_str += msg - - all_dialogue_history = get_raw_msg_before_timestamp_with_chat( - chat_id=chat_stream.stream_id, - timestamp=time.time(), - limit=20, - ) - - all_dialogue_prompt_str = build_readable_messages( - all_dialogue_history, - timestamp_mode="normal_no_YMD", - show_pic=False, - ) - - return core_msg_str, background_dialogue_prompt, all_dialogue_prompt_str - - def build_gift_info(self, message: MessageRecvS4U): - if message.is_gift: - return f"这是一条礼物信息，{message.gift_name} x{message.gift_count}，请注意这位用户" - else: - if message.is_fake_gift: - return f"{message.processed_plain_text}（注意：这是一条普通弹幕信息，对方没有真的发送礼物，不是礼物信息，注意区分，如果对方在发假的礼物骗你，请反击）" - - return "" - - def build_sc_info(self, message: MessageRecvS4U): - super_chat_manager = get_super_chat_manager() - return super_chat_manager.build_superchat_summary_string(message.chat_stream.stream_id) - - async def build_prompt_normal( - self, - message: MessageRecvS4U, - message_txt: str, - ) -> str: - chat_stream = message.chat_stream - - person = Person(platform=message.chat_stream.user_info.platform, user_id=message.chat_stream.user_info.user_id) - person_name = person.person_name - - if message.chat_stream.user_info.user_nickname: - if person_name: - sender_name = f"[{message.chat_stream.user_info.user_nickname}]（你叫ta{person_name}）" - else: - sender_name = f"[{message.chat_stream.user_info.user_nickname}]" - else: - sender_name = f"用户({message.chat_stream.user_info.user_id})" - - relation_info_block, memory_block, expression_habits_block = await asyncio.gather( - self.build_relation_info(chat_stream), - self.build_memory_block(message_txt), - self.build_expression_habits(chat_stream, message_txt, sender_name), - ) - - core_dialogue_prompt, background_dialogue_prompt, all_dialogue_prompt = self.build_chat_history_prompts( - chat_stream, message - ) - - gift_info = self.build_gift_info(message) - - sc_info = self.build_sc_info(message) - - screen_info = screen_manager.get_screen_str() - - internal_state = internal_manager.get_internal_state_str() - - time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}" - - mood = mood_manager.get_mood_by_chat_id(chat_stream.stream_id) - - template_name = "s4u_prompt" - - if not message.is_internal: - prompt = await global_prompt_manager.format_prompt( - template_name, - time_block=time_block, - expression_habits_block=expression_habits_block, - relation_info_block=relation_info_block, - memory_block=memory_block, - screen_info=screen_info, - internal_state=internal_state, - gift_info=gift_info, - sc_info=sc_info, - sender_name=sender_name, - core_dialogue_prompt=core_dialogue_prompt, - background_dialogue_prompt=background_dialogue_prompt, - message_txt=message_txt, - mood_state=mood.mood_state, - ) - else: - prompt = await global_prompt_manager.format_prompt( - "s4u_prompt_internal", - time_block=time_block, - expression_habits_block=expression_habits_block, - relation_info_block=relation_info_block, - memory_block=memory_block, - screen_info=screen_info, - gift_info=gift_info, - sc_info=sc_info, - chat_info_danmu=all_dialogue_prompt, - chat_info_qq=message.chat_info, - mind=message.processed_plain_text, - mood_state=mood.mood_state, - ) - - # print(prompt) - - return prompt - - -def weighted_sample_no_replacement(items, weights, k) -> list: - """ - 加权且不放回地随机抽取k个元素。 - - 参数： - items: 待抽取的元素列表 - weights: 每个元素对应的权重（与items等长，且为正数） - k: 需要抽取的元素个数 - 返回： - selected: 按权重加权且不重复抽取的k个元素组成的列表 - - 如果 items 中的元素不足 k 个，就只会返回所有可用的元素 - - 实现思路： - 每次从当前池中按权重加权随机选出一个元素，选中后将其从池中移除，重复k次。 - 这样保证了： - 1. count越大被选中概率越高 - 2. 不会重复选中同一个元素 - """ - selected = [] - pool = list(zip(items, weights, strict=False)) - for _ in range(min(k, len(pool))): - total = sum(w for _, w in pool) - r = random.uniform(0, total) - upto = 0 - for idx, (item, weight) in enumerate(pool): - upto += weight - if upto >= r: - selected.append(item) - pool.pop(idx) - break - return selected - - -init_prompt() -prompt_builder = PromptBuilder() diff --git a/src/mais4u/mais4u_chat/s4u_stream_generator.py b/src/mais4u/mais4u_chat/s4u_stream_generator.py deleted file mode 100644 index 3d7db3f3..00000000 --- a/src/mais4u/mais4u_chat/s4u_stream_generator.py +++ /dev/null @@ -1,203 +0,0 @@ -from typing import AsyncGenerator -from src.llm_models.utils_model import LLMRequest, RequestType -from src.llm_models.payload_content.message import MessageBuilder -from src.config.config import model_config -from src.chat.message_receive.message import MessageRecvS4U -from src.mais4u.mais4u_chat.s4u_prompt import prompt_builder -from src.common.logger import get_logger -import re - - -logger = get_logger("s4u_stream_generator") - - -class S4UStreamGenerator: - def __init__(self): - # 使用LLMRequest替代AsyncOpenAIClient - self.llm_request = LLMRequest(model_set=model_config.model_task_config.replyer, request_type="s4u_replyer") - - self.current_model_name = "unknown model" - self.partial_response = "" - - # 正则表达式用于按句子切分，同时处理各种标点和边缘情况 - # 匹配常见的句子结束符，但会忽略引号内和数字中的标点 - self.sentence_split_pattern = re.compile( - r'([^\s\w"\'([{]*["\'([{].*?["\'}\])][^\s\w"\'([{]*|' # 匹配被引号/括号包裹的内容 - r'[^.。!?？！\n\r]+(?:[.。!?？！\n\r](?![\'"])|$))', # 匹配直到句子结束符 - re.UNICODE | re.DOTALL, - ) - - self.chat_stream = None - - async def build_last_internal_message(self, message: MessageRecvS4U, previous_reply_context: str = ""): - # person_id = PersonInfoManager.get_person_id( - # message.chat_stream.user_info.platform, message.chat_stream.user_info.user_id - # ) - # person_info_manager = get_person_info_manager() - # person_name = await person_info_manager.get_value(person_id, "person_name") - - # if message.chat_stream.user_info.user_nickname: - # if person_name: - # sender_name = f"[{message.chat_stream.user_info.user_nickname}]（你叫ta{person_name}）" - # else: - # sender_name = f"[{message.chat_stream.user_info.user_nickname}]" - # else: - # sender_name = f"用户({message.chat_stream.user_info.user_id})" - - # 构建prompt - if previous_reply_context: - message_txt = f""" - 你正在回复用户的消息，但中途被打断了。这是已有的对话上下文: - [你已经对上一条消息说的话]: {previous_reply_context} - --- - [这是用户发来的新消息, 你需要结合上下文，对此进行回复]: - {message.processed_plain_text} - """ - return True, message_txt - else: - message_txt = message.processed_plain_text - return False, message_txt - - async def generate_response( - self, message: MessageRecvS4U, previous_reply_context: str = "" - ) -> AsyncGenerator[str, None]: - """根据当前模型类型选择对应的生成函数""" - # 从global_config中获取模型概率值并选择模型 - self.partial_response = "" - message_txt = message.processed_plain_text - if not message.is_internal: - interupted, message_txt_added = await self.build_last_internal_message(message, previous_reply_context) - if interupted: - message_txt = message_txt_added - - message.chat_stream = self.chat_stream - prompt = await prompt_builder.build_prompt_normal( - message=message, - message_txt=message_txt, - ) - - logger.info( - f"{self.current_model_name}思考:{message_txt[:30] + '...' if len(message_txt) > 30 else message_txt}" - ) # noqa: E501 - - # 使用LLMRequest进行流式生成 - async for chunk in self._generate_response_with_llm_request(prompt): - yield chunk - - async def _generate_response_with_llm_request(self, prompt: str) -> AsyncGenerator[str, None]: - """使用LLMRequest进行流式响应生成""" - - # 构建消息 - message_builder = MessageBuilder() - message_builder.add_text_content(prompt) - messages = [message_builder.build()] - - # 选择模型 - model_info, api_provider, client = self.llm_request._select_model() - self.current_model_name = model_info.name - - # 如果模型支持强制流式模式，使用真正的流式处理 - if model_info.force_stream_mode: - # 简化流式处理：直接使用LLMRequest的流式功能 - try: - # 直接调用LLMRequest的流式处理 - response = await self.llm_request._execute_request( - api_provider=api_provider, - client=client, - request_type=RequestType.RESPONSE, - model_info=model_info, - message_list=messages, - ) - - # 处理响应内容 - content = response.content or "" - if content: - # 将内容按句子分割并输出 - async for chunk in self._process_content_streaming(content): - yield chunk - - except Exception as e: - logger.error(f"流式请求执行失败: {e}") - # 如果流式请求失败，回退到普通模式 - response = await self.llm_request._execute_request( - api_provider=api_provider, - client=client, - request_type=RequestType.RESPONSE, - model_info=model_info, - message_list=messages, - ) - content = response.content or "" - async for chunk in self._process_content_streaming(content): - yield chunk - - else: - # 如果不支持流式，使用普通方式然后模拟流式输出 - response = await self.llm_request._execute_request( - api_provider=api_provider, - client=client, - request_type=RequestType.RESPONSE, - model_info=model_info, - message_list=messages, - ) - - content = response.content or "" - async for chunk in self._process_content_streaming(content): - yield chunk - - async def _process_buffer_streaming(self, buffer: str) -> AsyncGenerator[str, None]: - """实时处理缓冲区内容，输出完整句子""" - # 使用正则表达式匹配完整句子 - for match in self.sentence_split_pattern.finditer(buffer): - sentence = match.group(0).strip() - if sentence and match.end(0) <= len(buffer): - # 检查句子是否完整（以标点符号结尾） - if sentence.endswith(("。", "！", "？", ".", "!", "?")): - if sentence not in [",", "，", ".", "。", "!", "！", "?", "？"]: - self.partial_response += sentence - yield sentence - - async def _process_content_streaming(self, content: str) -> AsyncGenerator[str, None]: - """处理内容进行流式输出（用于非流式模型的模拟流式输出）""" - buffer = content - punctuation_buffer = "" - - # 使用正则表达式匹配句子 - last_match_end = 0 - for match in self.sentence_split_pattern.finditer(buffer): - sentence = match.group(0).strip() - if sentence: - # 检查是否只是一个标点符号 - if sentence in [",", "，", ".", "。", "!", "！", "?", "？"]: - punctuation_buffer += sentence - else: - # 发送之前累积的标点和当前句子 - to_yield = punctuation_buffer + sentence - if to_yield.endswith((",", "，")): - to_yield = to_yield.rstrip(",，") - - self.partial_response += to_yield - yield to_yield - punctuation_buffer = "" # 清空标点符号缓冲区 - - last_match_end = match.end(0) - - # 发送缓冲区中剩余的任何内容 - remaining = buffer[last_match_end:].strip() - to_yield = (punctuation_buffer + remaining).strip() - if to_yield: - if to_yield.endswith(("，", ",")): - to_yield = to_yield.rstrip("，,") - if to_yield: - self.partial_response += to_yield - yield to_yield - - async def _generate_response_with_model( - self, - prompt: str, - client, - model_name: str, - **kwargs, - ) -> AsyncGenerator[str, None]: - """保留原有方法签名以保持兼容性，但重定向到新的实现""" - async for chunk in self._generate_response_with_llm_request(prompt): - yield chunk diff --git a/src/mais4u/mais4u_chat/s4u_watching_manager.py b/src/mais4u/mais4u_chat/s4u_watching_manager.py deleted file mode 100644 index f079501c..00000000 --- a/src/mais4u/mais4u_chat/s4u_watching_manager.py +++ /dev/null @@ -1,106 +0,0 @@ -from src.common.logger import get_logger -from src.plugin_system.apis import send_api - -""" -视线管理系统使用说明： - -1. 视线状态： - - wandering: 随意看 - - danmu: 看弹幕 - - lens: 看镜头 - -2. 状态切换逻辑： - - 收到消息时 → 切换为看弹幕，立即发送更新 - - 开始生成回复时 → 切换为看镜头或随意，立即发送更新 - - 生成完毕后 → 看弹幕1秒，然后回到看镜头直到有新消息，状态变化时立即发送更新 - -3. 使用方法： - # 获取视线管理器 - watching = watching_manager.get_watching_by_chat_id(chat_id) - - # 收到消息时调用 - await watching.on_message_received() - - # 开始生成回复时调用 - await watching.on_reply_start() - - # 生成回复完毕时调用 - await watching.on_reply_finished() - -4. 自动更新系统： - - 状态变化时立即发送type为"watching"，data为状态值的websocket消息 - - 使用定时器自动处理状态转换（如看弹幕时间结束后自动切换到看镜头） - - 无需定期检查，所有状态变化都是事件驱动的 -""" - -logger = get_logger("watching") - -HEAD_CODE = { - "看向上方": "(0,0.5,0)", - "看向下方": "(0,-0.5,0)", - "看向左边": "(-1,0,0)", - "看向右边": "(1,0,0)", - "随意朝向": "random", - "看向摄像机": "camera", - "注视对方": "(0,0,0)", - "看向正前方": "(0,0,0)", -} - - -class ChatWatching: - def __init__(self, chat_id: str): - self.chat_id: str = chat_id - - async def on_reply_start(self): - """开始生成回复时调用""" - await send_api.custom_to_stream( - message_type="state", content="start_thinking", stream_id=self.chat_id, storage_message=False - ) - - async def on_reply_finished(self): - """生成回复完毕时调用""" - await send_api.custom_to_stream( - message_type="state", content="finish_reply", stream_id=self.chat_id, storage_message=False - ) - - async def on_thinking_finished(self): - """思考完毕时调用""" - await send_api.custom_to_stream( - message_type="state", content="finish_thinking", stream_id=self.chat_id, storage_message=False - ) - - async def on_message_received(self): - """收到消息时调用""" - await send_api.custom_to_stream( - message_type="state", content="start_viewing", stream_id=self.chat_id, storage_message=False - ) - - async def on_internal_message_start(self): - """收到消息时调用""" - await send_api.custom_to_stream( - message_type="state", content="start_internal_thinking", stream_id=self.chat_id, storage_message=False - ) - - -class WatchingManager: - def __init__(self): - self.watching_list: list[ChatWatching] = [] - """当前视线状态列表""" - self.task_started: bool = False - - def get_watching_by_chat_id(self, chat_id: str) -> ChatWatching: - """获取或创建聊天对应的视线管理器""" - for watching in self.watching_list: - if watching.chat_id == chat_id: - return watching - - new_watching = ChatWatching(chat_id) - self.watching_list.append(new_watching) - logger.info(f"为chat {chat_id}创建新的视线管理器") - - return new_watching - - -# 全局视线管理器实例 -watching_manager = WatchingManager() -"""全局视线管理器""" diff --git a/src/mais4u/mais4u_chat/screen_manager.py b/src/mais4u/mais4u_chat/screen_manager.py deleted file mode 100644 index 996e6399..00000000 --- a/src/mais4u/mais4u_chat/screen_manager.py +++ /dev/null @@ -1,15 +0,0 @@ -class ScreenManager: - def __init__(self): - self.now_screen = str() - - def set_screen(self, screen_str: str): - self.now_screen = screen_str - - def get_screen(self): - return self.now_screen - - def get_screen_str(self): - return f"你可以看见面前的屏幕，目前屏幕的内容是:现在千石可乐在和你一起直播，这是他正在操作的屏幕内容：{self.now_screen}" - - -screen_manager = ScreenManager() diff --git a/src/mais4u/mais4u_chat/super_chat_manager.py b/src/mais4u/mais4u_chat/super_chat_manager.py deleted file mode 100644 index ef86a6ba..00000000 --- a/src/mais4u/mais4u_chat/super_chat_manager.py +++ /dev/null @@ -1,303 +0,0 @@ -import asyncio -import time -from dataclasses import dataclass -from typing import Dict, List, Optional -from src.common.logger import get_logger -from src.chat.message_receive.message import MessageRecvS4U - -# 全局SuperChat管理器实例 -from src.mais4u.s4u_config import s4u_config - -logger = get_logger("super_chat_manager") - - -@dataclass -class SuperChatRecord: - """SuperChat记录数据类""" - - user_id: str - user_nickname: str - platform: str - chat_id: str - price: float - message_text: str - timestamp: float - expire_time: float - group_name: Optional[str] = None - - def is_expired(self) -> bool: - """检查SuperChat是否已过期""" - return time.time() > self.expire_time - - def remaining_time(self) -> float: - """获取剩余时间（秒）""" - return max(0, self.expire_time - time.time()) - - def to_dict(self) -> dict: - """转换为字典格式""" - return { - "user_id": self.user_id, - "user_nickname": self.user_nickname, - "platform": self.platform, - "chat_id": self.chat_id, - "price": self.price, - "message_text": self.message_text, - "timestamp": self.timestamp, - "expire_time": self.expire_time, - "group_name": self.group_name, - "remaining_time": self.remaining_time(), - } - - -class SuperChatManager: - """SuperChat管理器，负责管理和跟踪SuperChat消息""" - - def __init__(self): - self.super_chats: Dict[str, List[SuperChatRecord]] = {} # chat_id -> SuperChat列表 - self._cleanup_task: Optional[asyncio.Task] = None - self._is_initialized = False - logger.info("SuperChat管理器已初始化") - - def _ensure_cleanup_task_started(self): - """确保清理任务已启动（延迟启动）""" - if self._cleanup_task is None or self._cleanup_task.done(): - try: - loop = asyncio.get_running_loop() - self._cleanup_task = loop.create_task(self._cleanup_expired_superchats()) - self._is_initialized = True - logger.info("SuperChat清理任务已启动") - except RuntimeError: - # 没有运行的事件循环，稍后再启动 - logger.debug("当前没有运行的事件循环，将在需要时启动清理任务") - - def _start_cleanup_task(self): - """启动清理任务（已弃用，保留向后兼容）""" - self._ensure_cleanup_task_started() - - async def _cleanup_expired_superchats(self): - """定期清理过期的SuperChat""" - while True: - try: - total_removed = 0 - - for chat_id in list(self.super_chats.keys()): - original_count = len(self.super_chats[chat_id]) - # 移除过期的SuperChat - self.super_chats[chat_id] = [sc for sc in self.super_chats[chat_id] if not sc.is_expired()] - - removed_count = original_count - len(self.super_chats[chat_id]) - total_removed += removed_count - - if removed_count > 0: - logger.info(f"从聊天 {chat_id} 中清理了 {removed_count} 个过期的SuperChat") - - # 如果列表为空，删除该聊天的记录 - if not self.super_chats[chat_id]: - del self.super_chats[chat_id] - - if total_removed > 0: - logger.info(f"总共清理了 {total_removed} 个过期的SuperChat") - - # 每30秒检查一次 - await asyncio.sleep(30) - - except Exception as e: - logger.error(f"清理过期SuperChat时出错: {e}", exc_info=True) - await asyncio.sleep(60) # 出错时等待更长时间 - - def _calculate_expire_time(self, price: float) -> float: - """根据SuperChat金额计算过期时间""" - current_time = time.time() - - # 根据金额阶梯设置不同的存活时间 - if price >= 500: - # 500元以上：保持4小时 - duration = 4 * 3600 - elif price >= 200: - # 200-499元：保持2小时 - duration = 2 * 3600 - elif price >= 100: - # 100-199元：保持1小时 - duration = 1 * 3600 - elif price >= 50: - # 50-99元：保持30分钟 - duration = 30 * 60 - elif price >= 20: - # 20-49元：保持15分钟 - duration = 15 * 60 - elif price >= 10: - # 10-19元：保持10分钟 - duration = 10 * 60 - else: - # 10元以下：保持5分钟 - duration = 5 * 60 - - return current_time + duration - - async def add_superchat(self, message: MessageRecvS4U) -> None: - """添加新的SuperChat记录""" - # 确保清理任务已启动 - self._ensure_cleanup_task_started() - - if not message.is_superchat or not message.superchat_price: - logger.warning("尝试添加非SuperChat消息到SuperChat管理器") - return - - try: - price = float(message.superchat_price) - except (ValueError, TypeError): - logger.error(f"无效的SuperChat价格: {message.superchat_price}") - return - - user_info = message.message_info.user_info - group_info = message.message_info.group_info - chat_id = getattr(message, "chat_stream", None) - if chat_id: - chat_id = chat_id.stream_id - else: - # 生成chat_id的备用方法 - chat_id = f"{message.message_info.platform}_{user_info.user_id}" - if group_info: - chat_id = f"{message.message_info.platform}_{group_info.group_id}" - - expire_time = self._calculate_expire_time(price) - - record = SuperChatRecord( - user_id=user_info.user_id, - user_nickname=user_info.user_nickname, - platform=message.message_info.platform, - chat_id=chat_id, - price=price, - message_text=message.superchat_message_text or "", - timestamp=message.message_info.time, - expire_time=expire_time, - group_name=group_info.group_name if group_info else None, - ) - - # 添加到对应聊天的SuperChat列表 - if chat_id not in self.super_chats: - self.super_chats[chat_id] = [] - - self.super_chats[chat_id].append(record) - - # 按价格降序排序（价格高的在前） - self.super_chats[chat_id].sort(key=lambda x: x.price, reverse=True) - - logger.info(f"添加SuperChat记录: {user_info.user_nickname} - {price}元 - {message.superchat_message_text}") - - def get_superchats_by_chat(self, chat_id: str) -> List[SuperChatRecord]: - """获取指定聊天的所有有效SuperChat""" - # 确保清理任务已启动 - self._ensure_cleanup_task_started() - - if chat_id not in self.super_chats: - return [] - - # 过滤掉过期的SuperChat - valid_superchats = [sc for sc in self.super_chats[chat_id] if not sc.is_expired()] - return valid_superchats - - def get_all_valid_superchats(self) -> Dict[str, List[SuperChatRecord]]: - """获取所有有效的SuperChat""" - # 确保清理任务已启动 - self._ensure_cleanup_task_started() - - result = {} - for chat_id, superchats in self.super_chats.items(): - valid_superchats = [sc for sc in superchats if not sc.is_expired()] - if valid_superchats: - result[chat_id] = valid_superchats - return result - - def build_superchat_display_string(self, chat_id: str, max_count: int = 10) -> str: - """构建SuperChat显示字符串""" - superchats = self.get_superchats_by_chat(chat_id) - - if not superchats: - return "" - - # 限制显示数量 - display_superchats = superchats[:max_count] - - lines = ["📢 当前有效超级弹幕："] - for i, sc in enumerate(display_superchats, 1): - remaining_minutes = int(sc.remaining_time() / 60) - remaining_seconds = int(sc.remaining_time() % 60) - - time_display = ( - f"{remaining_minutes}分{remaining_seconds}秒" if remaining_minutes > 0 else f"{remaining_seconds}秒" - ) - - line = f"{i}. 【{sc.price}元】{sc.user_nickname}: {sc.message_text}" - if len(line) > 100: # 限制单行长度 - line = f"{line[:97]}..." - line += f" (剩余{time_display})" - lines.append(line) - - if len(superchats) > max_count: - lines.append(f"... 还有{len(superchats) - max_count}条SuperChat") - - return "\n".join(lines) - - def build_superchat_summary_string(self, chat_id: str) -> str: - """构建SuperChat摘要字符串""" - superchats = self.get_superchats_by_chat(chat_id) - - if not superchats: - return "当前没有有效的超级弹幕" - lines = [] - for sc in superchats: - single_sc_str = f"{sc.user_nickname} - {sc.price}元 - {sc.message_text}" - if len(single_sc_str) > 100: - single_sc_str = f"{single_sc_str[:97]}..." - single_sc_str += f" (剩余{int(sc.remaining_time())}秒)" - lines.append(single_sc_str) - - total_amount = sum(sc.price for sc in superchats) - count = len(superchats) - highest_amount = max(sc.price for sc in superchats) - - final_str = f"当前有{count}条超级弹幕，总金额{total_amount}元，最高单笔{highest_amount}元" - if lines: - final_str += "\n" + "\n".join(lines) - return final_str - - def get_superchat_statistics(self, chat_id: str) -> dict: - """获取SuperChat统计信息""" - superchats = self.get_superchats_by_chat(chat_id) - - if not superchats: - return {"count": 0, "total_amount": 0, "average_amount": 0, "highest_amount": 0, "lowest_amount": 0} - - amounts = [sc.price for sc in superchats] - - return { - "count": len(superchats), - "total_amount": sum(amounts), - "average_amount": sum(amounts) / len(amounts), - "highest_amount": max(amounts), - "lowest_amount": min(amounts), - } - - async def shutdown(self): # sourcery skip: use-contextlib-suppress - """关闭管理器，清理资源""" - if self._cleanup_task and not self._cleanup_task.done(): - self._cleanup_task.cancel() - try: - await self._cleanup_task - except asyncio.CancelledError: - pass - logger.info("SuperChat管理器已关闭") - - -# sourcery skip: assign-if-exp -if s4u_config.enable_s4u: - super_chat_manager = SuperChatManager() -else: - super_chat_manager = None - - -def get_super_chat_manager() -> SuperChatManager: - """获取全局SuperChat管理器实例""" - - return super_chat_manager diff --git a/src/mais4u/mais4u_chat/yes_or_no.py b/src/mais4u/mais4u_chat/yes_or_no.py deleted file mode 100644 index c71c160d..00000000 --- a/src/mais4u/mais4u_chat/yes_or_no.py +++ /dev/null @@ -1,46 +0,0 @@ -from src.llm_models.utils_model import LLMRequest -from src.common.logger import get_logger -from src.config.config import model_config -from src.plugin_system.apis import send_api - -logger = get_logger(__name__) - -head_actions_list = ["不做额外动作", "点头一次", "点头两次", "摇头", "歪脑袋", "低头望向一边"] - - -async def yes_or_no_head(text: str, emotion: str = "", chat_history: str = "", chat_id: str = ""): - prompt = f""" -{chat_history} -以上是对方的发言： - -对这个发言，你的心情是：{emotion} -对上面的发言，你的回复是：{text} -请判断时是否要伴随回复做头部动作，你可以选择： - -不做额外动作 -点头一次 -点头两次 -摇头 -歪脑袋 -低头望向一边 - -请从上面的动作中选择一个，并输出，请只输出你选择的动作就好，不要输出其他内容。""" - model = LLMRequest(model_set=model_config.model_task_config.emotion, request_type="motion") - - try: - # logger.info(f"prompt: {prompt}") - response, _ = await model.generate_response_async(prompt=prompt, temperature=0.7) - logger.info(f"response: {response}") - - head_action = response if response in head_actions_list else "不做额外动作" - await send_api.custom_to_stream( - message_type="head_action", - content=head_action, - stream_id=chat_id, - storage_message=False, - show_log=True, - ) - - except Exception as e: - logger.error(f"yes_or_no_head error: {e}") - return "不做额外动作" diff --git a/src/mais4u/s4u_config.py b/src/mais4u/s4u_config.py deleted file mode 100644 index cbb686a4..00000000 --- a/src/mais4u/s4u_config.py +++ /dev/null @@ -1,368 +0,0 @@ -import os -import tomlkit -import shutil -from datetime import datetime -from tomlkit import TOMLDocument -from tomlkit.items import Table -from dataclasses import dataclass, fields, MISSING, field -from typing import TypeVar, Type, Any, get_origin, get_args, Literal -from src.common.logger import get_logger - -logger = get_logger("s4u_config") - - -# 新增：兼容dict和tomlkit Table -def is_dict_like(obj): - return isinstance(obj, (dict, Table)) - - -# 新增：递归将Table转为dict -def table_to_dict(obj): - if isinstance(obj, Table): - return {k: table_to_dict(v) for k, v in obj.items()} - elif isinstance(obj, dict): - return {k: table_to_dict(v) for k, v in obj.items()} - elif isinstance(obj, list): - return [table_to_dict(i) for i in obj] - else: - return obj - - -# 获取mais4u模块目录 -MAIS4U_ROOT = os.path.dirname(__file__) -CONFIG_DIR = os.path.join(MAIS4U_ROOT, "config") -TEMPLATE_PATH = os.path.join(CONFIG_DIR, "s4u_config_template.toml") -CONFIG_PATH = os.path.join(CONFIG_DIR, "s4u_config.toml") - -# S4U配置版本 -S4U_VERSION = "1.1.0" - -T = TypeVar("T", bound="S4UConfigBase") - - -@dataclass -class S4UConfigBase: - """S4U配置类的基类""" - - @classmethod - def from_dict(cls: Type[T], data: dict[str, Any]) -> T: - """从字典加载配置字段""" - data = table_to_dict(data) # 递归转dict，兼容tomlkit Table - if not is_dict_like(data): - raise TypeError(f"Expected a dictionary, got {type(data).__name__}") - - init_args: dict[str, Any] = {} - - for f in fields(cls): - field_name = f.name - - if field_name.startswith("_"): - # 跳过以 _ 开头的字段 - continue - - if field_name not in data: - if f.default is not MISSING or f.default_factory is not MISSING: - # 跳过未提供且有默认值/默认构造方法的字段 - continue - else: - raise ValueError(f"Missing required field: '{field_name}'") - - value = data[field_name] - field_type = f.type - - try: - init_args[field_name] = cls._convert_field(value, field_type) # type: ignore - except TypeError as e: - raise TypeError(f"Field '{field_name}' has a type error: {e}") from e - except Exception as e: - raise RuntimeError(f"Failed to convert field '{field_name}' to target type: {e}") from e - - return cls(**init_args) - - @classmethod - def _convert_field(cls, value: Any, field_type: Type[Any]) -> Any: - """转换字段值为指定类型""" - # 如果是嵌套的 dataclass，递归调用 from_dict 方法 - if isinstance(field_type, type) and issubclass(field_type, S4UConfigBase): - if not is_dict_like(value): - raise TypeError(f"Expected a dictionary for {field_type.__name__}, got {type(value).__name__}") - return field_type.from_dict(value) - - # 处理泛型集合类型（list, set, tuple） - field_origin_type = get_origin(field_type) - field_type_args = get_args(field_type) - - if field_origin_type in {list, set, tuple}: - if not isinstance(value, list): - raise TypeError(f"Expected an list for {field_type.__name__}, got {type(value).__name__}") - - if field_origin_type is list: - if ( - field_type_args - and isinstance(field_type_args[0], type) - and issubclass(field_type_args[0], S4UConfigBase) - ): - return [field_type_args[0].from_dict(item) for item in value] - return [cls._convert_field(item, field_type_args[0]) for item in value] - elif field_origin_type is set: - return {cls._convert_field(item, field_type_args[0]) for item in value} - elif field_origin_type is tuple: - if len(value) != len(field_type_args): - raise TypeError( - f"Expected {len(field_type_args)} items for {field_type.__name__}, got {len(value)}" - ) - return tuple(cls._convert_field(item, arg) for item, arg in zip(value, field_type_args, strict=False)) - - if field_origin_type is dict: - if not is_dict_like(value): - raise TypeError(f"Expected a dictionary for {field_type.__name__}, got {type(value).__name__}") - - if len(field_type_args) != 2: - raise TypeError(f"Expected a dictionary with two type arguments for {field_type.__name__}") - key_type, value_type = field_type_args - - return {cls._convert_field(k, key_type): cls._convert_field(v, value_type) for k, v in value.items()} - - # 处理基础类型，例如 int, str 等 - if field_origin_type is type(None) and value is None: # 处理Optional类型 - return None - - # 处理Literal类型 - if field_origin_type is Literal or get_origin(field_type) is Literal: - allowed_values = get_args(field_type) - if value in allowed_values: - return value - else: - raise TypeError(f"Value '{value}' is not in allowed values {allowed_values} for Literal type") - - if field_type is Any or isinstance(value, field_type): - return value - - # 其他类型，尝试直接转换 - try: - return field_type(value) - except (ValueError, TypeError) as e: - raise TypeError(f"Cannot convert {type(value).__name__} to {field_type.__name__}") from e - - -@dataclass -class S4UModelConfig(S4UConfigBase): - """S4U模型配置类""" - - # 主要对话模型配置 - chat: dict[str, Any] = field(default_factory=lambda: {}) - """主要对话模型配置""" - - # 规划模型配置（原model_motion） - motion: dict[str, Any] = field(default_factory=lambda: {}) - """规划模型配置""" - - # 情感分析模型配置 - emotion: dict[str, Any] = field(default_factory=lambda: {}) - """情感分析模型配置""" - - # 记忆模型配置 - memory: dict[str, Any] = field(default_factory=lambda: {}) - """记忆模型配置""" - - # 工具使用模型配置 - tool_use: dict[str, Any] = field(default_factory=lambda: {}) - """工具使用模型配置""" - - # 嵌入模型配置 - embedding: dict[str, Any] = field(default_factory=lambda: {}) - """嵌入模型配置""" - - # 视觉语言模型配置 - vlm: dict[str, Any] = field(default_factory=lambda: {}) - """视觉语言模型配置""" - - # 知识库模型配置 - knowledge: dict[str, Any] = field(default_factory=lambda: {}) - """知识库模型配置""" - - # 实体提取模型配置 - entity_extract: dict[str, Any] = field(default_factory=lambda: {}) - """实体提取模型配置""" - - # 问答模型配置 - qa: dict[str, Any] = field(default_factory=lambda: {}) - """问答模型配置""" - - -@dataclass -class S4UConfig(S4UConfigBase): - """S4U聊天系统配置类""" - - enable_s4u: bool = False - """是否启用S4U聊天系统""" - - message_timeout_seconds: int = 120 - """普通消息存活时间（秒），超过此时间的消息将被丢弃""" - - at_bot_priority_bonus: float = 100.0 - """@机器人时的优先级加成分数""" - - recent_message_keep_count: int = 6 - """保留最近N条消息，超出范围的普通消息将被移除""" - - typing_delay: float = 0.1 - """打字延迟时间（秒），模拟真实打字速度""" - - chars_per_second: float = 15.0 - """每秒字符数，用于计算动态打字延迟""" - - min_typing_delay: float = 0.2 - """最小打字延迟（秒）""" - - max_typing_delay: float = 2.0 - """最大打字延迟（秒）""" - - enable_dynamic_typing_delay: bool = False - """是否启用基于文本长度的动态打字延迟""" - - vip_queue_priority: bool = True - """是否启用VIP队列优先级系统""" - - enable_message_interruption: bool = True - """是否允许高优先级消息中断当前回复""" - - enable_old_message_cleanup: bool = True - """是否自动清理过旧的普通消息""" - - enable_streaming_output: bool = True - """是否启用流式输出，false时全部生成后一次性发送""" - - max_context_message_length: int = 20 - """上下文消息最大长度""" - - max_core_message_length: int = 30 - """核心消息最大长度""" - - # 模型配置 - models: S4UModelConfig = field(default_factory=S4UModelConfig) - """S4U模型配置""" - - # 兼容性字段，保持向后兼容 - - -@dataclass -class S4UGlobalConfig(S4UConfigBase): - """S4U总配置类""" - - s4u: S4UConfig - S4U_VERSION: str = S4U_VERSION - - -def update_s4u_config(): - """更新S4U配置文件""" - # 创建配置目录（如果不存在） - os.makedirs(CONFIG_DIR, exist_ok=True) - - # 检查模板文件是否存在 - if not os.path.exists(TEMPLATE_PATH): - logger.error(f"S4U配置模板文件不存在: {TEMPLATE_PATH}") - logger.error("请确保模板文件存在后重新运行") - raise FileNotFoundError(f"S4U配置模板文件不存在: {TEMPLATE_PATH}") - - # 检查配置文件是否存在 - if not os.path.exists(CONFIG_PATH): - logger.info("S4U配置文件不存在，从模板创建新配置") - shutil.copy2(TEMPLATE_PATH, CONFIG_PATH) - logger.info(f"已创建S4U配置文件: {CONFIG_PATH}") - return - - # 读取旧配置文件和模板文件 - with open(CONFIG_PATH, "r", encoding="utf-8") as f: - old_config = tomlkit.load(f) - with open(TEMPLATE_PATH, "r", encoding="utf-8") as f: - new_config = tomlkit.load(f) - - # 检查version是否相同 - if old_config and "inner" in old_config and "inner" in new_config: - old_version = old_config["inner"].get("version") # type: ignore - new_version = new_config["inner"].get("version") # type: ignore - if old_version and new_version and old_version == new_version: - logger.info(f"检测到S4U配置文件版本号相同 (v{old_version})，跳过更新") - return - else: - logger.info(f"检测到S4U配置版本号不同: 旧版本 v{old_version} -> 新版本 v{new_version}") - else: - logger.info("S4U配置文件未检测到版本号，可能是旧版本。将进行更新") - - # 创建备份目录 - old_config_dir = os.path.join(CONFIG_DIR, "old") - os.makedirs(old_config_dir, exist_ok=True) - timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") - old_backup_path = os.path.join(old_config_dir, f"s4u_config_{timestamp}.toml") - - # 移动旧配置文件到old目录 - shutil.move(CONFIG_PATH, old_backup_path) - logger.info(f"已备份旧S4U配置文件到: {old_backup_path}") - - # 复制模板文件到配置目录 - shutil.copy2(TEMPLATE_PATH, CONFIG_PATH) - logger.info(f"已创建新S4U配置文件: {CONFIG_PATH}") - - def update_dict(target: TOMLDocument | dict | Table, source: TOMLDocument | dict): - """ - 将source字典的值更新到target字典中（如果target中存在相同的键） - """ - for key, value in source.items(): - # 跳过version字段的更新 - if key == "version": - continue - if key in target: - target_value = target[key] - if isinstance(value, dict) and isinstance(target_value, (dict, Table)): - update_dict(target_value, value) - else: - try: - # 对数组类型进行特殊处理 - if isinstance(value, list): - target[key] = tomlkit.array(str(value)) if value else tomlkit.array() - else: - # 其他类型使用item方法创建新值 - target[key] = tomlkit.item(value) - except (TypeError, ValueError): - # 如果转换失败，直接赋值 - target[key] = value - - # 将旧配置的值更新到新配置中 - logger.info("开始合并S4U新旧配置...") - update_dict(new_config, old_config) - - # 保存更新后的配置（保留注释和格式） - with open(CONFIG_PATH, "w", encoding="utf-8") as f: - f.write(tomlkit.dumps(new_config)) - - logger.info("S4U配置文件更新完成") - - -def load_s4u_config(config_path: str) -> S4UGlobalConfig: - """ - 加载S4U配置文件 - :param config_path: 配置文件路径 - :return: S4UGlobalConfig对象 - """ - # 读取配置文件 - with open(config_path, "r", encoding="utf-8") as f: - config_data = tomlkit.load(f) - - # 创建S4UGlobalConfig对象 - try: - return S4UGlobalConfig.from_dict(config_data) - except Exception as e: - logger.critical("S4U配置文件解析失败") - raise e - - # 初始化S4U配置 - - -logger.info(f"S4U当前版本: {S4U_VERSION}") -update_s4u_config() - -s4u_config_main = load_s4u_config(config_path=CONFIG_PATH) -logger.info("S4U配置文件加载完成！") - -s4u_config: S4UConfig = s4u_config_main.s4u diff --git a/src/memory_system/Memory_chest.py b/src/memory_system/Memory_chest.py new file mode 100644 index 00000000..e28267c0 --- /dev/null +++ b/src/memory_system/Memory_chest.py @@ -0,0 +1,797 @@ +import asyncio +import json +import re +import time +import random + +from src.llm_models.utils_model import LLMRequest +from src.config.config import model_config +from src.common.database.database_model import MemoryChest as MemoryChestModel +from src.common.logger import get_logger +from src.config.config import global_config +from src.plugin_system.apis.message_api import build_readable_messages +from src.plugin_system.apis.message_api import get_raw_msg_by_timestamp_with_chat +from json_repair import repair_json +from src.memory_system.questions import global_conflict_tracker + +from .memory_utils import ( + find_best_matching_memory, + check_title_exists_fuzzy, + get_all_titles, + get_memory_titles_by_chat_id_weighted, + +) + +logger = get_logger("memory") + +class MemoryChest: + def __init__(self): + + self.LLMRequest = LLMRequest( + model_set=model_config.model_task_config.utils_small, + request_type="memory_chest", + ) + + self.LLMRequest_build = LLMRequest( + model_set=model_config.model_task_config.utils, + request_type="memory_chest_build", + ) + + + self.running_content_list = {} # {chat_id: {"content": running_content, "last_update_time": timestamp, "create_time": timestamp}} + self.fetched_memory_list = [] # [(chat_id, (question, answer, timestamp)), ...] + + async def build_running_content(self, chat_id: str = None) -> str: + """ + 构建记忆仓库的运行内容 + + Args: + message_str: 消息内容 + chat_id: 聊天ID，用于提取对应的运行内容 + + Returns: + str: 构建后的运行内容 + """ + # 检查是否需要更新：基于消息数量和最新消息时间差的智能更新机制 + # + # 更新机制说明： + # 1. 消息数量 > 100：直接触发更新（高频消息场景） + # 2. 消息数量 > 70 且最新消息时间差 > 30秒：触发更新（中高频消息场景） + # 3. 消息数量 > 50 且最新消息时间差 > 60秒：触发更新（中频消息场景） + # 4. 消息数量 > 30 且最新消息时间差 > 300秒：触发更新（低频消息场景） + # + # 设计理念： + # - 消息越密集，时间阈值越短，确保及时更新记忆 + # - 消息越稀疏，时间阈值越长，避免频繁无意义的更新 + # - 通过最新消息时间差判断消息活跃度，而非简单的总时间差 + # - 平衡更新频率与性能，在保证记忆及时性的同时减少计算开销 + if chat_id not in self.running_content_list: + self.running_content_list[chat_id] = { + "content": "", + "last_update_time": time.time(), + "create_time": time.time() + } + + should_update = True + if chat_id and chat_id in self.running_content_list: + last_update_time = self.running_content_list[chat_id]["last_update_time"] + current_time = time.time() + # 使用message_api获取消息数量 + message_list = get_raw_msg_by_timestamp_with_chat( + timestamp_start=last_update_time, + timestamp_end=current_time, + chat_id=chat_id, + limit=global_config.chat.max_context_size * 2, + ) + + new_messages_count = len(message_list) + + # 获取最新消息的时间戳 + latest_message_time = last_update_time + if message_list: + # 假设消息列表按时间排序，取最后一条消息的时间戳 + latest_message = message_list[-1] + if hasattr(latest_message, 'timestamp'): + latest_message_time = latest_message.timestamp + elif isinstance(latest_message, dict) and 'timestamp' in latest_message: + latest_message_time = latest_message['timestamp'] + + # 计算最新消息时间与现在时间的差（秒） + latest_message_time_diff = current_time - latest_message_time + + # 智能更新条件判断 - 按优先级从高到低检查 + should_update = False + update_reason = "" + + if global_config.memory.memory_build_frequency > 0: + if new_messages_count > 100/global_config.memory.memory_build_frequency: + # 条件1：消息数量 > 100，直接触发更新 + # 适用场景：群聊刷屏、高频讨论等消息密集场景 + # 无需时间限制，确保重要信息不被遗漏 + should_update = True + update_reason = f"消息数量 {new_messages_count} > 100，直接触发更新" + elif new_messages_count > 70/global_config.memory.memory_build_frequency and latest_message_time_diff > 30: + # 条件2：消息数量 > 70 且最新消息时间差 > 30秒 + # 适用场景：中高频讨论，但需要确保消息流已稳定 + # 30秒的时间差确保不是正在进行的实时对话 + should_update = True + update_reason = f"消息数量 {new_messages_count} > 70 且最新消息时间差 {latest_message_time_diff:.1f}s > 30s" + elif new_messages_count > 50/global_config.memory.memory_build_frequency and latest_message_time_diff > 60: + # 条件3：消息数量 > 50 且最新消息时间差 > 60秒 + # 适用场景：中等频率讨论，等待1分钟确保对话告一段落 + # 平衡及时性与稳定性 + should_update = True + update_reason = f"消息数量 {new_messages_count} > 50 且最新消息时间差 {latest_message_time_diff:.1f}s > 60s" + elif new_messages_count > 30/global_config.memory.memory_build_frequency and latest_message_time_diff > 300: + # 条件4：消息数量 > 30 且最新消息时间差 > 300秒（5分钟） + # 适用场景：低频但有一定信息量的讨论 + # 5分钟的时间差确保对话完全结束，避免频繁更新 + should_update = True + update_reason = f"消息数量 {new_messages_count} > 30 且最新消息时间差 {latest_message_time_diff:.1f}s > 300s" + + logger.debug(f"chat_id {chat_id} 更新检查: {update_reason if should_update else f'消息数量 {new_messages_count}，最新消息时间差 {latest_message_time_diff:.1f}s，不满足更新条件'}") + + + if should_update: + # 如果有chat_id，先提取对应的running_content + message_str = build_readable_messages( + message_list, + replace_bot_name=True, + timestamp_mode="relative", + read_mark=0.0, + show_actions=False, + remove_emoji_stickers=True, + ) + + # 随机从格式示例列表中选取若干行用于提示 + format_candidates = [ + "[概念] 是 [概念的含义(简短描述，不超过十个字)]", + "[概念] 不是 [对概念的负面含义(简短描述，不超过十个字)]", + "[概念1] 与 [概念2] 是 [概念1和概念2的关联(简短描述，不超过二十个字)]", + "[概念1] 包含 [概念2] 和 [概念3]", + "[概念1] 属于 [概念2]", + "[概念1] 的例子是 [例子1] 和 [例子2]", + "[概念] 的特征是 [特征1]、[特征2]", + "[概念1] 导致 [概念2]", + "[概念1] 需要 [条件1] 和 [条件2]", + "[概念1] 的用途是 [用途1] 和 [用途2]", + "[概念1] 与 [概念2] 的区别是 [区别点]", + "[概念] 的别名是 [别名]", + "[概念1] 包括但不限于 [概念2]、[概念3]", + "[概念] 的反义是 [反义概念]", + "[概念] 的组成有 [部分1]、[部分2]", + "[概念] 出现于 [时间或场景]", + "[概念] 的方法有 [方法1]、[方法2]", + ] + + selected_count = random.randint(3, 6) + selected_lines = random.sample(format_candidates, selected_count) + format_section = "\n".join(selected_lines) + "\n......(不要包含中括号)" + + prompt = f""" +以下是一段你参与的聊天记录，请你在其中总结出记忆： + +<聊天记录> +{message_str} + +聊天记录中可能包含有效信息，也可能信息密度很低，请你根据聊天记录中的信息，总结出记忆内容 +-------------------------------- +对[图片]的处理： +1.除非与文本有关，不要将[图片]的内容整合到记忆中 +2.如果图片与某个概念相关，将图片中的关键内容也整合到记忆中，不要写入图片原文，例如： + +聊天记录（与图片有关）： +用户说：[图片1：这是一个黄色的龙形状玩偶，被一只手拿着。] +用户说：这个玩偶看起来很可爱，是我新买的奶龙 +总结的记忆内容： +黄色的龙形状玩偶 是 奶龙 + +聊天记录（概念与图片无关）： +用户说：[图片1：这是一个台电脑，屏幕上显示了某种游戏。] +用户说：使命召唤今天发售了新一代，有没有人玩 +总结的记忆内容： +使命召唤新一代 是 最新发售的游戏 + +请主要关注概念和知识或者时效性较强的信息！！，而不是聊天的琐事 +1.不要关注诸如某个用户做了什么，说了什么，不要关注某个用户的行为，而是关注其中的概念性信息 +2.概念要求精确，不啰嗦，像科普读物或教育课本那样 +3.记忆为一段纯文本，逻辑清晰，指出概念的含义，并说明关系 + + 记忆内容的格式，你必须仿照下面的格式，但不一定全部使用: +{format_section} + +请仿照上述格式输出，每个知识点一句话。输出成一段平文本 +现在请你输出,不要输出其他内容，注意一定要直白，白话，口语化不要浮夸，修辞。： +""" + + if global_config.debug.show_prompt: + logger.info(f"记忆仓库构建运行内容 prompt: {prompt}") + else: + logger.debug(f"记忆仓库构建运行内容 prompt: {prompt}") + + running_content, (reasoning_content, model_name, tool_calls) = await self.LLMRequest_build.generate_response_async(prompt) + + print(f"prompt: {prompt}\n记忆仓库构建运行内容: {running_content}") + + # 直接保存：每次构建后立即入库，并刷新时间戳窗口 + if chat_id and running_content: + await self._save_to_database_and_clear(chat_id, running_content) + + + return running_content + + + async def get_answer_by_question(self, chat_id: str = "", question: str = "") -> str: + """ + 根据问题获取答案 + """ + logger.info(f"正在回忆问题答案: {question}") + + title = await self.select_title_by_question(question) + + if not title: + return "" + + for memory in MemoryChestModel.select(): + if memory.title == title: + content = memory.content + + if random.random() < 0.5: + type = "要求原文能够较为全面的回答问题" + else: + type = "要求提取简短的内容" + + prompt = f""" +目标文段： +{content} + +你现在需要从目标文段中找出合适的信息来回答问题：{question} +请务必从目标文段中提取相关信息的**原文**并输出，{type} +如果没有原文能够回答问题，输出"无有效信息"即可，不要输出其他内容： +""" + + if global_config.debug.show_prompt: + logger.info(f"记忆仓库获取答案 prompt: {prompt}") + else: + logger.debug(f"记忆仓库获取答案 prompt: {prompt}") + + answer, (reasoning_content, model_name, tool_calls) = await self.LLMRequest.generate_response_async(prompt) + + if "无有效" in answer or "无有效信息" in answer or "无信息" in answer: + logger.info(f"没有能够回答{question}的记忆") + return "" + + logger.info(f"记忆仓库对问题 “{question}” 获取答案: {answer}") + + # 将问题和答案存到fetched_memory_list + if chat_id and answer: + self.fetched_memory_list.append((chat_id, (question, answer, time.time()))) + + # 清理fetched_memory_list + self._cleanup_fetched_memory_list() + + return answer + + def get_chat_memories_as_string(self, chat_id: str) -> str: + """ + 获取某个chat_id的所有记忆，并构建成字符串 + + Args: + chat_id: 聊天ID + + Returns: + str: 格式化的记忆字符串，格式：问题：xxx,答案:xxxxx\n问题：xxx,答案:xxxxx\n... + """ + try: + memories = [] + + # 从fetched_memory_list中获取该chat_id的所有记忆 + for cid, (question, answer, timestamp) in self.fetched_memory_list: + if cid == chat_id: + memories.append(f"问题：{question},答案:{answer}") + + # 按时间戳排序（最新的在后面） + memories.sort() + + # 用换行符连接所有记忆 + result = "\n".join(memories) + + # logger.info(f"chat_id {chat_id} 共有 {len(memories)} 条记忆") + return result + + except Exception as e: + logger.error(f"获取chat_id {chat_id} 的记忆时出错: {e}") + return "" + + + async def select_title_by_question(self, question: str) -> str: + """ + 根据消息内容选择最匹配的标题 + + Args: + question: 问题 + + Returns: + str: 选择的标题 + """ + # 获取所有标题并构建格式化字符串（排除锁定的记忆） + titles = get_all_titles(exclude_locked=True) + formatted_titles = "" + for title in titles: + formatted_titles += f"{title}\n" + + prompt = f""" +所有主题： +{formatted_titles} + +请根据以下问题，选择一个能够回答问题的主题： +问题：{question} +请你输出主题，不要输出其他内容，完整输出主题名： +""" + + if global_config.debug.show_prompt: + logger.info(f"记忆仓库选择标题 prompt: {prompt}") + else: + logger.debug(f"记忆仓库选择标题 prompt: {prompt}") + + + title, (reasoning_content, model_name, tool_calls) = await self.LLMRequest.generate_response_async(prompt) + + # 根据 title 获取 titles 里的对应项 + selected_title = None + + # 使用模糊查找匹配标题 + best_match = find_best_matching_memory(title, similarity_threshold=0.8) + if best_match: + selected_title = best_match[0] # 获取匹配的标题 + logger.info(f"记忆仓库选择标题: {selected_title} (相似度: {best_match[2]:.3f})") + else: + logger.warning(f"未找到相似度 >= 0.7 的标题匹配: {title}") + selected_title = None + + return selected_title + + def _cleanup_fetched_memory_list(self): + """ + 清理fetched_memory_list，移除超过10分钟的记忆和超过10条的最旧记忆 + """ + try: + current_time = time.time() + ten_minutes_ago = current_time - 600 # 10分钟 = 600秒 + + # 移除超过10分钟的记忆 + self.fetched_memory_list = [ + (chat_id, (question, answer, timestamp)) + for chat_id, (question, answer, timestamp) in self.fetched_memory_list + if timestamp > ten_minutes_ago + ] + + # 如果记忆条数超过10条，移除最旧的5条 + if len(self.fetched_memory_list) > 10: + # 按时间戳排序，移除最旧的5条 + self.fetched_memory_list.sort(key=lambda x: x[1][2]) # 按timestamp排序 + self.fetched_memory_list = self.fetched_memory_list[5:] # 保留最新的5条 + + logger.debug(f"fetched_memory_list清理后，当前有 {len(self.fetched_memory_list)} 条记忆") + + except Exception as e: + logger.error(f"清理fetched_memory_list时出错: {e}") + + async def _save_to_database_and_clear(self, chat_id: str, content: str): + """ + 生成标题，保存到数据库，并清空对应chat_id的running_content + + Args: + chat_id: 聊天ID + content: 要保存的内容 + """ + try: + # 生成标题 + title = "" + title_prompt = f""" +请为以下内容生成一个描述全面的标题，要求描述内容的主要概念和事件： +{content} + +标题不要分点，不要换行，不要输出其他内容 +请只输出标题，不要输出其他内容： +""" + + if global_config.debug.show_prompt: + logger.info(f"记忆仓库生成标题 prompt: {title_prompt}") + else: + logger.debug(f"记忆仓库生成标题 prompt: {title_prompt}") + + title, (reasoning_content, model_name, tool_calls) = await self.LLMRequest_build.generate_response_async(title_prompt) + + + await asyncio.sleep(0.5) + + if title: + # 保存到数据库 + MemoryChestModel.create( + title=title.strip(), + content=content, + chat_id=chat_id + ) + logger.info(f"已保存记忆仓库内容，标题: {title.strip()}, chat_id: {chat_id}") + + # 清空内容并刷新时间戳，但保留条目用于增量计算 + if chat_id in self.running_content_list: + current_time = time.time() + self.running_content_list[chat_id] = { + "content": "", + "last_update_time": current_time, + "create_time": current_time + } + logger.info(f"已保存并刷新chat_id {chat_id} 的时间戳，准备下一次增量构建") + else: + logger.warning(f"生成标题失败，chat_id: {chat_id}") + + except Exception as e: + logger.error(f"保存记忆仓库内容时出错: {e}") + + async def choose_merge_target(self, memory_title: str, chat_id: str = None) -> list[str]: + """ + 选择与给定记忆标题相关的记忆目标 + + Args: + memory_title: 要匹配的记忆标题 + chat_id: 聊天ID，用于加权抽样 + + Returns: + list[str]: 选中的记忆内容列表 + """ + try: + # 如果提供了chat_id，使用加权抽样 + all_titles = get_memory_titles_by_chat_id_weighted(chat_id) + # 剔除掉输入的 memory_title 本身 + all_titles = [title for title in all_titles if title and title.strip() != (memory_title or "").strip()] + + content = "" + display_index = 1 + for title in all_titles: + content += f"{display_index}. {title}\n" + display_index += 1 + + prompt = f""" +所有记忆列表 +{content} + +请根据以上记忆列表，选择一个与"{memory_title}"相关的记忆，用json输出： +如果没有相关记忆，输出: +{{ + "selected_title": "" +}} +可以选择多个相关的记忆，但最多不超过5个 +例如： +{{ + "selected_title": "选择的相关记忆标题" +}}, +{{ + "selected_title": "选择的相关记忆标题" +}}, +{{ + "selected_title": "选择的相关记忆标题" +}} +... +注意：请返回原始标题本身作为 selected_title，不要包含前面的序号或多余字符。 +请输出JSON格式，不要输出其他内容： +""" + + # logger.info(f"选择合并目标 prompt: {prompt}") + + if global_config.debug.show_prompt: + logger.info(f"选择合并目标 prompt: {prompt}") + else: + logger.debug(f"选择合并目标 prompt: {prompt}") + + merge_target_response, (reasoning_content, model_name, tool_calls) = await self.LLMRequest_build.generate_response_async(prompt) + + # 解析JSON响应 + selected_titles = self._parse_merge_target_json(merge_target_response) + + # 根据标题查找对应的内容 + selected_contents = self._get_memories_by_titles(selected_titles) + + logger.info(f"选择合并目标结果: {len(selected_contents)} 条记忆:{selected_titles}") + return selected_titles,selected_contents + + except Exception as e: + logger.error(f"选择合并目标时出错: {e}") + return [] + + def _get_memories_by_titles(self, titles: list[str]) -> list[str]: + """ + 根据标题列表查找对应的记忆内容 + + Args: + titles: 记忆标题列表 + + Returns: + list[str]: 记忆内容列表 + """ + try: + contents = [] + for title in titles: + if not title or not title.strip(): + continue + + # 使用模糊查找匹配记忆 + try: + best_match = find_best_matching_memory(title.strip(), similarity_threshold=0.8) + if best_match: + # 检查记忆是否被锁定 + memory_title = best_match[0] + memory_content = best_match[1] + + # 查询数据库中的锁定状态 + for memory in MemoryChestModel.select(): + if memory.title == memory_title and memory.locked: + logger.warning(f"记忆 '{memory_title}' 已锁定，跳过合并") + continue + + contents.append(memory_content) + logger.debug(f"找到记忆: {memory_title} (相似度: {best_match[2]:.3f})") + else: + logger.warning(f"未找到相似度 >= 0.8 的标题匹配: '{title}'") + except Exception as e: + logger.error(f"查找标题 '{title}' 的记忆时出错: {e}") + continue + + # logger.info(f"成功找到 {len(contents)} 条记忆内容") + return contents + + except Exception as e: + logger.error(f"根据标题查找记忆时出错: {e}") + return [] + + def _parse_merged_parts(self, merged_response: str) -> tuple[str, str]: + """ + 解析合并记忆的part1和part2内容 + + Args: + merged_response: LLM返回的合并记忆响应 + + Returns: + tuple[str, str]: (part1_content, part2_content) + """ + try: + # 使用正则表达式提取part1和part2内容 + import re + + # 提取part1内容 + part1_pattern = r'(.*?)' + part1_match = re.search(part1_pattern, merged_response, re.DOTALL) + part1_content = part1_match.group(1).strip() if part1_match else "" + + # 提取part2内容 + part2_pattern = r'(.*?)' + part2_match = re.search(part2_pattern, merged_response, re.DOTALL) + part2_content = part2_match.group(1).strip() if part2_match else "" + + # 检查是否包含none或None（不区分大小写） + def is_none_content(content: str) -> bool: + if not content: + return True + # 检查是否只包含"none"或"None"（不区分大小写） + return re.match(r'^\s*none\s*$', content, re.IGNORECASE) is not None + + # 如果包含none，则设置为空字符串 + if is_none_content(part1_content): + part1_content = "" + logger.info("part1内容为none，设置为空") + + if is_none_content(part2_content): + part2_content = "" + logger.info("part2内容为none，设置为空") + + return part1_content, part2_content + + except Exception as e: + logger.error(f"解析合并记忆part1/part2时出错: {e}") + return "", "" + + def _parse_merge_target_json(self, json_text: str) -> list[str]: + """ + 解析choose_merge_target生成的JSON响应 + + Args: + json_text: LLM返回的JSON文本 + + Returns: + list[str]: 解析出的记忆标题列表 + """ + try: + # 清理JSON文本，移除可能的额外内容 + repaired_content = repair_json(json_text) + + # 尝试直接解析JSON + try: + parsed_data = json.loads(repaired_content) + if isinstance(parsed_data, list): + # 如果是列表，提取selected_title字段 + titles = [] + for item in parsed_data: + if isinstance(item, dict) and "selected_title" in item: + value = item.get("selected_title", "") + if isinstance(value, str) and value.strip(): + titles.append(value) + return titles + elif isinstance(parsed_data, dict) and "selected_title" in parsed_data: + # 如果是单个对象 + value = parsed_data.get("selected_title", "") + if isinstance(value, str) and value.strip(): + return [value] + else: + # 空字符串表示没有相关记忆 + return [] + except json.JSONDecodeError: + pass + + # 如果直接解析失败，尝试提取JSON对象 + # 查找所有包含selected_title的JSON对象 + pattern = r'\{[^}]*"selected_title"[^}]*\}' + matches = re.findall(pattern, repaired_content) + + titles = [] + for match in matches: + try: + obj = json.loads(match) + if "selected_title" in obj: + value = obj.get("selected_title", "") + if isinstance(value, str) and value.strip(): + titles.append(value) + except json.JSONDecodeError: + continue + + if titles: + return titles + + logger.warning(f"无法解析JSON响应: {json_text[:200]}...") + return [] + + except Exception as e: + logger.error(f"解析合并目标JSON时出错: {e}") + return [] + + async def merge_memory(self,memory_list: list[str], chat_id: str = None) -> tuple[str, str]: + """ + 合并记忆 + """ + try: + content = "" + for memory in memory_list: + content += f"{memory}\n" + + prompt = f""" +以下是多段记忆内容，请将它们进行整合和修改： +{content} +-------------------------------- +请将上面的多段记忆内容，合并成两部分内容，第一部分是可以整合，不冲突的概念和知识，第二部分是相互有冲突的概念和知识 +请主要关注概念和知识，而不是聊天的琐事 +重要！！你要关注的概念和知识必须是较为不常见的信息，或者时效性较强的信息！！ +不要！！关注常见的只是，或者已经过时的信息！！ +1.不要关注诸如某个用户做了什么，说了什么，不要关注某个用户的行为，而是关注其中的概念性信息 +2.概念要求精确，不啰嗦，像科普读物或教育课本那样 +3.如果有图片，请只关注图片和文本结合的知识和概念性内容 +4.记忆为一段纯文本，逻辑清晰，指出概念的含义，并说明关系 +**第一部分** +1.如果两个概念在描述同一件事情，且相互之间逻辑不冲突（请你严格判断），且相互之间没有矛盾，请将它们整合成一个概念，并输出到第一部分 +2.如果某个概念在时间上更新了另一个概念，请用新概念更新就概念来整合，并输出到第一部分 +3.如果没有可整合的概念，请你输出none +**第二部分** +1.如果记忆中有无法整合的地方，例如概念不一致，有逻辑上的冲突，请你输出到第二部分 +2.如果两个概念在描述同一件事情，但相互之间逻辑冲突，请将它们输出到第二部分 +3.如果没有无法整合的概念，请你输出none + +**输出格式要求** +请你按以下格式输出： + +第一部分内容，整合后的概念，如果第一部分为none，请输出none + + +第二部分内容，无法整合，冲突的概念，如果第二部分为none，请输出none + +不要输出其他内容，现在请你输出,不要输出其他内容，注意一定要直白，白话，口语化不要浮夸，修辞。： +""" + + if global_config.debug.show_prompt: + logger.info(f"合并记忆 prompt: {prompt}") + else: + logger.debug(f"合并记忆 prompt: {prompt}") + + merged_memory, (reasoning_content, model_name, tool_calls) = await self.LLMRequest_build.generate_response_async(prompt) + + # 解析part1和part2 + part1_content, part2_content = self._parse_merged_parts(merged_memory) + + # 处理part2：独立记录冲突内容（无论part1是否为空） + if part2_content and part2_content.strip() != "none": + logger.info(f"合并记忆part2记录冲突内容: {len(part2_content)} 字符") + # 记录冲突到数据库 + await global_conflict_tracker.record_memory_merge_conflict(part2_content,chat_id) + + # 处理part1：生成标题并保存 + if part1_content and part1_content.strip() != "none": + merged_title = await self._generate_title_for_merged_memory(part1_content) + + # 保存part1到数据库 + MemoryChestModel.create( + title=merged_title, + content=part1_content, + chat_id=chat_id + ) + + logger.info(f"合并记忆part1已保存: {merged_title}") + + return merged_title, part1_content + else: + logger.warning("合并记忆part1为空，跳过保存") + return "", "" + except Exception as e: + logger.error(f"合并记忆时出错: {e}") + return "", "" + + async def _generate_title_for_merged_memory(self, merged_content: str) -> str: + """ + 为合并后的记忆生成标题 + + Args: + merged_content: 合并后的记忆内容 + + Returns: + str: 生成的标题 + """ + try: + prompt = f""" +请为以下内容生成一个描述全面的标题，要求描述内容的主要概念和事件： +例如： + +标题：达尔文的自然选择理论 +内容：达尔文的自然选择是生物进化理论的重要组成部分，它解释了生物进化过程中的自然选择机制。 + + +标题：麦麦的禁言插件和支持版本 +内容： +麦麦的禁言插件是一款能够实现禁言的插件 +麦麦的禁言插件可能不支持0.10.2 +MutePlugin 是禁言插件的名称 + + + +需要对以下内容生成标题： +{merged_content} + + +标题不要分点，不要换行，不要输出其他内容，不要浮夸，以白话简洁的风格输出标题 +请只输出标题，不要输出其他内容： +""" + + if global_config.debug.show_prompt: + logger.info(f"生成合并记忆标题 prompt: {prompt}") + else: + logger.debug(f"生成合并记忆标题 prompt: {prompt}") + + title_response, (reasoning_content, model_name, tool_calls) = await self.LLMRequest.generate_response_async(prompt) + + # 清理标题，移除可能的引号或多余字符 + title = title_response.strip().strip('"').strip("'").strip() + + if title: + # 检查是否存在相似标题 + if check_title_exists_fuzzy(title, similarity_threshold=0.9): + logger.warning(f"生成的标题 '{title}' 与现有标题相似，使用时间戳后缀") + title = f"{title}_{int(time.time())}" + + logger.info(f"生成合并记忆标题: {title}") + return title + else: + logger.warning("生成合并记忆标题失败，使用默认标题") + return f"合并记忆_{int(time.time())}" + + except Exception as e: + logger.error(f"生成合并记忆标题时出错: {e}") + return f"合并记忆_{int(time.time())}" + + +global_memory_chest = MemoryChest() \ No newline at end of file diff --git a/src/memory_system/memory_management_task.py b/src/memory_system/memory_management_task.py new file mode 100644 index 00000000..4d89658d --- /dev/null +++ b/src/memory_system/memory_management_task.py @@ -0,0 +1,167 @@ +# -*- coding: utf-8 -*- +import asyncio +import random +from typing import List + +from src.manager.async_task_manager import AsyncTask +from src.memory_system.Memory_chest import global_memory_chest +from src.common.logger import get_logger +from src.common.database.database_model import MemoryChest as MemoryChestModel +from src.config.config import global_config +from src.memory_system.memory_utils import get_all_titles + +logger = get_logger("memory") + + +class MemoryManagementTask(AsyncTask): + """记忆管理定时任务 + + 根据Memory_chest中的记忆数量与MAX_MEMORY_NUMBER的比例来决定执行频率： + - 小于50%：每600秒执行一次 + - 大于等于50%：每300秒执行一次 + + 每次执行时随机选择一个title，执行choose_merge_target和merge_memory， + 然后删除原始记忆 + """ + + def __init__(self): + super().__init__( + task_name="Memory Management Task", + wait_before_start=10, # 启动后等待10秒再开始 + run_interval=300 # 默认300秒间隔，会根据记忆数量动态调整 + ) + self.max_memory_number = global_config.memory.max_memory_number + + async def start_task(self, abort_flag: asyncio.Event): + """重写start_task方法，支持动态调整执行间隔""" + if self.wait_before_start > 0: + # 等待指定时间后开始任务 + await asyncio.sleep(self.wait_before_start) + + while not abort_flag.is_set(): + await self.run() + + # 动态调整执行间隔 + current_interval = self._calculate_interval() + logger.info(f"[记忆管理] 下次执行间隔: {current_interval}秒") + + if current_interval > 0: + await asyncio.sleep(current_interval) + else: + break + + def _calculate_interval(self) -> int: + """根据当前记忆数量计算执行间隔""" + try: + current_count = self._get_memory_count() + percentage = current_count / self.max_memory_number + + if percentage < 0.5: + # 小于50%，每600秒执行一次 + return 3600 + elif percentage < 0.7: + # 大于等于50%，每300秒执行一次 + return 1800 + elif percentage < 0.9: + # 大于等于70%，每120秒执行一次 + return 300 + elif percentage < 1.2: + return 30 + else: + return 10 + + except Exception as e: + logger.error(f"[记忆管理] 计算执行间隔时出错: {e}") + return 300 # 默认300秒 + + def _get_memory_count(self) -> int: + """获取当前记忆数量""" + try: + count = MemoryChestModel.select().count() + logger.debug(f"[记忆管理] 当前记忆数量: {count}") + return count + except Exception as e: + logger.error(f"[记忆管理] 获取记忆数量时出错: {e}") + return 0 + + async def run(self): + """执行记忆管理任务""" + try: + + # 获取当前记忆数量 + current_count = self._get_memory_count() + percentage = current_count / self.max_memory_number + logger.info(f"当前记忆数量: {current_count}/{self.max_memory_number} ({percentage:.1%})") + + # 如果记忆数量为0，跳过执行 + if current_count < 10: + return + + # 随机选择一个记忆标题和chat_id + selected_title, selected_chat_id = self._get_random_memory_title() + if not selected_title: + logger.warning("无法获取随机记忆标题，跳过执行") + return + + # 执行choose_merge_target获取相关记忆（标题与内容） + related_titles, related_contents = await global_memory_chest.choose_merge_target(selected_title, selected_chat_id) + if not related_titles or not related_contents: + logger.info("无合适合并内容，跳过本次合并") + return + + logger.info(f"为 [{selected_title}] 找到 {len(related_contents)} 条相关记忆:{related_titles}") + + # 执行merge_memory合并记忆 + merged_title, merged_content = await global_memory_chest.merge_memory(related_contents,selected_chat_id) + if not merged_title or not merged_content: + logger.warning("[记忆管理] 记忆合并失败，跳过删除") + return + + logger.info(f"记忆合并成功，新标题: {merged_title}") + + # 删除原始记忆（包括选中的标题和相关的记忆标题） + titles_to_delete = [selected_title] + related_titles + deleted_count = self._delete_original_memories(titles_to_delete) + logger.info(f"已删除 {deleted_count} 条原始记忆") + + except Exception as e: + logger.error(f"[记忆管理] 执行记忆管理任务时发生错误: {e}", exc_info=True) + + def _get_random_memory_title(self) -> tuple[str, str]: + """随机获取一个记忆标题和对应的chat_id""" + try: + # 获取所有记忆记录 + all_memories = MemoryChestModel.select() + if not all_memories: + return "", "" + + # 随机选择一个记忆 + selected_memory = random.choice(list(all_memories)) + return selected_memory.title, selected_memory.chat_id or "" + + except Exception as e: + logger.error(f"[记忆管理] 获取随机记忆标题时发生错误: {e}") + return "", "" + + def _delete_original_memories(self, related_titles: List[str]) -> int: + """按标题删除原始记忆""" + try: + deleted_count = 0 + # 删除相关记忆（通过标题匹配） + for title in related_titles: + try: + # 通过标题查找并删除对应的记忆 + memories_to_delete = MemoryChestModel.select().where(MemoryChestModel.title == title) + for memory in memories_to_delete: + MemoryChestModel.delete().where(MemoryChestModel.id == memory.id).execute() + deleted_count += 1 + logger.debug(f"[记忆管理] 删除相关记忆: {memory.title}") + except Exception as e: + logger.error(f"[记忆管理] 删除相关记忆时出错: {e}") + continue + + return deleted_count + + except Exception as e: + logger.error(f"[记忆管理] 删除原始记忆时发生错误: {e}") + return 0 diff --git a/src/memory_system/memory_utils.py b/src/memory_system/memory_utils.py new file mode 100644 index 00000000..bdf8c2d3 --- /dev/null +++ b/src/memory_system/memory_utils.py @@ -0,0 +1,306 @@ +# -*- coding: utf-8 -*- +""" +记忆系统工具函数 +包含模糊查找、相似度计算等工具函数 +""" +import json +import re +from difflib import SequenceMatcher +from typing import List, Tuple, Optional + +from src.common.database.database_model import MemoryChest as MemoryChestModel +from src.common.logger import get_logger +from json_repair import repair_json + + +logger = get_logger("memory_utils") + +def get_all_titles(exclude_locked: bool = False) -> list[str]: + """ + 获取记忆仓库中的所有标题 + + Args: + exclude_locked: 是否排除锁定的记忆，默认为 False + + Returns: + list: 包含所有标题的列表 + """ + try: + # 查询所有记忆记录的标题 + titles = [] + for memory in MemoryChestModel.select(): + if memory.title: + # 如果 exclude_locked 为 True 且记忆已锁定，则跳过 + if exclude_locked and memory.locked: + continue + titles.append(memory.title) + return titles + except Exception as e: + print(f"获取记忆标题时出错: {e}") + return [] + +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: + """ + 计算两个文本的相似度 + + Args: + text1: 第一个文本 + text2: 第二个文本 + + Returns: + float: 相似度分数 (0-1) + """ + try: + # 预处理文本 + text1 = preprocess_text(text1) + text2 = preprocess_text(text2) + + # 使用SequenceMatcher计算相似度 + similarity = SequenceMatcher(None, text1, text2).ratio() + + # 如果其中一个文本包含另一个，提高相似度 + if text1 in text2 or text2 in text1: + similarity = max(similarity, 0.8) + + return similarity + + 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 + + +def fuzzy_find_memory_by_title(target_title: str, similarity_threshold: float = 0.9) -> List[Tuple[str, str, float]]: + """ + 根据标题模糊查找记忆 + + Args: + target_title: 目标标题 + similarity_threshold: 相似度阈值，默认0.9 + + Returns: + List[Tuple[str, str, float]]: 匹配的记忆列表，每个元素为(title, content, similarity_score) + """ + try: + # 获取所有记忆 + all_memories = MemoryChestModel.select() + + matches = [] + for memory in all_memories: + similarity = calculate_similarity(target_title, memory.title) + if similarity >= similarity_threshold: + matches.append((memory.title, memory.content, similarity)) + + # 按相似度降序排序 + matches.sort(key=lambda x: x[2], reverse=True) + + # logger.info(f"模糊查找标题 '{target_title}' 找到 {len(matches)} 个匹配项") + return matches + + except Exception as e: + logger.error(f"模糊查找记忆时出错: {e}") + return [] + + +def find_best_matching_memory(target_title: str, similarity_threshold: float = 0.9) -> Optional[Tuple[str, str, float]]: + """ + 查找最佳匹配的记忆 + + Args: + target_title: 目标标题 + similarity_threshold: 相似度阈值 + + Returns: + Optional[Tuple[str, str, float]]: 最佳匹配的记忆(title, content, similarity)或None + """ + try: + matches = fuzzy_find_memory_by_title(target_title, similarity_threshold) + + if matches: + best_match = matches[0] # 已经按相似度排序，第一个是最佳匹配 + # logger.info(f"找到最佳匹配: '{best_match[0]}' (相似度: {best_match[2]:.3f})") + return best_match + else: + logger.info(f"未找到相似度 >= {similarity_threshold} 的记忆") + return None + + except Exception as e: + logger.error(f"查找最佳匹配记忆时出错: {e}") + return None + + +def check_title_exists_fuzzy(target_title: str, similarity_threshold: float = 0.9) -> bool: + """ + 检查标题是否已存在（模糊匹配） + + Args: + target_title: 目标标题 + similarity_threshold: 相似度阈值，默认0.9（较高阈值避免误判） + + Returns: + bool: 是否存在相似标题 + """ + try: + matches = fuzzy_find_memory_by_title(target_title, similarity_threshold) + exists = len(matches) > 0 + + if exists: + logger.info(f"发现相似标题: '{matches[0][0]}' (相似度: {matches[0][2]:.3f})") + else: + logger.debug("未发现相似标题") + + return exists + + except Exception as e: + logger.error(f"检查标题是否存在时出错: {e}") + return False + + +def get_memories_by_chat_id_weighted(target_chat_id: str, same_chat_weight: float = 0.95, other_chat_weight: float = 0.05) -> List[Tuple[str, str, str]]: + """ + 根据chat_id进行加权抽样获取记忆列表 + + Args: + target_chat_id: 目标聊天ID + same_chat_weight: 同chat_id记忆的权重，默认0.95（95%概率） + other_chat_weight: 其他chat_id记忆的权重，默认0.05（5%概率） + + Returns: + List[Tuple[str, str, str]]: 选中的记忆列表，每个元素为(title, content, chat_id) + """ + try: + # 获取所有记忆 + all_memories = MemoryChestModel.select() + + # 按chat_id分组 + same_chat_memories = [] + other_chat_memories = [] + + for memory in all_memories: + if memory.title and not memory.locked: # 排除锁定的记忆 + if memory.chat_id == target_chat_id: + same_chat_memories.append((memory.title, memory.content, memory.chat_id)) + else: + other_chat_memories.append((memory.title, memory.content, memory.chat_id)) + + # 如果没有同chat_id的记忆，返回空列表 + if not same_chat_memories: + logger.warning(f"未找到chat_id为 '{target_chat_id}' 的记忆") + return [] + + # 计算抽样数量 + total_same = len(same_chat_memories) + total_other = len(other_chat_memories) + + # 根据权重计算抽样数量 + if total_other > 0: + # 计算其他chat_id记忆的抽样数量（至少1个，最多不超过总数的10%） + other_sample_count = max(1, min(total_other, int(total_same * other_chat_weight / same_chat_weight))) + else: + other_sample_count = 0 + + # 随机抽样 + selected_memories = [] + + # 选择同chat_id的记忆（全部选择，因为权重很高） + selected_memories.extend(same_chat_memories) + + # 随机选择其他chat_id的记忆 + if other_sample_count > 0 and total_other > 0: + import random + other_selected = random.sample(other_chat_memories, min(other_sample_count, total_other)) + selected_memories.extend(other_selected) + + logger.info(f"加权抽样结果: 同chat_id记忆 {len(same_chat_memories)} 条，其他chat_id记忆 {min(other_sample_count, total_other)} 条") + + return selected_memories + + except Exception as e: + logger.error(f"按chat_id加权抽样记忆时出错: {e}") + return [] + + +def get_memory_titles_by_chat_id_weighted(target_chat_id: str, same_chat_weight: float = 0.95, other_chat_weight: float = 0.05) -> List[str]: + """ + 根据chat_id进行加权抽样获取记忆标题列表（用于合并选择） + + Args: + target_chat_id: 目标聊天ID + same_chat_weight: 同chat_id记忆的权重，默认0.95（95%概率） + other_chat_weight: 其他chat_id记忆的权重，默认0.05（5%概率） + + Returns: + List[str]: 选中的记忆标题列表 + """ + try: + memories = get_memories_by_chat_id_weighted(target_chat_id, same_chat_weight, other_chat_weight) + titles = [memory[0] for memory in memories] # 提取标题 + return titles + + except Exception as e: + logger.error(f"按chat_id加权抽样记忆标题时出错: {e}") + return [] \ No newline at end of file diff --git a/src/memory_system/question_maker.py b/src/memory_system/question_maker.py new file mode 100644 index 00000000..316afee5 --- /dev/null +++ b/src/memory_system/question_maker.py @@ -0,0 +1,97 @@ +import time +import random +from typing import List, Optional, Tuple +from src.chat.utils.chat_message_builder import get_raw_msg_before_timestamp_with_chat, build_readable_messages +from src.common.database.database_model import MemoryConflict +from src.config.config import global_config + + +class QuestionMaker: + def __init__(self, chat_id: str, context: str = "") -> None: + """问题生成器。 + + - chat_id: 会话 ID，用于筛选该会话下的冲突记录。 + - context: 额外上下文，可用于后续扩展。 + + 用法示例： + >>> qm = QuestionMaker(chat_id="some_chat") + >>> question, chat_ctx, conflict_ctx = await qm.make_question() + """ + self.chat_id = chat_id + self.context = context + + def get_context(self, timestamp: float = time.time()) -> str: + """获取指定时间点之前的对话上下文字符串。""" + latest_30_msgs = get_raw_msg_before_timestamp_with_chat( + chat_id=self.chat_id, + timestamp=timestamp, + limit=30, + ) + + all_dialogue_prompt_str = build_readable_messages( + latest_30_msgs, + replace_bot_name=True, + timestamp_mode="normal_no_YMD", + ) + return all_dialogue_prompt_str + + + async def get_all_conflicts(self) -> List[MemoryConflict]: + """获取当前会话下的所有记忆冲突记录。""" + conflicts: List[MemoryConflict] = list(MemoryConflict.select().where(MemoryConflict.chat_id == self.chat_id)) + return conflicts + + async def get_un_answered_conflict(self) -> List[MemoryConflict]: + """获取未回答的记忆冲突记录（answer 为空）。""" + conflicts = await self.get_all_conflicts() + return [conflict for conflict in conflicts if not conflict.answer] + + async def get_random_unanswered_conflict(self) -> Optional[MemoryConflict]: + """按权重随机选取一个未回答的冲突并自增 raise_time。 + + 选择规则： + - 若存在 `raise_time == 0` 的项：按权重抽样（0 次权重 1.0，≥1 次权重 0.05）。 + - 若不存在 `raise_time == 0` 的项：仅 5% 概率返回其中任意一条，否则返回 None。 + - 每次成功选中后，将该条目的 `raise_time` 自增 1 并保存。 + """ + conflicts = await self.get_un_answered_conflict() + if not conflicts: + return None + + # 如果没有 raise_time==0 的项，则仅有 5% 概率抽样一个 + conflicts_with_zero = [c for c in conflicts if (getattr(c, "raise_time", 0) or 0) == 0] + if conflicts_with_zero: + # 权重规则：raise_time == 0 -> 1.0；raise_time >= 1 -> 0.01 + weights = [] + for conflict in conflicts: + current_raise_time = getattr(conflict, "raise_time", 0) or 0 + weight = 1.0 if current_raise_time == 0 else 0.01 + weights.append(weight) + + # 按权重随机选择 + chosen_conflict = random.choices(conflicts, weights=weights, k=1)[0] + + # 选中后，自增 raise_time 并保存 + chosen_conflict.raise_time = (getattr(chosen_conflict, "raise_time", 0) or 0) + 1 + chosen_conflict.save() + + + return chosen_conflict + + async def make_question(self) -> Tuple[Optional[str], Optional[str], Optional[str]]: + """生成一条用于询问用户的冲突问题与上下文。 + + 返回三元组 (question, chat_context, conflict_context)： + - question: 冲突文本；若本次未选中任何冲突则为 None。 + - chat_context: 该冲突创建时间点前的会话上下文字符串；若无则为 None。 + - conflict_context: 冲突在 DB 中存储的上下文；若无则为 None。 + """ + conflict = await self.get_random_unanswered_conflict() + if not conflict: + return None, None, None + question = conflict.conflict_content + conflict_context = conflict.context + create_time = conflict.create_time + chat_context = self.get_context(create_time) + + return question, chat_context, conflict_context \ No newline at end of file diff --git a/src/memory_system/questions.py b/src/memory_system/questions.py new file mode 100644 index 00000000..3816213c --- /dev/null +++ b/src/memory_system/questions.py @@ -0,0 +1,478 @@ +import time +import asyncio +from src.common.logger import get_logger +from src.common.database.database_model import MemoryConflict +from src.chat.utils.chat_message_builder import ( + get_raw_msg_by_timestamp_with_chat, + build_readable_messages, +) +from src.llm_models.utils_model import LLMRequest +from src.config.config import model_config, global_config +from typing import List +from src.memory_system.memory_utils import parse_md_json + +logger = get_logger("conflict_tracker") + +class QuestionTracker: + """ + 用于跟踪一个问题在后续聊天中的解答情况 + """ + + def __init__(self, question: str, chat_id: str, context: str = "") -> None: + self.question = question + self.chat_id = chat_id + now = time.time() + self.context = context + self.start_time = now + self.last_read_time = now + self.last_judge_time = now # 上次判定的时间 + self.judge_debounce_interval = 10.0 # 判定防抖间隔：10秒 + self.consecutive_end_count = 0 # 连续END计数 + self.active = True + # 将 LLM 实例作为类属性，使用 utils 模型 + self.llm_request = LLMRequest(model_set=model_config.model_task_config.utils, request_type="conflict.judge") + + def stop(self) -> None: + self.active = False + + def should_judge_now(self) -> bool: + """ + 检查是否应该进行判定（防抖检查） + + Returns: + bool: 是否可以判定 + """ + now = time.time() + # 检查是否已经过了10秒的防抖间隔 + return (now - self.last_judge_time) >= self.judge_debounce_interval + + def __eq__(self, other) -> bool: + """比较两个追踪器是否相等（基于问题内容和聊天ID）""" + if not isinstance(other, QuestionTracker): + return False + return self.question == other.question and self.chat_id == other.chat_id + + def __hash__(self) -> int: + """为对象提供哈希值，支持集合操作""" + return hash((self.question, self.chat_id)) + + async def judge_answer(self, conversation_text: str,chat_len: int) -> tuple[bool, str, str]: + """ + 使用模型判定问题是否已得到解答。 + + Returns: + tuple[bool, str, str]: (是否结束跟踪, 结束原因或答案, 判定类型) + - True: 结束跟踪（已解答、话题转向等） + - False: 继续跟踪 + 判定类型: "ANSWERED", "END", "CONTINUE" + """ + + end_prompt = "" + if chat_len > 20: + end_prompt = "\n- 如果最新20条聊天记录内容与问题无关，话题已转向其他方向，请只输出：END" + + prompt = f"""你是一个严谨的判定器。下面给出聊天记录以及一个问题。 +任务：判断在这段聊天中，该问题是否已经得到明确解答。 +**你必须严格按照聊天记录的内容，不要添加额外的信息** + +输出规则： +- 如果聊天记录内容的信息已解答问题，请只输出：YES: <简短答案>{end_prompt} +- 如果问题尚未解答但聊天仍在相关话题上，请只输出：NO + +**问题** +{self.question} + + +**聊天记录** +{conversation_text} +""" + + if global_config.debug.show_prompt: + logger.info(f"判定提示词: {prompt}") + else: + logger.debug("已发送判定提示词") + + result_text, _ = await self.llm_request.generate_response_async(prompt, temperature=0.5) + + logger.info(f"判定结果: {prompt}\n{result_text}") + + # 更新上次判定时间 + self.last_judge_time = time.time() + + if not result_text: + return False, "", "CONTINUE" + + text = result_text.strip() + if text.upper().startswith("YES:"): + answer = text[4:].strip() + return True, answer, "ANSWERED" + if text.upper().startswith("YES"): + # 兼容仅输出 YES 或 YES + answer = text[3:].strip().lstrip(":").strip() + return True, answer, "ANSWERED" + if text.upper().startswith("END"): + # 聊天内容与问题无关，放弃该问题思考 + return True, "话题已转向其他方向，放弃该问题思考", "END" + return False, "", "CONTINUE" + +class ConflictTracker: + """ + 记忆整合冲突追踪器 + + 用于记录和存储记忆整合过程中的冲突内容 + """ + def __init__(self): + self.question_tracker_list:List[QuestionTracker] = [] + + self.LLMRequest_tracker = LLMRequest( + model_set=model_config.model_task_config.utils, + request_type="conflict_tracker", + ) + + def get_questions_by_chat_id(self, chat_id: str) -> List[QuestionTracker]: + return [tracker for tracker in self.question_tracker_list if tracker.chat_id == chat_id] + + async def track_conflict(self, question: str, context: str = "",start_following: bool = False,chat_id: str = "") -> bool: + """ + 跟踪冲突内容 + """ + tracker = QuestionTracker(question.strip(), chat_id, context) + self.question_tracker_list.append(tracker) + asyncio.create_task(self._follow_and_record(tracker, question.strip())) + return True + + async def record_conflict(self, conflict_content: str, context: str = "",start_following: bool = False,chat_id: str = "") -> bool: + """ + 记录冲突内容 + + Args:k + conflict_content: 冲突内容 + + Returns: + bool: 是否成功记录 + """ + try: + if not conflict_content or conflict_content.strip() == "": + return False + + # 若需要跟随后续消息以判断是否得到解答，则进入跟踪流程 + if start_following and chat_id: + tracker = QuestionTracker(conflict_content.strip(), chat_id, context) + self.question_tracker_list.append(tracker) + # 后台启动跟踪任务，避免阻塞 + asyncio.create_task(self._follow_and_record(tracker, conflict_content.strip())) + return True + + # 默认：直接记录，不进行跟踪 + MemoryConflict.create( + conflict_content=conflict_content, + create_time=time.time(), + update_time=time.time(), + answer="", + chat_id=chat_id, + ) + + logger.info(f"记录冲突内容: {len(conflict_content)} 字符") + return True + + except Exception as e: + logger.error(f"记录冲突内容时出错: {e}") + return False + + async def _follow_and_record(self, tracker: QuestionTracker, original_question: str) -> None: + """ + 后台任务：跟踪问题是否被解答，并写入数据库。 + """ + try: + max_duration = 10 * 60 # 30 分钟 + max_messages = 50 # 最多 100 条消息 + poll_interval = 2.0 # 秒 + logger.info(f"开始跟踪问题: {original_question}") + while tracker.active: + now_ts = time.time() + # 终止条件：时长达到上限 + if now_ts - tracker.start_time >= max_duration: + logger.info("问题跟踪达到10分钟上限，判定为未解答") + break + + # 统计最近一段是否有新消息（不过滤机器人，过滤命令） + recent_msgs = get_raw_msg_by_timestamp_with_chat( + chat_id=tracker.chat_id, + timestamp_start=tracker.last_read_time, + timestamp_end=now_ts, + limit=30, + limit_mode="latest", + filter_bot=False, + filter_command=True, + ) + + if len(recent_msgs) > 0: + tracker.last_read_time = now_ts + + # 统计从开始到现在的总消息数（用于触发100条上限） + all_msgs = get_raw_msg_by_timestamp_with_chat( + chat_id=tracker.chat_id, + timestamp_start=tracker.start_time, + timestamp_end=now_ts, + limit=0, + limit_mode="latest", + filter_bot=False, + filter_command=True, + ) + + # 检查是否应该进行判定（防抖检查） + if not tracker.should_judge_now(): + logger.debug(f"判定防抖中，跳过本次判定: {tracker.question}") + await asyncio.sleep(poll_interval) + continue + + # 构建可读聊天文本 + chat_text = build_readable_messages( + all_msgs, + replace_bot_name=True, + timestamp_mode="relative", + read_mark=0.0, + truncate=False, + show_actions=False, + show_pic=False, + remove_emoji_stickers=True, + ) + chat_len = len(all_msgs) + # 让小模型判断是否有答案 + answered, answer_text, judge_type = await tracker.judge_answer(chat_text,chat_len) + + if judge_type == "ANSWERED": + # 问题已解答，直接结束跟踪 + logger.info("问题已得到解答，结束跟踪并写入答案") + await self.add_or_update_conflict( + conflict_content=tracker.question, + create_time=tracker.start_time, + update_time=time.time(), + answer=answer_text or "", + chat_id=tracker.chat_id, + ) + return + elif judge_type == "END": + # 话题转向，增加END计数 + tracker.consecutive_end_count += 1 + logger.info(f"话题已转向，连续END次数: {tracker.consecutive_end_count}") + + if tracker.consecutive_end_count >= 2: + # 连续两次END，结束跟踪 + logger.info("连续两次END，结束跟踪") + break + else: + # 第一次END，重置计数器并继续跟踪 + logger.info("第一次END，继续跟踪") + continue + elif judge_type == "CONTINUE": + # 继续跟踪，重置END计数器 + tracker.consecutive_end_count = 0 + continue + + if len(all_msgs) >= max_messages: + logger.info("问题跟踪达到100条消息上限，判定为未解答") + logger.info(f"追踪结束：{tracker.question}") + break + + # 无新消息时稍作等待 + await asyncio.sleep(poll_interval) + + # 未获取到答案，检查是否需要删除记录 + # 查找现有的冲突记录 + existing_conflict = MemoryConflict.get_or_none( + MemoryConflict.conflict_content == original_question, + MemoryConflict.chat_id == tracker.chat_id + ) + + if existing_conflict: + # 检查raise_time是否大于3且没有答案 + current_raise_time = getattr(existing_conflict, "raise_time", 0) or 0 + if current_raise_time > 0 and not existing_conflict.answer: + # 删除该条目 + await self.delete_conflict(original_question, tracker.chat_id) + logger.info(f"追踪结束后删除条目(raise_time={current_raise_time}且无答案): {original_question}") + else: + # 更新记录但不删除 + await self.add_or_update_conflict( + conflict_content=original_question, + create_time=existing_conflict.create_time, + update_time=time.time(), + answer="", + chat_id=tracker.chat_id, + ) + logger.info(f"记录冲突内容(未解答): {len(original_question)} 字符") + else: + # 如果没有现有记录，创建新记录 + await self.add_or_update_conflict( + conflict_content=original_question, + create_time=time.time(), + update_time=time.time(), + answer="", + chat_id=tracker.chat_id, + ) + logger.info(f"记录冲突内容(未解答): {len(original_question)} 字符") + + logger.info(f"问题跟踪结束：{original_question}") + except Exception as e: + logger.error(f"后台问题跟踪任务异常: {e}") + finally: + # 无论任务成功还是失败，都要从追踪列表中移除 + tracker.stop() + self.remove_tracker(tracker) + + def remove_tracker(self, tracker: QuestionTracker) -> None: + """ + 从追踪列表中移除指定的追踪器 + + Args: + tracker: 要移除的追踪器对象 + """ + try: + if tracker in self.question_tracker_list: + self.question_tracker_list.remove(tracker) + logger.info(f"已从追踪列表中移除追踪器: {tracker.question}") + else: + logger.warning(f"尝试移除不存在的追踪器: {tracker.question}") + except Exception as e: + logger.error(f"移除追踪器时出错: {e}") + + async def add_or_update_conflict( + self, + conflict_content: str, + create_time: float, + update_time: float, + answer: str = "", + context: str = "", + chat_id: str = None + ) -> bool: + """ + 根据conflict_content匹配数据库内容，如果找到相同的就更新update_time和answer， + 如果没有相同的，就新建一条保存全部内容 + """ + try: + # 尝试根据conflict_content查找现有记录 + existing_conflict = MemoryConflict.get_or_none( + MemoryConflict.conflict_content == conflict_content, + MemoryConflict.chat_id == chat_id + ) + + if existing_conflict: + # 如果找到相同的conflict_content，更新update_time和answer + existing_conflict.update_time = update_time + existing_conflict.answer = answer + existing_conflict.save() + return True + else: + # 如果没有找到相同的，创建新记录 + MemoryConflict.create( + conflict_content=conflict_content, + create_time=create_time, + update_time=update_time, + answer=answer, + context=context, + chat_id=chat_id, + ) + return True + except Exception as e: + # 记录错误并返回False + logger.error(f"添加或更新冲突记录时出错: {e}") + return False + + async def record_memory_merge_conflict(self, part2_content: str, chat_id: str = None) -> bool: + """ + 记录记忆整合过程中的冲突内容（part2） + + Args: + part2_content: 冲突内容（part2） + + Returns: + bool: 是否成功记录 + """ + if not part2_content or part2_content.strip() == "": + return False + + prompt = f"""以下是一段有冲突的信息，请你根据这些信息总结出几个具体的提问: +冲突信息： +{part2_content} + +要求： +1.提问必须具体，明确 +2.提问最好涉及指向明确的事物，而不是代称 +3.如果缺少上下文，不要强行提问，可以忽略 + +请用json格式输出，不要输出其他内容，仅输出提问理由和具体提的提问: +**示例** +// 理由文本 +```json +{{ + "question":"提问", +}} +``` +```json +{{ + "question":"提问" +}} +``` +...提问数量在1-3个之间，不要重复，现在请输出：""" + + question_response, (reasoning_content, model_name, tool_calls) = await self.LLMRequest_tracker.generate_response_async(prompt) + + # 解析JSON响应 + questions, reasoning_content = parse_md_json(question_response) + + print(prompt) + print(question_response) + + for question in questions: + await self.record_conflict( + conflict_content=question["question"], + context=reasoning_content, + start_following=False, + chat_id=chat_id, + ) + return True + + async def get_conflict_count(self) -> int: + """ + 获取冲突记录数量 + + Returns: + int: 记录数量 + """ + try: + return MemoryConflict.select().count() + except Exception as e: + logger.error(f"获取冲突记录数量时出错: {e}") + return 0 + + async def delete_conflict(self, conflict_content: str, chat_id: str) -> bool: + """ + 删除指定的冲突记录 + + Args: + conflict_content: 冲突内容 + chat_id: 聊天ID + + Returns: + bool: 是否成功删除 + """ + try: + conflict = MemoryConflict.get_or_none( + MemoryConflict.conflict_content == conflict_content, + MemoryConflict.chat_id == chat_id + ) + + if conflict: + conflict.delete_instance() + logger.info(f"已删除冲突记录: {conflict_content}") + return True + else: + logger.warning(f"未找到要删除的冲突记录: {conflict_content}") + return False + except Exception as e: + logger.error(f"删除冲突记录时出错: {e}") + return False + +# 全局冲突追踪器实例 +global_conflict_tracker = ConflictTracker() \ No newline at end of file diff --git a/src/migrate_helper/migrate.py b/src/migrate_helper/migrate.py deleted file mode 100644 index 5a565cae..00000000 --- a/src/migrate_helper/migrate.py +++ /dev/null @@ -1,319 +0,0 @@ -import json -import os -import asyncio -from src.common.database.database_model import GraphNodes -from src.common.logger import get_logger - -logger = get_logger("migrate") - - -async def migrate_memory_items_to_string(): - """ - 将数据库中记忆节点的memory_items从list格式迁移到string格式 - 并根据原始list的项目数量设置weight值 - """ - logger.info("开始迁移记忆节点格式...") - - migration_stats = { - "total_nodes": 0, - "converted_nodes": 0, - "already_string_nodes": 0, - "empty_nodes": 0, - "error_nodes": 0, - "weight_updated_nodes": 0, - "truncated_nodes": 0, - } - - try: - # 获取所有图节点 - all_nodes = GraphNodes.select() - migration_stats["total_nodes"] = all_nodes.count() - - logger.info(f"找到 {migration_stats['total_nodes']} 个记忆节点") - - for node in all_nodes: - try: - concept = node.concept - memory_items_raw = node.memory_items.strip() if node.memory_items else "" - original_weight = node.weight if hasattr(node, "weight") and node.weight is not None else 1.0 - - # 如果为空，跳过 - if not memory_items_raw: - migration_stats["empty_nodes"] += 1 - logger.debug(f"跳过空节点: {concept}") - continue - - try: - # 尝试解析JSON - parsed_data = json.loads(memory_items_raw) - - if isinstance(parsed_data, list): - # 如果是list格式，需要转换 - if parsed_data: - # 转换为字符串格式 - new_memory_items = " | ".join(str(item) for item in parsed_data) - original_length = len(new_memory_items) - - # 检查长度并截断 - if len(new_memory_items) > 100: - new_memory_items = new_memory_items[:100] - migration_stats["truncated_nodes"] += 1 - logger.debug(f"节点 '{concept}' 内容过长，从 {original_length} 字符截断到 100 字符") - - new_weight = float(len(parsed_data)) # weight = list项目数量 - - # 更新数据库 - node.memory_items = new_memory_items - node.weight = new_weight - node.save() - - migration_stats["converted_nodes"] += 1 - migration_stats["weight_updated_nodes"] += 1 - - length_info = f" (截断: {original_length}→100)" if original_length > 100 else "" - logger.info( - f"转换节点 '{concept}': {len(parsed_data)} 项 -> 字符串{length_info}, weight: {original_weight} -> {new_weight}" - ) - else: - # 空list，设置为空字符串 - node.memory_items = "" - node.weight = 1.0 - node.save() - - migration_stats["converted_nodes"] += 1 - logger.debug(f"转换空list节点: {concept}") - - elif isinstance(parsed_data, str): - # 已经是字符串格式，检查长度和weight - current_content = parsed_data - original_length = len(current_content) - content_truncated = False - - # 检查长度并截断 - if len(current_content) > 100: - current_content = current_content[:100] - content_truncated = True - migration_stats["truncated_nodes"] += 1 - node.memory_items = current_content - logger.debug(f"节点 '{concept}' 字符串内容过长，从 {original_length} 字符截断到 100 字符") - - # 检查weight是否需要更新 - update_needed = False - if original_weight == 1.0: - # 如果weight还是默认值，可以根据内容复杂度估算 - content_parts = ( - current_content.split(" | ") if " | " in current_content else [current_content] - ) - estimated_weight = max(1.0, float(len(content_parts))) - - if estimated_weight != original_weight: - node.weight = estimated_weight - update_needed = True - logger.debug(f"更新字符串节点权重 '{concept}': {original_weight} -> {estimated_weight}") - - # 如果内容被截断或权重需要更新，保存到数据库 - if content_truncated or update_needed: - node.save() - if update_needed: - migration_stats["weight_updated_nodes"] += 1 - if content_truncated: - migration_stats["converted_nodes"] += 1 # 算作转换节点 - else: - migration_stats["already_string_nodes"] += 1 - else: - migration_stats["already_string_nodes"] += 1 - - else: - # 其他JSON类型，转换为字符串 - new_memory_items = str(parsed_data) if parsed_data else "" - original_length = len(new_memory_items) - - # 检查长度并截断 - if len(new_memory_items) > 100: - new_memory_items = new_memory_items[:100] - migration_stats["truncated_nodes"] += 1 - logger.debug(f"节点 '{concept}' 其他类型内容过长，从 {original_length} 字符截断到 100 字符") - - node.memory_items = new_memory_items - node.weight = 1.0 - node.save() - - migration_stats["converted_nodes"] += 1 - length_info = f" (截断: {original_length}→100)" if original_length > 100 else "" - logger.debug(f"转换其他类型节点: {concept}{length_info}") - - except json.JSONDecodeError: - # 不是JSON格式，假设已经是纯字符串 - # 检查是否是带引号的字符串 - if memory_items_raw.startswith('"') and memory_items_raw.endswith('"'): - # 去掉引号 - clean_content = memory_items_raw[1:-1] - original_length = len(clean_content) - - # 检查长度并截断 - if len(clean_content) > 100: - clean_content = clean_content[:100] - migration_stats["truncated_nodes"] += 1 - logger.debug(f"节点 '{concept}' 去引号内容过长，从 {original_length} 字符截断到 100 字符") - - node.memory_items = clean_content - node.save() - - migration_stats["converted_nodes"] += 1 - length_info = f" (截断: {original_length}→100)" if original_length > 100 else "" - logger.debug(f"去除引号节点: {concept}{length_info}") - else: - # 已经是纯字符串格式，检查长度 - current_content = memory_items_raw - original_length = len(current_content) - - # 检查长度并截断 - if len(current_content) > 100: - current_content = current_content[:100] - node.memory_items = current_content - node.save() - - migration_stats["converted_nodes"] += 1 # 算作转换节点 - migration_stats["truncated_nodes"] += 1 - logger.debug(f"节点 '{concept}' 纯字符串内容过长，从 {original_length} 字符截断到 100 字符") - else: - migration_stats["already_string_nodes"] += 1 - logger.debug(f"已是字符串格式节点: {concept}") - - except Exception as e: - migration_stats["error_nodes"] += 1 - logger.error(f"处理节点 {concept} 时发生错误: {e}") - continue - - except Exception as e: - logger.error(f"迁移过程中发生严重错误: {e}") - raise - - # 输出迁移统计 - logger.info("=== 记忆节点迁移完成 ===") - logger.info(f"总节点数: {migration_stats['total_nodes']}") - logger.info(f"已转换节点: {migration_stats['converted_nodes']}") - logger.info(f"已是字符串格式: {migration_stats['already_string_nodes']}") - logger.info(f"空节点: {migration_stats['empty_nodes']}") - logger.info(f"错误节点: {migration_stats['error_nodes']}") - logger.info(f"权重更新节点: {migration_stats['weight_updated_nodes']}") - logger.info(f"内容截断节点: {migration_stats['truncated_nodes']}") - - success_rate = ( - (migration_stats["converted_nodes"] + migration_stats["already_string_nodes"]) - / migration_stats["total_nodes"] - * 100 - if migration_stats["total_nodes"] > 0 - else 0 - ) - logger.info(f"迁移成功率: {success_rate:.1f}%") - - return migration_stats - - -async def set_all_person_known(): - """ - 将person_info库中所有记录的is_known字段设置为True - 在设置之前，先清理掉user_id或platform为空的记录 - """ - logger.info("开始设置所有person_info记录为已认识...") - - try: - from src.common.database.database_model import PersonInfo - - # 获取所有PersonInfo记录 - all_persons = PersonInfo.select() - total_count = all_persons.count() - - logger.info(f"找到 {total_count} 个人员记录") - - if total_count == 0: - logger.info("没有找到任何人员记录") - return {"total": 0, "deleted": 0, "updated": 0, "known_count": 0} - - # 删除user_id或platform为空的记录 - deleted_count = 0 - invalid_records = PersonInfo.select().where( - (PersonInfo.user_id.is_null()) - | (PersonInfo.user_id == "") - | (PersonInfo.platform.is_null()) - | (PersonInfo.platform == "") - ) - - # 记录要删除的记录信息 - for record in invalid_records: - user_id_info = f"'{record.user_id}'" if record.user_id else "NULL" - platform_info = f"'{record.platform}'" if record.platform else "NULL" - person_name_info = f"'{record.person_name}'" if record.person_name else "无名称" - logger.debug( - f"删除无效记录: person_id={record.person_id}, user_id={user_id_info}, platform={platform_info}, person_name={person_name_info}" - ) - - # 执行删除操作 - deleted_count = ( - PersonInfo.delete() - .where( - (PersonInfo.user_id.is_null()) - | (PersonInfo.user_id == "") - | (PersonInfo.platform.is_null()) - | (PersonInfo.platform == "") - ) - .execute() - ) - - if deleted_count > 0: - logger.info(f"删除了 {deleted_count} 个user_id或platform为空的记录") - else: - logger.info("没有发现user_id或platform为空的记录") - - # 重新获取剩余记录数量 - remaining_count = PersonInfo.select().count() - logger.info(f"清理后剩余 {remaining_count} 个有效记录") - - if remaining_count == 0: - logger.info("清理后没有剩余记录") - return {"total": total_count, "deleted": deleted_count, "updated": 0, "known_count": 0} - - # 批量更新剩余记录的is_known字段为True - updated_count = PersonInfo.update(is_known=True).execute() - - logger.info(f"成功更新 {updated_count} 个人员记录的is_known字段为True") - - # 验证更新结果 - known_count = PersonInfo.select().where(PersonInfo.is_known).count() - - result = {"total": total_count, "deleted": deleted_count, "updated": updated_count, "known_count": known_count} - - logger.info("=== person_info更新完成 ===") - logger.info(f"原始记录数: {result['total']}") - logger.info(f"删除记录数: {result['deleted']}") - logger.info(f"更新记录数: {result['updated']}") - logger.info(f"已认识记录数: {result['known_count']}") - - return result - - except Exception as e: - logger.error(f"更新person_info过程中发生错误: {e}") - raise - - -async def check_and_run_migrations(): - # 获取根目录 - project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) - data_dir = os.path.join(project_root, "data") - temp_dir = os.path.join(data_dir, "temp") - done_file = os.path.join(temp_dir, "done.mem") - - # 检查done.mem是否存在 - if not os.path.exists(done_file): - # 如果temp目录不存在则创建 - if not os.path.exists(temp_dir): - os.makedirs(temp_dir, exist_ok=True) - # 执行迁移函数 - # 依次执行两个异步函数 - await asyncio.sleep(3) - await migrate_memory_items_to_string() - await set_all_person_known() - # 创建done.mem文件 - with open(done_file, "w", encoding="utf-8") as f: - f.write("done") diff --git a/src/mood/mood_manager.py b/src/mood/mood_manager.py index be193e07..d64c2d9d 100644 --- a/src/mood/mood_manager.py +++ b/src/mood/mood_manager.py @@ -22,14 +22,15 @@ def init_prompt(): 以上是群里正在进行的聊天记录 {identity_block} -你刚刚的情绪状态是：{mood_state} - -现在，发送了消息，引起了你的注意，你对其进行了阅读和思考，请你输出一句话描述你新的情绪状态 +你先前的情绪状态是：{mood_state} 你的情绪特点是:{emotion_style} + +现在，请你根据先前的情绪状态和现在的聊天内容，总结推断你现在的情绪状态 请只输出新的情绪状态，不要输出其他内容： """, - "change_mood_prompt", + "get_mood_prompt", ) + Prompt( """ {chat_talking_prompt} @@ -66,37 +67,16 @@ class ChatMood: self.last_change_time: float = 0 - async def update_mood_by_message(self, message: MessageRecv): + async def get_mood(self) -> str: self.regression_count = 0 - during_last_time = message.message_info.time - self.last_change_time # type: ignore + current_time = time.time() - base_probability = 0.05 - time_multiplier = 4 * (1 - math.exp(-0.01 * during_last_time)) - - # 基于消息长度计算基础兴趣度 - message_length = len(message.processed_plain_text or "") - interest_multiplier = min(2.0, 1.0 + message_length / 100) - - logger.debug( - f"base_probability: {base_probability}, time_multiplier: {time_multiplier}, interest_multiplier: {interest_multiplier}" - ) - update_probability = global_config.mood.mood_update_threshold * min( - 1.0, base_probability * time_multiplier * interest_multiplier - ) - - if random.random() > update_probability: - return - - logger.debug( - f"{self.log_prefix} 更新情绪状态，更新概率: {update_probability:.2f}" - ) - - message_time: float = message.message_info.time # type: ignore + logger.info(f"{self.log_prefix} 获取情绪状态") message_list_before_now = get_raw_msg_by_timestamp_with_chat_inclusive( chat_id=self.chat_id, timestamp_start=self.last_change_time, - timestamp_end=message_time, + timestamp_end=current_time, limit=int(global_config.chat.max_context_size / 3), limit_mode="last", ) @@ -119,11 +99,11 @@ class ChatMood: identity_block = f"你的名字是{bot_name}{bot_nickname}" prompt = await global_prompt_manager.format_prompt( - "change_mood_prompt", + "get_mood_prompt", chat_talking_prompt=chat_talking_prompt, identity_block=identity_block, mood_state=self.mood_state, - emotion_style=global_config.personality.emotion_style, + emotion_style=global_config.mood.emotion_style, ) response, (reasoning_content, _, _) = await self.mood_model.generate_response_async( @@ -138,7 +118,9 @@ class ChatMood: self.mood_state = response - self.last_change_time = message_time + self.last_change_time = current_time + + return response async def regress_mood(self): message_time = time.time() @@ -172,7 +154,7 @@ class ChatMood: chat_talking_prompt=chat_talking_prompt, identity_block=identity_block, mood_state=self.mood_state, - emotion_style=global_config.personality.emotion_style, + emotion_style=global_config.mood.emotion_style, ) response, (reasoning_content, _, _) = await self.mood_model.generate_response_async( @@ -222,7 +204,6 @@ class MoodManager: if self.task_started: return - logger.info("启动情绪回归任务...") task = MoodRegressionTask(self) await async_task_manager.add_task(task) self.task_started = True diff --git a/src/person_info/person_info.py b/src/person_info/person_info.py index 52ddfb9f..7793da31 100644 --- a/src/person_info/person_info.py +++ b/src/person_info/person_info.py @@ -17,7 +17,9 @@ from src.config.config import global_config, model_config logger = get_logger("person_info") -relation_selection_model = LLMRequest(model_set=model_config.model_task_config.utils_small, request_type="relation_selection") +relation_selection_model = LLMRequest( + model_set=model_config.model_task_config.utils_small, request_type="relation_selection" +) def get_person_id(platform: str, user_id: Union[int, str]) -> str: @@ -91,9 +93,10 @@ def extract_categories_from_response(response: str) -> list[str]: """从response中提取所有<>包裹的内容""" if not isinstance(response, str): return [] - + import re - pattern = r'<([^<>]+)>' + + pattern = r"<([^<>]+)>" matches = re.findall(pattern, response) return matches @@ -420,7 +423,7 @@ class Person: except Exception as e: logger.error(f"同步用户 {self.person_id} 信息到数据库时出错: {e}") - async def build_relationship(self,chat_content:str = "",info_type = ""): + async def build_relationship(self, chat_content: str = "", info_type=""): if not self.is_known: return "" # 构建points文本 @@ -433,7 +436,7 @@ class Person: points_text = "" category_list = self.get_all_category() - + if chat_content: prompt = f"""当前聊天内容： {chat_content} @@ -449,11 +452,13 @@ class Person: # print(prompt) # print(response) category_list = extract_categories_from_response(response) - if "none" not in category_list: + if "none" not in category_list: for category in category_list: random_memory = self.get_random_memory_by_category(category, 2) if random_memory: - random_memory_str = "\n".join([get_memory_content_from_memory(memory) for memory in random_memory]) + random_memory_str = "\n".join( + [get_memory_content_from_memory(memory) for memory in random_memory] + ) points_text = f"有关 {category} 的内容：{random_memory_str}" break elif info_type: @@ -466,18 +471,19 @@ class Person: <分类1><分类2><分类3>...... 如果没有相关的分类，请输出""" response, _ = await relation_selection_model.generate_response_async(prompt) - print(prompt) - print(response) + # print(prompt) + # print(response) category_list = extract_categories_from_response(response) - if "none" not in category_list: + if "none" not in category_list: for category in category_list: random_memory = self.get_random_memory_by_category(category, 3) if random_memory: - random_memory_str = "\n".join([get_memory_content_from_memory(memory) for memory in random_memory]) + random_memory_str = "\n".join( + [get_memory_content_from_memory(memory) for memory in random_memory] + ) points_text = f"有关 {category} 的内容：{random_memory_str}" break else: - for category in category_list: random_memory = self.get_random_memory_by_category(category, 1)[0] if random_memory: diff --git a/src/plugin_system/apis/__init__.py b/src/plugin_system/apis/__init__.py index 036c077e..5df61ef8 100644 --- a/src/plugin_system/apis/__init__.py +++ b/src/plugin_system/apis/__init__.py @@ -19,6 +19,7 @@ from src.plugin_system.apis import ( send_api, tool_api, frequency_api, + mood_api, ) from .logging_api import get_logger from .plugin_register_api import register_plugin @@ -40,4 +41,5 @@ __all__ = [ "register_plugin", "tool_api", "frequency_api", + "mood_api", ] diff --git a/src/plugin_system/apis/database_api.py b/src/plugin_system/apis/database_api.py index be087914..bb96aeb3 100644 --- a/src/plugin_system/apis/database_api.py +++ b/src/plugin_system/apis/database_api.py @@ -309,6 +309,7 @@ async def store_action_info( thinking_id: str = "", action_data: Optional[dict] = None, action_name: str = "", + action_reasoning: str = "", ) -> Optional[Dict[str, Any]]: """存储动作信息到数据库 @@ -322,7 +323,7 @@ async def store_action_info( thinking_id: 关联的思考ID action_data: 动作数据字典 action_name: 动作名称 - + action_reasoning: 动作执行理由 Returns: Dict[str, Any]: 保存的记录数据 None: 如果保存失败 @@ -348,6 +349,7 @@ async def store_action_info( "action_name": action_name, "action_data": json.dumps(action_data or {}, ensure_ascii=False), "action_done": action_done, + "action_reasoning": action_reasoning, "action_build_into_prompt": action_build_into_prompt, "action_prompt_display": action_prompt_display, } diff --git a/src/plugin_system/apis/emoji_api.py b/src/plugin_system/apis/emoji_api.py index f8faebfe..e1661887 100644 --- a/src/plugin_system/apis/emoji_api.py +++ b/src/plugin_system/apis/emoji_api.py @@ -9,11 +9,14 @@ """ import random +import base64 +import os +import uuid -from typing import Optional, Tuple, List +from typing import Optional, Tuple, List, Dict, Any from src.common.logger import get_logger -from src.chat.emoji_system.emoji_manager import get_emoji_manager -from src.chat.utils.utils_image import image_path_to_base64 +from src.chat.emoji_system.emoji_manager import get_emoji_manager, EMOJI_DIR +from src.chat.utils.utils_image import image_path_to_base64, base64_to_image logger = get_logger("emoji_api") @@ -245,6 +248,42 @@ def get_emotions() -> List[str]: return [] +async def get_all() -> List[Tuple[str, str, str]]: + """获取所有表情包 + + Returns: + List[Tuple[str, str, str]]: 包含(base64编码, 表情包描述, 随机情感标签)的元组列表 + """ + try: + emoji_manager = get_emoji_manager() + all_emojis = emoji_manager.emoji_objects + + if not all_emojis: + logger.warning("[EmojiAPI] 没有可用的表情包") + return [] + + results = [] + for emoji_obj in all_emojis: + if emoji_obj.is_deleted: + continue + + emoji_base64 = image_path_to_base64(emoji_obj.full_path) + + if not emoji_base64: + logger.error(f"[EmojiAPI] 无法转换表情包为base64: {emoji_obj.full_path}") + continue + + matched_emotion = random.choice(emoji_obj.emotion) if emoji_obj.emotion else "随机表情" + results.append((emoji_base64, emoji_obj.description, matched_emotion)) + + logger.debug(f"[EmojiAPI] 成功获取 {len(results)} 个表情包") + return results + + except Exception as e: + logger.error(f"[EmojiAPI] 获取所有表情包失败: {e}") + return [] + + def get_descriptions() -> List[str]: """获取所有表情包描述 @@ -264,3 +303,403 @@ def get_descriptions() -> List[str]: except Exception as e: logger.error(f"[EmojiAPI] 获取表情包描述失败: {e}") return [] + + +# ============================================================================= +# 表情包注册API函数 +# ============================================================================= + + +async def register_emoji(image_base64: str, filename: Optional[str] = None) -> Dict[str, Any]: + """注册新的表情包 + + Args: + image_base64: 图片的base64编码 + filename: 可选的文件名，如果未提供则自动生成 + + Returns: + Dict[str, Any]: 注册结果，包含以下字段： + - success: bool, 是否成功注册 + - message: str, 结果消息 + - description: Optional[str], 表情包描述（成功时） + - emotions: Optional[List[str]], 情感标签列表（成功时） + - replaced: Optional[bool], 是否替换了旧表情包（成功时） + - hash: Optional[str], 表情包哈希值（成功时） + + Raises: + ValueError: 如果base64为空或无效 + TypeError: 如果参数类型不正确 + """ + if not image_base64: + raise ValueError("图片base64编码不能为空") + if not isinstance(image_base64, str): + raise TypeError("image_base64必须是字符串类型") + if filename is not None and not isinstance(filename, str): + raise TypeError("filename必须是字符串类型或None") + + try: + logger.info(f"[EmojiAPI] 开始注册表情包，文件名: {filename or '自动生成'}") + + # 1. 获取emoji管理器并检查容量 + emoji_manager = get_emoji_manager() + count_before = emoji_manager.emoji_num + max_count = emoji_manager.emoji_num_max + + # 2. 检查是否可以注册（未达到上限或启用替换） + can_register = count_before < max_count or ( + count_before >= max_count and emoji_manager.emoji_num_max_reach_deletion + ) + + if not can_register: + return { + "success": False, + "message": f"表情包数量已达上限({count_before}/{max_count})且未启用替换功能", + "description": None, + "emotions": None, + "replaced": None, + "hash": None, + } + + # 3. 确保emoji目录存在 + os.makedirs(EMOJI_DIR, exist_ok=True) + + # 4. 生成文件名 + if not filename: + # 基于时间戳、微秒和短base64生成唯一文件名 + import time + + timestamp = int(time.time()) + microseconds = int(time.time() * 1000000) % 1000000 # 添加微秒级精度 + + # 生成12位随机标识符，使用base64编码（增加随机性） + import random + + random_bytes = random.getrandbits(72).to_bytes(9, "big") # 72位 = 9字节 = 12位base64 + short_id = base64.b64encode(random_bytes).decode("ascii")[:12].rstrip("=") + # 确保base64编码适合文件名（替换/和-） + short_id = short_id.replace("/", "_").replace("+", "-") + filename = f"emoji_{timestamp}_{microseconds}_{short_id}" + + # 确保文件名有扩展名 + if not filename.lower().endswith((".jpg", ".jpeg", ".png", ".gif")): + filename = f"{filename}.png" # 默认使用png格式 + + # 检查文件名是否已存在，如果存在则重新生成短标识符 + temp_file_path = os.path.join(EMOJI_DIR, filename) + attempts = 0 + max_attempts = 10 + while os.path.exists(temp_file_path) and attempts < max_attempts: + # 重新生成短标识符 + import random + + random_bytes = random.getrandbits(48).to_bytes(6, "big") + short_id = base64.b64encode(random_bytes).decode("ascii")[:8].rstrip("=") + short_id = short_id.replace("/", "_").replace("+", "-") + + # 分离文件名和扩展名，重新生成文件名 + name_part, ext = os.path.splitext(filename) + # 去掉原来的标识符，添加新的 + base_name = name_part.rsplit("_", 1)[0] # 移除最后一个_后的部分 + filename = f"{base_name}_{short_id}{ext}" + temp_file_path = os.path.join(EMOJI_DIR, filename) + attempts += 1 + + # 如果还是冲突，使用UUID作为备用方案 + if os.path.exists(temp_file_path): + uuid_short = str(uuid.uuid4())[:8] + name_part, ext = os.path.splitext(filename) + base_name = name_part.rsplit("_", 1)[0] + filename = f"{base_name}_{uuid_short}{ext}" + temp_file_path = os.path.join(EMOJI_DIR, filename) + + # 如果UUID方案也冲突，添加序号 + counter = 1 + original_filename = filename + while os.path.exists(temp_file_path): + name_part, ext = os.path.splitext(original_filename) + filename = f"{name_part}_{counter}{ext}" + temp_file_path = os.path.join(EMOJI_DIR, filename) + counter += 1 + + # 防止无限循环，最多尝试100次 + if counter > 100: + logger.error(f"[EmojiAPI] 无法生成唯一文件名，尝试次数过多: {original_filename}") + return { + "success": False, + "message": "无法生成唯一文件名，请稍后重试", + "description": None, + "emotions": None, + "replaced": None, + "hash": None, + } + + # 5. 保存base64图片到emoji目录 + + try: + # 解码base64并保存图片 + if not base64_to_image(image_base64, temp_file_path): + logger.error(f"[EmojiAPI] 无法保存base64图片到文件: {temp_file_path}") + return { + "success": False, + "message": "无法保存图片文件", + "description": None, + "emotions": None, + "replaced": None, + "hash": None, + } + + logger.debug(f"[EmojiAPI] 图片已保存到临时文件: {temp_file_path}") + + except Exception as save_error: + logger.error(f"[EmojiAPI] 保存图片文件失败: {save_error}") + return { + "success": False, + "message": f"保存图片文件失败: {str(save_error)}", + "description": None, + "emotions": None, + "replaced": None, + "hash": None, + } + + # 6. 调用注册方法 + register_success = await emoji_manager.register_emoji_by_filename(filename) + + # 7. 清理临时文件（如果注册失败但文件还存在） + if not register_success and os.path.exists(temp_file_path): + try: + os.remove(temp_file_path) + logger.debug(f"[EmojiAPI] 已清理临时文件: {temp_file_path}") + except Exception as cleanup_error: + logger.warning(f"[EmojiAPI] 清理临时文件失败: {cleanup_error}") + + # 8. 构建返回结果 + if register_success: + count_after = emoji_manager.emoji_num + replaced = count_after <= count_before # 如果数量没增加，说明是替换 + + # 尝试获取新注册的表情包信息 + new_emoji_info = None + if count_after > count_before or replaced: + # 获取最新的表情包信息 + try: + # 通过文件名查找新注册的表情包（注意：文件名在注册后可能已经改变） + for emoji_obj in reversed(emoji_manager.emoji_objects): + if not emoji_obj.is_deleted and ( + emoji_obj.filename == filename # 直接匹配 + or (hasattr(emoji_obj, "full_path") and filename in emoji_obj.full_path) # 路径包含匹配 + ): + new_emoji_info = emoji_obj + break + except Exception as find_error: + logger.warning(f"[EmojiAPI] 查找新注册表情包信息失败: {find_error}") + + description = new_emoji_info.description if new_emoji_info else None + emotions = new_emoji_info.emotion if new_emoji_info else None + emoji_hash = new_emoji_info.hash if new_emoji_info else None + + return { + "success": True, + "message": f"表情包注册成功 {'(替换旧表情包)' if replaced else '(新增表情包)'}", + "description": description, + "emotions": emotions, + "replaced": replaced, + "hash": emoji_hash, + } + else: + return { + "success": False, + "message": "表情包注册失败，可能因为重复、格式不支持或审核未通过", + "description": None, + "emotions": None, + "replaced": None, + "hash": None, + } + + except Exception as e: + logger.error(f"[EmojiAPI] 注册表情包时发生异常: {e}") + return { + "success": False, + "message": f"注册过程中发生错误: {str(e)}", + "description": None, + "emotions": None, + "replaced": None, + "hash": None, + } + + +# ============================================================================= +# 表情包删除API函数 +# ============================================================================= + + +async def delete_emoji(emoji_hash: str) -> Dict[str, Any]: + """删除表情包 + + Args: + emoji_hash: 要删除的表情包的哈希值 + + Returns: + Dict[str, Any]: 删除结果，包含以下字段： + - success: bool, 是否成功删除 + - message: str, 结果消息 + - count_before: Optional[int], 删除前的表情包数量 + - count_after: Optional[int], 删除后的表情包数量 + - description: Optional[str], 被删除的表情包描述（成功时） + - emotions: Optional[List[str]], 被删除的表情包情感标签（成功时） + + Raises: + ValueError: 如果哈希值为空 + TypeError: 如果哈希值不是字符串类型 + """ + if not emoji_hash: + raise ValueError("表情包哈希值不能为空") + if not isinstance(emoji_hash, str): + raise TypeError("emoji_hash必须是字符串类型") + + try: + logger.info(f"[EmojiAPI] 开始删除表情包，哈希值: {emoji_hash}") + + # 1. 获取emoji管理器和删除前的数量 + emoji_manager = get_emoji_manager() + count_before = emoji_manager.emoji_num + + # 2. 获取被删除表情包的信息（用于返回结果） + try: + deleted_emoji = await emoji_manager.get_emoji_from_manager(emoji_hash) + description = deleted_emoji.description if deleted_emoji else None + emotions = deleted_emoji.emotion if deleted_emoji else None + except Exception as info_error: + logger.warning(f"[EmojiAPI] 获取被删除表情包信息失败: {info_error}") + description = None + emotions = None + + # 3. 执行删除操作 + delete_success = await emoji_manager.delete_emoji(emoji_hash) + + # 4. 获取删除后的数量 + count_after = emoji_manager.emoji_num + + # 5. 构建返回结果 + if delete_success: + return { + "success": True, + "message": f"表情包删除成功 (哈希: {emoji_hash[:8]}...)", + "count_before": count_before, + "count_after": count_after, + "description": description, + "emotions": emotions, + } + else: + return { + "success": False, + "message": "表情包删除失败，可能因为哈希值不存在或删除过程出错", + "count_before": count_before, + "count_after": count_after, + "description": None, + "emotions": None, + } + + except Exception as e: + logger.error(f"[EmojiAPI] 删除表情包时发生异常: {e}") + return { + "success": False, + "message": f"删除过程中发生错误: {str(e)}", + "count_before": None, + "count_after": None, + "description": None, + "emotions": None, + } + + +async def delete_emoji_by_description(description: str, exact_match: bool = False) -> Dict[str, Any]: + """根据描述删除表情包 + + Args: + description: 表情包描述文本 + exact_match: 是否精确匹配描述，False则为模糊匹配 + + Returns: + Dict[str, Any]: 删除结果，包含以下字段： + - success: bool, 是否成功删除 + - message: str, 结果消息 + - deleted_count: int, 删除的表情包数量 + - deleted_hashes: List[str], 被删除的表情包哈希列表 + - matched_count: int, 匹配到的表情包数量 + + Raises: + ValueError: 如果描述为空 + TypeError: 如果描述不是字符串类型 + """ + if not description: + raise ValueError("描述不能为空") + if not isinstance(description, str): + raise TypeError("description必须是字符串类型") + + try: + logger.info(f"[EmojiAPI] 根据描述删除表情包: {description} (精确匹配: {exact_match})") + + emoji_manager = get_emoji_manager() + all_emojis = emoji_manager.emoji_objects + + # 筛选匹配的表情包 + matching_emojis = [] + for emoji_obj in all_emojis: + if emoji_obj.is_deleted: + continue + + if exact_match: + if emoji_obj.description == description: + matching_emojis.append(emoji_obj) + else: + if description.lower() in emoji_obj.description.lower(): + matching_emojis.append(emoji_obj) + + matched_count = len(matching_emojis) + if matched_count == 0: + return { + "success": False, + "message": f"未找到匹配描述 '{description}' 的表情包", + "deleted_count": 0, + "deleted_hashes": [], + "matched_count": 0, + } + + # 删除匹配的表情包 + deleted_count = 0 + deleted_hashes = [] + for emoji_obj in matching_emojis: + try: + delete_success = await emoji_manager.delete_emoji(emoji_obj.hash) + if delete_success: + deleted_count += 1 + deleted_hashes.append(emoji_obj.hash) + except Exception as delete_error: + logger.error(f"[EmojiAPI] 删除表情包失败 (哈希: {emoji_obj.hash}): {delete_error}") + + # 构建返回结果 + if deleted_count > 0: + return { + "success": True, + "message": f"成功删除 {deleted_count} 个表情包 (匹配到 {matched_count} 个)", + "deleted_count": deleted_count, + "deleted_hashes": deleted_hashes, + "matched_count": matched_count, + } + else: + return { + "success": False, + "message": f"匹配到 {matched_count} 个表情包，但删除全部失败", + "deleted_count": 0, + "deleted_hashes": [], + "matched_count": matched_count, + } + + except Exception as e: + logger.error(f"[EmojiAPI] 根据描述删除表情包时发生异常: {e}") + return { + "success": False, + "message": f"删除过程中发生错误: {str(e)}", + "deleted_count": 0, + "deleted_hashes": [], + "matched_count": 0, + } diff --git a/src/plugin_system/apis/frequency_api.py b/src/plugin_system/apis/frequency_api.py index 51d10a09..68c1fa5a 100644 --- a/src/plugin_system/apis/frequency_api.py +++ b/src/plugin_system/apis/frequency_api.py @@ -3,13 +3,14 @@ from src.chat.frequency_control.frequency_control import frequency_control_manag logger = get_logger("frequency_api") + def get_current_talk_frequency(chat_id: str) -> float: return frequency_control_manager.get_or_create_frequency_control(chat_id).get_talk_frequency_adjust() + def set_talk_frequency_adjust(chat_id: str, talk_frequency_adjust: float) -> None: - frequency_control_manager.get_or_create_frequency_control( - chat_id - ).set_talk_frequency_adjust(talk_frequency_adjust) + frequency_control_manager.get_or_create_frequency_control(chat_id).set_talk_frequency_adjust(talk_frequency_adjust) + def get_talk_frequency_adjust(chat_id: str) -> float: return frequency_control_manager.get_or_create_frequency_control(chat_id).get_talk_frequency_adjust() diff --git a/src/plugin_system/apis/generator_api.py b/src/plugin_system/apis/generator_api.py index 335cc18f..29d0b66d 100644 --- a/src/plugin_system/apis/generator_api.py +++ b/src/plugin_system/apis/generator_api.py @@ -90,6 +90,7 @@ async def generate_reply( enable_chinese_typo: bool = True, request_type: str = "generator_api", from_plugin: bool = True, + reply_time_point: Optional[float] = None, ) -> Tuple[bool, Optional["LLMGenerationDataModel"]]: """生成回复 @@ -109,6 +110,7 @@ async def generate_reply( model_set_with_weight: 模型配置列表，每个元素为 (TaskConfig, weight) 元组 request_type: 请求类型（可选，记录LLM使用） from_plugin: 是否来自插件 + reply_time_point: 回复时间点 Returns: Tuple[bool, List[Tuple[str, Any]], Optional[str]]: (是否成功, 回复集合, 提示词) """ @@ -136,6 +138,7 @@ async def generate_reply( reply_reason=reply_reason, from_plugin=from_plugin, stream_id=chat_stream.stream_id if chat_stream else chat_id, + reply_time_point=reply_time_point, ) if not success: logger.warning("[GeneratorAPI] 回复生成失败") diff --git a/src/plugin_system/apis/llm_api.py b/src/plugin_system/apis/llm_api.py index debb67d7..e454c486 100644 --- a/src/plugin_system/apis/llm_api.py +++ b/src/plugin_system/apis/llm_api.py @@ -66,8 +66,8 @@ async def generate_with_model( Tuple[bool, str, str, str]: (是否成功, 生成的内容, 推理过程, 模型名称) """ try: - model_name_list = model_config.model_list - logger.info(f"[LLMAPI] 使用模型集合 {model_name_list} 生成内容") + # model_name_list = model_config.model_list + # logger.info(f"[LLMAPI] 使用模型集合 {model_name_list} 生成内容") logger.debug(f"[LLMAPI] 完整提示词: {prompt}") llm_request = LLMRequest(model_set=model_config, request_type=request_type) diff --git a/src/plugin_system/apis/message_api.py b/src/plugin_system/apis/message_api.py index f4ba0b71..8a2f8389 100644 --- a/src/plugin_system/apis/message_api.py +++ b/src/plugin_system/apis/message_api.py @@ -98,11 +98,19 @@ def get_messages_by_time_in_chat( 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(chat_id, start_time, end_time, limit, limit_mode, filter_command) - ) - return get_raw_msg_by_timestamp_with_chat(chat_id, start_time, end_time, limit, limit_mode, filter_command) + # if filter_mai: + # return filter_mai_messages( + # get_raw_msg_by_timestamp_with_chat(chat_id, start_time, end_time, limit, limit_mode, filter_command) + # ) + return get_raw_msg_by_timestamp_with_chat( + 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 + ) def get_messages_by_time_in_chat_inclusive( @@ -492,8 +500,8 @@ def filter_mai_messages(messages: List[DatabaseMessages]) -> List[DatabaseMessag def translate_pid_to_description(pid: str) -> str: image = Images.get_or_none(Images.image_id == pid) description = "" - if image and image.description: - description = image.description + if image and image.description and image.description.strip(): + description = image.description.strip() else: description = "[图片]" return description diff --git a/src/plugin_system/apis/mood_api.py b/src/plugin_system/apis/mood_api.py new file mode 100644 index 00000000..d5300e9f --- /dev/null +++ b/src/plugin_system/apis/mood_api.py @@ -0,0 +1,13 @@ +import asyncio +from typing import Optional + +from src.common.logger import get_logger +from src.mood.mood_manager import mood_manager + +logger = get_logger("mood_api") + + +async def get_mood_by_chat_id(chat_id: str) -> Optional[float]: + chat_mood = mood_manager.get_mood_by_chat_id(chat_id) + mood = asyncio.create_task(chat_mood.get_mood()) + return mood diff --git a/src/plugin_system/apis/send_api.py b/src/plugin_system/apis/send_api.py index 6a43b586..fd2b723f 100644 --- a/src/plugin_system/apis/send_api.py +++ b/src/plugin_system/apis/send_api.py @@ -100,7 +100,7 @@ async def _send_to_target( anchor_message: Union["MessageRecv", None] = None if reply_message: anchor_message = db_message_to_message_recv(reply_message) - logger.info(f"[SendAPI] 找到匹配的回复消息，发送者: {anchor_message.message_info.user_info.user_id}") # type: ignore + logger.debug(f"[SendAPI] 找到匹配的回复消息，发送者: {anchor_message.message_info.user_info.user_id}") # type: ignore if anchor_message: anchor_message.update_chat_stream(target_stream) assert anchor_message.message_info.user_info, "用户信息缺失" @@ -363,7 +363,7 @@ async def custom_reply_set_to_stream( ) -> bool: """ 向指定流发送混合型消息集 - + Args: reply_set: ReplySetModel 对象，包含多个 ReplyContent stream_id: 聊天流ID @@ -451,7 +451,9 @@ def _parse_content_to_seg(reply_content: "ReplyContent") -> Tuple[Seg, bool]: single_node_content.append(sub_seg) message_segment = Seg(type="seglist", data=single_node_content) forward_message_list.append( - MessageBase(message_segment=message_segment, message_info=BaseMessageInfo(user_info=user_info)).to_dict() + MessageBase( + message_segment=message_segment, message_info=BaseMessageInfo(user_info=user_info) + ).to_dict() ) return Seg(type="forward", data=forward_message_list), False # type: ignore else: diff --git a/src/plugin_system/base/base_action.py b/src/plugin_system/base/base_action.py index e48181e2..4e55a945 100644 --- a/src/plugin_system/base/base_action.py +++ b/src/plugin_system/base/base_action.py @@ -34,11 +34,10 @@ class BaseAction(ABC): def __init__( self, action_data: dict, - reasoning: str, + action_reasoning: str, cycle_timers: dict, thinking_id: str, chat_stream: ChatStream, - log_prefix: str = "", plugin_config: Optional[dict] = None, action_message: Optional["DatabaseMessages"] = None, **kwargs, @@ -60,10 +59,11 @@ class BaseAction(ABC): if plugin_config is None: plugin_config = {} self.action_data = action_data - self.reasoning = reasoning + self.reasoning = "" self.cycle_timers = cycle_timers self.thinking_id = thinking_id - self.log_prefix = log_prefix + + self.action_reasoning = action_reasoning self.plugin_config = plugin_config or {} """对应的插件配置""" @@ -76,16 +76,8 @@ class BaseAction(ABC): self.action_parameters: dict = getattr(self.__class__, "action_parameters", {}).copy() self.action_require: list[str] = getattr(self.__class__, "action_require", []).copy() - # 设置激活类型实例属性（从类属性复制，提供默认值） - self.focus_activation_type = getattr( - self.__class__, "focus_activation_type", ActionActivationType.ALWAYS - ) # 已弃用 - """FOCUS模式下的激活类型""" - self.normal_activation_type = getattr( - self.__class__, "normal_activation_type", ActionActivationType.ALWAYS - ) # 已弃用 """NORMAL模式下的激活类型""" - self.activation_type = getattr(self.__class__, "activation_type", self.focus_activation_type) + self.activation_type = getattr(self.__class__, "activation_type") """激活类型""" self.random_activation_probability: float = getattr(self.__class__, "random_activation_probability", 0.0) """当激活类型为RANDOM时的概率""" @@ -115,44 +107,32 @@ class BaseAction(ABC): self.user_nickname = None self.is_group = False self.target_id = None - self.has_action_message = False - if self.action_message: - self.has_action_message = True - if self.action_name != "no_action": - self.group_id = ( - str(self.action_message.chat_info.group_info.group_id) - if self.action_message.chat_info.group_info - else None - ) - self.group_name = ( - self.action_message.chat_info.group_info.group_name - if self.action_message.chat_info.group_info - else None - ) + self.group_id = ( + str(self.action_message.chat_info.group_info.group_id) + if self.action_message.chat_info.group_info + else None + ) + self.group_name = ( + self.action_message.chat_info.group_info.group_name + if self.action_message.chat_info.group_info + else None + ) + + self.user_id = str(self.action_message.user_info.user_id) + self.user_nickname = self.action_message.user_info.user_nickname + + if self.group_id: + self.is_group = True + self.target_id = self.group_id + self.log_prefix = f"[{self.group_name}]" + else: + self.is_group = False + self.target_id = self.user_id + self.log_prefix = f"[{self.user_nickname} 的 私聊]" - self.user_id = str(self.action_message.user_info.user_id) - self.user_nickname = self.action_message.user_info.user_nickname - if self.group_id: - self.is_group = True - self.target_id = self.group_id - else: - self.is_group = False - self.target_id = self.user_id - else: - if self.chat_stream.group_info: - self.group_id = self.chat_stream.group_info.group_id - self.group_name = self.chat_stream.group_info.group_name - self.is_group = True - self.target_id = self.group_id - else: - self.user_id = self.chat_stream.user_info.user_id - self.user_nickname = self.chat_stream.user_info.user_nickname - self.is_group = False - self.target_id = self.user_id - logger.debug(f"{self.log_prefix} Action组件初始化完成") logger.debug( f"{self.log_prefix} 聊天信息: 类型={'群聊' if self.is_group else '私聊'}, 平台={self.platform}, 目标={self.target_id}" ) @@ -441,6 +421,7 @@ class BaseAction(ABC): thinking_id=self.thinking_id, action_data=self.action_data, action_name=self.action_name, + action_reasoning=self.action_reasoning, ) async def wait_for_new_message(self, timeout: int = 1200) -> Tuple[bool, str]: @@ -467,11 +448,6 @@ class BaseAction(ABC): wait_start_time = asyncio.get_event_loop().time() while True: - # 检查关闭标志 - # shutting_down = self.get_action_context("shutting_down", False) - # if shutting_down: - # logger.info(f"{self.log_prefix} 等待新消息时检测到关闭信号，中断等待") - # return False, "" # 检查新消息 current_time = time.time() @@ -530,8 +506,6 @@ class BaseAction(ABC): name=name, component_type=ComponentType.ACTION, description=getattr(cls, "action_description", "Action动作"), - focus_activation_type=focus_activation_type, - normal_activation_type=normal_activation_type, activation_type=activation_type, activation_keywords=getattr(cls, "activation_keywords", []).copy(), keyword_case_sensitive=getattr(cls, "keyword_case_sensitive", False), diff --git a/src/plugin_system/core/events_manager.py b/src/plugin_system/core/events_manager.py index beac2ca6..576f830c 100644 --- a/src/plugin_system/core/events_manager.py +++ b/src/plugin_system/core/events_manager.py @@ -340,9 +340,28 @@ class EventsManager: if event_type not in self._history_enable_map: raise ValueError(f"事件类型 {event_type} 未注册") try: - success, continue_processing, return_message, custom_result, modified_message = await handler.execute( - message - ) + result = await handler.execute(message) + + expected_fields = ["success", "continue_processing", "return_message", "custom_result", "modified_message"] + + if not isinstance(result, tuple) or len(result) != 5: + if isinstance(result, tuple): + annotated = ", ".join( + f"{name}={val!r}" for name, val in zip(expected_fields, result) + ) + actual_desc = f"{len(result)} 个元素 ({annotated})" + else: + actual_desc = f"非 tuple 类型: {type(result)}" + + logger.error( + f"[{self.__class__.__name__}] EventHandler {handler.handler_name} 返回值不符合预期:\n" + f" 模块来源: {handler.__class__.__module__}.{handler.__class__.__name__}\n" + f" 期望: 5 个元素 ({', '.join(expected_fields)})\n" + f" 实际: {actual_desc}" + ) + return True, None + + success, continue_processing, return_message, custom_result, modified_message = result if not success: logger.error(f"EventHandler {handler.handler_name} 执行失败: {return_message}") @@ -351,7 +370,9 @@ class EventsManager: if self._history_enable_map[event_type] and custom_result: self._events_result_history[event_type].append(custom_result) + return continue_processing, modified_message + except KeyError: logger.error(f"事件 {event_type} 注册的历史记录启用情况与实际不符合") return True, None @@ -359,6 +380,7 @@ class EventsManager: logger.error(f"EventHandler {handler.handler_name} 发生异常: {e}", exc_info=True) return True, None # 发生异常时默认不中断其他处理 + def _task_done_callback( self, task: asyncio.Task[Tuple[bool, bool, str | None, CustomEventHandlerResult | None, MaiMessages | None]], diff --git a/src/plugin_system/core/tool_use.py b/src/plugin_system/core/tool_use.py index 10a8b05d..80db6596 100644 --- a/src/plugin_system/core/tool_use.py +++ b/src/plugin_system/core/tool_use.py @@ -24,8 +24,9 @@ def init_tool_executor_prompt(): 请仔细分析聊天内容，考虑以下几点： 1. 内容中是否包含需要查询信息的问题 2. 是否有明确的工具使用指令 +你可以选择多个动作 -If you need to use a tool, please directly call the corresponding tool function. If you do not need to use any tool, simply output "No tool needed". +If you need to use tools, please directly call the corresponding tool function. If you do not need to use any tool, simply output "No tool needed". """ Prompt(tool_executor_prompt, "tool_executor_prompt") @@ -91,7 +92,7 @@ class ToolExecutor: # 缓存未命中，执行工具调用 # 获取可用工具 tools = self._get_tool_definitions() - + # print(f"tools: {tools}") # 获取当前时间 @@ -177,10 +178,17 @@ class ToolExecutor: content = tool_info["content"] if not isinstance(content, (str, list, tuple)): tool_info["content"] = str(content) + # 空内容直接跳过（空字符串、全空白字符串、空列表/空元组） + content_check = tool_info["content"] + if ( + (isinstance(content_check, str) and not content_check.strip()) + or (isinstance(content_check, (list, tuple)) and len(content_check) == 0) + ): + logger.debug(f"{self.log_prefix}工具{tool_name}无有效内容，跳过展示") + continue tool_results.append(tool_info) used_tools.append(tool_name) - logger.info(f"{self.log_prefix}工具{tool_name}执行成功，类型: {tool_info['type']}") preview = content[:200] logger.debug(f"{self.log_prefix}工具{tool_name}结果内容: {preview}...") except Exception as e: diff --git a/src/plugins/built_in/MaiCurious/_manifest.json b/src/plugins/built_in/MaiCurious/_manifest.json new file mode 100644 index 00000000..121c9454 --- /dev/null +++ b/src/plugins/built_in/MaiCurious/_manifest.json @@ -0,0 +1,34 @@ +{ + "manifest_version": 1, + "name": "MaiCurious插件 (MaiCurious Actions)", + "version": "1.0.0", + "description": "可以好奇", + "author": { + "name": "SengokuCola", + "url": "https://github.com/MaiM-with-u" + }, + "license": "GPL-v3.0-or-later", + + "host_application": { + "min_version": "0.11.0" + }, + "homepage_url": "https://github.com/MaiM-with-u/maibot", + "repository_url": "https://github.com/MaiM-with-u/maibot", + "keywords": ["curious", "action", "built-in"], + "categories": ["Deep Think"], + + "default_locale": "zh-CN", + "locales_path": "_locales", + + "plugin_info": { + "is_built_in": true, + "plugin_type": "action_provider", + "components": [ + { + "type": "action", + "name": "maicurious", + "description": "发送好奇" + } + ] + } +} diff --git a/src/plugins/built_in/MaiCurious/plugin.py b/src/plugins/built_in/MaiCurious/plugin.py new file mode 100644 index 00000000..95865ef2 --- /dev/null +++ b/src/plugins/built_in/MaiCurious/plugin.py @@ -0,0 +1,117 @@ +from typing import List, Tuple, Type, Any + +# 导入新插件系统 +from src.plugin_system import BasePlugin, register_plugin, ComponentInfo +from src.plugin_system.base.config_types import ConfigField +from src.person_info.person_info import Person +from src.plugin_system.base.base_tool import BaseTool, ToolParamType + +# 导入依赖的系统组件 +from src.common.logger import get_logger + +from src.plugins.built_in.relation.relation import BuildRelationAction +from src.plugin_system.apis import llm_api +from src.plugin_system.base.base_action import BaseAction +from src.plugin_system.base.component_types import ActionActivationType +from src.plugin_system.apis import config_api +from src.plugin_system.apis import frequency_api +from src.plugin_system.apis import generator_api +from src.memory_system.questions import global_conflict_tracker + +logger = get_logger("question_actions") + + + +class CuriousAction(BaseAction): + """频率调节动作 - 调整聊天发言频率""" + + activation_type = ActionActivationType.ALWAYS + parallel_action = True + + # 动作基本信息 + action_name = "make_question" + + action_description = "提出一个问题，当有人反驳你的观点，或其他人之间有观点冲突时使用" + + # 动作参数定义 + action_parameters = { + "question": "对存在疑问的信息提出一个问题，描述全面，完整的描述涉及的概念和问题", + } + + action_require = [ + f"当聊天记录中的概念存在逻辑上的矛盾时使用", + f"当有人反对或否定你提出的信息时使用", + f"或当你对现有的概念或事物存在疑问时使用", + f"有人认为你的观点是错误的，请选择question动作", + f"有人与你观点不一致，请选择question动作", + ] + + # 关联类型 + associated_types = ["text"] + + async def execute(self) -> Tuple[bool, str]: + """执行频率调节动作""" + try: + if len(global_conflict_tracker.question_tracker_list) > 1: + return False, "当前已有问题，请先解答完再提问，不要再使用make_question动作" + + question = self.action_data.get("question", "") + + # 存储问题到冲突追踪器 + if question: + await global_conflict_tracker.record_conflict(conflict_content=question, start_following=True,chat_id=self.chat_id) + logger.info(f"已存储问题到冲突追踪器: {question}") + await self.store_action_info( + action_build_into_prompt=True, + action_prompt_display=f"你产生了一个问题：{question}", + action_done=True, + ) + return True, f"问题{question}已记录，不要重复提问该问题" + except Exception as e: + error_msg = f"问题生成失败: {str(e)}" + logger.error(f"{self.log_prefix} {error_msg}", exc_info=True) + await self.send_text("问题生成失败") + return False, error_msg + + +@register_plugin +class CuriousPlugin(BasePlugin): + """关系动作插件 + + 系统内置插件，提供基础的聊天交互功能： + - Reply: 回复动作 + - NoReply: 不回复动作 + - Emoji: 表情动作 + + 注意：插件基本信息优先从_manifest.json文件中读取 + """ + + # 插件基本信息 + plugin_name: str = "maicurious" # 内部标识符 + enable_plugin: bool = True + dependencies: list[str] = [] # 插件依赖列表 + python_dependencies: list[str] = [] # Python包依赖列表 + config_file_name: str = "config.toml" + + # 配置节描述 + config_section_descriptions = { + "plugin": "插件启用配置", + "components": "核心组件启用配置", + } + + # 配置Schema定义 + config_schema: dict = { + "plugin": { + "enabled": ConfigField(type=bool, default=True, description="是否启用插件"), + "config_version": ConfigField(type=str, default="3.0.0", description="配置文件版本"), + } + } + + def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]: + """返回插件包含的组件列表""" + + # --- 根据配置注册组件 --- + components = [] + components.append((CuriousAction.get_action_info(), CuriousAction)) + + return components diff --git a/src/plugins/built_in/emoji_plugin/emoji.py b/src/plugins/built_in/emoji_plugin/emoji.py index c1f963df..7078a817 100644 --- a/src/plugins/built_in/emoji_plugin/emoji.py +++ b/src/plugins/built_in/emoji_plugin/emoji.py @@ -28,16 +28,6 @@ class EmojiAction(BaseAction): action_name = "emoji" action_description = "发送表情包辅助表达情绪" - # LLM判断提示词 - llm_judge_prompt = """ - 判定是否需要使用表情动作的条件： - 1. 用户明确要求使用表情包 - 2. 这是一个适合表达强烈情绪的场合 - 3. 不要发送太多表情包，如果你已经发送过多个表情包则回答"否" - - 请回答"是"或"否"。 - """ - # 动作参数定义 action_parameters = {} @@ -56,7 +46,8 @@ class EmojiAction(BaseAction): """执行表情动作""" try: # 1. 获取发送表情的原因 - reason = self.action_data.get("reason", "表达当前情绪") + # reason = self.action_data.get("reason", "表达当前情绪") + reason = self.reasoning # 2. 随机获取20个表情包 sampled_emojis = await emoji_api.get_random(30) @@ -72,6 +63,9 @@ class EmojiAction(BaseAction): emotion_map[emo].append((b64, desc)) available_emotions = list(emotion_map.keys()) + available_emotions_str = "" + for emotion in available_emotions: + available_emotions_str += f"{emotion}\n" if not available_emotions: logger.warning(f"{self.log_prefix} 获取到的表情包均无情感标签, 将随机发送") @@ -90,14 +84,15 @@ class EmojiAction(BaseAction): ) # 4. 构建prompt让LLM选择情感 - prompt = f""" - 你是一个正在进行聊天的网友，你需要根据一个理由和最近的聊天记录，从一个情感标签列表中选择最匹配的一个。 - 这是最近的聊天记录： - {messages_text} - - 这是理由：“{reason}” - 这里是可用的情感标签：{available_emotions} - 请直接返回最匹配的那个情感标签，不要进行任何解释或添加其他多余的文字。 + prompt = f"""你正在进行QQ聊天，你需要根据聊天记录，选出一个合适的情感标签。 +请你根据以下原因和聊天记录进行选择 +原因：{reason} +聊天记录： +{messages_text} + +这里是可用的情感标签： +{available_emotions_str} +请直接返回最匹配的那个情感标签，不要进行任何解释或添加其他多余的文字。 """ if global_config.debug.show_prompt: @@ -107,10 +102,10 @@ class EmojiAction(BaseAction): # 5. 调用LLM models = llm_api.get_available_models() - chat_model_config = models.get("utils_small") # 使用字典访问方式 + chat_model_config = models.get("replyer") # 使用字典访问方式 if not chat_model_config: - logger.error(f"{self.log_prefix} 未找到'utils_small'模型配置，无法调用LLM") - return False, "未找到'utils_small'模型配置" + logger.error(f"{self.log_prefix} 未找到'replyer'模型配置，无法调用LLM") + return False, "未找到'replyer'模型配置" success, chosen_emotion, _, _ = await llm_api.generate_with_model( prompt, model_config=chat_model_config, request_type="emoji" @@ -143,7 +138,7 @@ class EmojiAction(BaseAction): action_prompt_display=f"你发送了表情包，原因：{reason}", action_done=True, ) - return True, f"成功发送表情包:{emoji_description}" + return True, f"成功发送表情包:[表情包：{chosen_emotion}]" else: error_msg = "发送表情包失败" logger.error(f"{self.log_prefix} {error_msg}") diff --git a/src/plugins/built_in/emoji_plugin/plugin.py b/src/plugins/built_in/emoji_plugin/plugin.py index b7afc522..98b1e01a 100644 --- a/src/plugins/built_in/emoji_plugin/plugin.py +++ b/src/plugins/built_in/emoji_plugin/plugin.py @@ -1,7 +1,7 @@ """ 核心动作插件 -将系统核心动作（reply、no_action、emoji）转换为新插件系统格式 +将系统核心动作（reply、no_reply、emoji）转换为新插件系统格式 这是系统的内置插件，提供基础的聊天交互功能 """ diff --git a/src/plugins/built_in/memory/_manifest.json b/src/plugins/built_in/memory/_manifest.json index 08a58540..fd6a2179 100644 --- a/src/plugins/built_in/memory/_manifest.json +++ b/src/plugins/built_in/memory/_manifest.json @@ -10,7 +10,7 @@ "license": "GPL-v3.0-or-later", "host_application": { - "min_version": "0.10.1" + "min_version": "0.10.4" }, "homepage_url": "https://github.com/MaiM-with-u/maibot", "repository_url": "https://github.com/MaiM-with-u/maibot", diff --git a/src/plugins/built_in/memory/build_memory.py b/src/plugins/built_in/memory/build_memory.py index e53b57fe..32df11cb 100644 --- a/src/plugins/built_in/memory/build_memory.py +++ b/src/plugins/built_in/memory/build_memory.py @@ -3,137 +3,88 @@ from typing import Tuple from src.common.logger import get_logger from src.config.config import global_config from src.chat.utils.prompt_builder import Prompt +from src.llm_models.payload_content.tool_option import ToolParamType from src.plugin_system import BaseAction, ActionActivationType -from src.chat.memory_system.Hippocampus import hippocampus_manager from src.chat.utils.utils import cut_key_words +from src.memory_system.Memory_chest import global_memory_chest +from src.plugin_system.base.base_tool import BaseTool +from typing import Any logger = get_logger("memory") +class GetMemoryTool(BaseTool): + """获取用户信息""" + name = "get_memory" + description = "在记忆中搜索，获取某个问题的答案" + parameters = [ + ("question", ToolParamType.STRING, "需要获取答案的问题", True, None) + ] + + available_for_llm = True -def init_prompt(): - Prompt( + async def execute(self, function_args: dict[str, Any]) -> dict[str, Any]: + """执行比较两个数的大小 + + Args: + function_args: 工具参数 + + Returns: + dict: 工具执行结果 """ -以下是一些记忆条目的分类： ----------------------- -{category_list} ----------------------- -每一个分类条目类型代表了你对用户："{person_name}"的印象的一个类别 + question: str = function_args.get("question") # type: ignore -现在，你有一条对 {person_name} 的新记忆内容： -{memory_point} - -请判断该记忆内容是否属于上述分类，请给出分类的名称。 -如果不属于上述分类，请输出一个合适的分类名称，对新记忆内容进行概括。要求分类名具有概括性。 -注意分类数一般不超过5个 -请严格用json格式输出，不要输出任何其他内容： -{{ - "category": "分类名称" -}} """, - "relation_category", - ) - - Prompt( - """ -以下是有关{category}的现有记忆： ----------------------- -{memory_list} ----------------------- - -现在，你有一条对 {person_name} 的新记忆内容： -{memory_point} - -请判断该新记忆内容是否已经存在于现有记忆中，你可以对现有进行进行以下修改： -注意，一般来说记忆内容不超过5个，且记忆文本不应太长 - -1.新增：当记忆内容不存在于现有记忆，且不存在矛盾，请用json格式输出： -{{ - "new_memory": "需要新增的记忆内容" -}} -2.加深印象：如果这个新记忆已经存在于现有记忆中，在内容上与现有记忆类似，请用json格式输出： -{{ - "memory_id": 1, #请输出你认为需要加深印象的，与新记忆内容类似的，已经存在的记忆的序号 - "integrate_memory": "加深后的记忆内容，合并内容类似的新记忆和旧记忆" -}} -3.整合：如果这个新记忆与现有记忆产生矛盾，请你结合其他记忆进行整合，用json格式输出： -{{ - "memory_id": 1, #请输出你认为需要整合的，与新记忆存在矛盾的，已经存在的记忆的序号 - "integrate_memory": "整合后的记忆内容，合并内容矛盾的新记忆和旧记忆" -}} - -现在，请你根据情况选出合适的修改方式，并输出json，不要输出其他内容： -""", - "relation_category_update", - ) - - -class BuildMemoryAction(BaseAction): - """关系动作 - 构建关系""" + answer = await global_memory_chest.get_answer_by_question(question=question) + if not answer: + return {"content": f"问题：{question}，没有找到相关记忆"} + + return {"content": f"问题：{question}，答案：{answer}"} +class GetMemoryAction(BaseAction): + """关系动作 - 获取记忆""" + activation_type = ActionActivationType.LLM_JUDGE parallel_action = True - - # 动作基本信息 - action_name = "build_memory" + + # 动作基本信息 + action_name = "get_memory" action_description = ( - "了解对于某个概念或者某件事的记忆，并存储下来，在之后的聊天中，你可以根据这条记忆来获取相关信息" + "在记忆中搜寻某个问题的答案" ) # 动作参数定义 action_parameters = { - "concept_name": "需要了解或记忆的概念或事件的名称", - "concept_description": "需要了解或记忆的概念或事件的描述，需要具体且明确", + "question": "需要搜寻或回答的问题", } # 动作使用场景 action_require = [ - "了解对于某个概念或者某件事的记忆，并存储下来，在之后的聊天中，你可以根据这条记忆来获取相关信息", + "在记忆中搜寻某个问题的答案", "有你不了解的概念", - "有人要求你记住某个概念或者事件", - "你对某件事或概念有新的理解，或产生了兴趣", + "有人提问关于过去的事情" + "你需要根据记忆回答某个问题", ] - + # 关联类型 associated_types = ["text"] - + async def execute(self) -> Tuple[bool, str]: """执行关系动作""" - - try: - # 1. 获取构建关系的原因 - concept_description = self.action_data.get("concept_description", "") - logger.info(f"{self.log_prefix} 添加记忆原因: {self.reasoning}") - concept_name = self.action_data.get("concept_name", "") - # 2. 获取目标用户信息 - - # 对 concept_name 进行jieba分词 - concept_name_tokens = cut_key_words(concept_name) - # logger.info(f"{self.log_prefix} 对 concept_name 进行分词结果: {concept_name_tokens}") - - filtered_concept_name_tokens = [ - token - for token in concept_name_tokens - if all(keyword not in token for keyword in global_config.memory.memory_ban_words) - ] - - if not filtered_concept_name_tokens: - logger.warning(f"{self.log_prefix} 过滤后的概念名称列表为空，跳过添加记忆") - return False, "过滤后的概念名称列表为空，跳过添加记忆" - - similar_topics_dict = ( - hippocampus_manager.get_hippocampus().parahippocampal_gyrus.get_similar_topics_from_keywords( - filtered_concept_name_tokens - ) + + question = self.action_data.get("question", "") + answer = await global_memory_chest.get_answer_by_question(self.chat_id, question) + if not answer: + await self.store_action_info( + action_build_into_prompt=True, + action_prompt_display=f"你回忆了有关问题：{question}的记忆，但是没有找到相关记忆", + action_done=True, ) - await hippocampus_manager.get_hippocampus().parahippocampal_gyrus.add_memory_with_similar( - concept_description, similar_topics_dict - ) - - return True, f"成功添加记忆: {concept_name}" - - except Exception as e: - logger.error(f"{self.log_prefix} 构建记忆时出错: {e}") - return False, f"构建记忆时出错: {e}" - - -# 还缺一个关系的太多遗忘和对应的提取 -init_prompt() + + return False, f"问题：{question}，没有找到相关记忆" + + await self.store_action_info( + action_build_into_prompt=True, + action_prompt_display=f"你回忆了有关问题：{question}的记忆，答案是：{answer}", + action_done=True, + ) + + return True, f"成功获取记忆: {answer}" diff --git a/src/plugins/built_in/memory/plugin.py b/src/plugins/built_in/memory/plugin.py index 25f95448..c3045fdc 100644 --- a/src/plugins/built_in/memory/plugin.py +++ b/src/plugins/built_in/memory/plugin.py @@ -1,25 +1,23 @@ from typing import List, Tuple, Type # 导入新插件系统 -from src.plugin_system import BasePlugin, ComponentInfo +from src.plugin_system import BasePlugin, ComponentInfo, register_plugin from src.plugin_system.base.config_types import ConfigField # 导入依赖的系统组件 from src.common.logger import get_logger -from src.plugins.built_in.memory.build_memory import BuildMemoryAction +from src.plugins.built_in.memory.build_memory import GetMemoryAction, GetMemoryTool -logger = get_logger("relation_actions") +logger = get_logger("memory_build") -# @register_plugin +@register_plugin class MemoryBuildPlugin(BasePlugin): - """关系动作插件 + """记忆构建插件 系统内置插件，提供基础的聊天交互功能： - - Reply: 回复动作 - - NoReply: 不回复动作 - - Emoji: 表情动作 + - GetMemory: 获取记忆 注意：插件基本信息优先从_manifest.json文件中读取 """ @@ -41,10 +39,7 @@ class MemoryBuildPlugin(BasePlugin): config_schema: dict = { "plugin": { "enabled": ConfigField(type=bool, default=True, description="是否启用插件"), - "config_version": ConfigField(type=str, default="1.1.0", description="配置文件版本"), - }, - "components": { - "memory_max_memory_num": ConfigField(type=int, default=10, description="记忆最大数量"), + "config_version": ConfigField(type=str, default="1.1.1", description="配置文件版本"), }, } @@ -53,6 +48,7 @@ class MemoryBuildPlugin(BasePlugin): # --- 根据配置注册组件 --- components = [] - components.append((BuildMemoryAction.get_action_info(), BuildMemoryAction)) + # components.append((GetMemoryAction.get_action_info(), GetMemoryAction)) + components.append((GetMemoryTool.get_tool_info(), GetMemoryTool)) return components diff --git a/src/plugins/built_in/relation/plugin.py b/src/plugins/built_in/relation/plugin.py index 500dae39..8ab48e4d 100644 --- a/src/plugins/built_in/relation/plugin.py +++ b/src/plugins/built_in/relation/plugin.py @@ -14,7 +14,6 @@ from src.plugins.built_in.relation.relation import BuildRelationAction logger = get_logger("relation_actions") - class GetPersonInfoTool(BaseTool): """获取用户信息""" @@ -24,7 +23,7 @@ class GetPersonInfoTool(BaseTool): ("person_name", ToolParamType.STRING, "需要获取信息的人的名称", True, None), ("info_type", ToolParamType.STRING, "需要获取信息的类型", True, None), ] - + available_for_llm = True async def execute(self, function_args: dict[str, Any]) -> dict[str, Any]: @@ -44,7 +43,7 @@ class GetPersonInfoTool(BaseTool): return {"content": f"用户 {person_name} 不存在"} if not person.is_known: return {"content": f"不认识用户 {person_name}"} - + relation_str = await person.build_relationship(info_type=info_type) return {"content": relation_str} @@ -78,8 +77,8 @@ class RelationActionsPlugin(BasePlugin): # 配置Schema定义 config_schema: dict = { "plugin": { - "enabled": ConfigField(type=bool, default=True, description="是否启用插件"), - "config_version": ConfigField(type=str, default="1.0.0", description="配置文件版本"), + "enabled": ConfigField(type=bool, default=False, description="是否启用插件"), + "config_version": ConfigField(type=str, default="1.0.1", description="配置文件版本"), }, "components": { "relation_max_memory_num": ConfigField(type=int, default=10, description="关系记忆最大数量"), diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml index ea97d28a..b88077ca 100644 --- a/template/bot_config_template.toml +++ b/template/bot_config_template.toml @@ -1,5 +1,5 @@ [inner] -version = "6.14.2" +version = "6.18.3" #----以下是给开发人员阅读的，如果你只是部署了麦麦，不需要阅读---- #如果你想要修改配置文件，请递增version的值 @@ -23,13 +23,12 @@ personality = "是一个女大学生，现在在读大二，会刷贴吧。" #アイデンティティがない 生まれないらららら # 描述麦麦说话的表达风格，表达习惯，如要修改，可以酌情新增内容 reply_style = "请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景。可以参考贴吧，知乎和微博的回复风格。" -# 情感特征，影响情绪的变化情况 -emotion_style = "情绪较为稳定，但遭遇特定事件的时候起伏较大" + # 麦麦的兴趣，会影响麦麦对什么话题进行回复 interest = "对技术相关话题，游戏和动漫相关话题感兴趣，也对日常话题感兴趣，不喜欢太过沉重严肃的话题" # 麦麦的说话规则，行为风格: -plan_style = """请你根据聊天内容,用户的最新消息和以下标准选择合适的动作: +plan_style = """ 1.思考**所有**的可用的action中的**每个动作**是否符合当下条件，如果动作使用条件符合聊天内容就使用 2.如果相同的内容已经被执行，请不要重复执行 3.请控制你的发言频率，不要太过频繁的发言 @@ -39,13 +38,17 @@ plan_style = """请你根据聊天内容,用户的最新消息和以下标准选 # 麦麦识图规则，不建议修改 visual_style = "请用中文描述这张图片的内容。如果有文字，请把文字描述概括出来，请留意其主题，直观感受，输出为一段平文本，最多30字，请注意不要分点，就输出一段文本" - # 麦麦私聊的说话规则，行为风格: -private_plan_style = """请你根据聊天内容,用户的最新消息和以下标准选择合适的动作: +private_plan_style = """ 1.思考**所有**的可用的action中的**每个动作**是否符合当下条件，如果动作使用条件符合聊天内容就使用 -2.如果相同的内容已经被执行，请不要重复执行""" +2.如果相同的内容已经被执行，请不要重复执行 +3.某句话如果已经被回复过，不要重复回复""" [expression] +# 表达方式模式 +mode = "classic" +# 可选：classic经典模式，exp_model 表达模型模式 + # 表达学习配置 learning_list = [ # 表达学习配置列表，支持按聊天流配置 ["", "enable", "enable", "1.0"], # 全局配置：使用表达，启用学习，学习强度1.0 @@ -70,22 +73,53 @@ expression_groups = [ [chat] #麦麦的聊天设置 -talk_value = 1 +talk_value = 1 #聊天频率，越小越沉默，范围0-1 mentioned_bot_reply = true # 是否启用提及必回复 -max_context_size = 20 # 上下文长度 +max_context_size = 30 # 上下文长度 +auto_chat_value = 1 # 自动聊天，越小，麦麦主动聊天的概率越低 +planner_smooth = 5 #规划器平滑，增大数值会减小planner负荷，略微降低反应速度，推荐2-8，0为关闭，必须大于等于0 + +# 动态发言频率规则：按时段/按chat_id调整 talk_value（优先匹配具体chat，再匹配全局） +# 推荐格式（对象数组）：{ target="platform:id:type" 或 "", time="HH:MM-HH:MM", value=0.5 } +# 说明: +# - target 为空字符串表示全局；type 为 group/private，例如："qq:1919810:group" 或 "qq:114514:private"； +# - 支持跨夜区间，例如 "23:00-02:00"；数值范围建议 0-1。 +talk_value_rules = [ + { target = "", time = "00:00-08:59", value = 0.8 }, + { target = "", time = "09:00-22:59", value = 1.0 }, + { target = "qq:1919810:group", time = "20:00-23:59", value = 0.6 }, + { target = "qq:114514:private", time = "00:00-23:59", value = 0.3 }, +] + +# 动态自动聊天频率规则：按时段/按chat_id调整 auto_chat_value（优先匹配具体chat，再匹配全局） +# 推荐格式（对象数组）：{ target="platform:id:type" 或 "", time="HH:MM-HH:MM", value=0.5 } +# 说明: +# - target 为空字符串表示全局；type 为 group/private，例如："qq:1919810:group" 或 "qq:114514:private"； +# - 支持跨夜区间，例如 "23:00-02:00"；数值范围建议 0-1。 +auto_chat_value_rules = [ + { target = "", time = "00:00-08:59", value = 0.3 }, + { target = "", time = "09:00-22:59", value = 1.0 }, + { target = "qq:1919810:group", time = "20:00-23:59", value = 0.8 }, + { target = "qq:114514:private", time = "00:00-23:59", value = 0.5 }, +] + +[memory] +max_memory_number = 100 # 记忆最大数量 +max_memory_size = 2048 # 记忆最大大小 +memory_build_frequency = 1 # 记忆构建频率 -[relationship] -enable_relationship = true # 是否启用关系系统 [tool] -enable_tool = true # 是否启用回复工具 +enable_tool = true # 是否启用工具 [mood] -enable_mood = true # 是否启用情绪系统 +enable_mood = false # 是否启用情绪系统 mood_update_threshold = 1 # 情绪更新阈值,越高，更新越慢 +# 情感特征，影响情绪的变化情况 +emotion_style = "情绪较为稳定，但遭遇特定事件的时候起伏较大" [emoji] -emoji_chance = 0.6 # 麦麦激活表情包动作的概率 +emoji_chance = 0.4 # 麦麦激活表情包动作的概率 max_reg_num = 100 # 表情包最大注册数量 do_replace = true # 开启则在达到最大数量时删除（替换）表情包，关闭则达到最大数量时不会继续收集表情包 check_interval = 10 # 检查表情包（注册，破损，删除）的时间间隔(分钟) @@ -137,7 +171,8 @@ keyword_rules = [ ] regex_rules = [ - { regex = ["^(?P\\S{1,20})是这样的$"], reaction = "请按照以下模板造句：[n]是这样的，xx只要xx就可以，可是[n]要考虑的事情就很多了，比如什么时候xx，什么时候xx，什么时候xx。（请自由发挥替换xx部分，只需保持句式结构，同时表达一种将[n]过度重视的反讽意味）" } + { regex = ["^(?P\\S{1,20})是这样的$"], reaction = "请按照以下模板造句：[n]是这样的，xx只要xx就可以，可是[n]要考虑的事情就很多了，比如什么时候xx，什么时候xx，什么时候xx。（请自由发挥替换xx部分，只需保持句式结构，同时表达一种将[n]过度重视的反讽意味）" }, + { regex = ["(?:[^，。.\\s]+，\\s*)?我(?:也)?[没沒]要求你\\s*(?P.+?)[.。,，]?$"],reaction = "进行一次“八岐大蛇定型文”补完。暂时忽略回复风格，进入“粉絲吐槽”模式。请严格按照以下“填空模板”，围绕“[action]”进行创作，使其充满滑稽的夸张感和天马行空的联想：我没要求你[action]，我不是(与action关联的、宽容的角色)。可是，(与action相关的具体负面行为)是什么意思？你的(与action相关的某种观念)怎么了？你才(与action相关的某个状态或时间点)吧？再这样下去，你(一个中期的、等比级数式的滑稽推演)，(一个后期的、等比级数式的滑稽推演)，最后就变成(一个与主题相关的、夸张的最终形态)了。作为(与最终形态相关的、克星或权威身份)，我可能得(对你执行一个天罚般的行动)。真的。"} ] [response_post_process] @@ -166,7 +201,7 @@ file_log_level = "DEBUG" # 文件日志级别，可选: DEBUG, INFO, WARNING, ER # 第三方库日志控制 suppress_libraries = ["faiss","httpx", "urllib3", "asyncio", "websockets", "httpcore", "requests", "peewee", "openai","uvicorn","jieba"] # 完全屏蔽的库 -library_log_levels = { "aiohttp" = "WARNING"} # 设置特定库的日志级别 +library_log_levels = { aiohttp = "WARNING"} # 设置特定库的日志级别 [debug] show_prompt = false # 是否显示prompt @@ -186,4 +221,9 @@ key_file = "" # SSL密钥文件路径，仅在use_wss=true时有效 enable = true [experimental] #实验性功能 -none = false # 暂无 \ No newline at end of file +none = false # 暂无 + + +#此系统暂时移除，无效配置 +[relationship] +enable_relationship = true # 是否启用关系系统 \ No newline at end of file diff --git a/template/model_config_template.toml b/template/model_config_template.toml index f7be4325..c97a6579 100644 --- a/template/model_config_template.toml +++ b/template/model_config_template.toml @@ -1,5 +1,5 @@ [inner] -version = "1.7.0" +version = "1.7.4" # 配置文件版本号迭代规则同bot_config.toml @@ -9,7 +9,7 @@ base_url = "https://api.deepseek.com/v1" # API服务商的BaseURL api_key = "your-api-key-here" # API密钥（请替换为实际的API密钥） client_type = "openai" # 请求客户端（可选，默认值为"openai"，使用gimini等Google系模型时请配置为"gemini"） max_retry = 2 # 最大重试次数（单个模型API调用失败，最多重试的次数） -timeout = 30 # API请求超时时间（单位：秒） +timeout = 120 # API请求超时时间（单位：秒） retry_interval = 10 # 重试间隔时间（单位：秒） [[api_providers]] # 阿里 百炼 API服务商配置 @@ -18,16 +18,16 @@ base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1" api_key = "your-bailian-key" client_type = "openai" max_retry = 2 -timeout = 15 +timeout = 120 retry_interval = 5 [[api_providers]] # 特殊：Google的Gimini使用特殊API，与OpenAI格式不兼容，需要配置client为"gemini" name = "Google" -base_url = "https://api.google.com/v1" +base_url = "https://generativelanguage.googleapis.com/v1beta" api_key = "your-google-api-key-1" client_type = "gemini" max_retry = 2 -timeout = 30 +timeout = 120 retry_interval = 10 [[api_providers]] # SiliconFlow的API服务商配置 @@ -36,7 +36,7 @@ base_url = "https://api.siliconflow.cn/v1" api_key = "your-siliconflow-api-key" client_type = "openai" max_retry = 2 -timeout = 60 +timeout = 120 retry_interval = 10 @@ -94,14 +94,14 @@ price_out = 0 [model_task_config.utils] # 在麦麦的一些组件中使用的模型，例如表情包模块，取名模块，关系模块，麦麦的情绪变化等，是麦麦必须的模型 -model_list = ["siliconflow-deepseek-v3","qwen3-30b"] # 使用的模型列表，每个子项对应上面的模型名称(name) +model_list = ["siliconflow-deepseek-v3"] # 使用的模型列表，每个子项对应上面的模型名称(name) temperature = 0.2 # 模型温度，新V3建议0.1-0.3 -max_tokens = 800 # 最大输出token数 +max_tokens = 2048 # 最大输出token数 [model_task_config.utils_small] # 在麦麦的一些组件中使用的小模型，消耗量较大，建议使用速度较快的小模型 model_list = ["qwen3-8b","qwen3-30b"] temperature = 0.7 -max_tokens = 800 +max_tokens = 2048 [model_task_config.tool_use] #工具调用模型，需要使用支持工具调用的模型 model_list = ["qwen3-30b"] diff --git a/test_style_learner_db.py b/test_style_learner_db.py new file mode 100644 index 00000000..ba1e2023 --- /dev/null +++ b/test_style_learner_db.py @@ -0,0 +1,391 @@ +""" +StyleLearner 数据库测试脚本 +使用数据库中的expression数据测试style_learner功能 +""" + +import os +import sys +from typing import List, Dict, Tuple +from sklearn.model_selection import train_test_split +from sklearn.metrics import precision_recall_fscore_support + +# 添加项目根目录到Python路径 +sys.path.append(os.path.dirname(os.path.abspath(__file__))) + +from src.common.database.database_model import Expression, db +from src.express.style_learner import StyleLearnerManager +from src.common.logger import get_logger + +logger = get_logger("style_learner_test") + + +class StyleLearnerDatabaseTest: + """使用数据库数据测试StyleLearner""" + + def __init__(self, random_state: int = 42): + self.random_state = random_state + self.manager = StyleLearnerManager(model_save_path="data/test_style_models") + + # 测试结果 + self.test_results = { + "total_samples": 0, + "train_samples": 0, + "test_samples": 0, + "unique_styles": 0, + "unique_chat_ids": 0, + "accuracy": 0.0, + "precision": 0.0, + "recall": 0.0, + "f1_score": 0.0, + "predictions": [], + "ground_truth": [], + "model_save_success": False, + "model_save_path": self.manager.model_save_path + } + + def load_data_from_database(self) -> List[Dict]: + """ + 从数据库加载expression数据 + + Returns: + List[Dict]: 包含up_content, style, chat_id的数据列表 + """ + try: + # 连接数据库 + db.connect(reuse_if_open=True) + + # 查询所有expression数据 + expressions = Expression.select().where( + (Expression.up_content.is_null(False)) & + (Expression.style.is_null(False)) & + (Expression.chat_id.is_null(False)) & + (Expression.type == "style") + ) + + data = [] + for expr in expressions: + if expr.up_content and expr.style and expr.chat_id: + data.append({ + "up_content": expr.up_content, + "style": expr.style, + "chat_id": expr.chat_id, + "last_active_time": expr.last_active_time, + "context": expr.context, + "situation": expr.situation + }) + + logger.info(f"从数据库加载了 {len(data)} 条expression数据") + return data + + except Exception as e: + logger.error(f"从数据库加载数据失败: {e}") + return [] + + def preprocess_data(self, data: List[Dict]) -> List[Dict]: + """ + 数据预处理 + + Args: + data: 原始数据 + + Returns: + List[Dict]: 预处理后的数据 + """ + # 过滤掉空值或过短的数据 + filtered_data = [] + for item in data: + up_content = item["up_content"].strip() + style = item["style"].strip() + + if len(up_content) >= 2 and len(style) >= 2: + filtered_data.append({ + "up_content": up_content, + "style": style, + "chat_id": item["chat_id"], + "last_active_time": item["last_active_time"], + "context": item["context"], + "situation": item["situation"] + }) + + logger.info(f"预处理后剩余 {len(filtered_data)} 条数据") + return filtered_data + + def split_data(self, data: List[Dict]) -> Tuple[List[Dict], List[Dict]]: + """ + 分割训练集和测试集 + 训练集使用所有数据，测试集从训练集中随机选择5% + + Args: + data: 预处理后的数据 + + Returns: + Tuple[List[Dict], List[Dict]]: (训练集, 测试集) + """ + # 训练集使用所有数据 + train_data = data.copy() + + # 测试集从训练集中随机选择5% + test_size = 0.05 # 5% + test_data = train_test_split( + train_data, test_size=test_size, random_state=self.random_state + )[1] # 只取测试集部分 + + logger.info(f"数据分割完成: 训练集 {len(train_data)} 条, 测试集 {len(test_data)} 条") + logger.info(f"训练集使用所有数据，测试集从训练集中随机选择 {test_size*100:.1f}%") + return train_data, test_data + + def train_model(self, train_data: List[Dict]) -> None: + """ + 训练模型 + + Args: + train_data: 训练数据 + """ + logger.info("开始训练模型...") + + # 统计信息 + chat_ids = set() + styles = set() + + for item in train_data: + chat_id = item["chat_id"] + up_content = item["up_content"] + style = item["style"] + + chat_ids.add(chat_id) + styles.add(style) + + # 学习映射关系 + success = self.manager.learn_mapping(chat_id, up_content, style) + if not success: + logger.warning(f"学习失败: {chat_id} - {up_content} -> {style}") + + self.test_results["train_samples"] = len(train_data) + self.test_results["unique_styles"] = len(styles) + self.test_results["unique_chat_ids"] = len(chat_ids) + + logger.info(f"训练完成: {len(train_data)} 个样本, {len(styles)} 种风格, {len(chat_ids)} 个聊天室") + + # 保存训练好的模型 + logger.info("开始保存训练好的模型...") + save_success = self.manager.save_all_models() + self.test_results["model_save_success"] = save_success + + if save_success: + logger.info(f"所有模型已成功保存到: {self.manager.model_save_path}") + print(f"✅ 模型已保存到: {self.manager.model_save_path}") + else: + logger.warning("部分模型保存失败") + print(f"⚠️ 模型保存失败，请检查路径: {self.manager.model_save_path}") + + def test_model(self, test_data: List[Dict]) -> None: + """ + 测试模型 + + Args: + test_data: 测试数据 + """ + logger.info("开始测试模型...") + + predictions = [] + ground_truth = [] + correct_predictions = 0 + + for item in test_data: + chat_id = item["chat_id"] + up_content = item["up_content"] + true_style = item["style"] + + # 预测风格 + predicted_style, scores = self.manager.predict_style(chat_id, up_content, top_k=1) + + predictions.append(predicted_style) + ground_truth.append(true_style) + + # 检查预测是否正确 + if predicted_style == true_style: + correct_predictions += 1 + + # 记录详细预测结果 + self.test_results["predictions"].append({ + "chat_id": chat_id, + "up_content": up_content, + "true_style": true_style, + "predicted_style": predicted_style, + "scores": scores + }) + + # 计算准确率 + accuracy = correct_predictions / len(test_data) if test_data else 0 + + # 计算其他指标（需要处理None值） + valid_predictions = [p for p in predictions if p is not None] + valid_ground_truth = [gt for p, gt in zip(predictions, ground_truth, strict=False) if p is not None] + + if valid_predictions: + precision, recall, f1, _ = precision_recall_fscore_support( + valid_ground_truth, valid_predictions, average='weighted', zero_division=0 + ) + else: + precision = recall = f1 = 0.0 + + self.test_results["test_samples"] = len(test_data) + self.test_results["accuracy"] = accuracy + self.test_results["precision"] = precision + self.test_results["recall"] = recall + self.test_results["f1_score"] = f1 + + logger.info(f"测试完成: 准确率 {accuracy:.4f}, 精确率 {precision:.4f}, 召回率 {recall:.4f}, F1分数 {f1:.4f}") + + def analyze_results(self) -> None: + """分析测试结果""" + logger.info("=== 测试结果分析 ===") + + print("\n📊 数据统计:") + print(f" 总样本数: {self.test_results['total_samples']}") + print(f" 训练样本数: {self.test_results['train_samples']}") + print(f" 测试样本数: {self.test_results['test_samples']}") + print(f" 唯一风格数: {self.test_results['unique_styles']}") + print(f" 唯一聊天室数: {self.test_results['unique_chat_ids']}") + + print("\n🎯 模型性能:") + print(f" 准确率: {self.test_results['accuracy']:.4f}") + print(f" 精确率: {self.test_results['precision']:.4f}") + print(f" 召回率: {self.test_results['recall']:.4f}") + print(f" F1分数: {self.test_results['f1_score']:.4f}") + + print("\n💾 模型保存:") + save_status = "成功" if self.test_results['model_save_success'] else "失败" + print(f" 保存状态: {save_status}") + print(f" 保存路径: {self.test_results['model_save_path']}") + + # 分析各聊天室的性能 + chat_performance = {} + for pred in self.test_results["predictions"]: + chat_id = pred["chat_id"] + if chat_id not in chat_performance: + chat_performance[chat_id] = {"correct": 0, "total": 0} + + chat_performance[chat_id]["total"] += 1 + if pred["predicted_style"] == pred["true_style"]: + chat_performance[chat_id]["correct"] += 1 + + print("\n📈 各聊天室性能:") + for chat_id, perf in chat_performance.items(): + accuracy = perf["correct"] / perf["total"] if perf["total"] > 0 else 0 + print(f" {chat_id}: {accuracy:.4f} ({perf['correct']}/{perf['total']})") + + # 分析风格分布 + style_counts = {} + for pred in self.test_results["predictions"]: + style = pred["true_style"] + style_counts[style] = style_counts.get(style, 0) + 1 + + print("\n🎨 风格分布 (前10个):") + sorted_styles = sorted(style_counts.items(), key=lambda x: x[1], reverse=True) + for style, count in sorted_styles[:10]: + print(f" {style}: {count} 次") + + def show_sample_predictions(self, num_samples: int = 10) -> None: + """显示样本预测结果""" + print(f"\n🔍 样本预测结果 (前{num_samples}个):") + + for i, pred in enumerate(self.test_results["predictions"][:num_samples]): + status = "✓" if pred["predicted_style"] == pred["true_style"] else "✗" + print(f"\n {i+1}. {status}") + print(f" 聊天室: {pred['chat_id']}") + print(f" 输入内容: {pred['up_content']}") + print(f" 真实风格: {pred['true_style']}") + print(f" 预测风格: {pred['predicted_style']}") + if pred["scores"]: + top_scores = dict(list(pred["scores"].items())[:3]) + print(f" 分数: {top_scores}") + + def save_results(self, output_file: str = "style_learner_test_results.txt") -> None: + """保存测试结果到文件""" + try: + with open(output_file, "w", encoding="utf-8") as f: + f.write("StyleLearner 数据库测试结果\n") + f.write("=" * 50 + "\n\n") + + f.write("数据统计:\n") + f.write(f" 总样本数: {self.test_results['total_samples']}\n") + f.write(f" 训练样本数: {self.test_results['train_samples']}\n") + f.write(f" 测试样本数: {self.test_results['test_samples']}\n") + f.write(f" 唯一风格数: {self.test_results['unique_styles']}\n") + f.write(f" 唯一聊天室数: {self.test_results['unique_chat_ids']}\n\n") + + f.write("模型性能:\n") + f.write(f" 准确率: {self.test_results['accuracy']:.4f}\n") + f.write(f" 精确率: {self.test_results['precision']:.4f}\n") + f.write(f" 召回率: {self.test_results['recall']:.4f}\n") + f.write(f" F1分数: {self.test_results['f1_score']:.4f}\n\n") + + f.write("模型保存:\n") + save_status = "成功" if self.test_results['model_save_success'] else "失败" + f.write(f" 保存状态: {save_status}\n") + f.write(f" 保存路径: {self.test_results['model_save_path']}\n\n") + + f.write("详细预测结果:\n") + for i, pred in enumerate(self.test_results["predictions"]): + status = "✓" if pred["predicted_style"] == pred["true_style"] else "✗" + f.write(f"{i+1}. {status} [{pred['chat_id']}] {pred['up_content']} -> {pred['predicted_style']} (真实: {pred['true_style']})\n") + + logger.info(f"测试结果已保存到 {output_file}") + + except Exception as e: + logger.error(f"保存测试结果失败: {e}") + + def run_test(self) -> None: + """运行完整测试""" + logger.info("开始StyleLearner数据库测试...") + + # 1. 加载数据 + raw_data = self.load_data_from_database() + if not raw_data: + logger.error("没有加载到数据，测试终止") + return + + # 2. 数据预处理 + processed_data = self.preprocess_data(raw_data) + if not processed_data: + logger.error("预处理后没有数据，测试终止") + return + + self.test_results["total_samples"] = len(processed_data) + + # 3. 分割数据 + train_data, test_data = self.split_data(processed_data) + + # 4. 训练模型 + self.train_model(train_data) + + # 5. 测试模型 + self.test_model(test_data) + + # 6. 分析结果 + self.analyze_results() + + # 7. 显示样本预测 + self.show_sample_predictions(10) + + # 8. 保存结果 + self.save_results() + + logger.info("StyleLearner数据库测试完成!") + + +def main(): + """主函数""" + print("StyleLearner 数据库测试脚本") + print("=" * 50) + + # 创建测试实例 + test = StyleLearnerDatabaseTest(random_state=42) + + # 运行测试 + test.run_test() + + +if __name__ == "__main__": + main() diff --git a/uv.lock b/uv.lock deleted file mode 100644 index 7f69962a..00000000 --- a/uv.lock +++ /dev/null @@ -1,2656 +0,0 @@ -version = 1 -revision = 2 -requires-python = ">=3.10" -resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", - "python_full_version < '3.11'", -] - -[[package]] -name = "aenum" -version = "3.1.16" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e3/52/6ad8f63ec8da1bf40f96996d25d5b650fdd38f5975f8c813732c47388f18/aenum-3.1.16-py3-none-any.whl", hash = "sha256:9035092855a98e41b66e3d0998bd7b96280e85ceb3a04cc035636138a1943eaf", size = 165627, upload_time = "2025-04-25T03:17:58.89Z" }, -] - -[[package]] -name = "aiohappyeyeballs" -version = "2.6.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload_time = "2025-03-12T01:42:48.764Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload_time = "2025-03-12T01:42:47.083Z" }, -] - -[[package]] -name = "aiohttp" -version = "3.12.14" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aiohappyeyeballs" }, - { name = "aiosignal" }, - { name = "async-timeout", marker = "python_full_version < '3.11'" }, - { name = "attrs" }, - { name = "frozenlist" }, - { name = "multidict" }, - { name = "propcache" }, - { name = "yarl" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e6/0b/e39ad954107ebf213a2325038a3e7a506be3d98e1435e1f82086eec4cde2/aiohttp-3.12.14.tar.gz", hash = "sha256:6e06e120e34d93100de448fd941522e11dafa78ef1a893c179901b7d66aa29f2", size = 7822921, upload_time = "2025-07-10T13:05:33.968Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/88/f161f429f9de391eee6a5c2cffa54e2ecd5b7122ae99df247f7734dfefcb/aiohttp-3.12.14-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:906d5075b5ba0dd1c66fcaaf60eb09926a9fef3ca92d912d2a0bbdbecf8b1248", size = 702641, upload_time = "2025-07-10T13:02:38.98Z" }, - { url = "https://files.pythonhosted.org/packages/fe/b5/24fa382a69a25d242e2baa3e56d5ea5227d1b68784521aaf3a1a8b34c9a4/aiohttp-3.12.14-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c875bf6fc2fd1a572aba0e02ef4e7a63694778c5646cdbda346ee24e630d30fb", size = 479005, upload_time = "2025-07-10T13:02:42.714Z" }, - { url = "https://files.pythonhosted.org/packages/09/67/fda1bc34adbfaa950d98d934a23900918f9d63594928c70e55045838c943/aiohttp-3.12.14-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fbb284d15c6a45fab030740049d03c0ecd60edad9cd23b211d7e11d3be8d56fd", size = 466781, upload_time = "2025-07-10T13:02:44.639Z" }, - { url = "https://files.pythonhosted.org/packages/36/96/3ce1ea96d3cf6928b87cfb8cdd94650367f5c2f36e686a1f5568f0f13754/aiohttp-3.12.14-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38e360381e02e1a05d36b223ecab7bc4a6e7b5ab15760022dc92589ee1d4238c", size = 1648841, upload_time = "2025-07-10T13:02:46.356Z" }, - { url = "https://files.pythonhosted.org/packages/be/04/ddea06cb4bc7d8db3745cf95e2c42f310aad485ca075bd685f0e4f0f6b65/aiohttp-3.12.14-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aaf90137b5e5d84a53632ad95ebee5c9e3e7468f0aab92ba3f608adcb914fa95", size = 1622896, upload_time = "2025-07-10T13:02:48.422Z" }, - { url = "https://files.pythonhosted.org/packages/73/66/63942f104d33ce6ca7871ac6c1e2ebab48b88f78b2b7680c37de60f5e8cd/aiohttp-3.12.14-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e532a25e4a0a2685fa295a31acf65e027fbe2bea7a4b02cdfbbba8a064577663", size = 1695302, upload_time = "2025-07-10T13:02:50.078Z" }, - { url = "https://files.pythonhosted.org/packages/20/00/aab615742b953f04b48cb378ee72ada88555b47b860b98c21c458c030a23/aiohttp-3.12.14-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eab9762c4d1b08ae04a6c77474e6136da722e34fdc0e6d6eab5ee93ac29f35d1", size = 1737617, upload_time = "2025-07-10T13:02:52.123Z" }, - { url = "https://files.pythonhosted.org/packages/d6/4f/ef6d9f77225cf27747368c37b3d69fac1f8d6f9d3d5de2d410d155639524/aiohttp-3.12.14-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:abe53c3812b2899889a7fca763cdfaeee725f5be68ea89905e4275476ffd7e61", size = 1642282, upload_time = "2025-07-10T13:02:53.899Z" }, - { url = "https://files.pythonhosted.org/packages/37/e1/e98a43c15aa52e9219a842f18c59cbae8bbe2d50c08d298f17e9e8bafa38/aiohttp-3.12.14-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5760909b7080aa2ec1d320baee90d03b21745573780a072b66ce633eb77a8656", size = 1582406, upload_time = "2025-07-10T13:02:55.515Z" }, - { url = "https://files.pythonhosted.org/packages/71/5c/29c6dfb49323bcdb0239bf3fc97ffcf0eaf86d3a60426a3287ec75d67721/aiohttp-3.12.14-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:02fcd3f69051467bbaa7f84d7ec3267478c7df18d68b2e28279116e29d18d4f3", size = 1626255, upload_time = "2025-07-10T13:02:57.343Z" }, - { url = "https://files.pythonhosted.org/packages/79/60/ec90782084090c4a6b459790cfd8d17be2c5662c9c4b2d21408b2f2dc36c/aiohttp-3.12.14-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:4dcd1172cd6794884c33e504d3da3c35648b8be9bfa946942d353b939d5f1288", size = 1637041, upload_time = "2025-07-10T13:02:59.008Z" }, - { url = "https://files.pythonhosted.org/packages/22/89/205d3ad30865c32bc472ac13f94374210745b05bd0f2856996cb34d53396/aiohttp-3.12.14-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:224d0da41355b942b43ad08101b1b41ce633a654128ee07e36d75133443adcda", size = 1612494, upload_time = "2025-07-10T13:03:00.618Z" }, - { url = "https://files.pythonhosted.org/packages/48/ae/2f66edaa8bd6db2a4cba0386881eb92002cdc70834e2a93d1d5607132c7e/aiohttp-3.12.14-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:e387668724f4d734e865c1776d841ed75b300ee61059aca0b05bce67061dcacc", size = 1692081, upload_time = "2025-07-10T13:03:02.154Z" }, - { url = "https://files.pythonhosted.org/packages/08/3a/fa73bfc6e21407ea57f7906a816f0dc73663d9549da703be05dbd76d2dc3/aiohttp-3.12.14-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:dec9cde5b5a24171e0b0a4ca064b1414950904053fb77c707efd876a2da525d8", size = 1715318, upload_time = "2025-07-10T13:03:04.322Z" }, - { url = "https://files.pythonhosted.org/packages/e3/b3/751124b8ceb0831c17960d06ee31a4732cb4a6a006fdbfa1153d07c52226/aiohttp-3.12.14-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bbad68a2af4877cc103cd94af9160e45676fc6f0c14abb88e6e092b945c2c8e3", size = 1643660, upload_time = "2025-07-10T13:03:06.406Z" }, - { url = "https://files.pythonhosted.org/packages/81/3c/72477a1d34edb8ab8ce8013086a41526d48b64f77e381c8908d24e1c18f5/aiohttp-3.12.14-cp310-cp310-win32.whl", hash = "sha256:ee580cb7c00bd857b3039ebca03c4448e84700dc1322f860cf7a500a6f62630c", size = 428289, upload_time = "2025-07-10T13:03:08.274Z" }, - { url = "https://files.pythonhosted.org/packages/a2/c4/8aec4ccf1b822ec78e7982bd5cf971113ecce5f773f04039c76a083116fc/aiohttp-3.12.14-cp310-cp310-win_amd64.whl", hash = "sha256:cf4f05b8cea571e2ccc3ca744e35ead24992d90a72ca2cf7ab7a2efbac6716db", size = 451328, upload_time = "2025-07-10T13:03:10.146Z" }, - { url = "https://files.pythonhosted.org/packages/53/e1/8029b29316971c5fa89cec170274582619a01b3d82dd1036872acc9bc7e8/aiohttp-3.12.14-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f4552ff7b18bcec18b60a90c6982049cdb9dac1dba48cf00b97934a06ce2e597", size = 709960, upload_time = "2025-07-10T13:03:11.936Z" }, - { url = "https://files.pythonhosted.org/packages/96/bd/4f204cf1e282041f7b7e8155f846583b19149e0872752711d0da5e9cc023/aiohttp-3.12.14-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8283f42181ff6ccbcf25acaae4e8ab2ff7e92b3ca4a4ced73b2c12d8cd971393", size = 482235, upload_time = "2025-07-10T13:03:14.118Z" }, - { url = "https://files.pythonhosted.org/packages/d6/0f/2a580fcdd113fe2197a3b9df30230c7e85bb10bf56f7915457c60e9addd9/aiohttp-3.12.14-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:040afa180ea514495aaff7ad34ec3d27826eaa5d19812730fe9e529b04bb2179", size = 470501, upload_time = "2025-07-10T13:03:16.153Z" }, - { url = "https://files.pythonhosted.org/packages/38/78/2c1089f6adca90c3dd74915bafed6d6d8a87df5e3da74200f6b3a8b8906f/aiohttp-3.12.14-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b413c12f14c1149f0ffd890f4141a7471ba4b41234fe4fd4a0ff82b1dc299dbb", size = 1740696, upload_time = "2025-07-10T13:03:18.4Z" }, - { url = "https://files.pythonhosted.org/packages/4a/c8/ce6c7a34d9c589f007cfe064da2d943b3dee5aabc64eaecd21faf927ab11/aiohttp-3.12.14-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d6f607ce2e1a93315414e3d448b831238f1874b9968e1195b06efaa5c87e245", size = 1689365, upload_time = "2025-07-10T13:03:20.629Z" }, - { url = "https://files.pythonhosted.org/packages/18/10/431cd3d089de700756a56aa896faf3ea82bee39d22f89db7ddc957580308/aiohttp-3.12.14-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:565e70d03e924333004ed101599902bba09ebb14843c8ea39d657f037115201b", size = 1788157, upload_time = "2025-07-10T13:03:22.44Z" }, - { url = "https://files.pythonhosted.org/packages/fa/b2/26f4524184e0f7ba46671c512d4b03022633bcf7d32fa0c6f1ef49d55800/aiohttp-3.12.14-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4699979560728b168d5ab63c668a093c9570af2c7a78ea24ca5212c6cdc2b641", size = 1827203, upload_time = "2025-07-10T13:03:24.628Z" }, - { url = "https://files.pythonhosted.org/packages/e0/30/aadcdf71b510a718e3d98a7bfeaea2396ac847f218b7e8edb241b09bd99a/aiohttp-3.12.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad5fdf6af93ec6c99bf800eba3af9a43d8bfd66dce920ac905c817ef4a712afe", size = 1729664, upload_time = "2025-07-10T13:03:26.412Z" }, - { url = "https://files.pythonhosted.org/packages/67/7f/7ccf11756ae498fdedc3d689a0c36ace8fc82f9d52d3517da24adf6e9a74/aiohttp-3.12.14-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4ac76627c0b7ee0e80e871bde0d376a057916cb008a8f3ffc889570a838f5cc7", size = 1666741, upload_time = "2025-07-10T13:03:28.167Z" }, - { url = "https://files.pythonhosted.org/packages/6b/4d/35ebc170b1856dd020c92376dbfe4297217625ef4004d56587024dc2289c/aiohttp-3.12.14-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:798204af1180885651b77bf03adc903743a86a39c7392c472891649610844635", size = 1715013, upload_time = "2025-07-10T13:03:30.018Z" }, - { url = "https://files.pythonhosted.org/packages/7b/24/46dc0380146f33e2e4aa088b92374b598f5bdcde1718c77e8d1a0094f1a4/aiohttp-3.12.14-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:4f1205f97de92c37dd71cf2d5bcfb65fdaed3c255d246172cce729a8d849b4da", size = 1710172, upload_time = "2025-07-10T13:03:31.821Z" }, - { url = "https://files.pythonhosted.org/packages/2f/0a/46599d7d19b64f4d0fe1b57bdf96a9a40b5c125f0ae0d8899bc22e91fdce/aiohttp-3.12.14-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:76ae6f1dd041f85065d9df77c6bc9c9703da9b5c018479d20262acc3df97d419", size = 1690355, upload_time = "2025-07-10T13:03:34.754Z" }, - { url = "https://files.pythonhosted.org/packages/08/86/b21b682e33d5ca317ef96bd21294984f72379454e689d7da584df1512a19/aiohttp-3.12.14-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a194ace7bc43ce765338ca2dfb5661489317db216ea7ea700b0332878b392cab", size = 1783958, upload_time = "2025-07-10T13:03:36.53Z" }, - { url = "https://files.pythonhosted.org/packages/4f/45/f639482530b1396c365f23c5e3b1ae51c9bc02ba2b2248ca0c855a730059/aiohttp-3.12.14-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:16260e8e03744a6fe3fcb05259eeab8e08342c4c33decf96a9dad9f1187275d0", size = 1804423, upload_time = "2025-07-10T13:03:38.504Z" }, - { url = "https://files.pythonhosted.org/packages/7e/e5/39635a9e06eed1d73671bd4079a3caf9cf09a49df08490686f45a710b80e/aiohttp-3.12.14-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c779e5ebbf0e2e15334ea404fcce54009dc069210164a244d2eac8352a44b28", size = 1717479, upload_time = "2025-07-10T13:03:40.158Z" }, - { url = "https://files.pythonhosted.org/packages/51/e1/7f1c77515d369b7419c5b501196526dad3e72800946c0099594c1f0c20b4/aiohttp-3.12.14-cp311-cp311-win32.whl", hash = "sha256:a289f50bf1bd5be227376c067927f78079a7bdeccf8daa6a9e65c38bae14324b", size = 427907, upload_time = "2025-07-10T13:03:41.801Z" }, - { url = "https://files.pythonhosted.org/packages/06/24/a6bf915c85b7a5b07beba3d42b3282936b51e4578b64a51e8e875643c276/aiohttp-3.12.14-cp311-cp311-win_amd64.whl", hash = "sha256:0b8a69acaf06b17e9c54151a6c956339cf46db4ff72b3ac28516d0f7068f4ced", size = 452334, upload_time = "2025-07-10T13:03:43.485Z" }, - { url = "https://files.pythonhosted.org/packages/c3/0d/29026524e9336e33d9767a1e593ae2b24c2b8b09af7c2bd8193762f76b3e/aiohttp-3.12.14-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a0ecbb32fc3e69bc25efcda7d28d38e987d007096cbbeed04f14a6662d0eee22", size = 701055, upload_time = "2025-07-10T13:03:45.59Z" }, - { url = "https://files.pythonhosted.org/packages/0a/b8/a5e8e583e6c8c1056f4b012b50a03c77a669c2e9bf012b7cf33d6bc4b141/aiohttp-3.12.14-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0400f0ca9bb3e0b02f6466421f253797f6384e9845820c8b05e976398ac1d81a", size = 475670, upload_time = "2025-07-10T13:03:47.249Z" }, - { url = "https://files.pythonhosted.org/packages/29/e8/5202890c9e81a4ec2c2808dd90ffe024952e72c061729e1d49917677952f/aiohttp-3.12.14-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a56809fed4c8a830b5cae18454b7464e1529dbf66f71c4772e3cfa9cbec0a1ff", size = 468513, upload_time = "2025-07-10T13:03:49.377Z" }, - { url = "https://files.pythonhosted.org/packages/23/e5/d11db8c23d8923d3484a27468a40737d50f05b05eebbb6288bafcb467356/aiohttp-3.12.14-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27f2e373276e4755691a963e5d11756d093e346119f0627c2d6518208483fb6d", size = 1715309, upload_time = "2025-07-10T13:03:51.556Z" }, - { url = "https://files.pythonhosted.org/packages/53/44/af6879ca0eff7a16b1b650b7ea4a827301737a350a464239e58aa7c387ef/aiohttp-3.12.14-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ca39e433630e9a16281125ef57ece6817afd1d54c9f1bf32e901f38f16035869", size = 1697961, upload_time = "2025-07-10T13:03:53.511Z" }, - { url = "https://files.pythonhosted.org/packages/bb/94/18457f043399e1ec0e59ad8674c0372f925363059c276a45a1459e17f423/aiohttp-3.12.14-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9c748b3f8b14c77720132b2510a7d9907a03c20ba80f469e58d5dfd90c079a1c", size = 1753055, upload_time = "2025-07-10T13:03:55.368Z" }, - { url = "https://files.pythonhosted.org/packages/26/d9/1d3744dc588fafb50ff8a6226d58f484a2242b5dd93d8038882f55474d41/aiohttp-3.12.14-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f0a568abe1b15ce69d4cc37e23020720423f0728e3cb1f9bcd3f53420ec3bfe7", size = 1799211, upload_time = "2025-07-10T13:03:57.216Z" }, - { url = "https://files.pythonhosted.org/packages/73/12/2530fb2b08773f717ab2d249ca7a982ac66e32187c62d49e2c86c9bba9b4/aiohttp-3.12.14-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9888e60c2c54eaf56704b17feb558c7ed6b7439bca1e07d4818ab878f2083660", size = 1718649, upload_time = "2025-07-10T13:03:59.469Z" }, - { url = "https://files.pythonhosted.org/packages/b9/34/8d6015a729f6571341a311061b578e8b8072ea3656b3d72329fa0faa2c7c/aiohttp-3.12.14-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3006a1dc579b9156de01e7916d38c63dc1ea0679b14627a37edf6151bc530088", size = 1634452, upload_time = "2025-07-10T13:04:01.698Z" }, - { url = "https://files.pythonhosted.org/packages/ff/4b/08b83ea02595a582447aeb0c1986792d0de35fe7a22fb2125d65091cbaf3/aiohttp-3.12.14-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aa8ec5c15ab80e5501a26719eb48a55f3c567da45c6ea5bb78c52c036b2655c7", size = 1695511, upload_time = "2025-07-10T13:04:04.165Z" }, - { url = "https://files.pythonhosted.org/packages/b5/66/9c7c31037a063eec13ecf1976185c65d1394ded4a5120dd5965e3473cb21/aiohttp-3.12.14-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:39b94e50959aa07844c7fe2206b9f75d63cc3ad1c648aaa755aa257f6f2498a9", size = 1716967, upload_time = "2025-07-10T13:04:06.132Z" }, - { url = "https://files.pythonhosted.org/packages/ba/02/84406e0ad1acb0fb61fd617651ab6de760b2d6a31700904bc0b33bd0894d/aiohttp-3.12.14-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:04c11907492f416dad9885d503fbfc5dcb6768d90cad8639a771922d584609d3", size = 1657620, upload_time = "2025-07-10T13:04:07.944Z" }, - { url = "https://files.pythonhosted.org/packages/07/53/da018f4013a7a179017b9a274b46b9a12cbeb387570f116964f498a6f211/aiohttp-3.12.14-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:88167bd9ab69bb46cee91bd9761db6dfd45b6e76a0438c7e884c3f8160ff21eb", size = 1737179, upload_time = "2025-07-10T13:04:10.182Z" }, - { url = "https://files.pythonhosted.org/packages/49/e8/ca01c5ccfeaafb026d85fa4f43ceb23eb80ea9c1385688db0ef322c751e9/aiohttp-3.12.14-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:791504763f25e8f9f251e4688195e8b455f8820274320204f7eafc467e609425", size = 1765156, upload_time = "2025-07-10T13:04:12.029Z" }, - { url = "https://files.pythonhosted.org/packages/22/32/5501ab525a47ba23c20613e568174d6c63aa09e2caa22cded5c6ea8e3ada/aiohttp-3.12.14-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2785b112346e435dd3a1a67f67713a3fe692d288542f1347ad255683f066d8e0", size = 1724766, upload_time = "2025-07-10T13:04:13.961Z" }, - { url = "https://files.pythonhosted.org/packages/06/af/28e24574801fcf1657945347ee10df3892311c2829b41232be6089e461e7/aiohttp-3.12.14-cp312-cp312-win32.whl", hash = "sha256:15f5f4792c9c999a31d8decf444e79fcfd98497bf98e94284bf390a7bb8c1729", size = 422641, upload_time = "2025-07-10T13:04:16.018Z" }, - { url = "https://files.pythonhosted.org/packages/98/d5/7ac2464aebd2eecac38dbe96148c9eb487679c512449ba5215d233755582/aiohttp-3.12.14-cp312-cp312-win_amd64.whl", hash = "sha256:3b66e1a182879f579b105a80d5c4bd448b91a57e8933564bf41665064796a338", size = 449316, upload_time = "2025-07-10T13:04:18.289Z" }, - { url = "https://files.pythonhosted.org/packages/06/48/e0d2fa8ac778008071e7b79b93ab31ef14ab88804d7ba71b5c964a7c844e/aiohttp-3.12.14-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3143a7893d94dc82bc409f7308bc10d60285a3cd831a68faf1aa0836c5c3c767", size = 695471, upload_time = "2025-07-10T13:04:20.124Z" }, - { url = "https://files.pythonhosted.org/packages/8d/e7/f73206afa33100804f790b71092888f47df65fd9a4cd0e6800d7c6826441/aiohttp-3.12.14-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3d62ac3d506cef54b355bd34c2a7c230eb693880001dfcda0bf88b38f5d7af7e", size = 473128, upload_time = "2025-07-10T13:04:21.928Z" }, - { url = "https://files.pythonhosted.org/packages/df/e2/4dd00180be551a6e7ee979c20fc7c32727f4889ee3fd5b0586e0d47f30e1/aiohttp-3.12.14-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:48e43e075c6a438937c4de48ec30fa8ad8e6dfef122a038847456bfe7b947b63", size = 465426, upload_time = "2025-07-10T13:04:24.071Z" }, - { url = "https://files.pythonhosted.org/packages/de/dd/525ed198a0bb674a323e93e4d928443a680860802c44fa7922d39436b48b/aiohttp-3.12.14-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:077b4488411a9724cecc436cbc8c133e0d61e694995b8de51aaf351c7578949d", size = 1704252, upload_time = "2025-07-10T13:04:26.049Z" }, - { url = "https://files.pythonhosted.org/packages/d8/b1/01e542aed560a968f692ab4fc4323286e8bc4daae83348cd63588e4f33e3/aiohttp-3.12.14-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d8c35632575653f297dcbc9546305b2c1133391089ab925a6a3706dfa775ccab", size = 1685514, upload_time = "2025-07-10T13:04:28.186Z" }, - { url = "https://files.pythonhosted.org/packages/b3/06/93669694dc5fdabdc01338791e70452d60ce21ea0946a878715688d5a191/aiohttp-3.12.14-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6b8ce87963f0035c6834b28f061df90cf525ff7c9b6283a8ac23acee6502afd4", size = 1737586, upload_time = "2025-07-10T13:04:30.195Z" }, - { url = "https://files.pythonhosted.org/packages/a5/3a/18991048ffc1407ca51efb49ba8bcc1645961f97f563a6c480cdf0286310/aiohttp-3.12.14-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f0a2cf66e32a2563bb0766eb24eae7e9a269ac0dc48db0aae90b575dc9583026", size = 1786958, upload_time = "2025-07-10T13:04:32.482Z" }, - { url = "https://files.pythonhosted.org/packages/30/a8/81e237f89a32029f9b4a805af6dffc378f8459c7b9942712c809ff9e76e5/aiohttp-3.12.14-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdea089caf6d5cde975084a884c72d901e36ef9c2fd972c9f51efbbc64e96fbd", size = 1709287, upload_time = "2025-07-10T13:04:34.493Z" }, - { url = "https://files.pythonhosted.org/packages/8c/e3/bd67a11b0fe7fc12c6030473afd9e44223d456f500f7cf526dbaa259ae46/aiohttp-3.12.14-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8a7865f27db67d49e81d463da64a59365ebd6b826e0e4847aa111056dcb9dc88", size = 1622990, upload_time = "2025-07-10T13:04:36.433Z" }, - { url = "https://files.pythonhosted.org/packages/83/ba/e0cc8e0f0d9ce0904e3cf2d6fa41904e379e718a013c721b781d53dcbcca/aiohttp-3.12.14-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0ab5b38a6a39781d77713ad930cb5e7feea6f253de656a5f9f281a8f5931b086", size = 1676015, upload_time = "2025-07-10T13:04:38.958Z" }, - { url = "https://files.pythonhosted.org/packages/d8/b3/1e6c960520bda094c48b56de29a3d978254637ace7168dd97ddc273d0d6c/aiohttp-3.12.14-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:9b3b15acee5c17e8848d90a4ebc27853f37077ba6aec4d8cb4dbbea56d156933", size = 1707678, upload_time = "2025-07-10T13:04:41.275Z" }, - { url = "https://files.pythonhosted.org/packages/0a/19/929a3eb8c35b7f9f076a462eaa9830b32c7f27d3395397665caa5e975614/aiohttp-3.12.14-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e4c972b0bdaac167c1e53e16a16101b17c6d0ed7eac178e653a07b9f7fad7151", size = 1650274, upload_time = "2025-07-10T13:04:43.483Z" }, - { url = "https://files.pythonhosted.org/packages/22/e5/81682a6f20dd1b18ce3d747de8eba11cbef9b270f567426ff7880b096b48/aiohttp-3.12.14-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7442488b0039257a3bdbc55f7209587911f143fca11df9869578db6c26feeeb8", size = 1726408, upload_time = "2025-07-10T13:04:45.577Z" }, - { url = "https://files.pythonhosted.org/packages/8c/17/884938dffaa4048302985483f77dfce5ac18339aad9b04ad4aaa5e32b028/aiohttp-3.12.14-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:f68d3067eecb64c5e9bab4a26aa11bd676f4c70eea9ef6536b0a4e490639add3", size = 1759879, upload_time = "2025-07-10T13:04:47.663Z" }, - { url = "https://files.pythonhosted.org/packages/95/78/53b081980f50b5cf874359bde707a6eacd6c4be3f5f5c93937e48c9d0025/aiohttp-3.12.14-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f88d3704c8b3d598a08ad17d06006cb1ca52a1182291f04979e305c8be6c9758", size = 1708770, upload_time = "2025-07-10T13:04:49.944Z" }, - { url = "https://files.pythonhosted.org/packages/ed/91/228eeddb008ecbe3ffa6c77b440597fdf640307162f0c6488e72c5a2d112/aiohttp-3.12.14-cp313-cp313-win32.whl", hash = "sha256:a3c99ab19c7bf375c4ae3debd91ca5d394b98b6089a03231d4c580ef3c2ae4c5", size = 421688, upload_time = "2025-07-10T13:04:51.993Z" }, - { url = "https://files.pythonhosted.org/packages/66/5f/8427618903343402fdafe2850738f735fd1d9409d2a8f9bcaae5e630d3ba/aiohttp-3.12.14-cp313-cp313-win_amd64.whl", hash = "sha256:3f8aad695e12edc9d571f878c62bedc91adf30c760c8632f09663e5f564f4baa", size = 448098, upload_time = "2025-07-10T13:04:53.999Z" }, -] - -[[package]] -name = "aiosignal" -version = "1.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "frozenlist" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload_time = "2025-07-03T22:54:43.528Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload_time = "2025-07-03T22:54:42.156Z" }, -] - -[[package]] -name = "annotated-types" -version = "0.7.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload_time = "2024-05-20T21:33:25.928Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload_time = "2024-05-20T21:33:24.1Z" }, -] - -[[package]] -name = "anyio" -version = "4.9.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, - { name = "idna" }, - { name = "sniffio" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload_time = "2025-03-17T00:02:54.77Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload_time = "2025-03-17T00:02:52.713Z" }, -] - -[[package]] -name = "apscheduler" -version = "3.11.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "tzlocal" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/4e/00/6d6814ddc19be2df62c8c898c4df6b5b1914f3bd024b780028caa392d186/apscheduler-3.11.0.tar.gz", hash = "sha256:4c622d250b0955a65d5d0eb91c33e6d43fd879834bf541e0a18661ae60460133", size = 107347, upload_time = "2024-11-24T19:39:26.463Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/ae/9a053dd9229c0fde6b1f1f33f609ccff1ee79ddda364c756a924c6d8563b/APScheduler-3.11.0-py3-none-any.whl", hash = "sha256:fc134ca32e50f5eadcc4938e3a4545ab19131435e851abb40b34d63d5141c6da", size = 64004, upload_time = "2024-11-24T19:39:24.442Z" }, -] - -[[package]] -name = "async-timeout" -version = "5.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload_time = "2024-11-06T16:41:39.6Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload_time = "2024-11-06T16:41:37.9Z" }, -] - -[[package]] -name = "attrs" -version = "25.3.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032, upload_time = "2025-03-13T11:10:22.779Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload_time = "2025-03-13T11:10:21.14Z" }, -] - -[[package]] -name = "certifi" -version = "2025.7.9" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/de/8a/c729b6b60c66a38f590c4e774decc4b2ec7b0576be8f1aa984a53ffa812a/certifi-2025.7.9.tar.gz", hash = "sha256:c1d2ec05395148ee10cf672ffc28cd37ea0ab0d99f9cc74c43e588cbd111b079", size = 160386, upload_time = "2025-07-09T02:13:58.874Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/66/f3/80a3f974c8b535d394ff960a11ac20368e06b736da395b551a49ce950cce/certifi-2025.7.9-py3-none-any.whl", hash = "sha256:d842783a14f8fdd646895ac26f719a061408834473cfc10203f6a575beb15d39", size = 159230, upload_time = "2025-07-09T02:13:57.007Z" }, -] - -[[package]] -name = "cffi" -version = "1.17.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pycparser" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload_time = "2024-09-04T20:45:21.852Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191, upload_time = "2024-09-04T20:43:30.027Z" }, - { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592, upload_time = "2024-09-04T20:43:32.108Z" }, - { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024, upload_time = "2024-09-04T20:43:34.186Z" }, - { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188, upload_time = "2024-09-04T20:43:36.286Z" }, - { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571, upload_time = "2024-09-04T20:43:38.586Z" }, - { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687, upload_time = "2024-09-04T20:43:40.084Z" }, - { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211, upload_time = "2024-09-04T20:43:41.526Z" }, - { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325, upload_time = "2024-09-04T20:43:43.117Z" }, - { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784, upload_time = "2024-09-04T20:43:45.256Z" }, - { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564, upload_time = "2024-09-04T20:43:46.779Z" }, - { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804, upload_time = "2024-09-04T20:43:48.186Z" }, - { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299, upload_time = "2024-09-04T20:43:49.812Z" }, - { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264, upload_time = "2024-09-04T20:43:51.124Z" }, - { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651, upload_time = "2024-09-04T20:43:52.872Z" }, - { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259, upload_time = "2024-09-04T20:43:56.123Z" }, - { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200, upload_time = "2024-09-04T20:43:57.891Z" }, - { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235, upload_time = "2024-09-04T20:44:00.18Z" }, - { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721, upload_time = "2024-09-04T20:44:01.585Z" }, - { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242, upload_time = "2024-09-04T20:44:03.467Z" }, - { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999, upload_time = "2024-09-04T20:44:05.023Z" }, - { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242, upload_time = "2024-09-04T20:44:06.444Z" }, - { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604, upload_time = "2024-09-04T20:44:08.206Z" }, - { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727, upload_time = "2024-09-04T20:44:09.481Z" }, - { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400, upload_time = "2024-09-04T20:44:10.873Z" }, - { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload_time = "2024-09-04T20:44:12.232Z" }, - { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload_time = "2024-09-04T20:44:13.739Z" }, - { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload_time = "2024-09-04T20:44:15.231Z" }, - { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload_time = "2024-09-04T20:44:17.188Z" }, - { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload_time = "2024-09-04T20:44:18.688Z" }, - { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload_time = "2024-09-04T20:44:20.248Z" }, - { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload_time = "2024-09-04T20:44:21.673Z" }, - { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload_time = "2024-09-04T20:44:23.245Z" }, - { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload_time = "2024-09-04T20:44:24.757Z" }, - { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload_time = "2024-09-04T20:44:26.208Z" }, - { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload_time = "2024-09-04T20:44:27.578Z" }, - { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989, upload_time = "2024-09-04T20:44:28.956Z" }, - { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802, upload_time = "2024-09-04T20:44:30.289Z" }, - { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792, upload_time = "2024-09-04T20:44:32.01Z" }, - { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893, upload_time = "2024-09-04T20:44:33.606Z" }, - { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810, upload_time = "2024-09-04T20:44:35.191Z" }, - { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200, upload_time = "2024-09-04T20:44:36.743Z" }, - { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447, upload_time = "2024-09-04T20:44:38.492Z" }, - { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358, upload_time = "2024-09-04T20:44:40.046Z" }, - { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469, upload_time = "2024-09-04T20:44:41.616Z" }, - { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload_time = "2024-09-04T20:44:43.733Z" }, - { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload_time = "2024-09-04T20:44:45.309Z" }, -] - -[[package]] -name = "charset-normalizer" -version = "3.4.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367, upload_time = "2025-05-02T08:34:42.01Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/95/28/9901804da60055b406e1a1c5ba7aac1276fb77f1dde635aabfc7fd84b8ab/charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941", size = 201818, upload_time = "2025-05-02T08:31:46.725Z" }, - { url = "https://files.pythonhosted.org/packages/d9/9b/892a8c8af9110935e5adcbb06d9c6fe741b6bb02608c6513983048ba1a18/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd", size = 144649, upload_time = "2025-05-02T08:31:48.889Z" }, - { url = "https://files.pythonhosted.org/packages/7b/a5/4179abd063ff6414223575e008593861d62abfc22455b5d1a44995b7c101/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6", size = 155045, upload_time = "2025-05-02T08:31:50.757Z" }, - { url = "https://files.pythonhosted.org/packages/3b/95/bc08c7dfeddd26b4be8c8287b9bb055716f31077c8b0ea1cd09553794665/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d", size = 147356, upload_time = "2025-05-02T08:31:52.634Z" }, - { url = "https://files.pythonhosted.org/packages/a8/2d/7a5b635aa65284bf3eab7653e8b4151ab420ecbae918d3e359d1947b4d61/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86", size = 149471, upload_time = "2025-05-02T08:31:56.207Z" }, - { url = "https://files.pythonhosted.org/packages/ae/38/51fc6ac74251fd331a8cfdb7ec57beba8c23fd5493f1050f71c87ef77ed0/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c", size = 151317, upload_time = "2025-05-02T08:31:57.613Z" }, - { url = "https://files.pythonhosted.org/packages/b7/17/edee1e32215ee6e9e46c3e482645b46575a44a2d72c7dfd49e49f60ce6bf/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0", size = 146368, upload_time = "2025-05-02T08:31:59.468Z" }, - { url = "https://files.pythonhosted.org/packages/26/2c/ea3e66f2b5f21fd00b2825c94cafb8c326ea6240cd80a91eb09e4a285830/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef", size = 154491, upload_time = "2025-05-02T08:32:01.219Z" }, - { url = "https://files.pythonhosted.org/packages/52/47/7be7fa972422ad062e909fd62460d45c3ef4c141805b7078dbab15904ff7/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6", size = 157695, upload_time = "2025-05-02T08:32:03.045Z" }, - { url = "https://files.pythonhosted.org/packages/2f/42/9f02c194da282b2b340f28e5fb60762de1151387a36842a92b533685c61e/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366", size = 154849, upload_time = "2025-05-02T08:32:04.651Z" }, - { url = "https://files.pythonhosted.org/packages/67/44/89cacd6628f31fb0b63201a618049be4be2a7435a31b55b5eb1c3674547a/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db", size = 150091, upload_time = "2025-05-02T08:32:06.719Z" }, - { url = "https://files.pythonhosted.org/packages/1f/79/4b8da9f712bc079c0f16b6d67b099b0b8d808c2292c937f267d816ec5ecc/charset_normalizer-3.4.2-cp310-cp310-win32.whl", hash = "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a", size = 98445, upload_time = "2025-05-02T08:32:08.66Z" }, - { url = "https://files.pythonhosted.org/packages/7d/d7/96970afb4fb66497a40761cdf7bd4f6fca0fc7bafde3a84f836c1f57a926/charset_normalizer-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509", size = 105782, upload_time = "2025-05-02T08:32:10.46Z" }, - { url = "https://files.pythonhosted.org/packages/05/85/4c40d00dcc6284a1c1ad5de5e0996b06f39d8232f1031cd23c2f5c07ee86/charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2", size = 198794, upload_time = "2025-05-02T08:32:11.945Z" }, - { url = "https://files.pythonhosted.org/packages/41/d9/7a6c0b9db952598e97e93cbdfcb91bacd89b9b88c7c983250a77c008703c/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645", size = 142846, upload_time = "2025-05-02T08:32:13.946Z" }, - { url = "https://files.pythonhosted.org/packages/66/82/a37989cda2ace7e37f36c1a8ed16c58cf48965a79c2142713244bf945c89/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd", size = 153350, upload_time = "2025-05-02T08:32:15.873Z" }, - { url = "https://files.pythonhosted.org/packages/df/68/a576b31b694d07b53807269d05ec3f6f1093e9545e8607121995ba7a8313/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8", size = 145657, upload_time = "2025-05-02T08:32:17.283Z" }, - { url = "https://files.pythonhosted.org/packages/92/9b/ad67f03d74554bed3aefd56fe836e1623a50780f7c998d00ca128924a499/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f", size = 147260, upload_time = "2025-05-02T08:32:18.807Z" }, - { url = "https://files.pythonhosted.org/packages/a6/e6/8aebae25e328160b20e31a7e9929b1578bbdc7f42e66f46595a432f8539e/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7", size = 149164, upload_time = "2025-05-02T08:32:20.333Z" }, - { url = "https://files.pythonhosted.org/packages/8b/f2/b3c2f07dbcc248805f10e67a0262c93308cfa149a4cd3d1fe01f593e5fd2/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9", size = 144571, upload_time = "2025-05-02T08:32:21.86Z" }, - { url = "https://files.pythonhosted.org/packages/60/5b/c3f3a94bc345bc211622ea59b4bed9ae63c00920e2e8f11824aa5708e8b7/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544", size = 151952, upload_time = "2025-05-02T08:32:23.434Z" }, - { url = "https://files.pythonhosted.org/packages/e2/4d/ff460c8b474122334c2fa394a3f99a04cf11c646da895f81402ae54f5c42/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82", size = 155959, upload_time = "2025-05-02T08:32:24.993Z" }, - { url = "https://files.pythonhosted.org/packages/a2/2b/b964c6a2fda88611a1fe3d4c400d39c66a42d6c169c924818c848f922415/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0", size = 153030, upload_time = "2025-05-02T08:32:26.435Z" }, - { url = "https://files.pythonhosted.org/packages/59/2e/d3b9811db26a5ebf444bc0fa4f4be5aa6d76fc6e1c0fd537b16c14e849b6/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5", size = 148015, upload_time = "2025-05-02T08:32:28.376Z" }, - { url = "https://files.pythonhosted.org/packages/90/07/c5fd7c11eafd561bb51220d600a788f1c8d77c5eef37ee49454cc5c35575/charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a", size = 98106, upload_time = "2025-05-02T08:32:30.281Z" }, - { url = "https://files.pythonhosted.org/packages/a8/05/5e33dbef7e2f773d672b6d79f10ec633d4a71cd96db6673625838a4fd532/charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28", size = 105402, upload_time = "2025-05-02T08:32:32.191Z" }, - { url = "https://files.pythonhosted.org/packages/d7/a4/37f4d6035c89cac7930395a35cc0f1b872e652eaafb76a6075943754f095/charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7", size = 199936, upload_time = "2025-05-02T08:32:33.712Z" }, - { url = "https://files.pythonhosted.org/packages/ee/8a/1a5e33b73e0d9287274f899d967907cd0bf9c343e651755d9307e0dbf2b3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3", size = 143790, upload_time = "2025-05-02T08:32:35.768Z" }, - { url = "https://files.pythonhosted.org/packages/66/52/59521f1d8e6ab1482164fa21409c5ef44da3e9f653c13ba71becdd98dec3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a", size = 153924, upload_time = "2025-05-02T08:32:37.284Z" }, - { url = "https://files.pythonhosted.org/packages/86/2d/fb55fdf41964ec782febbf33cb64be480a6b8f16ded2dbe8db27a405c09f/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214", size = 146626, upload_time = "2025-05-02T08:32:38.803Z" }, - { url = "https://files.pythonhosted.org/packages/8c/73/6ede2ec59bce19b3edf4209d70004253ec5f4e319f9a2e3f2f15601ed5f7/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a", size = 148567, upload_time = "2025-05-02T08:32:40.251Z" }, - { url = "https://files.pythonhosted.org/packages/09/14/957d03c6dc343c04904530b6bef4e5efae5ec7d7990a7cbb868e4595ee30/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd", size = 150957, upload_time = "2025-05-02T08:32:41.705Z" }, - { url = "https://files.pythonhosted.org/packages/0d/c8/8174d0e5c10ccebdcb1b53cc959591c4c722a3ad92461a273e86b9f5a302/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981", size = 145408, upload_time = "2025-05-02T08:32:43.709Z" }, - { url = "https://files.pythonhosted.org/packages/58/aa/8904b84bc8084ac19dc52feb4f5952c6df03ffb460a887b42615ee1382e8/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c", size = 153399, upload_time = "2025-05-02T08:32:46.197Z" }, - { url = "https://files.pythonhosted.org/packages/c2/26/89ee1f0e264d201cb65cf054aca6038c03b1a0c6b4ae998070392a3ce605/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b", size = 156815, upload_time = "2025-05-02T08:32:48.105Z" }, - { url = "https://files.pythonhosted.org/packages/fd/07/68e95b4b345bad3dbbd3a8681737b4338ff2c9df29856a6d6d23ac4c73cb/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d", size = 154537, upload_time = "2025-05-02T08:32:49.719Z" }, - { url = "https://files.pythonhosted.org/packages/77/1a/5eefc0ce04affb98af07bc05f3bac9094513c0e23b0562d64af46a06aae4/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f", size = 149565, upload_time = "2025-05-02T08:32:51.404Z" }, - { url = "https://files.pythonhosted.org/packages/37/a0/2410e5e6032a174c95e0806b1a6585eb21e12f445ebe239fac441995226a/charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c", size = 98357, upload_time = "2025-05-02T08:32:53.079Z" }, - { url = "https://files.pythonhosted.org/packages/6c/4f/c02d5c493967af3eda9c771ad4d2bbc8df6f99ddbeb37ceea6e8716a32bc/charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e", size = 105776, upload_time = "2025-05-02T08:32:54.573Z" }, - { url = "https://files.pythonhosted.org/packages/ea/12/a93df3366ed32db1d907d7593a94f1fe6293903e3e92967bebd6950ed12c/charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0", size = 199622, upload_time = "2025-05-02T08:32:56.363Z" }, - { url = "https://files.pythonhosted.org/packages/04/93/bf204e6f344c39d9937d3c13c8cd5bbfc266472e51fc8c07cb7f64fcd2de/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf", size = 143435, upload_time = "2025-05-02T08:32:58.551Z" }, - { url = "https://files.pythonhosted.org/packages/22/2a/ea8a2095b0bafa6c5b5a55ffdc2f924455233ee7b91c69b7edfcc9e02284/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e", size = 153653, upload_time = "2025-05-02T08:33:00.342Z" }, - { url = "https://files.pythonhosted.org/packages/b6/57/1b090ff183d13cef485dfbe272e2fe57622a76694061353c59da52c9a659/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1", size = 146231, upload_time = "2025-05-02T08:33:02.081Z" }, - { url = "https://files.pythonhosted.org/packages/e2/28/ffc026b26f441fc67bd21ab7f03b313ab3fe46714a14b516f931abe1a2d8/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c", size = 148243, upload_time = "2025-05-02T08:33:04.063Z" }, - { url = "https://files.pythonhosted.org/packages/c0/0f/9abe9bd191629c33e69e47c6ef45ef99773320e9ad8e9cb08b8ab4a8d4cb/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691", size = 150442, upload_time = "2025-05-02T08:33:06.418Z" }, - { url = "https://files.pythonhosted.org/packages/67/7c/a123bbcedca91d5916c056407f89a7f5e8fdfce12ba825d7d6b9954a1a3c/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0", size = 145147, upload_time = "2025-05-02T08:33:08.183Z" }, - { url = "https://files.pythonhosted.org/packages/ec/fe/1ac556fa4899d967b83e9893788e86b6af4d83e4726511eaaad035e36595/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b", size = 153057, upload_time = "2025-05-02T08:33:09.986Z" }, - { url = "https://files.pythonhosted.org/packages/2b/ff/acfc0b0a70b19e3e54febdd5301a98b72fa07635e56f24f60502e954c461/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff", size = 156454, upload_time = "2025-05-02T08:33:11.814Z" }, - { url = "https://files.pythonhosted.org/packages/92/08/95b458ce9c740d0645feb0e96cea1f5ec946ea9c580a94adfe0b617f3573/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b", size = 154174, upload_time = "2025-05-02T08:33:13.707Z" }, - { url = "https://files.pythonhosted.org/packages/78/be/8392efc43487ac051eee6c36d5fbd63032d78f7728cb37aebcc98191f1ff/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148", size = 149166, upload_time = "2025-05-02T08:33:15.458Z" }, - { url = "https://files.pythonhosted.org/packages/44/96/392abd49b094d30b91d9fbda6a69519e95802250b777841cf3bda8fe136c/charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7", size = 98064, upload_time = "2025-05-02T08:33:17.06Z" }, - { url = "https://files.pythonhosted.org/packages/e9/b0/0200da600134e001d91851ddc797809e2fe0ea72de90e09bec5a2fbdaccb/charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980", size = 105641, upload_time = "2025-05-02T08:33:18.753Z" }, - { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626, upload_time = "2025-05-02T08:34:40.053Z" }, -] - -[[package]] -name = "click" -version = "8.2.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342, upload_time = "2025-05-20T23:19:49.832Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload_time = "2025-05-20T23:19:47.796Z" }, -] - -[[package]] -name = "colorama" -version = "0.4.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload_time = "2022-10-25T02:36:22.414Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload_time = "2022-10-25T02:36:20.889Z" }, -] - -[[package]] -name = "contourpy" -version = "1.3.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload_time = "2025-04-15T17:47:53.79Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload_time = "2025-04-15T17:34:46.581Z" }, - { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload_time = "2025-04-15T17:34:51.427Z" }, - { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload_time = "2025-04-15T17:34:55.961Z" }, - { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload_time = "2025-04-15T17:35:00.992Z" }, - { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload_time = "2025-04-15T17:35:06.177Z" }, - { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload_time = "2025-04-15T17:35:11.244Z" }, - { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload_time = "2025-04-15T17:35:26.701Z" }, - { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload_time = "2025-04-15T17:35:43.204Z" }, - { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload_time = "2025-04-15T17:35:46.554Z" }, - { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload_time = "2025-04-15T17:35:50.064Z" }, - { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload_time = "2025-04-15T17:35:54.473Z" }, - { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload_time = "2025-04-15T17:35:58.283Z" }, - { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload_time = "2025-04-15T17:36:03.235Z" }, - { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload_time = "2025-04-15T17:36:08.275Z" }, - { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload_time = "2025-04-15T17:36:13.29Z" }, - { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload_time = "2025-04-15T17:36:18.329Z" }, - { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload_time = "2025-04-15T17:36:33.878Z" }, - { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload_time = "2025-04-15T17:36:51.295Z" }, - { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload_time = "2025-04-15T17:36:55.002Z" }, - { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload_time = "2025-04-15T17:36:58.576Z" }, - { url = "https://files.pythonhosted.org/packages/34/f7/44785876384eff370c251d58fd65f6ad7f39adce4a093c934d4a67a7c6b6/contourpy-1.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4caf2bcd2969402bf77edc4cb6034c7dd7c0803213b3523f111eb7460a51b8d2", size = 271580, upload_time = "2025-04-15T17:37:03.105Z" }, - { url = "https://files.pythonhosted.org/packages/93/3b/0004767622a9826ea3d95f0e9d98cd8729015768075d61f9fea8eeca42a8/contourpy-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:82199cb78276249796419fe36b7386bd8d2cc3f28b3bc19fe2454fe2e26c4c15", size = 255530, upload_time = "2025-04-15T17:37:07.026Z" }, - { url = "https://files.pythonhosted.org/packages/e7/bb/7bd49e1f4fa805772d9fd130e0d375554ebc771ed7172f48dfcd4ca61549/contourpy-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106fab697af11456fcba3e352ad50effe493a90f893fca6c2ca5c033820cea92", size = 307688, upload_time = "2025-04-15T17:37:11.481Z" }, - { url = "https://files.pythonhosted.org/packages/fc/97/e1d5dbbfa170725ef78357a9a0edc996b09ae4af170927ba8ce977e60a5f/contourpy-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d14f12932a8d620e307f715857107b1d1845cc44fdb5da2bc8e850f5ceba9f87", size = 347331, upload_time = "2025-04-15T17:37:18.212Z" }, - { url = "https://files.pythonhosted.org/packages/6f/66/e69e6e904f5ecf6901be3dd16e7e54d41b6ec6ae3405a535286d4418ffb4/contourpy-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:532fd26e715560721bb0d5fc7610fce279b3699b018600ab999d1be895b09415", size = 318963, upload_time = "2025-04-15T17:37:22.76Z" }, - { url = "https://files.pythonhosted.org/packages/a8/32/b8a1c8965e4f72482ff2d1ac2cd670ce0b542f203c8e1d34e7c3e6925da7/contourpy-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b383144cf2d2c29f01a1e8170f50dacf0eac02d64139dcd709a8ac4eb3cfe", size = 323681, upload_time = "2025-04-15T17:37:33.001Z" }, - { url = "https://files.pythonhosted.org/packages/30/c6/12a7e6811d08757c7162a541ca4c5c6a34c0f4e98ef2b338791093518e40/contourpy-1.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c49f73e61f1f774650a55d221803b101d966ca0c5a2d6d5e4320ec3997489441", size = 1308674, upload_time = "2025-04-15T17:37:48.64Z" }, - { url = "https://files.pythonhosted.org/packages/2a/8a/bebe5a3f68b484d3a2b8ffaf84704b3e343ef1addea528132ef148e22b3b/contourpy-1.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d80b2c0300583228ac98d0a927a1ba6a2ba6b8a742463c564f1d419ee5b211e", size = 1380480, upload_time = "2025-04-15T17:38:06.7Z" }, - { url = "https://files.pythonhosted.org/packages/34/db/fcd325f19b5978fb509a7d55e06d99f5f856294c1991097534360b307cf1/contourpy-1.3.2-cp312-cp312-win32.whl", hash = "sha256:90df94c89a91b7362e1142cbee7568f86514412ab8a2c0d0fca72d7e91b62912", size = 178489, upload_time = "2025-04-15T17:38:10.338Z" }, - { url = "https://files.pythonhosted.org/packages/01/c8/fadd0b92ffa7b5eb5949bf340a63a4a496a6930a6c37a7ba0f12acb076d6/contourpy-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c942a01d9163e2e5cfb05cb66110121b8d07ad438a17f9e766317bcb62abf73", size = 223042, upload_time = "2025-04-15T17:38:14.239Z" }, - { url = "https://files.pythonhosted.org/packages/2e/61/5673f7e364b31e4e7ef6f61a4b5121c5f170f941895912f773d95270f3a2/contourpy-1.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:de39db2604ae755316cb5967728f4bea92685884b1e767b7c24e983ef5f771cb", size = 271630, upload_time = "2025-04-15T17:38:19.142Z" }, - { url = "https://files.pythonhosted.org/packages/ff/66/a40badddd1223822c95798c55292844b7e871e50f6bfd9f158cb25e0bd39/contourpy-1.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f9e896f447c5c8618f1edb2bafa9a4030f22a575ec418ad70611450720b5b08", size = 255670, upload_time = "2025-04-15T17:38:23.688Z" }, - { url = "https://files.pythonhosted.org/packages/1e/c7/cf9fdee8200805c9bc3b148f49cb9482a4e3ea2719e772602a425c9b09f8/contourpy-1.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71e2bd4a1c4188f5c2b8d274da78faab884b59df20df63c34f74aa1813c4427c", size = 306694, upload_time = "2025-04-15T17:38:28.238Z" }, - { url = "https://files.pythonhosted.org/packages/dd/e7/ccb9bec80e1ba121efbffad7f38021021cda5be87532ec16fd96533bb2e0/contourpy-1.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de425af81b6cea33101ae95ece1f696af39446db9682a0b56daaa48cfc29f38f", size = 345986, upload_time = "2025-04-15T17:38:33.502Z" }, - { url = "https://files.pythonhosted.org/packages/dc/49/ca13bb2da90391fa4219fdb23b078d6065ada886658ac7818e5441448b78/contourpy-1.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:977e98a0e0480d3fe292246417239d2d45435904afd6d7332d8455981c408b85", size = 318060, upload_time = "2025-04-15T17:38:38.672Z" }, - { url = "https://files.pythonhosted.org/packages/c8/65/5245ce8c548a8422236c13ffcdcdada6a2a812c361e9e0c70548bb40b661/contourpy-1.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:434f0adf84911c924519d2b08fc10491dd282b20bdd3fa8f60fd816ea0b48841", size = 322747, upload_time = "2025-04-15T17:38:43.712Z" }, - { url = "https://files.pythonhosted.org/packages/72/30/669b8eb48e0a01c660ead3752a25b44fdb2e5ebc13a55782f639170772f9/contourpy-1.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c66c4906cdbc50e9cba65978823e6e00b45682eb09adbb78c9775b74eb222422", size = 1308895, upload_time = "2025-04-15T17:39:00.224Z" }, - { url = "https://files.pythonhosted.org/packages/05/5a/b569f4250decee6e8d54498be7bdf29021a4c256e77fe8138c8319ef8eb3/contourpy-1.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8b7fc0cd78ba2f4695fd0a6ad81a19e7e3ab825c31b577f384aa9d7817dc3bef", size = 1379098, upload_time = "2025-04-15T17:43:29.649Z" }, - { url = "https://files.pythonhosted.org/packages/19/ba/b227c3886d120e60e41b28740ac3617b2f2b971b9f601c835661194579f1/contourpy-1.3.2-cp313-cp313-win32.whl", hash = "sha256:15ce6ab60957ca74cff444fe66d9045c1fd3e92c8936894ebd1f3eef2fff075f", size = 178535, upload_time = "2025-04-15T17:44:44.532Z" }, - { url = "https://files.pythonhosted.org/packages/12/6e/2fed56cd47ca739b43e892707ae9a13790a486a3173be063681ca67d2262/contourpy-1.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e1578f7eafce927b168752ed7e22646dad6cd9bca673c60bff55889fa236ebf9", size = 223096, upload_time = "2025-04-15T17:44:48.194Z" }, - { url = "https://files.pythonhosted.org/packages/54/4c/e76fe2a03014a7c767d79ea35c86a747e9325537a8b7627e0e5b3ba266b4/contourpy-1.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0475b1f6604896bc7c53bb070e355e9321e1bc0d381735421a2d2068ec56531f", size = 285090, upload_time = "2025-04-15T17:43:34.084Z" }, - { url = "https://files.pythonhosted.org/packages/7b/e2/5aba47debd55d668e00baf9651b721e7733975dc9fc27264a62b0dd26eb8/contourpy-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c85bb486e9be652314bb5b9e2e3b0d1b2e643d5eec4992c0fbe8ac71775da739", size = 268643, upload_time = "2025-04-15T17:43:38.626Z" }, - { url = "https://files.pythonhosted.org/packages/a1/37/cd45f1f051fe6230f751cc5cdd2728bb3a203f5619510ef11e732109593c/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:745b57db7758f3ffc05a10254edd3182a2a83402a89c00957a8e8a22f5582823", size = 310443, upload_time = "2025-04-15T17:43:44.522Z" }, - { url = "https://files.pythonhosted.org/packages/8b/a2/36ea6140c306c9ff6dd38e3bcec80b3b018474ef4d17eb68ceecd26675f4/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:970e9173dbd7eba9b4e01aab19215a48ee5dd3f43cef736eebde064a171f89a5", size = 349865, upload_time = "2025-04-15T17:43:49.545Z" }, - { url = "https://files.pythonhosted.org/packages/95/b7/2fc76bc539693180488f7b6cc518da7acbbb9e3b931fd9280504128bf956/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6c4639a9c22230276b7bffb6a850dfc8258a2521305e1faefe804d006b2e532", size = 321162, upload_time = "2025-04-15T17:43:54.203Z" }, - { url = "https://files.pythonhosted.org/packages/f4/10/76d4f778458b0aa83f96e59d65ece72a060bacb20cfbee46cf6cd5ceba41/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc829960f34ba36aad4302e78eabf3ef16a3a100863f0d4eeddf30e8a485a03b", size = 327355, upload_time = "2025-04-15T17:44:01.025Z" }, - { url = "https://files.pythonhosted.org/packages/43/a3/10cf483ea683f9f8ab096c24bad3cce20e0d1dd9a4baa0e2093c1c962d9d/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d32530b534e986374fc19eaa77fcb87e8a99e5431499949b828312bdcd20ac52", size = 1307935, upload_time = "2025-04-15T17:44:17.322Z" }, - { url = "https://files.pythonhosted.org/packages/78/73/69dd9a024444489e22d86108e7b913f3528f56cfc312b5c5727a44188471/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e298e7e70cf4eb179cc1077be1c725b5fd131ebc81181bf0c03525c8abc297fd", size = 1372168, upload_time = "2025-04-15T17:44:33.43Z" }, - { url = "https://files.pythonhosted.org/packages/0f/1b/96d586ccf1b1a9d2004dd519b25fbf104a11589abfd05484ff12199cca21/contourpy-1.3.2-cp313-cp313t-win32.whl", hash = "sha256:d0e589ae0d55204991450bb5c23f571c64fe43adaa53f93fc902a84c96f52fe1", size = 189550, upload_time = "2025-04-15T17:44:37.092Z" }, - { url = "https://files.pythonhosted.org/packages/b0/e6/6000d0094e8a5e32ad62591c8609e269febb6e4db83a1c75ff8868b42731/contourpy-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:78e9253c3de756b3f6a5174d024c4835acd59eb3f8e2ca13e775dbffe1558f69", size = 238214, upload_time = "2025-04-15T17:44:40.827Z" }, - { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload_time = "2025-04-15T17:44:59.314Z" }, - { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload_time = "2025-04-15T17:45:04.165Z" }, - { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload_time = "2025-04-15T17:45:08.456Z" }, - { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload_time = "2025-04-15T17:45:15.535Z" }, - { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload_time = "2025-04-15T17:45:20.166Z" }, - { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload_time = "2025-04-15T17:45:24.794Z" }, -] - -[[package]] -name = "cryptography" -version = "45.0.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/95/1e/49527ac611af559665f71cbb8f92b332b5ec9c6fbc4e88b0f8e92f5e85df/cryptography-45.0.5.tar.gz", hash = "sha256:72e76caa004ab63accdf26023fccd1d087f6d90ec6048ff33ad0445abf7f605a", size = 744903, upload_time = "2025-07-02T13:06:25.941Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f0/fb/09e28bc0c46d2c547085e60897fea96310574c70fb21cd58a730a45f3403/cryptography-45.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:101ee65078f6dd3e5a028d4f19c07ffa4dd22cce6a20eaa160f8b5219911e7d8", size = 7043092, upload_time = "2025-07-02T13:05:01.514Z" }, - { url = "https://files.pythonhosted.org/packages/b1/05/2194432935e29b91fb649f6149c1a4f9e6d3d9fc880919f4ad1bcc22641e/cryptography-45.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3a264aae5f7fbb089dbc01e0242d3b67dffe3e6292e1f5182122bdf58e65215d", size = 4205926, upload_time = "2025-07-02T13:05:04.741Z" }, - { url = "https://files.pythonhosted.org/packages/07/8b/9ef5da82350175e32de245646b1884fc01124f53eb31164c77f95a08d682/cryptography-45.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e74d30ec9c7cb2f404af331d5b4099a9b322a8a6b25c4632755c8757345baac5", size = 4429235, upload_time = "2025-07-02T13:05:07.084Z" }, - { url = "https://files.pythonhosted.org/packages/7c/e1/c809f398adde1994ee53438912192d92a1d0fc0f2d7582659d9ef4c28b0c/cryptography-45.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:3af26738f2db354aafe492fb3869e955b12b2ef2e16908c8b9cb928128d42c57", size = 4209785, upload_time = "2025-07-02T13:05:09.321Z" }, - { url = "https://files.pythonhosted.org/packages/d0/8b/07eb6bd5acff58406c5e806eff34a124936f41a4fb52909ffa4d00815f8c/cryptography-45.0.5-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e6c00130ed423201c5bc5544c23359141660b07999ad82e34e7bb8f882bb78e0", size = 3893050, upload_time = "2025-07-02T13:05:11.069Z" }, - { url = "https://files.pythonhosted.org/packages/ec/ef/3333295ed58d900a13c92806b67e62f27876845a9a908c939f040887cca9/cryptography-45.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:dd420e577921c8c2d31289536c386aaa30140b473835e97f83bc71ea9d2baf2d", size = 4457379, upload_time = "2025-07-02T13:05:13.32Z" }, - { url = "https://files.pythonhosted.org/packages/d9/9d/44080674dee514dbb82b21d6fa5d1055368f208304e2ab1828d85c9de8f4/cryptography-45.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:d05a38884db2ba215218745f0781775806bde4f32e07b135348355fe8e4991d9", size = 4209355, upload_time = "2025-07-02T13:05:15.017Z" }, - { url = "https://files.pythonhosted.org/packages/c9/d8/0749f7d39f53f8258e5c18a93131919ac465ee1f9dccaf1b3f420235e0b5/cryptography-45.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:ad0caded895a00261a5b4aa9af828baede54638754b51955a0ac75576b831b27", size = 4456087, upload_time = "2025-07-02T13:05:16.945Z" }, - { url = "https://files.pythonhosted.org/packages/09/d7/92acac187387bf08902b0bf0699816f08553927bdd6ba3654da0010289b4/cryptography-45.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9024beb59aca9d31d36fcdc1604dd9bbeed0a55bface9f1908df19178e2f116e", size = 4332873, upload_time = "2025-07-02T13:05:18.743Z" }, - { url = "https://files.pythonhosted.org/packages/03/c2/840e0710da5106a7c3d4153c7215b2736151bba60bf4491bdb421df5056d/cryptography-45.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:91098f02ca81579c85f66df8a588c78f331ca19089763d733e34ad359f474174", size = 4564651, upload_time = "2025-07-02T13:05:21.382Z" }, - { url = "https://files.pythonhosted.org/packages/2e/92/cc723dd6d71e9747a887b94eb3827825c6c24b9e6ce2bb33b847d31d5eaa/cryptography-45.0.5-cp311-abi3-win32.whl", hash = "sha256:926c3ea71a6043921050eaa639137e13dbe7b4ab25800932a8498364fc1abec9", size = 2929050, upload_time = "2025-07-02T13:05:23.39Z" }, - { url = "https://files.pythonhosted.org/packages/1f/10/197da38a5911a48dd5389c043de4aec4b3c94cb836299b01253940788d78/cryptography-45.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:b85980d1e345fe769cfc57c57db2b59cff5464ee0c045d52c0df087e926fbe63", size = 3403224, upload_time = "2025-07-02T13:05:25.202Z" }, - { url = "https://files.pythonhosted.org/packages/fe/2b/160ce8c2765e7a481ce57d55eba1546148583e7b6f85514472b1d151711d/cryptography-45.0.5-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f3562c2f23c612f2e4a6964a61d942f891d29ee320edb62ff48ffb99f3de9ae8", size = 7017143, upload_time = "2025-07-02T13:05:27.229Z" }, - { url = "https://files.pythonhosted.org/packages/c2/e7/2187be2f871c0221a81f55ee3105d3cf3e273c0a0853651d7011eada0d7e/cryptography-45.0.5-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3fcfbefc4a7f332dece7272a88e410f611e79458fab97b5efe14e54fe476f4fd", size = 4197780, upload_time = "2025-07-02T13:05:29.299Z" }, - { url = "https://files.pythonhosted.org/packages/b9/cf/84210c447c06104e6be9122661159ad4ce7a8190011669afceeaea150524/cryptography-45.0.5-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:460f8c39ba66af7db0545a8c6f2eabcbc5a5528fc1cf6c3fa9a1e44cec33385e", size = 4420091, upload_time = "2025-07-02T13:05:31.221Z" }, - { url = "https://files.pythonhosted.org/packages/3e/6a/cb8b5c8bb82fafffa23aeff8d3a39822593cee6e2f16c5ca5c2ecca344f7/cryptography-45.0.5-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:9b4cf6318915dccfe218e69bbec417fdd7c7185aa7aab139a2c0beb7468c89f0", size = 4198711, upload_time = "2025-07-02T13:05:33.062Z" }, - { url = "https://files.pythonhosted.org/packages/04/f7/36d2d69df69c94cbb2473871926daf0f01ad8e00fe3986ac3c1e8c4ca4b3/cryptography-45.0.5-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2089cc8f70a6e454601525e5bf2779e665d7865af002a5dec8d14e561002e135", size = 3883299, upload_time = "2025-07-02T13:05:34.94Z" }, - { url = "https://files.pythonhosted.org/packages/82/c7/f0ea40f016de72f81288e9fe8d1f6748036cb5ba6118774317a3ffc6022d/cryptography-45.0.5-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0027d566d65a38497bc37e0dd7c2f8ceda73597d2ac9ba93810204f56f52ebc7", size = 4450558, upload_time = "2025-07-02T13:05:37.288Z" }, - { url = "https://files.pythonhosted.org/packages/06/ae/94b504dc1a3cdf642d710407c62e86296f7da9e66f27ab12a1ee6fdf005b/cryptography-45.0.5-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:be97d3a19c16a9be00edf79dca949c8fa7eff621763666a145f9f9535a5d7f42", size = 4198020, upload_time = "2025-07-02T13:05:39.102Z" }, - { url = "https://files.pythonhosted.org/packages/05/2b/aaf0adb845d5dabb43480f18f7ca72e94f92c280aa983ddbd0bcd6ecd037/cryptography-45.0.5-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:7760c1c2e1a7084153a0f68fab76e754083b126a47d0117c9ed15e69e2103492", size = 4449759, upload_time = "2025-07-02T13:05:41.398Z" }, - { url = "https://files.pythonhosted.org/packages/91/e4/f17e02066de63e0100a3a01b56f8f1016973a1d67551beaf585157a86b3f/cryptography-45.0.5-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6ff8728d8d890b3dda5765276d1bc6fb099252915a2cd3aff960c4c195745dd0", size = 4319991, upload_time = "2025-07-02T13:05:43.64Z" }, - { url = "https://files.pythonhosted.org/packages/f2/2e/e2dbd629481b499b14516eed933f3276eb3239f7cee2dcfa4ee6b44d4711/cryptography-45.0.5-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7259038202a47fdecee7e62e0fd0b0738b6daa335354396c6ddebdbe1206af2a", size = 4554189, upload_time = "2025-07-02T13:05:46.045Z" }, - { url = "https://files.pythonhosted.org/packages/f8/ea/a78a0c38f4c8736287b71c2ea3799d173d5ce778c7d6e3c163a95a05ad2a/cryptography-45.0.5-cp37-abi3-win32.whl", hash = "sha256:1e1da5accc0c750056c556a93c3e9cb828970206c68867712ca5805e46dc806f", size = 2911769, upload_time = "2025-07-02T13:05:48.329Z" }, - { url = "https://files.pythonhosted.org/packages/79/b3/28ac139109d9005ad3f6b6f8976ffede6706a6478e21c889ce36c840918e/cryptography-45.0.5-cp37-abi3-win_amd64.whl", hash = "sha256:90cb0a7bb35959f37e23303b7eed0a32280510030daba3f7fdfbb65defde6a97", size = 3390016, upload_time = "2025-07-02T13:05:50.811Z" }, - { url = "https://files.pythonhosted.org/packages/f8/8b/34394337abe4566848a2bd49b26bcd4b07fd466afd3e8cce4cb79a390869/cryptography-45.0.5-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:206210d03c1193f4e1ff681d22885181d47efa1ab3018766a7b32a7b3d6e6afd", size = 3575762, upload_time = "2025-07-02T13:05:53.166Z" }, - { url = "https://files.pythonhosted.org/packages/8b/5d/a19441c1e89afb0f173ac13178606ca6fab0d3bd3ebc29e9ed1318b507fc/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c648025b6840fe62e57107e0a25f604db740e728bd67da4f6f060f03017d5097", size = 4140906, upload_time = "2025-07-02T13:05:55.914Z" }, - { url = "https://files.pythonhosted.org/packages/4b/db/daceb259982a3c2da4e619f45b5bfdec0e922a23de213b2636e78ef0919b/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b8fa8b0a35a9982a3c60ec79905ba5bb090fc0b9addcfd3dc2dd04267e45f25e", size = 4374411, upload_time = "2025-07-02T13:05:57.814Z" }, - { url = "https://files.pythonhosted.org/packages/6a/35/5d06ad06402fc522c8bf7eab73422d05e789b4e38fe3206a85e3d6966c11/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:14d96584701a887763384f3c47f0ca7c1cce322aa1c31172680eb596b890ec30", size = 4140942, upload_time = "2025-07-02T13:06:00.137Z" }, - { url = "https://files.pythonhosted.org/packages/65/79/020a5413347e44c382ef1f7f7e7a66817cd6273e3e6b5a72d18177b08b2f/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:57c816dfbd1659a367831baca4b775b2a5b43c003daf52e9d57e1d30bc2e1b0e", size = 4374079, upload_time = "2025-07-02T13:06:02.043Z" }, - { url = "https://files.pythonhosted.org/packages/9b/c5/c0e07d84a9a2a8a0ed4f865e58f37c71af3eab7d5e094ff1b21f3f3af3bc/cryptography-45.0.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b9e38e0a83cd51e07f5a48ff9691cae95a79bea28fe4ded168a8e5c6c77e819d", size = 3321362, upload_time = "2025-07-02T13:06:04.463Z" }, - { url = "https://files.pythonhosted.org/packages/c0/71/9bdbcfd58d6ff5084687fe722c58ac718ebedbc98b9f8f93781354e6d286/cryptography-45.0.5-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:8c4a6ff8a30e9e3d38ac0539e9a9e02540ab3f827a3394f8852432f6b0ea152e", size = 3587878, upload_time = "2025-07-02T13:06:06.339Z" }, - { url = "https://files.pythonhosted.org/packages/f0/63/83516cfb87f4a8756eaa4203f93b283fda23d210fc14e1e594bd5f20edb6/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bd4c45986472694e5121084c6ebbd112aa919a25e783b87eb95953c9573906d6", size = 4152447, upload_time = "2025-07-02T13:06:08.345Z" }, - { url = "https://files.pythonhosted.org/packages/22/11/d2823d2a5a0bd5802b3565437add16f5c8ce1f0778bf3822f89ad2740a38/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:982518cd64c54fcada9d7e5cf28eabd3ee76bd03ab18e08a48cad7e8b6f31b18", size = 4386778, upload_time = "2025-07-02T13:06:10.263Z" }, - { url = "https://files.pythonhosted.org/packages/5f/38/6bf177ca6bce4fe14704ab3e93627c5b0ca05242261a2e43ef3168472540/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:12e55281d993a793b0e883066f590c1ae1e802e3acb67f8b442e721e475e6463", size = 4151627, upload_time = "2025-07-02T13:06:13.097Z" }, - { url = "https://files.pythonhosted.org/packages/38/6a/69fc67e5266bff68a91bcb81dff8fb0aba4d79a78521a08812048913e16f/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:5aa1e32983d4443e310f726ee4b071ab7569f58eedfdd65e9675484a4eb67bd1", size = 4385593, upload_time = "2025-07-02T13:06:15.689Z" }, - { url = "https://files.pythonhosted.org/packages/f6/34/31a1604c9a9ade0fdab61eb48570e09a796f4d9836121266447b0eaf7feb/cryptography-45.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e357286c1b76403dd384d938f93c46b2b058ed4dfcdce64a770f0537ed3feb6f", size = 3331106, upload_time = "2025-07-02T13:06:18.058Z" }, -] - -[[package]] -name = "customtkinter" -version = "5.2.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "darkdetect" }, - { name = "packaging" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/cf/48/c5a9d44188c44702e1e3db493c741e9c779596835a761b819fe15431d163/customtkinter-5.2.2.tar.gz", hash = "sha256:fd8db3bafa961c982ee6030dba80b4c2e25858630756b513986db19113d8d207", size = 261999, upload_time = "2024-01-10T02:24:36.314Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/b1/b43b33001a77256b335511e75f257d001082350b8506c8807f30c98db052/customtkinter-5.2.2-py3-none-any.whl", hash = "sha256:14ad3e7cd3cb3b9eb642b9d4e8711ae80d3f79fb82545ad11258eeffb2e6b37c", size = 296062, upload_time = "2024-01-10T02:24:33.53Z" }, -] - -[[package]] -name = "cycler" -version = "0.12.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload_time = "2023-10-07T05:32:18.335Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload_time = "2023-10-07T05:32:16.783Z" }, -] - -[[package]] -name = "darkdetect" -version = "0.8.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/45/77/7575be73bf12dee231d0c6e60ce7fb7a7be4fcd58823374fc59a6e48262e/darkdetect-0.8.0.tar.gz", hash = "sha256:b5428e1170263eb5dea44c25dc3895edd75e6f52300986353cd63533fe7df8b1", size = 7681, upload_time = "2022-12-16T14:14:42.113Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f2/f2/728f041460f1b9739b85ee23b45fa5a505962ea11fd85bdbe2a02b021373/darkdetect-0.8.0-py3-none-any.whl", hash = "sha256:a7509ccf517eaad92b31c214f593dbcf138ea8a43b2935406bbd565e15527a85", size = 8955, upload_time = "2022-12-16T14:14:40.92Z" }, -] - -[[package]] -name = "distro" -version = "1.9.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload_time = "2023-12-24T09:54:32.31Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload_time = "2023-12-24T09:54:30.421Z" }, -] - -[[package]] -name = "dnspython" -version = "2.7.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b5/4a/263763cb2ba3816dd94b08ad3a33d5fdae34ecb856678773cc40a3605829/dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1", size = 345197, upload_time = "2024-10-05T20:14:59.362Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/68/1b/e0a87d256e40e8c888847551b20a017a6b98139178505dc7ffb96f04e954/dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86", size = 313632, upload_time = "2024-10-05T20:14:57.687Z" }, -] - -[[package]] -name = "dotenv" -version = "0.9.9" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "python-dotenv" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892, upload_time = "2025-02-19T22:15:01.647Z" }, -] - -[[package]] -name = "exceptiongroup" -version = "1.3.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload_time = "2025-05-10T17:42:51.123Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload_time = "2025-05-10T17:42:49.33Z" }, -] - -[[package]] -name = "faiss-cpu" -version = "1.11.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "packaging" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e7/9a/e33fc563f007924dd4ec3c5101fe5320298d6c13c158a24a9ed849058569/faiss_cpu-1.11.0.tar.gz", hash = "sha256:44877b896a2b30a61e35ea4970d008e8822545cb340eca4eff223ac7f40a1db9", size = 70218, upload_time = "2025-04-28T07:48:30.459Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ed/e5/7490368ec421e44efd60a21aa88d244653c674d8d6ee6bc455d8ee3d02ed/faiss_cpu-1.11.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:1995119152928c68096b0c1e5816e3ee5b1eebcf615b80370874523be009d0f6", size = 3307996, upload_time = "2025-04-28T07:47:29.126Z" }, - { url = "https://files.pythonhosted.org/packages/dd/ac/a94fbbbf4f38c2ad11862af92c071ff346630ebf33f3d36fe75c3817c2f0/faiss_cpu-1.11.0-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:788d7bf24293fdecc1b93f1414ca5cc62ebd5f2fecfcbb1d77f0e0530621c95d", size = 7886309, upload_time = "2025-04-28T07:47:31.668Z" }, - { url = "https://files.pythonhosted.org/packages/63/48/ad79f34f1b9eba58c32399ad4fbedec3f2a717d72fb03648e906aab48a52/faiss_cpu-1.11.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:73408d52429558f67889581c0c6d206eedcf6fabe308908f2bdcd28fd5e8be4a", size = 3778443, upload_time = "2025-04-28T07:47:33.685Z" }, - { url = "https://files.pythonhosted.org/packages/95/67/3c6b94dd3223a8ecaff1c10c11b4ac6f3f13f1ba8ab6b6109c24b6e9b23d/faiss_cpu-1.11.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:1f53513682ca94c76472544fa5f071553e428a1453e0b9755c9673f68de45f12", size = 31295174, upload_time = "2025-04-28T07:47:36.309Z" }, - { url = "https://files.pythonhosted.org/packages/a4/2c/d843256aabdb7f20f0f87f61efe3fb7c2c8e7487915f560ba523cfcbab57/faiss_cpu-1.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:30489de0356d3afa0b492ca55da164d02453db2f7323c682b69334fde9e8d48e", size = 15003860, upload_time = "2025-04-28T07:47:39.381Z" }, - { url = "https://files.pythonhosted.org/packages/ed/83/8aefc4d07624a868e046cc23ede8a59bebda57f09f72aee2150ef0855a82/faiss_cpu-1.11.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a90d1c81d0ecf2157e1d2576c482d734d10760652a5b2fcfa269916611e41f1c", size = 3307997, upload_time = "2025-04-28T07:47:41.905Z" }, - { url = "https://files.pythonhosted.org/packages/2b/64/f97e91d89dc6327e08f619fe387d7d9945bc4be3b0f1ca1e494a41c92ebe/faiss_cpu-1.11.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:2c39a388b059fb82cd97fbaa7310c3580ced63bf285be531453bfffbe89ea3dd", size = 7886308, upload_time = "2025-04-28T07:47:44.677Z" }, - { url = "https://files.pythonhosted.org/packages/44/0a/7c17b6df017b0bc127c6aa4066b028281e67ab83d134c7433c4e75cd6bb6/faiss_cpu-1.11.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a4e3433ffc7f9b8707a7963db04f8676a5756868d325644db2db9d67a618b7a0", size = 3778441, upload_time = "2025-04-28T07:47:46.914Z" }, - { url = "https://files.pythonhosted.org/packages/53/45/7c85551025d9f0237d891b5cffdc5d4a366011d53b4b0a423b972cc52cea/faiss_cpu-1.11.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:926645f1b6829623bc88e93bc8ca872504d604718ada3262e505177939aaee0a", size = 31295136, upload_time = "2025-04-28T07:47:49.299Z" }, - { url = "https://files.pythonhosted.org/packages/7f/9a/accade34b8668b21206c0c4cf0b96cd0b750b693ba5b255c1c10cfee460f/faiss_cpu-1.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:931db6ed2197c03a7fdf833b057c13529afa2cec8a827aa081b7f0543e4e671b", size = 15003710, upload_time = "2025-04-28T07:47:52.226Z" }, - { url = "https://files.pythonhosted.org/packages/3b/d3/7178fa07047fd770964a83543329bb5e3fc1447004cfd85186ccf65ec3ee/faiss_cpu-1.11.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:356437b9a46f98c25831cdae70ca484bd6c05065af6256d87f6505005e9135b9", size = 3313807, upload_time = "2025-04-28T07:47:54.533Z" }, - { url = "https://files.pythonhosted.org/packages/9e/71/25f5f7b70a9f22a3efe19e7288278da460b043a3b60ad98e4e47401ed5aa/faiss_cpu-1.11.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:c4a3d35993e614847f3221c6931529c0bac637a00eff0d55293e1db5cb98c85f", size = 7913537, upload_time = "2025-04-28T07:47:56.723Z" }, - { url = "https://files.pythonhosted.org/packages/b0/c8/a5cb8466c981ad47750e1d5fda3d4223c82f9da947538749a582b3a2d35c/faiss_cpu-1.11.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:8f9af33e0b8324e8199b93eb70ac4a951df02802a9dcff88e9afc183b11666f0", size = 3785180, upload_time = "2025-04-28T07:47:59.004Z" }, - { url = "https://files.pythonhosted.org/packages/7f/37/eaf15a7d80e1aad74f56cf737b31b4547a1a664ad3c6e4cfaf90e82454a8/faiss_cpu-1.11.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:48b7e7876829e6bdf7333041800fa3c1753bb0c47e07662e3ef55aca86981430", size = 31287630, upload_time = "2025-04-28T07:48:01.248Z" }, - { url = "https://files.pythonhosted.org/packages/ff/5c/902a78347e9c47baaf133e47863134e564c39f9afe105795b16ee986b0df/faiss_cpu-1.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:bdc199311266d2be9d299da52361cad981393327b2b8aa55af31a1b75eaaf522", size = 15005398, upload_time = "2025-04-28T07:48:04.232Z" }, - { url = "https://files.pythonhosted.org/packages/92/90/d2329ce56423cc61f4c20ae6b4db001c6f88f28bf5a7ef7f8bbc246fd485/faiss_cpu-1.11.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:0c98e5feff83b87348e44eac4d578d6f201780dae6f27f08a11d55536a20b3a8", size = 3313807, upload_time = "2025-04-28T07:48:06.486Z" }, - { url = "https://files.pythonhosted.org/packages/24/14/8af8f996d54e6097a86e6048b1a2c958c52dc985eb4f935027615079939e/faiss_cpu-1.11.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:796e90389427b1c1fb06abdb0427bb343b6350f80112a2e6090ac8f176ff7416", size = 7913539, upload_time = "2025-04-28T07:48:08.338Z" }, - { url = "https://files.pythonhosted.org/packages/b2/2b/437c2f36c3aa3cffe041479fced1c76420d3e92e1f434f1da3be3e6f32b1/faiss_cpu-1.11.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:2b6e355dda72b3050991bc32031b558b8f83a2b3537a2b9e905a84f28585b47e", size = 3785181, upload_time = "2025-04-28T07:48:10.594Z" }, - { url = "https://files.pythonhosted.org/packages/66/75/955527414371843f558234df66fa0b62c6e86e71e4022b1be9333ac6004c/faiss_cpu-1.11.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6c482d07194638c169b4422774366e7472877d09181ea86835e782e6304d4185", size = 31287635, upload_time = "2025-04-28T07:48:12.93Z" }, - { url = "https://files.pythonhosted.org/packages/50/51/35b7a3f47f7859363a367c344ae5d415ea9eda65db0a7d497c7ea2c0b576/faiss_cpu-1.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:13eac45299532b10e911bff1abbb19d1bf5211aa9e72afeade653c3f1e50e042", size = 15005455, upload_time = "2025-04-28T07:48:16.173Z" }, -] - -[[package]] -name = "fastapi" -version = "0.116.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic" }, - { name = "starlette" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/20/38/e1da78736143fd885c36213a3ccc493c384ae8fea6a0f0bc272ef42ebea8/fastapi-0.116.0.tar.gz", hash = "sha256:80dc0794627af0390353a6d1171618276616310d37d24faba6648398e57d687a", size = 296518, upload_time = "2025-07-07T15:09:27.82Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2f/68/d80347fe2360445b5f58cf290e588a4729746e7501080947e6cdae114b1f/fastapi-0.116.0-py3-none-any.whl", hash = "sha256:fdcc9ed272eaef038952923bef2b735c02372402d1203ee1210af4eea7a78d2b", size = 95625, upload_time = "2025-07-07T15:09:26.348Z" }, -] - -[[package]] -name = "fonttools" -version = "4.58.5" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/52/97/5735503e58d3816b0989955ef9b2df07e4c99b246469bd8b3823a14095da/fonttools-4.58.5.tar.gz", hash = "sha256:b2a35b0a19f1837284b3a23dd64fd7761b8911d50911ecd2bdbaf5b2d1b5df9c", size = 3526243, upload_time = "2025-07-03T14:04:47.736Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/cd/d2a50d9e9e9f01491993acd557051a05b0bbe57eb47710c6381dca741ac9/fonttools-4.58.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d500d399aa4e92d969a0d21052696fa762385bb23c3e733703af4a195ad9f34c", size = 2749015, upload_time = "2025-07-03T14:03:15.683Z" }, - { url = "https://files.pythonhosted.org/packages/ee/5e/8f9a4781f79042b2efb68a1636b9013c54f80311dbbc05e6a4bacdaf7661/fonttools-4.58.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b00530b84f87792891874938bd42f47af2f7f4c2a1d70466e6eb7166577853ab", size = 2319224, upload_time = "2025-07-03T14:03:18.627Z" }, - { url = "https://files.pythonhosted.org/packages/51/87/dddb6c9b4af1f49b100e3ec84d45c769947fd8e58943d35a58f27aa017b0/fonttools-4.58.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5579fb3744dfec151b5c29b35857df83e01f06fe446e8c2ebaf1effd7e6cdce", size = 4839510, upload_time = "2025-07-03T14:03:22.785Z" }, - { url = "https://files.pythonhosted.org/packages/30/57/63fd49a3328e39e3f8868dd0b0f00370f4f40c4bd44a8478efad3338ebd9/fonttools-4.58.5-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adf440deecfcc2390998e649156e3bdd0b615863228c484732dc06ac04f57385", size = 4768294, upload_time = "2025-07-03T14:03:24.853Z" }, - { url = "https://files.pythonhosted.org/packages/84/1a/e943dfecf56b48d7e684be7c37749c48560461d14f480b4e7c42285976ce/fonttools-4.58.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a81769fc4d473c808310c9ed91fbe01b67f615e3196fb9773e093939f59e6783", size = 4820057, upload_time = "2025-07-03T14:03:26.939Z" }, - { url = "https://files.pythonhosted.org/packages/02/68/04e9dd0b711ca720f5473adde9325941c73faf947b771ea21fac9e3613c3/fonttools-4.58.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0162a6a37b0ca70d8505311d541e291cd6cab54d1a986ae3d2686c56c0581e8f", size = 4927299, upload_time = "2025-07-03T14:03:29.136Z" }, - { url = "https://files.pythonhosted.org/packages/80/82/9d36a24c47ae4b93377332343b4f018c965e9c4835bbebaed951f99784d0/fonttools-4.58.5-cp310-cp310-win32.whl", hash = "sha256:1cde303422198fdc7f502dbdf1bf65306166cdb9446debd6c7fb826b4d66a530", size = 2203042, upload_time = "2025-07-03T14:03:31.139Z" }, - { url = "https://files.pythonhosted.org/packages/b7/d1/c2c3582d575ef901cad6cfbe77aa5396debd652f51bf32b6963245f00dfa/fonttools-4.58.5-cp310-cp310-win_amd64.whl", hash = "sha256:75cf8c2812c898dd3d70d62b2b768df4eeb524a83fb987a512ddb3863d6a8c54", size = 2247338, upload_time = "2025-07-03T14:03:33.24Z" }, - { url = "https://files.pythonhosted.org/packages/14/50/26c683bf6f30dcbde6955c8e07ec6af23764aab86ff06b36383654ab6739/fonttools-4.58.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:cda226253bf14c559bc5a17c570d46abd70315c9a687d91c0e01147f87736182", size = 2769557, upload_time = "2025-07-03T14:03:35.383Z" }, - { url = "https://files.pythonhosted.org/packages/b1/00/c3c75fb6196b9ff9988e6a82319ae23f4ae7098e1c01e2408e58d2e7d9c7/fonttools-4.58.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:83a96e4a4e65efd6c098da549ec34f328f08963acd2d7bc910ceba01d2dc73e6", size = 2329367, upload_time = "2025-07-03T14:03:37.322Z" }, - { url = "https://files.pythonhosted.org/packages/59/e9/6946366c8e88650c199da9b284559de5d47a6e66ed6d175a166953347959/fonttools-4.58.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d172b92dff59ef8929b4452d5a7b19b8e92081aa87bfb2d82b03b1ff14fc667", size = 5019491, upload_time = "2025-07-03T14:03:39.759Z" }, - { url = "https://files.pythonhosted.org/packages/76/12/2f3f7d09bba7a93bd48dcb54b170fba665f0b7e80e959ac831b907d40785/fonttools-4.58.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0bfddfd09aafbbfb3bd98ae67415fbe51eccd614c17db0c8844fe724fbc5d43d", size = 4961579, upload_time = "2025-07-03T14:03:41.611Z" }, - { url = "https://files.pythonhosted.org/packages/2c/95/87e84071189e51c714074646dfac8275b2e9c6b2b118600529cc74f7451e/fonttools-4.58.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cfde5045f1bc92ad11b4b7551807564045a1b38cb037eb3c2bc4e737cd3a8d0f", size = 4997792, upload_time = "2025-07-03T14:03:44.529Z" }, - { url = "https://files.pythonhosted.org/packages/73/47/5c4df7473ecbeb8aa4e01373e4f614ca33f53227fe13ae673c6d5ca99be7/fonttools-4.58.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3515ac47a9a5ac025d2899d195198314023d89492340ba86e4ba79451f7518a8", size = 5109361, upload_time = "2025-07-03T14:03:46.693Z" }, - { url = "https://files.pythonhosted.org/packages/06/00/31406853c570210232b845e08e5a566e15495910790381566ffdbdc7f9a2/fonttools-4.58.5-cp311-cp311-win32.whl", hash = "sha256:9f7e2ab9c10b6811b4f12a0768661325a48e664ec0a0530232c1605896a598db", size = 2201369, upload_time = "2025-07-03T14:03:48.885Z" }, - { url = "https://files.pythonhosted.org/packages/c5/90/ac0facb57962cef53a5734d0be5d2f2936e55aa5c62647c38ca3497263d8/fonttools-4.58.5-cp311-cp311-win_amd64.whl", hash = "sha256:126c16ec4a672c9cb5c1c255dc438d15436b470afc8e9cac25a2d39dd2dc26eb", size = 2249021, upload_time = "2025-07-03T14:03:51.232Z" }, - { url = "https://files.pythonhosted.org/packages/d6/68/66b498ee66f3e7e92fd68476c2509508082b7f57d68c0cdb4b8573f44331/fonttools-4.58.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:c3af3fefaafb570a03051a0d6899b8374dcf8e6a4560e42575843aef33bdbad6", size = 2754751, upload_time = "2025-07-03T14:03:52.976Z" }, - { url = "https://files.pythonhosted.org/packages/f1/1e/edbc14b79290980c3944a1f43098624bc8965f534964aa03d52041f24cb4/fonttools-4.58.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:688137789dbd44e8757ad77b49a771539d8069195ffa9a8bcf18176e90bbd86d", size = 2322342, upload_time = "2025-07-03T14:03:54.957Z" }, - { url = "https://files.pythonhosted.org/packages/c1/d7/3c87cf147185d91c2e946460a5cf68c236427b4a23ab96793ccb7d8017c9/fonttools-4.58.5-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2af65836cf84cd7cb882d0b353bdc73643a497ce23b7414c26499bb8128ca1af", size = 4897011, upload_time = "2025-07-03T14:03:56.829Z" }, - { url = "https://files.pythonhosted.org/packages/a0/d6/fbb44cc85d4195fe54356658bd9f934328b4f74ae14addd90b4b5558b5c9/fonttools-4.58.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d2d79cfeb456bf438cb9fb87437634d4d6f228f27572ca5c5355e58472d5519d", size = 4942291, upload_time = "2025-07-03T14:03:59.204Z" }, - { url = "https://files.pythonhosted.org/packages/4d/c8/453f82e21aedf25cdc2ae619c03a73512398cec9bd8b6c3b1c571e0b6632/fonttools-4.58.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0feac9dda9a48a7a342a593f35d50a5cee2dbd27a03a4c4a5192834a4853b204", size = 4886824, upload_time = "2025-07-03T14:04:01.517Z" }, - { url = "https://files.pythonhosted.org/packages/40/54/e9190001b8e22d123f78925b2f508c866d9d18531694b979277ad45d59b0/fonttools-4.58.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36555230e168511e83ad8637232268649634b8dfff6ef58f46e1ebc057a041ad", size = 5038510, upload_time = "2025-07-03T14:04:03.917Z" }, - { url = "https://files.pythonhosted.org/packages/cf/9c/07cdad4774841a6304aabae939f8cbb9538cb1d8e97f5016b334da98e73a/fonttools-4.58.5-cp312-cp312-win32.whl", hash = "sha256:26ec05319353842d127bd02516eacb25b97ca83966e40e9ad6fab85cab0576f4", size = 2188459, upload_time = "2025-07-03T14:04:06.103Z" }, - { url = "https://files.pythonhosted.org/packages/0e/4d/1eaaad22781d55f49d1b184563842172aeb6a4fe53c029e503be81114314/fonttools-4.58.5-cp312-cp312-win_amd64.whl", hash = "sha256:778a632e538f82c1920579c0c01566a8f83dc24470c96efbf2fbac698907f569", size = 2236565, upload_time = "2025-07-03T14:04:08.27Z" }, - { url = "https://files.pythonhosted.org/packages/3a/ee/764dd8b99891f815241f449345863cfed9e546923d9cef463f37fd1d7168/fonttools-4.58.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f4b6f1360da13cecc88c0d60716145b31e1015fbe6a59e32f73a4404e2ea92cf", size = 2745867, upload_time = "2025-07-03T14:04:10.586Z" }, - { url = "https://files.pythonhosted.org/packages/e2/23/8fef484c02fef55e226dfeac4339a015c5480b6a496064058491759ac71e/fonttools-4.58.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a036822e915692aa2c03e2decc60f49a8190f8111b639c947a4f4e5774d0d7a", size = 2317933, upload_time = "2025-07-03T14:04:12.335Z" }, - { url = "https://files.pythonhosted.org/packages/ab/47/f92b135864fa777e11ad68420bf89446c91a572fe2782745586f8e6aac0c/fonttools-4.58.5-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6d7709fcf4577b0f294ee6327088884ca95046e1eccde87c53bbba4d5008541", size = 4877844, upload_time = "2025-07-03T14:04:14.58Z" }, - { url = "https://files.pythonhosted.org/packages/3e/65/6c1a83511d8ac32411930495645edb3f8dfabebcb78f08cf6009ba2585ec/fonttools-4.58.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b9b5099ca99b79d6d67162778b1b1616fc0e1de02c1a178248a0da8d78a33852", size = 4940106, upload_time = "2025-07-03T14:04:16.563Z" }, - { url = "https://files.pythonhosted.org/packages/fa/90/df8eb77d6cf266cbbba01866a1349a3e9121e0a63002cf8d6754e994f755/fonttools-4.58.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3f2c05a8d82a4d15aebfdb3506e90793aea16e0302cec385134dd960647a36c0", size = 4879458, upload_time = "2025-07-03T14:04:19.584Z" }, - { url = "https://files.pythonhosted.org/packages/26/b1/e32f8de51b7afcfea6ad62780da2fa73212c43a32cd8cafcc852189d7949/fonttools-4.58.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:79f0c4b1cc63839b61deeac646d8dba46f8ed40332c2ac1b9997281462c2e4ba", size = 5021917, upload_time = "2025-07-03T14:04:21.736Z" }, - { url = "https://files.pythonhosted.org/packages/89/72/578aa7fe32918dd763c62f447aaed672d665ee10e3eeb1725f4d6493fe96/fonttools-4.58.5-cp313-cp313-win32.whl", hash = "sha256:a1a9a2c462760976882131cbab7d63407813413a2d32cd699e86a1ff22bf7aa5", size = 2186827, upload_time = "2025-07-03T14:04:24.237Z" }, - { url = "https://files.pythonhosted.org/packages/71/a3/21e921b16cb9c029d3308e0cb79c9a937e9ff1fc1ee28c2419f0957b9e7c/fonttools-4.58.5-cp313-cp313-win_amd64.whl", hash = "sha256:bca61b14031a4b7dc87e14bf6ca34c275f8e4b9f7a37bc2fe746b532a924cf30", size = 2235706, upload_time = "2025-07-03T14:04:26.082Z" }, - { url = "https://files.pythonhosted.org/packages/d7/d4/1d85a1996b6188cd2713230e002d79a6f3a289bb17cef600cba385848b72/fonttools-4.58.5-py3-none-any.whl", hash = "sha256:e48a487ed24d9b611c5c4b25db1e50e69e9854ca2670e39a3486ffcd98863ec4", size = 1115318, upload_time = "2025-07-03T14:04:45.378Z" }, -] - -[[package]] -name = "frozenlist" -version = "1.7.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/79/b1/b64018016eeb087db503b038296fd782586432b9c077fc5c7839e9cb6ef6/frozenlist-1.7.0.tar.gz", hash = "sha256:2e310d81923c2437ea8670467121cc3e9b0f76d3043cc1d2331d56c7fb7a3a8f", size = 45078, upload_time = "2025-06-09T23:02:35.538Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/af/36/0da0a49409f6b47cc2d060dc8c9040b897b5902a8a4e37d9bc1deb11f680/frozenlist-1.7.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cc4df77d638aa2ed703b878dd093725b72a824c3c546c076e8fdf276f78ee84a", size = 81304, upload_time = "2025-06-09T22:59:46.226Z" }, - { url = "https://files.pythonhosted.org/packages/77/f0/77c11d13d39513b298e267b22eb6cb559c103d56f155aa9a49097221f0b6/frozenlist-1.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:716a9973a2cc963160394f701964fe25012600f3d311f60c790400b00e568b61", size = 47735, upload_time = "2025-06-09T22:59:48.133Z" }, - { url = "https://files.pythonhosted.org/packages/37/12/9d07fa18971a44150593de56b2f2947c46604819976784bcf6ea0d5db43b/frozenlist-1.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a0fd1bad056a3600047fb9462cff4c5322cebc59ebf5d0a3725e0ee78955001d", size = 46775, upload_time = "2025-06-09T22:59:49.564Z" }, - { url = "https://files.pythonhosted.org/packages/70/34/f73539227e06288fcd1f8a76853e755b2b48bca6747e99e283111c18bcd4/frozenlist-1.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3789ebc19cb811163e70fe2bd354cea097254ce6e707ae42e56f45e31e96cb8e", size = 224644, upload_time = "2025-06-09T22:59:51.35Z" }, - { url = "https://files.pythonhosted.org/packages/fb/68/c1d9c2f4a6e438e14613bad0f2973567586610cc22dcb1e1241da71de9d3/frozenlist-1.7.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:af369aa35ee34f132fcfad5be45fbfcde0e3a5f6a1ec0712857f286b7d20cca9", size = 222125, upload_time = "2025-06-09T22:59:52.884Z" }, - { url = "https://files.pythonhosted.org/packages/b9/d0/98e8f9a515228d708344d7c6986752be3e3192d1795f748c24bcf154ad99/frozenlist-1.7.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac64b6478722eeb7a3313d494f8342ef3478dff539d17002f849101b212ef97c", size = 233455, upload_time = "2025-06-09T22:59:54.74Z" }, - { url = "https://files.pythonhosted.org/packages/79/df/8a11bcec5600557f40338407d3e5bea80376ed1c01a6c0910fcfdc4b8993/frozenlist-1.7.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f89f65d85774f1797239693cef07ad4c97fdd0639544bad9ac4b869782eb1981", size = 227339, upload_time = "2025-06-09T22:59:56.187Z" }, - { url = "https://files.pythonhosted.org/packages/50/82/41cb97d9c9a5ff94438c63cc343eb7980dac4187eb625a51bdfdb7707314/frozenlist-1.7.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1073557c941395fdfcfac13eb2456cb8aad89f9de27bae29fabca8e563b12615", size = 212969, upload_time = "2025-06-09T22:59:57.604Z" }, - { url = "https://files.pythonhosted.org/packages/13/47/f9179ee5ee4f55629e4f28c660b3fdf2775c8bfde8f9c53f2de2d93f52a9/frozenlist-1.7.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ed8d2fa095aae4bdc7fdd80351009a48d286635edffee66bf865e37a9125c50", size = 222862, upload_time = "2025-06-09T22:59:59.498Z" }, - { url = "https://files.pythonhosted.org/packages/1a/52/df81e41ec6b953902c8b7e3a83bee48b195cb0e5ec2eabae5d8330c78038/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:24c34bea555fe42d9f928ba0a740c553088500377448febecaa82cc3e88aa1fa", size = 222492, upload_time = "2025-06-09T23:00:01.026Z" }, - { url = "https://files.pythonhosted.org/packages/84/17/30d6ea87fa95a9408245a948604b82c1a4b8b3e153cea596421a2aef2754/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:69cac419ac6a6baad202c85aaf467b65ac860ac2e7f2ac1686dc40dbb52f6577", size = 238250, upload_time = "2025-06-09T23:00:03.401Z" }, - { url = "https://files.pythonhosted.org/packages/8f/00/ecbeb51669e3c3df76cf2ddd66ae3e48345ec213a55e3887d216eb4fbab3/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:960d67d0611f4c87da7e2ae2eacf7ea81a5be967861e0c63cf205215afbfac59", size = 218720, upload_time = "2025-06-09T23:00:05.282Z" }, - { url = "https://files.pythonhosted.org/packages/1a/c0/c224ce0e0eb31cc57f67742071bb470ba8246623c1823a7530be0e76164c/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:41be2964bd4b15bf575e5daee5a5ce7ed3115320fb3c2b71fca05582ffa4dc9e", size = 232585, upload_time = "2025-06-09T23:00:07.962Z" }, - { url = "https://files.pythonhosted.org/packages/55/3c/34cb694abf532f31f365106deebdeac9e45c19304d83cf7d51ebbb4ca4d1/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:46d84d49e00c9429238a7ce02dc0be8f6d7cd0cd405abd1bebdc991bf27c15bd", size = 234248, upload_time = "2025-06-09T23:00:09.428Z" }, - { url = "https://files.pythonhosted.org/packages/98/c0/2052d8b6cecda2e70bd81299e3512fa332abb6dcd2969b9c80dfcdddbf75/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:15900082e886edb37480335d9d518cec978afc69ccbc30bd18610b7c1b22a718", size = 221621, upload_time = "2025-06-09T23:00:11.32Z" }, - { url = "https://files.pythonhosted.org/packages/c5/bf/7dcebae315436903b1d98ffb791a09d674c88480c158aa171958a3ac07f0/frozenlist-1.7.0-cp310-cp310-win32.whl", hash = "sha256:400ddd24ab4e55014bba442d917203c73b2846391dd42ca5e38ff52bb18c3c5e", size = 39578, upload_time = "2025-06-09T23:00:13.526Z" }, - { url = "https://files.pythonhosted.org/packages/8f/5f/f69818f017fa9a3d24d1ae39763e29b7f60a59e46d5f91b9c6b21622f4cd/frozenlist-1.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:6eb93efb8101ef39d32d50bce242c84bcbddb4f7e9febfa7b524532a239b4464", size = 43830, upload_time = "2025-06-09T23:00:14.98Z" }, - { url = "https://files.pythonhosted.org/packages/34/7e/803dde33760128acd393a27eb002f2020ddb8d99d30a44bfbaab31c5f08a/frozenlist-1.7.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:aa51e147a66b2d74de1e6e2cf5921890de6b0f4820b257465101d7f37b49fb5a", size = 82251, upload_time = "2025-06-09T23:00:16.279Z" }, - { url = "https://files.pythonhosted.org/packages/75/a9/9c2c5760b6ba45eae11334db454c189d43d34a4c0b489feb2175e5e64277/frozenlist-1.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9b35db7ce1cd71d36ba24f80f0c9e7cff73a28d7a74e91fe83e23d27c7828750", size = 48183, upload_time = "2025-06-09T23:00:17.698Z" }, - { url = "https://files.pythonhosted.org/packages/47/be/4038e2d869f8a2da165f35a6befb9158c259819be22eeaf9c9a8f6a87771/frozenlist-1.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:34a69a85e34ff37791e94542065c8416c1afbf820b68f720452f636d5fb990cd", size = 47107, upload_time = "2025-06-09T23:00:18.952Z" }, - { url = "https://files.pythonhosted.org/packages/79/26/85314b8a83187c76a37183ceed886381a5f992975786f883472fcb6dc5f2/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a646531fa8d82c87fe4bb2e596f23173caec9185bfbca5d583b4ccfb95183e2", size = 237333, upload_time = "2025-06-09T23:00:20.275Z" }, - { url = "https://files.pythonhosted.org/packages/1f/fd/e5b64f7d2c92a41639ffb2ad44a6a82f347787abc0c7df5f49057cf11770/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:79b2ffbba483f4ed36a0f236ccb85fbb16e670c9238313709638167670ba235f", size = 231724, upload_time = "2025-06-09T23:00:21.705Z" }, - { url = "https://files.pythonhosted.org/packages/20/fb/03395c0a43a5976af4bf7534759d214405fbbb4c114683f434dfdd3128ef/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a26f205c9ca5829cbf82bb2a84b5c36f7184c4316617d7ef1b271a56720d6b30", size = 245842, upload_time = "2025-06-09T23:00:23.148Z" }, - { url = "https://files.pythonhosted.org/packages/d0/15/c01c8e1dffdac5d9803507d824f27aed2ba76b6ed0026fab4d9866e82f1f/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bcacfad3185a623fa11ea0e0634aac7b691aa925d50a440f39b458e41c561d98", size = 239767, upload_time = "2025-06-09T23:00:25.103Z" }, - { url = "https://files.pythonhosted.org/packages/14/99/3f4c6fe882c1f5514b6848aa0a69b20cb5e5d8e8f51a339d48c0e9305ed0/frozenlist-1.7.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:72c1b0fe8fe451b34f12dce46445ddf14bd2a5bcad7e324987194dc8e3a74c86", size = 224130, upload_time = "2025-06-09T23:00:27.061Z" }, - { url = "https://files.pythonhosted.org/packages/4d/83/220a374bd7b2aeba9d0725130665afe11de347d95c3620b9b82cc2fcab97/frozenlist-1.7.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61d1a5baeaac6c0798ff6edfaeaa00e0e412d49946c53fae8d4b8e8b3566c4ae", size = 235301, upload_time = "2025-06-09T23:00:29.02Z" }, - { url = "https://files.pythonhosted.org/packages/03/3c/3e3390d75334a063181625343e8daab61b77e1b8214802cc4e8a1bb678fc/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7edf5c043c062462f09b6820de9854bf28cc6cc5b6714b383149745e287181a8", size = 234606, upload_time = "2025-06-09T23:00:30.514Z" }, - { url = "https://files.pythonhosted.org/packages/23/1e/58232c19608b7a549d72d9903005e2d82488f12554a32de2d5fb59b9b1ba/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:d50ac7627b3a1bd2dcef6f9da89a772694ec04d9a61b66cf87f7d9446b4a0c31", size = 248372, upload_time = "2025-06-09T23:00:31.966Z" }, - { url = "https://files.pythonhosted.org/packages/c0/a4/e4a567e01702a88a74ce8a324691e62a629bf47d4f8607f24bf1c7216e7f/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ce48b2fece5aeb45265bb7a58259f45027db0abff478e3077e12b05b17fb9da7", size = 229860, upload_time = "2025-06-09T23:00:33.375Z" }, - { url = "https://files.pythonhosted.org/packages/73/a6/63b3374f7d22268b41a9db73d68a8233afa30ed164c46107b33c4d18ecdd/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:fe2365ae915a1fafd982c146754e1de6ab3478def8a59c86e1f7242d794f97d5", size = 245893, upload_time = "2025-06-09T23:00:35.002Z" }, - { url = "https://files.pythonhosted.org/packages/6d/eb/d18b3f6e64799a79673c4ba0b45e4cfbe49c240edfd03a68be20002eaeaa/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:45a6f2fdbd10e074e8814eb98b05292f27bad7d1883afbe009d96abdcf3bc898", size = 246323, upload_time = "2025-06-09T23:00:36.468Z" }, - { url = "https://files.pythonhosted.org/packages/5a/f5/720f3812e3d06cd89a1d5db9ff6450088b8f5c449dae8ffb2971a44da506/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:21884e23cffabb157a9dd7e353779077bf5b8f9a58e9b262c6caad2ef5f80a56", size = 233149, upload_time = "2025-06-09T23:00:37.963Z" }, - { url = "https://files.pythonhosted.org/packages/69/68/03efbf545e217d5db8446acfd4c447c15b7c8cf4dbd4a58403111df9322d/frozenlist-1.7.0-cp311-cp311-win32.whl", hash = "sha256:284d233a8953d7b24f9159b8a3496fc1ddc00f4db99c324bd5fb5f22d8698ea7", size = 39565, upload_time = "2025-06-09T23:00:39.753Z" }, - { url = "https://files.pythonhosted.org/packages/58/17/fe61124c5c333ae87f09bb67186d65038834a47d974fc10a5fadb4cc5ae1/frozenlist-1.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:387cbfdcde2f2353f19c2f66bbb52406d06ed77519ac7ee21be0232147c2592d", size = 44019, upload_time = "2025-06-09T23:00:40.988Z" }, - { url = "https://files.pythonhosted.org/packages/ef/a2/c8131383f1e66adad5f6ecfcce383d584ca94055a34d683bbb24ac5f2f1c/frozenlist-1.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3dbf9952c4bb0e90e98aec1bd992b3318685005702656bc6f67c1a32b76787f2", size = 81424, upload_time = "2025-06-09T23:00:42.24Z" }, - { url = "https://files.pythonhosted.org/packages/4c/9d/02754159955088cb52567337d1113f945b9e444c4960771ea90eb73de8db/frozenlist-1.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1f5906d3359300b8a9bb194239491122e6cf1444c2efb88865426f170c262cdb", size = 47952, upload_time = "2025-06-09T23:00:43.481Z" }, - { url = "https://files.pythonhosted.org/packages/01/7a/0046ef1bd6699b40acd2067ed6d6670b4db2f425c56980fa21c982c2a9db/frozenlist-1.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3dabd5a8f84573c8d10d8859a50ea2dec01eea372031929871368c09fa103478", size = 46688, upload_time = "2025-06-09T23:00:44.793Z" }, - { url = "https://files.pythonhosted.org/packages/d6/a2/a910bafe29c86997363fb4c02069df4ff0b5bc39d33c5198b4e9dd42d8f8/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa57daa5917f1738064f302bf2626281a1cb01920c32f711fbc7bc36111058a8", size = 243084, upload_time = "2025-06-09T23:00:46.125Z" }, - { url = "https://files.pythonhosted.org/packages/64/3e/5036af9d5031374c64c387469bfcc3af537fc0f5b1187d83a1cf6fab1639/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c193dda2b6d49f4c4398962810fa7d7c78f032bf45572b3e04dd5249dff27e08", size = 233524, upload_time = "2025-06-09T23:00:47.73Z" }, - { url = "https://files.pythonhosted.org/packages/06/39/6a17b7c107a2887e781a48ecf20ad20f1c39d94b2a548c83615b5b879f28/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfe2b675cf0aaa6d61bf8fbffd3c274b3c9b7b1623beb3809df8a81399a4a9c4", size = 248493, upload_time = "2025-06-09T23:00:49.742Z" }, - { url = "https://files.pythonhosted.org/packages/be/00/711d1337c7327d88c44d91dd0f556a1c47fb99afc060ae0ef66b4d24793d/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8fc5d5cda37f62b262405cf9652cf0856839c4be8ee41be0afe8858f17f4c94b", size = 244116, upload_time = "2025-06-09T23:00:51.352Z" }, - { url = "https://files.pythonhosted.org/packages/24/fe/74e6ec0639c115df13d5850e75722750adabdc7de24e37e05a40527ca539/frozenlist-1.7.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0d5ce521d1dd7d620198829b87ea002956e4319002ef0bc8d3e6d045cb4646e", size = 224557, upload_time = "2025-06-09T23:00:52.855Z" }, - { url = "https://files.pythonhosted.org/packages/8d/db/48421f62a6f77c553575201e89048e97198046b793f4a089c79a6e3268bd/frozenlist-1.7.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:488d0a7d6a0008ca0db273c542098a0fa9e7dfaa7e57f70acef43f32b3f69dca", size = 241820, upload_time = "2025-06-09T23:00:54.43Z" }, - { url = "https://files.pythonhosted.org/packages/1d/fa/cb4a76bea23047c8462976ea7b7a2bf53997a0ca171302deae9d6dd12096/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:15a7eaba63983d22c54d255b854e8108e7e5f3e89f647fc854bd77a237e767df", size = 236542, upload_time = "2025-06-09T23:00:56.409Z" }, - { url = "https://files.pythonhosted.org/packages/5d/32/476a4b5cfaa0ec94d3f808f193301debff2ea42288a099afe60757ef6282/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1eaa7e9c6d15df825bf255649e05bd8a74b04a4d2baa1ae46d9c2d00b2ca2cb5", size = 249350, upload_time = "2025-06-09T23:00:58.468Z" }, - { url = "https://files.pythonhosted.org/packages/8d/ba/9a28042f84a6bf8ea5dbc81cfff8eaef18d78b2a1ad9d51c7bc5b029ad16/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e4389e06714cfa9d47ab87f784a7c5be91d3934cd6e9a7b85beef808297cc025", size = 225093, upload_time = "2025-06-09T23:01:00.015Z" }, - { url = "https://files.pythonhosted.org/packages/bc/29/3a32959e68f9cf000b04e79ba574527c17e8842e38c91d68214a37455786/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:73bd45e1488c40b63fe5a7df892baf9e2a4d4bb6409a2b3b78ac1c6236178e01", size = 245482, upload_time = "2025-06-09T23:01:01.474Z" }, - { url = "https://files.pythonhosted.org/packages/80/e8/edf2f9e00da553f07f5fa165325cfc302dead715cab6ac8336a5f3d0adc2/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99886d98e1643269760e5fe0df31e5ae7050788dd288947f7f007209b8c33f08", size = 249590, upload_time = "2025-06-09T23:01:02.961Z" }, - { url = "https://files.pythonhosted.org/packages/1c/80/9a0eb48b944050f94cc51ee1c413eb14a39543cc4f760ed12657a5a3c45a/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:290a172aae5a4c278c6da8a96222e6337744cd9c77313efe33d5670b9f65fc43", size = 237785, upload_time = "2025-06-09T23:01:05.095Z" }, - { url = "https://files.pythonhosted.org/packages/f3/74/87601e0fb0369b7a2baf404ea921769c53b7ae00dee7dcfe5162c8c6dbf0/frozenlist-1.7.0-cp312-cp312-win32.whl", hash = "sha256:426c7bc70e07cfebc178bc4c2bf2d861d720c4fff172181eeb4a4c41d4ca2ad3", size = 39487, upload_time = "2025-06-09T23:01:06.54Z" }, - { url = "https://files.pythonhosted.org/packages/0b/15/c026e9a9fc17585a9d461f65d8593d281fedf55fbf7eb53f16c6df2392f9/frozenlist-1.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:563b72efe5da92e02eb68c59cb37205457c977aa7a449ed1b37e6939e5c47c6a", size = 43874, upload_time = "2025-06-09T23:01:07.752Z" }, - { url = "https://files.pythonhosted.org/packages/24/90/6b2cebdabdbd50367273c20ff6b57a3dfa89bd0762de02c3a1eb42cb6462/frozenlist-1.7.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee80eeda5e2a4e660651370ebffd1286542b67e268aa1ac8d6dbe973120ef7ee", size = 79791, upload_time = "2025-06-09T23:01:09.368Z" }, - { url = "https://files.pythonhosted.org/packages/83/2e/5b70b6a3325363293fe5fc3ae74cdcbc3e996c2a11dde2fd9f1fb0776d19/frozenlist-1.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d1a81c85417b914139e3a9b995d4a1c84559afc839a93cf2cb7f15e6e5f6ed2d", size = 47165, upload_time = "2025-06-09T23:01:10.653Z" }, - { url = "https://files.pythonhosted.org/packages/f4/25/a0895c99270ca6966110f4ad98e87e5662eab416a17e7fd53c364bf8b954/frozenlist-1.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cbb65198a9132ebc334f237d7b0df163e4de83fb4f2bdfe46c1e654bdb0c5d43", size = 45881, upload_time = "2025-06-09T23:01:12.296Z" }, - { url = "https://files.pythonhosted.org/packages/19/7c/71bb0bbe0832793c601fff68cd0cf6143753d0c667f9aec93d3c323f4b55/frozenlist-1.7.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dab46c723eeb2c255a64f9dc05b8dd601fde66d6b19cdb82b2e09cc6ff8d8b5d", size = 232409, upload_time = "2025-06-09T23:01:13.641Z" }, - { url = "https://files.pythonhosted.org/packages/c0/45/ed2798718910fe6eb3ba574082aaceff4528e6323f9a8570be0f7028d8e9/frozenlist-1.7.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6aeac207a759d0dedd2e40745575ae32ab30926ff4fa49b1635def65806fddee", size = 225132, upload_time = "2025-06-09T23:01:15.264Z" }, - { url = "https://files.pythonhosted.org/packages/ba/e2/8417ae0f8eacb1d071d4950f32f229aa6bf68ab69aab797b72a07ea68d4f/frozenlist-1.7.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bd8c4e58ad14b4fa7802b8be49d47993182fdd4023393899632c88fd8cd994eb", size = 237638, upload_time = "2025-06-09T23:01:16.752Z" }, - { url = "https://files.pythonhosted.org/packages/f8/b7/2ace5450ce85f2af05a871b8c8719b341294775a0a6c5585d5e6170f2ce7/frozenlist-1.7.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04fb24d104f425da3540ed83cbfc31388a586a7696142004c577fa61c6298c3f", size = 233539, upload_time = "2025-06-09T23:01:18.202Z" }, - { url = "https://files.pythonhosted.org/packages/46/b9/6989292c5539553dba63f3c83dc4598186ab2888f67c0dc1d917e6887db6/frozenlist-1.7.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a5c505156368e4ea6b53b5ac23c92d7edc864537ff911d2fb24c140bb175e60", size = 215646, upload_time = "2025-06-09T23:01:19.649Z" }, - { url = "https://files.pythonhosted.org/packages/72/31/bc8c5c99c7818293458fe745dab4fd5730ff49697ccc82b554eb69f16a24/frozenlist-1.7.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8bd7eb96a675f18aa5c553eb7ddc24a43c8c18f22e1f9925528128c052cdbe00", size = 232233, upload_time = "2025-06-09T23:01:21.175Z" }, - { url = "https://files.pythonhosted.org/packages/59/52/460db4d7ba0811b9ccb85af996019f5d70831f2f5f255f7cc61f86199795/frozenlist-1.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:05579bf020096fe05a764f1f84cd104a12f78eaab68842d036772dc6d4870b4b", size = 227996, upload_time = "2025-06-09T23:01:23.098Z" }, - { url = "https://files.pythonhosted.org/packages/ba/c9/f4b39e904c03927b7ecf891804fd3b4df3db29b9e487c6418e37988d6e9d/frozenlist-1.7.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:376b6222d114e97eeec13d46c486facd41d4f43bab626b7c3f6a8b4e81a5192c", size = 242280, upload_time = "2025-06-09T23:01:24.808Z" }, - { url = "https://files.pythonhosted.org/packages/b8/33/3f8d6ced42f162d743e3517781566b8481322be321b486d9d262adf70bfb/frozenlist-1.7.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:0aa7e176ebe115379b5b1c95b4096fb1c17cce0847402e227e712c27bdb5a949", size = 217717, upload_time = "2025-06-09T23:01:26.28Z" }, - { url = "https://files.pythonhosted.org/packages/3e/e8/ad683e75da6ccef50d0ab0c2b2324b32f84fc88ceee778ed79b8e2d2fe2e/frozenlist-1.7.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3fbba20e662b9c2130dc771e332a99eff5da078b2b2648153a40669a6d0e36ca", size = 236644, upload_time = "2025-06-09T23:01:27.887Z" }, - { url = "https://files.pythonhosted.org/packages/b2/14/8d19ccdd3799310722195a72ac94ddc677541fb4bef4091d8e7775752360/frozenlist-1.7.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:f3f4410a0a601d349dd406b5713fec59b4cee7e71678d5b17edda7f4655a940b", size = 238879, upload_time = "2025-06-09T23:01:29.524Z" }, - { url = "https://files.pythonhosted.org/packages/ce/13/c12bf657494c2fd1079a48b2db49fa4196325909249a52d8f09bc9123fd7/frozenlist-1.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e2cdfaaec6a2f9327bf43c933c0319a7c429058e8537c508964a133dffee412e", size = 232502, upload_time = "2025-06-09T23:01:31.287Z" }, - { url = "https://files.pythonhosted.org/packages/d7/8b/e7f9dfde869825489382bc0d512c15e96d3964180c9499efcec72e85db7e/frozenlist-1.7.0-cp313-cp313-win32.whl", hash = "sha256:5fc4df05a6591c7768459caba1b342d9ec23fa16195e744939ba5914596ae3e1", size = 39169, upload_time = "2025-06-09T23:01:35.503Z" }, - { url = "https://files.pythonhosted.org/packages/35/89/a487a98d94205d85745080a37860ff5744b9820a2c9acbcdd9440bfddf98/frozenlist-1.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:52109052b9791a3e6b5d1b65f4b909703984b770694d3eb64fad124c835d7cba", size = 43219, upload_time = "2025-06-09T23:01:36.784Z" }, - { url = "https://files.pythonhosted.org/packages/56/d5/5c4cf2319a49eddd9dd7145e66c4866bdc6f3dbc67ca3d59685149c11e0d/frozenlist-1.7.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a6f86e4193bb0e235ef6ce3dde5cbabed887e0b11f516ce8a0f4d3b33078ec2d", size = 84345, upload_time = "2025-06-09T23:01:38.295Z" }, - { url = "https://files.pythonhosted.org/packages/a4/7d/ec2c1e1dc16b85bc9d526009961953df9cec8481b6886debb36ec9107799/frozenlist-1.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:82d664628865abeb32d90ae497fb93df398a69bb3434463d172b80fc25b0dd7d", size = 48880, upload_time = "2025-06-09T23:01:39.887Z" }, - { url = "https://files.pythonhosted.org/packages/69/86/f9596807b03de126e11e7d42ac91e3d0b19a6599c714a1989a4e85eeefc4/frozenlist-1.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:912a7e8375a1c9a68325a902f3953191b7b292aa3c3fb0d71a216221deca460b", size = 48498, upload_time = "2025-06-09T23:01:41.318Z" }, - { url = "https://files.pythonhosted.org/packages/5e/cb/df6de220f5036001005f2d726b789b2c0b65f2363b104bbc16f5be8084f8/frozenlist-1.7.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9537c2777167488d539bc5de2ad262efc44388230e5118868e172dd4a552b146", size = 292296, upload_time = "2025-06-09T23:01:42.685Z" }, - { url = "https://files.pythonhosted.org/packages/83/1f/de84c642f17c8f851a2905cee2dae401e5e0daca9b5ef121e120e19aa825/frozenlist-1.7.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:f34560fb1b4c3e30ba35fa9a13894ba39e5acfc5f60f57d8accde65f46cc5e74", size = 273103, upload_time = "2025-06-09T23:01:44.166Z" }, - { url = "https://files.pythonhosted.org/packages/88/3c/c840bfa474ba3fa13c772b93070893c6e9d5c0350885760376cbe3b6c1b3/frozenlist-1.7.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:acd03d224b0175f5a850edc104ac19040d35419eddad04e7cf2d5986d98427f1", size = 292869, upload_time = "2025-06-09T23:01:45.681Z" }, - { url = "https://files.pythonhosted.org/packages/a6/1c/3efa6e7d5a39a1d5ef0abeb51c48fb657765794a46cf124e5aca2c7a592c/frozenlist-1.7.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2038310bc582f3d6a09b3816ab01737d60bf7b1ec70f5356b09e84fb7408ab1", size = 291467, upload_time = "2025-06-09T23:01:47.234Z" }, - { url = "https://files.pythonhosted.org/packages/4f/00/d5c5e09d4922c395e2f2f6b79b9a20dab4b67daaf78ab92e7729341f61f6/frozenlist-1.7.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b8c05e4c8e5f36e5e088caa1bf78a687528f83c043706640a92cb76cd6999384", size = 266028, upload_time = "2025-06-09T23:01:48.819Z" }, - { url = "https://files.pythonhosted.org/packages/4e/27/72765be905619dfde25a7f33813ac0341eb6b076abede17a2e3fbfade0cb/frozenlist-1.7.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:765bb588c86e47d0b68f23c1bee323d4b703218037765dcf3f25c838c6fecceb", size = 284294, upload_time = "2025-06-09T23:01:50.394Z" }, - { url = "https://files.pythonhosted.org/packages/88/67/c94103a23001b17808eb7dd1200c156bb69fb68e63fcf0693dde4cd6228c/frozenlist-1.7.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:32dc2e08c67d86d0969714dd484fd60ff08ff81d1a1e40a77dd34a387e6ebc0c", size = 281898, upload_time = "2025-06-09T23:01:52.234Z" }, - { url = "https://files.pythonhosted.org/packages/42/34/a3e2c00c00f9e2a9db5653bca3fec306349e71aff14ae45ecc6d0951dd24/frozenlist-1.7.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:c0303e597eb5a5321b4de9c68e9845ac8f290d2ab3f3e2c864437d3c5a30cd65", size = 290465, upload_time = "2025-06-09T23:01:53.788Z" }, - { url = "https://files.pythonhosted.org/packages/bb/73/f89b7fbce8b0b0c095d82b008afd0590f71ccb3dee6eee41791cf8cd25fd/frozenlist-1.7.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:a47f2abb4e29b3a8d0b530f7c3598badc6b134562b1a5caee867f7c62fee51e3", size = 266385, upload_time = "2025-06-09T23:01:55.769Z" }, - { url = "https://files.pythonhosted.org/packages/cd/45/e365fdb554159462ca12df54bc59bfa7a9a273ecc21e99e72e597564d1ae/frozenlist-1.7.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:3d688126c242a6fabbd92e02633414d40f50bb6002fa4cf995a1d18051525657", size = 288771, upload_time = "2025-06-09T23:01:57.4Z" }, - { url = "https://files.pythonhosted.org/packages/00/11/47b6117002a0e904f004d70ec5194fe9144f117c33c851e3d51c765962d0/frozenlist-1.7.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:4e7e9652b3d367c7bd449a727dc79d5043f48b88d0cbfd4f9f1060cf2b414104", size = 288206, upload_time = "2025-06-09T23:01:58.936Z" }, - { url = "https://files.pythonhosted.org/packages/40/37/5f9f3c3fd7f7746082ec67bcdc204db72dad081f4f83a503d33220a92973/frozenlist-1.7.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1a85e345b4c43db8b842cab1feb41be5cc0b10a1830e6295b69d7310f99becaf", size = 282620, upload_time = "2025-06-09T23:02:00.493Z" }, - { url = "https://files.pythonhosted.org/packages/0b/31/8fbc5af2d183bff20f21aa743b4088eac4445d2bb1cdece449ae80e4e2d1/frozenlist-1.7.0-cp313-cp313t-win32.whl", hash = "sha256:3a14027124ddb70dfcee5148979998066897e79f89f64b13328595c4bdf77c81", size = 43059, upload_time = "2025-06-09T23:02:02.072Z" }, - { url = "https://files.pythonhosted.org/packages/bb/ed/41956f52105b8dbc26e457c5705340c67c8cc2b79f394b79bffc09d0e938/frozenlist-1.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:3bf8010d71d4507775f658e9823210b7427be36625b387221642725b515dcf3e", size = 47516, upload_time = "2025-06-09T23:02:03.779Z" }, - { url = "https://files.pythonhosted.org/packages/ee/45/b82e3c16be2182bff01179db177fe144d58b5dc787a7d4492c6ed8b9317f/frozenlist-1.7.0-py3-none-any.whl", hash = "sha256:9a5af342e34f7e97caf8c995864c7a396418ae2859cc6fdf1b1073020d516a7e", size = 13106, upload_time = "2025-06-09T23:02:34.204Z" }, -] - -[[package]] -name = "graphql-core" -version = "3.2.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/c4/16/7574029da84834349b60ed71614d66ca3afe46e9bf9c7b9562102acb7d4f/graphql_core-3.2.6.tar.gz", hash = "sha256:c08eec22f9e40f0bd61d805907e3b3b1b9a320bc606e23dc145eebca07c8fbab", size = 505353, upload_time = "2025-01-26T16:36:27.374Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ae/4f/7297663840621022bc73c22d7d9d80dbc78b4db6297f764b545cd5dd462d/graphql_core-3.2.6-py3-none-any.whl", hash = "sha256:78b016718c161a6fb20a7d97bbf107f331cd1afe53e45566c59f776ed7f0b45f", size = 203416, upload_time = "2025-01-26T16:36:24.868Z" }, -] - -[[package]] -name = "h11" -version = "0.16.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload_time = "2025-04-24T03:35:25.427Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload_time = "2025-04-24T03:35:24.344Z" }, -] - -[[package]] -name = "httpcore" -version = "1.0.9" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "h11" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload_time = "2025-04-24T22:06:22.219Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload_time = "2025-04-24T22:06:20.566Z" }, -] - -[[package]] -name = "httpx" -version = "0.28.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "certifi" }, - { name = "httpcore" }, - { name = "idna" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload_time = "2024-12-06T15:37:23.222Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload_time = "2024-12-06T15:37:21.509Z" }, -] - -[[package]] -name = "idna" -version = "3.10" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload_time = "2024-09-15T18:07:39.745Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload_time = "2024-09-15T18:07:37.964Z" }, -] - -[[package]] -name = "igraph" -version = "0.11.9" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "texttable" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/fa/a2/ed3f1513b14e98f73ad29a2bbd2898aef7ceac739e9eff1b3b6a9126dfe6/igraph-0.11.9.tar.gz", hash = "sha256:c57ce44873abcfcfd1d61d7d261e416d352186958e7b5d299cf244efa6757816", size = 4587322, upload_time = "2025-06-11T09:27:49.958Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ab/84/bbcde5833e2685b722ce04ed2ec542cff49f12b4d6a3aa27d23c4febd4db/igraph-0.11.9-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ef30a8eb6329a71211652223cad900dc42bc7fdb44d9e942e991181232906ac2", size = 1936209, upload_time = "2025-06-11T09:24:32.932Z" }, - { url = "https://files.pythonhosted.org/packages/15/47/6e94649b7fe12f3a82e75ef0f35fb0a2d860b13aafcfcfcdf467d50e9208/igraph-0.11.9-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:4b3224b2b74e9dfac1271dc6f2e1061d13492f91198d05e1b8b696b994e5e269", size = 1752923, upload_time = "2025-06-11T09:24:36.256Z" }, - { url = "https://files.pythonhosted.org/packages/2c/21/8649eebbe101ecc704863a05814ccca90f578afcfd990038c739027211e9/igraph-0.11.9-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:adf7d7200c2e11a3b1122786f77cee96072c593fd62794aadb5ce546a24fa791", size = 4133376, upload_time = "2025-06-11T09:24:40.65Z" }, - { url = "https://files.pythonhosted.org/packages/7c/63/c4e561d5947d728dc1dd244bd86c1c2d01bd1e1b14ec04e6dc9bac1e601c/igraph-0.11.9-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78a7f3a490f3f6a8aab99948e3e62ae81fc1e8a8aa07e326b09f4e570c042e79", size = 4285168, upload_time = "2025-06-11T09:24:46.84Z" }, - { url = "https://files.pythonhosted.org/packages/b8/79/a21fec50837ee429fd0cb675b93cd7db80f687a9eeab53f63ea02f0a5a99/igraph-0.11.9-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:773201c9eafef668be11d8966cf2d7114d34757cd9cfdbd8c190fefcd341220b", size = 4372306, upload_time = "2025-06-11T09:24:51.698Z" }, - { url = "https://files.pythonhosted.org/packages/8a/01/42bd858f01aa45f769f4edd0a643cf333f5a2b36efcca38f228af1cd02bc/igraph-0.11.9-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9bc6fb4316bc79bd0d800dd0186921ef62da971be147861872be90242acbae7d", size = 5250489, upload_time = "2025-06-11T09:24:57.376Z" }, - { url = "https://files.pythonhosted.org/packages/39/b5/44c6cd220baa6213a9edcc097aa9b2f4867d4f1f9b321369aa4820cb4790/igraph-0.11.9-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:e45d03bfb931b73f323b531fc0d87235ac96c41a64363b243677034576cf411b", size = 5638683, upload_time = "2025-06-11T09:25:03.056Z" }, - { url = "https://files.pythonhosted.org/packages/ef/06/91761a416d52ba7049dffa8bfc6eb14b41c5c7f926c6d02a3532030f59d6/igraph-0.11.9-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:157b4a836628ca55c6422098bf34336006c1d517fc86fa0e89af3a233e3baa30", size = 5512189, upload_time = "2025-06-11T09:25:09Z" }, - { url = "https://files.pythonhosted.org/packages/01/1b/b330e61dc2afb2f00bf152d1b570267741e2465a460a4f9a6e4c41057cbb/igraph-0.11.9-cp39-abi3-win32.whl", hash = "sha256:1fd67a0771b8ce70bef361557bdeb6ca7a1012f9fb8368eba86967deeb99a110", size = 2500729, upload_time = "2025-06-11T09:26:31.389Z" }, - { url = "https://files.pythonhosted.org/packages/1c/36/8de9605ba946f9ce82558e753ab08c4705124a92df561df83ac551c6e36a/igraph-0.11.9-cp39-abi3-win_amd64.whl", hash = "sha256:09c7d49c7759e058bf2526bbac54dd1f9e0725ff64352f01545db59c09de88cf", size = 2927497, upload_time = "2025-06-11T09:26:23.7Z" }, - { url = "https://files.pythonhosted.org/packages/e4/71/608f07217246858d5c73a68488bef60b819e502a3287e34a77743109011c/igraph-0.11.9-cp39-abi3-win_arm64.whl", hash = "sha256:8acca4f2463f4de572471cca2d46bb3ef5b3082bc125b9ec30e8032b177951df", size = 2568065, upload_time = "2025-06-11T09:26:27.491Z" }, - { url = "https://files.pythonhosted.org/packages/3e/1b/e1d03f3173f7b8b3b837f3d8ffbdbcdd942ab2e0e5ad824f29f5cce40af1/igraph-0.11.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:63f5953619b308b0afbb3ceb5c7b7ab3ee847eca348dfca7d7eb93290568ce02", size = 1922428, upload_time = "2025-06-11T09:26:35.023Z" }, - { url = "https://files.pythonhosted.org/packages/d2/a1/8c7619d74c587b793fcdff80424c0bc62dfaa8604510b5bceb3329ed4ce7/igraph-0.11.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:a2c4384d1ea1fb071c1b367069783dc195919596d9bb73fef1eddf97cfb5613b", size = 1739360, upload_time = "2025-06-11T09:26:38.68Z" }, - { url = "https://files.pythonhosted.org/packages/53/5b/9403e5e90e496799226f5a0ea99582b41c9b97c99fd34256a33a6956cf13/igraph-0.11.9-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:02e2e6747d3c70fcb539bc29b80377d63859f30db8a9b4bc6f440d317c07a47b", size = 2599045, upload_time = "2025-06-11T09:26:42.147Z" }, - { url = "https://files.pythonhosted.org/packages/8b/f8/c2b3256f6aa986a4204bcdfd0be0d4fe44fdec66a14573ff1b16bb7d0e28/igraph-0.11.9-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f74dd13b36fd5a831632be0e8f0b3b1519067c479a820f54168e70ac0b71b89d", size = 2759711, upload_time = "2025-06-11T09:26:45.573Z" }, - { url = "https://files.pythonhosted.org/packages/1c/23/839f946aea34856ba0dd96320eb0c3cec1b52ab2f1ab7351d607a79ef8ca/igraph-0.11.9-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:abb5097c402e82a8bb074ab9df2e45e0c9bcd76bb36a3a839e7cd4d71143bbba", size = 2765467, upload_time = "2025-06-11T09:26:49.147Z" }, - { url = "https://files.pythonhosted.org/packages/83/fa/cbb7226191a54238930d66701293cf66e5d0798b89b0c08d47812c8c79c8/igraph-0.11.9-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b0561914fc415dc2fa4194c39585336dde42c3cf5fafd1b404f5e847d055fa17", size = 2926684, upload_time = "2025-06-11T09:26:53.242Z" }, - { url = "https://files.pythonhosted.org/packages/cc/a6/9dbdb3063139102f899b30ce4b4aab30db9f741519432f876a75f3fce044/igraph-0.11.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7a38e20a45499ae258c36ff27a32e9afeac777bac0c94c3511af75503f37523f", size = 1922237, upload_time = "2025-06-11T09:26:56.807Z" }, - { url = "https://files.pythonhosted.org/packages/74/92/0d48d40febb259ef9ec8e0ba3de6c23169469a1deabd00377533aae80970/igraph-0.11.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:1bbf2b7a928441184ec9fc1f771ddf61bcd6a3f812a8861cab465c5c985ccc6c", size = 1739476, upload_time = "2025-06-11T09:27:01.472Z" }, - { url = "https://files.pythonhosted.org/packages/1a/21/ae0f653be1e25110f536ffd37948a08b4f1de2dfeb804dcdbde793289afb/igraph-0.11.9-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8fb6db6056f90364436f32439b3fc23947d469de0894240ed94dfdecc2eb3c89", size = 2599570, upload_time = "2025-06-11T09:27:05.443Z" }, - { url = "https://files.pythonhosted.org/packages/98/6f/b5bc2d59aafcf6f3a5524cf11b5c9eb91fd2ed34895ed63e5fb45209fec5/igraph-0.11.9-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f4c6ff8fea88f4b7f6202f6ff939853e09c383b2a35c58aa05f374b66fe46c7c", size = 2759495, upload_time = "2025-06-11T09:27:09.777Z" }, - { url = "https://files.pythonhosted.org/packages/01/81/54ed84a43b796f943d78ad28582c6a85b645870e38d752d31497bc4179a2/igraph-0.11.9-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9911a7c5b256c0e7d50f958bbabba47a5eeddde67b47271a05e0850de129e2fc", size = 2765372, upload_time = "2025-06-11T09:27:14.246Z" }, - { url = "https://files.pythonhosted.org/packages/d7/91/c1b597004248bd7ce6c9593465308a1a5f0467c4ec4056aa51a6c017a669/igraph-0.11.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f35694100691bf8ef0c370615d87bcf1d6c0f15e356269c6357f8f78a9f1acea", size = 2926242, upload_time = "2025-06-11T09:27:18.553Z" }, -] - -[[package]] -name = "jieba" -version = "0.42.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/c6/cb/18eeb235f833b726522d7ebed54f2278ce28ba9438e3135ab0278d9792a2/jieba-0.42.1.tar.gz", hash = "sha256:055ca12f62674fafed09427f176506079bc135638a14e23e25be909131928db2", size = 19214172, upload_time = "2020-01-20T14:27:23.5Z" } - -[[package]] -name = "jiter" -version = "0.10.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ee/9d/ae7ddb4b8ab3fb1b51faf4deb36cb48a4fbbd7cb36bad6a5fca4741306f7/jiter-0.10.0.tar.gz", hash = "sha256:07a7142c38aacc85194391108dc91b5b57093c978a9932bd86a36862759d9500", size = 162759, upload_time = "2025-05-18T19:04:59.73Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/be/7e/4011b5c77bec97cb2b572f566220364e3e21b51c48c5bd9c4a9c26b41b67/jiter-0.10.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:cd2fb72b02478f06a900a5782de2ef47e0396b3e1f7d5aba30daeb1fce66f303", size = 317215, upload_time = "2025-05-18T19:03:04.303Z" }, - { url = "https://files.pythonhosted.org/packages/8a/4f/144c1b57c39692efc7ea7d8e247acf28e47d0912800b34d0ad815f6b2824/jiter-0.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:32bb468e3af278f095d3fa5b90314728a6916d89ba3d0ffb726dd9bf7367285e", size = 322814, upload_time = "2025-05-18T19:03:06.433Z" }, - { url = "https://files.pythonhosted.org/packages/63/1f/db977336d332a9406c0b1f0b82be6f71f72526a806cbb2281baf201d38e3/jiter-0.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa8b3e0068c26ddedc7abc6fac37da2d0af16b921e288a5a613f4b86f050354f", size = 345237, upload_time = "2025-05-18T19:03:07.833Z" }, - { url = "https://files.pythonhosted.org/packages/d7/1c/aa30a4a775e8a672ad7f21532bdbfb269f0706b39c6ff14e1f86bdd9e5ff/jiter-0.10.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:286299b74cc49e25cd42eea19b72aa82c515d2f2ee12d11392c56d8701f52224", size = 370999, upload_time = "2025-05-18T19:03:09.338Z" }, - { url = "https://files.pythonhosted.org/packages/35/df/f8257abc4207830cb18880781b5f5b716bad5b2a22fb4330cfd357407c5b/jiter-0.10.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6ed5649ceeaeffc28d87fb012d25a4cd356dcd53eff5acff1f0466b831dda2a7", size = 491109, upload_time = "2025-05-18T19:03:11.13Z" }, - { url = "https://files.pythonhosted.org/packages/06/76/9e1516fd7b4278aa13a2cc7f159e56befbea9aa65c71586305e7afa8b0b3/jiter-0.10.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2ab0051160cb758a70716448908ef14ad476c3774bd03ddce075f3c1f90a3d6", size = 388608, upload_time = "2025-05-18T19:03:12.911Z" }, - { url = "https://files.pythonhosted.org/packages/6d/64/67750672b4354ca20ca18d3d1ccf2c62a072e8a2d452ac3cf8ced73571ef/jiter-0.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03997d2f37f6b67d2f5c475da4412be584e1cec273c1cfc03d642c46db43f8cf", size = 352454, upload_time = "2025-05-18T19:03:14.741Z" }, - { url = "https://files.pythonhosted.org/packages/96/4d/5c4e36d48f169a54b53a305114be3efa2bbffd33b648cd1478a688f639c1/jiter-0.10.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c404a99352d839fed80d6afd6c1d66071f3bacaaa5c4268983fc10f769112e90", size = 391833, upload_time = "2025-05-18T19:03:16.426Z" }, - { url = "https://files.pythonhosted.org/packages/0b/de/ce4a6166a78810bd83763d2fa13f85f73cbd3743a325469a4a9289af6dae/jiter-0.10.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:66e989410b6666d3ddb27a74c7e50d0829704ede652fd4c858e91f8d64b403d0", size = 523646, upload_time = "2025-05-18T19:03:17.704Z" }, - { url = "https://files.pythonhosted.org/packages/a2/a6/3bc9acce53466972964cf4ad85efecb94f9244539ab6da1107f7aed82934/jiter-0.10.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b532d3af9ef4f6374609a3bcb5e05a1951d3bf6190dc6b176fdb277c9bbf15ee", size = 514735, upload_time = "2025-05-18T19:03:19.44Z" }, - { url = "https://files.pythonhosted.org/packages/b4/d8/243c2ab8426a2a4dea85ba2a2ba43df379ccece2145320dfd4799b9633c5/jiter-0.10.0-cp310-cp310-win32.whl", hash = "sha256:da9be20b333970e28b72edc4dff63d4fec3398e05770fb3205f7fb460eb48dd4", size = 210747, upload_time = "2025-05-18T19:03:21.184Z" }, - { url = "https://files.pythonhosted.org/packages/37/7a/8021bd615ef7788b98fc76ff533eaac846322c170e93cbffa01979197a45/jiter-0.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:f59e533afed0c5b0ac3eba20d2548c4a550336d8282ee69eb07b37ea526ee4e5", size = 207484, upload_time = "2025-05-18T19:03:23.046Z" }, - { url = "https://files.pythonhosted.org/packages/1b/dd/6cefc6bd68b1c3c979cecfa7029ab582b57690a31cd2f346c4d0ce7951b6/jiter-0.10.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3bebe0c558e19902c96e99217e0b8e8b17d570906e72ed8a87170bc290b1e978", size = 317473, upload_time = "2025-05-18T19:03:25.942Z" }, - { url = "https://files.pythonhosted.org/packages/be/cf/fc33f5159ce132be1d8dd57251a1ec7a631c7df4bd11e1cd198308c6ae32/jiter-0.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:558cc7e44fd8e507a236bee6a02fa17199ba752874400a0ca6cd6e2196cdb7dc", size = 321971, upload_time = "2025-05-18T19:03:27.255Z" }, - { url = "https://files.pythonhosted.org/packages/68/a4/da3f150cf1d51f6c472616fb7650429c7ce053e0c962b41b68557fdf6379/jiter-0.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d613e4b379a07d7c8453c5712ce7014e86c6ac93d990a0b8e7377e18505e98d", size = 345574, upload_time = "2025-05-18T19:03:28.63Z" }, - { url = "https://files.pythonhosted.org/packages/84/34/6e8d412e60ff06b186040e77da5f83bc158e9735759fcae65b37d681f28b/jiter-0.10.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f62cf8ba0618eda841b9bf61797f21c5ebd15a7a1e19daab76e4e4b498d515b2", size = 371028, upload_time = "2025-05-18T19:03:30.292Z" }, - { url = "https://files.pythonhosted.org/packages/fb/d9/9ee86173aae4576c35a2f50ae930d2ccb4c4c236f6cb9353267aa1d626b7/jiter-0.10.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:919d139cdfa8ae8945112398511cb7fca58a77382617d279556b344867a37e61", size = 491083, upload_time = "2025-05-18T19:03:31.654Z" }, - { url = "https://files.pythonhosted.org/packages/d9/2c/f955de55e74771493ac9e188b0f731524c6a995dffdcb8c255b89c6fb74b/jiter-0.10.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:13ddbc6ae311175a3b03bd8994881bc4635c923754932918e18da841632349db", size = 388821, upload_time = "2025-05-18T19:03:33.184Z" }, - { url = "https://files.pythonhosted.org/packages/81/5a/0e73541b6edd3f4aada586c24e50626c7815c561a7ba337d6a7eb0a915b4/jiter-0.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c440ea003ad10927a30521a9062ce10b5479592e8a70da27f21eeb457b4a9c5", size = 352174, upload_time = "2025-05-18T19:03:34.965Z" }, - { url = "https://files.pythonhosted.org/packages/1c/c0/61eeec33b8c75b31cae42be14d44f9e6fe3ac15a4e58010256ac3abf3638/jiter-0.10.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dc347c87944983481e138dea467c0551080c86b9d21de6ea9306efb12ca8f606", size = 391869, upload_time = "2025-05-18T19:03:36.436Z" }, - { url = "https://files.pythonhosted.org/packages/41/22/5beb5ee4ad4ef7d86f5ea5b4509f680a20706c4a7659e74344777efb7739/jiter-0.10.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:13252b58c1f4d8c5b63ab103c03d909e8e1e7842d302473f482915d95fefd605", size = 523741, upload_time = "2025-05-18T19:03:38.168Z" }, - { url = "https://files.pythonhosted.org/packages/ea/10/768e8818538e5817c637b0df52e54366ec4cebc3346108a4457ea7a98f32/jiter-0.10.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7d1bbf3c465de4a24ab12fb7766a0003f6f9bce48b8b6a886158c4d569452dc5", size = 514527, upload_time = "2025-05-18T19:03:39.577Z" }, - { url = "https://files.pythonhosted.org/packages/73/6d/29b7c2dc76ce93cbedabfd842fc9096d01a0550c52692dfc33d3cc889815/jiter-0.10.0-cp311-cp311-win32.whl", hash = "sha256:db16e4848b7e826edca4ccdd5b145939758dadf0dc06e7007ad0e9cfb5928ae7", size = 210765, upload_time = "2025-05-18T19:03:41.271Z" }, - { url = "https://files.pythonhosted.org/packages/c2/c9/d394706deb4c660137caf13e33d05a031d734eb99c051142e039d8ceb794/jiter-0.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:9c9c1d5f10e18909e993f9641f12fe1c77b3e9b533ee94ffa970acc14ded3812", size = 209234, upload_time = "2025-05-18T19:03:42.918Z" }, - { url = "https://files.pythonhosted.org/packages/6d/b5/348b3313c58f5fbfb2194eb4d07e46a35748ba6e5b3b3046143f3040bafa/jiter-0.10.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:1e274728e4a5345a6dde2d343c8da018b9d4bd4350f5a472fa91f66fda44911b", size = 312262, upload_time = "2025-05-18T19:03:44.637Z" }, - { url = "https://files.pythonhosted.org/packages/9c/4a/6a2397096162b21645162825f058d1709a02965606e537e3304b02742e9b/jiter-0.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7202ae396446c988cb2a5feb33a543ab2165b786ac97f53b59aafb803fef0744", size = 320124, upload_time = "2025-05-18T19:03:46.341Z" }, - { url = "https://files.pythonhosted.org/packages/2a/85/1ce02cade7516b726dd88f59a4ee46914bf79d1676d1228ef2002ed2f1c9/jiter-0.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23ba7722d6748b6920ed02a8f1726fb4b33e0fd2f3f621816a8b486c66410ab2", size = 345330, upload_time = "2025-05-18T19:03:47.596Z" }, - { url = "https://files.pythonhosted.org/packages/75/d0/bb6b4f209a77190ce10ea8d7e50bf3725fc16d3372d0a9f11985a2b23eff/jiter-0.10.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:371eab43c0a288537d30e1f0b193bc4eca90439fc08a022dd83e5e07500ed026", size = 369670, upload_time = "2025-05-18T19:03:49.334Z" }, - { url = "https://files.pythonhosted.org/packages/a0/f5/a61787da9b8847a601e6827fbc42ecb12be2c925ced3252c8ffcb56afcaf/jiter-0.10.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c675736059020365cebc845a820214765162728b51ab1e03a1b7b3abb70f74c", size = 489057, upload_time = "2025-05-18T19:03:50.66Z" }, - { url = "https://files.pythonhosted.org/packages/12/e4/6f906272810a7b21406c760a53aadbe52e99ee070fc5c0cb191e316de30b/jiter-0.10.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0c5867d40ab716e4684858e4887489685968a47e3ba222e44cde6e4a2154f959", size = 389372, upload_time = "2025-05-18T19:03:51.98Z" }, - { url = "https://files.pythonhosted.org/packages/e2/ba/77013b0b8ba904bf3762f11e0129b8928bff7f978a81838dfcc958ad5728/jiter-0.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:395bb9a26111b60141757d874d27fdea01b17e8fac958b91c20128ba8f4acc8a", size = 352038, upload_time = "2025-05-18T19:03:53.703Z" }, - { url = "https://files.pythonhosted.org/packages/67/27/c62568e3ccb03368dbcc44a1ef3a423cb86778a4389e995125d3d1aaa0a4/jiter-0.10.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6842184aed5cdb07e0c7e20e5bdcfafe33515ee1741a6835353bb45fe5d1bd95", size = 391538, upload_time = "2025-05-18T19:03:55.046Z" }, - { url = "https://files.pythonhosted.org/packages/c0/72/0d6b7e31fc17a8fdce76164884edef0698ba556b8eb0af9546ae1a06b91d/jiter-0.10.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:62755d1bcea9876770d4df713d82606c8c1a3dca88ff39046b85a048566d56ea", size = 523557, upload_time = "2025-05-18T19:03:56.386Z" }, - { url = "https://files.pythonhosted.org/packages/2f/09/bc1661fbbcbeb6244bd2904ff3a06f340aa77a2b94e5a7373fd165960ea3/jiter-0.10.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:533efbce2cacec78d5ba73a41756beff8431dfa1694b6346ce7af3a12c42202b", size = 514202, upload_time = "2025-05-18T19:03:57.675Z" }, - { url = "https://files.pythonhosted.org/packages/1b/84/5a5d5400e9d4d54b8004c9673bbe4403928a00d28529ff35b19e9d176b19/jiter-0.10.0-cp312-cp312-win32.whl", hash = "sha256:8be921f0cadd245e981b964dfbcd6fd4bc4e254cdc069490416dd7a2632ecc01", size = 211781, upload_time = "2025-05-18T19:03:59.025Z" }, - { url = "https://files.pythonhosted.org/packages/9b/52/7ec47455e26f2d6e5f2ea4951a0652c06e5b995c291f723973ae9e724a65/jiter-0.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:a7c7d785ae9dda68c2678532a5a1581347e9c15362ae9f6e68f3fdbfb64f2e49", size = 206176, upload_time = "2025-05-18T19:04:00.305Z" }, - { url = "https://files.pythonhosted.org/packages/2e/b0/279597e7a270e8d22623fea6c5d4eeac328e7d95c236ed51a2b884c54f70/jiter-0.10.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e0588107ec8e11b6f5ef0e0d656fb2803ac6cf94a96b2b9fc675c0e3ab5e8644", size = 311617, upload_time = "2025-05-18T19:04:02.078Z" }, - { url = "https://files.pythonhosted.org/packages/91/e3/0916334936f356d605f54cc164af4060e3e7094364add445a3bc79335d46/jiter-0.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cafc4628b616dc32530c20ee53d71589816cf385dd9449633e910d596b1f5c8a", size = 318947, upload_time = "2025-05-18T19:04:03.347Z" }, - { url = "https://files.pythonhosted.org/packages/6a/8e/fd94e8c02d0e94539b7d669a7ebbd2776e51f329bb2c84d4385e8063a2ad/jiter-0.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:520ef6d981172693786a49ff5b09eda72a42e539f14788124a07530f785c3ad6", size = 344618, upload_time = "2025-05-18T19:04:04.709Z" }, - { url = "https://files.pythonhosted.org/packages/6f/b0/f9f0a2ec42c6e9c2e61c327824687f1e2415b767e1089c1d9135f43816bd/jiter-0.10.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:554dedfd05937f8fc45d17ebdf298fe7e0c77458232bcb73d9fbbf4c6455f5b3", size = 368829, upload_time = "2025-05-18T19:04:06.912Z" }, - { url = "https://files.pythonhosted.org/packages/e8/57/5bbcd5331910595ad53b9fd0c610392ac68692176f05ae48d6ce5c852967/jiter-0.10.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5bc299da7789deacf95f64052d97f75c16d4fc8c4c214a22bf8d859a4288a1c2", size = 491034, upload_time = "2025-05-18T19:04:08.222Z" }, - { url = "https://files.pythonhosted.org/packages/9b/be/c393df00e6e6e9e623a73551774449f2f23b6ec6a502a3297aeeece2c65a/jiter-0.10.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5161e201172de298a8a1baad95eb85db4fb90e902353b1f6a41d64ea64644e25", size = 388529, upload_time = "2025-05-18T19:04:09.566Z" }, - { url = "https://files.pythonhosted.org/packages/42/3e/df2235c54d365434c7f150b986a6e35f41ebdc2f95acea3036d99613025d/jiter-0.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2e2227db6ba93cb3e2bf67c87e594adde0609f146344e8207e8730364db27041", size = 350671, upload_time = "2025-05-18T19:04:10.98Z" }, - { url = "https://files.pythonhosted.org/packages/c6/77/71b0b24cbcc28f55ab4dbfe029f9a5b73aeadaba677843fc6dc9ed2b1d0a/jiter-0.10.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:15acb267ea5e2c64515574b06a8bf393fbfee6a50eb1673614aa45f4613c0cca", size = 390864, upload_time = "2025-05-18T19:04:12.722Z" }, - { url = "https://files.pythonhosted.org/packages/6a/d3/ef774b6969b9b6178e1d1e7a89a3bd37d241f3d3ec5f8deb37bbd203714a/jiter-0.10.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:901b92f2e2947dc6dfcb52fd624453862e16665ea909a08398dde19c0731b7f4", size = 522989, upload_time = "2025-05-18T19:04:14.261Z" }, - { url = "https://files.pythonhosted.org/packages/0c/41/9becdb1d8dd5d854142f45a9d71949ed7e87a8e312b0bede2de849388cb9/jiter-0.10.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:d0cb9a125d5a3ec971a094a845eadde2db0de85b33c9f13eb94a0c63d463879e", size = 513495, upload_time = "2025-05-18T19:04:15.603Z" }, - { url = "https://files.pythonhosted.org/packages/9c/36/3468e5a18238bdedae7c4d19461265b5e9b8e288d3f86cd89d00cbb48686/jiter-0.10.0-cp313-cp313-win32.whl", hash = "sha256:48a403277ad1ee208fb930bdf91745e4d2d6e47253eedc96e2559d1e6527006d", size = 211289, upload_time = "2025-05-18T19:04:17.541Z" }, - { url = "https://files.pythonhosted.org/packages/7e/07/1c96b623128bcb913706e294adb5f768fb7baf8db5e1338ce7b4ee8c78ef/jiter-0.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:75f9eb72ecb640619c29bf714e78c9c46c9c4eaafd644bf78577ede459f330d4", size = 205074, upload_time = "2025-05-18T19:04:19.21Z" }, - { url = "https://files.pythonhosted.org/packages/54/46/caa2c1342655f57d8f0f2519774c6d67132205909c65e9aa8255e1d7b4f4/jiter-0.10.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:28ed2a4c05a1f32ef0e1d24c2611330219fed727dae01789f4a335617634b1ca", size = 318225, upload_time = "2025-05-18T19:04:20.583Z" }, - { url = "https://files.pythonhosted.org/packages/43/84/c7d44c75767e18946219ba2d703a5a32ab37b0bc21886a97bc6062e4da42/jiter-0.10.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14a4c418b1ec86a195f1ca69da8b23e8926c752b685af665ce30777233dfe070", size = 350235, upload_time = "2025-05-18T19:04:22.363Z" }, - { url = "https://files.pythonhosted.org/packages/01/16/f5a0135ccd968b480daad0e6ab34b0c7c5ba3bc447e5088152696140dcb3/jiter-0.10.0-cp313-cp313t-win_amd64.whl", hash = "sha256:d7bfed2fe1fe0e4dda6ef682cee888ba444b21e7a6553e03252e4feb6cf0adca", size = 207278, upload_time = "2025-05-18T19:04:23.627Z" }, - { url = "https://files.pythonhosted.org/packages/1c/9b/1d646da42c3de6c2188fdaa15bce8ecb22b635904fc68be025e21249ba44/jiter-0.10.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:5e9251a5e83fab8d87799d3e1a46cb4b7f2919b895c6f4483629ed2446f66522", size = 310866, upload_time = "2025-05-18T19:04:24.891Z" }, - { url = "https://files.pythonhosted.org/packages/ad/0e/26538b158e8a7c7987e94e7aeb2999e2e82b1f9d2e1f6e9874ddf71ebda0/jiter-0.10.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:023aa0204126fe5b87ccbcd75c8a0d0261b9abdbbf46d55e7ae9f8e22424eeb8", size = 318772, upload_time = "2025-05-18T19:04:26.161Z" }, - { url = "https://files.pythonhosted.org/packages/7b/fb/d302893151caa1c2636d6574d213e4b34e31fd077af6050a9c5cbb42f6fb/jiter-0.10.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c189c4f1779c05f75fc17c0c1267594ed918996a231593a21a5ca5438445216", size = 344534, upload_time = "2025-05-18T19:04:27.495Z" }, - { url = "https://files.pythonhosted.org/packages/01/d8/5780b64a149d74e347c5128d82176eb1e3241b1391ac07935693466d6219/jiter-0.10.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:15720084d90d1098ca0229352607cd68256c76991f6b374af96f36920eae13c4", size = 369087, upload_time = "2025-05-18T19:04:28.896Z" }, - { url = "https://files.pythonhosted.org/packages/e8/5b/f235a1437445160e777544f3ade57544daf96ba7e96c1a5b24a6f7ac7004/jiter-0.10.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e4f2fb68e5f1cfee30e2b2a09549a00683e0fde4c6a2ab88c94072fc33cb7426", size = 490694, upload_time = "2025-05-18T19:04:30.183Z" }, - { url = "https://files.pythonhosted.org/packages/85/a9/9c3d4617caa2ff89cf61b41e83820c27ebb3f7b5fae8a72901e8cd6ff9be/jiter-0.10.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce541693355fc6da424c08b7edf39a2895f58d6ea17d92cc2b168d20907dee12", size = 388992, upload_time = "2025-05-18T19:04:32.028Z" }, - { url = "https://files.pythonhosted.org/packages/68/b1/344fd14049ba5c94526540af7eb661871f9c54d5f5601ff41a959b9a0bbd/jiter-0.10.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31c50c40272e189d50006ad5c73883caabb73d4e9748a688b216e85a9a9ca3b9", size = 351723, upload_time = "2025-05-18T19:04:33.467Z" }, - { url = "https://files.pythonhosted.org/packages/41/89/4c0e345041186f82a31aee7b9d4219a910df672b9fef26f129f0cda07a29/jiter-0.10.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fa3402a2ff9815960e0372a47b75c76979d74402448509ccd49a275fa983ef8a", size = 392215, upload_time = "2025-05-18T19:04:34.827Z" }, - { url = "https://files.pythonhosted.org/packages/55/58/ee607863e18d3f895feb802154a2177d7e823a7103f000df182e0f718b38/jiter-0.10.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:1956f934dca32d7bb647ea21d06d93ca40868b505c228556d3373cbd255ce853", size = 522762, upload_time = "2025-05-18T19:04:36.19Z" }, - { url = "https://files.pythonhosted.org/packages/15/d0/9123fb41825490d16929e73c212de9a42913d68324a8ce3c8476cae7ac9d/jiter-0.10.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:fcedb049bdfc555e261d6f65a6abe1d5ad68825b7202ccb9692636c70fcced86", size = 513427, upload_time = "2025-05-18T19:04:37.544Z" }, - { url = "https://files.pythonhosted.org/packages/d8/b3/2bd02071c5a2430d0b70403a34411fc519c2f227da7b03da9ba6a956f931/jiter-0.10.0-cp314-cp314-win32.whl", hash = "sha256:ac509f7eccca54b2a29daeb516fb95b6f0bd0d0d8084efaf8ed5dfc7b9f0b357", size = 210127, upload_time = "2025-05-18T19:04:38.837Z" }, - { url = "https://files.pythonhosted.org/packages/03/0c/5fe86614ea050c3ecd728ab4035534387cd41e7c1855ef6c031f1ca93e3f/jiter-0.10.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5ed975b83a2b8639356151cef5c0d597c68376fc4922b45d0eb384ac058cfa00", size = 318527, upload_time = "2025-05-18T19:04:40.612Z" }, - { url = "https://files.pythonhosted.org/packages/b3/4a/4175a563579e884192ba6e81725fc0448b042024419be8d83aa8a80a3f44/jiter-0.10.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3aa96f2abba33dc77f79b4cf791840230375f9534e5fac927ccceb58c5e604a5", size = 354213, upload_time = "2025-05-18T19:04:41.894Z" }, -] - -[[package]] -name = "joblib" -version = "1.5.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/dc/fe/0f5a938c54105553436dbff7a61dc4fed4b1b2c98852f8833beaf4d5968f/joblib-1.5.1.tar.gz", hash = "sha256:f4f86e351f39fe3d0d32a9f2c3d8af1ee4cec285aafcb27003dda5205576b444", size = 330475, upload_time = "2025-05-23T12:04:37.097Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7d/4f/1195bbac8e0c2acc5f740661631d8d750dc38d4a32b23ee5df3cde6f4e0d/joblib-1.5.1-py3-none-any.whl", hash = "sha256:4719a31f054c7d766948dcd83e9613686b27114f190f717cec7eaa2084f8a74a", size = 307746, upload_time = "2025-05-23T12:04:35.124Z" }, -] - -[[package]] -name = "json-repair" -version = "0.47.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ae/9e/e8bcda4fd47b16fcd4f545af258d56ba337fa43b847beb213818d7641515/json_repair-0.47.6.tar.gz", hash = "sha256:4af5a14b9291d4d005a11537bae5a6b7912376d7584795f0ac1b23724b999620", size = 34400, upload_time = "2025-07-01T15:42:07.458Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/f8/f464ce2afc4be5decf53d0171c2d399d9ee6cd70d2273b8e85e7c6d00324/json_repair-0.47.6-py3-none-any.whl", hash = "sha256:1c9da58fb6240f99b8405f63534e08f8402793f09074dea25800a0b232d4fb19", size = 25754, upload_time = "2025-07-01T15:42:06.418Z" }, -] - -[[package]] -name = "jsonlines" -version = "4.0.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "attrs" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/35/87/bcda8e46c88d0e34cad2f09ee2d0c7f5957bccdb9791b0b934ec84d84be4/jsonlines-4.0.0.tar.gz", hash = "sha256:0c6d2c09117550c089995247f605ae4cf77dd1533041d366351f6f298822ea74", size = 11359, upload_time = "2023-09-01T12:34:44.187Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", hash = "sha256:185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55", size = 8701, upload_time = "2023-09-01T12:34:42.563Z" }, -] - -[[package]] -name = "kiwisolver" -version = "1.4.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538, upload_time = "2024-12-24T18:30:51.519Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/47/5f/4d8e9e852d98ecd26cdf8eaf7ed8bc33174033bba5e07001b289f07308fd/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88c6f252f6816a73b1f8c904f7bbe02fd67c09a69f7cb8a0eecdbf5ce78e63db", size = 124623, upload_time = "2024-12-24T18:28:17.687Z" }, - { url = "https://files.pythonhosted.org/packages/1d/70/7f5af2a18a76fe92ea14675f8bd88ce53ee79e37900fa5f1a1d8e0b42998/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c72941acb7b67138f35b879bbe85be0f6c6a70cab78fe3ef6db9c024d9223e5b", size = 66720, upload_time = "2024-12-24T18:28:19.158Z" }, - { url = "https://files.pythonhosted.org/packages/c6/13/e15f804a142353aefd089fadc8f1d985561a15358c97aca27b0979cb0785/kiwisolver-1.4.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce2cf1e5688edcb727fdf7cd1bbd0b6416758996826a8be1d958f91880d0809d", size = 65413, upload_time = "2024-12-24T18:28:20.064Z" }, - { url = "https://files.pythonhosted.org/packages/ce/6d/67d36c4d2054e83fb875c6b59d0809d5c530de8148846b1370475eeeece9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c8bf637892dc6e6aad2bc6d4d69d08764166e5e3f69d469e55427b6ac001b19d", size = 1650826, upload_time = "2024-12-24T18:28:21.203Z" }, - { url = "https://files.pythonhosted.org/packages/de/c6/7b9bb8044e150d4d1558423a1568e4f227193662a02231064e3824f37e0a/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:034d2c891f76bd3edbdb3ea11140d8510dca675443da7304205a2eaa45d8334c", size = 1628231, upload_time = "2024-12-24T18:28:23.851Z" }, - { url = "https://files.pythonhosted.org/packages/b6/38/ad10d437563063eaaedbe2c3540a71101fc7fb07a7e71f855e93ea4de605/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d47b28d1dfe0793d5e96bce90835e17edf9a499b53969b03c6c47ea5985844c3", size = 1408938, upload_time = "2024-12-24T18:28:26.687Z" }, - { url = "https://files.pythonhosted.org/packages/52/ce/c0106b3bd7f9e665c5f5bc1e07cc95b5dabd4e08e3dad42dbe2faad467e7/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb158fe28ca0c29f2260cca8c43005329ad58452c36f0edf298204de32a9a3ed", size = 1422799, upload_time = "2024-12-24T18:28:30.538Z" }, - { url = "https://files.pythonhosted.org/packages/d0/87/efb704b1d75dc9758087ba374c0f23d3254505edaedd09cf9d247f7878b9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5536185fce131780ebd809f8e623bf4030ce1b161353166c49a3c74c287897f", size = 1354362, upload_time = "2024-12-24T18:28:32.943Z" }, - { url = "https://files.pythonhosted.org/packages/eb/b3/fd760dc214ec9a8f208b99e42e8f0130ff4b384eca8b29dd0efc62052176/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:369b75d40abedc1da2c1f4de13f3482cb99e3237b38726710f4a793432b1c5ff", size = 2222695, upload_time = "2024-12-24T18:28:35.641Z" }, - { url = "https://files.pythonhosted.org/packages/a2/09/a27fb36cca3fc01700687cc45dae7a6a5f8eeb5f657b9f710f788748e10d/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:641f2ddf9358c80faa22e22eb4c9f54bd3f0e442e038728f500e3b978d00aa7d", size = 2370802, upload_time = "2024-12-24T18:28:38.357Z" }, - { url = "https://files.pythonhosted.org/packages/3d/c3/ba0a0346db35fe4dc1f2f2cf8b99362fbb922d7562e5f911f7ce7a7b60fa/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d561d2d8883e0819445cfe58d7ddd673e4015c3c57261d7bdcd3710d0d14005c", size = 2334646, upload_time = "2024-12-24T18:28:40.941Z" }, - { url = "https://files.pythonhosted.org/packages/41/52/942cf69e562f5ed253ac67d5c92a693745f0bed3c81f49fc0cbebe4d6b00/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1732e065704b47c9afca7ffa272f845300a4eb959276bf6970dc07265e73b605", size = 2467260, upload_time = "2024-12-24T18:28:42.273Z" }, - { url = "https://files.pythonhosted.org/packages/32/26/2d9668f30d8a494b0411d4d7d4ea1345ba12deb6a75274d58dd6ea01e951/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bcb1ebc3547619c3b58a39e2448af089ea2ef44b37988caf432447374941574e", size = 2288633, upload_time = "2024-12-24T18:28:44.87Z" }, - { url = "https://files.pythonhosted.org/packages/98/99/0dd05071654aa44fe5d5e350729961e7bb535372935a45ac89a8924316e6/kiwisolver-1.4.8-cp310-cp310-win_amd64.whl", hash = "sha256:89c107041f7b27844179ea9c85d6da275aa55ecf28413e87624d033cf1f6b751", size = 71885, upload_time = "2024-12-24T18:28:47.346Z" }, - { url = "https://files.pythonhosted.org/packages/6c/fc/822e532262a97442989335394d441cd1d0448c2e46d26d3e04efca84df22/kiwisolver-1.4.8-cp310-cp310-win_arm64.whl", hash = "sha256:b5773efa2be9eb9fcf5415ea3ab70fc785d598729fd6057bea38d539ead28271", size = 65175, upload_time = "2024-12-24T18:28:49.651Z" }, - { url = "https://files.pythonhosted.org/packages/da/ed/c913ee28936c371418cb167b128066ffb20bbf37771eecc2c97edf8a6e4c/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a4d3601908c560bdf880f07d94f31d734afd1bb71e96585cace0e38ef44c6d84", size = 124635, upload_time = "2024-12-24T18:28:51.826Z" }, - { url = "https://files.pythonhosted.org/packages/4c/45/4a7f896f7467aaf5f56ef093d1f329346f3b594e77c6a3c327b2d415f521/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:856b269c4d28a5c0d5e6c1955ec36ebfd1651ac00e1ce0afa3e28da95293b561", size = 66717, upload_time = "2024-12-24T18:28:54.256Z" }, - { url = "https://files.pythonhosted.org/packages/5f/b4/c12b3ac0852a3a68f94598d4c8d569f55361beef6159dce4e7b624160da2/kiwisolver-1.4.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c2b9a96e0f326205af81a15718a9073328df1173a2619a68553decb7097fd5d7", size = 65413, upload_time = "2024-12-24T18:28:55.184Z" }, - { url = "https://files.pythonhosted.org/packages/a9/98/1df4089b1ed23d83d410adfdc5947245c753bddfbe06541c4aae330e9e70/kiwisolver-1.4.8-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5020c83e8553f770cb3b5fc13faac40f17e0b205bd237aebd21d53d733adb03", size = 1343994, upload_time = "2024-12-24T18:28:57.493Z" }, - { url = "https://files.pythonhosted.org/packages/8d/bf/b4b169b050c8421a7c53ea1ea74e4ef9c335ee9013216c558a047f162d20/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dace81d28c787956bfbfbbfd72fdcef014f37d9b48830829e488fdb32b49d954", size = 1434804, upload_time = "2024-12-24T18:29:00.077Z" }, - { url = "https://files.pythonhosted.org/packages/66/5a/e13bd341fbcf73325ea60fdc8af752addf75c5079867af2e04cc41f34434/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11e1022b524bd48ae56c9b4f9296bce77e15a2e42a502cceba602f804b32bb79", size = 1450690, upload_time = "2024-12-24T18:29:01.401Z" }, - { url = "https://files.pythonhosted.org/packages/9b/4f/5955dcb376ba4a830384cc6fab7d7547bd6759fe75a09564910e9e3bb8ea/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b9b4d2892fefc886f30301cdd80debd8bb01ecdf165a449eb6e78f79f0fabd6", size = 1376839, upload_time = "2024-12-24T18:29:02.685Z" }, - { url = "https://files.pythonhosted.org/packages/3a/97/5edbed69a9d0caa2e4aa616ae7df8127e10f6586940aa683a496c2c280b9/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a96c0e790ee875d65e340ab383700e2b4891677b7fcd30a699146f9384a2bb0", size = 1435109, upload_time = "2024-12-24T18:29:04.113Z" }, - { url = "https://files.pythonhosted.org/packages/13/fc/e756382cb64e556af6c1809a1bbb22c141bbc2445049f2da06b420fe52bf/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:23454ff084b07ac54ca8be535f4174170c1094a4cff78fbae4f73a4bcc0d4dab", size = 2245269, upload_time = "2024-12-24T18:29:05.488Z" }, - { url = "https://files.pythonhosted.org/packages/76/15/e59e45829d7f41c776d138245cabae6515cb4eb44b418f6d4109c478b481/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:87b287251ad6488e95b4f0b4a79a6d04d3ea35fde6340eb38fbd1ca9cd35bbbc", size = 2393468, upload_time = "2024-12-24T18:29:06.79Z" }, - { url = "https://files.pythonhosted.org/packages/e9/39/483558c2a913ab8384d6e4b66a932406f87c95a6080112433da5ed668559/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b21dbe165081142b1232a240fc6383fd32cdd877ca6cc89eab93e5f5883e1c25", size = 2355394, upload_time = "2024-12-24T18:29:08.24Z" }, - { url = "https://files.pythonhosted.org/packages/01/aa/efad1fbca6570a161d29224f14b082960c7e08268a133fe5dc0f6906820e/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:768cade2c2df13db52475bd28d3a3fac8c9eff04b0e9e2fda0f3760f20b3f7fc", size = 2490901, upload_time = "2024-12-24T18:29:09.653Z" }, - { url = "https://files.pythonhosted.org/packages/c9/4f/15988966ba46bcd5ab9d0c8296914436720dd67fca689ae1a75b4ec1c72f/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d47cfb2650f0e103d4bf68b0b5804c68da97272c84bb12850d877a95c056bd67", size = 2312306, upload_time = "2024-12-24T18:29:12.644Z" }, - { url = "https://files.pythonhosted.org/packages/2d/27/bdf1c769c83f74d98cbc34483a972f221440703054894a37d174fba8aa68/kiwisolver-1.4.8-cp311-cp311-win_amd64.whl", hash = "sha256:ed33ca2002a779a2e20eeb06aea7721b6e47f2d4b8a8ece979d8ba9e2a167e34", size = 71966, upload_time = "2024-12-24T18:29:14.089Z" }, - { url = "https://files.pythonhosted.org/packages/4a/c9/9642ea855604aeb2968a8e145fc662edf61db7632ad2e4fb92424be6b6c0/kiwisolver-1.4.8-cp311-cp311-win_arm64.whl", hash = "sha256:16523b40aab60426ffdebe33ac374457cf62863e330a90a0383639ce14bf44b2", size = 65311, upload_time = "2024-12-24T18:29:15.892Z" }, - { url = "https://files.pythonhosted.org/packages/fc/aa/cea685c4ab647f349c3bc92d2daf7ae34c8e8cf405a6dcd3a497f58a2ac3/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6af5e8815fd02997cb6ad9bbed0ee1e60014438ee1a5c2444c96f87b8843502", size = 124152, upload_time = "2024-12-24T18:29:16.85Z" }, - { url = "https://files.pythonhosted.org/packages/c5/0b/8db6d2e2452d60d5ebc4ce4b204feeb16176a851fd42462f66ade6808084/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bade438f86e21d91e0cf5dd7c0ed00cda0f77c8c1616bd83f9fc157fa6760d31", size = 66555, upload_time = "2024-12-24T18:29:19.146Z" }, - { url = "https://files.pythonhosted.org/packages/60/26/d6a0db6785dd35d3ba5bf2b2df0aedc5af089962c6eb2cbf67a15b81369e/kiwisolver-1.4.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b83dc6769ddbc57613280118fb4ce3cd08899cc3369f7d0e0fab518a7cf37fdb", size = 65067, upload_time = "2024-12-24T18:29:20.096Z" }, - { url = "https://files.pythonhosted.org/packages/c9/ed/1d97f7e3561e09757a196231edccc1bcf59d55ddccefa2afc9c615abd8e0/kiwisolver-1.4.8-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111793b232842991be367ed828076b03d96202c19221b5ebab421ce8bcad016f", size = 1378443, upload_time = "2024-12-24T18:29:22.843Z" }, - { url = "https://files.pythonhosted.org/packages/29/61/39d30b99954e6b46f760e6289c12fede2ab96a254c443639052d1b573fbc/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:257af1622860e51b1a9d0ce387bf5c2c4f36a90594cb9514f55b074bcc787cfc", size = 1472728, upload_time = "2024-12-24T18:29:24.463Z" }, - { url = "https://files.pythonhosted.org/packages/0c/3e/804163b932f7603ef256e4a715e5843a9600802bb23a68b4e08c8c0ff61d/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b5637c3f316cab1ec1c9a12b8c5f4750a4c4b71af9157645bf32830e39c03a", size = 1478388, upload_time = "2024-12-24T18:29:25.776Z" }, - { url = "https://files.pythonhosted.org/packages/8a/9e/60eaa75169a154700be74f875a4d9961b11ba048bef315fbe89cb6999056/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:782bb86f245ec18009890e7cb8d13a5ef54dcf2ebe18ed65f795e635a96a1c6a", size = 1413849, upload_time = "2024-12-24T18:29:27.202Z" }, - { url = "https://files.pythonhosted.org/packages/bc/b3/9458adb9472e61a998c8c4d95cfdfec91c73c53a375b30b1428310f923e4/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc978a80a0db3a66d25767b03688f1147a69e6237175c0f4ffffaaedf744055a", size = 1475533, upload_time = "2024-12-24T18:29:28.638Z" }, - { url = "https://files.pythonhosted.org/packages/e4/7a/0a42d9571e35798de80aef4bb43a9b672aa7f8e58643d7bd1950398ffb0a/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:36dbbfd34838500a31f52c9786990d00150860e46cd5041386f217101350f0d3", size = 2268898, upload_time = "2024-12-24T18:29:30.368Z" }, - { url = "https://files.pythonhosted.org/packages/d9/07/1255dc8d80271400126ed8db35a1795b1a2c098ac3a72645075d06fe5c5d/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eaa973f1e05131de5ff3569bbba7f5fd07ea0595d3870ed4a526d486fe57fa1b", size = 2425605, upload_time = "2024-12-24T18:29:33.151Z" }, - { url = "https://files.pythonhosted.org/packages/84/df/5a3b4cf13780ef6f6942df67b138b03b7e79e9f1f08f57c49957d5867f6e/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a66f60f8d0c87ab7f59b6fb80e642ebb29fec354a4dfad687ca4092ae69d04f4", size = 2375801, upload_time = "2024-12-24T18:29:34.584Z" }, - { url = "https://files.pythonhosted.org/packages/8f/10/2348d068e8b0f635c8c86892788dac7a6b5c0cb12356620ab575775aad89/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858416b7fb777a53f0c59ca08190ce24e9abbd3cffa18886a5781b8e3e26f65d", size = 2520077, upload_time = "2024-12-24T18:29:36.138Z" }, - { url = "https://files.pythonhosted.org/packages/32/d8/014b89fee5d4dce157d814303b0fce4d31385a2af4c41fed194b173b81ac/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:085940635c62697391baafaaeabdf3dd7a6c3643577dde337f4d66eba021b2b8", size = 2338410, upload_time = "2024-12-24T18:29:39.991Z" }, - { url = "https://files.pythonhosted.org/packages/bd/72/dfff0cc97f2a0776e1c9eb5bef1ddfd45f46246c6533b0191887a427bca5/kiwisolver-1.4.8-cp312-cp312-win_amd64.whl", hash = "sha256:01c3d31902c7db5fb6182832713d3b4122ad9317c2c5877d0539227d96bb2e50", size = 71853, upload_time = "2024-12-24T18:29:42.006Z" }, - { url = "https://files.pythonhosted.org/packages/dc/85/220d13d914485c0948a00f0b9eb419efaf6da81b7d72e88ce2391f7aed8d/kiwisolver-1.4.8-cp312-cp312-win_arm64.whl", hash = "sha256:a3c44cb68861de93f0c4a8175fbaa691f0aa22550c331fefef02b618a9dcb476", size = 65424, upload_time = "2024-12-24T18:29:44.38Z" }, - { url = "https://files.pythonhosted.org/packages/79/b3/e62464a652f4f8cd9006e13d07abad844a47df1e6537f73ddfbf1bc997ec/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1c8ceb754339793c24aee1c9fb2485b5b1f5bb1c2c214ff13368431e51fc9a09", size = 124156, upload_time = "2024-12-24T18:29:45.368Z" }, - { url = "https://files.pythonhosted.org/packages/8d/2d/f13d06998b546a2ad4f48607a146e045bbe48030774de29f90bdc573df15/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a62808ac74b5e55a04a408cda6156f986cefbcf0ada13572696b507cc92fa1", size = 66555, upload_time = "2024-12-24T18:29:46.37Z" }, - { url = "https://files.pythonhosted.org/packages/59/e3/b8bd14b0a54998a9fd1e8da591c60998dc003618cb19a3f94cb233ec1511/kiwisolver-1.4.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:68269e60ee4929893aad82666821aaacbd455284124817af45c11e50a4b42e3c", size = 65071, upload_time = "2024-12-24T18:29:47.333Z" }, - { url = "https://files.pythonhosted.org/packages/f0/1c/6c86f6d85ffe4d0ce04228d976f00674f1df5dc893bf2dd4f1928748f187/kiwisolver-1.4.8-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34d142fba9c464bc3bbfeff15c96eab0e7310343d6aefb62a79d51421fcc5f1b", size = 1378053, upload_time = "2024-12-24T18:29:49.636Z" }, - { url = "https://files.pythonhosted.org/packages/4e/b9/1c6e9f6dcb103ac5cf87cb695845f5fa71379021500153566d8a8a9fc291/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc373e0eef45b59197de815b1b28ef89ae3955e7722cc9710fb91cd77b7f47", size = 1472278, upload_time = "2024-12-24T18:29:51.164Z" }, - { url = "https://files.pythonhosted.org/packages/ee/81/aca1eb176de671f8bda479b11acdc42c132b61a2ac861c883907dde6debb/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77e6f57a20b9bd4e1e2cedda4d0b986ebd0216236f0106e55c28aea3d3d69b16", size = 1478139, upload_time = "2024-12-24T18:29:52.594Z" }, - { url = "https://files.pythonhosted.org/packages/49/f4/e081522473671c97b2687d380e9e4c26f748a86363ce5af48b4a28e48d06/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08e77738ed7538f036cd1170cbed942ef749137b1311fa2bbe2a7fda2f6bf3cc", size = 1413517, upload_time = "2024-12-24T18:29:53.941Z" }, - { url = "https://files.pythonhosted.org/packages/8f/e9/6a7d025d8da8c4931522922cd706105aa32b3291d1add8c5427cdcd66e63/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5ce1e481a74b44dd5e92ff03ea0cb371ae7a0268318e202be06c8f04f4f1246", size = 1474952, upload_time = "2024-12-24T18:29:56.523Z" }, - { url = "https://files.pythonhosted.org/packages/82/13/13fa685ae167bee5d94b415991c4fc7bb0a1b6ebea6e753a87044b209678/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc2ace710ba7c1dfd1a3b42530b62b9ceed115f19a1656adefce7b1782a37794", size = 2269132, upload_time = "2024-12-24T18:29:57.989Z" }, - { url = "https://files.pythonhosted.org/packages/ef/92/bb7c9395489b99a6cb41d502d3686bac692586db2045adc19e45ee64ed23/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3452046c37c7692bd52b0e752b87954ef86ee2224e624ef7ce6cb21e8c41cc1b", size = 2425997, upload_time = "2024-12-24T18:29:59.393Z" }, - { url = "https://files.pythonhosted.org/packages/ed/12/87f0e9271e2b63d35d0d8524954145837dd1a6c15b62a2d8c1ebe0f182b4/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e9a60b50fe8b2ec6f448fe8d81b07e40141bfced7f896309df271a0b92f80f3", size = 2376060, upload_time = "2024-12-24T18:30:01.338Z" }, - { url = "https://files.pythonhosted.org/packages/02/6e/c8af39288edbce8bf0fa35dee427b082758a4b71e9c91ef18fa667782138/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:918139571133f366e8362fa4a297aeba86c7816b7ecf0bc79168080e2bd79957", size = 2520471, upload_time = "2024-12-24T18:30:04.574Z" }, - { url = "https://files.pythonhosted.org/packages/13/78/df381bc7b26e535c91469f77f16adcd073beb3e2dd25042efd064af82323/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e063ef9f89885a1d68dd8b2e18f5ead48653176d10a0e324e3b0030e3a69adeb", size = 2338793, upload_time = "2024-12-24T18:30:06.25Z" }, - { url = "https://files.pythonhosted.org/packages/d0/dc/c1abe38c37c071d0fc71c9a474fd0b9ede05d42f5a458d584619cfd2371a/kiwisolver-1.4.8-cp313-cp313-win_amd64.whl", hash = "sha256:a17b7c4f5b2c51bb68ed379defd608a03954a1845dfed7cc0117f1cc8a9b7fd2", size = 71855, upload_time = "2024-12-24T18:30:07.535Z" }, - { url = "https://files.pythonhosted.org/packages/a0/b6/21529d595b126ac298fdd90b705d87d4c5693de60023e0efcb4f387ed99e/kiwisolver-1.4.8-cp313-cp313-win_arm64.whl", hash = "sha256:3cd3bc628b25f74aedc6d374d5babf0166a92ff1317f46267f12d2ed54bc1d30", size = 65430, upload_time = "2024-12-24T18:30:08.504Z" }, - { url = "https://files.pythonhosted.org/packages/34/bd/b89380b7298e3af9b39f49334e3e2a4af0e04819789f04b43d560516c0c8/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370fd2df41660ed4e26b8c9d6bbcad668fbe2560462cba151a721d49e5b6628c", size = 126294, upload_time = "2024-12-24T18:30:09.508Z" }, - { url = "https://files.pythonhosted.org/packages/83/41/5857dc72e5e4148eaac5aa76e0703e594e4465f8ab7ec0fc60e3a9bb8fea/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:84a2f830d42707de1d191b9490ac186bf7997a9495d4e9072210a1296345f7dc", size = 67736, upload_time = "2024-12-24T18:30:11.039Z" }, - { url = "https://files.pythonhosted.org/packages/e1/d1/be059b8db56ac270489fb0b3297fd1e53d195ba76e9bbb30e5401fa6b759/kiwisolver-1.4.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7a3ad337add5148cf51ce0b55642dc551c0b9d6248458a757f98796ca7348712", size = 66194, upload_time = "2024-12-24T18:30:14.886Z" }, - { url = "https://files.pythonhosted.org/packages/e1/83/4b73975f149819eb7dcf9299ed467eba068ecb16439a98990dcb12e63fdd/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7506488470f41169b86d8c9aeff587293f530a23a23a49d6bc64dab66bedc71e", size = 1465942, upload_time = "2024-12-24T18:30:18.927Z" }, - { url = "https://files.pythonhosted.org/packages/c7/2c/30a5cdde5102958e602c07466bce058b9d7cb48734aa7a4327261ac8e002/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f0121b07b356a22fb0414cec4666bbe36fd6d0d759db3d37228f496ed67c880", size = 1595341, upload_time = "2024-12-24T18:30:22.102Z" }, - { url = "https://files.pythonhosted.org/packages/ff/9b/1e71db1c000385aa069704f5990574b8244cce854ecd83119c19e83c9586/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6d6bd87df62c27d4185de7c511c6248040afae67028a8a22012b010bc7ad062", size = 1598455, upload_time = "2024-12-24T18:30:24.947Z" }, - { url = "https://files.pythonhosted.org/packages/85/92/c8fec52ddf06231b31cbb779af77e99b8253cd96bd135250b9498144c78b/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:291331973c64bb9cce50bbe871fb2e675c4331dab4f31abe89f175ad7679a4d7", size = 1522138, upload_time = "2024-12-24T18:30:26.286Z" }, - { url = "https://files.pythonhosted.org/packages/0b/51/9eb7e2cd07a15d8bdd976f6190c0164f92ce1904e5c0c79198c4972926b7/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:893f5525bb92d3d735878ec00f781b2de998333659507d29ea4466208df37bed", size = 1582857, upload_time = "2024-12-24T18:30:28.86Z" }, - { url = "https://files.pythonhosted.org/packages/0f/95/c5a00387a5405e68ba32cc64af65ce881a39b98d73cc394b24143bebc5b8/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b47a465040146981dc9db8647981b8cb96366fbc8d452b031e4f8fdffec3f26d", size = 2293129, upload_time = "2024-12-24T18:30:30.34Z" }, - { url = "https://files.pythonhosted.org/packages/44/83/eeb7af7d706b8347548313fa3a3a15931f404533cc54fe01f39e830dd231/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:99cea8b9dd34ff80c521aef46a1dddb0dcc0283cf18bde6d756f1e6f31772165", size = 2421538, upload_time = "2024-12-24T18:30:33.334Z" }, - { url = "https://files.pythonhosted.org/packages/05/f9/27e94c1b3eb29e6933b6986ffc5fa1177d2cd1f0c8efc5f02c91c9ac61de/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:151dffc4865e5fe6dafce5480fab84f950d14566c480c08a53c663a0020504b6", size = 2390661, upload_time = "2024-12-24T18:30:34.939Z" }, - { url = "https://files.pythonhosted.org/packages/d9/d4/3c9735faa36ac591a4afcc2980d2691000506050b7a7e80bcfe44048daa7/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:577facaa411c10421314598b50413aa1ebcf5126f704f1e5d72d7e4e9f020d90", size = 2546710, upload_time = "2024-12-24T18:30:37.281Z" }, - { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213, upload_time = "2024-12-24T18:30:40.019Z" }, - { url = "https://files.pythonhosted.org/packages/1f/f9/ae81c47a43e33b93b0a9819cac6723257f5da2a5a60daf46aa5c7226ea85/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e7a019419b7b510f0f7c9dceff8c5eae2392037eae483a7f9162625233802b0a", size = 60403, upload_time = "2024-12-24T18:30:41.372Z" }, - { url = "https://files.pythonhosted.org/packages/58/ca/f92b5cb6f4ce0c1ebfcfe3e2e42b96917e16f7090e45b21102941924f18f/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:286b18e86682fd2217a48fc6be6b0f20c1d0ed10958d8dc53453ad58d7be0bf8", size = 58657, upload_time = "2024-12-24T18:30:42.392Z" }, - { url = "https://files.pythonhosted.org/packages/80/28/ae0240f732f0484d3a4dc885d055653c47144bdf59b670aae0ec3c65a7c8/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4191ee8dfd0be1c3666ccbac178c5a05d5f8d689bbe3fc92f3c4abec817f8fe0", size = 84948, upload_time = "2024-12-24T18:30:44.703Z" }, - { url = "https://files.pythonhosted.org/packages/5d/eb/78d50346c51db22c7203c1611f9b513075f35c4e0e4877c5dde378d66043/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd2785b9391f2873ad46088ed7599a6a71e762e1ea33e87514b1a441ed1da1c", size = 81186, upload_time = "2024-12-24T18:30:45.654Z" }, - { url = "https://files.pythonhosted.org/packages/43/f8/7259f18c77adca88d5f64f9a522792e178b2691f3748817a8750c2d216ef/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c07b29089b7ba090b6f1a669f1411f27221c3662b3a1b7010e67b59bb5a6f10b", size = 80279, upload_time = "2024-12-24T18:30:47.951Z" }, - { url = "https://files.pythonhosted.org/packages/3a/1d/50ad811d1c5dae091e4cf046beba925bcae0a610e79ae4c538f996f63ed5/kiwisolver-1.4.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:65ea09a5a3faadd59c2ce96dc7bf0f364986a315949dc6374f04396b0d60e09b", size = 71762, upload_time = "2024-12-24T18:30:48.903Z" }, -] - -[[package]] -name = "maibot" -version = "0.8.1" -source = { virtual = "." } -dependencies = [ - { name = "aiohttp" }, - { name = "apscheduler" }, - { name = "colorama" }, - { name = "cryptography" }, - { name = "customtkinter" }, - { name = "dotenv" }, - { name = "faiss-cpu" }, - { name = "fastapi" }, - { name = "jieba" }, - { name = "json-repair" }, - { name = "jsonlines" }, - { name = "maim-message" }, - { name = "matplotlib" }, - { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "openai" }, - { name = "packaging" }, - { name = "pandas" }, - { name = "peewee" }, - { name = "pillow" }, - { name = "psutil" }, - { name = "pyarrow" }, - { name = "pydantic" }, - { name = "pymongo" }, - { name = "pypinyin" }, - { name = "python-dateutil" }, - { name = "python-dotenv" }, - { name = "python-igraph" }, - { name = "quick-algo" }, - { name = "reportportal-client" }, - { name = "requests" }, - { name = "rich" }, - { name = "ruff" }, - { name = "scikit-learn" }, - { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "scipy", version = "1.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "seaborn" }, - { name = "setuptools" }, - { name = "strawberry-graphql", extra = ["fastapi"] }, - { name = "structlog" }, - { name = "toml" }, - { name = "tomli" }, - { name = "tomli-w" }, - { name = "tomlkit" }, - { name = "tqdm" }, - { name = "urllib3" }, - { name = "uvicorn" }, - { name = "websockets" }, -] - -[package.metadata] -requires-dist = [ - { name = "aiohttp", specifier = ">=3.12.14" }, - { name = "apscheduler", specifier = ">=3.11.0" }, - { name = "colorama", specifier = ">=0.4.6" }, - { name = "cryptography", specifier = ">=45.0.5" }, - { name = "customtkinter", specifier = ">=5.2.2" }, - { name = "dotenv", specifier = ">=0.9.9" }, - { name = "faiss-cpu", specifier = ">=1.11.0" }, - { name = "fastapi", specifier = ">=0.116.0" }, - { name = "jieba", specifier = ">=0.42.1" }, - { name = "json-repair", specifier = ">=0.47.6" }, - { name = "jsonlines", specifier = ">=4.0.0" }, - { name = "maim-message", specifier = ">=0.3.8" }, - { name = "matplotlib", specifier = ">=3.10.3" }, - { name = "networkx", specifier = ">=3.4.2" }, - { name = "numpy", specifier = ">=2.2.6" }, - { name = "openai", specifier = ">=1.95.0" }, - { name = "packaging", specifier = ">=25.0" }, - { name = "pandas", specifier = ">=2.3.1" }, - { name = "peewee", specifier = ">=3.18.2" }, - { name = "pillow", specifier = ">=11.3.0" }, - { name = "psutil", specifier = ">=7.0.0" }, - { name = "pyarrow", specifier = ">=20.0.0" }, - { name = "pydantic", specifier = ">=2.11.7" }, - { name = "pymongo", specifier = ">=4.13.2" }, - { name = "pypinyin", specifier = ">=0.54.0" }, - { name = "python-dateutil", specifier = ">=2.9.0.post0" }, - { name = "python-dotenv", specifier = ">=1.1.1" }, - { name = "python-igraph", specifier = ">=0.11.9" }, - { name = "quick-algo", specifier = ">=0.1.3" }, - { name = "reportportal-client", specifier = ">=5.6.5" }, - { name = "requests", specifier = ">=2.32.4" }, - { name = "rich", specifier = ">=14.0.0" }, - { name = "ruff", specifier = ">=0.12.2" }, - { name = "scikit-learn", specifier = ">=1.7.0" }, - { name = "scipy", specifier = ">=1.15.3" }, - { name = "seaborn", specifier = ">=0.13.2" }, - { name = "setuptools", specifier = ">=80.9.0" }, - { name = "strawberry-graphql", extras = ["fastapi"], specifier = ">=0.275.5" }, - { name = "structlog", specifier = ">=25.4.0" }, - { name = "toml", specifier = ">=0.10.2" }, - { name = "tomli", specifier = ">=2.2.1" }, - { name = "tomli-w", specifier = ">=1.2.0" }, - { name = "tomlkit", specifier = ">=0.13.3" }, - { name = "tqdm", specifier = ">=4.67.1" }, - { name = "urllib3", specifier = ">=2.5.0" }, - { name = "uvicorn", specifier = ">=0.35.0" }, - { name = "websockets", specifier = ">=15.0.1" }, -] - -[[package]] -name = "maim-message" -version = "0.3.8" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aiohttp" }, - { name = "cryptography" }, - { name = "fastapi" }, - { name = "pydantic" }, - { name = "uvicorn" }, - { name = "websockets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/82/42/49ce67a12cfb7c75b9a7f44fab9312585881aee9f2ddc4109f2626b0f564/maim_message-0.3.8.tar.gz", hash = "sha256:fb0ee63fcad9da003091c384a95ba955bfeda4f0ba69557fe1ca0e19c71dfd11", size = 604914, upload_time = "2025-07-06T06:14:58.884Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a8/bb/2e52f575d4110fdef811a3939b565a89b4ec06082b40cb7c7e1eee40ef67/maim_message-0.3.8-py3-none-any.whl", hash = "sha256:967570cbe7892ced9bc0de912c6a76f5f71000120f8489d1a2ac2f808f5ffe89", size = 26061, upload_time = "2025-07-06T06:14:53.891Z" }, -] - -[[package]] -name = "markdown-it-py" -version = "3.0.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "mdurl" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload_time = "2023-06-03T06:41:14.443Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload_time = "2023-06-03T06:41:11.019Z" }, -] - -[[package]] -name = "matplotlib" -version = "3.10.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "contourpy" }, - { name = "cycler" }, - { name = "fonttools" }, - { name = "kiwisolver" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "packaging" }, - { name = "pillow" }, - { name = "pyparsing" }, - { name = "python-dateutil" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/26/91/d49359a21893183ed2a5b6c76bec40e0b1dcbf8ca148f864d134897cfc75/matplotlib-3.10.3.tar.gz", hash = "sha256:2f82d2c5bb7ae93aaaa4cd42aca65d76ce6376f83304fa3a630b569aca274df0", size = 34799811, upload_time = "2025-05-08T19:10:54.39Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/ea/2bba25d289d389c7451f331ecd593944b3705f06ddf593fa7be75037d308/matplotlib-3.10.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:213fadd6348d106ca7db99e113f1bea1e65e383c3ba76e8556ba4a3054b65ae7", size = 8167862, upload_time = "2025-05-08T19:09:39.563Z" }, - { url = "https://files.pythonhosted.org/packages/41/81/cc70b5138c926604e8c9ed810ed4c79e8116ba72e02230852f5c12c87ba2/matplotlib-3.10.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3bec61cb8221f0ca6313889308326e7bb303d0d302c5cc9e523b2f2e6c73deb", size = 8042149, upload_time = "2025-05-08T19:09:42.413Z" }, - { url = "https://files.pythonhosted.org/packages/4a/9a/0ff45b6bfa42bb16de597e6058edf2361c298ad5ef93b327728145161bbf/matplotlib-3.10.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c21ae75651c0231b3ba014b6d5e08fb969c40cdb5a011e33e99ed0c9ea86ecb", size = 8453719, upload_time = "2025-05-08T19:09:44.901Z" }, - { url = "https://files.pythonhosted.org/packages/85/c7/1866e972fed6d71ef136efbc980d4d1854ab7ef1ea8152bbd995ca231c81/matplotlib-3.10.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a49e39755580b08e30e3620efc659330eac5d6534ab7eae50fa5e31f53ee4e30", size = 8590801, upload_time = "2025-05-08T19:09:47.404Z" }, - { url = "https://files.pythonhosted.org/packages/5d/b9/748f6626d534ab7e255bdc39dc22634d337cf3ce200f261b5d65742044a1/matplotlib-3.10.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cf4636203e1190871d3a73664dea03d26fb019b66692cbfd642faafdad6208e8", size = 9402111, upload_time = "2025-05-08T19:09:49.474Z" }, - { url = "https://files.pythonhosted.org/packages/1f/78/8bf07bd8fb67ea5665a6af188e70b57fcb2ab67057daa06b85a08e59160a/matplotlib-3.10.3-cp310-cp310-win_amd64.whl", hash = "sha256:fd5641a9bb9d55f4dd2afe897a53b537c834b9012684c8444cc105895c8c16fd", size = 8057213, upload_time = "2025-05-08T19:09:51.489Z" }, - { url = "https://files.pythonhosted.org/packages/f5/bd/af9f655456f60fe1d575f54fb14704ee299b16e999704817a7645dfce6b0/matplotlib-3.10.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0ef061f74cd488586f552d0c336b2f078d43bc00dc473d2c3e7bfee2272f3fa8", size = 8178873, upload_time = "2025-05-08T19:09:53.857Z" }, - { url = "https://files.pythonhosted.org/packages/c2/86/e1c86690610661cd716eda5f9d0b35eaf606ae6c9b6736687cfc8f2d0cd8/matplotlib-3.10.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d96985d14dc5f4a736bbea4b9de9afaa735f8a0fc2ca75be2fa9e96b2097369d", size = 8052205, upload_time = "2025-05-08T19:09:55.684Z" }, - { url = "https://files.pythonhosted.org/packages/54/51/a9f8e49af3883dacddb2da1af5fca1f7468677f1188936452dd9aaaeb9ed/matplotlib-3.10.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7c5f0283da91e9522bdba4d6583ed9d5521566f63729ffb68334f86d0bb98049", size = 8465823, upload_time = "2025-05-08T19:09:57.442Z" }, - { url = "https://files.pythonhosted.org/packages/e7/e3/c82963a3b86d6e6d5874cbeaa390166458a7f1961bab9feb14d3d1a10f02/matplotlib-3.10.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdfa07c0ec58035242bc8b2c8aae37037c9a886370eef6850703d7583e19964b", size = 8606464, upload_time = "2025-05-08T19:09:59.471Z" }, - { url = "https://files.pythonhosted.org/packages/0e/34/24da1027e7fcdd9e82da3194c470143c551852757a4b473a09a012f5b945/matplotlib-3.10.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c0b9849a17bce080a16ebcb80a7b714b5677d0ec32161a2cc0a8e5a6030ae220", size = 9413103, upload_time = "2025-05-08T19:10:03.208Z" }, - { url = "https://files.pythonhosted.org/packages/a6/da/948a017c3ea13fd4a97afad5fdebe2f5bbc4d28c0654510ce6fd6b06b7bd/matplotlib-3.10.3-cp311-cp311-win_amd64.whl", hash = "sha256:eef6ed6c03717083bc6d69c2d7ee8624205c29a8e6ea5a31cd3492ecdbaee1e1", size = 8065492, upload_time = "2025-05-08T19:10:05.271Z" }, - { url = "https://files.pythonhosted.org/packages/eb/43/6b80eb47d1071f234ef0c96ca370c2ca621f91c12045f1401b5c9b28a639/matplotlib-3.10.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ab1affc11d1f495ab9e6362b8174a25afc19c081ba5b0775ef00533a4236eea", size = 8179689, upload_time = "2025-05-08T19:10:07.602Z" }, - { url = "https://files.pythonhosted.org/packages/0f/70/d61a591958325c357204870b5e7b164f93f2a8cca1dc6ce940f563909a13/matplotlib-3.10.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2a818d8bdcafa7ed2eed74487fdb071c09c1ae24152d403952adad11fa3c65b4", size = 8050466, upload_time = "2025-05-08T19:10:09.383Z" }, - { url = "https://files.pythonhosted.org/packages/e7/75/70c9d2306203148cc7902a961240c5927dd8728afedf35e6a77e105a2985/matplotlib-3.10.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:748ebc3470c253e770b17d8b0557f0aa85cf8c63fd52f1a61af5b27ec0b7ffee", size = 8456252, upload_time = "2025-05-08T19:10:11.958Z" }, - { url = "https://files.pythonhosted.org/packages/c4/91/ba0ae1ff4b3f30972ad01cd4a8029e70a0ec3b8ea5be04764b128b66f763/matplotlib-3.10.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed70453fd99733293ace1aec568255bc51c6361cb0da94fa5ebf0649fdb2150a", size = 8601321, upload_time = "2025-05-08T19:10:14.47Z" }, - { url = "https://files.pythonhosted.org/packages/d2/88/d636041eb54a84b889e11872d91f7cbf036b3b0e194a70fa064eb8b04f7a/matplotlib-3.10.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dbed9917b44070e55640bd13419de83b4c918e52d97561544814ba463811cbc7", size = 9406972, upload_time = "2025-05-08T19:10:16.569Z" }, - { url = "https://files.pythonhosted.org/packages/b1/79/0d1c165eac44405a86478082e225fce87874f7198300bbebc55faaf6d28d/matplotlib-3.10.3-cp312-cp312-win_amd64.whl", hash = "sha256:cf37d8c6ef1a48829443e8ba5227b44236d7fcaf7647caa3178a4ff9f7a5be05", size = 8067954, upload_time = "2025-05-08T19:10:18.663Z" }, - { url = "https://files.pythonhosted.org/packages/3b/c1/23cfb566a74c696a3b338d8955c549900d18fe2b898b6e94d682ca21e7c2/matplotlib-3.10.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9f2efccc8dcf2b86fc4ee849eea5dcaecedd0773b30f47980dc0cbeabf26ec84", size = 8180318, upload_time = "2025-05-08T19:10:20.426Z" }, - { url = "https://files.pythonhosted.org/packages/6c/0c/02f1c3b66b30da9ee343c343acbb6251bef5b01d34fad732446eaadcd108/matplotlib-3.10.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3ddbba06a6c126e3301c3d272a99dcbe7f6c24c14024e80307ff03791a5f294e", size = 8051132, upload_time = "2025-05-08T19:10:22.569Z" }, - { url = "https://files.pythonhosted.org/packages/b4/ab/8db1a5ac9b3a7352fb914133001dae889f9fcecb3146541be46bed41339c/matplotlib-3.10.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:748302b33ae9326995b238f606e9ed840bf5886ebafcb233775d946aa8107a15", size = 8457633, upload_time = "2025-05-08T19:10:24.749Z" }, - { url = "https://files.pythonhosted.org/packages/f5/64/41c4367bcaecbc03ef0d2a3ecee58a7065d0a36ae1aa817fe573a2da66d4/matplotlib-3.10.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a80fcccbef63302c0efd78042ea3c2436104c5b1a4d3ae20f864593696364ac7", size = 8601031, upload_time = "2025-05-08T19:10:27.03Z" }, - { url = "https://files.pythonhosted.org/packages/12/6f/6cc79e9e5ab89d13ed64da28898e40fe5b105a9ab9c98f83abd24e46d7d7/matplotlib-3.10.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:55e46cbfe1f8586adb34f7587c3e4f7dedc59d5226719faf6cb54fc24f2fd52d", size = 9406988, upload_time = "2025-05-08T19:10:29.056Z" }, - { url = "https://files.pythonhosted.org/packages/b1/0f/eed564407bd4d935ffabf561ed31099ed609e19287409a27b6d336848653/matplotlib-3.10.3-cp313-cp313-win_amd64.whl", hash = "sha256:151d89cb8d33cb23345cd12490c76fd5d18a56581a16d950b48c6ff19bb2ab93", size = 8068034, upload_time = "2025-05-08T19:10:31.221Z" }, - { url = "https://files.pythonhosted.org/packages/3e/e5/2f14791ff69b12b09e9975e1d116d9578ac684460860ce542c2588cb7a1c/matplotlib-3.10.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:c26dd9834e74d164d06433dc7be5d75a1e9890b926b3e57e74fa446e1a62c3e2", size = 8218223, upload_time = "2025-05-08T19:10:33.114Z" }, - { url = "https://files.pythonhosted.org/packages/5c/08/30a94afd828b6e02d0a52cae4a29d6e9ccfcf4c8b56cc28b021d3588873e/matplotlib-3.10.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:24853dad5b8c84c8c2390fc31ce4858b6df504156893292ce8092d190ef8151d", size = 8094985, upload_time = "2025-05-08T19:10:35.337Z" }, - { url = "https://files.pythonhosted.org/packages/89/44/f3bc6b53066c889d7a1a3ea8094c13af6a667c5ca6220ec60ecceec2dabe/matplotlib-3.10.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68f7878214d369d7d4215e2a9075fef743be38fa401d32e6020bab2dfabaa566", size = 8483109, upload_time = "2025-05-08T19:10:37.611Z" }, - { url = "https://files.pythonhosted.org/packages/ba/c7/473bc559beec08ebee9f86ca77a844b65747e1a6c2691e8c92e40b9f42a8/matplotlib-3.10.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6929fc618cb6db9cb75086f73b3219bbb25920cb24cee2ea7a12b04971a4158", size = 8618082, upload_time = "2025-05-08T19:10:39.892Z" }, - { url = "https://files.pythonhosted.org/packages/d8/e9/6ce8edd264c8819e37bbed8172e0ccdc7107fe86999b76ab5752276357a4/matplotlib-3.10.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6c7818292a5cc372a2dc4c795e5c356942eb8350b98ef913f7fda51fe175ac5d", size = 9413699, upload_time = "2025-05-08T19:10:42.376Z" }, - { url = "https://files.pythonhosted.org/packages/1b/92/9a45c91089c3cf690b5badd4be81e392ff086ccca8a1d4e3a08463d8a966/matplotlib-3.10.3-cp313-cp313t-win_amd64.whl", hash = "sha256:4f23ffe95c5667ef8a2b56eea9b53db7f43910fa4a2d5472ae0f72b64deab4d5", size = 8139044, upload_time = "2025-05-08T19:10:44.551Z" }, - { url = "https://files.pythonhosted.org/packages/3d/d1/f54d43e95384b312ffa4a74a4326c722f3b8187aaaa12e9a84cdf3037131/matplotlib-3.10.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:86ab63d66bbc83fdb6733471d3bff40897c1e9921cba112accd748eee4bce5e4", size = 8162896, upload_time = "2025-05-08T19:10:46.432Z" }, - { url = "https://files.pythonhosted.org/packages/24/a4/fbfc00c2346177c95b353dcf9b5a004106abe8730a62cb6f27e79df0a698/matplotlib-3.10.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:a48f9c08bf7444b5d2391a83e75edb464ccda3c380384b36532a0962593a1751", size = 8039702, upload_time = "2025-05-08T19:10:49.634Z" }, - { url = "https://files.pythonhosted.org/packages/6a/b9/59e120d24a2ec5fc2d30646adb2efb4621aab3c6d83d66fb2a7a182db032/matplotlib-3.10.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb73d8aa75a237457988f9765e4dfe1c0d2453c5ca4eabc897d4309672c8e014", size = 8594298, upload_time = "2025-05-08T19:10:51.738Z" }, -] - -[[package]] -name = "mdurl" -version = "0.1.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload_time = "2022-08-14T12:40:10.846Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload_time = "2022-08-14T12:40:09.779Z" }, -] - -[[package]] -name = "multidict" -version = "6.6.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/3d/2c/5dad12e82fbdf7470f29bff2171484bf07cb3b16ada60a6589af8f376440/multidict-6.6.3.tar.gz", hash = "sha256:798a9eb12dab0a6c2e29c1de6f3468af5cb2da6053a20dfa3344907eed0937cc", size = 101006, upload_time = "2025-06-30T15:53:46.929Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/67/414933982bce2efce7cbcb3169eaaf901e0f25baec69432b4874dfb1f297/multidict-6.6.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a2be5b7b35271f7fff1397204ba6708365e3d773579fe2a30625e16c4b4ce817", size = 77017, upload_time = "2025-06-30T15:50:58.931Z" }, - { url = "https://files.pythonhosted.org/packages/8a/fe/d8a3ee1fad37dc2ef4f75488b0d9d4f25bf204aad8306cbab63d97bff64a/multidict-6.6.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:12f4581d2930840295c461764b9a65732ec01250b46c6b2c510d7ee68872b140", size = 44897, upload_time = "2025-06-30T15:51:00.999Z" }, - { url = "https://files.pythonhosted.org/packages/1f/e0/265d89af8c98240265d82b8cbcf35897f83b76cd59ee3ab3879050fd8c45/multidict-6.6.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dd7793bab517e706c9ed9d7310b06c8672fd0aeee5781bfad612f56b8e0f7d14", size = 44574, upload_time = "2025-06-30T15:51:02.449Z" }, - { url = "https://files.pythonhosted.org/packages/e6/05/6b759379f7e8e04ccc97cfb2a5dcc5cdbd44a97f072b2272dc51281e6a40/multidict-6.6.3-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:72d8815f2cd3cf3df0f83cac3f3ef801d908b2d90409ae28102e0553af85545a", size = 225729, upload_time = "2025-06-30T15:51:03.794Z" }, - { url = "https://files.pythonhosted.org/packages/4e/f5/8d5a15488edd9a91fa4aad97228d785df208ed6298580883aa3d9def1959/multidict-6.6.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:531e331a2ee53543ab32b16334e2deb26f4e6b9b28e41f8e0c87e99a6c8e2d69", size = 242515, upload_time = "2025-06-30T15:51:05.002Z" }, - { url = "https://files.pythonhosted.org/packages/6e/b5/a8f317d47d0ac5bb746d6d8325885c8967c2a8ce0bb57be5399e3642cccb/multidict-6.6.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:42ca5aa9329a63be8dc49040f63817d1ac980e02eeddba763a9ae5b4027b9c9c", size = 222224, upload_time = "2025-06-30T15:51:06.148Z" }, - { url = "https://files.pythonhosted.org/packages/76/88/18b2a0d5e80515fa22716556061189c2853ecf2aa2133081ebbe85ebea38/multidict-6.6.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:208b9b9757060b9faa6f11ab4bc52846e4f3c2fb8b14d5680c8aac80af3dc751", size = 253124, upload_time = "2025-06-30T15:51:07.375Z" }, - { url = "https://files.pythonhosted.org/packages/62/bf/ebfcfd6b55a1b05ef16d0775ae34c0fe15e8dab570d69ca9941073b969e7/multidict-6.6.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:acf6b97bd0884891af6a8b43d0f586ab2fcf8e717cbd47ab4bdddc09e20652d8", size = 251529, upload_time = "2025-06-30T15:51:08.691Z" }, - { url = "https://files.pythonhosted.org/packages/44/11/780615a98fd3775fc309d0234d563941af69ade2df0bb82c91dda6ddaea1/multidict-6.6.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:68e9e12ed00e2089725669bdc88602b0b6f8d23c0c95e52b95f0bc69f7fe9b55", size = 241627, upload_time = "2025-06-30T15:51:10.605Z" }, - { url = "https://files.pythonhosted.org/packages/28/3d/35f33045e21034b388686213752cabc3a1b9d03e20969e6fa8f1b1d82db1/multidict-6.6.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:05db2f66c9addb10cfa226e1acb363450fab2ff8a6df73c622fefe2f5af6d4e7", size = 239351, upload_time = "2025-06-30T15:51:12.18Z" }, - { url = "https://files.pythonhosted.org/packages/6e/cc/ff84c03b95b430015d2166d9aae775a3985d757b94f6635010d0038d9241/multidict-6.6.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:0db58da8eafb514db832a1b44f8fa7906fdd102f7d982025f816a93ba45e3dcb", size = 233429, upload_time = "2025-06-30T15:51:13.533Z" }, - { url = "https://files.pythonhosted.org/packages/2e/f0/8cd49a0b37bdea673a4b793c2093f2f4ba8e7c9d6d7c9bd672fd6d38cd11/multidict-6.6.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:14117a41c8fdb3ee19c743b1c027da0736fdb79584d61a766da53d399b71176c", size = 243094, upload_time = "2025-06-30T15:51:14.815Z" }, - { url = "https://files.pythonhosted.org/packages/96/19/5d9a0cfdafe65d82b616a45ae950975820289069f885328e8185e64283c2/multidict-6.6.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:877443eaaabcd0b74ff32ebeed6f6176c71850feb7d6a1d2db65945256ea535c", size = 248957, upload_time = "2025-06-30T15:51:16.076Z" }, - { url = "https://files.pythonhosted.org/packages/e6/dc/c90066151da87d1e489f147b9b4327927241e65f1876702fafec6729c014/multidict-6.6.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:70b72e749a4f6e7ed8fb334fa8d8496384840319512746a5f42fa0aec79f4d61", size = 243590, upload_time = "2025-06-30T15:51:17.413Z" }, - { url = "https://files.pythonhosted.org/packages/ec/39/458afb0cccbb0ee9164365273be3e039efddcfcb94ef35924b7dbdb05db0/multidict-6.6.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:43571f785b86afd02b3855c5ac8e86ec921b760298d6f82ff2a61daf5a35330b", size = 237487, upload_time = "2025-06-30T15:51:19.039Z" }, - { url = "https://files.pythonhosted.org/packages/35/38/0016adac3990426610a081787011177e661875546b434f50a26319dc8372/multidict-6.6.3-cp310-cp310-win32.whl", hash = "sha256:20c5a0c3c13a15fd5ea86c42311859f970070e4e24de5a550e99d7c271d76318", size = 41390, upload_time = "2025-06-30T15:51:20.362Z" }, - { url = "https://files.pythonhosted.org/packages/f3/d2/17897a8f3f2c5363d969b4c635aa40375fe1f09168dc09a7826780bfb2a4/multidict-6.6.3-cp310-cp310-win_amd64.whl", hash = "sha256:ab0a34a007704c625e25a9116c6770b4d3617a071c8a7c30cd338dfbadfe6485", size = 45954, upload_time = "2025-06-30T15:51:21.383Z" }, - { url = "https://files.pythonhosted.org/packages/2d/5f/d4a717c1e457fe44072e33fa400d2b93eb0f2819c4d669381f925b7cba1f/multidict-6.6.3-cp310-cp310-win_arm64.whl", hash = "sha256:769841d70ca8bdd140a715746199fc6473414bd02efd678d75681d2d6a8986c5", size = 42981, upload_time = "2025-06-30T15:51:22.809Z" }, - { url = "https://files.pythonhosted.org/packages/08/f0/1a39863ced51f639c81a5463fbfa9eb4df59c20d1a8769ab9ef4ca57ae04/multidict-6.6.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:18f4eba0cbac3546b8ae31e0bbc55b02c801ae3cbaf80c247fcdd89b456ff58c", size = 76445, upload_time = "2025-06-30T15:51:24.01Z" }, - { url = "https://files.pythonhosted.org/packages/c9/0e/a7cfa451c7b0365cd844e90b41e21fab32edaa1e42fc0c9f68461ce44ed7/multidict-6.6.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef43b5dd842382329e4797c46f10748d8c2b6e0614f46b4afe4aee9ac33159df", size = 44610, upload_time = "2025-06-30T15:51:25.158Z" }, - { url = "https://files.pythonhosted.org/packages/c6/bb/a14a4efc5ee748cc1904b0748be278c31b9295ce5f4d2ef66526f410b94d/multidict-6.6.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bf9bd1fd5eec01494e0f2e8e446a74a85d5e49afb63d75a9934e4a5423dba21d", size = 44267, upload_time = "2025-06-30T15:51:26.326Z" }, - { url = "https://files.pythonhosted.org/packages/c2/f8/410677d563c2d55e063ef74fe578f9d53fe6b0a51649597a5861f83ffa15/multidict-6.6.3-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:5bd8d6f793a787153956cd35e24f60485bf0651c238e207b9a54f7458b16d539", size = 230004, upload_time = "2025-06-30T15:51:27.491Z" }, - { url = "https://files.pythonhosted.org/packages/fd/df/2b787f80059314a98e1ec6a4cc7576244986df3e56b3c755e6fc7c99e038/multidict-6.6.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1bf99b4daf908c73856bd87ee0a2499c3c9a3d19bb04b9c6025e66af3fd07462", size = 247196, upload_time = "2025-06-30T15:51:28.762Z" }, - { url = "https://files.pythonhosted.org/packages/05/f2/f9117089151b9a8ab39f9019620d10d9718eec2ac89e7ca9d30f3ec78e96/multidict-6.6.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b9e59946b49dafaf990fd9c17ceafa62976e8471a14952163d10a7a630413a9", size = 225337, upload_time = "2025-06-30T15:51:30.025Z" }, - { url = "https://files.pythonhosted.org/packages/93/2d/7115300ec5b699faa152c56799b089a53ed69e399c3c2d528251f0aeda1a/multidict-6.6.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e2db616467070d0533832d204c54eea6836a5e628f2cb1e6dfd8cd6ba7277cb7", size = 257079, upload_time = "2025-06-30T15:51:31.716Z" }, - { url = "https://files.pythonhosted.org/packages/15/ea/ff4bab367623e39c20d3b07637225c7688d79e4f3cc1f3b9f89867677f9a/multidict-6.6.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7394888236621f61dcdd25189b2768ae5cc280f041029a5bcf1122ac63df79f9", size = 255461, upload_time = "2025-06-30T15:51:33.029Z" }, - { url = "https://files.pythonhosted.org/packages/74/07/2c9246cda322dfe08be85f1b8739646f2c4c5113a1422d7a407763422ec4/multidict-6.6.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f114d8478733ca7388e7c7e0ab34b72547476b97009d643644ac33d4d3fe1821", size = 246611, upload_time = "2025-06-30T15:51:34.47Z" }, - { url = "https://files.pythonhosted.org/packages/a8/62/279c13d584207d5697a752a66ffc9bb19355a95f7659140cb1b3cf82180e/multidict-6.6.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cdf22e4db76d323bcdc733514bf732e9fb349707c98d341d40ebcc6e9318ef3d", size = 243102, upload_time = "2025-06-30T15:51:36.525Z" }, - { url = "https://files.pythonhosted.org/packages/69/cc/e06636f48c6d51e724a8bc8d9e1db5f136fe1df066d7cafe37ef4000f86a/multidict-6.6.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e995a34c3d44ab511bfc11aa26869b9d66c2d8c799fa0e74b28a473a692532d6", size = 238693, upload_time = "2025-06-30T15:51:38.278Z" }, - { url = "https://files.pythonhosted.org/packages/89/a4/66c9d8fb9acf3b226cdd468ed009537ac65b520aebdc1703dd6908b19d33/multidict-6.6.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:766a4a5996f54361d8d5a9050140aa5362fe48ce51c755a50c0bc3706460c430", size = 246582, upload_time = "2025-06-30T15:51:39.709Z" }, - { url = "https://files.pythonhosted.org/packages/cf/01/c69e0317be556e46257826d5449feb4e6aa0d18573e567a48a2c14156f1f/multidict-6.6.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:3893a0d7d28a7fe6ca7a1f760593bc13038d1d35daf52199d431b61d2660602b", size = 253355, upload_time = "2025-06-30T15:51:41.013Z" }, - { url = "https://files.pythonhosted.org/packages/c0/da/9cc1da0299762d20e626fe0042e71b5694f9f72d7d3f9678397cbaa71b2b/multidict-6.6.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:934796c81ea996e61914ba58064920d6cad5d99140ac3167901eb932150e2e56", size = 247774, upload_time = "2025-06-30T15:51:42.291Z" }, - { url = "https://files.pythonhosted.org/packages/e6/91/b22756afec99cc31105ddd4a52f95ab32b1a4a58f4d417979c570c4a922e/multidict-6.6.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9ed948328aec2072bc00f05d961ceadfd3e9bfc2966c1319aeaf7b7c21219183", size = 242275, upload_time = "2025-06-30T15:51:43.642Z" }, - { url = "https://files.pythonhosted.org/packages/be/f1/adcc185b878036a20399d5be5228f3cbe7f823d78985d101d425af35c800/multidict-6.6.3-cp311-cp311-win32.whl", hash = "sha256:9f5b28c074c76afc3e4c610c488e3493976fe0e596dd3db6c8ddfbb0134dcac5", size = 41290, upload_time = "2025-06-30T15:51:45.264Z" }, - { url = "https://files.pythonhosted.org/packages/e0/d4/27652c1c6526ea6b4f5ddd397e93f4232ff5de42bea71d339bc6a6cc497f/multidict-6.6.3-cp311-cp311-win_amd64.whl", hash = "sha256:bc7f6fbc61b1c16050a389c630da0b32fc6d4a3d191394ab78972bf5edc568c2", size = 45942, upload_time = "2025-06-30T15:51:46.377Z" }, - { url = "https://files.pythonhosted.org/packages/16/18/23f4932019804e56d3c2413e237f866444b774b0263bcb81df2fdecaf593/multidict-6.6.3-cp311-cp311-win_arm64.whl", hash = "sha256:d4e47d8faffaae822fb5cba20937c048d4f734f43572e7079298a6c39fb172cb", size = 42880, upload_time = "2025-06-30T15:51:47.561Z" }, - { url = "https://files.pythonhosted.org/packages/0e/a0/6b57988ea102da0623ea814160ed78d45a2645e4bbb499c2896d12833a70/multidict-6.6.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:056bebbeda16b2e38642d75e9e5310c484b7c24e3841dc0fb943206a72ec89d6", size = 76514, upload_time = "2025-06-30T15:51:48.728Z" }, - { url = "https://files.pythonhosted.org/packages/07/7a/d1e92665b0850c6c0508f101f9cf0410c1afa24973e1115fe9c6a185ebf7/multidict-6.6.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e5f481cccb3c5c5e5de5d00b5141dc589c1047e60d07e85bbd7dea3d4580d63f", size = 45394, upload_time = "2025-06-30T15:51:49.986Z" }, - { url = "https://files.pythonhosted.org/packages/52/6f/dd104490e01be6ef8bf9573705d8572f8c2d2c561f06e3826b081d9e6591/multidict-6.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:10bea2ee839a759ee368b5a6e47787f399b41e70cf0c20d90dfaf4158dfb4e55", size = 43590, upload_time = "2025-06-30T15:51:51.331Z" }, - { url = "https://files.pythonhosted.org/packages/44/fe/06e0e01b1b0611e6581b7fd5a85b43dacc08b6cea3034f902f383b0873e5/multidict-6.6.3-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:2334cfb0fa9549d6ce2c21af2bfbcd3ac4ec3646b1b1581c88e3e2b1779ec92b", size = 237292, upload_time = "2025-06-30T15:51:52.584Z" }, - { url = "https://files.pythonhosted.org/packages/ce/71/4f0e558fb77696b89c233c1ee2d92f3e1d5459070a0e89153c9e9e804186/multidict-6.6.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8fee016722550a2276ca2cb5bb624480e0ed2bd49125b2b73b7010b9090e888", size = 258385, upload_time = "2025-06-30T15:51:53.913Z" }, - { url = "https://files.pythonhosted.org/packages/e3/25/cca0e68228addad24903801ed1ab42e21307a1b4b6dd2cf63da5d3ae082a/multidict-6.6.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5511cb35f5c50a2db21047c875eb42f308c5583edf96bd8ebf7d770a9d68f6d", size = 242328, upload_time = "2025-06-30T15:51:55.672Z" }, - { url = "https://files.pythonhosted.org/packages/6e/a3/46f2d420d86bbcb8fe660b26a10a219871a0fbf4d43cb846a4031533f3e0/multidict-6.6.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:712b348f7f449948e0a6c4564a21c7db965af900973a67db432d724619b3c680", size = 268057, upload_time = "2025-06-30T15:51:57.037Z" }, - { url = "https://files.pythonhosted.org/packages/9e/73/1c743542fe00794a2ec7466abd3f312ccb8fad8dff9f36d42e18fb1ec33e/multidict-6.6.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e4e15d2138ee2694e038e33b7c3da70e6b0ad8868b9f8094a72e1414aeda9c1a", size = 269341, upload_time = "2025-06-30T15:51:59.111Z" }, - { url = "https://files.pythonhosted.org/packages/a4/11/6ec9dcbe2264b92778eeb85407d1df18812248bf3506a5a1754bc035db0c/multidict-6.6.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8df25594989aebff8a130f7899fa03cbfcc5d2b5f4a461cf2518236fe6f15961", size = 256081, upload_time = "2025-06-30T15:52:00.533Z" }, - { url = "https://files.pythonhosted.org/packages/9b/2b/631b1e2afeb5f1696846d747d36cda075bfdc0bc7245d6ba5c319278d6c4/multidict-6.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:159ca68bfd284a8860f8d8112cf0521113bffd9c17568579e4d13d1f1dc76b65", size = 253581, upload_time = "2025-06-30T15:52:02.43Z" }, - { url = "https://files.pythonhosted.org/packages/bf/0e/7e3b93f79efeb6111d3bf9a1a69e555ba1d07ad1c11bceb56b7310d0d7ee/multidict-6.6.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:e098c17856a8c9ade81b4810888c5ad1914099657226283cab3062c0540b0643", size = 250750, upload_time = "2025-06-30T15:52:04.26Z" }, - { url = "https://files.pythonhosted.org/packages/ad/9e/086846c1d6601948e7de556ee464a2d4c85e33883e749f46b9547d7b0704/multidict-6.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:67c92ed673049dec52d7ed39f8cf9ebbadf5032c774058b4406d18c8f8fe7063", size = 251548, upload_time = "2025-06-30T15:52:06.002Z" }, - { url = "https://files.pythonhosted.org/packages/8c/7b/86ec260118e522f1a31550e87b23542294880c97cfbf6fb18cc67b044c66/multidict-6.6.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:bd0578596e3a835ef451784053cfd327d607fc39ea1a14812139339a18a0dbc3", size = 262718, upload_time = "2025-06-30T15:52:07.707Z" }, - { url = "https://files.pythonhosted.org/packages/8c/bd/22ce8f47abb0be04692c9fc4638508b8340987b18691aa7775d927b73f72/multidict-6.6.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:346055630a2df2115cd23ae271910b4cae40f4e336773550dca4889b12916e75", size = 259603, upload_time = "2025-06-30T15:52:09.58Z" }, - { url = "https://files.pythonhosted.org/packages/07/9c/91b7ac1691be95cd1f4a26e36a74b97cda6aa9820632d31aab4410f46ebd/multidict-6.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:555ff55a359302b79de97e0468e9ee80637b0de1fce77721639f7cd9440b3a10", size = 251351, upload_time = "2025-06-30T15:52:10.947Z" }, - { url = "https://files.pythonhosted.org/packages/6f/5c/4d7adc739884f7a9fbe00d1eac8c034023ef8bad71f2ebe12823ca2e3649/multidict-6.6.3-cp312-cp312-win32.whl", hash = "sha256:73ab034fb8d58ff85c2bcbadc470efc3fafeea8affcf8722855fb94557f14cc5", size = 41860, upload_time = "2025-06-30T15:52:12.334Z" }, - { url = "https://files.pythonhosted.org/packages/6a/a3/0fbc7afdf7cb1aa12a086b02959307848eb6bcc8f66fcb66c0cb57e2a2c1/multidict-6.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:04cbcce84f63b9af41bad04a54d4cc4e60e90c35b9e6ccb130be2d75b71f8c17", size = 45982, upload_time = "2025-06-30T15:52:13.6Z" }, - { url = "https://files.pythonhosted.org/packages/b8/95/8c825bd70ff9b02462dc18d1295dd08d3e9e4eb66856d292ffa62cfe1920/multidict-6.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:0f1130b896ecb52d2a1e615260f3ea2af55fa7dc3d7c3003ba0c3121a759b18b", size = 43210, upload_time = "2025-06-30T15:52:14.893Z" }, - { url = "https://files.pythonhosted.org/packages/52/1d/0bebcbbb4f000751fbd09957257903d6e002943fc668d841a4cf2fb7f872/multidict-6.6.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:540d3c06d48507357a7d57721e5094b4f7093399a0106c211f33540fdc374d55", size = 75843, upload_time = "2025-06-30T15:52:16.155Z" }, - { url = "https://files.pythonhosted.org/packages/07/8f/cbe241b0434cfe257f65c2b1bcf9e8d5fb52bc708c5061fb29b0fed22bdf/multidict-6.6.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9c19cea2a690f04247d43f366d03e4eb110a0dc4cd1bbeee4d445435428ed35b", size = 45053, upload_time = "2025-06-30T15:52:17.429Z" }, - { url = "https://files.pythonhosted.org/packages/32/d2/0b3b23f9dbad5b270b22a3ac3ea73ed0a50ef2d9a390447061178ed6bdb8/multidict-6.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7af039820cfd00effec86bda5d8debef711a3e86a1d3772e85bea0f243a4bd65", size = 43273, upload_time = "2025-06-30T15:52:19.346Z" }, - { url = "https://files.pythonhosted.org/packages/fd/fe/6eb68927e823999e3683bc49678eb20374ba9615097d085298fd5b386564/multidict-6.6.3-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:500b84f51654fdc3944e936f2922114349bf8fdcac77c3092b03449f0e5bc2b3", size = 237124, upload_time = "2025-06-30T15:52:20.773Z" }, - { url = "https://files.pythonhosted.org/packages/e7/ab/320d8507e7726c460cb77117848b3834ea0d59e769f36fdae495f7669929/multidict-6.6.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3fc723ab8a5c5ed6c50418e9bfcd8e6dceba6c271cee6728a10a4ed8561520c", size = 256892, upload_time = "2025-06-30T15:52:22.242Z" }, - { url = "https://files.pythonhosted.org/packages/76/60/38ee422db515ac69834e60142a1a69111ac96026e76e8e9aa347fd2e4591/multidict-6.6.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:94c47ea3ade005b5976789baaed66d4de4480d0a0bf31cef6edaa41c1e7b56a6", size = 240547, upload_time = "2025-06-30T15:52:23.736Z" }, - { url = "https://files.pythonhosted.org/packages/27/fb/905224fde2dff042b030c27ad95a7ae744325cf54b890b443d30a789b80e/multidict-6.6.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dbc7cf464cc6d67e83e136c9f55726da3a30176f020a36ead246eceed87f1cd8", size = 266223, upload_time = "2025-06-30T15:52:25.185Z" }, - { url = "https://files.pythonhosted.org/packages/76/35/dc38ab361051beae08d1a53965e3e1a418752fc5be4d3fb983c5582d8784/multidict-6.6.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:900eb9f9da25ada070f8ee4a23f884e0ee66fe4e1a38c3af644256a508ad81ca", size = 267262, upload_time = "2025-06-30T15:52:26.969Z" }, - { url = "https://files.pythonhosted.org/packages/1f/a3/0a485b7f36e422421b17e2bbb5a81c1af10eac1d4476f2ff92927c730479/multidict-6.6.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c6df517cf177da5d47ab15407143a89cd1a23f8b335f3a28d57e8b0a3dbb884", size = 254345, upload_time = "2025-06-30T15:52:28.467Z" }, - { url = "https://files.pythonhosted.org/packages/b4/59/bcdd52c1dab7c0e0d75ff19cac751fbd5f850d1fc39172ce809a74aa9ea4/multidict-6.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4ef421045f13879e21c994b36e728d8e7d126c91a64b9185810ab51d474f27e7", size = 252248, upload_time = "2025-06-30T15:52:29.938Z" }, - { url = "https://files.pythonhosted.org/packages/bb/a4/2d96aaa6eae8067ce108d4acee6f45ced5728beda55c0f02ae1072c730d1/multidict-6.6.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:6c1e61bb4f80895c081790b6b09fa49e13566df8fbff817da3f85b3a8192e36b", size = 250115, upload_time = "2025-06-30T15:52:31.416Z" }, - { url = "https://files.pythonhosted.org/packages/25/d2/ed9f847fa5c7d0677d4f02ea2c163d5e48573de3f57bacf5670e43a5ffaa/multidict-6.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e5e8523bb12d7623cd8300dbd91b9e439a46a028cd078ca695eb66ba31adee3c", size = 249649, upload_time = "2025-06-30T15:52:32.996Z" }, - { url = "https://files.pythonhosted.org/packages/1f/af/9155850372563fc550803d3f25373308aa70f59b52cff25854086ecb4a79/multidict-6.6.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:ef58340cc896219e4e653dade08fea5c55c6df41bcc68122e3be3e9d873d9a7b", size = 261203, upload_time = "2025-06-30T15:52:34.521Z" }, - { url = "https://files.pythonhosted.org/packages/36/2f/c6a728f699896252cf309769089568a33c6439626648843f78743660709d/multidict-6.6.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc9dc435ec8699e7b602b94fe0cd4703e69273a01cbc34409af29e7820f777f1", size = 258051, upload_time = "2025-06-30T15:52:35.999Z" }, - { url = "https://files.pythonhosted.org/packages/d0/60/689880776d6b18fa2b70f6cc74ff87dd6c6b9b47bd9cf74c16fecfaa6ad9/multidict-6.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9e864486ef4ab07db5e9cb997bad2b681514158d6954dd1958dfb163b83d53e6", size = 249601, upload_time = "2025-06-30T15:52:37.473Z" }, - { url = "https://files.pythonhosted.org/packages/75/5e/325b11f2222a549019cf2ef879c1f81f94a0d40ace3ef55cf529915ba6cc/multidict-6.6.3-cp313-cp313-win32.whl", hash = "sha256:5633a82fba8e841bc5c5c06b16e21529573cd654f67fd833650a215520a6210e", size = 41683, upload_time = "2025-06-30T15:52:38.927Z" }, - { url = "https://files.pythonhosted.org/packages/b1/ad/cf46e73f5d6e3c775cabd2a05976547f3f18b39bee06260369a42501f053/multidict-6.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:e93089c1570a4ad54c3714a12c2cef549dc9d58e97bcded193d928649cab78e9", size = 45811, upload_time = "2025-06-30T15:52:40.207Z" }, - { url = "https://files.pythonhosted.org/packages/c5/c9/2e3fe950db28fb7c62e1a5f46e1e38759b072e2089209bc033c2798bb5ec/multidict-6.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:c60b401f192e79caec61f166da9c924e9f8bc65548d4246842df91651e83d600", size = 43056, upload_time = "2025-06-30T15:52:41.575Z" }, - { url = "https://files.pythonhosted.org/packages/3a/58/aaf8114cf34966e084a8cc9517771288adb53465188843d5a19862cb6dc3/multidict-6.6.3-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:02fd8f32d403a6ff13864b0851f1f523d4c988051eea0471d4f1fd8010f11134", size = 82811, upload_time = "2025-06-30T15:52:43.281Z" }, - { url = "https://files.pythonhosted.org/packages/71/af/5402e7b58a1f5b987a07ad98f2501fdba2a4f4b4c30cf114e3ce8db64c87/multidict-6.6.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:f3aa090106b1543f3f87b2041eef3c156c8da2aed90c63a2fbed62d875c49c37", size = 48304, upload_time = "2025-06-30T15:52:45.026Z" }, - { url = "https://files.pythonhosted.org/packages/39/65/ab3c8cafe21adb45b24a50266fd747147dec7847425bc2a0f6934b3ae9ce/multidict-6.6.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e924fb978615a5e33ff644cc42e6aa241effcf4f3322c09d4f8cebde95aff5f8", size = 46775, upload_time = "2025-06-30T15:52:46.459Z" }, - { url = "https://files.pythonhosted.org/packages/49/ba/9fcc1b332f67cc0c0c8079e263bfab6660f87fe4e28a35921771ff3eea0d/multidict-6.6.3-cp313-cp313t-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:b9fe5a0e57c6dbd0e2ce81ca66272282c32cd11d31658ee9553849d91289e1c1", size = 229773, upload_time = "2025-06-30T15:52:47.88Z" }, - { url = "https://files.pythonhosted.org/packages/a4/14/0145a251f555f7c754ce2dcbcd012939bbd1f34f066fa5d28a50e722a054/multidict-6.6.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b24576f208793ebae00280c59927c3b7c2a3b1655e443a25f753c4611bc1c373", size = 250083, upload_time = "2025-06-30T15:52:49.366Z" }, - { url = "https://files.pythonhosted.org/packages/9e/d4/d5c0bd2bbb173b586c249a151a26d2fb3ec7d53c96e42091c9fef4e1f10c/multidict-6.6.3-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:135631cb6c58eac37d7ac0df380294fecdc026b28837fa07c02e459c7fb9c54e", size = 228980, upload_time = "2025-06-30T15:52:50.903Z" }, - { url = "https://files.pythonhosted.org/packages/21/32/c9a2d8444a50ec48c4733ccc67254100c10e1c8ae8e40c7a2d2183b59b97/multidict-6.6.3-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:274d416b0df887aef98f19f21578653982cfb8a05b4e187d4a17103322eeaf8f", size = 257776, upload_time = "2025-06-30T15:52:52.764Z" }, - { url = "https://files.pythonhosted.org/packages/68/d0/14fa1699f4ef629eae08ad6201c6b476098f5efb051b296f4c26be7a9fdf/multidict-6.6.3-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e252017a817fad7ce05cafbe5711ed40faeb580e63b16755a3a24e66fa1d87c0", size = 256882, upload_time = "2025-06-30T15:52:54.596Z" }, - { url = "https://files.pythonhosted.org/packages/da/88/84a27570fbe303c65607d517a5f147cd2fc046c2d1da02b84b17b9bdc2aa/multidict-6.6.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e4cc8d848cd4fe1cdee28c13ea79ab0ed37fc2e89dd77bac86a2e7959a8c3bc", size = 247816, upload_time = "2025-06-30T15:52:56.175Z" }, - { url = "https://files.pythonhosted.org/packages/1c/60/dca352a0c999ce96a5d8b8ee0b2b9f729dcad2e0b0c195f8286269a2074c/multidict-6.6.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9e236a7094b9c4c1b7585f6b9cca34b9d833cf079f7e4c49e6a4a6ec9bfdc68f", size = 245341, upload_time = "2025-06-30T15:52:57.752Z" }, - { url = "https://files.pythonhosted.org/packages/50/ef/433fa3ed06028f03946f3993223dada70fb700f763f70c00079533c34578/multidict-6.6.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:e0cb0ab69915c55627c933f0b555a943d98ba71b4d1c57bc0d0a66e2567c7471", size = 235854, upload_time = "2025-06-30T15:52:59.74Z" }, - { url = "https://files.pythonhosted.org/packages/1b/1f/487612ab56fbe35715320905215a57fede20de7db40a261759690dc80471/multidict-6.6.3-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:81ef2f64593aba09c5212a3d0f8c906a0d38d710a011f2f42759704d4557d3f2", size = 243432, upload_time = "2025-06-30T15:53:01.602Z" }, - { url = "https://files.pythonhosted.org/packages/da/6f/ce8b79de16cd885c6f9052c96a3671373d00c59b3ee635ea93e6e81b8ccf/multidict-6.6.3-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:b9cbc60010de3562545fa198bfc6d3825df430ea96d2cc509c39bd71e2e7d648", size = 252731, upload_time = "2025-06-30T15:53:03.517Z" }, - { url = "https://files.pythonhosted.org/packages/bb/fe/a2514a6aba78e5abefa1624ca85ae18f542d95ac5cde2e3815a9fbf369aa/multidict-6.6.3-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:70d974eaaa37211390cd02ef93b7e938de564bbffa866f0b08d07e5e65da783d", size = 247086, upload_time = "2025-06-30T15:53:05.48Z" }, - { url = "https://files.pythonhosted.org/packages/8c/22/b788718d63bb3cce752d107a57c85fcd1a212c6c778628567c9713f9345a/multidict-6.6.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3713303e4a6663c6d01d648a68f2848701001f3390a030edaaf3fc949c90bf7c", size = 243338, upload_time = "2025-06-30T15:53:07.522Z" }, - { url = "https://files.pythonhosted.org/packages/22/d6/fdb3d0670819f2228f3f7d9af613d5e652c15d170c83e5f1c94fbc55a25b/multidict-6.6.3-cp313-cp313t-win32.whl", hash = "sha256:639ecc9fe7cd73f2495f62c213e964843826f44505a3e5d82805aa85cac6f89e", size = 47812, upload_time = "2025-06-30T15:53:09.263Z" }, - { url = "https://files.pythonhosted.org/packages/b6/d6/a9d2c808f2c489ad199723197419207ecbfbc1776f6e155e1ecea9c883aa/multidict-6.6.3-cp313-cp313t-win_amd64.whl", hash = "sha256:9f97e181f344a0ef3881b573d31de8542cc0dbc559ec68c8f8b5ce2c2e91646d", size = 53011, upload_time = "2025-06-30T15:53:11.038Z" }, - { url = "https://files.pythonhosted.org/packages/f2/40/b68001cba8188dd267590a111f9661b6256debc327137667e832bf5d66e8/multidict-6.6.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ce8b7693da41a3c4fde5871c738a81490cea5496c671d74374c8ab889e1834fb", size = 45254, upload_time = "2025-06-30T15:53:12.421Z" }, - { url = "https://files.pythonhosted.org/packages/d8/30/9aec301e9772b098c1f5c0ca0279237c9766d94b97802e9888010c64b0ed/multidict-6.6.3-py3-none-any.whl", hash = "sha256:8db10f29c7541fc5da4defd8cd697e1ca429db743fa716325f236079b96f775a", size = 12313, upload_time = "2025-06-30T15:53:45.437Z" }, -] - -[[package]] -name = "networkx" -version = "3.4.2" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.11'", -] -sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload_time = "2024-10-21T12:39:38.695Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload_time = "2024-10-21T12:39:36.247Z" }, -] - -[[package]] -name = "networkx" -version = "3.5" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", -] -sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065, upload_time = "2025-05-29T11:35:07.804Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406, upload_time = "2025-05-29T11:35:04.961Z" }, -] - -[[package]] -name = "numpy" -version = "2.2.6" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.11'", -] -sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload_time = "2025-05-17T22:38:04.611Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload_time = "2025-05-17T21:27:58.555Z" }, - { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload_time = "2025-05-17T21:28:21.406Z" }, - { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload_time = "2025-05-17T21:28:30.931Z" }, - { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload_time = "2025-05-17T21:28:41.613Z" }, - { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload_time = "2025-05-17T21:29:02.78Z" }, - { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload_time = "2025-05-17T21:29:27.675Z" }, - { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload_time = "2025-05-17T21:29:51.102Z" }, - { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload_time = "2025-05-17T21:30:18.703Z" }, - { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload_time = "2025-05-17T21:30:29.788Z" }, - { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload_time = "2025-05-17T21:30:48.994Z" }, - { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload_time = "2025-05-17T21:31:19.36Z" }, - { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload_time = "2025-05-17T21:31:41.087Z" }, - { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload_time = "2025-05-17T21:31:50.072Z" }, - { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload_time = "2025-05-17T21:32:01.712Z" }, - { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload_time = "2025-05-17T21:32:23.332Z" }, - { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload_time = "2025-05-17T21:32:47.991Z" }, - { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload_time = "2025-05-17T21:33:11.728Z" }, - { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload_time = "2025-05-17T21:33:39.139Z" }, - { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload_time = "2025-05-17T21:33:50.273Z" }, - { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload_time = "2025-05-17T21:34:09.135Z" }, - { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload_time = "2025-05-17T21:34:39.648Z" }, - { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload_time = "2025-05-17T21:35:01.241Z" }, - { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload_time = "2025-05-17T21:35:10.622Z" }, - { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload_time = "2025-05-17T21:35:21.414Z" }, - { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload_time = "2025-05-17T21:35:42.174Z" }, - { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload_time = "2025-05-17T21:36:06.711Z" }, - { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload_time = "2025-05-17T21:36:29.965Z" }, - { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload_time = "2025-05-17T21:36:56.883Z" }, - { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload_time = "2025-05-17T21:37:07.368Z" }, - { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload_time = "2025-05-17T21:37:26.213Z" }, - { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload_time = "2025-05-17T21:37:56.699Z" }, - { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload_time = "2025-05-17T21:38:18.291Z" }, - { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload_time = "2025-05-17T21:38:27.319Z" }, - { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload_time = "2025-05-17T21:38:38.141Z" }, - { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload_time = "2025-05-17T21:38:58.433Z" }, - { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload_time = "2025-05-17T21:39:22.638Z" }, - { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload_time = "2025-05-17T21:39:45.865Z" }, - { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload_time = "2025-05-17T21:40:13.331Z" }, - { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload_time = "2025-05-17T21:43:46.099Z" }, - { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload_time = "2025-05-17T21:44:05.145Z" }, - { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload_time = "2025-05-17T21:40:44Z" }, - { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload_time = "2025-05-17T21:41:05.695Z" }, - { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload_time = "2025-05-17T21:41:15.903Z" }, - { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload_time = "2025-05-17T21:41:27.321Z" }, - { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload_time = "2025-05-17T21:41:49.738Z" }, - { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload_time = "2025-05-17T21:42:14.046Z" }, - { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload_time = "2025-05-17T21:42:37.464Z" }, - { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload_time = "2025-05-17T21:43:05.189Z" }, - { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload_time = "2025-05-17T21:43:16.254Z" }, - { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload_time = "2025-05-17T21:43:35.479Z" }, - { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload_time = "2025-05-17T21:44:35.948Z" }, - { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload_time = "2025-05-17T21:44:47.446Z" }, - { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload_time = "2025-05-17T21:45:11.871Z" }, - { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload_time = "2025-05-17T21:45:31.426Z" }, -] - -[[package]] -name = "numpy" -version = "2.3.1" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", -] -sdist = { url = "https://files.pythonhosted.org/packages/2e/19/d7c972dfe90a353dbd3efbbe1d14a5951de80c99c9dc1b93cd998d51dc0f/numpy-2.3.1.tar.gz", hash = "sha256:1ec9ae20a4226da374362cca3c62cd753faf2f951440b0e3b98e93c235441d2b", size = 20390372, upload_time = "2025-06-21T12:28:33.469Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b0/c7/87c64d7ab426156530676000c94784ef55676df2f13b2796f97722464124/numpy-2.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6ea9e48336a402551f52cd8f593343699003d2353daa4b72ce8d34f66b722070", size = 21199346, upload_time = "2025-06-21T11:47:47.57Z" }, - { url = "https://files.pythonhosted.org/packages/58/0e/0966c2f44beeac12af8d836e5b5f826a407cf34c45cb73ddcdfce9f5960b/numpy-2.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ccb7336eaf0e77c1635b232c141846493a588ec9ea777a7c24d7166bb8533ae", size = 14361143, upload_time = "2025-06-21T11:48:10.766Z" }, - { url = "https://files.pythonhosted.org/packages/7d/31/6e35a247acb1bfc19226791dfc7d4c30002cd4e620e11e58b0ddf836fe52/numpy-2.3.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:0bb3a4a61e1d327e035275d2a993c96fa786e4913aa089843e6a2d9dd205c66a", size = 5378989, upload_time = "2025-06-21T11:48:19.998Z" }, - { url = "https://files.pythonhosted.org/packages/b0/25/93b621219bb6f5a2d4e713a824522c69ab1f06a57cd571cda70e2e31af44/numpy-2.3.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:e344eb79dab01f1e838ebb67aab09965fb271d6da6b00adda26328ac27d4a66e", size = 6912890, upload_time = "2025-06-21T11:48:31.376Z" }, - { url = "https://files.pythonhosted.org/packages/ef/60/6b06ed98d11fb32e27fb59468b42383f3877146d3ee639f733776b6ac596/numpy-2.3.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:467db865b392168ceb1ef1ffa6f5a86e62468c43e0cfb4ab6da667ede10e58db", size = 14569032, upload_time = "2025-06-21T11:48:52.563Z" }, - { url = "https://files.pythonhosted.org/packages/75/c9/9bec03675192077467a9c7c2bdd1f2e922bd01d3a69b15c3a0fdcd8548f6/numpy-2.3.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:afed2ce4a84f6b0fc6c1ce734ff368cbf5a5e24e8954a338f3bdffa0718adffb", size = 16930354, upload_time = "2025-06-21T11:49:17.473Z" }, - { url = "https://files.pythonhosted.org/packages/6a/e2/5756a00cabcf50a3f527a0c968b2b4881c62b1379223931853114fa04cda/numpy-2.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0025048b3c1557a20bc80d06fdeb8cc7fc193721484cca82b2cfa072fec71a93", size = 15879605, upload_time = "2025-06-21T11:49:41.161Z" }, - { url = "https://files.pythonhosted.org/packages/ff/86/a471f65f0a86f1ca62dcc90b9fa46174dd48f50214e5446bc16a775646c5/numpy-2.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5ee121b60aa509679b682819c602579e1df14a5b07fe95671c8849aad8f2115", size = 18666994, upload_time = "2025-06-21T11:50:08.516Z" }, - { url = "https://files.pythonhosted.org/packages/43/a6/482a53e469b32be6500aaf61cfafd1de7a0b0d484babf679209c3298852e/numpy-2.3.1-cp311-cp311-win32.whl", hash = "sha256:a8b740f5579ae4585831b3cf0e3b0425c667274f82a484866d2adf9570539369", size = 6603672, upload_time = "2025-06-21T11:50:19.584Z" }, - { url = "https://files.pythonhosted.org/packages/6b/fb/bb613f4122c310a13ec67585c70e14b03bfc7ebabd24f4d5138b97371d7c/numpy-2.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4580adadc53311b163444f877e0789f1c8861e2698f6b2a4ca852fda154f3ff", size = 13024015, upload_time = "2025-06-21T11:50:39.139Z" }, - { url = "https://files.pythonhosted.org/packages/51/58/2d842825af9a0c041aca246dc92eb725e1bc5e1c9ac89712625db0c4e11c/numpy-2.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:ec0bdafa906f95adc9a0c6f26a4871fa753f25caaa0e032578a30457bff0af6a", size = 10456989, upload_time = "2025-06-21T11:50:55.616Z" }, - { url = "https://files.pythonhosted.org/packages/c6/56/71ad5022e2f63cfe0ca93559403d0edef14aea70a841d640bd13cdba578e/numpy-2.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2959d8f268f3d8ee402b04a9ec4bb7604555aeacf78b360dc4ec27f1d508177d", size = 20896664, upload_time = "2025-06-21T12:15:30.845Z" }, - { url = "https://files.pythonhosted.org/packages/25/65/2db52ba049813670f7f987cc5db6dac9be7cd95e923cc6832b3d32d87cef/numpy-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:762e0c0c6b56bdedfef9a8e1d4538556438288c4276901ea008ae44091954e29", size = 14131078, upload_time = "2025-06-21T12:15:52.23Z" }, - { url = "https://files.pythonhosted.org/packages/57/dd/28fa3c17b0e751047ac928c1e1b6990238faad76e9b147e585b573d9d1bd/numpy-2.3.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:867ef172a0976aaa1f1d1b63cf2090de8b636a7674607d514505fb7276ab08fc", size = 5112554, upload_time = "2025-06-21T12:16:01.434Z" }, - { url = "https://files.pythonhosted.org/packages/c9/fc/84ea0cba8e760c4644b708b6819d91784c290288c27aca916115e3311d17/numpy-2.3.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:4e602e1b8682c2b833af89ba641ad4176053aaa50f5cacda1a27004352dde943", size = 6646560, upload_time = "2025-06-21T12:16:11.895Z" }, - { url = "https://files.pythonhosted.org/packages/61/b2/512b0c2ddec985ad1e496b0bd853eeb572315c0f07cd6997473ced8f15e2/numpy-2.3.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:8e333040d069eba1652fb08962ec5b76af7f2c7bce1df7e1418c8055cf776f25", size = 14260638, upload_time = "2025-06-21T12:16:32.611Z" }, - { url = "https://files.pythonhosted.org/packages/6e/45/c51cb248e679a6c6ab14b7a8e3ead3f4a3fe7425fc7a6f98b3f147bec532/numpy-2.3.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e7cbf5a5eafd8d230a3ce356d892512185230e4781a361229bd902ff403bc660", size = 16632729, upload_time = "2025-06-21T12:16:57.439Z" }, - { url = "https://files.pythonhosted.org/packages/e4/ff/feb4be2e5c09a3da161b412019caf47183099cbea1132fd98061808c2df2/numpy-2.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5f1b8f26d1086835f442286c1d9b64bb3974b0b1e41bb105358fd07d20872952", size = 15565330, upload_time = "2025-06-21T12:17:20.638Z" }, - { url = "https://files.pythonhosted.org/packages/bc/6d/ceafe87587101e9ab0d370e4f6e5f3f3a85b9a697f2318738e5e7e176ce3/numpy-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ee8340cb48c9b7a5899d1149eece41ca535513a9698098edbade2a8e7a84da77", size = 18361734, upload_time = "2025-06-21T12:17:47.938Z" }, - { url = "https://files.pythonhosted.org/packages/2b/19/0fb49a3ea088be691f040c9bf1817e4669a339d6e98579f91859b902c636/numpy-2.3.1-cp312-cp312-win32.whl", hash = "sha256:e772dda20a6002ef7061713dc1e2585bc1b534e7909b2030b5a46dae8ff077ab", size = 6320411, upload_time = "2025-06-21T12:17:58.475Z" }, - { url = "https://files.pythonhosted.org/packages/b1/3e/e28f4c1dd9e042eb57a3eb652f200225e311b608632bc727ae378623d4f8/numpy-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cfecc7822543abdea6de08758091da655ea2210b8ffa1faf116b940693d3df76", size = 12734973, upload_time = "2025-06-21T12:18:17.601Z" }, - { url = "https://files.pythonhosted.org/packages/04/a8/8a5e9079dc722acf53522b8f8842e79541ea81835e9b5483388701421073/numpy-2.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:7be91b2239af2658653c5bb6f1b8bccafaf08226a258caf78ce44710a0160d30", size = 10191491, upload_time = "2025-06-21T12:18:33.585Z" }, - { url = "https://files.pythonhosted.org/packages/d4/bd/35ad97006d8abff8631293f8ea6adf07b0108ce6fec68da3c3fcca1197f2/numpy-2.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:25a1992b0a3fdcdaec9f552ef10d8103186f5397ab45e2d25f8ac51b1a6b97e8", size = 20889381, upload_time = "2025-06-21T12:19:04.103Z" }, - { url = "https://files.pythonhosted.org/packages/f1/4f/df5923874d8095b6062495b39729178eef4a922119cee32a12ee1bd4664c/numpy-2.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7dea630156d39b02a63c18f508f85010230409db5b2927ba59c8ba4ab3e8272e", size = 14152726, upload_time = "2025-06-21T12:19:25.599Z" }, - { url = "https://files.pythonhosted.org/packages/8c/0f/a1f269b125806212a876f7efb049b06c6f8772cf0121139f97774cd95626/numpy-2.3.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:bada6058dd886061f10ea15f230ccf7dfff40572e99fef440a4a857c8728c9c0", size = 5105145, upload_time = "2025-06-21T12:19:34.782Z" }, - { url = "https://files.pythonhosted.org/packages/6d/63/a7f7fd5f375b0361682f6ffbf686787e82b7bbd561268e4f30afad2bb3c0/numpy-2.3.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:a894f3816eb17b29e4783e5873f92faf55b710c2519e5c351767c51f79d8526d", size = 6639409, upload_time = "2025-06-21T12:19:45.228Z" }, - { url = "https://files.pythonhosted.org/packages/bf/0d/1854a4121af895aab383f4aa233748f1df4671ef331d898e32426756a8a6/numpy-2.3.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:18703df6c4a4fee55fd3d6e5a253d01c5d33a295409b03fda0c86b3ca2ff41a1", size = 14257630, upload_time = "2025-06-21T12:20:06.544Z" }, - { url = "https://files.pythonhosted.org/packages/50/30/af1b277b443f2fb08acf1c55ce9d68ee540043f158630d62cef012750f9f/numpy-2.3.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5902660491bd7a48b2ec16c23ccb9124b8abfd9583c5fdfa123fe6b421e03de1", size = 16627546, upload_time = "2025-06-21T12:20:31.002Z" }, - { url = "https://files.pythonhosted.org/packages/6e/ec/3b68220c277e463095342d254c61be8144c31208db18d3fd8ef02712bcd6/numpy-2.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:36890eb9e9d2081137bd78d29050ba63b8dab95dff7912eadf1185e80074b2a0", size = 15562538, upload_time = "2025-06-21T12:20:54.322Z" }, - { url = "https://files.pythonhosted.org/packages/77/2b/4014f2bcc4404484021c74d4c5ee8eb3de7e3f7ac75f06672f8dcf85140a/numpy-2.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a780033466159c2270531e2b8ac063704592a0bc62ec4a1b991c7c40705eb0e8", size = 18360327, upload_time = "2025-06-21T12:21:21.053Z" }, - { url = "https://files.pythonhosted.org/packages/40/8d/2ddd6c9b30fcf920837b8672f6c65590c7d92e43084c25fc65edc22e93ca/numpy-2.3.1-cp313-cp313-win32.whl", hash = "sha256:39bff12c076812595c3a306f22bfe49919c5513aa1e0e70fac756a0be7c2a2b8", size = 6312330, upload_time = "2025-06-21T12:25:07.447Z" }, - { url = "https://files.pythonhosted.org/packages/dd/c8/beaba449925988d415efccb45bf977ff8327a02f655090627318f6398c7b/numpy-2.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d5ee6eec45f08ce507a6570e06f2f879b374a552087a4179ea7838edbcbfa42", size = 12731565, upload_time = "2025-06-21T12:25:26.444Z" }, - { url = "https://files.pythonhosted.org/packages/0b/c3/5c0c575d7ec78c1126998071f58facfc124006635da75b090805e642c62e/numpy-2.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:0c4d9e0a8368db90f93bd192bfa771ace63137c3488d198ee21dfb8e7771916e", size = 10190262, upload_time = "2025-06-21T12:25:42.196Z" }, - { url = "https://files.pythonhosted.org/packages/ea/19/a029cd335cf72f79d2644dcfc22d90f09caa86265cbbde3b5702ccef6890/numpy-2.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b0b5397374f32ec0649dd98c652a1798192042e715df918c20672c62fb52d4b8", size = 20987593, upload_time = "2025-06-21T12:21:51.664Z" }, - { url = "https://files.pythonhosted.org/packages/25/91/8ea8894406209107d9ce19b66314194675d31761fe2cb3c84fe2eeae2f37/numpy-2.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c5bdf2015ccfcee8253fb8be695516ac4457c743473a43290fd36eba6a1777eb", size = 14300523, upload_time = "2025-06-21T12:22:13.583Z" }, - { url = "https://files.pythonhosted.org/packages/a6/7f/06187b0066eefc9e7ce77d5f2ddb4e314a55220ad62dd0bfc9f2c44bac14/numpy-2.3.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d70f20df7f08b90a2062c1f07737dd340adccf2068d0f1b9b3d56e2038979fee", size = 5227993, upload_time = "2025-06-21T12:22:22.53Z" }, - { url = "https://files.pythonhosted.org/packages/e8/ec/a926c293c605fa75e9cfb09f1e4840098ed46d2edaa6e2152ee35dc01ed3/numpy-2.3.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:2fb86b7e58f9ac50e1e9dd1290154107e47d1eef23a0ae9145ded06ea606f992", size = 6736652, upload_time = "2025-06-21T12:22:33.629Z" }, - { url = "https://files.pythonhosted.org/packages/e3/62/d68e52fb6fde5586650d4c0ce0b05ff3a48ad4df4ffd1b8866479d1d671d/numpy-2.3.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:23ab05b2d241f76cb883ce8b9a93a680752fbfcbd51c50eff0b88b979e471d8c", size = 14331561, upload_time = "2025-06-21T12:22:55.056Z" }, - { url = "https://files.pythonhosted.org/packages/fc/ec/b74d3f2430960044bdad6900d9f5edc2dc0fb8bf5a0be0f65287bf2cbe27/numpy-2.3.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ce2ce9e5de4703a673e705183f64fd5da5bf36e7beddcb63a25ee2286e71ca48", size = 16693349, upload_time = "2025-06-21T12:23:20.53Z" }, - { url = "https://files.pythonhosted.org/packages/0d/15/def96774b9d7eb198ddadfcbd20281b20ebb510580419197e225f5c55c3e/numpy-2.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c4913079974eeb5c16ccfd2b1f09354b8fed7e0d6f2cab933104a09a6419b1ee", size = 15642053, upload_time = "2025-06-21T12:23:43.697Z" }, - { url = "https://files.pythonhosted.org/packages/2b/57/c3203974762a759540c6ae71d0ea2341c1fa41d84e4971a8e76d7141678a/numpy-2.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:010ce9b4f00d5c036053ca684c77441f2f2c934fd23bee058b4d6f196efd8280", size = 18434184, upload_time = "2025-06-21T12:24:10.708Z" }, - { url = "https://files.pythonhosted.org/packages/22/8a/ccdf201457ed8ac6245187850aff4ca56a79edbea4829f4e9f14d46fa9a5/numpy-2.3.1-cp313-cp313t-win32.whl", hash = "sha256:6269b9edfe32912584ec496d91b00b6d34282ca1d07eb10e82dfc780907d6c2e", size = 6440678, upload_time = "2025-06-21T12:24:21.596Z" }, - { url = "https://files.pythonhosted.org/packages/f1/7e/7f431d8bd8eb7e03d79294aed238b1b0b174b3148570d03a8a8a8f6a0da9/numpy-2.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:2a809637460e88a113e186e87f228d74ae2852a2e0c44de275263376f17b5bdc", size = 12870697, upload_time = "2025-06-21T12:24:40.644Z" }, - { url = "https://files.pythonhosted.org/packages/d4/ca/af82bf0fad4c3e573c6930ed743b5308492ff19917c7caaf2f9b6f9e2e98/numpy-2.3.1-cp313-cp313t-win_arm64.whl", hash = "sha256:eccb9a159db9aed60800187bc47a6d3451553f0e1b08b068d8b277ddfbb9b244", size = 10260376, upload_time = "2025-06-21T12:24:56.884Z" }, - { url = "https://files.pythonhosted.org/packages/e8/34/facc13b9b42ddca30498fc51f7f73c3d0f2be179943a4b4da8686e259740/numpy-2.3.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ad506d4b09e684394c42c966ec1527f6ebc25da7f4da4b1b056606ffe446b8a3", size = 21070637, upload_time = "2025-06-21T12:26:12.518Z" }, - { url = "https://files.pythonhosted.org/packages/65/b6/41b705d9dbae04649b529fc9bd3387664c3281c7cd78b404a4efe73dcc45/numpy-2.3.1-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:ebb8603d45bc86bbd5edb0d63e52c5fd9e7945d3a503b77e486bd88dde67a19b", size = 5304087, upload_time = "2025-06-21T12:26:22.294Z" }, - { url = "https://files.pythonhosted.org/packages/7a/b4/fe3ac1902bff7a4934a22d49e1c9d71a623204d654d4cc43c6e8fe337fcb/numpy-2.3.1-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:15aa4c392ac396e2ad3d0a2680c0f0dee420f9fed14eef09bdb9450ee6dcb7b7", size = 6817588, upload_time = "2025-06-21T12:26:32.939Z" }, - { url = "https://files.pythonhosted.org/packages/ae/ee/89bedf69c36ace1ac8f59e97811c1f5031e179a37e4821c3a230bf750142/numpy-2.3.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c6e0bf9d1a2f50d2b65a7cf56db37c095af17b59f6c132396f7c6d5dd76484df", size = 14399010, upload_time = "2025-06-21T12:26:54.086Z" }, - { url = "https://files.pythonhosted.org/packages/15/08/e00e7070ede29b2b176165eba18d6f9784d5349be3c0c1218338e79c27fd/numpy-2.3.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:eabd7e8740d494ce2b4ea0ff05afa1b7b291e978c0ae075487c51e8bd93c0c68", size = 16752042, upload_time = "2025-06-21T12:27:19.018Z" }, - { url = "https://files.pythonhosted.org/packages/48/6b/1c6b515a83d5564b1698a61efa245727c8feecf308f4091f565988519d20/numpy-2.3.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e610832418a2bc09d974cc9fecebfa51e9532d6190223bc5ef6a7402ebf3b5cb", size = 12927246, upload_time = "2025-06-21T12:27:38.618Z" }, -] - -[[package]] -name = "openai" -version = "1.95.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "distro" }, - { name = "httpx" }, - { name = "jiter" }, - { name = "pydantic" }, - { name = "sniffio" }, - { name = "tqdm" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ef/2f/0c6f509a1585545962bfa6e201d7fb658eb2a6f52fb8c26765632d91706c/openai-1.95.0.tar.gz", hash = "sha256:54bc42df9f7142312647dd485d34cca5df20af825fa64a30ca55164be2cf4cc9", size = 488144, upload_time = "2025-07-10T18:35:49.946Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/19/a5/57d0bb58b938a3e3f352ff26e645da1660436402a6ad1b29780d261cc5a5/openai-1.95.0-py3-none-any.whl", hash = "sha256:a7afc9dca7e7d616371842af8ea6dbfbcb739a85d183f5f664ab1cc311b9ef18", size = 755572, upload_time = "2025-07-10T18:35:47.507Z" }, -] - -[[package]] -name = "packaging" -version = "25.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload_time = "2025-04-19T11:48:59.673Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload_time = "2025-04-19T11:48:57.875Z" }, -] - -[[package]] -name = "pandas" -version = "2.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "python-dateutil" }, - { name = "pytz" }, - { name = "tzdata" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/d1/6f/75aa71f8a14267117adeeed5d21b204770189c0a0025acbdc03c337b28fc/pandas-2.3.1.tar.gz", hash = "sha256:0a95b9ac964fe83ce317827f80304d37388ea77616b1425f0ae41c9d2d0d7bb2", size = 4487493, upload_time = "2025-07-07T19:20:04.079Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c4/ca/aa97b47287221fa37a49634532e520300088e290b20d690b21ce3e448143/pandas-2.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:22c2e866f7209ebc3a8f08d75766566aae02bcc91d196935a1d9e59c7b990ac9", size = 11542731, upload_time = "2025-07-07T19:18:12.619Z" }, - { url = "https://files.pythonhosted.org/packages/80/bf/7938dddc5f01e18e573dcfb0f1b8c9357d9b5fa6ffdee6e605b92efbdff2/pandas-2.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3583d348546201aff730c8c47e49bc159833f971c2899d6097bce68b9112a4f1", size = 10790031, upload_time = "2025-07-07T19:18:16.611Z" }, - { url = "https://files.pythonhosted.org/packages/ee/2f/9af748366763b2a494fed477f88051dbf06f56053d5c00eba652697e3f94/pandas-2.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f951fbb702dacd390561e0ea45cdd8ecfa7fb56935eb3dd78e306c19104b9b0", size = 11724083, upload_time = "2025-07-07T19:18:20.512Z" }, - { url = "https://files.pythonhosted.org/packages/2c/95/79ab37aa4c25d1e7df953dde407bb9c3e4ae47d154bc0dd1692f3a6dcf8c/pandas-2.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd05b72ec02ebfb993569b4931b2e16fbb4d6ad6ce80224a3ee838387d83a191", size = 12342360, upload_time = "2025-07-07T19:18:23.194Z" }, - { url = "https://files.pythonhosted.org/packages/75/a7/d65e5d8665c12c3c6ff5edd9709d5836ec9b6f80071b7f4a718c6106e86e/pandas-2.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1b916a627919a247d865aed068eb65eb91a344b13f5b57ab9f610b7716c92de1", size = 13202098, upload_time = "2025-07-07T19:18:25.558Z" }, - { url = "https://files.pythonhosted.org/packages/65/f3/4c1dbd754dbaa79dbf8b537800cb2fa1a6e534764fef50ab1f7533226c5c/pandas-2.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:fe67dc676818c186d5a3d5425250e40f179c2a89145df477dd82945eaea89e97", size = 13837228, upload_time = "2025-07-07T19:18:28.344Z" }, - { url = "https://files.pythonhosted.org/packages/3f/d6/d7f5777162aa9b48ec3910bca5a58c9b5927cfd9cfde3aa64322f5ba4b9f/pandas-2.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:2eb789ae0274672acbd3c575b0598d213345660120a257b47b5dafdc618aec83", size = 11336561, upload_time = "2025-07-07T19:18:31.211Z" }, - { url = "https://files.pythonhosted.org/packages/76/1c/ccf70029e927e473a4476c00e0d5b32e623bff27f0402d0a92b7fc29bb9f/pandas-2.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2b0540963d83431f5ce8870ea02a7430adca100cec8a050f0811f8e31035541b", size = 11566608, upload_time = "2025-07-07T19:18:33.86Z" }, - { url = "https://files.pythonhosted.org/packages/ec/d3/3c37cb724d76a841f14b8f5fe57e5e3645207cc67370e4f84717e8bb7657/pandas-2.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fe7317f578c6a153912bd2292f02e40c1d8f253e93c599e82620c7f69755c74f", size = 10823181, upload_time = "2025-07-07T19:18:36.151Z" }, - { url = "https://files.pythonhosted.org/packages/8a/4c/367c98854a1251940edf54a4df0826dcacfb987f9068abf3e3064081a382/pandas-2.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e6723a27ad7b244c0c79d8e7007092d7c8f0f11305770e2f4cd778b3ad5f9f85", size = 11793570, upload_time = "2025-07-07T19:18:38.385Z" }, - { url = "https://files.pythonhosted.org/packages/07/5f/63760ff107bcf5146eee41b38b3985f9055e710a72fdd637b791dea3495c/pandas-2.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3462c3735fe19f2638f2c3a40bd94ec2dc5ba13abbb032dd2fa1f540a075509d", size = 12378887, upload_time = "2025-07-07T19:18:41.284Z" }, - { url = "https://files.pythonhosted.org/packages/15/53/f31a9b4dfe73fe4711c3a609bd8e60238022f48eacedc257cd13ae9327a7/pandas-2.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:98bcc8b5bf7afed22cc753a28bc4d9e26e078e777066bc53fac7904ddef9a678", size = 13230957, upload_time = "2025-07-07T19:18:44.187Z" }, - { url = "https://files.pythonhosted.org/packages/e0/94/6fce6bf85b5056d065e0a7933cba2616dcb48596f7ba3c6341ec4bcc529d/pandas-2.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4d544806b485ddf29e52d75b1f559142514e60ef58a832f74fb38e48d757b299", size = 13883883, upload_time = "2025-07-07T19:18:46.498Z" }, - { url = "https://files.pythonhosted.org/packages/c8/7b/bdcb1ed8fccb63d04bdb7635161d0ec26596d92c9d7a6cce964e7876b6c1/pandas-2.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b3cd4273d3cb3707b6fffd217204c52ed92859533e31dc03b7c5008aa933aaab", size = 11340212, upload_time = "2025-07-07T19:18:49.293Z" }, - { url = "https://files.pythonhosted.org/packages/46/de/b8445e0f5d217a99fe0eeb2f4988070908979bec3587c0633e5428ab596c/pandas-2.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:689968e841136f9e542020698ee1c4fbe9caa2ed2213ae2388dc7b81721510d3", size = 11588172, upload_time = "2025-07-07T19:18:52.054Z" }, - { url = "https://files.pythonhosted.org/packages/1e/e0/801cdb3564e65a5ac041ab99ea6f1d802a6c325bb6e58c79c06a3f1cd010/pandas-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:025e92411c16cbe5bb2a4abc99732a6b132f439b8aab23a59fa593eb00704232", size = 10717365, upload_time = "2025-07-07T19:18:54.785Z" }, - { url = "https://files.pythonhosted.org/packages/51/a5/c76a8311833c24ae61a376dbf360eb1b1c9247a5d9c1e8b356563b31b80c/pandas-2.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b7ff55f31c4fcb3e316e8f7fa194566b286d6ac430afec0d461163312c5841e", size = 11280411, upload_time = "2025-07-07T19:18:57.045Z" }, - { url = "https://files.pythonhosted.org/packages/da/01/e383018feba0a1ead6cf5fe8728e5d767fee02f06a3d800e82c489e5daaf/pandas-2.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7dcb79bf373a47d2a40cf7232928eb7540155abbc460925c2c96d2d30b006eb4", size = 11988013, upload_time = "2025-07-07T19:18:59.771Z" }, - { url = "https://files.pythonhosted.org/packages/5b/14/cec7760d7c9507f11c97d64f29022e12a6cc4fc03ac694535e89f88ad2ec/pandas-2.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:56a342b231e8862c96bdb6ab97170e203ce511f4d0429589c8ede1ee8ece48b8", size = 12767210, upload_time = "2025-07-07T19:19:02.944Z" }, - { url = "https://files.pythonhosted.org/packages/50/b9/6e2d2c6728ed29fb3d4d4d302504fb66f1a543e37eb2e43f352a86365cdf/pandas-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ca7ed14832bce68baef331f4d7f294411bed8efd032f8109d690df45e00c4679", size = 13440571, upload_time = "2025-07-07T19:19:06.82Z" }, - { url = "https://files.pythonhosted.org/packages/80/a5/3a92893e7399a691bad7664d977cb5e7c81cf666c81f89ea76ba2bff483d/pandas-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:ac942bfd0aca577bef61f2bc8da8147c4ef6879965ef883d8e8d5d2dc3e744b8", size = 10987601, upload_time = "2025-07-07T19:19:09.589Z" }, - { url = "https://files.pythonhosted.org/packages/32/ed/ff0a67a2c5505e1854e6715586ac6693dd860fbf52ef9f81edee200266e7/pandas-2.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9026bd4a80108fac2239294a15ef9003c4ee191a0f64b90f170b40cfb7cf2d22", size = 11531393, upload_time = "2025-07-07T19:19:12.245Z" }, - { url = "https://files.pythonhosted.org/packages/c7/db/d8f24a7cc9fb0972adab0cc80b6817e8bef888cfd0024eeb5a21c0bb5c4a/pandas-2.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6de8547d4fdb12421e2d047a2c446c623ff4c11f47fddb6b9169eb98ffba485a", size = 10668750, upload_time = "2025-07-07T19:19:14.612Z" }, - { url = "https://files.pythonhosted.org/packages/0f/b0/80f6ec783313f1e2356b28b4fd8d2148c378370045da918c73145e6aab50/pandas-2.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:782647ddc63c83133b2506912cc6b108140a38a37292102aaa19c81c83db2928", size = 11342004, upload_time = "2025-07-07T19:19:16.857Z" }, - { url = "https://files.pythonhosted.org/packages/e9/e2/20a317688435470872885e7fc8f95109ae9683dec7c50be29b56911515a5/pandas-2.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ba6aff74075311fc88504b1db890187a3cd0f887a5b10f5525f8e2ef55bfdb9", size = 12050869, upload_time = "2025-07-07T19:19:19.265Z" }, - { url = "https://files.pythonhosted.org/packages/55/79/20d746b0a96c67203a5bee5fb4e00ac49c3e8009a39e1f78de264ecc5729/pandas-2.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e5635178b387bd2ba4ac040f82bc2ef6e6b500483975c4ebacd34bec945fda12", size = 12750218, upload_time = "2025-07-07T19:19:21.547Z" }, - { url = "https://files.pythonhosted.org/packages/7c/0f/145c8b41e48dbf03dd18fdd7f24f8ba95b8254a97a3379048378f33e7838/pandas-2.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6f3bf5ec947526106399a9e1d26d40ee2b259c66422efdf4de63c848492d91bb", size = 13416763, upload_time = "2025-07-07T19:19:23.939Z" }, - { url = "https://files.pythonhosted.org/packages/b2/c0/54415af59db5cdd86a3d3bf79863e8cc3fa9ed265f0745254061ac09d5f2/pandas-2.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:1c78cf43c8fde236342a1cb2c34bcff89564a7bfed7e474ed2fffa6aed03a956", size = 10987482, upload_time = "2025-07-07T19:19:42.699Z" }, - { url = "https://files.pythonhosted.org/packages/48/64/2fd2e400073a1230e13b8cd604c9bc95d9e3b962e5d44088ead2e8f0cfec/pandas-2.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8dfc17328e8da77be3cf9f47509e5637ba8f137148ed0e9b5241e1baf526e20a", size = 12029159, upload_time = "2025-07-07T19:19:26.362Z" }, - { url = "https://files.pythonhosted.org/packages/d8/0a/d84fd79b0293b7ef88c760d7dca69828d867c89b6d9bc52d6a27e4d87316/pandas-2.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ec6c851509364c59a5344458ab935e6451b31b818be467eb24b0fe89bd05b6b9", size = 11393287, upload_time = "2025-07-07T19:19:29.157Z" }, - { url = "https://files.pythonhosted.org/packages/50/ae/ff885d2b6e88f3c7520bb74ba319268b42f05d7e583b5dded9837da2723f/pandas-2.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:911580460fc4884d9b05254b38a6bfadddfcc6aaef856fb5859e7ca202e45275", size = 11309381, upload_time = "2025-07-07T19:19:31.436Z" }, - { url = "https://files.pythonhosted.org/packages/85/86/1fa345fc17caf5d7780d2699985c03dbe186c68fee00b526813939062bb0/pandas-2.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2f4d6feeba91744872a600e6edbbd5b033005b431d5ae8379abee5bcfa479fab", size = 11883998, upload_time = "2025-07-07T19:19:34.267Z" }, - { url = "https://files.pythonhosted.org/packages/81/aa/e58541a49b5e6310d89474333e994ee57fea97c8aaa8fc7f00b873059bbf/pandas-2.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fe37e757f462d31a9cd7580236a82f353f5713a80e059a29753cf938c6775d96", size = 12704705, upload_time = "2025-07-07T19:19:36.856Z" }, - { url = "https://files.pythonhosted.org/packages/d5/f9/07086f5b0f2a19872554abeea7658200824f5835c58a106fa8f2ae96a46c/pandas-2.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5db9637dbc24b631ff3707269ae4559bce4b7fd75c1c4d7e13f40edc42df4444", size = 13189044, upload_time = "2025-07-07T19:19:39.999Z" }, -] - -[[package]] -name = "peewee" -version = "3.18.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/04/89/76f6f1b744c8608e0d416b588b9d63c2a500ff800065ae610f7c80f532d6/peewee-3.18.2.tar.gz", hash = "sha256:77a54263eb61aff2ea72f63d2eeb91b140c25c1884148e28e4c0f7c4f64996a0", size = 949220, upload_time = "2025-07-08T12:52:03.941Z" } - -[[package]] -name = "pillow" -version = "11.3.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload_time = "2025-07-01T09:16:30.666Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4c/5d/45a3553a253ac8763f3561371432a90bdbe6000fbdcf1397ffe502aa206c/pillow-11.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b9c17fd4ace828b3003dfd1e30bff24863e0eb59b535e8f80194d9cc7ecf860", size = 5316554, upload_time = "2025-07-01T09:13:39.342Z" }, - { url = "https://files.pythonhosted.org/packages/7c/c8/67c12ab069ef586a25a4a79ced553586748fad100c77c0ce59bb4983ac98/pillow-11.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:65dc69160114cdd0ca0f35cb434633c75e8e7fad4cf855177a05bf38678f73ad", size = 4686548, upload_time = "2025-07-01T09:13:41.835Z" }, - { url = "https://files.pythonhosted.org/packages/2f/bd/6741ebd56263390b382ae4c5de02979af7f8bd9807346d068700dd6d5cf9/pillow-11.3.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7107195ddc914f656c7fc8e4a5e1c25f32e9236ea3ea860f257b0436011fddd0", size = 5859742, upload_time = "2025-07-03T13:09:47.439Z" }, - { url = "https://files.pythonhosted.org/packages/ca/0b/c412a9e27e1e6a829e6ab6c2dca52dd563efbedf4c9c6aa453d9a9b77359/pillow-11.3.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc3e831b563b3114baac7ec2ee86819eb03caa1a2cef0b481a5675b59c4fe23b", size = 7633087, upload_time = "2025-07-03T13:09:51.796Z" }, - { url = "https://files.pythonhosted.org/packages/59/9d/9b7076aaf30f5dd17e5e5589b2d2f5a5d7e30ff67a171eb686e4eecc2adf/pillow-11.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f1f182ebd2303acf8c380a54f615ec883322593320a9b00438eb842c1f37ae50", size = 5963350, upload_time = "2025-07-01T09:13:43.865Z" }, - { url = "https://files.pythonhosted.org/packages/f0/16/1a6bf01fb622fb9cf5c91683823f073f053005c849b1f52ed613afcf8dae/pillow-11.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4445fa62e15936a028672fd48c4c11a66d641d2c05726c7ec1f8ba6a572036ae", size = 6631840, upload_time = "2025-07-01T09:13:46.161Z" }, - { url = "https://files.pythonhosted.org/packages/7b/e6/6ff7077077eb47fde78739e7d570bdcd7c10495666b6afcd23ab56b19a43/pillow-11.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:71f511f6b3b91dd543282477be45a033e4845a40278fa8dcdbfdb07109bf18f9", size = 6074005, upload_time = "2025-07-01T09:13:47.829Z" }, - { url = "https://files.pythonhosted.org/packages/c3/3a/b13f36832ea6d279a697231658199e0a03cd87ef12048016bdcc84131601/pillow-11.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:040a5b691b0713e1f6cbe222e0f4f74cd233421e105850ae3b3c0ceda520f42e", size = 6708372, upload_time = "2025-07-01T09:13:52.145Z" }, - { url = "https://files.pythonhosted.org/packages/6c/e4/61b2e1a7528740efbc70b3d581f33937e38e98ef3d50b05007267a55bcb2/pillow-11.3.0-cp310-cp310-win32.whl", hash = "sha256:89bd777bc6624fe4115e9fac3352c79ed60f3bb18651420635f26e643e3dd1f6", size = 6277090, upload_time = "2025-07-01T09:13:53.915Z" }, - { url = "https://files.pythonhosted.org/packages/a9/d3/60c781c83a785d6afbd6a326ed4d759d141de43aa7365725cbcd65ce5e54/pillow-11.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:19d2ff547c75b8e3ff46f4d9ef969a06c30ab2d4263a9e287733aa8b2429ce8f", size = 6985988, upload_time = "2025-07-01T09:13:55.699Z" }, - { url = "https://files.pythonhosted.org/packages/9f/28/4f4a0203165eefb3763939c6789ba31013a2e90adffb456610f30f613850/pillow-11.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:819931d25e57b513242859ce1876c58c59dc31587847bf74cfe06b2e0cb22d2f", size = 2422899, upload_time = "2025-07-01T09:13:57.497Z" }, - { url = "https://files.pythonhosted.org/packages/db/26/77f8ed17ca4ffd60e1dcd220a6ec6d71210ba398cfa33a13a1cd614c5613/pillow-11.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1cd110edf822773368b396281a2293aeb91c90a2db00d78ea43e7e861631b722", size = 5316531, upload_time = "2025-07-01T09:13:59.203Z" }, - { url = "https://files.pythonhosted.org/packages/cb/39/ee475903197ce709322a17a866892efb560f57900d9af2e55f86db51b0a5/pillow-11.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c412fddd1b77a75aa904615ebaa6001f169b26fd467b4be93aded278266b288", size = 4686560, upload_time = "2025-07-01T09:14:01.101Z" }, - { url = "https://files.pythonhosted.org/packages/d5/90/442068a160fd179938ba55ec8c97050a612426fae5ec0a764e345839f76d/pillow-11.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1aa4de119a0ecac0a34a9c8bde33f34022e2e8f99104e47a3ca392fd60e37d", size = 5870978, upload_time = "2025-07-03T13:09:55.638Z" }, - { url = "https://files.pythonhosted.org/packages/13/92/dcdd147ab02daf405387f0218dcf792dc6dd5b14d2573d40b4caeef01059/pillow-11.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:91da1d88226663594e3f6b4b8c3c8d85bd504117d043740a8e0ec449087cc494", size = 7641168, upload_time = "2025-07-03T13:10:00.37Z" }, - { url = "https://files.pythonhosted.org/packages/6e/db/839d6ba7fd38b51af641aa904e2960e7a5644d60ec754c046b7d2aee00e5/pillow-11.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:643f189248837533073c405ec2f0bb250ba54598cf80e8c1e043381a60632f58", size = 5973053, upload_time = "2025-07-01T09:14:04.491Z" }, - { url = "https://files.pythonhosted.org/packages/f2/2f/d7675ecae6c43e9f12aa8d58b6012683b20b6edfbdac7abcb4e6af7a3784/pillow-11.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:106064daa23a745510dabce1d84f29137a37224831d88eb4ce94bb187b1d7e5f", size = 6640273, upload_time = "2025-07-01T09:14:06.235Z" }, - { url = "https://files.pythonhosted.org/packages/45/ad/931694675ede172e15b2ff03c8144a0ddaea1d87adb72bb07655eaffb654/pillow-11.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd8ff254faf15591e724dc7c4ddb6bf4793efcbe13802a4ae3e863cd300b493e", size = 6082043, upload_time = "2025-07-01T09:14:07.978Z" }, - { url = "https://files.pythonhosted.org/packages/3a/04/ba8f2b11fc80d2dd462d7abec16351b45ec99cbbaea4387648a44190351a/pillow-11.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:932c754c2d51ad2b2271fd01c3d121daaa35e27efae2a616f77bf164bc0b3e94", size = 6715516, upload_time = "2025-07-01T09:14:10.233Z" }, - { url = "https://files.pythonhosted.org/packages/48/59/8cd06d7f3944cc7d892e8533c56b0acb68399f640786313275faec1e3b6f/pillow-11.3.0-cp311-cp311-win32.whl", hash = "sha256:b4b8f3efc8d530a1544e5962bd6b403d5f7fe8b9e08227c6b255f98ad82b4ba0", size = 6274768, upload_time = "2025-07-01T09:14:11.921Z" }, - { url = "https://files.pythonhosted.org/packages/f1/cc/29c0f5d64ab8eae20f3232da8f8571660aa0ab4b8f1331da5c2f5f9a938e/pillow-11.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:1a992e86b0dd7aeb1f053cd506508c0999d710a8f07b4c791c63843fc6a807ac", size = 6986055, upload_time = "2025-07-01T09:14:13.623Z" }, - { url = "https://files.pythonhosted.org/packages/c6/df/90bd886fabd544c25addd63e5ca6932c86f2b701d5da6c7839387a076b4a/pillow-11.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:30807c931ff7c095620fe04448e2c2fc673fcbb1ffe2a7da3fb39613489b1ddd", size = 2423079, upload_time = "2025-07-01T09:14:15.268Z" }, - { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800, upload_time = "2025-07-01T09:14:17.648Z" }, - { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296, upload_time = "2025-07-01T09:14:19.828Z" }, - { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726, upload_time = "2025-07-03T13:10:04.448Z" }, - { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652, upload_time = "2025-07-03T13:10:10.391Z" }, - { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787, upload_time = "2025-07-01T09:14:21.63Z" }, - { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236, upload_time = "2025-07-01T09:14:23.321Z" }, - { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950, upload_time = "2025-07-01T09:14:25.237Z" }, - { url = "https://files.pythonhosted.org/packages/0b/1a/7cff92e695a2a29ac1958c2a0fe4c0b2393b60aac13b04a4fe2735cad52d/pillow-11.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d", size = 6723358, upload_time = "2025-07-01T09:14:27.053Z" }, - { url = "https://files.pythonhosted.org/packages/26/7d/73699ad77895f69edff76b0f332acc3d497f22f5d75e5360f78cbcaff248/pillow-11.3.0-cp312-cp312-win32.whl", hash = "sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149", size = 6275079, upload_time = "2025-07-01T09:14:30.104Z" }, - { url = "https://files.pythonhosted.org/packages/8c/ce/e7dfc873bdd9828f3b6e5c2bbb74e47a98ec23cc5c74fc4e54462f0d9204/pillow-11.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d", size = 6986324, upload_time = "2025-07-01T09:14:31.899Z" }, - { url = "https://files.pythonhosted.org/packages/16/8f/b13447d1bf0b1f7467ce7d86f6e6edf66c0ad7cf44cf5c87a37f9bed9936/pillow-11.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542", size = 2423067, upload_time = "2025-07-01T09:14:33.709Z" }, - { url = "https://files.pythonhosted.org/packages/1e/93/0952f2ed8db3a5a4c7a11f91965d6184ebc8cd7cbb7941a260d5f018cd2d/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1c627742b539bba4309df89171356fcb3cc5a9178355b2727d1b74a6cf155fbd", size = 2128328, upload_time = "2025-07-01T09:14:35.276Z" }, - { url = "https://files.pythonhosted.org/packages/4b/e8/100c3d114b1a0bf4042f27e0f87d2f25e857e838034e98ca98fe7b8c0a9c/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:30b7c02f3899d10f13d7a48163c8969e4e653f8b43416d23d13d1bbfdc93b9f8", size = 2170652, upload_time = "2025-07-01T09:14:37.203Z" }, - { url = "https://files.pythonhosted.org/packages/aa/86/3f758a28a6e381758545f7cdb4942e1cb79abd271bea932998fc0db93cb6/pillow-11.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f", size = 2227443, upload_time = "2025-07-01T09:14:39.344Z" }, - { url = "https://files.pythonhosted.org/packages/01/f4/91d5b3ffa718df2f53b0dc109877993e511f4fd055d7e9508682e8aba092/pillow-11.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c", size = 5278474, upload_time = "2025-07-01T09:14:41.843Z" }, - { url = "https://files.pythonhosted.org/packages/f9/0e/37d7d3eca6c879fbd9dba21268427dffda1ab00d4eb05b32923d4fbe3b12/pillow-11.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd", size = 4686038, upload_time = "2025-07-01T09:14:44.008Z" }, - { url = "https://files.pythonhosted.org/packages/ff/b0/3426e5c7f6565e752d81221af9d3676fdbb4f352317ceafd42899aaf5d8a/pillow-11.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e", size = 5864407, upload_time = "2025-07-03T13:10:15.628Z" }, - { url = "https://files.pythonhosted.org/packages/fc/c1/c6c423134229f2a221ee53f838d4be9d82bab86f7e2f8e75e47b6bf6cd77/pillow-11.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1", size = 7639094, upload_time = "2025-07-03T13:10:21.857Z" }, - { url = "https://files.pythonhosted.org/packages/ba/c9/09e6746630fe6372c67c648ff9deae52a2bc20897d51fa293571977ceb5d/pillow-11.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805", size = 5973503, upload_time = "2025-07-01T09:14:45.698Z" }, - { url = "https://files.pythonhosted.org/packages/d5/1c/a2a29649c0b1983d3ef57ee87a66487fdeb45132df66ab30dd37f7dbe162/pillow-11.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8", size = 6642574, upload_time = "2025-07-01T09:14:47.415Z" }, - { url = "https://files.pythonhosted.org/packages/36/de/d5cc31cc4b055b6c6fd990e3e7f0f8aaf36229a2698501bcb0cdf67c7146/pillow-11.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2", size = 6084060, upload_time = "2025-07-01T09:14:49.636Z" }, - { url = "https://files.pythonhosted.org/packages/d5/ea/502d938cbaeec836ac28a9b730193716f0114c41325db428e6b280513f09/pillow-11.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:45dfc51ac5975b938e9809451c51734124e73b04d0f0ac621649821a63852e7b", size = 6721407, upload_time = "2025-07-01T09:14:51.962Z" }, - { url = "https://files.pythonhosted.org/packages/45/9c/9c5e2a73f125f6cbc59cc7087c8f2d649a7ae453f83bd0362ff7c9e2aee2/pillow-11.3.0-cp313-cp313-win32.whl", hash = "sha256:a4d336baed65d50d37b88ca5b60c0fa9d81e3a87d4a7930d3880d1624d5b31f3", size = 6273841, upload_time = "2025-07-01T09:14:54.142Z" }, - { url = "https://files.pythonhosted.org/packages/23/85/397c73524e0cd212067e0c969aa245b01d50183439550d24d9f55781b776/pillow-11.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bce5c4fd0921f99d2e858dc4d4d64193407e1b99478bc5cacecba2311abde51", size = 6978450, upload_time = "2025-07-01T09:14:56.436Z" }, - { url = "https://files.pythonhosted.org/packages/17/d2/622f4547f69cd173955194b78e4d19ca4935a1b0f03a302d655c9f6aae65/pillow-11.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580", size = 2423055, upload_time = "2025-07-01T09:14:58.072Z" }, - { url = "https://files.pythonhosted.org/packages/dd/80/a8a2ac21dda2e82480852978416cfacd439a4b490a501a288ecf4fe2532d/pillow-11.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e", size = 5281110, upload_time = "2025-07-01T09:14:59.79Z" }, - { url = "https://files.pythonhosted.org/packages/44/d6/b79754ca790f315918732e18f82a8146d33bcd7f4494380457ea89eb883d/pillow-11.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d", size = 4689547, upload_time = "2025-07-01T09:15:01.648Z" }, - { url = "https://files.pythonhosted.org/packages/49/20/716b8717d331150cb00f7fdd78169c01e8e0c219732a78b0e59b6bdb2fd6/pillow-11.3.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced", size = 5901554, upload_time = "2025-07-03T13:10:27.018Z" }, - { url = "https://files.pythonhosted.org/packages/74/cf/a9f3a2514a65bb071075063a96f0a5cf949c2f2fce683c15ccc83b1c1cab/pillow-11.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c", size = 7669132, upload_time = "2025-07-03T13:10:33.01Z" }, - { url = "https://files.pythonhosted.org/packages/98/3c/da78805cbdbee9cb43efe8261dd7cc0b4b93f2ac79b676c03159e9db2187/pillow-11.3.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8", size = 6005001, upload_time = "2025-07-01T09:15:03.365Z" }, - { url = "https://files.pythonhosted.org/packages/6c/fa/ce044b91faecf30e635321351bba32bab5a7e034c60187fe9698191aef4f/pillow-11.3.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59", size = 6668814, upload_time = "2025-07-01T09:15:05.655Z" }, - { url = "https://files.pythonhosted.org/packages/7b/51/90f9291406d09bf93686434f9183aba27b831c10c87746ff49f127ee80cb/pillow-11.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe", size = 6113124, upload_time = "2025-07-01T09:15:07.358Z" }, - { url = "https://files.pythonhosted.org/packages/cd/5a/6fec59b1dfb619234f7636d4157d11fb4e196caeee220232a8d2ec48488d/pillow-11.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83e1b0161c9d148125083a35c1c5a89db5b7054834fd4387499e06552035236c", size = 6747186, upload_time = "2025-07-01T09:15:09.317Z" }, - { url = "https://files.pythonhosted.org/packages/49/6b/00187a044f98255225f172de653941e61da37104a9ea60e4f6887717e2b5/pillow-11.3.0-cp313-cp313t-win32.whl", hash = "sha256:2a3117c06b8fb646639dce83694f2f9eac405472713fcb1ae887469c0d4f6788", size = 6277546, upload_time = "2025-07-01T09:15:11.311Z" }, - { url = "https://files.pythonhosted.org/packages/e8/5c/6caaba7e261c0d75bab23be79f1d06b5ad2a2ae49f028ccec801b0e853d6/pillow-11.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:857844335c95bea93fb39e0fa2726b4d9d758850b34075a7e3ff4f4fa3aa3b31", size = 6985102, upload_time = "2025-07-01T09:15:13.164Z" }, - { url = "https://files.pythonhosted.org/packages/f3/7e/b623008460c09a0cb38263c93b828c666493caee2eb34ff67f778b87e58c/pillow-11.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e", size = 2424803, upload_time = "2025-07-01T09:15:15.695Z" }, - { url = "https://files.pythonhosted.org/packages/73/f4/04905af42837292ed86cb1b1dabe03dce1edc008ef14c473c5c7e1443c5d/pillow-11.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d9da3df5f9ea2a89b81bb6087177fb1f4d1c7146d583a3fe5c672c0d94e55e12", size = 5278520, upload_time = "2025-07-01T09:15:17.429Z" }, - { url = "https://files.pythonhosted.org/packages/41/b0/33d79e377a336247df6348a54e6d2a2b85d644ca202555e3faa0cf811ecc/pillow-11.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0b275ff9b04df7b640c59ec5a3cb113eefd3795a8df80bac69646ef699c6981a", size = 4686116, upload_time = "2025-07-01T09:15:19.423Z" }, - { url = "https://files.pythonhosted.org/packages/49/2d/ed8bc0ab219ae8768f529597d9509d184fe8a6c4741a6864fea334d25f3f/pillow-11.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0743841cabd3dba6a83f38a92672cccbd69af56e3e91777b0ee7f4dba4385632", size = 5864597, upload_time = "2025-07-03T13:10:38.404Z" }, - { url = "https://files.pythonhosted.org/packages/b5/3d/b932bb4225c80b58dfadaca9d42d08d0b7064d2d1791b6a237f87f661834/pillow-11.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2465a69cf967b8b49ee1b96d76718cd98c4e925414ead59fdf75cf0fd07df673", size = 7638246, upload_time = "2025-07-03T13:10:44.987Z" }, - { url = "https://files.pythonhosted.org/packages/09/b5/0487044b7c096f1b48f0d7ad416472c02e0e4bf6919541b111efd3cae690/pillow-11.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41742638139424703b4d01665b807c6468e23e699e8e90cffefe291c5832b027", size = 5973336, upload_time = "2025-07-01T09:15:21.237Z" }, - { url = "https://files.pythonhosted.org/packages/a8/2d/524f9318f6cbfcc79fbc004801ea6b607ec3f843977652fdee4857a7568b/pillow-11.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93efb0b4de7e340d99057415c749175e24c8864302369e05914682ba642e5d77", size = 6642699, upload_time = "2025-07-01T09:15:23.186Z" }, - { url = "https://files.pythonhosted.org/packages/6f/d2/a9a4f280c6aefedce1e8f615baaa5474e0701d86dd6f1dede66726462bbd/pillow-11.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7966e38dcd0fa11ca390aed7c6f20454443581d758242023cf36fcb319b1a874", size = 6083789, upload_time = "2025-07-01T09:15:25.1Z" }, - { url = "https://files.pythonhosted.org/packages/fe/54/86b0cd9dbb683a9d5e960b66c7379e821a19be4ac5810e2e5a715c09a0c0/pillow-11.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:98a9afa7b9007c67ed84c57c9e0ad86a6000da96eaa638e4f8abe5b65ff83f0a", size = 6720386, upload_time = "2025-07-01T09:15:27.378Z" }, - { url = "https://files.pythonhosted.org/packages/e7/95/88efcaf384c3588e24259c4203b909cbe3e3c2d887af9e938c2022c9dd48/pillow-11.3.0-cp314-cp314-win32.whl", hash = "sha256:02a723e6bf909e7cea0dac1b0e0310be9d7650cd66222a5f1c571455c0a45214", size = 6370911, upload_time = "2025-07-01T09:15:29.294Z" }, - { url = "https://files.pythonhosted.org/packages/2e/cc/934e5820850ec5eb107e7b1a72dd278140731c669f396110ebc326f2a503/pillow-11.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:a418486160228f64dd9e9efcd132679b7a02a5f22c982c78b6fc7dab3fefb635", size = 7117383, upload_time = "2025-07-01T09:15:31.128Z" }, - { url = "https://files.pythonhosted.org/packages/d6/e9/9c0a616a71da2a5d163aa37405e8aced9a906d574b4a214bede134e731bc/pillow-11.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:155658efb5e044669c08896c0c44231c5e9abcaadbc5cd3648df2f7c0b96b9a6", size = 2511385, upload_time = "2025-07-01T09:15:33.328Z" }, - { url = "https://files.pythonhosted.org/packages/1a/33/c88376898aff369658b225262cd4f2659b13e8178e7534df9e6e1fa289f6/pillow-11.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:59a03cdf019efbfeeed910bf79c7c93255c3d54bc45898ac2a4140071b02b4ae", size = 5281129, upload_time = "2025-07-01T09:15:35.194Z" }, - { url = "https://files.pythonhosted.org/packages/1f/70/d376247fb36f1844b42910911c83a02d5544ebd2a8bad9efcc0f707ea774/pillow-11.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f8a5827f84d973d8636e9dc5764af4f0cf2318d26744b3d902931701b0d46653", size = 4689580, upload_time = "2025-07-01T09:15:37.114Z" }, - { url = "https://files.pythonhosted.org/packages/eb/1c/537e930496149fbac69efd2fc4329035bbe2e5475b4165439e3be9cb183b/pillow-11.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ee92f2fd10f4adc4b43d07ec5e779932b4eb3dbfbc34790ada5a6669bc095aa6", size = 5902860, upload_time = "2025-07-03T13:10:50.248Z" }, - { url = "https://files.pythonhosted.org/packages/bd/57/80f53264954dcefeebcf9dae6e3eb1daea1b488f0be8b8fef12f79a3eb10/pillow-11.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c96d333dcf42d01f47b37e0979b6bd73ec91eae18614864622d9b87bbd5bbf36", size = 7670694, upload_time = "2025-07-03T13:10:56.432Z" }, - { url = "https://files.pythonhosted.org/packages/70/ff/4727d3b71a8578b4587d9c276e90efad2d6fe0335fd76742a6da08132e8c/pillow-11.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c96f993ab8c98460cd0c001447bff6194403e8b1d7e149ade5f00594918128b", size = 6005888, upload_time = "2025-07-01T09:15:39.436Z" }, - { url = "https://files.pythonhosted.org/packages/05/ae/716592277934f85d3be51d7256f3636672d7b1abfafdc42cf3f8cbd4b4c8/pillow-11.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:41342b64afeba938edb034d122b2dda5db2139b9a4af999729ba8818e0056477", size = 6670330, upload_time = "2025-07-01T09:15:41.269Z" }, - { url = "https://files.pythonhosted.org/packages/e7/bb/7fe6cddcc8827b01b1a9766f5fdeb7418680744f9082035bdbabecf1d57f/pillow-11.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:068d9c39a2d1b358eb9f245ce7ab1b5c3246c7c8c7d9ba58cfa5b43146c06e50", size = 6114089, upload_time = "2025-07-01T09:15:43.13Z" }, - { url = "https://files.pythonhosted.org/packages/8b/f5/06bfaa444c8e80f1a8e4bff98da9c83b37b5be3b1deaa43d27a0db37ef84/pillow-11.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a1bc6ba083b145187f648b667e05a2534ecc4b9f2784c2cbe3089e44868f2b9b", size = 6748206, upload_time = "2025-07-01T09:15:44.937Z" }, - { url = "https://files.pythonhosted.org/packages/f0/77/bc6f92a3e8e6e46c0ca78abfffec0037845800ea38c73483760362804c41/pillow-11.3.0-cp314-cp314t-win32.whl", hash = "sha256:118ca10c0d60b06d006be10a501fd6bbdfef559251ed31b794668ed569c87e12", size = 6377370, upload_time = "2025-07-01T09:15:46.673Z" }, - { url = "https://files.pythonhosted.org/packages/4a/82/3a721f7d69dca802befb8af08b7c79ebcab461007ce1c18bd91a5d5896f9/pillow-11.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8924748b688aa210d79883357d102cd64690e56b923a186f35a82cbc10f997db", size = 7121500, upload_time = "2025-07-01T09:15:48.512Z" }, - { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835, upload_time = "2025-07-01T09:15:50.399Z" }, - { url = "https://files.pythonhosted.org/packages/6f/8b/209bd6b62ce8367f47e68a218bffac88888fdf2c9fcf1ecadc6c3ec1ebc7/pillow-11.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3cee80663f29e3843b68199b9d6f4f54bd1d4a6b59bdd91bceefc51238bcb967", size = 5270556, upload_time = "2025-07-01T09:16:09.961Z" }, - { url = "https://files.pythonhosted.org/packages/2e/e6/231a0b76070c2cfd9e260a7a5b504fb72da0a95279410fa7afd99d9751d6/pillow-11.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b5f56c3f344f2ccaf0dd875d3e180f631dc60a51b314295a3e681fe8cf851fbe", size = 4654625, upload_time = "2025-07-01T09:16:11.913Z" }, - { url = "https://files.pythonhosted.org/packages/13/f4/10cf94fda33cb12765f2397fc285fa6d8eb9c29de7f3185165b702fc7386/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e67d793d180c9df62f1f40aee3accca4829d3794c95098887edc18af4b8b780c", size = 4874207, upload_time = "2025-07-03T13:11:10.201Z" }, - { url = "https://files.pythonhosted.org/packages/72/c9/583821097dc691880c92892e8e2d41fe0a5a3d6021f4963371d2f6d57250/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d000f46e2917c705e9fb93a3606ee4a819d1e3aa7a9b442f6444f07e77cf5e25", size = 6583939, upload_time = "2025-07-03T13:11:15.68Z" }, - { url = "https://files.pythonhosted.org/packages/3b/8e/5c9d410f9217b12320efc7c413e72693f48468979a013ad17fd690397b9a/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:527b37216b6ac3a12d7838dc3bd75208ec57c1c6d11ef01902266a5a0c14fc27", size = 4957166, upload_time = "2025-07-01T09:16:13.74Z" }, - { url = "https://files.pythonhosted.org/packages/62/bb/78347dbe13219991877ffb3a91bf09da8317fbfcd4b5f9140aeae020ad71/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be5463ac478b623b9dd3937afd7fb7ab3d79dd290a28e2b6df292dc75063eb8a", size = 5581482, upload_time = "2025-07-01T09:16:16.107Z" }, - { url = "https://files.pythonhosted.org/packages/d9/28/1000353d5e61498aaeaaf7f1e4b49ddb05f2c6575f9d4f9f914a3538b6e1/pillow-11.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:8dc70ca24c110503e16918a658b869019126ecfe03109b754c402daff12b3d9f", size = 6984596, upload_time = "2025-07-01T09:16:18.07Z" }, - { url = "https://files.pythonhosted.org/packages/9e/e3/6fa84033758276fb31da12e5fb66ad747ae83b93c67af17f8c6ff4cc8f34/pillow-11.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7c8ec7a017ad1bd562f93dbd8505763e688d388cde6e4a010ae1486916e713e6", size = 5270566, upload_time = "2025-07-01T09:16:19.801Z" }, - { url = "https://files.pythonhosted.org/packages/5b/ee/e8d2e1ab4892970b561e1ba96cbd59c0d28cf66737fc44abb2aec3795a4e/pillow-11.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9ab6ae226de48019caa8074894544af5b53a117ccb9d3b3dcb2871464c829438", size = 4654618, upload_time = "2025-07-01T09:16:21.818Z" }, - { url = "https://files.pythonhosted.org/packages/f2/6d/17f80f4e1f0761f02160fc433abd4109fa1548dcfdca46cfdadaf9efa565/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe27fb049cdcca11f11a7bfda64043c37b30e6b91f10cb5bab275806c32f6ab3", size = 4874248, upload_time = "2025-07-03T13:11:20.738Z" }, - { url = "https://files.pythonhosted.org/packages/de/5f/c22340acd61cef960130585bbe2120e2fd8434c214802f07e8c03596b17e/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:465b9e8844e3c3519a983d58b80be3f668e2a7a5db97f2784e7079fbc9f9822c", size = 6583963, upload_time = "2025-07-03T13:11:26.283Z" }, - { url = "https://files.pythonhosted.org/packages/31/5e/03966aedfbfcbb4d5f8aa042452d3361f325b963ebbadddac05b122e47dd/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5418b53c0d59b3824d05e029669efa023bbef0f3e92e75ec8428f3799487f361", size = 4957170, upload_time = "2025-07-01T09:16:23.762Z" }, - { url = "https://files.pythonhosted.org/packages/cc/2d/e082982aacc927fc2cab48e1e731bdb1643a1406acace8bed0900a61464e/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:504b6f59505f08ae014f724b6207ff6222662aab5cc9542577fb084ed0676ac7", size = 5581505, upload_time = "2025-07-01T09:16:25.593Z" }, - { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598, upload_time = "2025-07-01T09:16:27.732Z" }, -] - -[[package]] -name = "propcache" -version = "0.3.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a6/16/43264e4a779dd8588c21a70f0709665ee8f611211bdd2c87d952cfa7c776/propcache-0.3.2.tar.gz", hash = "sha256:20d7d62e4e7ef05f221e0db2856b979540686342e7dd9973b815599c7057e168", size = 44139, upload_time = "2025-06-09T22:56:06.081Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ab/14/510deed325e262afeb8b360043c5d7c960da7d3ecd6d6f9496c9c56dc7f4/propcache-0.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:22d9962a358aedbb7a2e36187ff273adeaab9743373a272976d2e348d08c7770", size = 73178, upload_time = "2025-06-09T22:53:40.126Z" }, - { url = "https://files.pythonhosted.org/packages/cd/4e/ad52a7925ff01c1325653a730c7ec3175a23f948f08626a534133427dcff/propcache-0.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0d0fda578d1dc3f77b6b5a5dce3b9ad69a8250a891760a548df850a5e8da87f3", size = 43133, upload_time = "2025-06-09T22:53:41.965Z" }, - { url = "https://files.pythonhosted.org/packages/63/7c/e9399ba5da7780871db4eac178e9c2e204c23dd3e7d32df202092a1ed400/propcache-0.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3def3da3ac3ce41562d85db655d18ebac740cb3fa4367f11a52b3da9d03a5cc3", size = 43039, upload_time = "2025-06-09T22:53:43.268Z" }, - { url = "https://files.pythonhosted.org/packages/22/e1/58da211eb8fdc6fc854002387d38f415a6ca5f5c67c1315b204a5d3e9d7a/propcache-0.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9bec58347a5a6cebf239daba9bda37dffec5b8d2ce004d9fe4edef3d2815137e", size = 201903, upload_time = "2025-06-09T22:53:44.872Z" }, - { url = "https://files.pythonhosted.org/packages/c4/0a/550ea0f52aac455cb90111c8bab995208443e46d925e51e2f6ebdf869525/propcache-0.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55ffda449a507e9fbd4aca1a7d9aa6753b07d6166140e5a18d2ac9bc49eac220", size = 213362, upload_time = "2025-06-09T22:53:46.707Z" }, - { url = "https://files.pythonhosted.org/packages/5a/af/9893b7d878deda9bb69fcf54600b247fba7317761b7db11fede6e0f28bd0/propcache-0.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:64a67fb39229a8a8491dd42f864e5e263155e729c2e7ff723d6e25f596b1e8cb", size = 210525, upload_time = "2025-06-09T22:53:48.547Z" }, - { url = "https://files.pythonhosted.org/packages/7c/bb/38fd08b278ca85cde36d848091ad2b45954bc5f15cce494bb300b9285831/propcache-0.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9da1cf97b92b51253d5b68cf5a2b9e0dafca095e36b7f2da335e27dc6172a614", size = 198283, upload_time = "2025-06-09T22:53:50.067Z" }, - { url = "https://files.pythonhosted.org/packages/78/8c/9fe55bd01d362bafb413dfe508c48753111a1e269737fa143ba85693592c/propcache-0.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5f559e127134b07425134b4065be45b166183fdcb433cb6c24c8e4149056ad50", size = 191872, upload_time = "2025-06-09T22:53:51.438Z" }, - { url = "https://files.pythonhosted.org/packages/54/14/4701c33852937a22584e08abb531d654c8bcf7948a8f87ad0a4822394147/propcache-0.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:aff2e4e06435d61f11a428360a932138d0ec288b0a31dd9bd78d200bd4a2b339", size = 199452, upload_time = "2025-06-09T22:53:53.229Z" }, - { url = "https://files.pythonhosted.org/packages/16/44/447f2253d859602095356007657ee535e0093215ea0b3d1d6a41d16e5201/propcache-0.3.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:4927842833830942a5d0a56e6f4839bc484785b8e1ce8d287359794818633ba0", size = 191567, upload_time = "2025-06-09T22:53:54.541Z" }, - { url = "https://files.pythonhosted.org/packages/f2/b3/e4756258749bb2d3b46defcff606a2f47410bab82be5824a67e84015b267/propcache-0.3.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:6107ddd08b02654a30fb8ad7a132021759d750a82578b94cd55ee2772b6ebea2", size = 193015, upload_time = "2025-06-09T22:53:56.44Z" }, - { url = "https://files.pythonhosted.org/packages/1e/df/e6d3c7574233164b6330b9fd697beeac402afd367280e6dc377bb99b43d9/propcache-0.3.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:70bd8b9cd6b519e12859c99f3fc9a93f375ebd22a50296c3a295028bea73b9e7", size = 204660, upload_time = "2025-06-09T22:53:57.839Z" }, - { url = "https://files.pythonhosted.org/packages/b2/53/e4d31dd5170b4a0e2e6b730f2385a96410633b4833dc25fe5dffd1f73294/propcache-0.3.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2183111651d710d3097338dd1893fcf09c9f54e27ff1a8795495a16a469cc90b", size = 206105, upload_time = "2025-06-09T22:53:59.638Z" }, - { url = "https://files.pythonhosted.org/packages/7f/fe/74d54cf9fbe2a20ff786e5f7afcfde446588f0cf15fb2daacfbc267b866c/propcache-0.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:fb075ad271405dcad8e2a7ffc9a750a3bf70e533bd86e89f0603e607b93aa64c", size = 196980, upload_time = "2025-06-09T22:54:01.071Z" }, - { url = "https://files.pythonhosted.org/packages/22/ec/c469c9d59dada8a7679625e0440b544fe72e99311a4679c279562051f6fc/propcache-0.3.2-cp310-cp310-win32.whl", hash = "sha256:404d70768080d3d3bdb41d0771037da19d8340d50b08e104ca0e7f9ce55fce70", size = 37679, upload_time = "2025-06-09T22:54:03.003Z" }, - { url = "https://files.pythonhosted.org/packages/38/35/07a471371ac89d418f8d0b699c75ea6dca2041fbda360823de21f6a9ce0a/propcache-0.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:7435d766f978b4ede777002e6b3b6641dd229cd1da8d3d3106a45770365f9ad9", size = 41459, upload_time = "2025-06-09T22:54:04.134Z" }, - { url = "https://files.pythonhosted.org/packages/80/8d/e8b436717ab9c2cfc23b116d2c297305aa4cd8339172a456d61ebf5669b8/propcache-0.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0b8d2f607bd8f80ddc04088bc2a037fdd17884a6fcadc47a96e334d72f3717be", size = 74207, upload_time = "2025-06-09T22:54:05.399Z" }, - { url = "https://files.pythonhosted.org/packages/d6/29/1e34000e9766d112171764b9fa3226fa0153ab565d0c242c70e9945318a7/propcache-0.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:06766d8f34733416e2e34f46fea488ad5d60726bb9481d3cddf89a6fa2d9603f", size = 43648, upload_time = "2025-06-09T22:54:08.023Z" }, - { url = "https://files.pythonhosted.org/packages/46/92/1ad5af0df781e76988897da39b5f086c2bf0f028b7f9bd1f409bb05b6874/propcache-0.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2dc1f4a1df4fecf4e6f68013575ff4af84ef6f478fe5344317a65d38a8e6dc9", size = 43496, upload_time = "2025-06-09T22:54:09.228Z" }, - { url = "https://files.pythonhosted.org/packages/b3/ce/e96392460f9fb68461fabab3e095cb00c8ddf901205be4eae5ce246e5b7e/propcache-0.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be29c4f4810c5789cf10ddf6af80b041c724e629fa51e308a7a0fb19ed1ef7bf", size = 217288, upload_time = "2025-06-09T22:54:10.466Z" }, - { url = "https://files.pythonhosted.org/packages/c5/2a/866726ea345299f7ceefc861a5e782b045545ae6940851930a6adaf1fca6/propcache-0.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59d61f6970ecbd8ff2e9360304d5c8876a6abd4530cb752c06586849ac8a9dc9", size = 227456, upload_time = "2025-06-09T22:54:11.828Z" }, - { url = "https://files.pythonhosted.org/packages/de/03/07d992ccb6d930398689187e1b3c718339a1c06b8b145a8d9650e4726166/propcache-0.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:62180e0b8dbb6b004baec00a7983e4cc52f5ada9cd11f48c3528d8cfa7b96a66", size = 225429, upload_time = "2025-06-09T22:54:13.823Z" }, - { url = "https://files.pythonhosted.org/packages/5d/e6/116ba39448753b1330f48ab8ba927dcd6cf0baea8a0ccbc512dfb49ba670/propcache-0.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c144ca294a204c470f18cf4c9d78887810d04a3e2fbb30eea903575a779159df", size = 213472, upload_time = "2025-06-09T22:54:15.232Z" }, - { url = "https://files.pythonhosted.org/packages/a6/85/f01f5d97e54e428885a5497ccf7f54404cbb4f906688a1690cd51bf597dc/propcache-0.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5c2a784234c28854878d68978265617aa6dc0780e53d44b4d67f3651a17a9a2", size = 204480, upload_time = "2025-06-09T22:54:17.104Z" }, - { url = "https://files.pythonhosted.org/packages/e3/79/7bf5ab9033b8b8194cc3f7cf1aaa0e9c3256320726f64a3e1f113a812dce/propcache-0.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5745bc7acdafa978ca1642891b82c19238eadc78ba2aaa293c6863b304e552d7", size = 214530, upload_time = "2025-06-09T22:54:18.512Z" }, - { url = "https://files.pythonhosted.org/packages/31/0b/bd3e0c00509b609317df4a18e6b05a450ef2d9a963e1d8bc9c9415d86f30/propcache-0.3.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:c0075bf773d66fa8c9d41f66cc132ecc75e5bb9dd7cce3cfd14adc5ca184cb95", size = 205230, upload_time = "2025-06-09T22:54:19.947Z" }, - { url = "https://files.pythonhosted.org/packages/7a/23/fae0ff9b54b0de4e819bbe559508da132d5683c32d84d0dc2ccce3563ed4/propcache-0.3.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5f57aa0847730daceff0497f417c9de353c575d8da3579162cc74ac294c5369e", size = 206754, upload_time = "2025-06-09T22:54:21.716Z" }, - { url = "https://files.pythonhosted.org/packages/b7/7f/ad6a3c22630aaa5f618b4dc3c3598974a72abb4c18e45a50b3cdd091eb2f/propcache-0.3.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:eef914c014bf72d18efb55619447e0aecd5fb7c2e3fa7441e2e5d6099bddff7e", size = 218430, upload_time = "2025-06-09T22:54:23.17Z" }, - { url = "https://files.pythonhosted.org/packages/5b/2c/ba4f1c0e8a4b4c75910742f0d333759d441f65a1c7f34683b4a74c0ee015/propcache-0.3.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2a4092e8549031e82facf3decdbc0883755d5bbcc62d3aea9d9e185549936dcf", size = 223884, upload_time = "2025-06-09T22:54:25.539Z" }, - { url = "https://files.pythonhosted.org/packages/88/e4/ebe30fc399e98572019eee82ad0caf512401661985cbd3da5e3140ffa1b0/propcache-0.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:85871b050f174bc0bfb437efbdb68aaf860611953ed12418e4361bc9c392749e", size = 211480, upload_time = "2025-06-09T22:54:26.892Z" }, - { url = "https://files.pythonhosted.org/packages/96/0a/7d5260b914e01d1d0906f7f38af101f8d8ed0dc47426219eeaf05e8ea7c2/propcache-0.3.2-cp311-cp311-win32.whl", hash = "sha256:36c8d9b673ec57900c3554264e630d45980fd302458e4ac801802a7fd2ef7897", size = 37757, upload_time = "2025-06-09T22:54:28.241Z" }, - { url = "https://files.pythonhosted.org/packages/e1/2d/89fe4489a884bc0da0c3278c552bd4ffe06a1ace559db5ef02ef24ab446b/propcache-0.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53af8cb6a781b02d2ea079b5b853ba9430fcbe18a8e3ce647d5982a3ff69f39", size = 41500, upload_time = "2025-06-09T22:54:29.4Z" }, - { url = "https://files.pythonhosted.org/packages/a8/42/9ca01b0a6f48e81615dca4765a8f1dd2c057e0540f6116a27dc5ee01dfb6/propcache-0.3.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8de106b6c84506b31c27168582cd3cb3000a6412c16df14a8628e5871ff83c10", size = 73674, upload_time = "2025-06-09T22:54:30.551Z" }, - { url = "https://files.pythonhosted.org/packages/af/6e/21293133beb550f9c901bbece755d582bfaf2176bee4774000bd4dd41884/propcache-0.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:28710b0d3975117239c76600ea351934ac7b5ff56e60953474342608dbbb6154", size = 43570, upload_time = "2025-06-09T22:54:32.296Z" }, - { url = "https://files.pythonhosted.org/packages/0c/c8/0393a0a3a2b8760eb3bde3c147f62b20044f0ddac81e9d6ed7318ec0d852/propcache-0.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce26862344bdf836650ed2487c3d724b00fbfec4233a1013f597b78c1cb73615", size = 43094, upload_time = "2025-06-09T22:54:33.929Z" }, - { url = "https://files.pythonhosted.org/packages/37/2c/489afe311a690399d04a3e03b069225670c1d489eb7b044a566511c1c498/propcache-0.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bca54bd347a253af2cf4544bbec232ab982f4868de0dd684246b67a51bc6b1db", size = 226958, upload_time = "2025-06-09T22:54:35.186Z" }, - { url = "https://files.pythonhosted.org/packages/9d/ca/63b520d2f3d418c968bf596839ae26cf7f87bead026b6192d4da6a08c467/propcache-0.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55780d5e9a2ddc59711d727226bb1ba83a22dd32f64ee15594b9392b1f544eb1", size = 234894, upload_time = "2025-06-09T22:54:36.708Z" }, - { url = "https://files.pythonhosted.org/packages/11/60/1d0ed6fff455a028d678df30cc28dcee7af77fa2b0e6962ce1df95c9a2a9/propcache-0.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:035e631be25d6975ed87ab23153db6a73426a48db688070d925aa27e996fe93c", size = 233672, upload_time = "2025-06-09T22:54:38.062Z" }, - { url = "https://files.pythonhosted.org/packages/37/7c/54fd5301ef38505ab235d98827207176a5c9b2aa61939b10a460ca53e123/propcache-0.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ee6f22b6eaa39297c751d0e80c0d3a454f112f5c6481214fcf4c092074cecd67", size = 224395, upload_time = "2025-06-09T22:54:39.634Z" }, - { url = "https://files.pythonhosted.org/packages/ee/1a/89a40e0846f5de05fdc6779883bf46ba980e6df4d2ff8fb02643de126592/propcache-0.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ca3aee1aa955438c4dba34fc20a9f390e4c79967257d830f137bd5a8a32ed3b", size = 212510, upload_time = "2025-06-09T22:54:41.565Z" }, - { url = "https://files.pythonhosted.org/packages/5e/33/ca98368586c9566a6b8d5ef66e30484f8da84c0aac3f2d9aec6d31a11bd5/propcache-0.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4f30862869fa2b68380d677cc1c5fcf1e0f2b9ea0cf665812895c75d0ca3b8", size = 222949, upload_time = "2025-06-09T22:54:43.038Z" }, - { url = "https://files.pythonhosted.org/packages/ba/11/ace870d0aafe443b33b2f0b7efdb872b7c3abd505bfb4890716ad7865e9d/propcache-0.3.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b77ec3c257d7816d9f3700013639db7491a434644c906a2578a11daf13176251", size = 217258, upload_time = "2025-06-09T22:54:44.376Z" }, - { url = "https://files.pythonhosted.org/packages/5b/d2/86fd6f7adffcfc74b42c10a6b7db721d1d9ca1055c45d39a1a8f2a740a21/propcache-0.3.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cab90ac9d3f14b2d5050928483d3d3b8fb6b4018893fc75710e6aa361ecb2474", size = 213036, upload_time = "2025-06-09T22:54:46.243Z" }, - { url = "https://files.pythonhosted.org/packages/07/94/2d7d1e328f45ff34a0a284cf5a2847013701e24c2a53117e7c280a4316b3/propcache-0.3.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:0b504d29f3c47cf6b9e936c1852246c83d450e8e063d50562115a6be6d3a2535", size = 227684, upload_time = "2025-06-09T22:54:47.63Z" }, - { url = "https://files.pythonhosted.org/packages/b7/05/37ae63a0087677e90b1d14710e532ff104d44bc1efa3b3970fff99b891dc/propcache-0.3.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:ce2ac2675a6aa41ddb2a0c9cbff53780a617ac3d43e620f8fd77ba1c84dcfc06", size = 234562, upload_time = "2025-06-09T22:54:48.982Z" }, - { url = "https://files.pythonhosted.org/packages/a4/7c/3f539fcae630408d0bd8bf3208b9a647ccad10976eda62402a80adf8fc34/propcache-0.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:62b4239611205294cc433845b914131b2a1f03500ff3c1ed093ed216b82621e1", size = 222142, upload_time = "2025-06-09T22:54:50.424Z" }, - { url = "https://files.pythonhosted.org/packages/7c/d2/34b9eac8c35f79f8a962546b3e97e9d4b990c420ee66ac8255d5d9611648/propcache-0.3.2-cp312-cp312-win32.whl", hash = "sha256:df4a81b9b53449ebc90cc4deefb052c1dd934ba85012aa912c7ea7b7e38b60c1", size = 37711, upload_time = "2025-06-09T22:54:52.072Z" }, - { url = "https://files.pythonhosted.org/packages/19/61/d582be5d226cf79071681d1b46b848d6cb03d7b70af7063e33a2787eaa03/propcache-0.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:7046e79b989d7fe457bb755844019e10f693752d169076138abf17f31380800c", size = 41479, upload_time = "2025-06-09T22:54:53.234Z" }, - { url = "https://files.pythonhosted.org/packages/dc/d1/8c747fafa558c603c4ca19d8e20b288aa0c7cda74e9402f50f31eb65267e/propcache-0.3.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ca592ed634a73ca002967458187109265e980422116c0a107cf93d81f95af945", size = 71286, upload_time = "2025-06-09T22:54:54.369Z" }, - { url = "https://files.pythonhosted.org/packages/61/99/d606cb7986b60d89c36de8a85d58764323b3a5ff07770a99d8e993b3fa73/propcache-0.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9ecb0aad4020e275652ba3975740f241bd12a61f1a784df044cf7477a02bc252", size = 42425, upload_time = "2025-06-09T22:54:55.642Z" }, - { url = "https://files.pythonhosted.org/packages/8c/96/ef98f91bbb42b79e9bb82bdd348b255eb9d65f14dbbe3b1594644c4073f7/propcache-0.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7f08f1cc28bd2eade7a8a3d2954ccc673bb02062e3e7da09bc75d843386b342f", size = 41846, upload_time = "2025-06-09T22:54:57.246Z" }, - { url = "https://files.pythonhosted.org/packages/5b/ad/3f0f9a705fb630d175146cd7b1d2bf5555c9beaed54e94132b21aac098a6/propcache-0.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1a342c834734edb4be5ecb1e9fb48cb64b1e2320fccbd8c54bf8da8f2a84c33", size = 208871, upload_time = "2025-06-09T22:54:58.975Z" }, - { url = "https://files.pythonhosted.org/packages/3a/38/2085cda93d2c8b6ec3e92af2c89489a36a5886b712a34ab25de9fbca7992/propcache-0.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8a544caaae1ac73f1fecfae70ded3e93728831affebd017d53449e3ac052ac1e", size = 215720, upload_time = "2025-06-09T22:55:00.471Z" }, - { url = "https://files.pythonhosted.org/packages/61/c1/d72ea2dc83ac7f2c8e182786ab0fc2c7bd123a1ff9b7975bee671866fe5f/propcache-0.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:310d11aa44635298397db47a3ebce7db99a4cc4b9bbdfcf6c98a60c8d5261cf1", size = 215203, upload_time = "2025-06-09T22:55:01.834Z" }, - { url = "https://files.pythonhosted.org/packages/af/81/b324c44ae60c56ef12007105f1460d5c304b0626ab0cc6b07c8f2a9aa0b8/propcache-0.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c1396592321ac83157ac03a2023aa6cc4a3cc3cfdecb71090054c09e5a7cce3", size = 206365, upload_time = "2025-06-09T22:55:03.199Z" }, - { url = "https://files.pythonhosted.org/packages/09/73/88549128bb89e66d2aff242488f62869014ae092db63ccea53c1cc75a81d/propcache-0.3.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cabf5b5902272565e78197edb682017d21cf3b550ba0460ee473753f28d23c1", size = 196016, upload_time = "2025-06-09T22:55:04.518Z" }, - { url = "https://files.pythonhosted.org/packages/b9/3f/3bdd14e737d145114a5eb83cb172903afba7242f67c5877f9909a20d948d/propcache-0.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0a2f2235ac46a7aa25bdeb03a9e7060f6ecbd213b1f9101c43b3090ffb971ef6", size = 205596, upload_time = "2025-06-09T22:55:05.942Z" }, - { url = "https://files.pythonhosted.org/packages/0f/ca/2f4aa819c357d3107c3763d7ef42c03980f9ed5c48c82e01e25945d437c1/propcache-0.3.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:92b69e12e34869a6970fd2f3da91669899994b47c98f5d430b781c26f1d9f387", size = 200977, upload_time = "2025-06-09T22:55:07.792Z" }, - { url = "https://files.pythonhosted.org/packages/cd/4a/e65276c7477533c59085251ae88505caf6831c0e85ff8b2e31ebcbb949b1/propcache-0.3.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:54e02207c79968ebbdffc169591009f4474dde3b4679e16634d34c9363ff56b4", size = 197220, upload_time = "2025-06-09T22:55:09.173Z" }, - { url = "https://files.pythonhosted.org/packages/7c/54/fc7152e517cf5578278b242396ce4d4b36795423988ef39bb8cd5bf274c8/propcache-0.3.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4adfb44cb588001f68c5466579d3f1157ca07f7504fc91ec87862e2b8e556b88", size = 210642, upload_time = "2025-06-09T22:55:10.62Z" }, - { url = "https://files.pythonhosted.org/packages/b9/80/abeb4a896d2767bf5f1ea7b92eb7be6a5330645bd7fb844049c0e4045d9d/propcache-0.3.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fd3e6019dc1261cd0291ee8919dd91fbab7b169bb76aeef6c716833a3f65d206", size = 212789, upload_time = "2025-06-09T22:55:12.029Z" }, - { url = "https://files.pythonhosted.org/packages/b3/db/ea12a49aa7b2b6d68a5da8293dcf50068d48d088100ac016ad92a6a780e6/propcache-0.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4c181cad81158d71c41a2bce88edce078458e2dd5ffee7eddd6b05da85079f43", size = 205880, upload_time = "2025-06-09T22:55:13.45Z" }, - { url = "https://files.pythonhosted.org/packages/d1/e5/9076a0bbbfb65d1198007059c65639dfd56266cf8e477a9707e4b1999ff4/propcache-0.3.2-cp313-cp313-win32.whl", hash = "sha256:8a08154613f2249519e549de2330cf8e2071c2887309a7b07fb56098f5170a02", size = 37220, upload_time = "2025-06-09T22:55:15.284Z" }, - { url = "https://files.pythonhosted.org/packages/d3/f5/b369e026b09a26cd77aa88d8fffd69141d2ae00a2abaaf5380d2603f4b7f/propcache-0.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e41671f1594fc4ab0a6dec1351864713cb3a279910ae8b58f884a88a0a632c05", size = 40678, upload_time = "2025-06-09T22:55:16.445Z" }, - { url = "https://files.pythonhosted.org/packages/a4/3a/6ece377b55544941a08d03581c7bc400a3c8cd3c2865900a68d5de79e21f/propcache-0.3.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:9a3cf035bbaf035f109987d9d55dc90e4b0e36e04bbbb95af3055ef17194057b", size = 76560, upload_time = "2025-06-09T22:55:17.598Z" }, - { url = "https://files.pythonhosted.org/packages/0c/da/64a2bb16418740fa634b0e9c3d29edff1db07f56d3546ca2d86ddf0305e1/propcache-0.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:156c03d07dc1323d8dacaa221fbe028c5c70d16709cdd63502778e6c3ccca1b0", size = 44676, upload_time = "2025-06-09T22:55:18.922Z" }, - { url = "https://files.pythonhosted.org/packages/36/7b/f025e06ea51cb72c52fb87e9b395cced02786610b60a3ed51da8af017170/propcache-0.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74413c0ba02ba86f55cf60d18daab219f7e531620c15f1e23d95563f505efe7e", size = 44701, upload_time = "2025-06-09T22:55:20.106Z" }, - { url = "https://files.pythonhosted.org/packages/a4/00/faa1b1b7c3b74fc277f8642f32a4c72ba1d7b2de36d7cdfb676db7f4303e/propcache-0.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f066b437bb3fa39c58ff97ab2ca351db465157d68ed0440abecb21715eb24b28", size = 276934, upload_time = "2025-06-09T22:55:21.5Z" }, - { url = "https://files.pythonhosted.org/packages/74/ab/935beb6f1756e0476a4d5938ff44bf0d13a055fed880caf93859b4f1baf4/propcache-0.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f1304b085c83067914721e7e9d9917d41ad87696bf70f0bc7dee450e9c71ad0a", size = 278316, upload_time = "2025-06-09T22:55:22.918Z" }, - { url = "https://files.pythonhosted.org/packages/f8/9d/994a5c1ce4389610838d1caec74bdf0e98b306c70314d46dbe4fcf21a3e2/propcache-0.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ab50cef01b372763a13333b4e54021bdcb291fc9a8e2ccb9c2df98be51bcde6c", size = 282619, upload_time = "2025-06-09T22:55:24.651Z" }, - { url = "https://files.pythonhosted.org/packages/2b/00/a10afce3d1ed0287cef2e09506d3be9822513f2c1e96457ee369adb9a6cd/propcache-0.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fad3b2a085ec259ad2c2842666b2a0a49dea8463579c606426128925af1ed725", size = 265896, upload_time = "2025-06-09T22:55:26.049Z" }, - { url = "https://files.pythonhosted.org/packages/2e/a8/2aa6716ffa566ca57c749edb909ad27884680887d68517e4be41b02299f3/propcache-0.3.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:261fa020c1c14deafd54c76b014956e2f86991af198c51139faf41c4d5e83892", size = 252111, upload_time = "2025-06-09T22:55:27.381Z" }, - { url = "https://files.pythonhosted.org/packages/36/4f/345ca9183b85ac29c8694b0941f7484bf419c7f0fea2d1e386b4f7893eed/propcache-0.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:46d7f8aa79c927e5f987ee3a80205c987717d3659f035c85cf0c3680526bdb44", size = 268334, upload_time = "2025-06-09T22:55:28.747Z" }, - { url = "https://files.pythonhosted.org/packages/3e/ca/fcd54f78b59e3f97b3b9715501e3147f5340167733d27db423aa321e7148/propcache-0.3.2-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:6d8f3f0eebf73e3c0ff0e7853f68be638b4043c65a70517bb575eff54edd8dbe", size = 255026, upload_time = "2025-06-09T22:55:30.184Z" }, - { url = "https://files.pythonhosted.org/packages/8b/95/8e6a6bbbd78ac89c30c225210a5c687790e532ba4088afb8c0445b77ef37/propcache-0.3.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:03c89c1b14a5452cf15403e291c0ccd7751d5b9736ecb2c5bab977ad6c5bcd81", size = 250724, upload_time = "2025-06-09T22:55:31.646Z" }, - { url = "https://files.pythonhosted.org/packages/ee/b0/0dd03616142baba28e8b2d14ce5df6631b4673850a3d4f9c0f9dd714a404/propcache-0.3.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:0cc17efde71e12bbaad086d679ce575268d70bc123a5a71ea7ad76f70ba30bba", size = 268868, upload_time = "2025-06-09T22:55:33.209Z" }, - { url = "https://files.pythonhosted.org/packages/c5/98/2c12407a7e4fbacd94ddd32f3b1e3d5231e77c30ef7162b12a60e2dd5ce3/propcache-0.3.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:acdf05d00696bc0447e278bb53cb04ca72354e562cf88ea6f9107df8e7fd9770", size = 271322, upload_time = "2025-06-09T22:55:35.065Z" }, - { url = "https://files.pythonhosted.org/packages/35/91/9cb56efbb428b006bb85db28591e40b7736847b8331d43fe335acf95f6c8/propcache-0.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4445542398bd0b5d32df908031cb1b30d43ac848e20470a878b770ec2dcc6330", size = 265778, upload_time = "2025-06-09T22:55:36.45Z" }, - { url = "https://files.pythonhosted.org/packages/9a/4c/b0fe775a2bdd01e176b14b574be679d84fc83958335790f7c9a686c1f468/propcache-0.3.2-cp313-cp313t-win32.whl", hash = "sha256:f86e5d7cd03afb3a1db8e9f9f6eff15794e79e791350ac48a8c924e6f439f394", size = 41175, upload_time = "2025-06-09T22:55:38.436Z" }, - { url = "https://files.pythonhosted.org/packages/a4/ff/47f08595e3d9b5e149c150f88d9714574f1a7cbd89fe2817158a952674bf/propcache-0.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:9704bedf6e7cbe3c65eca4379a9b53ee6a83749f047808cbb5044d40d7d72198", size = 44857, upload_time = "2025-06-09T22:55:39.687Z" }, - { url = "https://files.pythonhosted.org/packages/cc/35/cc0aaecf278bb4575b8555f2b137de5ab821595ddae9da9d3cd1da4072c7/propcache-0.3.2-py3-none-any.whl", hash = "sha256:98f1ec44fb675f5052cccc8e609c46ed23a35a1cfd18545ad4e29002d858a43f", size = 12663, upload_time = "2025-06-09T22:56:04.484Z" }, -] - -[[package]] -name = "psutil" -version = "7.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003, upload_time = "2025-02-13T21:54:07.946Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051, upload_time = "2025-02-13T21:54:12.36Z" }, - { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535, upload_time = "2025-02-13T21:54:16.07Z" }, - { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004, upload_time = "2025-02-13T21:54:18.662Z" }, - { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986, upload_time = "2025-02-13T21:54:21.811Z" }, - { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544, upload_time = "2025-02-13T21:54:24.68Z" }, - { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053, upload_time = "2025-02-13T21:54:34.31Z" }, - { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885, upload_time = "2025-02-13T21:54:37.486Z" }, -] - -[[package]] -name = "pyarrow" -version = "20.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/ee/a7810cb9f3d6e9238e61d312076a9859bf3668fd21c69744de9532383912/pyarrow-20.0.0.tar.gz", hash = "sha256:febc4a913592573c8d5805091a6c2b5064c8bd6e002131f01061797d91c783c1", size = 1125187, upload_time = "2025-04-27T12:34:23.264Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5b/23/77094eb8ee0dbe88441689cb6afc40ac312a1e15d3a7acc0586999518222/pyarrow-20.0.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:c7dd06fd7d7b410ca5dc839cc9d485d2bc4ae5240851bcd45d85105cc90a47d7", size = 30832591, upload_time = "2025-04-27T12:27:27.89Z" }, - { url = "https://files.pythonhosted.org/packages/c3/d5/48cc573aff00d62913701d9fac478518f693b30c25f2c157550b0b2565cb/pyarrow-20.0.0-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:d5382de8dc34c943249b01c19110783d0d64b207167c728461add1ecc2db88e4", size = 32273686, upload_time = "2025-04-27T12:27:36.816Z" }, - { url = "https://files.pythonhosted.org/packages/37/df/4099b69a432b5cb412dd18adc2629975544d656df3d7fda6d73c5dba935d/pyarrow-20.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6415a0d0174487456ddc9beaead703d0ded5966129fa4fd3114d76b5d1c5ceae", size = 41337051, upload_time = "2025-04-27T12:27:44.4Z" }, - { url = "https://files.pythonhosted.org/packages/4c/27/99922a9ac1c9226f346e3a1e15e63dee6f623ed757ff2893f9d6994a69d3/pyarrow-20.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15aa1b3b2587e74328a730457068dc6c89e6dcbf438d4369f572af9d320a25ee", size = 42404659, upload_time = "2025-04-27T12:27:51.715Z" }, - { url = "https://files.pythonhosted.org/packages/21/d1/71d91b2791b829c9e98f1e0d85be66ed93aff399f80abb99678511847eaa/pyarrow-20.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:5605919fbe67a7948c1f03b9f3727d82846c053cd2ce9303ace791855923fd20", size = 40695446, upload_time = "2025-04-27T12:27:59.643Z" }, - { url = "https://files.pythonhosted.org/packages/f1/ca/ae10fba419a6e94329707487835ec721f5a95f3ac9168500bcf7aa3813c7/pyarrow-20.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a5704f29a74b81673d266e5ec1fe376f060627c2e42c5c7651288ed4b0db29e9", size = 42278528, upload_time = "2025-04-27T12:28:07.297Z" }, - { url = "https://files.pythonhosted.org/packages/7a/a6/aba40a2bf01b5d00cf9cd16d427a5da1fad0fb69b514ce8c8292ab80e968/pyarrow-20.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:00138f79ee1b5aca81e2bdedb91e3739b987245e11fa3c826f9e57c5d102fb75", size = 42918162, upload_time = "2025-04-27T12:28:15.716Z" }, - { url = "https://files.pythonhosted.org/packages/93/6b/98b39650cd64f32bf2ec6d627a9bd24fcb3e4e6ea1873c5e1ea8a83b1a18/pyarrow-20.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f2d67ac28f57a362f1a2c1e6fa98bfe2f03230f7e15927aecd067433b1e70ce8", size = 44550319, upload_time = "2025-04-27T12:28:27.026Z" }, - { url = "https://files.pythonhosted.org/packages/ab/32/340238be1eb5037e7b5de7e640ee22334417239bc347eadefaf8c373936d/pyarrow-20.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:4a8b029a07956b8d7bd742ffca25374dd3f634b35e46cc7a7c3fa4c75b297191", size = 25770759, upload_time = "2025-04-27T12:28:33.702Z" }, - { url = "https://files.pythonhosted.org/packages/47/a2/b7930824181ceadd0c63c1042d01fa4ef63eee233934826a7a2a9af6e463/pyarrow-20.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:24ca380585444cb2a31324c546a9a56abbe87e26069189e14bdba19c86c049f0", size = 30856035, upload_time = "2025-04-27T12:28:40.78Z" }, - { url = "https://files.pythonhosted.org/packages/9b/18/c765770227d7f5bdfa8a69f64b49194352325c66a5c3bb5e332dfd5867d9/pyarrow-20.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:95b330059ddfdc591a3225f2d272123be26c8fa76e8c9ee1a77aad507361cfdb", size = 32309552, upload_time = "2025-04-27T12:28:47.051Z" }, - { url = "https://files.pythonhosted.org/packages/44/fb/dfb2dfdd3e488bb14f822d7335653092dde150cffc2da97de6e7500681f9/pyarrow-20.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f0fb1041267e9968c6d0d2ce3ff92e3928b243e2b6d11eeb84d9ac547308232", size = 41334704, upload_time = "2025-04-27T12:28:55.064Z" }, - { url = "https://files.pythonhosted.org/packages/58/0d/08a95878d38808051a953e887332d4a76bc06c6ee04351918ee1155407eb/pyarrow-20.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8ff87cc837601532cc8242d2f7e09b4e02404de1b797aee747dd4ba4bd6313f", size = 42399836, upload_time = "2025-04-27T12:29:02.13Z" }, - { url = "https://files.pythonhosted.org/packages/f3/cd/efa271234dfe38f0271561086eedcad7bc0f2ddd1efba423916ff0883684/pyarrow-20.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:7a3a5dcf54286e6141d5114522cf31dd67a9e7c9133d150799f30ee302a7a1ab", size = 40711789, upload_time = "2025-04-27T12:29:09.951Z" }, - { url = "https://files.pythonhosted.org/packages/46/1f/7f02009bc7fc8955c391defee5348f510e589a020e4b40ca05edcb847854/pyarrow-20.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a6ad3e7758ecf559900261a4df985662df54fb7fdb55e8e3b3aa99b23d526b62", size = 42301124, upload_time = "2025-04-27T12:29:17.187Z" }, - { url = "https://files.pythonhosted.org/packages/4f/92/692c562be4504c262089e86757a9048739fe1acb4024f92d39615e7bab3f/pyarrow-20.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6bb830757103a6cb300a04610e08d9636f0cd223d32f388418ea893a3e655f1c", size = 42916060, upload_time = "2025-04-27T12:29:24.253Z" }, - { url = "https://files.pythonhosted.org/packages/a4/ec/9f5c7e7c828d8e0a3c7ef50ee62eca38a7de2fa6eb1b8fa43685c9414fef/pyarrow-20.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:96e37f0766ecb4514a899d9a3554fadda770fb57ddf42b63d80f14bc20aa7db3", size = 44547640, upload_time = "2025-04-27T12:29:32.782Z" }, - { url = "https://files.pythonhosted.org/packages/54/96/46613131b4727f10fd2ffa6d0d6f02efcc09a0e7374eff3b5771548aa95b/pyarrow-20.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:3346babb516f4b6fd790da99b98bed9708e3f02e734c84971faccb20736848dc", size = 25781491, upload_time = "2025-04-27T12:29:38.464Z" }, - { url = "https://files.pythonhosted.org/packages/a1/d6/0c10e0d54f6c13eb464ee9b67a68b8c71bcf2f67760ef5b6fbcddd2ab05f/pyarrow-20.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:75a51a5b0eef32727a247707d4755322cb970be7e935172b6a3a9f9ae98404ba", size = 30815067, upload_time = "2025-04-27T12:29:44.384Z" }, - { url = "https://files.pythonhosted.org/packages/7e/e2/04e9874abe4094a06fd8b0cbb0f1312d8dd7d707f144c2ec1e5e8f452ffa/pyarrow-20.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:211d5e84cecc640c7a3ab900f930aaff5cd2702177e0d562d426fb7c4f737781", size = 32297128, upload_time = "2025-04-27T12:29:52.038Z" }, - { url = "https://files.pythonhosted.org/packages/31/fd/c565e5dcc906a3b471a83273039cb75cb79aad4a2d4a12f76cc5ae90a4b8/pyarrow-20.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ba3cf4182828be7a896cbd232aa8dd6a31bd1f9e32776cc3796c012855e1199", size = 41334890, upload_time = "2025-04-27T12:29:59.452Z" }, - { url = "https://files.pythonhosted.org/packages/af/a9/3bdd799e2c9b20c1ea6dc6fa8e83f29480a97711cf806e823f808c2316ac/pyarrow-20.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c3a01f313ffe27ac4126f4c2e5ea0f36a5fc6ab51f8726cf41fee4b256680bd", size = 42421775, upload_time = "2025-04-27T12:30:06.875Z" }, - { url = "https://files.pythonhosted.org/packages/10/f7/da98ccd86354c332f593218101ae56568d5dcedb460e342000bd89c49cc1/pyarrow-20.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:a2791f69ad72addd33510fec7bb14ee06c2a448e06b649e264c094c5b5f7ce28", size = 40687231, upload_time = "2025-04-27T12:30:13.954Z" }, - { url = "https://files.pythonhosted.org/packages/bb/1b/2168d6050e52ff1e6cefc61d600723870bf569cbf41d13db939c8cf97a16/pyarrow-20.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:4250e28a22302ce8692d3a0e8ec9d9dde54ec00d237cff4dfa9c1fbf79e472a8", size = 42295639, upload_time = "2025-04-27T12:30:21.949Z" }, - { url = "https://files.pythonhosted.org/packages/b2/66/2d976c0c7158fd25591c8ca55aee026e6d5745a021915a1835578707feb3/pyarrow-20.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:89e030dc58fc760e4010148e6ff164d2f44441490280ef1e97a542375e41058e", size = 42908549, upload_time = "2025-04-27T12:30:29.551Z" }, - { url = "https://files.pythonhosted.org/packages/31/a9/dfb999c2fc6911201dcbf348247f9cc382a8990f9ab45c12eabfd7243a38/pyarrow-20.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6102b4864d77102dbbb72965618e204e550135a940c2534711d5ffa787df2a5a", size = 44557216, upload_time = "2025-04-27T12:30:36.977Z" }, - { url = "https://files.pythonhosted.org/packages/a0/8e/9adee63dfa3911be2382fb4d92e4b2e7d82610f9d9f668493bebaa2af50f/pyarrow-20.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:96d6a0a37d9c98be08f5ed6a10831d88d52cac7b13f5287f1e0f625a0de8062b", size = 25660496, upload_time = "2025-04-27T12:30:42.809Z" }, - { url = "https://files.pythonhosted.org/packages/9b/aa/daa413b81446d20d4dad2944110dcf4cf4f4179ef7f685dd5a6d7570dc8e/pyarrow-20.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a15532e77b94c61efadde86d10957950392999503b3616b2ffcef7621a002893", size = 30798501, upload_time = "2025-04-27T12:30:48.351Z" }, - { url = "https://files.pythonhosted.org/packages/ff/75/2303d1caa410925de902d32ac215dc80a7ce7dd8dfe95358c165f2adf107/pyarrow-20.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:dd43f58037443af715f34f1322c782ec463a3c8a94a85fdb2d987ceb5658e061", size = 32277895, upload_time = "2025-04-27T12:30:55.238Z" }, - { url = "https://files.pythonhosted.org/packages/92/41/fe18c7c0b38b20811b73d1bdd54b1fccba0dab0e51d2048878042d84afa8/pyarrow-20.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa0d288143a8585806e3cc7c39566407aab646fb9ece164609dac1cfff45f6ae", size = 41327322, upload_time = "2025-04-27T12:31:05.587Z" }, - { url = "https://files.pythonhosted.org/packages/da/ab/7dbf3d11db67c72dbf36ae63dcbc9f30b866c153b3a22ef728523943eee6/pyarrow-20.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6953f0114f8d6f3d905d98e987d0924dabce59c3cda380bdfaa25a6201563b4", size = 42411441, upload_time = "2025-04-27T12:31:15.675Z" }, - { url = "https://files.pythonhosted.org/packages/90/c3/0c7da7b6dac863af75b64e2f827e4742161128c350bfe7955b426484e226/pyarrow-20.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:991f85b48a8a5e839b2128590ce07611fae48a904cae6cab1f089c5955b57eb5", size = 40677027, upload_time = "2025-04-27T12:31:24.631Z" }, - { url = "https://files.pythonhosted.org/packages/be/27/43a47fa0ff9053ab5203bb3faeec435d43c0d8bfa40179bfd076cdbd4e1c/pyarrow-20.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:97c8dc984ed09cb07d618d57d8d4b67a5100a30c3818c2fb0b04599f0da2de7b", size = 42281473, upload_time = "2025-04-27T12:31:31.311Z" }, - { url = "https://files.pythonhosted.org/packages/bc/0b/d56c63b078876da81bbb9ba695a596eabee9b085555ed12bf6eb3b7cab0e/pyarrow-20.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9b71daf534f4745818f96c214dbc1e6124d7daf059167330b610fc69b6f3d3e3", size = 42893897, upload_time = "2025-04-27T12:31:39.406Z" }, - { url = "https://files.pythonhosted.org/packages/92/ac/7d4bd020ba9145f354012838692d48300c1b8fe5634bfda886abcada67ed/pyarrow-20.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8b88758f9303fa5a83d6c90e176714b2fd3852e776fc2d7e42a22dd6c2fb368", size = 44543847, upload_time = "2025-04-27T12:31:45.997Z" }, - { url = "https://files.pythonhosted.org/packages/9d/07/290f4abf9ca702c5df7b47739c1b2c83588641ddfa2cc75e34a301d42e55/pyarrow-20.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:30b3051b7975801c1e1d387e17c588d8ab05ced9b1e14eec57915f79869b5031", size = 25653219, upload_time = "2025-04-27T12:31:54.11Z" }, - { url = "https://files.pythonhosted.org/packages/95/df/720bb17704b10bd69dde086e1400b8eefb8f58df3f8ac9cff6c425bf57f1/pyarrow-20.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:ca151afa4f9b7bc45bcc791eb9a89e90a9eb2772767d0b1e5389609c7d03db63", size = 30853957, upload_time = "2025-04-27T12:31:59.215Z" }, - { url = "https://files.pythonhosted.org/packages/d9/72/0d5f875efc31baef742ba55a00a25213a19ea64d7176e0fe001c5d8b6e9a/pyarrow-20.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:4680f01ecd86e0dd63e39eb5cd59ef9ff24a9d166db328679e36c108dc993d4c", size = 32247972, upload_time = "2025-04-27T12:32:05.369Z" }, - { url = "https://files.pythonhosted.org/packages/d5/bc/e48b4fa544d2eea72f7844180eb77f83f2030b84c8dad860f199f94307ed/pyarrow-20.0.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f4c8534e2ff059765647aa69b75d6543f9fef59e2cd4c6d18015192565d2b70", size = 41256434, upload_time = "2025-04-27T12:32:11.814Z" }, - { url = "https://files.pythonhosted.org/packages/c3/01/974043a29874aa2cf4f87fb07fd108828fc7362300265a2a64a94965e35b/pyarrow-20.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e1f8a47f4b4ae4c69c4d702cfbdfe4d41e18e5c7ef6f1bb1c50918c1e81c57b", size = 42353648, upload_time = "2025-04-27T12:32:20.766Z" }, - { url = "https://files.pythonhosted.org/packages/68/95/cc0d3634cde9ca69b0e51cbe830d8915ea32dda2157560dda27ff3b3337b/pyarrow-20.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:a1f60dc14658efaa927f8214734f6a01a806d7690be4b3232ba526836d216122", size = 40619853, upload_time = "2025-04-27T12:32:28.1Z" }, - { url = "https://files.pythonhosted.org/packages/29/c2/3ad40e07e96a3e74e7ed7cc8285aadfa84eb848a798c98ec0ad009eb6bcc/pyarrow-20.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:204a846dca751428991346976b914d6d2a82ae5b8316a6ed99789ebf976551e6", size = 42241743, upload_time = "2025-04-27T12:32:35.792Z" }, - { url = "https://files.pythonhosted.org/packages/eb/cb/65fa110b483339add6a9bc7b6373614166b14e20375d4daa73483755f830/pyarrow-20.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f3b117b922af5e4c6b9a9115825726cac7d8b1421c37c2b5e24fbacc8930612c", size = 42839441, upload_time = "2025-04-27T12:32:46.64Z" }, - { url = "https://files.pythonhosted.org/packages/98/7b/f30b1954589243207d7a0fbc9997401044bf9a033eec78f6cb50da3f304a/pyarrow-20.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e724a3fd23ae5b9c010e7be857f4405ed5e679db5c93e66204db1a69f733936a", size = 44503279, upload_time = "2025-04-27T12:32:56.503Z" }, - { url = "https://files.pythonhosted.org/packages/37/40/ad395740cd641869a13bcf60851296c89624662575621968dcfafabaa7f6/pyarrow-20.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:82f1ee5133bd8f49d31be1299dc07f585136679666b502540db854968576faf9", size = 25944982, upload_time = "2025-04-27T12:33:04.72Z" }, -] - -[[package]] -name = "pycparser" -version = "2.22" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload_time = "2024-03-30T13:22:22.564Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload_time = "2024-03-30T13:22:20.476Z" }, -] - -[[package]] -name = "pydantic" -version = "2.11.7" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "annotated-types" }, - { name = "pydantic-core" }, - { name = "typing-extensions" }, - { name = "typing-inspection" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/00/dd/4325abf92c39ba8623b5af936ddb36ffcfe0beae70405d456ab1fb2f5b8c/pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db", size = 788350, upload_time = "2025-06-14T08:33:17.137Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6a/c0/ec2b1c8712ca690e5d61979dee872603e92b8a32f94cc1b72d53beab008a/pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b", size = 444782, upload_time = "2025-06-14T08:33:14.905Z" }, -] - -[[package]] -name = "pydantic-core" -version = "2.33.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload_time = "2025-04-23T18:33:52.104Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e5/92/b31726561b5dae176c2d2c2dc43a9c5bfba5d32f96f8b4c0a600dd492447/pydantic_core-2.33.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2b3d326aaef0c0399d9afffeb6367d5e26ddc24d351dbc9c636840ac355dc5d8", size = 2028817, upload_time = "2025-04-23T18:30:43.919Z" }, - { url = "https://files.pythonhosted.org/packages/a3/44/3f0b95fafdaca04a483c4e685fe437c6891001bf3ce8b2fded82b9ea3aa1/pydantic_core-2.33.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e5b2671f05ba48b94cb90ce55d8bdcaaedb8ba00cc5359f6810fc918713983d", size = 1861357, upload_time = "2025-04-23T18:30:46.372Z" }, - { url = "https://files.pythonhosted.org/packages/30/97/e8f13b55766234caae05372826e8e4b3b96e7b248be3157f53237682e43c/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0069c9acc3f3981b9ff4cdfaf088e98d83440a4c7ea1bc07460af3d4dc22e72d", size = 1898011, upload_time = "2025-04-23T18:30:47.591Z" }, - { url = "https://files.pythonhosted.org/packages/9b/a3/99c48cf7bafc991cc3ee66fd544c0aae8dc907b752f1dad2d79b1b5a471f/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d53b22f2032c42eaaf025f7c40c2e3b94568ae077a606f006d206a463bc69572", size = 1982730, upload_time = "2025-04-23T18:30:49.328Z" }, - { url = "https://files.pythonhosted.org/packages/de/8e/a5b882ec4307010a840fb8b58bd9bf65d1840c92eae7534c7441709bf54b/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0405262705a123b7ce9f0b92f123334d67b70fd1f20a9372b907ce1080c7ba02", size = 2136178, upload_time = "2025-04-23T18:30:50.907Z" }, - { url = "https://files.pythonhosted.org/packages/e4/bb/71e35fc3ed05af6834e890edb75968e2802fe98778971ab5cba20a162315/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4b25d91e288e2c4e0662b8038a28c6a07eaac3e196cfc4ff69de4ea3db992a1b", size = 2736462, upload_time = "2025-04-23T18:30:52.083Z" }, - { url = "https://files.pythonhosted.org/packages/31/0d/c8f7593e6bc7066289bbc366f2235701dcbebcd1ff0ef8e64f6f239fb47d/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bdfe4b3789761f3bcb4b1ddf33355a71079858958e3a552f16d5af19768fef2", size = 2005652, upload_time = "2025-04-23T18:30:53.389Z" }, - { url = "https://files.pythonhosted.org/packages/d2/7a/996d8bd75f3eda405e3dd219ff5ff0a283cd8e34add39d8ef9157e722867/pydantic_core-2.33.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:efec8db3266b76ef9607c2c4c419bdb06bf335ae433b80816089ea7585816f6a", size = 2113306, upload_time = "2025-04-23T18:30:54.661Z" }, - { url = "https://files.pythonhosted.org/packages/ff/84/daf2a6fb2db40ffda6578a7e8c5a6e9c8affb251a05c233ae37098118788/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:031c57d67ca86902726e0fae2214ce6770bbe2f710dc33063187a68744a5ecac", size = 2073720, upload_time = "2025-04-23T18:30:56.11Z" }, - { url = "https://files.pythonhosted.org/packages/77/fb/2258da019f4825128445ae79456a5499c032b55849dbd5bed78c95ccf163/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:f8de619080e944347f5f20de29a975c2d815d9ddd8be9b9b7268e2e3ef68605a", size = 2244915, upload_time = "2025-04-23T18:30:57.501Z" }, - { url = "https://files.pythonhosted.org/packages/d8/7a/925ff73756031289468326e355b6fa8316960d0d65f8b5d6b3a3e7866de7/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:73662edf539e72a9440129f231ed3757faab89630d291b784ca99237fb94db2b", size = 2241884, upload_time = "2025-04-23T18:30:58.867Z" }, - { url = "https://files.pythonhosted.org/packages/0b/b0/249ee6d2646f1cdadcb813805fe76265745c4010cf20a8eba7b0e639d9b2/pydantic_core-2.33.2-cp310-cp310-win32.whl", hash = "sha256:0a39979dcbb70998b0e505fb1556a1d550a0781463ce84ebf915ba293ccb7e22", size = 1910496, upload_time = "2025-04-23T18:31:00.078Z" }, - { url = "https://files.pythonhosted.org/packages/66/ff/172ba8f12a42d4b552917aa65d1f2328990d3ccfc01d5b7c943ec084299f/pydantic_core-2.33.2-cp310-cp310-win_amd64.whl", hash = "sha256:b0379a2b24882fef529ec3b4987cb5d003b9cda32256024e6fe1586ac45fc640", size = 1955019, upload_time = "2025-04-23T18:31:01.335Z" }, - { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584, upload_time = "2025-04-23T18:31:03.106Z" }, - { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071, upload_time = "2025-04-23T18:31:04.621Z" }, - { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823, upload_time = "2025-04-23T18:31:06.377Z" }, - { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792, upload_time = "2025-04-23T18:31:07.93Z" }, - { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338, upload_time = "2025-04-23T18:31:09.283Z" }, - { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998, upload_time = "2025-04-23T18:31:11.7Z" }, - { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200, upload_time = "2025-04-23T18:31:13.536Z" }, - { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890, upload_time = "2025-04-23T18:31:15.011Z" }, - { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359, upload_time = "2025-04-23T18:31:16.393Z" }, - { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883, upload_time = "2025-04-23T18:31:17.892Z" }, - { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074, upload_time = "2025-04-23T18:31:19.205Z" }, - { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538, upload_time = "2025-04-23T18:31:20.541Z" }, - { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909, upload_time = "2025-04-23T18:31:22.371Z" }, - { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786, upload_time = "2025-04-23T18:31:24.161Z" }, - { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload_time = "2025-04-23T18:31:25.863Z" }, - { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload_time = "2025-04-23T18:31:27.341Z" }, - { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload_time = "2025-04-23T18:31:28.956Z" }, - { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload_time = "2025-04-23T18:31:31.025Z" }, - { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload_time = "2025-04-23T18:31:32.514Z" }, - { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload_time = "2025-04-23T18:31:33.958Z" }, - { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload_time = "2025-04-23T18:31:39.095Z" }, - { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload_time = "2025-04-23T18:31:41.034Z" }, - { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload_time = "2025-04-23T18:31:42.757Z" }, - { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload_time = "2025-04-23T18:31:44.304Z" }, - { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload_time = "2025-04-23T18:31:45.891Z" }, - { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload_time = "2025-04-23T18:31:47.819Z" }, - { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload_time = "2025-04-23T18:31:49.635Z" }, - { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload_time = "2025-04-23T18:31:51.609Z" }, - { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload_time = "2025-04-23T18:31:53.175Z" }, - { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload_time = "2025-04-23T18:31:54.79Z" }, - { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload_time = "2025-04-23T18:31:57.393Z" }, - { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload_time = "2025-04-23T18:31:59.065Z" }, - { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload_time = "2025-04-23T18:32:00.78Z" }, - { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload_time = "2025-04-23T18:32:02.418Z" }, - { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload_time = "2025-04-23T18:32:04.152Z" }, - { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload_time = "2025-04-23T18:32:06.129Z" }, - { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload_time = "2025-04-23T18:32:08.178Z" }, - { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload_time = "2025-04-23T18:32:10.242Z" }, - { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload_time = "2025-04-23T18:32:12.382Z" }, - { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload_time = "2025-04-23T18:32:14.034Z" }, - { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload_time = "2025-04-23T18:32:15.783Z" }, - { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload_time = "2025-04-23T18:32:18.473Z" }, - { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload_time = "2025-04-23T18:32:20.188Z" }, - { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload_time = "2025-04-23T18:32:22.354Z" }, - { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload_time = "2025-04-23T18:32:25.088Z" }, - { url = "https://files.pythonhosted.org/packages/30/68/373d55e58b7e83ce371691f6eaa7175e3a24b956c44628eb25d7da007917/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5c4aa4e82353f65e548c476b37e64189783aa5384903bfea4f41580f255fddfa", size = 2023982, upload_time = "2025-04-23T18:32:53.14Z" }, - { url = "https://files.pythonhosted.org/packages/a4/16/145f54ac08c96a63d8ed6442f9dec17b2773d19920b627b18d4f10a061ea/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d946c8bf0d5c24bf4fe333af284c59a19358aa3ec18cb3dc4370080da1e8ad29", size = 1858412, upload_time = "2025-04-23T18:32:55.52Z" }, - { url = "https://files.pythonhosted.org/packages/41/b1/c6dc6c3e2de4516c0bb2c46f6a373b91b5660312342a0cf5826e38ad82fa/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87b31b6846e361ef83fedb187bb5b4372d0da3f7e28d85415efa92d6125d6e6d", size = 1892749, upload_time = "2025-04-23T18:32:57.546Z" }, - { url = "https://files.pythonhosted.org/packages/12/73/8cd57e20afba760b21b742106f9dbdfa6697f1570b189c7457a1af4cd8a0/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa9d91b338f2df0508606f7009fde642391425189bba6d8c653afd80fd6bb64e", size = 2067527, upload_time = "2025-04-23T18:32:59.771Z" }, - { url = "https://files.pythonhosted.org/packages/e3/d5/0bb5d988cc019b3cba4a78f2d4b3854427fc47ee8ec8e9eaabf787da239c/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2058a32994f1fde4ca0480ab9d1e75a0e8c87c22b53a3ae66554f9af78f2fe8c", size = 2108225, upload_time = "2025-04-23T18:33:04.51Z" }, - { url = "https://files.pythonhosted.org/packages/f1/c5/00c02d1571913d496aabf146106ad8239dc132485ee22efe08085084ff7c/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:0e03262ab796d986f978f79c943fc5f620381be7287148b8010b4097f79a39ec", size = 2069490, upload_time = "2025-04-23T18:33:06.391Z" }, - { url = "https://files.pythonhosted.org/packages/22/a8/dccc38768274d3ed3a59b5d06f59ccb845778687652daa71df0cab4040d7/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:1a8695a8d00c73e50bff9dfda4d540b7dee29ff9b8053e38380426a85ef10052", size = 2237525, upload_time = "2025-04-23T18:33:08.44Z" }, - { url = "https://files.pythonhosted.org/packages/d4/e7/4f98c0b125dda7cf7ccd14ba936218397b44f50a56dd8c16a3091df116c3/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:fa754d1850735a0b0e03bcffd9d4b4343eb417e47196e4485d9cca326073a42c", size = 2238446, upload_time = "2025-04-23T18:33:10.313Z" }, - { url = "https://files.pythonhosted.org/packages/ce/91/2ec36480fdb0b783cd9ef6795753c1dea13882f2e68e73bce76ae8c21e6a/pydantic_core-2.33.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a11c8d26a50bfab49002947d3d237abe4d9e4b5bdc8846a63537b6488e197808", size = 2066678, upload_time = "2025-04-23T18:33:12.224Z" }, - { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200, upload_time = "2025-04-23T18:33:14.199Z" }, - { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123, upload_time = "2025-04-23T18:33:16.555Z" }, - { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852, upload_time = "2025-04-23T18:33:18.513Z" }, - { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484, upload_time = "2025-04-23T18:33:20.475Z" }, - { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896, upload_time = "2025-04-23T18:33:22.501Z" }, - { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475, upload_time = "2025-04-23T18:33:24.528Z" }, - { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013, upload_time = "2025-04-23T18:33:26.621Z" }, - { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715, upload_time = "2025-04-23T18:33:28.656Z" }, - { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757, upload_time = "2025-04-23T18:33:30.645Z" }, -] - -[[package]] -name = "pygments" -version = "2.19.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload_time = "2025-06-21T13:39:12.283Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload_time = "2025-06-21T13:39:07.939Z" }, -] - -[[package]] -name = "pymongo" -version = "4.13.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "dnspython" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/4b/5a/d664298bf54762f0c89b8aa2c276868070e06afb853b4a8837de5741e5f9/pymongo-4.13.2.tar.gz", hash = "sha256:0f64c6469c2362962e6ce97258ae1391abba1566a953a492562d2924b44815c2", size = 2167844, upload_time = "2025-06-16T18:16:30.685Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/df/a8/293dfd3accda06ae94c54e7c15ac5108614d31263708236b4743554ad6ee/pymongo-4.13.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:01065eb1838e3621a30045ab14d1a60ee62e01f65b7cf154e69c5c722ef14d2f", size = 802768, upload_time = "2025-06-16T18:14:39.521Z" }, - { url = "https://files.pythonhosted.org/packages/ce/7f/2cbc897dd2867b9b5f8e9e6587dc4bf23e3777a4ddd712064ed21aea99e0/pymongo-4.13.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9ab0325d436075f5f1901cde95afae811141d162bc42d9a5befb647fda585ae6", size = 803053, upload_time = "2025-06-16T18:14:43.318Z" }, - { url = "https://files.pythonhosted.org/packages/b6/da/07cdbaf507cccfdac837f612ea276523d2cdd380c5253c86ceae0369f0e2/pymongo-4.13.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdd8041902963c84dc4e27034fa045ac55fabcb2a4ba5b68b880678557573e70", size = 1180427, upload_time = "2025-06-16T18:14:44.841Z" }, - { url = "https://files.pythonhosted.org/packages/2b/5c/5f61269c87e565a6f4016e644e2bd20473b4b5a47c362ad3d57a1428ef33/pymongo-4.13.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b00ab04630aa4af97294e9abdbe0506242396269619c26f5761fd7b2524ef501", size = 1214655, upload_time = "2025-06-16T18:14:46.635Z" }, - { url = "https://files.pythonhosted.org/packages/26/51/757ee06299e2bb61c0ae7b886ca845a78310cf94fc95bbc044bbe7892392/pymongo-4.13.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:16440d0da30ba804c6c01ea730405fdbbb476eae760588ea09e6e7d28afc06de", size = 1197586, upload_time = "2025-06-16T18:14:48.129Z" }, - { url = "https://files.pythonhosted.org/packages/5a/a8/9ddf0ad0884046c34c5eb3de9a944c47d37e39989ae782ded2b207462a97/pymongo-4.13.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad9a2d1357aed5d6750deb315f62cb6f5b3c4c03ffb650da559cb09cb29e6fe8", size = 1183599, upload_time = "2025-06-16T18:14:49.576Z" }, - { url = "https://files.pythonhosted.org/packages/7b/57/61b289b440e77524e4b0d6881f6c6f50cf9a55a72b5ba2adaa43d70531e6/pymongo-4.13.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c793223aef21a8c415c840af1ca36c55a05d6fa3297378da35de3fb6661c0174", size = 1162761, upload_time = "2025-06-16T18:14:51.558Z" }, - { url = "https://files.pythonhosted.org/packages/05/22/bd328cedc79768ab03942fd828f0cd1d50a3ae2c3caf3aebad65a644eb75/pymongo-4.13.2-cp310-cp310-win32.whl", hash = "sha256:8ef6ae029a3390565a0510c872624514dde350007275ecd8126b09175aa02cca", size = 790062, upload_time = "2025-06-16T18:14:53.024Z" }, - { url = "https://files.pythonhosted.org/packages/9f/70/2d8bbdac28e869cebb8081a43f8b16c6dd2384f6aef28fcc6ec0693a7042/pymongo-4.13.2-cp310-cp310-win_amd64.whl", hash = "sha256:66f168f8c5b1e2e3d518507cf9f200f0c86ac79e2b2be9e7b6c8fd1e2f7d7824", size = 800198, upload_time = "2025-06-16T18:14:54.481Z" }, - { url = "https://files.pythonhosted.org/packages/94/df/4c4ef17b48c70120f834ba7151860c300924915696c4a57170cb5b09787f/pymongo-4.13.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7af8c56d0a7fcaf966d5292e951f308fb1f8bac080257349e14742725fd7990d", size = 857145, upload_time = "2025-06-16T18:14:56.516Z" }, - { url = "https://files.pythonhosted.org/packages/e7/41/480ca82b3b3320fc70fe699a01df28db15a4ea154c8759ab4a437a74c808/pymongo-4.13.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ad24f5864706f052b05069a6bc59ff875026e28709548131448fe1e40fc5d80f", size = 857437, upload_time = "2025-06-16T18:14:58.572Z" }, - { url = "https://files.pythonhosted.org/packages/50/d4/eb74e98ea980a5e1ec4f06f383ec6c52ab02076802de24268f477ef616d2/pymongo-4.13.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a10069454195d1d2dda98d681b1dbac9a425f4b0fe744aed5230c734021c1cb9", size = 1426516, upload_time = "2025-06-16T18:15:00.589Z" }, - { url = "https://files.pythonhosted.org/packages/aa/fe/c5960c0e6438bd489367261e5ef1a5db01e34349f0dbf7529fb938d3d2ef/pymongo-4.13.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e20862b81e3863bcd72334e3577a3107604553b614a8d25ee1bb2caaea4eb90", size = 1477477, upload_time = "2025-06-16T18:15:02.283Z" }, - { url = "https://files.pythonhosted.org/packages/f6/9f/ef4395175fc97876978736c8493d8ffa4d13aa7a4e12269a2cb0d52a1246/pymongo-4.13.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b4d5794ca408317c985d7acfb346a60f96f85a7c221d512ff0ecb3cce9d6110", size = 1451921, upload_time = "2025-06-16T18:15:04.35Z" }, - { url = "https://files.pythonhosted.org/packages/2a/b9/397cb2a3ec03f880e882102eddcb46c3d516c6cf47a05f44db48067924d9/pymongo-4.13.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c8e0420fb4901006ae7893e76108c2a36a343b4f8922466d51c45e9e2ceb717", size = 1431045, upload_time = "2025-06-16T18:15:06.392Z" }, - { url = "https://files.pythonhosted.org/packages/f5/0d/e150a414e5cb07f2fefca817fa071a6da8d96308469a85a777244c8c4337/pymongo-4.13.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:239b5f83b83008471d54095e145d4c010f534af99e87cc8877fc6827736451a0", size = 1399697, upload_time = "2025-06-16T18:15:08.975Z" }, - { url = "https://files.pythonhosted.org/packages/b8/29/5190eafb994721c30a38a8a62df225c47a9da364ab5c8cffe90aabf6a54e/pymongo-4.13.2-cp311-cp311-win32.whl", hash = "sha256:6bceb524110c32319eb7119422e400dbcafc5b21bcc430d2049a894f69b604e5", size = 836261, upload_time = "2025-06-16T18:15:10.459Z" }, - { url = "https://files.pythonhosted.org/packages/d3/da/30bdcc83b23fc4f2996b39b41b2ff0ff2184230a78617c7b8636aac4d81d/pymongo-4.13.2-cp311-cp311-win_amd64.whl", hash = "sha256:ab87484c97ae837b0a7bbdaa978fa932fbb6acada3f42c3b2bee99121a594715", size = 851451, upload_time = "2025-06-16T18:15:12.181Z" }, - { url = "https://files.pythonhosted.org/packages/03/e0/0e187750e23eed4227282fcf568fdb61f2b53bbcf8cbe3a71dde2a860d12/pymongo-4.13.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ec89516622dfc8b0fdff499612c0bd235aa45eeb176c9e311bcc0af44bf952b6", size = 912004, upload_time = "2025-06-16T18:15:14.299Z" }, - { url = "https://files.pythonhosted.org/packages/57/c2/9b79795382daaf41e5f7379bffdef1880d68160adea352b796d6948cb5be/pymongo-4.13.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f30eab4d4326df54fee54f31f93e532dc2918962f733ee8e115b33e6fe151d92", size = 911698, upload_time = "2025-06-16T18:15:16.334Z" }, - { url = "https://files.pythonhosted.org/packages/6f/e4/f04dc9ed5d1d9dbc539dc2d8758dd359c5373b0e06fcf25418b2c366737c/pymongo-4.13.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cce9428d12ba396ea245fc4c51f20228cead01119fcc959e1c80791ea45f820", size = 1690357, upload_time = "2025-06-16T18:15:18.358Z" }, - { url = "https://files.pythonhosted.org/packages/bb/de/41478a7d527d38f1b98b084f4a78bbb805439a6ebd8689fbbee0a3dfacba/pymongo-4.13.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac9241b727a69c39117c12ac1e52d817ea472260dadc66262c3fdca0bab0709b", size = 1754593, upload_time = "2025-06-16T18:15:20.096Z" }, - { url = "https://files.pythonhosted.org/packages/df/d9/8fa2eb110291e154f4312779b1a5b815090b8b05a59ecb4f4a32427db1df/pymongo-4.13.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3efc4c515b371a9fa1d198b6e03340985bfe1a55ae2d2b599a714934e7bc61ab", size = 1723637, upload_time = "2025-06-16T18:15:22.048Z" }, - { url = "https://files.pythonhosted.org/packages/27/7b/9863fa60a4a51ea09f5e3cd6ceb231af804e723671230f2daf3bd1b59c2b/pymongo-4.13.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f57a664aa74610eb7a52fa93f2cf794a1491f4f76098343485dd7da5b3bcff06", size = 1693613, upload_time = "2025-06-16T18:15:24.866Z" }, - { url = "https://files.pythonhosted.org/packages/9b/89/a42efa07820a59089836f409a63c96e7a74e33313e50dc39c554db99ac42/pymongo-4.13.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3dcb0b8cdd499636017a53f63ef64cf9b6bd3fd9355796c5a1d228e4be4a4c94", size = 1652745, upload_time = "2025-06-16T18:15:27.078Z" }, - { url = "https://files.pythonhosted.org/packages/6a/cf/2c77d1acda61d281edd3e3f00d5017d3fac0c29042c769efd3b8018cb469/pymongo-4.13.2-cp312-cp312-win32.whl", hash = "sha256:bf43ae07804d7762b509f68e5ec73450bb8824e960b03b861143ce588b41f467", size = 883232, upload_time = "2025-06-16T18:15:29.169Z" }, - { url = "https://files.pythonhosted.org/packages/d2/4f/727f59156e3798850c3c2901f106804053cb0e057ed1bd9883f5fa5aa8fa/pymongo-4.13.2-cp312-cp312-win_amd64.whl", hash = "sha256:812a473d584bcb02ab819d379cd5e752995026a2bb0d7713e78462b6650d3f3a", size = 903304, upload_time = "2025-06-16T18:15:31.346Z" }, - { url = "https://files.pythonhosted.org/packages/e0/95/b44b8e24b161afe7b244f6d43c09a7a1f93308cad04198de1c14c67b24ce/pymongo-4.13.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6044ca0eb74d97f7d3415264de86a50a401b7b0b136d30705f022f9163c3124", size = 966232, upload_time = "2025-06-16T18:15:33.057Z" }, - { url = "https://files.pythonhosted.org/packages/6d/fc/d4d59799a52033acb187f7bd1f09bc75bebb9fd12cef4ba2964d235ad3f9/pymongo-4.13.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dd326bcb92d28d28a3e7ef0121602bad78691b6d4d1f44b018a4616122f1ba8b", size = 965935, upload_time = "2025-06-16T18:15:34.826Z" }, - { url = "https://files.pythonhosted.org/packages/07/a8/67502899d89b317ea9952e4769bc193ca15efee561b24b38a86c59edde6f/pymongo-4.13.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfb0c21bdd58e58625c9cd8de13e859630c29c9537944ec0a14574fdf88c2ac4", size = 1954070, upload_time = "2025-06-16T18:15:36.576Z" }, - { url = "https://files.pythonhosted.org/packages/da/3b/0dac5d81d1af1b96b3200da7ccc52fc261a35efb7d2ac493252eb40a2b11/pymongo-4.13.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9c7d345d57f17b1361008aea78a37e8c139631a46aeb185dd2749850883c7ba", size = 2031424, upload_time = "2025-06-16T18:15:38.723Z" }, - { url = "https://files.pythonhosted.org/packages/31/ed/7a5af49a153224ca7e31e9915703e612ad9c45808cc39540e9dd1a2a7537/pymongo-4.13.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8860445a8da1b1545406fab189dc20319aff5ce28e65442b2b4a8f4228a88478", size = 1995339, upload_time = "2025-06-16T18:15:40.474Z" }, - { url = "https://files.pythonhosted.org/packages/f1/e9/9c72eceae8439c4f1bdebc4e6b290bf035e3f050a80eeb74abb5e12ef8e2/pymongo-4.13.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01c184b612f67d5a4c8f864ae7c40b6cc33c0e9bb05e39d08666f8831d120504", size = 1956066, upload_time = "2025-06-16T18:15:42.272Z" }, - { url = "https://files.pythonhosted.org/packages/ac/79/9b019c47923395d5fced03856996465fb9340854b0f5a2ddf16d47e2437c/pymongo-4.13.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ea8c62d5f3c6529407c12471385d9a05f9fb890ce68d64976340c85cd661b", size = 1905642, upload_time = "2025-06-16T18:15:43.978Z" }, - { url = "https://files.pythonhosted.org/packages/93/2f/ebf56c7fa9298fa2f9716e7b66cf62b29e7fc6e11774f3b87f55d214d466/pymongo-4.13.2-cp313-cp313-win32.whl", hash = "sha256:d13556e91c4a8cb07393b8c8be81e66a11ebc8335a40fa4af02f4d8d3b40c8a1", size = 930184, upload_time = "2025-06-16T18:15:46.899Z" }, - { url = "https://files.pythonhosted.org/packages/76/2f/49c35464cbd5d116d950ff5d24b4b20491aaae115d35d40b945c33b29250/pymongo-4.13.2-cp313-cp313-win_amd64.whl", hash = "sha256:cfc69d7bc4d4d5872fd1e6de25e6a16e2372c7d5556b75c3b8e2204dce73e3fb", size = 955111, upload_time = "2025-06-16T18:15:48.85Z" }, - { url = "https://files.pythonhosted.org/packages/57/56/b17c8b5329b1842b7847cf0fa224ef0a272bf2e5126360f4da8065c855a1/pymongo-4.13.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a457d2ac34c05e9e8a6bb724115b093300bf270f0655fb897df8d8604b2e3700", size = 1022735, upload_time = "2025-06-16T18:15:50.672Z" }, - { url = "https://files.pythonhosted.org/packages/83/e6/66fec65a7919bf5f35be02e131b4dc4bf3152b5e8d78cd04b6d266a44514/pymongo-4.13.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:02f131a6e61559613b1171b53fbe21fed64e71b0cb4858c47fc9bc7c8e0e501c", size = 1022740, upload_time = "2025-06-16T18:15:53.218Z" }, - { url = "https://files.pythonhosted.org/packages/17/92/cda7383df0d5e71dc007f172c1ecae6313d64ea05d82bbba06df7f6b3e49/pymongo-4.13.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c942d1c6334e894271489080404b1a2e3b8bd5de399f2a0c14a77d966be5bc9", size = 2282430, upload_time = "2025-06-16T18:15:55.356Z" }, - { url = "https://files.pythonhosted.org/packages/84/da/285e05eb1d617b30dc7a7a98ebeb264353a8903e0e816a4eec6487c81f18/pymongo-4.13.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:850168d115680ab66a0931a6aa9dd98ed6aa5e9c3b9a6c12128049b9a5721bc5", size = 2369470, upload_time = "2025-06-16T18:15:57.5Z" }, - { url = "https://files.pythonhosted.org/packages/89/c0/c0d5eae236de9ca293497dc58fc1e4872382223c28ec223f76afc701392c/pymongo-4.13.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af7dfff90647ee77c53410f7fe8ca4fe343f8b768f40d2d0f71a5602f7b5a541", size = 2328857, upload_time = "2025-06-16T18:15:59.59Z" }, - { url = "https://files.pythonhosted.org/packages/2b/5a/d8639fba60def128ce9848b99c56c54c8a4d0cd60342054cd576f0bfdf26/pymongo-4.13.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8057f9bc9c94a8fd54ee4f5e5106e445a8f406aff2df74746f21c8791ee2403", size = 2280053, upload_time = "2025-06-16T18:16:02.166Z" }, - { url = "https://files.pythonhosted.org/packages/a1/69/d56f0897cc4932a336820c5d2470ffed50be04c624b07d1ad6ea75aaa975/pymongo-4.13.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:51040e1ba78d6671f8c65b29e2864483451e789ce93b1536de9cc4456ede87fa", size = 2219378, upload_time = "2025-06-16T18:16:04.108Z" }, - { url = "https://files.pythonhosted.org/packages/04/1e/427e7f99801ee318b6331062d682d3816d7e1d6b6013077636bd75d49c87/pymongo-4.13.2-cp313-cp313t-win32.whl", hash = "sha256:7ab86b98a18c8689514a9f8d0ec7d9ad23a949369b31c9a06ce4a45dcbffcc5e", size = 979460, upload_time = "2025-06-16T18:16:06.128Z" }, - { url = "https://files.pythonhosted.org/packages/b5/9c/00301a6df26f0f8d5c5955192892241e803742e7c3da8c2c222efabc0df6/pymongo-4.13.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c38168263ed94a250fc5cf9c6d33adea8ab11c9178994da1c3481c2a49d235f8", size = 1011057, upload_time = "2025-06-16T18:16:07.917Z" }, -] - -[[package]] -name = "pyparsing" -version = "3.2.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bb/22/f1129e69d94ffff626bdb5c835506b3a5b4f3d070f17ea295e12c2c6f60f/pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be", size = 1088608, upload_time = "2025-03-25T05:01:28.114Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120, upload_time = "2025-03-25T05:01:24.908Z" }, -] - -[[package]] -name = "pypinyin" -version = "0.54.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/c9/7f/81cb5416ddacfeccca8eeedcd3543a72b093b26d9c4ca7bde8beea733e4e/pypinyin-0.54.0.tar.gz", hash = "sha256:9ab0d07ff51d191529e22134a60e109d0526d80b7a80afa73da4c89521610958", size = 837455, upload_time = "2025-03-30T11:31:39.142Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b6/ec/2c04ac863e7a85bb68b0b655cec2f19853d51d305ce3d785848db6037b8d/pypinyin-0.54.0-py2.py3-none-any.whl", hash = "sha256:5f776f19b9fd922e4121a114810b22048d90e6e8037fb1c07f4c40f987ae6e7a", size = 837012, upload_time = "2025-03-30T11:31:36.588Z" }, -] - -[[package]] -name = "python-dateutil" -version = "2.9.0.post0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "six" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload_time = "2024-03-01T18:36:20.211Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload_time = "2024-03-01T18:36:18.57Z" }, -] - -[[package]] -name = "python-dotenv" -version = "1.1.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload_time = "2025-06-24T04:21:07.341Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload_time = "2025-06-24T04:21:06.073Z" }, -] - -[[package]] -name = "python-igraph" -version = "0.11.9" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "igraph" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/54/b6/c03609dd766c5c5ca17e3b42b42a92fbb2ab133256265128cfeb9b1f1733/python_igraph-0.11.9.tar.gz", hash = "sha256:51ad8bfba7777ff110cd4f47eb9efeaf092e4edf3167153b05156dbe55dbf90c", size = 9756, upload_time = "2025-06-11T09:28:44.9Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/86/64/0d58006ac4f03dc0b8055bbf6b4cdee361646dc7a8db9b233145e3b981d9/python_igraph-0.11.9-py3-none-any.whl", hash = "sha256:9154606132dac48071edf5bc27f5b54cb316db09686ad8cffce078943733de29", size = 9172, upload_time = "2025-06-11T09:28:41.99Z" }, -] - -[[package]] -name = "python-multipart" -version = "0.0.20" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload_time = "2024-12-16T19:45:46.972Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload_time = "2024-12-16T19:45:44.423Z" }, -] - -[[package]] -name = "pytz" -version = "2025.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload_time = "2025-03-25T02:25:00.538Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload_time = "2025-03-25T02:24:58.468Z" }, -] - -[[package]] -name = "quick-algo" -version = "0.1.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b6/5e/9a8aa66f6a9da26253bb1fb87c573fb5ced9da19aea306787542bb4abc2f/quick_algo-0.1.3.tar.gz", hash = "sha256:83bc6a991a30222019b38dcccabe0aa703d4a14ef6d8a41d801f6c51f2b6beec", size = 201656, upload_time = "2025-04-24T08:39:56.854Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d9/8e/779063325ba04c0a44e61c9ebf5fedecb427de377c081986bcc59dba6312/quick_algo-0.1.3-cp310-cp310-win_amd64.whl", hash = "sha256:901b365e5ada781332bf38103b7a03f52a5bd4a81e01391d1271f710be1a4092", size = 320533, upload_time = "2025-04-24T08:39:49.485Z" }, - { url = "https://files.pythonhosted.org/packages/4b/0d/9dcf1ed1f1a89a4b307408fe980b853bdaabd5d72d625b30bcbb0c972750/quick_algo-0.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:68b121726cabb4da03bd6b644df2a0d7be9accf8388f2cd34cb2cc9318d96f0a", size = 320943, upload_time = "2025-04-24T08:39:51.911Z" }, - { url = "https://files.pythonhosted.org/packages/5e/3d/c75e6c509fde672c19e63cf22389da60f5bbe9273bc91865726b24f88689/quick_algo-0.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:1d73297c6f0135ca6acd1a3c036a8d4280f005744abdbb5a30428fabb8f095fe", size = 318958, upload_time = "2025-04-24T08:39:53.491Z" }, - { url = "https://files.pythonhosted.org/packages/11/2f/9a9a77d4aafe9f290b5db1a63a1c3c2c105eb9dbdc573cc0a20fd5299b96/quick_algo-0.1.3-cp313-cp313-win_amd64.whl", hash = "sha256:8ddc2ec38a04e757b9b5861e73001c4e0d8f66d5cd9a45b00f878f396d50a2b1", size = 317673, upload_time = "2025-04-24T08:39:55.119Z" }, -] - -[[package]] -name = "reportportal-client" -version = "5.6.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aenum" }, - { name = "aiohttp" }, - { name = "certifi" }, - { name = "requests" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c6/ba/b5c68832fdc31f6a6a42fb0081bc6ab2421ef952355fdee97ccd458859b3/reportportal_client-5.6.5.tar.gz", hash = "sha256:c927f745e3e4b9f1e146207adf9709651318fcf05e577ffdddb00998262704be", size = 61192, upload_time = "2025-05-05T10:26:09.533Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/54/db/34d03623a1cc571f207cb5baa706f4360d5f26e06ba1f1aa057ba256a4b0/reportportal_client-5.6.5-py2.py3-none-any.whl", hash = "sha256:b3cc3c71c3748f1759b9893ee660176134f34650d1733fed45a5920806d239fe", size = 80896, upload_time = "2025-05-05T10:26:08.438Z" }, -] - -[[package]] -name = "requests" -version = "2.32.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "charset-normalizer" }, - { name = "idna" }, - { name = "urllib3" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258, upload_time = "2025-06-09T16:43:07.34Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847, upload_time = "2025-06-09T16:43:05.728Z" }, -] - -[[package]] -name = "rich" -version = "14.0.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "markdown-it-py" }, - { name = "pygments" }, - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a1/53/830aa4c3066a8ab0ae9a9955976fb770fe9c6102117c8ec4ab3ea62d89e8/rich-14.0.0.tar.gz", hash = "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725", size = 224078, upload_time = "2025-03-30T14:15:14.23Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/9b/63f4c7ebc259242c89b3acafdb37b41d1185c07ff0011164674e9076b491/rich-14.0.0-py3-none-any.whl", hash = "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0", size = 243229, upload_time = "2025-03-30T14:15:12.283Z" }, -] - -[[package]] -name = "ruff" -version = "0.12.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6c/3d/d9a195676f25d00dbfcf3cf95fdd4c685c497fcfa7e862a44ac5e4e96480/ruff-0.12.2.tar.gz", hash = "sha256:d7b4f55cd6f325cb7621244f19c873c565a08aff5a4ba9c69aa7355f3f7afd3e", size = 4432239, upload_time = "2025-07-03T16:40:19.566Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/74/b6/2098d0126d2d3318fd5bec3ad40d06c25d377d95749f7a0c5af17129b3b1/ruff-0.12.2-py3-none-linux_armv6l.whl", hash = "sha256:093ea2b221df1d2b8e7ad92fc6ffdca40a2cb10d8564477a987b44fd4008a7be", size = 10369761, upload_time = "2025-07-03T16:39:38.847Z" }, - { url = "https://files.pythonhosted.org/packages/b1/4b/5da0142033dbe155dc598cfb99262d8ee2449d76920ea92c4eeb9547c208/ruff-0.12.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:09e4cf27cc10f96b1708100fa851e0daf21767e9709e1649175355280e0d950e", size = 11155659, upload_time = "2025-07-03T16:39:42.294Z" }, - { url = "https://files.pythonhosted.org/packages/3e/21/967b82550a503d7c5c5c127d11c935344b35e8c521f52915fc858fb3e473/ruff-0.12.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:8ae64755b22f4ff85e9c52d1f82644abd0b6b6b6deedceb74bd71f35c24044cc", size = 10537769, upload_time = "2025-07-03T16:39:44.75Z" }, - { url = "https://files.pythonhosted.org/packages/33/91/00cff7102e2ec71a4890fb7ba1803f2cdb122d82787c7d7cf8041fe8cbc1/ruff-0.12.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3eb3a6b2db4d6e2c77e682f0b988d4d61aff06860158fdb413118ca133d57922", size = 10717602, upload_time = "2025-07-03T16:39:47.652Z" }, - { url = "https://files.pythonhosted.org/packages/9b/eb/928814daec4e1ba9115858adcda44a637fb9010618721937491e4e2283b8/ruff-0.12.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:73448de992d05517170fc37169cbca857dfeaeaa8c2b9be494d7bcb0d36c8f4b", size = 10198772, upload_time = "2025-07-03T16:39:49.641Z" }, - { url = "https://files.pythonhosted.org/packages/50/fa/f15089bc20c40f4f72334f9145dde55ab2b680e51afb3b55422effbf2fb6/ruff-0.12.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3b8b94317cbc2ae4a2771af641739f933934b03555e51515e6e021c64441532d", size = 11845173, upload_time = "2025-07-03T16:39:52.069Z" }, - { url = "https://files.pythonhosted.org/packages/43/9f/1f6f98f39f2b9302acc161a4a2187b1e3a97634fe918a8e731e591841cf4/ruff-0.12.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:45fc42c3bf1d30d2008023a0a9a0cfb06bf9835b147f11fe0679f21ae86d34b1", size = 12553002, upload_time = "2025-07-03T16:39:54.551Z" }, - { url = "https://files.pythonhosted.org/packages/d8/70/08991ac46e38ddd231c8f4fd05ef189b1b94be8883e8c0c146a025c20a19/ruff-0.12.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce48f675c394c37e958bf229fb5c1e843e20945a6d962cf3ea20b7a107dcd9f4", size = 12171330, upload_time = "2025-07-03T16:39:57.55Z" }, - { url = "https://files.pythonhosted.org/packages/88/a9/5a55266fec474acfd0a1c73285f19dd22461d95a538f29bba02edd07a5d9/ruff-0.12.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:793d8859445ea47591272021a81391350205a4af65a9392401f418a95dfb75c9", size = 11774717, upload_time = "2025-07-03T16:39:59.78Z" }, - { url = "https://files.pythonhosted.org/packages/87/e5/0c270e458fc73c46c0d0f7cf970bb14786e5fdb88c87b5e423a4bd65232b/ruff-0.12.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6932323db80484dda89153da3d8e58164d01d6da86857c79f1961934354992da", size = 11646659, upload_time = "2025-07-03T16:40:01.934Z" }, - { url = "https://files.pythonhosted.org/packages/b7/b6/45ab96070c9752af37f0be364d849ed70e9ccede07675b0ec4e3ef76b63b/ruff-0.12.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:6aa7e623a3a11538108f61e859ebf016c4f14a7e6e4eba1980190cacb57714ce", size = 10604012, upload_time = "2025-07-03T16:40:04.363Z" }, - { url = "https://files.pythonhosted.org/packages/86/91/26a6e6a424eb147cc7627eebae095cfa0b4b337a7c1c413c447c9ebb72fd/ruff-0.12.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2a4a20aeed74671b2def096bdf2eac610c7d8ffcbf4fb0e627c06947a1d7078d", size = 10176799, upload_time = "2025-07-03T16:40:06.514Z" }, - { url = "https://files.pythonhosted.org/packages/f5/0c/9f344583465a61c8918a7cda604226e77b2c548daf8ef7c2bfccf2b37200/ruff-0.12.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:71a4c550195612f486c9d1f2b045a600aeba851b298c667807ae933478fcef04", size = 11241507, upload_time = "2025-07-03T16:40:08.708Z" }, - { url = "https://files.pythonhosted.org/packages/1c/b7/99c34ded8fb5f86c0280278fa89a0066c3760edc326e935ce0b1550d315d/ruff-0.12.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:4987b8f4ceadf597c927beee65a5eaf994c6e2b631df963f86d8ad1bdea99342", size = 11717609, upload_time = "2025-07-03T16:40:10.836Z" }, - { url = "https://files.pythonhosted.org/packages/51/de/8589fa724590faa057e5a6d171e7f2f6cffe3287406ef40e49c682c07d89/ruff-0.12.2-py3-none-win32.whl", hash = "sha256:369ffb69b70cd55b6c3fc453b9492d98aed98062db9fec828cdfd069555f5f1a", size = 10523823, upload_time = "2025-07-03T16:40:13.203Z" }, - { url = "https://files.pythonhosted.org/packages/94/47/8abf129102ae4c90cba0c2199a1a9b0fa896f6f806238d6f8c14448cc748/ruff-0.12.2-py3-none-win_amd64.whl", hash = "sha256:dca8a3b6d6dc9810ed8f328d406516bf4d660c00caeaef36eb831cf4871b0639", size = 11629831, upload_time = "2025-07-03T16:40:15.478Z" }, - { url = "https://files.pythonhosted.org/packages/e2/1f/72d2946e3cc7456bb837e88000eb3437e55f80db339c840c04015a11115d/ruff-0.12.2-py3-none-win_arm64.whl", hash = "sha256:48d6c6bfb4761df68bc05ae630e24f506755e702d4fb08f08460be778c7ccb12", size = 10735334, upload_time = "2025-07-03T16:40:17.677Z" }, -] - -[[package]] -name = "scikit-learn" -version = "1.7.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "joblib" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "scipy", version = "1.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "threadpoolctl" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/df/3b/29fa87e76b1d7b3b77cc1fcbe82e6e6b8cd704410705b008822de530277c/scikit_learn-1.7.0.tar.gz", hash = "sha256:c01e869b15aec88e2cdb73d27f15bdbe03bce8e2fb43afbe77c45d399e73a5a3", size = 7178217, upload_time = "2025-06-05T22:02:46.703Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a4/70/e725b1da11e7e833f558eb4d3ea8b7ed7100edda26101df074f1ae778235/scikit_learn-1.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9fe7f51435f49d97bd41d724bb3e11eeb939882af9c29c931a8002c357e8cdd5", size = 11728006, upload_time = "2025-06-05T22:01:43.007Z" }, - { url = "https://files.pythonhosted.org/packages/32/aa/43874d372e9dc51eb361f5c2f0a4462915c9454563b3abb0d9457c66b7e9/scikit_learn-1.7.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d0c93294e1e1acbee2d029b1f2a064f26bd928b284938d51d412c22e0c977eb3", size = 10726255, upload_time = "2025-06-05T22:01:46.082Z" }, - { url = "https://files.pythonhosted.org/packages/f5/1a/da73cc18e00f0b9ae89f7e4463a02fb6e0569778120aeab138d9554ecef0/scikit_learn-1.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf3755f25f145186ad8c403312f74fb90df82a4dfa1af19dc96ef35f57237a94", size = 12205657, upload_time = "2025-06-05T22:01:48.729Z" }, - { url = "https://files.pythonhosted.org/packages/fb/f6/800cb3243dd0137ca6d98df8c9d539eb567ba0a0a39ecd245c33fab93510/scikit_learn-1.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2726c8787933add436fb66fb63ad18e8ef342dfb39bbbd19dc1e83e8f828a85a", size = 12877290, upload_time = "2025-06-05T22:01:51.073Z" }, - { url = "https://files.pythonhosted.org/packages/4c/bd/99c3ccb49946bd06318fe194a1c54fb7d57ac4fe1c2f4660d86b3a2adf64/scikit_learn-1.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:e2539bb58886a531b6e86a510c0348afaadd25005604ad35966a85c2ec378800", size = 10713211, upload_time = "2025-06-05T22:01:54.107Z" }, - { url = "https://files.pythonhosted.org/packages/5a/42/c6b41711c2bee01c4800ad8da2862c0b6d2956a399d23ce4d77f2ca7f0c7/scikit_learn-1.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ef09b1615e1ad04dc0d0054ad50634514818a8eb3ee3dee99af3bffc0ef5007", size = 11719657, upload_time = "2025-06-05T22:01:56.345Z" }, - { url = "https://files.pythonhosted.org/packages/a3/24/44acca76449e391b6b2522e67a63c0454b7c1f060531bdc6d0118fb40851/scikit_learn-1.7.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:7d7240c7b19edf6ed93403f43b0fcb0fe95b53bc0b17821f8fb88edab97085ef", size = 10712636, upload_time = "2025-06-05T22:01:59.093Z" }, - { url = "https://files.pythonhosted.org/packages/9f/1b/fcad1ccb29bdc9b96bcaa2ed8345d56afb77b16c0c47bafe392cc5d1d213/scikit_learn-1.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:80bd3bd4e95381efc47073a720d4cbab485fc483966f1709f1fd559afac57ab8", size = 12242817, upload_time = "2025-06-05T22:02:01.43Z" }, - { url = "https://files.pythonhosted.org/packages/c6/38/48b75c3d8d268a3f19837cb8a89155ead6e97c6892bb64837183ea41db2b/scikit_learn-1.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9dbe48d69aa38ecfc5a6cda6c5df5abef0c0ebdb2468e92437e2053f84abb8bc", size = 12873961, upload_time = "2025-06-05T22:02:03.951Z" }, - { url = "https://files.pythonhosted.org/packages/f4/5a/ba91b8c57aa37dbd80d5ff958576a9a8c14317b04b671ae7f0d09b00993a/scikit_learn-1.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:8fa979313b2ffdfa049ed07252dc94038def3ecd49ea2a814db5401c07f1ecfa", size = 10717277, upload_time = "2025-06-05T22:02:06.77Z" }, - { url = "https://files.pythonhosted.org/packages/70/3a/bffab14e974a665a3ee2d79766e7389572ffcaad941a246931c824afcdb2/scikit_learn-1.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c2c7243d34aaede0efca7a5a96d67fddaebb4ad7e14a70991b9abee9dc5c0379", size = 11646758, upload_time = "2025-06-05T22:02:09.51Z" }, - { url = "https://files.pythonhosted.org/packages/58/d8/f3249232fa79a70cb40595282813e61453c1e76da3e1a44b77a63dd8d0cb/scikit_learn-1.7.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:9f39f6a811bf3f15177b66c82cbe0d7b1ebad9f190737dcdef77cfca1ea3c19c", size = 10673971, upload_time = "2025-06-05T22:02:12.217Z" }, - { url = "https://files.pythonhosted.org/packages/67/93/eb14c50533bea2f77758abe7d60a10057e5f2e2cdcf0a75a14c6bc19c734/scikit_learn-1.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63017a5f9a74963d24aac7590287149a8d0f1a0799bbe7173c0d8ba1523293c0", size = 11818428, upload_time = "2025-06-05T22:02:14.947Z" }, - { url = "https://files.pythonhosted.org/packages/08/17/804cc13b22a8663564bb0b55fb89e661a577e4e88a61a39740d58b909efe/scikit_learn-1.7.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b2f8a0b1e73e9a08b7cc498bb2aeab36cdc1f571f8ab2b35c6e5d1c7115d97d", size = 12505887, upload_time = "2025-06-05T22:02:17.824Z" }, - { url = "https://files.pythonhosted.org/packages/68/c7/4e956281a077f4835458c3f9656c666300282d5199039f26d9de1dabd9be/scikit_learn-1.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:34cc8d9d010d29fb2b7cbcd5ccc24ffdd80515f65fe9f1e4894ace36b267ce19", size = 10668129, upload_time = "2025-06-05T22:02:20.536Z" }, - { url = "https://files.pythonhosted.org/packages/9a/c3/a85dcccdaf1e807e6f067fa95788a6485b0491d9ea44fd4c812050d04f45/scikit_learn-1.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5b7974f1f32bc586c90145df51130e02267e4b7e77cab76165c76cf43faca0d9", size = 11559841, upload_time = "2025-06-05T22:02:23.308Z" }, - { url = "https://files.pythonhosted.org/packages/d8/57/eea0de1562cc52d3196eae51a68c5736a31949a465f0b6bb3579b2d80282/scikit_learn-1.7.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:014e07a23fe02e65f9392898143c542a50b6001dbe89cb867e19688e468d049b", size = 10616463, upload_time = "2025-06-05T22:02:26.068Z" }, - { url = "https://files.pythonhosted.org/packages/10/a4/39717ca669296dfc3a62928393168da88ac9d8cbec88b6321ffa62c6776f/scikit_learn-1.7.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e7e7ced20582d3a5516fb6f405fd1d254e1f5ce712bfef2589f51326af6346e8", size = 11766512, upload_time = "2025-06-05T22:02:28.689Z" }, - { url = "https://files.pythonhosted.org/packages/d5/cd/a19722241d5f7b51e08351e1e82453e0057aeb7621b17805f31fcb57bb6c/scikit_learn-1.7.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1babf2511e6ffd695da7a983b4e4d6de45dce39577b26b721610711081850906", size = 12461075, upload_time = "2025-06-05T22:02:31.233Z" }, - { url = "https://files.pythonhosted.org/packages/f3/bc/282514272815c827a9acacbe5b99f4f1a4bc5961053719d319480aee0812/scikit_learn-1.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:5abd2acff939d5bd4701283f009b01496832d50ddafa83c90125a4e41c33e314", size = 10652517, upload_time = "2025-06-05T22:02:34.139Z" }, - { url = "https://files.pythonhosted.org/packages/ea/78/7357d12b2e4c6674175f9a09a3ba10498cde8340e622715bcc71e532981d/scikit_learn-1.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:e39d95a929b112047c25b775035c8c234c5ca67e681ce60d12413afb501129f7", size = 12111822, upload_time = "2025-06-05T22:02:36.904Z" }, - { url = "https://files.pythonhosted.org/packages/d0/0c/9c3715393343f04232f9d81fe540eb3831d0b4ec351135a145855295110f/scikit_learn-1.7.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:0521cb460426c56fee7e07f9365b0f45ec8ca7b2d696534ac98bfb85e7ae4775", size = 11325286, upload_time = "2025-06-05T22:02:39.739Z" }, - { url = "https://files.pythonhosted.org/packages/64/e0/42282ad3dd70b7c1a5f65c412ac3841f6543502a8d6263cae7b466612dc9/scikit_learn-1.7.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:317ca9f83acbde2883bd6bb27116a741bfcb371369706b4f9973cf30e9a03b0d", size = 12380865, upload_time = "2025-06-05T22:02:42.137Z" }, - { url = "https://files.pythonhosted.org/packages/4e/d0/3ef4ab2c6be4aa910445cd09c5ef0b44512e3de2cfb2112a88bb647d2cf7/scikit_learn-1.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:126c09740a6f016e815ab985b21e3a0656835414521c81fc1a8da78b679bdb75", size = 11549609, upload_time = "2025-06-05T22:02:44.483Z" }, -] - -[[package]] -name = "scipy" -version = "1.15.3" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.11'", -] -dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload_time = "2025-05-08T16:13:05.955Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/78/2f/4966032c5f8cc7e6a60f1b2e0ad686293b9474b65246b0c642e3ef3badd0/scipy-1.15.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c", size = 38702770, upload_time = "2025-05-08T16:04:20.849Z" }, - { url = "https://files.pythonhosted.org/packages/a0/6e/0c3bf90fae0e910c274db43304ebe25a6b391327f3f10b5dcc638c090795/scipy-1.15.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253", size = 30094511, upload_time = "2025-05-08T16:04:27.103Z" }, - { url = "https://files.pythonhosted.org/packages/ea/b1/4deb37252311c1acff7f101f6453f0440794f51b6eacb1aad4459a134081/scipy-1.15.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f", size = 22368151, upload_time = "2025-05-08T16:04:31.731Z" }, - { url = "https://files.pythonhosted.org/packages/38/7d/f457626e3cd3c29b3a49ca115a304cebb8cc6f31b04678f03b216899d3c6/scipy-1.15.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92", size = 25121732, upload_time = "2025-05-08T16:04:36.596Z" }, - { url = "https://files.pythonhosted.org/packages/db/0a/92b1de4a7adc7a15dcf5bddc6e191f6f29ee663b30511ce20467ef9b82e4/scipy-1.15.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82", size = 35547617, upload_time = "2025-05-08T16:04:43.546Z" }, - { url = "https://files.pythonhosted.org/packages/8e/6d/41991e503e51fc1134502694c5fa7a1671501a17ffa12716a4a9151af3df/scipy-1.15.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40", size = 37662964, upload_time = "2025-05-08T16:04:49.431Z" }, - { url = "https://files.pythonhosted.org/packages/25/e1/3df8f83cb15f3500478c889be8fb18700813b95e9e087328230b98d547ff/scipy-1.15.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e", size = 37238749, upload_time = "2025-05-08T16:04:55.215Z" }, - { url = "https://files.pythonhosted.org/packages/93/3e/b3257cf446f2a3533ed7809757039016b74cd6f38271de91682aa844cfc5/scipy-1.15.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c", size = 40022383, upload_time = "2025-05-08T16:05:01.914Z" }, - { url = "https://files.pythonhosted.org/packages/d1/84/55bc4881973d3f79b479a5a2e2df61c8c9a04fcb986a213ac9c02cfb659b/scipy-1.15.3-cp310-cp310-win_amd64.whl", hash = "sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13", size = 41259201, upload_time = "2025-05-08T16:05:08.166Z" }, - { url = "https://files.pythonhosted.org/packages/96/ab/5cc9f80f28f6a7dff646c5756e559823614a42b1939d86dd0ed550470210/scipy-1.15.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b", size = 38714255, upload_time = "2025-05-08T16:05:14.596Z" }, - { url = "https://files.pythonhosted.org/packages/4a/4a/66ba30abe5ad1a3ad15bfb0b59d22174012e8056ff448cb1644deccbfed2/scipy-1.15.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba", size = 30111035, upload_time = "2025-05-08T16:05:20.152Z" }, - { url = "https://files.pythonhosted.org/packages/4b/fa/a7e5b95afd80d24313307f03624acc65801846fa75599034f8ceb9e2cbf6/scipy-1.15.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65", size = 22384499, upload_time = "2025-05-08T16:05:24.494Z" }, - { url = "https://files.pythonhosted.org/packages/17/99/f3aaddccf3588bb4aea70ba35328c204cadd89517a1612ecfda5b2dd9d7a/scipy-1.15.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1", size = 25152602, upload_time = "2025-05-08T16:05:29.313Z" }, - { url = "https://files.pythonhosted.org/packages/56/c5/1032cdb565f146109212153339f9cb8b993701e9fe56b1c97699eee12586/scipy-1.15.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889", size = 35503415, upload_time = "2025-05-08T16:05:34.699Z" }, - { url = "https://files.pythonhosted.org/packages/bd/37/89f19c8c05505d0601ed5650156e50eb881ae3918786c8fd7262b4ee66d3/scipy-1.15.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982", size = 37652622, upload_time = "2025-05-08T16:05:40.762Z" }, - { url = "https://files.pythonhosted.org/packages/7e/31/be59513aa9695519b18e1851bb9e487de66f2d31f835201f1b42f5d4d475/scipy-1.15.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9", size = 37244796, upload_time = "2025-05-08T16:05:48.119Z" }, - { url = "https://files.pythonhosted.org/packages/10/c0/4f5f3eeccc235632aab79b27a74a9130c6c35df358129f7ac8b29f562ac7/scipy-1.15.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594", size = 40047684, upload_time = "2025-05-08T16:05:54.22Z" }, - { url = "https://files.pythonhosted.org/packages/ab/a7/0ddaf514ce8a8714f6ed243a2b391b41dbb65251affe21ee3077ec45ea9a/scipy-1.15.3-cp311-cp311-win_amd64.whl", hash = "sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb", size = 41246504, upload_time = "2025-05-08T16:06:00.437Z" }, - { url = "https://files.pythonhosted.org/packages/37/4b/683aa044c4162e10ed7a7ea30527f2cbd92e6999c10a8ed8edb253836e9c/scipy-1.15.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac6310fdbfb7aa6612408bd2f07295bcbd3fda00d2d702178434751fe48e019", size = 38766735, upload_time = "2025-05-08T16:06:06.471Z" }, - { url = "https://files.pythonhosted.org/packages/7b/7e/f30be3d03de07f25dc0ec926d1681fed5c732d759ac8f51079708c79e680/scipy-1.15.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:185cd3d6d05ca4b44a8f1595af87f9c372bb6acf9c808e99aa3e9aa03bd98cf6", size = 30173284, upload_time = "2025-05-08T16:06:11.686Z" }, - { url = "https://files.pythonhosted.org/packages/07/9c/0ddb0d0abdabe0d181c1793db51f02cd59e4901da6f9f7848e1f96759f0d/scipy-1.15.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05dc6abcd105e1a29f95eada46d4a3f251743cfd7d3ae8ddb4088047f24ea477", size = 22446958, upload_time = "2025-05-08T16:06:15.97Z" }, - { url = "https://files.pythonhosted.org/packages/af/43/0bce905a965f36c58ff80d8bea33f1f9351b05fad4beaad4eae34699b7a1/scipy-1.15.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:06efcba926324df1696931a57a176c80848ccd67ce6ad020c810736bfd58eb1c", size = 25242454, upload_time = "2025-05-08T16:06:20.394Z" }, - { url = "https://files.pythonhosted.org/packages/56/30/a6f08f84ee5b7b28b4c597aca4cbe545535c39fe911845a96414700b64ba/scipy-1.15.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05045d8b9bfd807ee1b9f38761993297b10b245f012b11b13b91ba8945f7e45", size = 35210199, upload_time = "2025-05-08T16:06:26.159Z" }, - { url = "https://files.pythonhosted.org/packages/0b/1f/03f52c282437a168ee2c7c14a1a0d0781a9a4a8962d84ac05c06b4c5b555/scipy-1.15.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:271e3713e645149ea5ea3e97b57fdab61ce61333f97cfae392c28ba786f9bb49", size = 37309455, upload_time = "2025-05-08T16:06:32.778Z" }, - { url = "https://files.pythonhosted.org/packages/89/b1/fbb53137f42c4bf630b1ffdfc2151a62d1d1b903b249f030d2b1c0280af8/scipy-1.15.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6cfd56fc1a8e53f6e89ba3a7a7251f7396412d655bca2aa5611c8ec9a6784a1e", size = 36885140, upload_time = "2025-05-08T16:06:39.249Z" }, - { url = "https://files.pythonhosted.org/packages/2e/2e/025e39e339f5090df1ff266d021892694dbb7e63568edcfe43f892fa381d/scipy-1.15.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ff17c0bb1cb32952c09217d8d1eed9b53d1463e5f1dd6052c7857f83127d539", size = 39710549, upload_time = "2025-05-08T16:06:45.729Z" }, - { url = "https://files.pythonhosted.org/packages/e6/eb/3bf6ea8ab7f1503dca3a10df2e4b9c3f6b3316df07f6c0ded94b281c7101/scipy-1.15.3-cp312-cp312-win_amd64.whl", hash = "sha256:52092bc0472cfd17df49ff17e70624345efece4e1a12b23783a1ac59a1b728ed", size = 40966184, upload_time = "2025-05-08T16:06:52.623Z" }, - { url = "https://files.pythonhosted.org/packages/73/18/ec27848c9baae6e0d6573eda6e01a602e5649ee72c27c3a8aad673ebecfd/scipy-1.15.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c620736bcc334782e24d173c0fdbb7590a0a436d2fdf39310a8902505008759", size = 38728256, upload_time = "2025-05-08T16:06:58.696Z" }, - { url = "https://files.pythonhosted.org/packages/74/cd/1aef2184948728b4b6e21267d53b3339762c285a46a274ebb7863c9e4742/scipy-1.15.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:7e11270a000969409d37ed399585ee530b9ef6aa99d50c019de4cb01e8e54e62", size = 30109540, upload_time = "2025-05-08T16:07:04.209Z" }, - { url = "https://files.pythonhosted.org/packages/5b/d8/59e452c0a255ec352bd0a833537a3bc1bfb679944c4938ab375b0a6b3a3e/scipy-1.15.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8c9ed3ba2c8a2ce098163a9bdb26f891746d02136995df25227a20e71c396ebb", size = 22383115, upload_time = "2025-05-08T16:07:08.998Z" }, - { url = "https://files.pythonhosted.org/packages/08/f5/456f56bbbfccf696263b47095291040655e3cbaf05d063bdc7c7517f32ac/scipy-1.15.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0bdd905264c0c9cfa74a4772cdb2070171790381a5c4d312c973382fc6eaf730", size = 25163884, upload_time = "2025-05-08T16:07:14.091Z" }, - { url = "https://files.pythonhosted.org/packages/a2/66/a9618b6a435a0f0c0b8a6d0a2efb32d4ec5a85f023c2b79d39512040355b/scipy-1.15.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79167bba085c31f38603e11a267d862957cbb3ce018d8b38f79ac043bc92d825", size = 35174018, upload_time = "2025-05-08T16:07:19.427Z" }, - { url = "https://files.pythonhosted.org/packages/b5/09/c5b6734a50ad4882432b6bb7c02baf757f5b2f256041da5df242e2d7e6b6/scipy-1.15.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9deabd6d547aee2c9a81dee6cc96c6d7e9a9b1953f74850c179f91fdc729cb7", size = 37269716, upload_time = "2025-05-08T16:07:25.712Z" }, - { url = "https://files.pythonhosted.org/packages/77/0a/eac00ff741f23bcabd352731ed9b8995a0a60ef57f5fd788d611d43d69a1/scipy-1.15.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dde4fc32993071ac0c7dd2d82569e544f0bdaff66269cb475e0f369adad13f11", size = 36872342, upload_time = "2025-05-08T16:07:31.468Z" }, - { url = "https://files.pythonhosted.org/packages/fe/54/4379be86dd74b6ad81551689107360d9a3e18f24d20767a2d5b9253a3f0a/scipy-1.15.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f77f853d584e72e874d87357ad70f44b437331507d1c311457bed8ed2b956126", size = 39670869, upload_time = "2025-05-08T16:07:38.002Z" }, - { url = "https://files.pythonhosted.org/packages/87/2e/892ad2862ba54f084ffe8cc4a22667eaf9c2bcec6d2bff1d15713c6c0703/scipy-1.15.3-cp313-cp313-win_amd64.whl", hash = "sha256:b90ab29d0c37ec9bf55424c064312930ca5f4bde15ee8619ee44e69319aab163", size = 40988851, upload_time = "2025-05-08T16:08:33.671Z" }, - { url = "https://files.pythonhosted.org/packages/1b/e9/7a879c137f7e55b30d75d90ce3eb468197646bc7b443ac036ae3fe109055/scipy-1.15.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3ac07623267feb3ae308487c260ac684b32ea35fd81e12845039952f558047b8", size = 38863011, upload_time = "2025-05-08T16:07:44.039Z" }, - { url = "https://files.pythonhosted.org/packages/51/d1/226a806bbd69f62ce5ef5f3ffadc35286e9fbc802f606a07eb83bf2359de/scipy-1.15.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:6487aa99c2a3d509a5227d9a5e889ff05830a06b2ce08ec30df6d79db5fcd5c5", size = 30266407, upload_time = "2025-05-08T16:07:49.891Z" }, - { url = "https://files.pythonhosted.org/packages/e5/9b/f32d1d6093ab9eeabbd839b0f7619c62e46cc4b7b6dbf05b6e615bbd4400/scipy-1.15.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:50f9e62461c95d933d5c5ef4a1f2ebf9a2b4e83b0db374cb3f1de104d935922e", size = 22540030, upload_time = "2025-05-08T16:07:54.121Z" }, - { url = "https://files.pythonhosted.org/packages/e7/29/c278f699b095c1a884f29fda126340fcc201461ee8bfea5c8bdb1c7c958b/scipy-1.15.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:14ed70039d182f411ffc74789a16df3835e05dc469b898233a245cdfd7f162cb", size = 25218709, upload_time = "2025-05-08T16:07:58.506Z" }, - { url = "https://files.pythonhosted.org/packages/24/18/9e5374b617aba742a990581373cd6b68a2945d65cc588482749ef2e64467/scipy-1.15.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a769105537aa07a69468a0eefcd121be52006db61cdd8cac8a0e68980bbb723", size = 34809045, upload_time = "2025-05-08T16:08:03.929Z" }, - { url = "https://files.pythonhosted.org/packages/e1/fe/9c4361e7ba2927074360856db6135ef4904d505e9b3afbbcb073c4008328/scipy-1.15.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9db984639887e3dffb3928d118145ffe40eff2fa40cb241a306ec57c219ebbbb", size = 36703062, upload_time = "2025-05-08T16:08:09.558Z" }, - { url = "https://files.pythonhosted.org/packages/b7/8e/038ccfe29d272b30086b25a4960f757f97122cb2ec42e62b460d02fe98e9/scipy-1.15.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:40e54d5c7e7ebf1aa596c374c49fa3135f04648a0caabcb66c52884b943f02b4", size = 36393132, upload_time = "2025-05-08T16:08:15.34Z" }, - { url = "https://files.pythonhosted.org/packages/10/7e/5c12285452970be5bdbe8352c619250b97ebf7917d7a9a9e96b8a8140f17/scipy-1.15.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5e721fed53187e71d0ccf382b6bf977644c533e506c4d33c3fb24de89f5c3ed5", size = 38979503, upload_time = "2025-05-08T16:08:21.513Z" }, - { url = "https://files.pythonhosted.org/packages/81/06/0a5e5349474e1cbc5757975b21bd4fad0e72ebf138c5592f191646154e06/scipy-1.15.3-cp313-cp313t-win_amd64.whl", hash = "sha256:76ad1fb5f8752eabf0fa02e4cc0336b4e8f021e2d5f061ed37d6d264db35e3ca", size = 40308097, upload_time = "2025-05-08T16:08:27.627Z" }, -] - -[[package]] -name = "scipy" -version = "1.16.0" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", -] -dependencies = [ - { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/81/18/b06a83f0c5ee8cddbde5e3f3d0bb9b702abfa5136ef6d4620ff67df7eee5/scipy-1.16.0.tar.gz", hash = "sha256:b5ef54021e832869c8cfb03bc3bf20366cbcd426e02a58e8a58d7584dfbb8f62", size = 30581216, upload_time = "2025-06-22T16:27:55.782Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d9/f8/53fc4884df6b88afd5f5f00240bdc49fee2999c7eff3acf5953eb15bc6f8/scipy-1.16.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:deec06d831b8f6b5fb0b652433be6a09db29e996368ce5911faf673e78d20085", size = 36447362, upload_time = "2025-06-22T16:18:17.817Z" }, - { url = "https://files.pythonhosted.org/packages/c9/25/fad8aa228fa828705142a275fc593d701b1817c98361a2d6b526167d07bc/scipy-1.16.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:d30c0fe579bb901c61ab4bb7f3eeb7281f0d4c4a7b52dbf563c89da4fd2949be", size = 28547120, upload_time = "2025-06-22T16:18:24.117Z" }, - { url = "https://files.pythonhosted.org/packages/8d/be/d324ddf6b89fd1c32fecc307f04d095ce84abb52d2e88fab29d0cd8dc7a8/scipy-1.16.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:b2243561b45257f7391d0f49972fca90d46b79b8dbcb9b2cb0f9df928d370ad4", size = 20818922, upload_time = "2025-06-22T16:18:28.035Z" }, - { url = "https://files.pythonhosted.org/packages/cd/e0/cf3f39e399ac83fd0f3ba81ccc5438baba7cfe02176be0da55ff3396f126/scipy-1.16.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:e6d7dfc148135e9712d87c5f7e4f2ddc1304d1582cb3a7d698bbadedb61c7afd", size = 23409695, upload_time = "2025-06-22T16:18:32.497Z" }, - { url = "https://files.pythonhosted.org/packages/5b/61/d92714489c511d3ffd6830ac0eb7f74f243679119eed8b9048e56b9525a1/scipy-1.16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:90452f6a9f3fe5a2cf3748e7be14f9cc7d9b124dce19667b54f5b429d680d539", size = 33444586, upload_time = "2025-06-22T16:18:37.992Z" }, - { url = "https://files.pythonhosted.org/packages/af/2c/40108915fd340c830aee332bb85a9160f99e90893e58008b659b9f3dddc0/scipy-1.16.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a2f0bf2f58031c8701a8b601df41701d2a7be17c7ffac0a4816aeba89c4cdac8", size = 35284126, upload_time = "2025-06-22T16:18:43.605Z" }, - { url = "https://files.pythonhosted.org/packages/d3/30/e9eb0ad3d0858df35d6c703cba0a7e16a18a56a9e6b211d861fc6f261c5f/scipy-1.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c4abb4c11fc0b857474241b812ce69ffa6464b4bd8f4ecb786cf240367a36a7", size = 35608257, upload_time = "2025-06-22T16:18:49.09Z" }, - { url = "https://files.pythonhosted.org/packages/c8/ff/950ee3e0d612b375110d8cda211c1f787764b4c75e418a4b71f4a5b1e07f/scipy-1.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b370f8f6ac6ef99815b0d5c9f02e7ade77b33007d74802efc8316c8db98fd11e", size = 38040541, upload_time = "2025-06-22T16:18:55.077Z" }, - { url = "https://files.pythonhosted.org/packages/8b/c9/750d34788288d64ffbc94fdb4562f40f609d3f5ef27ab4f3a4ad00c9033e/scipy-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:a16ba90847249bedce8aa404a83fb8334b825ec4a8e742ce6012a7a5e639f95c", size = 38570814, upload_time = "2025-06-22T16:19:00.912Z" }, - { url = "https://files.pythonhosted.org/packages/01/c0/c943bc8d2bbd28123ad0f4f1eef62525fa1723e84d136b32965dcb6bad3a/scipy-1.16.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:7eb6bd33cef4afb9fa5f1fb25df8feeb1e52d94f21a44f1d17805b41b1da3180", size = 36459071, upload_time = "2025-06-22T16:19:06.605Z" }, - { url = "https://files.pythonhosted.org/packages/99/0d/270e2e9f1a4db6ffbf84c9a0b648499842046e4e0d9b2275d150711b3aba/scipy-1.16.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:1dbc8fdba23e4d80394ddfab7a56808e3e6489176d559c6c71935b11a2d59db1", size = 28490500, upload_time = "2025-06-22T16:19:11.775Z" }, - { url = "https://files.pythonhosted.org/packages/1c/22/01d7ddb07cff937d4326198ec8d10831367a708c3da72dfd9b7ceaf13028/scipy-1.16.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:7dcf42c380e1e3737b343dec21095c9a9ad3f9cbe06f9c05830b44b1786c9e90", size = 20762345, upload_time = "2025-06-22T16:19:15.813Z" }, - { url = "https://files.pythonhosted.org/packages/34/7f/87fd69856569ccdd2a5873fe5d7b5bbf2ad9289d7311d6a3605ebde3a94b/scipy-1.16.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:26ec28675f4a9d41587266084c626b02899db373717d9312fa96ab17ca1ae94d", size = 23418563, upload_time = "2025-06-22T16:19:20.746Z" }, - { url = "https://files.pythonhosted.org/packages/f6/f1/e4f4324fef7f54160ab749efbab6a4bf43678a9eb2e9817ed71a0a2fd8de/scipy-1.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:952358b7e58bd3197cfbd2f2f2ba829f258404bdf5db59514b515a8fe7a36c52", size = 33203951, upload_time = "2025-06-22T16:19:25.813Z" }, - { url = "https://files.pythonhosted.org/packages/6d/f0/b6ac354a956384fd8abee2debbb624648125b298f2c4a7b4f0d6248048a5/scipy-1.16.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03931b4e870c6fef5b5c0970d52c9f6ddd8c8d3e934a98f09308377eba6f3824", size = 35070225, upload_time = "2025-06-22T16:19:31.416Z" }, - { url = "https://files.pythonhosted.org/packages/e5/73/5cbe4a3fd4bc3e2d67ffad02c88b83edc88f381b73ab982f48f3df1a7790/scipy-1.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:512c4f4f85912767c351a0306824ccca6fd91307a9f4318efe8fdbd9d30562ef", size = 35389070, upload_time = "2025-06-22T16:19:37.387Z" }, - { url = "https://files.pythonhosted.org/packages/86/e8/a60da80ab9ed68b31ea5a9c6dfd3c2f199347429f229bf7f939a90d96383/scipy-1.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e69f798847e9add03d512eaf5081a9a5c9a98757d12e52e6186ed9681247a1ac", size = 37825287, upload_time = "2025-06-22T16:19:43.375Z" }, - { url = "https://files.pythonhosted.org/packages/ea/b5/29fece1a74c6a94247f8a6fb93f5b28b533338e9c34fdcc9cfe7a939a767/scipy-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:adf9b1999323ba335adc5d1dc7add4781cb5a4b0ef1e98b79768c05c796c4e49", size = 38431929, upload_time = "2025-06-22T16:19:49.385Z" }, - { url = "https://files.pythonhosted.org/packages/46/95/0746417bc24be0c2a7b7563946d61f670a3b491b76adede420e9d173841f/scipy-1.16.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:e9f414cbe9ca289a73e0cc92e33a6a791469b6619c240aa32ee18abdce8ab451", size = 36418162, upload_time = "2025-06-22T16:19:56.3Z" }, - { url = "https://files.pythonhosted.org/packages/19/5a/914355a74481b8e4bbccf67259bbde171348a3f160b67b4945fbc5f5c1e5/scipy-1.16.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:bbba55fb97ba3cdef9b1ee973f06b09d518c0c7c66a009c729c7d1592be1935e", size = 28465985, upload_time = "2025-06-22T16:20:01.238Z" }, - { url = "https://files.pythonhosted.org/packages/58/46/63477fc1246063855969cbefdcee8c648ba4b17f67370bd542ba56368d0b/scipy-1.16.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:58e0d4354eacb6004e7aa1cd350e5514bd0270acaa8d5b36c0627bb3bb486974", size = 20737961, upload_time = "2025-06-22T16:20:05.913Z" }, - { url = "https://files.pythonhosted.org/packages/93/86/0fbb5588b73555e40f9d3d6dde24ee6fac7d8e301a27f6f0cab9d8f66ff2/scipy-1.16.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:75b2094ec975c80efc273567436e16bb794660509c12c6a31eb5c195cbf4b6dc", size = 23377941, upload_time = "2025-06-22T16:20:10.668Z" }, - { url = "https://files.pythonhosted.org/packages/ca/80/a561f2bf4c2da89fa631b3cbf31d120e21ea95db71fd9ec00cb0247c7a93/scipy-1.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6b65d232157a380fdd11a560e7e21cde34fdb69d65c09cb87f6cc024ee376351", size = 33196703, upload_time = "2025-06-22T16:20:16.097Z" }, - { url = "https://files.pythonhosted.org/packages/11/6b/3443abcd0707d52e48eb315e33cc669a95e29fc102229919646f5a501171/scipy-1.16.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d8747f7736accd39289943f7fe53a8333be7f15a82eea08e4afe47d79568c32", size = 35083410, upload_time = "2025-06-22T16:20:21.734Z" }, - { url = "https://files.pythonhosted.org/packages/20/ab/eb0fc00e1e48961f1bd69b7ad7e7266896fe5bad4ead91b5fc6b3561bba4/scipy-1.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb9f147a1b8529bb7fec2a85cf4cf42bdfadf9e83535c309a11fdae598c88e8b", size = 35387829, upload_time = "2025-06-22T16:20:27.548Z" }, - { url = "https://files.pythonhosted.org/packages/57/9e/d6fc64e41fad5d481c029ee5a49eefc17f0b8071d636a02ceee44d4a0de2/scipy-1.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d2b83c37edbfa837a8923d19c749c1935ad3d41cf196006a24ed44dba2ec4358", size = 37841356, upload_time = "2025-06-22T16:20:35.112Z" }, - { url = "https://files.pythonhosted.org/packages/7c/a7/4c94bbe91f12126b8bf6709b2471900577b7373a4fd1f431f28ba6f81115/scipy-1.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:79a3c13d43c95aa80b87328a46031cf52508cf5f4df2767602c984ed1d3c6bbe", size = 38403710, upload_time = "2025-06-22T16:21:54.473Z" }, - { url = "https://files.pythonhosted.org/packages/47/20/965da8497f6226e8fa90ad3447b82ed0e28d942532e92dd8b91b43f100d4/scipy-1.16.0-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:f91b87e1689f0370690e8470916fe1b2308e5b2061317ff76977c8f836452a47", size = 36813833, upload_time = "2025-06-22T16:20:43.925Z" }, - { url = "https://files.pythonhosted.org/packages/28/f4/197580c3dac2d234e948806e164601c2df6f0078ed9f5ad4a62685b7c331/scipy-1.16.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:88a6ca658fb94640079e7a50b2ad3b67e33ef0f40e70bdb7dc22017dae73ac08", size = 28974431, upload_time = "2025-06-22T16:20:51.302Z" }, - { url = "https://files.pythonhosted.org/packages/8a/fc/e18b8550048d9224426e76906694c60028dbdb65d28b1372b5503914b89d/scipy-1.16.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:ae902626972f1bd7e4e86f58fd72322d7f4ec7b0cfc17b15d4b7006efc385176", size = 21246454, upload_time = "2025-06-22T16:20:57.276Z" }, - { url = "https://files.pythonhosted.org/packages/8c/48/07b97d167e0d6a324bfd7484cd0c209cc27338b67e5deadae578cf48e809/scipy-1.16.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:8cb824c1fc75ef29893bc32b3ddd7b11cf9ab13c1127fe26413a05953b8c32ed", size = 23772979, upload_time = "2025-06-22T16:21:03.363Z" }, - { url = "https://files.pythonhosted.org/packages/4c/4f/9efbd3f70baf9582edf271db3002b7882c875ddd37dc97f0f675ad68679f/scipy-1.16.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:de2db7250ff6514366a9709c2cba35cb6d08498e961cba20d7cff98a7ee88938", size = 33341972, upload_time = "2025-06-22T16:21:11.14Z" }, - { url = "https://files.pythonhosted.org/packages/3f/dc/9e496a3c5dbe24e76ee24525155ab7f659c20180bab058ef2c5fa7d9119c/scipy-1.16.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e85800274edf4db8dd2e4e93034f92d1b05c9421220e7ded9988b16976f849c1", size = 35185476, upload_time = "2025-06-22T16:21:19.156Z" }, - { url = "https://files.pythonhosted.org/packages/ce/b3/21001cff985a122ba434c33f2c9d7d1dc3b669827e94f4fc4e1fe8b9dfd8/scipy-1.16.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4f720300a3024c237ace1cb11f9a84c38beb19616ba7c4cdcd771047a10a1706", size = 35570990, upload_time = "2025-06-22T16:21:27.797Z" }, - { url = "https://files.pythonhosted.org/packages/e5/d3/7ba42647d6709251cdf97043d0c107e0317e152fa2f76873b656b509ff55/scipy-1.16.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:aad603e9339ddb676409b104c48a027e9916ce0d2838830691f39552b38a352e", size = 37950262, upload_time = "2025-06-22T16:21:36.976Z" }, - { url = "https://files.pythonhosted.org/packages/eb/c4/231cac7a8385394ebbbb4f1ca662203e9d8c332825ab4f36ffc3ead09a42/scipy-1.16.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f56296fefca67ba605fd74d12f7bd23636267731a72cb3947963e76b8c0a25db", size = 38515076, upload_time = "2025-06-22T16:21:45.694Z" }, -] - -[[package]] -name = "seaborn" -version = "0.13.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "matplotlib" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "pandas" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload_time = "2024-01-25T13:21:52.551Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload_time = "2024-01-25T13:21:49.598Z" }, -] - -[[package]] -name = "setuptools" -version = "80.9.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload_time = "2025-05-27T00:56:51.443Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload_time = "2025-05-27T00:56:49.664Z" }, -] - -[[package]] -name = "six" -version = "1.17.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload_time = "2024-12-04T17:35:28.174Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload_time = "2024-12-04T17:35:26.475Z" }, -] - -[[package]] -name = "sniffio" -version = "1.3.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload_time = "2024-02-25T23:20:04.057Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload_time = "2024-02-25T23:20:01.196Z" }, -] - -[[package]] -name = "starlette" -version = "0.46.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ce/20/08dfcd9c983f6a6f4a1000d934b9e6d626cff8d2eeb77a89a68eef20a2b7/starlette-0.46.2.tar.gz", hash = "sha256:7f7361f34eed179294600af672f565727419830b54b7b084efe44bb82d2fccd5", size = 2580846, upload_time = "2025-04-13T13:56:17.942Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8b/0c/9d30a4ebeb6db2b25a841afbb80f6ef9a854fc3b41be131d249a977b4959/starlette-0.46.2-py3-none-any.whl", hash = "sha256:595633ce89f8ffa71a015caed34a5b2dc1c0cdb3f0f1fbd1e69339cf2abeec35", size = 72037, upload_time = "2025-04-13T13:56:16.21Z" }, -] - -[[package]] -name = "strawberry-graphql" -version = "0.275.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "graphql-core" }, - { name = "packaging" }, - { name = "python-dateutil" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/67/52/8a317305bb3e484c4850befefe655069c51ff8a9fa7b30e96f6fd68e6203/strawberry_graphql-0.275.5.tar.gz", hash = "sha256:080518de70b82c04a1f2d6118f268fadde45b985821e20e1550e3281afdecc41", size = 209640, upload_time = "2025-06-26T22:38:51.863Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/17/1c/6b9727656968e6460fd22cdaedd1e309e26fa313053ed9bbdf1aee45082b/strawberry_graphql-0.275.5-py3-none-any.whl", hash = "sha256:b1d2c7c6febb5f8bd5bc9f3059d23f527f61f7a9fb6f7f24f4c5a7771dba7050", size = 306274, upload_time = "2025-06-26T22:38:49.05Z" }, -] - -[package.optional-dependencies] -fastapi = [ - { name = "fastapi" }, - { name = "python-multipart" }, -] - -[[package]] -name = "structlog" -version = "25.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/79/b9/6e672db4fec07349e7a8a8172c1a6ae235c58679ca29c3f86a61b5e59ff3/structlog-25.4.0.tar.gz", hash = "sha256:186cd1b0a8ae762e29417095664adf1d6a31702160a46dacb7796ea82f7409e4", size = 1369138, upload_time = "2025-06-02T08:21:12.971Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/4a/97ee6973e3a73c74c8120d59829c3861ea52210667ec3e7a16045c62b64d/structlog-25.4.0-py3-none-any.whl", hash = "sha256:fe809ff5c27e557d14e613f45ca441aabda051d119ee5a0102aaba6ce40eed2c", size = 68720, upload_time = "2025-06-02T08:21:11.43Z" }, -] - -[[package]] -name = "texttable" -version = "1.7.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1c/dc/0aff23d6036a4d3bf4f1d8c8204c5c79c4437e25e0ae94ffe4bbb55ee3c2/texttable-1.7.0.tar.gz", hash = "sha256:2d2068fb55115807d3ac77a4ca68fa48803e84ebb0ee2340f858107a36522638", size = 12831, upload_time = "2023-10-03T09:48:12.272Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/24/99/4772b8e00a136f3e01236de33b0efda31ee7077203ba5967fcc76da94d65/texttable-1.7.0-py2.py3-none-any.whl", hash = "sha256:72227d592c82b3d7f672731ae73e4d1f88cd8e2ef5b075a7a7f01a23a3743917", size = 10768, upload_time = "2023-10-03T09:48:10.434Z" }, -] - -[[package]] -name = "threadpoolctl" -version = "3.6.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload_time = "2025-03-13T13:49:23.031Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload_time = "2025-03-13T13:49:21.846Z" }, -] - -[[package]] -name = "toml" -version = "0.10.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload_time = "2020-11-01T01:40:22.204Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload_time = "2020-11-01T01:40:20.672Z" }, -] - -[[package]] -name = "tomli" -version = "2.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175, upload_time = "2024-11-27T22:38:36.873Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077, upload_time = "2024-11-27T22:37:54.956Z" }, - { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429, upload_time = "2024-11-27T22:37:56.698Z" }, - { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067, upload_time = "2024-11-27T22:37:57.63Z" }, - { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030, upload_time = "2024-11-27T22:37:59.344Z" }, - { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898, upload_time = "2024-11-27T22:38:00.429Z" }, - { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894, upload_time = "2024-11-27T22:38:02.094Z" }, - { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319, upload_time = "2024-11-27T22:38:03.206Z" }, - { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273, upload_time = "2024-11-27T22:38:04.217Z" }, - { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310, upload_time = "2024-11-27T22:38:05.908Z" }, - { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309, upload_time = "2024-11-27T22:38:06.812Z" }, - { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762, upload_time = "2024-11-27T22:38:07.731Z" }, - { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453, upload_time = "2024-11-27T22:38:09.384Z" }, - { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486, upload_time = "2024-11-27T22:38:10.329Z" }, - { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349, upload_time = "2024-11-27T22:38:11.443Z" }, - { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159, upload_time = "2024-11-27T22:38:13.099Z" }, - { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243, upload_time = "2024-11-27T22:38:14.766Z" }, - { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645, upload_time = "2024-11-27T22:38:15.843Z" }, - { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584, upload_time = "2024-11-27T22:38:17.645Z" }, - { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875, upload_time = "2024-11-27T22:38:19.159Z" }, - { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418, upload_time = "2024-11-27T22:38:20.064Z" }, - { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708, upload_time = "2024-11-27T22:38:21.659Z" }, - { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582, upload_time = "2024-11-27T22:38:22.693Z" }, - { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543, upload_time = "2024-11-27T22:38:24.367Z" }, - { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691, upload_time = "2024-11-27T22:38:26.081Z" }, - { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170, upload_time = "2024-11-27T22:38:27.921Z" }, - { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530, upload_time = "2024-11-27T22:38:29.591Z" }, - { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666, upload_time = "2024-11-27T22:38:30.639Z" }, - { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954, upload_time = "2024-11-27T22:38:31.702Z" }, - { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724, upload_time = "2024-11-27T22:38:32.837Z" }, - { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383, upload_time = "2024-11-27T22:38:34.455Z" }, - { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload_time = "2024-11-27T22:38:35.385Z" }, -] - -[[package]] -name = "tomli-w" -version = "1.2.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload_time = "2025-01-15T12:07:24.262Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload_time = "2025-01-15T12:07:22.074Z" }, -] - -[[package]] -name = "tomlkit" -version = "0.13.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/cc/18/0bbf3884e9eaa38819ebe46a7bd25dcd56b67434402b66a58c4b8e552575/tomlkit-0.13.3.tar.gz", hash = "sha256:430cf247ee57df2b94ee3fbe588e71d362a941ebb545dec29b53961d61add2a1", size = 185207, upload_time = "2025-06-05T07:13:44.947Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/75/8539d011f6be8e29f339c42e633aae3cb73bffa95dd0f9adec09b9c58e85/tomlkit-0.13.3-py3-none-any.whl", hash = "sha256:c89c649d79ee40629a9fda55f8ace8c6a1b42deb912b2a8fd8d942ddadb606b0", size = 38901, upload_time = "2025-06-05T07:13:43.546Z" }, -] - -[[package]] -name = "tqdm" -version = "4.67.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload_time = "2024-11-24T20:12:22.481Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload_time = "2024-11-24T20:12:19.698Z" }, -] - -[[package]] -name = "typing-extensions" -version = "4.14.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/98/5a/da40306b885cc8c09109dc2e1abd358d5684b1425678151cdaed4731c822/typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36", size = 107673, upload_time = "2025-07-04T13:28:34.16Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b5/00/d631e67a838026495268c2f6884f3711a15a9a2a96cd244fdaea53b823fb/typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76", size = 43906, upload_time = "2025-07-04T13:28:32.743Z" }, -] - -[[package]] -name = "typing-inspection" -version = "0.4.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload_time = "2025-05-21T18:55:23.885Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload_time = "2025-05-21T18:55:22.152Z" }, -] - -[[package]] -name = "tzdata" -version = "2025.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload_time = "2025-03-23T13:54:43.652Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload_time = "2025-03-23T13:54:41.845Z" }, -] - -[[package]] -name = "tzlocal" -version = "5.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "tzdata", marker = "sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761, upload_time = "2025-03-05T21:17:41.549Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload_time = "2025-03-05T21:17:39.857Z" }, -] - -[[package]] -name = "urllib3" -version = "2.5.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload_time = "2025-06-18T14:07:41.644Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload_time = "2025-06-18T14:07:40.39Z" }, -] - -[[package]] -name = "uvicorn" -version = "0.35.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "click" }, - { name = "h11" }, - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/5e/42/e0e305207bb88c6b8d3061399c6a961ffe5fbb7e2aa63c9234df7259e9cd/uvicorn-0.35.0.tar.gz", hash = "sha256:bc662f087f7cf2ce11a1d7fd70b90c9f98ef2e2831556dd078d131b96cc94a01", size = 78473, upload_time = "2025-06-28T16:15:46.058Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/e2/dc81b1bd1dcfe91735810265e9d26bc8ec5da45b4c0f6237e286819194c3/uvicorn-0.35.0-py3-none-any.whl", hash = "sha256:197535216b25ff9b785e29a0b79199f55222193d47f820816e7da751e9bc8d4a", size = 66406, upload_time = "2025-06-28T16:15:44.816Z" }, -] - -[[package]] -name = "websockets" -version = "15.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload_time = "2025-03-05T20:03:41.606Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1e/da/6462a9f510c0c49837bbc9345aca92d767a56c1fb2939e1579df1e1cdcf7/websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b", size = 175423, upload_time = "2025-03-05T20:01:35.363Z" }, - { url = "https://files.pythonhosted.org/packages/1c/9f/9d11c1a4eb046a9e106483b9ff69bce7ac880443f00e5ce64261b47b07e7/websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205", size = 173080, upload_time = "2025-03-05T20:01:37.304Z" }, - { url = "https://files.pythonhosted.org/packages/d5/4f/b462242432d93ea45f297b6179c7333dd0402b855a912a04e7fc61c0d71f/websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a", size = 173329, upload_time = "2025-03-05T20:01:39.668Z" }, - { url = "https://files.pythonhosted.org/packages/6e/0c/6afa1f4644d7ed50284ac59cc70ef8abd44ccf7d45850d989ea7310538d0/websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e", size = 182312, upload_time = "2025-03-05T20:01:41.815Z" }, - { url = "https://files.pythonhosted.org/packages/dd/d4/ffc8bd1350b229ca7a4db2a3e1c482cf87cea1baccd0ef3e72bc720caeec/websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf", size = 181319, upload_time = "2025-03-05T20:01:43.967Z" }, - { url = "https://files.pythonhosted.org/packages/97/3a/5323a6bb94917af13bbb34009fac01e55c51dfde354f63692bf2533ffbc2/websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb", size = 181631, upload_time = "2025-03-05T20:01:46.104Z" }, - { url = "https://files.pythonhosted.org/packages/a6/cc/1aeb0f7cee59ef065724041bb7ed667b6ab1eeffe5141696cccec2687b66/websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d", size = 182016, upload_time = "2025-03-05T20:01:47.603Z" }, - { url = "https://files.pythonhosted.org/packages/79/f9/c86f8f7af208e4161a7f7e02774e9d0a81c632ae76db2ff22549e1718a51/websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9", size = 181426, upload_time = "2025-03-05T20:01:48.949Z" }, - { url = "https://files.pythonhosted.org/packages/c7/b9/828b0bc6753db905b91df6ae477c0b14a141090df64fb17f8a9d7e3516cf/websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c", size = 181360, upload_time = "2025-03-05T20:01:50.938Z" }, - { url = "https://files.pythonhosted.org/packages/89/fb/250f5533ec468ba6327055b7d98b9df056fb1ce623b8b6aaafb30b55d02e/websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256", size = 176388, upload_time = "2025-03-05T20:01:52.213Z" }, - { url = "https://files.pythonhosted.org/packages/1c/46/aca7082012768bb98e5608f01658ff3ac8437e563eca41cf068bd5849a5e/websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41", size = 176830, upload_time = "2025-03-05T20:01:53.922Z" }, - { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload_time = "2025-03-05T20:01:56.276Z" }, - { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload_time = "2025-03-05T20:01:57.563Z" }, - { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload_time = "2025-03-05T20:01:59.063Z" }, - { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload_time = "2025-03-05T20:02:00.305Z" }, - { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload_time = "2025-03-05T20:02:03.148Z" }, - { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload_time = "2025-03-05T20:02:05.29Z" }, - { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload_time = "2025-03-05T20:02:07.458Z" }, - { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload_time = "2025-03-05T20:02:09.842Z" }, - { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload_time = "2025-03-05T20:02:11.968Z" }, - { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload_time = "2025-03-05T20:02:13.32Z" }, - { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload_time = "2025-03-05T20:02:14.585Z" }, - { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload_time = "2025-03-05T20:02:16.706Z" }, - { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload_time = "2025-03-05T20:02:18.832Z" }, - { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload_time = "2025-03-05T20:02:20.187Z" }, - { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload_time = "2025-03-05T20:02:22.286Z" }, - { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload_time = "2025-03-05T20:02:24.368Z" }, - { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload_time = "2025-03-05T20:02:25.669Z" }, - { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload_time = "2025-03-05T20:02:26.99Z" }, - { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload_time = "2025-03-05T20:02:30.291Z" }, - { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload_time = "2025-03-05T20:02:31.634Z" }, - { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload_time = "2025-03-05T20:02:33.017Z" }, - { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload_time = "2025-03-05T20:02:34.498Z" }, - { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload_time = "2025-03-05T20:02:36.695Z" }, - { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload_time = "2025-03-05T20:02:37.985Z" }, - { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload_time = "2025-03-05T20:02:39.298Z" }, - { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload_time = "2025-03-05T20:02:40.595Z" }, - { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload_time = "2025-03-05T20:02:41.926Z" }, - { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload_time = "2025-03-05T20:02:43.304Z" }, - { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload_time = "2025-03-05T20:02:48.812Z" }, - { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload_time = "2025-03-05T20:02:50.14Z" }, - { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload_time = "2025-03-05T20:02:51.561Z" }, - { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload_time = "2025-03-05T20:02:53.814Z" }, - { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload_time = "2025-03-05T20:02:55.237Z" }, - { url = "https://files.pythonhosted.org/packages/02/9e/d40f779fa16f74d3468357197af8d6ad07e7c5a27ea1ca74ceb38986f77a/websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3", size = 173109, upload_time = "2025-03-05T20:03:17.769Z" }, - { url = "https://files.pythonhosted.org/packages/bc/cd/5b887b8585a593073fd92f7c23ecd3985cd2c3175025a91b0d69b0551372/websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1", size = 173343, upload_time = "2025-03-05T20:03:19.094Z" }, - { url = "https://files.pythonhosted.org/packages/fe/ae/d34f7556890341e900a95acf4886833646306269f899d58ad62f588bf410/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475", size = 174599, upload_time = "2025-03-05T20:03:21.1Z" }, - { url = "https://files.pythonhosted.org/packages/71/e6/5fd43993a87db364ec60fc1d608273a1a465c0caba69176dd160e197ce42/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9", size = 174207, upload_time = "2025-03-05T20:03:23.221Z" }, - { url = "https://files.pythonhosted.org/packages/2b/fb/c492d6daa5ec067c2988ac80c61359ace5c4c674c532985ac5a123436cec/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04", size = 174155, upload_time = "2025-03-05T20:03:25.321Z" }, - { url = "https://files.pythonhosted.org/packages/68/a1/dcb68430b1d00b698ae7a7e0194433bce4f07ded185f0ee5fb21e2a2e91e/websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122", size = 176884, upload_time = "2025-03-05T20:03:27.934Z" }, - { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload_time = "2025-03-05T20:03:39.41Z" }, -] - -[[package]] -name = "yarl" -version = "1.20.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "idna" }, - { name = "multidict" }, - { name = "propcache" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/3c/fb/efaa23fa4e45537b827620f04cf8f3cd658b76642205162e072703a5b963/yarl-1.20.1.tar.gz", hash = "sha256:d017a4997ee50c91fd5466cef416231bb82177b93b029906cefc542ce14c35ac", size = 186428, upload_time = "2025-06-10T00:46:09.923Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cb/65/7fed0d774abf47487c64be14e9223749468922817b5e8792b8a64792a1bb/yarl-1.20.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:6032e6da6abd41e4acda34d75a816012717000fa6839f37124a47fcefc49bec4", size = 132910, upload_time = "2025-06-10T00:42:31.108Z" }, - { url = "https://files.pythonhosted.org/packages/8a/7b/988f55a52da99df9e56dc733b8e4e5a6ae2090081dc2754fc8fd34e60aa0/yarl-1.20.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2c7b34d804b8cf9b214f05015c4fee2ebe7ed05cf581e7192c06555c71f4446a", size = 90644, upload_time = "2025-06-10T00:42:33.851Z" }, - { url = "https://files.pythonhosted.org/packages/f7/de/30d98f03e95d30c7e3cc093759982d038c8833ec2451001d45ef4854edc1/yarl-1.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0c869f2651cc77465f6cd01d938d91a11d9ea5d798738c1dc077f3de0b5e5fed", size = 89322, upload_time = "2025-06-10T00:42:35.688Z" }, - { url = "https://files.pythonhosted.org/packages/e0/7a/f2f314f5ebfe9200724b0b748de2186b927acb334cf964fd312eb86fc286/yarl-1.20.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62915e6688eb4d180d93840cda4110995ad50c459bf931b8b3775b37c264af1e", size = 323786, upload_time = "2025-06-10T00:42:37.817Z" }, - { url = "https://files.pythonhosted.org/packages/15/3f/718d26f189db96d993d14b984ce91de52e76309d0fd1d4296f34039856aa/yarl-1.20.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:41ebd28167bc6af8abb97fec1a399f412eec5fd61a3ccbe2305a18b84fb4ca73", size = 319627, upload_time = "2025-06-10T00:42:39.937Z" }, - { url = "https://files.pythonhosted.org/packages/a5/76/8fcfbf5fa2369157b9898962a4a7d96764b287b085b5b3d9ffae69cdefd1/yarl-1.20.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:21242b4288a6d56f04ea193adde174b7e347ac46ce6bc84989ff7c1b1ecea84e", size = 339149, upload_time = "2025-06-10T00:42:42.627Z" }, - { url = "https://files.pythonhosted.org/packages/3c/95/d7fc301cc4661785967acc04f54a4a42d5124905e27db27bb578aac49b5c/yarl-1.20.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bea21cdae6c7eb02ba02a475f37463abfe0a01f5d7200121b03e605d6a0439f8", size = 333327, upload_time = "2025-06-10T00:42:44.842Z" }, - { url = "https://files.pythonhosted.org/packages/65/94/e21269718349582eee81efc5c1c08ee71c816bfc1585b77d0ec3f58089eb/yarl-1.20.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f8a891e4a22a89f5dde7862994485e19db246b70bb288d3ce73a34422e55b23", size = 326054, upload_time = "2025-06-10T00:42:47.149Z" }, - { url = "https://files.pythonhosted.org/packages/32/ae/8616d1f07853704523519f6131d21f092e567c5af93de7e3e94b38d7f065/yarl-1.20.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dd803820d44c8853a109a34e3660e5a61beae12970da479cf44aa2954019bf70", size = 315035, upload_time = "2025-06-10T00:42:48.852Z" }, - { url = "https://files.pythonhosted.org/packages/48/aa/0ace06280861ef055855333707db5e49c6e3a08840a7ce62682259d0a6c0/yarl-1.20.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b982fa7f74c80d5c0c7b5b38f908971e513380a10fecea528091405f519b9ebb", size = 338962, upload_time = "2025-06-10T00:42:51.024Z" }, - { url = "https://files.pythonhosted.org/packages/20/52/1e9d0e6916f45a8fb50e6844f01cb34692455f1acd548606cbda8134cd1e/yarl-1.20.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:33f29ecfe0330c570d997bcf1afd304377f2e48f61447f37e846a6058a4d33b2", size = 335399, upload_time = "2025-06-10T00:42:53.007Z" }, - { url = "https://files.pythonhosted.org/packages/f2/65/60452df742952c630e82f394cd409de10610481d9043aa14c61bf846b7b1/yarl-1.20.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:835ab2cfc74d5eb4a6a528c57f05688099da41cf4957cf08cad38647e4a83b30", size = 338649, upload_time = "2025-06-10T00:42:54.964Z" }, - { url = "https://files.pythonhosted.org/packages/7b/f5/6cd4ff38dcde57a70f23719a838665ee17079640c77087404c3d34da6727/yarl-1.20.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:46b5e0ccf1943a9a6e766b2c2b8c732c55b34e28be57d8daa2b3c1d1d4009309", size = 358563, upload_time = "2025-06-10T00:42:57.28Z" }, - { url = "https://files.pythonhosted.org/packages/d1/90/c42eefd79d0d8222cb3227bdd51b640c0c1d0aa33fe4cc86c36eccba77d3/yarl-1.20.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:df47c55f7d74127d1b11251fe6397d84afdde0d53b90bedb46a23c0e534f9d24", size = 357609, upload_time = "2025-06-10T00:42:59.055Z" }, - { url = "https://files.pythonhosted.org/packages/03/c8/cea6b232cb4617514232e0f8a718153a95b5d82b5290711b201545825532/yarl-1.20.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:76d12524d05841276b0e22573f28d5fbcb67589836772ae9244d90dd7d66aa13", size = 350224, upload_time = "2025-06-10T00:43:01.248Z" }, - { url = "https://files.pythonhosted.org/packages/ce/a3/eaa0ab9712f1f3d01faf43cf6f1f7210ce4ea4a7e9b28b489a2261ca8db9/yarl-1.20.1-cp310-cp310-win32.whl", hash = "sha256:6c4fbf6b02d70e512d7ade4b1f998f237137f1417ab07ec06358ea04f69134f8", size = 81753, upload_time = "2025-06-10T00:43:03.486Z" }, - { url = "https://files.pythonhosted.org/packages/8f/34/e4abde70a9256465fe31c88ed02c3f8502b7b5dead693a4f350a06413f28/yarl-1.20.1-cp310-cp310-win_amd64.whl", hash = "sha256:aef6c4d69554d44b7f9d923245f8ad9a707d971e6209d51279196d8e8fe1ae16", size = 86817, upload_time = "2025-06-10T00:43:05.231Z" }, - { url = "https://files.pythonhosted.org/packages/b1/18/893b50efc2350e47a874c5c2d67e55a0ea5df91186b2a6f5ac52eff887cd/yarl-1.20.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:47ee6188fea634bdfaeb2cc420f5b3b17332e6225ce88149a17c413c77ff269e", size = 133833, upload_time = "2025-06-10T00:43:07.393Z" }, - { url = "https://files.pythonhosted.org/packages/89/ed/b8773448030e6fc47fa797f099ab9eab151a43a25717f9ac043844ad5ea3/yarl-1.20.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d0f6500f69e8402d513e5eedb77a4e1818691e8f45e6b687147963514d84b44b", size = 91070, upload_time = "2025-06-10T00:43:09.538Z" }, - { url = "https://files.pythonhosted.org/packages/e3/e3/409bd17b1e42619bf69f60e4f031ce1ccb29bd7380117a55529e76933464/yarl-1.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a8900a42fcdaad568de58887c7b2f602962356908eedb7628eaf6021a6e435b", size = 89818, upload_time = "2025-06-10T00:43:11.575Z" }, - { url = "https://files.pythonhosted.org/packages/f8/77/64d8431a4d77c856eb2d82aa3de2ad6741365245a29b3a9543cd598ed8c5/yarl-1.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bad6d131fda8ef508b36be3ece16d0902e80b88ea7200f030a0f6c11d9e508d4", size = 347003, upload_time = "2025-06-10T00:43:14.088Z" }, - { url = "https://files.pythonhosted.org/packages/8d/d2/0c7e4def093dcef0bd9fa22d4d24b023788b0a33b8d0088b51aa51e21e99/yarl-1.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:df018d92fe22aaebb679a7f89fe0c0f368ec497e3dda6cb81a567610f04501f1", size = 336537, upload_time = "2025-06-10T00:43:16.431Z" }, - { url = "https://files.pythonhosted.org/packages/f0/f3/fc514f4b2cf02cb59d10cbfe228691d25929ce8f72a38db07d3febc3f706/yarl-1.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f969afbb0a9b63c18d0feecf0db09d164b7a44a053e78a7d05f5df163e43833", size = 362358, upload_time = "2025-06-10T00:43:18.704Z" }, - { url = "https://files.pythonhosted.org/packages/ea/6d/a313ac8d8391381ff9006ac05f1d4331cee3b1efaa833a53d12253733255/yarl-1.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:812303eb4aa98e302886ccda58d6b099e3576b1b9276161469c25803a8db277d", size = 357362, upload_time = "2025-06-10T00:43:20.888Z" }, - { url = "https://files.pythonhosted.org/packages/00/70/8f78a95d6935a70263d46caa3dd18e1f223cf2f2ff2037baa01a22bc5b22/yarl-1.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98c4a7d166635147924aa0bf9bfe8d8abad6fffa6102de9c99ea04a1376f91e8", size = 348979, upload_time = "2025-06-10T00:43:23.169Z" }, - { url = "https://files.pythonhosted.org/packages/cb/05/42773027968968f4f15143553970ee36ead27038d627f457cc44bbbeecf3/yarl-1.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12e768f966538e81e6e7550f9086a6236b16e26cd964cf4df35349970f3551cf", size = 337274, upload_time = "2025-06-10T00:43:27.111Z" }, - { url = "https://files.pythonhosted.org/packages/05/be/665634aa196954156741ea591d2f946f1b78ceee8bb8f28488bf28c0dd62/yarl-1.20.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fe41919b9d899661c5c28a8b4b0acf704510b88f27f0934ac7a7bebdd8938d5e", size = 363294, upload_time = "2025-06-10T00:43:28.96Z" }, - { url = "https://files.pythonhosted.org/packages/eb/90/73448401d36fa4e210ece5579895731f190d5119c4b66b43b52182e88cd5/yarl-1.20.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8601bc010d1d7780592f3fc1bdc6c72e2b6466ea34569778422943e1a1f3c389", size = 358169, upload_time = "2025-06-10T00:43:30.701Z" }, - { url = "https://files.pythonhosted.org/packages/c3/b0/fce922d46dc1eb43c811f1889f7daa6001b27a4005587e94878570300881/yarl-1.20.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:daadbdc1f2a9033a2399c42646fbd46da7992e868a5fe9513860122d7fe7a73f", size = 362776, upload_time = "2025-06-10T00:43:32.51Z" }, - { url = "https://files.pythonhosted.org/packages/f1/0d/b172628fce039dae8977fd22caeff3eeebffd52e86060413f5673767c427/yarl-1.20.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:03aa1e041727cb438ca762628109ef1333498b122e4c76dd858d186a37cec845", size = 381341, upload_time = "2025-06-10T00:43:34.543Z" }, - { url = "https://files.pythonhosted.org/packages/6b/9b/5b886d7671f4580209e855974fe1cecec409aa4a89ea58b8f0560dc529b1/yarl-1.20.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:642980ef5e0fa1de5fa96d905c7e00cb2c47cb468bfcac5a18c58e27dbf8d8d1", size = 379988, upload_time = "2025-06-10T00:43:36.489Z" }, - { url = "https://files.pythonhosted.org/packages/73/be/75ef5fd0fcd8f083a5d13f78fd3f009528132a1f2a1d7c925c39fa20aa79/yarl-1.20.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:86971e2795584fe8c002356d3b97ef6c61862720eeff03db2a7c86b678d85b3e", size = 371113, upload_time = "2025-06-10T00:43:38.592Z" }, - { url = "https://files.pythonhosted.org/packages/50/4f/62faab3b479dfdcb741fe9e3f0323e2a7d5cd1ab2edc73221d57ad4834b2/yarl-1.20.1-cp311-cp311-win32.whl", hash = "sha256:597f40615b8d25812f14562699e287f0dcc035d25eb74da72cae043bb884d773", size = 81485, upload_time = "2025-06-10T00:43:41.038Z" }, - { url = "https://files.pythonhosted.org/packages/f0/09/d9c7942f8f05c32ec72cd5c8e041c8b29b5807328b68b4801ff2511d4d5e/yarl-1.20.1-cp311-cp311-win_amd64.whl", hash = "sha256:26ef53a9e726e61e9cd1cda6b478f17e350fb5800b4bd1cd9fe81c4d91cfeb2e", size = 86686, upload_time = "2025-06-10T00:43:42.692Z" }, - { url = "https://files.pythonhosted.org/packages/5f/9a/cb7fad7d73c69f296eda6815e4a2c7ed53fc70c2f136479a91c8e5fbdb6d/yarl-1.20.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdcc4cd244e58593a4379fe60fdee5ac0331f8eb70320a24d591a3be197b94a9", size = 133667, upload_time = "2025-06-10T00:43:44.369Z" }, - { url = "https://files.pythonhosted.org/packages/67/38/688577a1cb1e656e3971fb66a3492501c5a5df56d99722e57c98249e5b8a/yarl-1.20.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b29a2c385a5f5b9c7d9347e5812b6f7ab267193c62d282a540b4fc528c8a9d2a", size = 91025, upload_time = "2025-06-10T00:43:46.295Z" }, - { url = "https://files.pythonhosted.org/packages/50/ec/72991ae51febeb11a42813fc259f0d4c8e0507f2b74b5514618d8b640365/yarl-1.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1112ae8154186dfe2de4732197f59c05a83dc814849a5ced892b708033f40dc2", size = 89709, upload_time = "2025-06-10T00:43:48.22Z" }, - { url = "https://files.pythonhosted.org/packages/99/da/4d798025490e89426e9f976702e5f9482005c548c579bdae792a4c37769e/yarl-1.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90bbd29c4fe234233f7fa2b9b121fb63c321830e5d05b45153a2ca68f7d310ee", size = 352287, upload_time = "2025-06-10T00:43:49.924Z" }, - { url = "https://files.pythonhosted.org/packages/1a/26/54a15c6a567aac1c61b18aa0f4b8aa2e285a52d547d1be8bf48abe2b3991/yarl-1.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:680e19c7ce3710ac4cd964e90dad99bf9b5029372ba0c7cbfcd55e54d90ea819", size = 345429, upload_time = "2025-06-10T00:43:51.7Z" }, - { url = "https://files.pythonhosted.org/packages/d6/95/9dcf2386cb875b234353b93ec43e40219e14900e046bf6ac118f94b1e353/yarl-1.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a979218c1fdb4246a05efc2cc23859d47c89af463a90b99b7c56094daf25a16", size = 365429, upload_time = "2025-06-10T00:43:53.494Z" }, - { url = "https://files.pythonhosted.org/packages/91/b2/33a8750f6a4bc224242a635f5f2cff6d6ad5ba651f6edcccf721992c21a0/yarl-1.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255b468adf57b4a7b65d8aad5b5138dce6a0752c139965711bdcb81bc370e1b6", size = 363862, upload_time = "2025-06-10T00:43:55.766Z" }, - { url = "https://files.pythonhosted.org/packages/98/28/3ab7acc5b51f4434b181b0cee8f1f4b77a65919700a355fb3617f9488874/yarl-1.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a97d67108e79cfe22e2b430d80d7571ae57d19f17cda8bb967057ca8a7bf5bfd", size = 355616, upload_time = "2025-06-10T00:43:58.056Z" }, - { url = "https://files.pythonhosted.org/packages/36/a3/f666894aa947a371724ec7cd2e5daa78ee8a777b21509b4252dd7bd15e29/yarl-1.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8570d998db4ddbfb9a590b185a0a33dbf8aafb831d07a5257b4ec9948df9cb0a", size = 339954, upload_time = "2025-06-10T00:43:59.773Z" }, - { url = "https://files.pythonhosted.org/packages/f1/81/5f466427e09773c04219d3450d7a1256138a010b6c9f0af2d48565e9ad13/yarl-1.20.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:97c75596019baae7c71ccf1d8cc4738bc08134060d0adfcbe5642f778d1dca38", size = 365575, upload_time = "2025-06-10T00:44:02.051Z" }, - { url = "https://files.pythonhosted.org/packages/2e/e3/e4b0ad8403e97e6c9972dd587388940a032f030ebec196ab81a3b8e94d31/yarl-1.20.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1c48912653e63aef91ff988c5432832692ac5a1d8f0fb8a33091520b5bbe19ef", size = 365061, upload_time = "2025-06-10T00:44:04.196Z" }, - { url = "https://files.pythonhosted.org/packages/ac/99/b8a142e79eb86c926f9f06452eb13ecb1bb5713bd01dc0038faf5452e544/yarl-1.20.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4c3ae28f3ae1563c50f3d37f064ddb1511ecc1d5584e88c6b7c63cf7702a6d5f", size = 364142, upload_time = "2025-06-10T00:44:06.527Z" }, - { url = "https://files.pythonhosted.org/packages/34/f2/08ed34a4a506d82a1a3e5bab99ccd930a040f9b6449e9fd050320e45845c/yarl-1.20.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c5e9642f27036283550f5f57dc6156c51084b458570b9d0d96100c8bebb186a8", size = 381894, upload_time = "2025-06-10T00:44:08.379Z" }, - { url = "https://files.pythonhosted.org/packages/92/f8/9a3fbf0968eac704f681726eff595dce9b49c8a25cd92bf83df209668285/yarl-1.20.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:2c26b0c49220d5799f7b22c6838409ee9bc58ee5c95361a4d7831f03cc225b5a", size = 383378, upload_time = "2025-06-10T00:44:10.51Z" }, - { url = "https://files.pythonhosted.org/packages/af/85/9363f77bdfa1e4d690957cd39d192c4cacd1c58965df0470a4905253b54f/yarl-1.20.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:564ab3d517e3d01c408c67f2e5247aad4019dcf1969982aba3974b4093279004", size = 374069, upload_time = "2025-06-10T00:44:12.834Z" }, - { url = "https://files.pythonhosted.org/packages/35/99/9918c8739ba271dcd935400cff8b32e3cd319eaf02fcd023d5dcd487a7c8/yarl-1.20.1-cp312-cp312-win32.whl", hash = "sha256:daea0d313868da1cf2fac6b2d3a25c6e3a9e879483244be38c8e6a41f1d876a5", size = 81249, upload_time = "2025-06-10T00:44:14.731Z" }, - { url = "https://files.pythonhosted.org/packages/eb/83/5d9092950565481b413b31a23e75dd3418ff0a277d6e0abf3729d4d1ce25/yarl-1.20.1-cp312-cp312-win_amd64.whl", hash = "sha256:48ea7d7f9be0487339828a4de0360d7ce0efc06524a48e1810f945c45b813698", size = 86710, upload_time = "2025-06-10T00:44:16.716Z" }, - { url = "https://files.pythonhosted.org/packages/8a/e1/2411b6d7f769a07687acee88a062af5833cf1966b7266f3d8dfb3d3dc7d3/yarl-1.20.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0b5ff0fbb7c9f1b1b5ab53330acbfc5247893069e7716840c8e7d5bb7355038a", size = 131811, upload_time = "2025-06-10T00:44:18.933Z" }, - { url = "https://files.pythonhosted.org/packages/b2/27/584394e1cb76fb771371770eccad35de400e7b434ce3142c2dd27392c968/yarl-1.20.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:14f326acd845c2b2e2eb38fb1346c94f7f3b01a4f5c788f8144f9b630bfff9a3", size = 90078, upload_time = "2025-06-10T00:44:20.635Z" }, - { url = "https://files.pythonhosted.org/packages/bf/9a/3246ae92d4049099f52d9b0fe3486e3b500e29b7ea872d0f152966fc209d/yarl-1.20.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f60e4ad5db23f0b96e49c018596707c3ae89f5d0bd97f0ad3684bcbad899f1e7", size = 88748, upload_time = "2025-06-10T00:44:22.34Z" }, - { url = "https://files.pythonhosted.org/packages/a3/25/35afe384e31115a1a801fbcf84012d7a066d89035befae7c5d4284df1e03/yarl-1.20.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:49bdd1b8e00ce57e68ba51916e4bb04461746e794e7c4d4bbc42ba2f18297691", size = 349595, upload_time = "2025-06-10T00:44:24.314Z" }, - { url = "https://files.pythonhosted.org/packages/28/2d/8aca6cb2cabc8f12efcb82749b9cefecbccfc7b0384e56cd71058ccee433/yarl-1.20.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:66252d780b45189975abfed839616e8fd2dbacbdc262105ad7742c6ae58f3e31", size = 342616, upload_time = "2025-06-10T00:44:26.167Z" }, - { url = "https://files.pythonhosted.org/packages/0b/e9/1312633d16b31acf0098d30440ca855e3492d66623dafb8e25b03d00c3da/yarl-1.20.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59174e7332f5d153d8f7452a102b103e2e74035ad085f404df2e40e663a22b28", size = 361324, upload_time = "2025-06-10T00:44:27.915Z" }, - { url = "https://files.pythonhosted.org/packages/bc/a0/688cc99463f12f7669eec7c8acc71ef56a1521b99eab7cd3abb75af887b0/yarl-1.20.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e3968ec7d92a0c0f9ac34d5ecfd03869ec0cab0697c91a45db3fbbd95fe1b653", size = 359676, upload_time = "2025-06-10T00:44:30.041Z" }, - { url = "https://files.pythonhosted.org/packages/af/44/46407d7f7a56e9a85a4c207724c9f2c545c060380718eea9088f222ba697/yarl-1.20.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d1a4fbb50e14396ba3d375f68bfe02215d8e7bc3ec49da8341fe3157f59d2ff5", size = 352614, upload_time = "2025-06-10T00:44:32.171Z" }, - { url = "https://files.pythonhosted.org/packages/b1/91/31163295e82b8d5485d31d9cf7754d973d41915cadce070491778d9c9825/yarl-1.20.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11a62c839c3a8eac2410e951301309426f368388ff2f33799052787035793b02", size = 336766, upload_time = "2025-06-10T00:44:34.494Z" }, - { url = "https://files.pythonhosted.org/packages/b4/8e/c41a5bc482121f51c083c4c2bcd16b9e01e1cf8729e380273a952513a21f/yarl-1.20.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:041eaa14f73ff5a8986b4388ac6bb43a77f2ea09bf1913df7a35d4646db69e53", size = 364615, upload_time = "2025-06-10T00:44:36.856Z" }, - { url = "https://files.pythonhosted.org/packages/e3/5b/61a3b054238d33d70ea06ebba7e58597891b71c699e247df35cc984ab393/yarl-1.20.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:377fae2fef158e8fd9d60b4c8751387b8d1fb121d3d0b8e9b0be07d1b41e83dc", size = 360982, upload_time = "2025-06-10T00:44:39.141Z" }, - { url = "https://files.pythonhosted.org/packages/df/a3/6a72fb83f8d478cb201d14927bc8040af901811a88e0ff2da7842dd0ed19/yarl-1.20.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1c92f4390e407513f619d49319023664643d3339bd5e5a56a3bebe01bc67ec04", size = 369792, upload_time = "2025-06-10T00:44:40.934Z" }, - { url = "https://files.pythonhosted.org/packages/7c/af/4cc3c36dfc7c077f8dedb561eb21f69e1e9f2456b91b593882b0b18c19dc/yarl-1.20.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:d25ddcf954df1754ab0f86bb696af765c5bfaba39b74095f27eececa049ef9a4", size = 382049, upload_time = "2025-06-10T00:44:42.854Z" }, - { url = "https://files.pythonhosted.org/packages/19/3a/e54e2c4752160115183a66dc9ee75a153f81f3ab2ba4bf79c3c53b33de34/yarl-1.20.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:909313577e9619dcff8c31a0ea2aa0a2a828341d92673015456b3ae492e7317b", size = 384774, upload_time = "2025-06-10T00:44:45.275Z" }, - { url = "https://files.pythonhosted.org/packages/9c/20/200ae86dabfca89060ec6447649f219b4cbd94531e425e50d57e5f5ac330/yarl-1.20.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:793fd0580cb9664548c6b83c63b43c477212c0260891ddf86809e1c06c8b08f1", size = 374252, upload_time = "2025-06-10T00:44:47.31Z" }, - { url = "https://files.pythonhosted.org/packages/83/75/11ee332f2f516b3d094e89448da73d557687f7d137d5a0f48c40ff211487/yarl-1.20.1-cp313-cp313-win32.whl", hash = "sha256:468f6e40285de5a5b3c44981ca3a319a4b208ccc07d526b20b12aeedcfa654b7", size = 81198, upload_time = "2025-06-10T00:44:49.164Z" }, - { url = "https://files.pythonhosted.org/packages/ba/ba/39b1ecbf51620b40ab402b0fc817f0ff750f6d92712b44689c2c215be89d/yarl-1.20.1-cp313-cp313-win_amd64.whl", hash = "sha256:495b4ef2fea40596bfc0affe3837411d6aa3371abcf31aac0ccc4bdd64d4ef5c", size = 86346, upload_time = "2025-06-10T00:44:51.182Z" }, - { url = "https://files.pythonhosted.org/packages/43/c7/669c52519dca4c95153c8ad96dd123c79f354a376346b198f438e56ffeb4/yarl-1.20.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f60233b98423aab21d249a30eb27c389c14929f47be8430efa7dbd91493a729d", size = 138826, upload_time = "2025-06-10T00:44:52.883Z" }, - { url = "https://files.pythonhosted.org/packages/6a/42/fc0053719b44f6ad04a75d7f05e0e9674d45ef62f2d9ad2c1163e5c05827/yarl-1.20.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6f3eff4cc3f03d650d8755c6eefc844edde99d641d0dcf4da3ab27141a5f8ddf", size = 93217, upload_time = "2025-06-10T00:44:54.658Z" }, - { url = "https://files.pythonhosted.org/packages/4f/7f/fa59c4c27e2a076bba0d959386e26eba77eb52ea4a0aac48e3515c186b4c/yarl-1.20.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:69ff8439d8ba832d6bed88af2c2b3445977eba9a4588b787b32945871c2444e3", size = 92700, upload_time = "2025-06-10T00:44:56.784Z" }, - { url = "https://files.pythonhosted.org/packages/2f/d4/062b2f48e7c93481e88eff97a6312dca15ea200e959f23e96d8ab898c5b8/yarl-1.20.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cf34efa60eb81dd2645a2e13e00bb98b76c35ab5061a3989c7a70f78c85006d", size = 347644, upload_time = "2025-06-10T00:44:59.071Z" }, - { url = "https://files.pythonhosted.org/packages/89/47/78b7f40d13c8f62b499cc702fdf69e090455518ae544c00a3bf4afc9fc77/yarl-1.20.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8e0fe9364ad0fddab2688ce72cb7a8e61ea42eff3c7caeeb83874a5d479c896c", size = 323452, upload_time = "2025-06-10T00:45:01.605Z" }, - { url = "https://files.pythonhosted.org/packages/eb/2b/490d3b2dc66f52987d4ee0d3090a147ea67732ce6b4d61e362c1846d0d32/yarl-1.20.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f64fbf81878ba914562c672024089e3401974a39767747691c65080a67b18c1", size = 346378, upload_time = "2025-06-10T00:45:03.946Z" }, - { url = "https://files.pythonhosted.org/packages/66/ad/775da9c8a94ce925d1537f939a4f17d782efef1f973039d821cbe4bcc211/yarl-1.20.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6342d643bf9a1de97e512e45e4b9560a043347e779a173250824f8b254bd5ce", size = 353261, upload_time = "2025-06-10T00:45:05.992Z" }, - { url = "https://files.pythonhosted.org/packages/4b/23/0ed0922b47a4f5c6eb9065d5ff1e459747226ddce5c6a4c111e728c9f701/yarl-1.20.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56dac5f452ed25eef0f6e3c6a066c6ab68971d96a9fb441791cad0efba6140d3", size = 335987, upload_time = "2025-06-10T00:45:08.227Z" }, - { url = "https://files.pythonhosted.org/packages/3e/49/bc728a7fe7d0e9336e2b78f0958a2d6b288ba89f25a1762407a222bf53c3/yarl-1.20.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7d7f497126d65e2cad8dc5f97d34c27b19199b6414a40cb36b52f41b79014be", size = 329361, upload_time = "2025-06-10T00:45:10.11Z" }, - { url = "https://files.pythonhosted.org/packages/93/8f/b811b9d1f617c83c907e7082a76e2b92b655400e61730cd61a1f67178393/yarl-1.20.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:67e708dfb8e78d8a19169818eeb5c7a80717562de9051bf2413aca8e3696bf16", size = 346460, upload_time = "2025-06-10T00:45:12.055Z" }, - { url = "https://files.pythonhosted.org/packages/70/fd/af94f04f275f95da2c3b8b5e1d49e3e79f1ed8b6ceb0f1664cbd902773ff/yarl-1.20.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:595c07bc79af2494365cc96ddeb772f76272364ef7c80fb892ef9d0649586513", size = 334486, upload_time = "2025-06-10T00:45:13.995Z" }, - { url = "https://files.pythonhosted.org/packages/84/65/04c62e82704e7dd0a9b3f61dbaa8447f8507655fd16c51da0637b39b2910/yarl-1.20.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7bdd2f80f4a7df852ab9ab49484a4dee8030023aa536df41f2d922fd57bf023f", size = 342219, upload_time = "2025-06-10T00:45:16.479Z" }, - { url = "https://files.pythonhosted.org/packages/91/95/459ca62eb958381b342d94ab9a4b6aec1ddec1f7057c487e926f03c06d30/yarl-1.20.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c03bfebc4ae8d862f853a9757199677ab74ec25424d0ebd68a0027e9c639a390", size = 350693, upload_time = "2025-06-10T00:45:18.399Z" }, - { url = "https://files.pythonhosted.org/packages/a6/00/d393e82dd955ad20617abc546a8f1aee40534d599ff555ea053d0ec9bf03/yarl-1.20.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:344d1103e9c1523f32a5ed704d576172d2cabed3122ea90b1d4e11fe17c66458", size = 355803, upload_time = "2025-06-10T00:45:20.677Z" }, - { url = "https://files.pythonhosted.org/packages/9e/ed/c5fb04869b99b717985e244fd93029c7a8e8febdfcffa06093e32d7d44e7/yarl-1.20.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:88cab98aa4e13e1ade8c141daeedd300a4603b7132819c484841bb7af3edce9e", size = 341709, upload_time = "2025-06-10T00:45:23.221Z" }, - { url = "https://files.pythonhosted.org/packages/24/fd/725b8e73ac2a50e78a4534ac43c6addf5c1c2d65380dd48a9169cc6739a9/yarl-1.20.1-cp313-cp313t-win32.whl", hash = "sha256:b121ff6a7cbd4abc28985b6028235491941b9fe8fe226e6fdc539c977ea1739d", size = 86591, upload_time = "2025-06-10T00:45:25.793Z" }, - { url = "https://files.pythonhosted.org/packages/94/c3/b2e9f38bc3e11191981d57ea08cab2166e74ea770024a646617c9cddd9f6/yarl-1.20.1-cp313-cp313t-win_amd64.whl", hash = "sha256:541d050a355bbbc27e55d906bc91cb6fe42f96c01413dd0f4ed5a5240513874f", size = 93003, upload_time = "2025-06-10T00:45:27.752Z" }, - { url = "https://files.pythonhosted.org/packages/b4/2d/2345fce04cfd4bee161bf1e7d9cdc702e3e16109021035dbb24db654a622/yarl-1.20.1-py3-none-any.whl", hash = "sha256:83b8eb083fe4683c6115795d9fc1cfaf2cbbefb19b3a1cb68f6527460f483a77", size = 46542, upload_time = "2025-06-10T00:46:07.521Z" }, -] diff --git a/view_pkl.py b/view_pkl.py new file mode 100644 index 00000000..0897e174 --- /dev/null +++ b/view_pkl.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +""" +查看 .pkl 文件内容的工具脚本 +""" + +import pickle +import sys +import os +from pprint import pprint + +def view_pkl_file(file_path): + """查看 pkl 文件内容""" + if not os.path.exists(file_path): + print(f"❌ 文件不存在: {file_path}") + return + + try: + with open(file_path, 'rb') as f: + data = pickle.load(f) + + print(f"📁 文件: {file_path}") + print(f"📊 数据类型: {type(data)}") + print("=" * 50) + + if isinstance(data, dict): + print("🔑 字典键:") + for key in data.keys(): + print(f" - {key}: {type(data[key])}") + print() + + print("📋 详细内容:") + pprint(data, width=120, depth=10) + + elif isinstance(data, list): + print(f"📝 列表长度: {len(data)}") + if data: + print(f"📊 第一个元素类型: {type(data[0])}") + print("📋 前几个元素:") + for i, item in enumerate(data[:3]): + print(f" [{i}]: {item}") + + else: + print("📋 内容:") + pprint(data, width=120, depth=10) + + # 如果是 expressor 模型，特别显示 token_counts 的详细信息 + if isinstance(data, dict) and 'nb' in data and 'token_counts' in data['nb']: + print("\n" + "="*50) + print("🔍 详细词汇统计 (token_counts):") + token_counts = data['nb']['token_counts'] + for style_id, tokens in token_counts.items(): + print(f"\n📝 {style_id}:") + if tokens: + # 按词频排序显示前10个词 + sorted_tokens = sorted(tokens.items(), key=lambda x: x[1], reverse=True) + for word, count in sorted_tokens[:10]: + print(f" '{word}': {count}") + if len(sorted_tokens) > 10: + print(f" ... 还有 {len(sorted_tokens) - 10} 个词") + else: + print(" (无词汇数据)") + + except Exception as e: + print(f"❌ 读取文件失败: {e}") + +def main(): + if len(sys.argv) != 2: + print("用法: python view_pkl.py ") + print("示例: python view_pkl.py data/test_style_models/chat_001_style_model.pkl") + return + + file_path = sys.argv[1] + view_pkl_file(file_path) + +if __name__ == "__main__": + main() diff --git a/view_tokens.py b/view_tokens.py new file mode 100644 index 00000000..03fe8992 --- /dev/null +++ b/view_tokens.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +""" +专门查看 expressor.pkl 文件中 token_counts 的脚本 +""" + +import pickle +import sys +import os + +def view_token_counts(file_path): + """查看 expressor.pkl 文件中的词汇统计""" + if not os.path.exists(file_path): + print(f"❌ 文件不存在: {file_path}") + return + + try: + with open(file_path, 'rb') as f: + data = pickle.load(f) + + print(f"📁 文件: {file_path}") + print("=" * 60) + + if 'nb' not in data or 'token_counts' not in data['nb']: + print("❌ 这不是一个 expressor 模型文件") + return + + token_counts = data['nb']['token_counts'] + candidates = data.get('candidates', {}) + + print(f"🎯 找到 {len(token_counts)} 个风格") + print("=" * 60) + + for style_id, tokens in token_counts.items(): + style_text = candidates.get(style_id, "未知风格") + print(f"\n📝 {style_id}: {style_text}") + print(f"📊 词汇数量: {len(tokens)}") + + if tokens: + # 按词频排序 + sorted_tokens = sorted(tokens.items(), key=lambda x: x[1], reverse=True) + + print("🔤 词汇统计 (按频率排序):") + for i, (word, count) in enumerate(sorted_tokens): + print(f" {i+1:2d}. '{word}': {count}") + else: + print(" (无词汇数据)") + + print("-" * 40) + + except Exception as e: + print(f"❌ 读取文件失败: {e}") + +def main(): + if len(sys.argv) != 2: + print("用法: python view_tokens.py ") + print("示例: python view_tokens.py data/test_style_models/chat_001_expressor.pkl") + return + + file_path = sys.argv[1] + view_token_counts(file_path) + +if __name__ == "__main__": + main()